When possible, remove fully-excluded constituents of a union-constrained type parameter from the false arm of a conditional type

[alesmenzel]

Bug Report

🔎 Search Terms

narrow type, mapped type, union

🕗 Version & Regression Information

Tested on latest version 4.6.2

⏯ Playground Link

Playground link with relevant code

💻 Code

import { ComponentType } from "react"

export type ElementConstraint = keyof JSX.IntrinsicElements | ComponentType<any>

export type ElementProps<Element extends ElementConstraint> =
	Element extends ComponentType<infer P>
	? P : JSX.IntrinsicElements[Element]
//                ^?
// WRONG: Here JSX.IntrinsicElements[Element] complains that Element cannot be used to index JSX.IntrinsicElements eventhoug we know it must be keyof JSX.IntrinsicElements...

🙁 Actual behavior

TS doesn't narrow the type and thus throws an error.

🙂 Expected behavior

When generic is constrained by a union type (e.g. A | B) then the conditional type should narrow the type when checking against one of those types from the union. T extends A ? <here we know it must be A type> : <here we know it must be B type>

[RyanCavanaugh]

Simpler:

type IsB<T extends "B"> = unknown;
type F<T extends "A" | "B"> = T extends "A" ? unknown : IsB<T>;

In the general case, it's not sound to narrow the false arm of a conditional type. When the check type fully subsumes one of the constraint's union constituents we could, but that logic just isn't present right now. Regardless, the workaround is straightforward.

[alesmenzel]

Thanks for the suggestion, but the simpler version has 2 issues

• T is not used in the first statement
• IsB<T> shows a squiggly, because TS doesn't narrow the generic T to type "B" so it complains that you cannot use T in isB<T> because the T must be of type "B", which it is, but TS doesn't know it yet. (playground)

[Elias-Graf]

Since this is tagged as "awaiting more feedback", I'll quickly leave some (what I believe are simpler, - or at least easier to understand) examples here, from my issue, which was marked as duplicate.

Adding "special cases" to a ObjVal type (generic over Key):

interface Obj {
  foo1: number;
  foo2?: number;
  bar1: string;
  bar2?: string;
}

type SpecialCase = { id: number };
type ObjKey = keyof Obj | "specialCase";

// Trying to handle the "special case" key:
type ObjVal<Key extends ObjKey> = Key extends "specialCase" ? SpecialCase : Obj[Key];
  // Does not work... Error: Type 'Key' cannot be used to index type 'Obj'.(2536)

Playground

Trying to extract the value type, of a particular key, that is only present in one part of the union:

type A = {x: string;};
type B = {y: string;};
type Both = A | B;
// Type '"y"' cannot be used to index type 'T'.(2536)
type X1<T extends Both> = T extends A ? T["x"] : T["y"];
// Type '"x"' cannot be used to index type 'T'.(2536)
type X2<T extends Both> = T extends B ? T["y"] : T["x"];

Playground

---

I would like it if TypeScript, where it is "sound", at least tried to evaluate the false branch of the conditional type. I don't think what I'm trying to do here is that unreasonable :).

[RyanCavanaugh]

Just documenting the workarounds since I'm confirming they exist anyway:

type ObjVal<Key extends ObjKey> = Key extends "specialCase" ? SpecialCase : Obj[Exclude<Key, "specialCase">];

// Make them different so we can check them
type A = {x: "is x";};
type B = {y: "is y";};
type Both = A | B;
type X1<T extends Both> = T extends { x: infer U } | { y: infer U } ? U : never;

// Tests, all ok
type T1 = X1<A>;
type T2 = X1<B>;
type T3 = X1<A | B>;

[RyanCavanaugh]

type X1<T extends Both> = T extends Partial<Record<"x" | "y", infer U>> ? U : never;

is also possible but probably worse

[Elias-Graf]

type ObjVal<Key extends ObjKey> = Key extends "specialCase" ? SpecialCase : Obj[Exclude<Key, "specialCase">];

I actually did that, but it became tedious quickly, after needing to add multiple special cases. Especially since the key name has to be typed out twice, but that's nitpicking.

Anyhow, I'm not sure if it has been mentioned before, but I find this a bit nicer:

interface Obj { foo1: number; foo2?: number; bar1: string; bar2?: string; }
type SpecialCase1 = { id_1: number };
type SpecialCase2 = { id_2: number };
type ObjKey = keyof Obj | "specialCase1" | "specialCase2";

type ObjVal<Key extends ObjKey> = Key extends keyof Obj
  ? Obj[Key]
  : Key extends "specialCase1"
  ? SpecialCase1
  : Key extends "specialCase2"
  ? SpecialCase2
  : never;