`SwitchOnExtends` instead of nested-ternary

[salisbury-espinosa]

Type description + examples

Nested ternary condition inside Typescript type looks awkward and unreadable
there is even a eslint rule
https://eslint.org/docs/latest/rules/no-nested-ternary

maybe it makes sense to do it SwitchOnExtends with more declarative form:

type KindOf<T> = T extends string
  ? 'string'
  : T extends number
    ? 'number'
    : T extends boolean
      ? 'boolean'
      : T extends any[]
        ? 'array'
        : never;

for example converting =>

type KindOf<T> = SwitchOnExtends<
	[string, 'string'],
	[number, 'boolean'],
	[boolean, 'string'],
	[any[], 'array'],
	never
>

or something like that

Type source

No response

Search existing types and issues first

• I tried my best to look for it

[som-sm]

The suggested API for this type is not possible because type arguments cannot be variadic.

[salisbury-espinosa]

The suggested API for this type is not possible because type arguments cannot be variadic.

@som-sm

API (SwitchOn)

type Case = [any, any];

type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y
  ? 1
  : 2
  ? true
  : false;

type Compare<
  Value,
  Condition,
  Mode extends 'extends' | 'strict',
> = Mode extends 'strict'
  ? Equal<Value, Condition>
  : Value extends Condition
    ? true
    : false;

type SwitchResolver<
  Value,
  Cases extends Array<Case>,
  Default,
  Mode extends 'extends' | 'strict',
> = Cases extends [infer First, ...infer Rest]
  ? First extends [infer Condition, infer Result]
    ? Compare<Value, Condition, Mode> extends true
      ? Result
      : Rest extends Array<Case>
        ? SwitchResolver<Value, Rest, Default, Mode>
        : Default
    : Default
  : Default;

/**
 * SwitchOn: A powerful utility to replace nested ternaries.
 * @param Value - The input type to check.
 * @param Cases - An array of [Condition, Result] tuples.
 * @param Default - Result if no conditions match.
 * @param Mode - 'extends' (default) or 'strict' (exact match).
 * @param Distribute - boolean (default false). If true, maps over unions.
 */
type SwitchOn<
  Value,
  Cases extends Array<Case>,
  Default = never,
  Mode extends 'extends' | 'strict' = 'extends',
  Distribute extends boolean = false,
> = Distribute extends true
  ? Value extends any
    ? SwitchResolver<Value, Cases, Default, Mode>
    : never
  : SwitchResolver<Value, Cases, Default, Mode>;

Usage

// --- Case 0
type MyResult<T> = SwitchOn<
  T,
  [
    [string, "It's a string!"],
    [number, "It's a number!"],
    [boolean, "It's a boolean!"],
  ],
  'Unknown Type'
>;
type Test1 = MyResult<42>; // "It's a number!"
type Test2 = MyResult<true>; // "It's a boolean!"
type Test3 = MyResult<object>; // "Unknown Type"

// --- Case 1: Standard 'extends' (Default) ---
type ExtendsResult = SwitchOn<
  'hello',
  [
    [string, "It's a string"], // Matches because "hello" extends string
  ],
  'No match'
>;
// Result: "It's a string"

// --- Case 2: 'strict' mode ---
type StrictResult = SwitchOn<
  string,
  [['hello', 'Specific'], [string, 'Exact String Type']],
  'No match',
  'strict'
>;

// --- Case 3: 'distribution' mode ---

type Result = SwitchOn<
  number | string,
  [[string, 'STR'], [number, 'NUM']],
  'OTHER',
  'extends',
  true // Distribute: ON
>;

// Result is: "STR" | "NUM"

Unit tests

import { expectType,expectError } from 'tsd';
// --- Tests for 'extends' mode (Default) ---

// 1. Should match a literal to its base type
expectType<'hit'>({} as SwitchOn<'hello', [[string, 'hit']], 'miss'>);

// 2. Should follow order of operations (first match wins)
expectType<'first'>(
  {} as SwitchOn<'apple', [[string, 'first'], ['apple', 'second']]>,
);

// 3. Should return default if no match
expectType<'fallback'>({} as SwitchOn<number, [[string, 'no']], 'fallback'>);

// --- Tests for 'strict' mode ---

// 4. Should NOT match 'string' to '"hello"' in strict mode
expectType<'miss'>(
  {} as SwitchOn<string, [['hello', 'hit']], 'miss', 'strict'>,
);

// 5. Should match 'string' to 'string' exactly in strict mode
expectType<'hit'>({} as SwitchOn<string, [[string, 'hit']], 'miss', 'strict'>);

// 6. 'any' protection: 'any' should only match 'any' in strict mode
expectType<'is-any'>(
  {} as SwitchOn<any, [[number, 'no'], [any, 'is-any']], 'miss', 'strict'>,
);

