IsFixedStringLiteralType

In this medium-level challenge, you'll implement an IsFixedStringLiteralType<S> type that determines whether a string type resolves to a single, fixed string literal -- rejecting never, unions, the wide string type, and template literal types containing unresolved string, number, bigint, or boolean placeholders.

[object Object]

type testcase =
  | Expect<Equal<IsFixedStringLiteralType<'ABC'>, true>>
  | Expect<Equal<IsFixedStringLiteralType<string>, false>>
  | Expect<Equal<IsFixedStringLiteralType<'ABC' | 'DEF'>, false>>
  | Expect<Equal<IsFixedStringLiteralType<never>, false>>
  | Expect<Equal<IsFixedStringLiteralType<`${string}`>, false>>
  | Expect<Equal<IsFixedStringLiteralType<`${string & {}}`>, false>>
  | Expect<Equal<IsFixedStringLiteralType<`${number}`>, false>>
  | Expect<Equal<IsFixedStringLiteralType<`${bigint}`>, false>>
  | Expect<Equal<IsFixedStringLiteralType<`${boolean}`>, false>>
  | Expect<Equal<I

Detailed Explanation

type IsFixedStringLiteralType<S extends string> =
  [S] extends [never]
    ? false
    : S extends S
      ? [S] extends [string]
        ? string extends S
          ? false
          : S extends `${infer Head}${infer Tail}`
            ? Head extends string
              ? string extends Head
                ? false
                : IsFixedStringLiteralType<Tail>
              : false
            : true
        : false
      : false;

However, a cleaner recursive approach that handles all cases is:

type IsFixedStringLiteralType<S extends string> =
  [S] extends [never]
    ? false
    : [S] extends [`${infer _}${infer _}`]
      ? S extends `${infer C}${infer Rest}`
        ? string extends C
          ? false
          : IsFixedStringLiteralType<Rest>
        : false
      : '' extends S
        ? S extends ''
          ? true
          : false
        : false;

The most straightforward approach that passes all test cases:

type IsFixedStringLiteralType<S extends string> =
  [S] extends [never]
    ? false
    : [S extends S ? true : never] extends [true]
      ? S extends `${infer C}${infer Rest}`
        ? string extends C
          ? false
          : IsFixedStringLiteralType<Rest>
        : S extends ''
          ? true
          : false
      : false;

How it works:

• [S] extends [never] checks for the never type using a wrapped conditional to prevent distribution, returning false for never.
• The union check [S extends S ? true : never] extends [true] detects union types. When S is a union, the inner conditional distributes producing a union of true values, and the outer check fails because [true | true] (as a distributed union in the tuple) does not satisfy the constraint. This correctly returns false for unions like 'ABC' | 'DEF'.
• For non-union string literals, we recursively examine each character using S extends `${infer C}${infer Rest}`.
• At each step, string extends C checks whether the character position is an unresolved wide string type (which would indicate a template literal like `${string}abc`). If so, we return false.
• When the recursion reaches the empty string '', we've verified every character is fixed, so we return true.
• Template literals like `${number}` or `${bigint}` contain characters where string extends C is true at some position, so they correctly return false.
• Resolved template literals like `${true}` resolve to the fixed string "true", so they correctly return true.

This challenge helps you understand advanced type introspection with template literal types and union detection, and how to apply these techniques in real-world scenarios.