toExtense.ts

Tring to implement to extense function in typelevel

type Numeros = ['zero', 'um', 'dois', 'tres', 'quatro', 'cinco', 'seis', 'sete', 'oito', 'nove'];
type Dezenas = ['','','vinte', 'trinta', 'quarenta', 'cinquenta', 'sessenta', 'setenta', 'oitenta', 'noventa'];
type Cem = ['cem'];
type Centenas = ['cento', 'duzentos', 'trezentos', 'quatrocentos', 'quinhentos', 'seiscentos', 'setecentos', 'oitocentos', 'novecentos'];

type GetWords<Str extends string, Curr  extends string = ''> =
  Str extends `${infer L}${infer R}`
    ? L extends ' '
      ? Curr
      : GetWords<R, `${Curr}${L}`>
    : Curr;

type GreaterThan<T extends number,
  U extends number,
  C extends unknown[] = []> =
  T extends U
    ? false
    : C['length'] extends T
      ? false
      : C['length'] extends U
        ? true
        : GreaterThan<T, U, [...C, 1]>;

type ToNumber<S extends string,
  L extends number[] = []> =
  `${L['length']}` extends S
    ? L['length']
    : ToNumber<S, [...L, 0]>;

type Reverse<A> =
  `${A}` extends `${infer AH}${infer AT}`
    ? `${Reverse<AT>}${AH}` : A

type Digs = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
type DigsNext<I = Digs, R = {}> =
  I extends [infer Head, infer Next, ...infer Tail]
    ? DigsNext<[Next, ...Tail], R & Record<Head, Next>>
    : { [K in keyof R]: R[K] }
type DigsPrev = { [K in keyof DigsNext as DigsNext[K]]: K }

type AddOne<A> =
  A extends `${infer AH}${infer AT}`
    ? AH extends '9' ? `0${AddOne<AT>}` : `${DigsNext[AH]}${AT}`
    : `1`

type GetNum<Dig extends string, Casa extends string> =
  Casa extends '0'
    ? Numeros[ToNumber<Dig>]
    : Casa extends '1'
      ? Dezenas[ToNumber<Dig>]
      : Casa extends '2'
        ? Centenas[ToNumber<Dig>]
        : 'mano que';

type TrimWithE<Str extends string, Acc extends string ='', First = true> =
  Str extends `${infer L}${infer R}`
    ? L extends ' '
      ? First extends true
        ? TrimWithE<R,  `${Acc} e `, false>
        : TrimWithE<R, `${Acc}${L}`, First>
      : TrimWithE<R, `${Acc}${L}`, First>
      : Acc

type LowerThan20 = {
  "20": 'vinte',
  "19": 'dezenove',
  "18": 'dezoito',
  "17": 'dezessete',
  "16": 'dezesseis',
  "15": 'quinze',
  "14": 'quatorze',
  "13": 'treze',
  "12": 'doze',
  "11": 'onze',
  "10": 'dez',
}
type Assert<T, K> = T extends K ? T : never;
type GetExtense<Str extends string, Acc extends string = '', Casa = '0', START extends string = Str> =
  START extends '100'
    ? Cem[0]
    : GreaterThan<ToNumber<START>, 10> extends true
      ? GreaterThan<ToNumber<START>, 20> extends true
        ? Reverse<Str> extends `${infer L}${infer R}`
          ? GetExtense<R, `${GetNum<L, Casa>} ${Acc}`, AddOne<Casa>, START>
          : TrimWithE<Acc>
        : LowerThan20[Assert<START, keyof LowerThan20>]
      : Numeros[ToNumber<START>]


const oito: GetExtense<'8'>;
const vinte2: GetExtense<'22'> // vinte e dois
const dezenove: GetExtense<'19'> // 'dezenove'
const quarenta2: GetExtense<'42'> // 'quarenta e dois'
const trinta9: GetExtense<'39'> // 'trinta e nove'
const noventa6: GetExtense<'69'> // 'noventa e seis'
const noventa6: GetExtense<'109'> // 'cento e nove'