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

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>

[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 😃.

[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)