// --- Complex Types ---

interface User {
  id: number;
  name: string;
}
interface Admin extends User {
  role: 'admin';
}

// 7. Should handle interface extension in default mode
expectType<'is-user'>({} as SwitchOn<Admin, [[User, 'is-user']], 'no'>);

// 8. Should fail interface extension in strict mode
expectType<'no'>({} as SwitchOn<Admin, [[User, 'is-user']], 'no', 'strict'>);

// 9. Distribution: Should map each member of the union
expectType<'is-number' | 'is-string'>(
  {} as SwitchOn<
    number | string,
    [[string, 'is-string'], [number, 'is-number']],
    'no',
    'extends',
    true
  >,
);

// 10. No Distribution (Default): Should fall to default for unions
expectType<'no'>(
  {} as SwitchOn<
    number | string,
    [[string, 'is-string'], [number, 'is-number']],
    'no',
    'extends',
    false
  >,
);

// 11. Strict + Distributive: Perfect for exact union mapping
type Literals = 'a' | 'b' | 'c';
expectType<'other' | 1 | 2>(
  {} as SwitchOn<Literals, [['a', 1], ['b', 2]], 'other', 'strict', true>,
);


// 12. Should error if a case is not a tuple
expectError(
  {} as SwitchOn<
    string,
    // @ts-expect-error
    [
      [string, 'valid'],
      'invalid', // Should trigger a compiler error
    ]
  >,
);

// 13. Should error if a case is an empty array
// @ts-expect-error
expectError({} as SwitchOn<string, [[]]>);

// 14. Should error if Mode is a typo
// @ts-expect-error
expectError({} as SwitchOn<string, [[string, 1]], never, 'stricttttt'>);

[salisbury-espinosa]

a little off-topic:

Perhaps for such types from type-fest it is necessary to create a tooling for automatic code refactoring on https://github.com/facebook/jscodeshift or https://github.com/dsherret/ts-morph

for example:

This script will identify "chains" where the Check Type (the variable being tested) remains the same. If the check type changes mid-stream, it stops flattening to avoid breaking logic.

npm install jscodeshift
npx jscodeshift -t migrate-to-switch-on.js ./src/**/*.ts --parser=ts

=>

T extends A ? 1 : T extends B ? 2 : 3 → Migrated.
T extends A ? 1 : U extends B ? 2 : 3 → Ignored (Safe, as SwitchOn only takes one input).

export default function transformer(file, api) {
  const j = api.jscodeshift;
  const root = j(file.source);

  /**
   * Recursively extracts [Condition, Result] pairs from nested ternaries
   * provided the "checkType" (e.g., the 'T' in 'T extends ...') remains the same.
   */
  const getCases = (node, originalCheckType) => {
    // If it's not a ternary, or it's testing a different variable, it's our "Default" case
    if (
      node.type !== 'TSConditionalType' || 
      j(node.checkType).toSource() !== originalCheckType
    ) {
      return { cases: [], defaultValue: node };
    }

    const currentCase = j.tsTupleType([node.extendsType, node.trueType]);
    const next = getCases(node.falseType, originalCheckType);

    return {
      cases: [currentCase, ...next.cases],
      defaultValue: next.defaultValue,
    };
  };

  // Find all Type Alias Declarations (e.g., type X = ...)
  root.find(j.TSTypeAliasDeclaration).forEach((path) => {
    const { typeAnnotation } = path.value;

    if (typeAnnotation.type === 'TSConditionalType') {
      const checkTypeSource = j(typeAnnotation.checkType).toSource();
      const { cases, defaultValue } = getCases(typeAnnotation, checkTypeSource);

      // Only migrate if we actually have a "nested" structure (more than 1 case)
      if (cases.length > 1) {
        path.value.typeAnnotation = j.tsTypeReference(
          j.identifier('SwitchOn'),
          j.tsTypeParameterInstantiation([
            typeAnnotation.checkType,       // Value
            j.tsTupleType(cases),           // Cases [[Cond, Res], [Cond, Res]]
            defaultValue                    // Default
          ])
        );
      }
    }
  });

  return root.toSource();
}

[som-sm]

type MyResult<T> = SwitchOn<
  T,
  [
    [string, "It's a string!"],
    [number, "It's a number!"],
    [boolean, "It's a boolean!"],
  ],
  'Unknown Type'
>;

Umm...I don't think this is better than writing the conditional explicitly, like:

type MyResult<T> = T extends string
	? "It's a string!"
	: T extends number
		? "It's a number!"
		: T extends boolean
			? "It's a boolean!"
			: 'Unknown Type';

This reads much better IMO!

@sindresorhus Thoughts?

[sindresorhus]

@som-sm I agree. I don't think this is a good fit for type-fest.