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.

type Action<ID extends string> = { readonly id: ID };

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 wherestring extends Cis true at some position, so they correctly returnfalse`.
• 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.