GeezerVison

declare type Capitalize<T extends string>;

type intrinsic = string;
let a1: intrinsic = "ok";

type Uncapitalize<S extends string> = `${uncapitalize S}`;
type Capitalize<S extends string> = `${capitalize S}`;
type Lowercase<S extends string> = `${lowercase S}`;
type Uppercase<S extends string> = `${uppercase S}`;

type B = 'hi_mate';
type Camelize<S extends string> = S extends `${infer A}_${infer B}`
  ? `${A}${Capitalize<B>}`
  : unknown;

type C = Camelize<B>;

type Z = 'hi_mate_what_up_good_morning_today';

type Camelize<
  S
> = S extends `${infer A}_${infer B}_${infer C}_${infer D}_${infer E}_${infer F}_${infer G}_${infer H}`
  ? `${A}${Capitalize<B>}${Capitalize<C>}${Capitalize<D>}${Capitalize<E>}${Capitalize<F>}${Capitalize<G>}${Capitalize<H>}`
  : S extends `${infer A}_${infer B}_${infer C}_${infer D}_${infer E}_${infer F}_${infer G}`
  ? `${A}${Capitalize<B>}${Capitalize<C>}${Capitalize<D>}${Capitalize<E>}${Capitalize<F>}${Capitalize<G>}`
  : S extends `${infer A}_${infer B}_${infer C}_${infer D}_${infer E}_${infer F}`
  ? `${A}${Capitalize<B>}${Capitalize<C>}${Capitalize<D>}${Capitalize<E>}${Capitalize<F>}`
  : S extends `${infer A}_${infer B}_${infer C}_${infer D}_${infer E}`
  ? `${A}${Capitalize<B>}${Capitalize<C>}${Capitalize<D>}${Capitalize<E>}`
  : S extends `${infer A}_${infer B}_${infer C}_${infer D}`
  ? `${A}${Capitalize<B>}${Capitalize<C>}${Capitalize<D>}`
  : S extends `${infer A}_${infer B}_${infer C}`
  ? `${A}${Capitalize<B>}${Capitalize<C>}`
  : S extends `${infer A}_${infer B}`
  ? `${A}${Capitalize<B>}`
  : S;

type C = Camelize<Z>; // hiMateWhatUpGoodMorningToday

function upperFirst<S extends string>(s: S) {
  const [head, ...tail] = s;
  return [head.toUpperCase(), ...tail].join('') as Capitalize<S>;
}

const z = upperFirst('hello');

function camelCase<S extends string>(s: S) {
  const [head, ...tail] = s.split('_');
  return `${head}${tail.map(upperFirst).join('')}` as Camelize<S>;
}

const y = camelCase('hello_mate');

type DeepCamelize<T> = {
  [K in keyof T as Camelize<K>]: DeepCamelize<T[K]>;
};

type CapitalizeIf<
  Condition extends boolean,
  T extends string
> = Condition extends true ? Capitalize<T> : T;

type SplitCamel<
  S extends string,
  D extends string,
  IsTail extends boolean = false
> = string extends S
  ? string[]
  : S extends ''
  ? []
  : S extends `${infer T}${D}${infer U}`
  ? [CapitalizeIf<IsTail, T>, ...SplitCamel<U, D, true>]
  : [CapitalizeIf<IsTail, S>];

type Camelize<S> = S extends string ? Join<SplitCamel<S, '_'>, ''> : S;


type DeepCamelize<T> = {
  [K in keyof T as Camelize<K>]: DeepCamelize<T[K]>;
};

type SnakeToCamelCase<S extends string> =
    S extends `${infer T}_${infer U}` ? `${lowercase T}${SnakeToPascalCase<U>}` :
    S extends `${infer T}` ? `${lowercase T}` :
    SnakeToPascalCase<S>;

type SnakeToPascalCase<S extends string> =
    string extends S ? string :
    S extends `${infer T}_${infer U}` ? `${capitalize `${lowercase T}`}${SnakeToPascalCase<U>}` :
    S extends `${infer T}` ? `${capitalize `${lowercase T}`}` :
    never;

type RR0 = SnakeToPascalCase<'hello_world_foo'>;  // 'HelloWorldFoo'
type RR1 = SnakeToPascalCase<'FOO_BAR_BAZ'>;  // 'FooBarBaz'
type RR2 = SnakeToCamelCase<'hello_world_foo'>;  // 'helloWorldFoo'
type RR3 = SnakeToCamelCase<'FOO_BAR_BAZ'>;  // 'fooBarBaz'

type ToCamelCase<T> =
    T extends `${infer A}_${infer B}`
        ? `${Uncapitalize<A>}${Capitalize<ToCamelCase<B>>}` :
    T extends string
        ? Uncapitalize<T> :
    T extends (infer A)[]
        ? ToCamelCase<A>[] :
    T extends {}
        ?  { [K in keyof T as ToCamelCase<K>]: ToCamelCase<T[K]>; } :
    T;

type ToSnakeCase<T> =
    T extends `${infer A}${infer B}${infer C}`
        ? (
           [A, B, C] extends [Lowercase<A>, Exclude<Uppercase<B>, '_'>, C]
                ? `${A}_${Lowercase<B>}${ToSnakeCase<C>}`
                : `${Lowercase<A>}${ToSnakeCase<`${B}${C}`>}`
        ) :
    T extends string
        ? Lowercase<T> :
    T extends (infer A)[]
        ? ToSnakeCase<A>[] :
    T extends {}
        ?  { [K in keyof T as ToSnakeCase<K>]: ToSnakeCase<T[K]>; } :
    T;