array-infer.ts

export type ArrayInfer<T> = T extends (infer U)[] ? U : never

arrow.ts

export type Arrow<P extends unknown[] = unknown[], R = unknown> = (
  ...args: P
) => R

callback.ts

export type Callback<T = void> = (data: T) => void

cast.ts

export type Cast<T1, T2> = T1 extends T2 ? T1 : T2

equals.ts

export type Equals<A1, A2> = (<A>() => A extends A2 ? 1 : 0) extends <
  A
>() => A extends A1 ? 1 : 0
  ? 1
  : 0

falsy.ts

export type Falsy = null | undefined | false | 0 | -0 | 0n | ''

head-letter.ts

export type HeadLetter<T> = T extends `${infer FirstLetter}${infer _Rest}`
  ? FirstLetter
  : never

head.ts

export type Head<T extends any[]> = T[0]

iter.ts

export type UniversalIterator<T = unknown> = Iterator<T> | AsyncIterator<T>

export type UniversalIterable<T = unknown> = Iterable<T> | AsyncIterable<T>

export type Iter<T> = UniversalIterator<T> | UniversalIterable<T>

iterable-infer.ts

export type IterableInfer<
  T extends Iterable<unknown> | AsyncIterable<unknown>
> = T extends Iterable<infer U> | AsyncIterable<infer U> ? U : never

last.ts

import type {ArrayInfer} from './array-infer'
import type {Equals} from './equals'
import type {Length} from './length'

export type Last<T extends unknown[]> = Equals<Length<T>, number> extends 1
  ? ArrayInfer<T>
  : T extends [...T, infer U]
  ? U
  : never

length.ts

export type Length<T extends unknown[]> = T['length']

letter-to-lower.ts

import {UpperToLowerCaseMapper} from './letters'

export type LetterToLower<T> = T extends `${infer FirstLetter}${infer _Rest}`
  ? FirstLetter extends keyof UpperToLowerCaseMapper
    ? UpperToLowerCaseMapper[FirstLetter]
    : FirstLetter
  : T

letter-to-upper.ts

import {LowerToUpperToLowerCaseMapper} from './letters'

export type LetterToUpper<T> = T extends `${infer FirstLetter}${infer _Rest}`
  ? FirstLetter extends keyof LowerToUpperToLowerCaseMapper
    ? LowerToUpperToLowerCaseMapper[FirstLetter]
    : FirstLetter
  : T

letters.ts

export type LowerToUpperToLowerCaseMapper = {
  a: 'A'
  b: 'B'
  c: 'C'
  d: 'D'
  e: 'E'
  f: 'F'
  g: 'G'
  h: 'H'
  i: 'I'
  j: 'J'
  k: 'K'
  l: 'L'
  m: 'M'
  n: 'N'
  o: 'O'
  p: 'P'
  q: 'Q'
  r: 'R'
  s: 'S'
  t: 'T'
  u: 'U'
  v: 'V'
  w: 'W'
  x: 'X'
  y: 'Y'
  z: 'Z'
}

export type UpperToLowerCaseMapper = {
  A: 'a'
  B: 'b'
  C: 'c'
  D: 'd'
  E: 'e'
  F: 'f'
  G: 'g'
  H: 'h'
  I: 'i'
  J: 'j'
  K: 'k'
  L: 'l'
  M: 'm'
  N: 'n'
  O: 'o'
  P: 'p'
  Q: 'q'
  R: 'r'
  S: 's'
  T: 't'
  U: 'u'
  V: 'v'
  W: 'w'
  X: 'x'
  Y: 'y'
  Z: 'z'
}

object-values.ts

export type ObjectValues<T> = T extends Record<any, infer V> ? V : never

prepend.ts

export type Prepend<ARR extends unknown[], T> = [T, ...ARR]

reject.ts

export type Reject = (reason: unknown) => void

resolve.ts

export type Resolve<T> = (a: IteratorResult<T>) => void

return-pipe-type.ts

import {Drop} from './drop'
import {Prepend} from './prepend'

export type ReturnPipeType<T extends unknown[]> = T extends [
  a: infer A,
  b: infer B,
  ...args: unknown[]
]
  ? A extends Promise<unknown>
    ? ReturnPipeType<Prepend<Drop<2, T>, Promise<Awaited<B>>>>
    : ReturnPipeType<Prepend<Drop<2, T>, B>>
  : T[0]

return-value-type.ts

import type {IterableInfer} from './iterable-infer'

