Avoid distribution of conditional types over union types

[aloifolia]

Search Terms

Suggestion

I would like to disable the distribution of union types over conditional types in certain cases. If this is already possible (not sure about that) it should be documented in a better way.

Use Cases

Suppose you would like to infer type parameters like so:

type Route = {
    Path: string;
    Params: { [key: string]: string }
}

type RouteWithParams<T extends string> = {
    Path: string;
    Params: { [key in T]: string }
}

type RouteWithParamsMaker<T extends Route> = (keyof T['Params']) extends infer U
    ? U extends string
        ? RouteWithParams<U>
        : never
    : never;

function toRouteWithParams<T extends Route>(r: T): RouteWithParamsMaker<typeof r> {
    return (r as unknown) as RouteWithParamsMaker<typeof r>;
}

const route = {
    Path: 'somewhere',
    Params: { id: 0, name: 1 },
}

const routeWithParams = toRoute(route);

The resulting variable is currently inferred to have the type

RouteWithParams<"id"> | RouteWithParams<"name">

Instead, I would like to receive the following type

RouteWithParams<"id" | "name">

I have no idea whether the current behaviour is intentional (and we would need a new annotation for such cases) or a bug.

Checklist

My suggestion meets these guidelines (not sure about the first and the last one):

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• [x ] This wouldn't change the runtime behavior of existing JavaScript code
• [x ] This could be implemented without emitting different JS based on the types of the expressions
• [x ] This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

[aloifolia]

So.... I just found out that I actually can circumvent the distribution if I change RouteWithParamsMaker:

type RouteWithParamsMaker <T extends Route> = (keyof T['Params']) extends infer U
    ? RouteWithParams<Extract<U, string>>
    : never;

This came a bit as a surprise - my initial feeling was that it should behave equally. So I guess one way to avoid the distribution is to extract conditionals in a clever way to new types. I would really like to have better guidance as a programmer here.

[jack-williams]

To avoid distribution: wrap any naked type parameters in a 1-tuple, and do the same for the check type.

type RouteWithParamsMaker<T extends Route> = (keyof T['Params']) extends infer U
    ? [U] extends [string]
        ? RouteWithParams<U>
        : never
    : never;

I don't believe this is in the TypeScript handbook, but it probably should be.

Tag for searching purpose: distributive conditional type trouble

[ClickerMonkey]

If you don't have a type to test against, [T] extends [T] will have the same effect.

This may be useful for others.

type NoDistribute<T> = [T] extends [T] ? T : never;

However, if T was used in a previous conditional type it may have already been distributed. If you have a deeply nested type you can use the single-element-tuple trick at each level around types you don't want distributed.

[yss14]

How to handle any type with single tuple type solution?

type NotUndefinedAndNotVoid<T> = [T] extends [undefined]
  ? never
  : [T] extends [void]
  ? never
  : T | Promise<T>

type A = NotUndefinedAndNotVoid<any> // A is never since "[any] extends [undefined]" evaluates to true

type NotUndefinedAndNotVoidDistributed<T> = T extends undefined
  ? never
  : T extends void
  ? never
  : T | Promise<T>

type B = NotUndefinedAndNotVoidDistributed<any> // B is any because "any extends undefined" evaluates to false