Convert `PascalCase` to `strictCamelCase` in TypeScript type

Using the builtin Uncapitalize<S>, you can naively transform a string such as FooBar to fooBar:

const fooBar: Uncapitalize<'FooBar'> = 'fooBar';

However, this method falls short when you use class names following the HTML5 convention, such as XMLHttpRequest:

const xmlHttpRequest: Uncapitalize<'XMLHttpRequest'> = 'xMLHttpRequest';

Specifically, I'm looking for a type that can:

  1. Transform instances of PascalCase that contains mutliple conjoined UPPER_CASE letters that form an acronym, into a strictCamelCase string type that lowercases the acronyms,
  2. Without multiple capital letter humps.

For example:

  • XMLHttpRequest -> xmlHttpRequest
  • HTMLAnchorElement -> htmlAnchorElement
  • FOOBaAAr -> foobaaAr

Since I'll be using this to validate code, not transform user input, I don't really care if it's ugly like that last example, because that becomes the consuming developer's problem to fix their naming (:

I know I can use the new template literal types in TypeScript, specifically, using their inference features. However, their examples only show one-sided inference, like ${infer Foo}bar, & using multiple inference types make seem to make the last one greedy, like ${infer FirstChar}${infer Rest}bar.


  • You can use recursion on the type level to get around the greediness problem.

    type StrictCase<S extends string> =
      S extends `${
        infer P1 extends Uppercase<string>
        infer P2 extends Uppercase<string>
        infer P3
        ? `${Lowercase<P1>}${StrictCase<`${P2}${P3}`>}`
        : S extends `${infer P1}${infer P2}`
        ? P2 extends ''
          ? Lowercase<P1>
          : `${P1}${StrictCase<P2>}`
        : S;
    type StrictPascalCase<S extends string> = Capitalize<StrictCase<S>>
    type StrictCamelCase<S extends string> = Uncapitalize<StrictCase<S>>;

    In the StrictCase<S> type:

    1. If there is two conjoined uppercase letters -> FOOBar
      1. This is the set of uppercase letters that were problematic in the question
        Transform the first char into lowercase, then pass the rest back into StrictCase<S>. -> fStrictCamelCaseImpl<'OOBar'>
    2. Else if there is only one letter left -> r
      1. Lowercase & return it. -> r
    3. Else if there are at least two letters -> Bar
      1. These can be any combination of cases
        Return the first char as is, then pass the rest back into StrictCase<S>. -> BStrictCamelCaseImpl<'ar'>
    4. Else -> ar
      1. Return as is -> ar

    Then, after that is done, to normalise into either camelCase or PascalCase, it's just a matter of Capitalize<S> or Uncapitalize<S>, which transforms the first letter either into UPPER_CASE or lowercase.