export type ReturnValueType<
  T extends Iterable<unknown> | AsyncIterable<unknown>,
  R = IterableInfer<T>
> = T extends AsyncIterable<unknown>
  ? Promise<Awaited<R>>
  : T extends Iterable<unknown>
  ? Awaited<R>
  : never

switch-key-value.ts

import {ObjectValues} from './object-values'

export type SwitchKeyValue<
  T,
  T1 extends Record<string, any> = {
    [K in keyof T]: {key: K; value: T[K]}
  },
  T2 = {
    [K in ObjectValues<T1>['value']]: Extract<
      ObjectValues<T1>,
      {value: K}
    >['key']
  }
> = T2

tail.ts

export type Tail<T extends unknown[]> = T extends [any, ...infer U] ? U : []

to-lower-case.ts

import {HeadLetter} from './head-letter'
import {LetterToLower} from './letter-to-lower'
import {TailLetters} from './trail-letters'

export type ToLowerCase<T> = T extends ''
  ? T
  : `${LetterToLower<HeadLetter<T>>}${ToLowerCase<TailLetters<T>>}`

to-pascal-case.ts

import {ToSentenceCase} from './to-sentence-case'

export type ToPascalCase<T> = T extends ``
  ? T
  : T extends `${infer FirstWord}_${infer RestLetters}`
  ? `${ToSentenceCase<FirstWord>}${ToPascalCase<RestLetters>}`
  : ToSentenceCase<T>

to-sentence-case.ts

import {HeadLetter} from './head-letter'
import {LetterToUpper} from './letter-to-upper'
import {ToLowerCase} from './to-lower-case'
import {TailLetters} from './trail-letters'

export type ToSentenceCase<T> = `${LetterToUpper<HeadLetter<T>>}${ToLowerCase<
  TailLetters<T>
>}`

trail-letters.ts

export type TailLetters<T> = T extends `${infer _FirstLetter}${infer Rest}`
  ? Rest
  : never

transform-keys-to-camel-case.ts

import {Cast} from '../cast'
import {SwitchKeyValue} from './switch-key-value'
import {UpperCaseToCamelCase} from './upper-case-to-camel-case'

type CallRecursiveTransformToCamelCaseIfObject<T> = T extends Record<any, any>
  ? TransformKeysToCamelCase<T>
  : T

export type TransformKeysToCamelCase<
  T extends Record<string, any>,
  T0 = {[K in keyof T]: UpperCaseToCamelCase<K>},
  T1 = SwitchKeyValue<T0>,
  T2 = {
    [K in keyof T1]: CallRecursiveTransformToCamelCaseIfObject<
      T[Cast<T1[K], string>]
    >
  }
> = T2

transform-keys-to-pascal-case.ts

import {Cast} from '../cast'
import {SwitchKeyValue} from './switch-key-value'
import {UpperCaseToPascalCase} from './upper-case-to-pascal-case'

type CallRecursiveTransformToPascalCaseIfObject<T> = T extends Record<any, any>
  ? TransformKeysToPascalCase<T>
  : T

export type TransformKeysToPascalCase<
  T extends Record<string, any>,
  T0 = {[K in keyof T]: UpperCaseToPascalCase<K>},
  T1 = SwitchKeyValue<T0>,
  T2 = {
    [K in keyof T1]: CallRecursiveTransformToPascalCaseIfObject<
      T[Cast<T1[K], string>]
    >
  }
> = T2

truthy-types-of.ts

import type {Falsy} from './falsy'

export type TruthyTypesOf<T> = T extends Falsy ? never : T

type.ts

export const Type = Function

export interface Type<T> extends ReturnType<FunctionConstructor> {
  new (...args: any[]): T
}

export function isType(v: any): v is Type<any> {
  return typeof v === 'function'
}

upper-case-to-camel-case.ts

import {HeadLetter} from './head-letter'
import {ToLowerCase} from './to-lower-case'
import {ToPascalCase} from './to-pascal-case'
import {TailLetters} from './trail-letters'

export type UpperCaseToCamelCase<T> = `${ToLowerCase<
  HeadLetter<T>
>}${TailLetters<ToPascalCase<T>>}`

upper-case-to-pascal-case.ts

import {HeadLetter} from './head-letter'
import {ToPascalCase} from './to-pascal-case'
import {TailLetters} from './trail-letters'

export type UpperCaseToPascalCase<T> = `${ToPascalCase<
  HeadLetter<T>
>}${TailLetters<ToPascalCase<T>>}`