Options
All
  • Public
  • Public/Protected
  • All
Menu

@oakfinch/ts-extra

Index

Type aliases Everyday

Type aliases Other

Type aliases Utility

Everyday Type aliases

AnyArray

AnyArray: any[]

Alias for any[]

AnyFunction

AnyFunction<TArgs, TReturn>: (...args: TArgs) => TReturn

Type parameters

  • TArgs: readonly any[] = any[]

  • TReturn = any

Type declaration

    • (...args: TArgs): TReturn

    • Function with arguments TArgs and return type TReturn

      Parameters

      • Rest ...args: TArgs

      Returns TReturn

AnyMap

AnyMap: Map<any, any>

Alias for Map<any, any>

AnyObject

AnyObject: {}

Alias for { [index: string | number | symbol]: any }

Type declaration

  • [index: string | number | symbol]: any

AnyPromise

AnyPromise: Promise<any>

Alias for Promise<any>

EmptyObject

EmptyObject: {}

Alias for {}

Type declaration

    Index

    Index: string | number | symbol

    Alias for string | number | symbol, used to index JS objects

    Other Type aliases

    Add

    Add<A, B>: AddHelper<A, B> extends infer T ? T extends string ? Convert<T> extends infer T0 ? T0 extends number ? T0 : number : never : T extends number ? T : never : never

    Type parameters

    • A: number

    • B: number

    ArrayIndex

    ArrayIndex<T>: Length<T> extends never ? number : Exclude<Range<Length<T>>, Length<T>>

    Type parameters

    FromArgs

    FromArgs<T, U>: Length<T> extends never ? T : T extends never[] ? U : ((...args: T) => any) extends (first: any, ...rest: infer ARest) => any ? FromArgs<ARest, [...U, T[0]]> : never

    Type parameters

    • T: readonly any[]

    • U: readonly any[] = []

    Range

    Range<P, T>: T extends void ? RangeOf1<P> : RangeOf2<P, Exclude<T, void>>

    Type parameters

    • P: number

    • T: number | void = void

    Slice

    Slice<T, S, E>: Length<T> extends never ? T : E extends number ? SliceStart<SliceEnd<T, Subtract<T["length"], E>>, S> : []

    Type parameters

    • T: readonly any[]

    • S: number = 0

    • E = Length<T>

    Subtract

    Subtract<A, B>: SubtractHelper<A, B> extends infer T ? T extends string ? Convert<T> extends infer T0 ? T0 extends number ? T0 : number : never : T extends number ? T : never : never

    Type parameters

    • A: number

    • B: number

    Trim

    Trim<T, U>: TrimStart<TrimEnd<T, U>, U>

    Trim characters from both ends of a string

    Type parameters

    • T: string

    • U: string

    TrimEnd

    TrimEnd<T, U>: T extends `${infer Rest}${U}` ? TrimEnd<Rest, U> : T

    Trim characters from the end of a string

    Type parameters

    • T: string

    • U: string

    TrimStart

    TrimStart<T, U>: T extends `${U}${infer Rest}` ? TrimStart<Rest, U> : T

    Trim characters from the start of a string

    Type parameters

    • T: string

    • U: string

    TupleOf

    TupleOf<T, N>: number extends N ? T[] : { [ K in N]: BuildPowersOf2LengthArrays<K, [[never]]> extends infer U ? U extends never[][] ? Replace<ConcatLargestUntilDone<K, U, []>, T> : never : never }[N]

    Type parameters

    • T

    • N: number

    Utility Type aliases

    ArrayItem

    ArrayItem<T>: T[number]

    A union of all possible values in array T

    example
    const arr = [1, 2, 3, 4, 5, 6] as const
    type Item = ArrayItem<typeof arr> // === 1|2|3|4|5|6

    Type parameters

    • T: readonly any[]

    Entries

    Entries<T>: Extract<Index, keyof T> extends never ? Tuple<Value<{ [ PKey in keyof T]: [PKey, T[PKey]] }>> : [keyof T, Value<T>][]

    A Tuple of [key, value] pairs constructed from T

    example
    type A = Entries<{foo: 'FOO', bar: 'BAR'}> // === [['foo', 'FOO'],['bar', 'BAR']]
    type B = Entries<{ [index: string | number]: any }> // === [string | number, any][]

    Type parameters

    First

    First<T>: Unshift<T>[0]

    Returns the first item of the Array T

    example
    type A = First<string[]> // === string
    type B = First<['hello', 'goodbye']> // === 'hello'

    Type parameters

    FromEntries

    FromEntries<T>: Simplify<FromEntriesInner<T>>

    An object constructed from entries T (like those returned from Object.entries)

    example
    type A = FromEntries<[['foo', 'FOO'],['bar', 'BAR']]> // === {foo: 'FOO', bar: 'BAR'}

    Type parameters

    Intersection

    Intersection<T>: (T extends any ? (arg: T) => void : never) extends (arg: infer U) => void ? U : never

    Converts a Union T to an Intersection

    example
    type A = Intersection<{ foo: 'FOO' } | { bar: 'BAR' }> // === { foo: 'FOO' } & { bar: 'BAR' }

    Type parameters

    • T

    Invert

    Invert<T>: Simplify<Intersection<Value<{ [ PKey in keyof T]: { [ PVal in T[PKey]]: PKey } }>>>

    Inverts the keys and values of type T

    example
    type A = Invert<{ foo: 'FOO', bar: 'BAR' }> // === { FOO: 'foo', BAR: 'bar' }

    Type parameters

    • T: {}

    Last

    Last<T>: Pop<T>[0]

    Returns the last item of the Array T

    example
    type A = First<string[]> // === string
    type B = First<['hello', 'goodbye']> // === 'goodbye'

    Type parameters

    Length

    Length<T>: number extends T["length"] ? never : T["length"]

    Returns the length of the Array T, provided it is not number

    example
    type A = DefinedLength<string[]> // === never
    type B = DefinedLength<['hello', 'goodbye']> // === 2

    Type parameters

    MergeArrays

    MergeArrays<T, U>: (Length<T> | Length<U>) extends never ? [ArrayItem<T>, ArrayItem<U>][] : Merge<T, U>

    Merges array items from two arrays into a single array

    example
    type A = Merge<['a', 'b', 'c'], [1, 2, 3]> // === [['a', 1], ['b', 2], ['c', 3]]
    type B = Merge<string[], number[]> // === [string, number][]

    Type parameters

    • T: readonly any[]

    • U: readonly any[]

    Mutable

    Mutable<T>: { -readonly [ P in keyof T]: T[P] }

    Removes the readonly prefix from T

    example
    type A = Mutable<readonly [1,2,3]> // === [1,2,3]
    type B = Mutable<{ readonly foo: 'FOO' }> // === { foo: 'FOO' }

    Type parameters

    • T

    Pop

    Pop<T>: T extends readonly [...infer TRest, infer TLast] ? [TLast, TRest] : [ArrayItem<T>, ArrayItem<T>[]]

    Returns a Tuple where the first item represents the last item of T, and the second item represents all the remaining items of T

    example
    type A = Pop<[1,2,3,4,5]> // === [5, [1, 2, 3, 4]]

    Type parameters

    Reverse

    Reverse<T>: ReverseHelper<T>

    Reverse the order of Array type T

    example
    type A = Reverse<[1,2,3,4,5]> // === [5, 4, 3, 2, 1]
    type B = Reverse<number[]> // === number[]

    Type parameters

    • T: readonly any[]

    Simplify

    Simplify<T>: T extends AnyObject ? { [ P in keyof T]: T[P] } : T

    Attempts to expand type definitions

    example
    // When you have a complex type, like so:

    interface T0 {
      a: string
      b: string
      d: string
    }

    interface T1 {
      d: string
      e: string
      f: string
    }

    interface T2 {
      g: string
      h: string
      i: string
    }

    type Complex = Partial<Record<keyof T0, Value<T1>>> & T2

    // The type hints shown by TypeScript may not always be helpful. For example,
    // hovering over `Complex` in VS Code shows:

    type Complex = Partial<Record<keyof T0, string>> & T2

    // However, if you wrap that definition in Simplify, like so:

    type Complex = Simplify<Partial<Record<keyof T0, Value<T1>>> & T2>

    // The hover hint in VS Code will then display the type as:

    type Complex = {
      a?: string | undefined;
      b?: string | undefined;
      d?: string | undefined;
      g: string;
      h: string;
      i: string;
    }

    Type parameters

    • T: any

    Tuple

    Tuple<T>: Exclude<T, LastOfUnion<T>> extends never ? T extends Readonly<AnyArray> ? Length<T> extends never ? UnionToTuple<T> : T : UnionToTuple<T> : UnionToTuple<T>

    Returns a Tuple for a given Union T

    example
    type A = Tuple<1|2|3> // === [1,2,3]

    Type parameters

    • T

    Unshift

    Unshift<T>: T extends readonly [infer TFirst, ...infer TRest] ? [TFirst, TRest] : [ArrayItem<T>, ArrayItem<T>[]]

    Returns a Tuple where the first item represents the first item of T, and the second item represents all the remaining items of T

    example
    type A = Unshift<[1,2,3,4,5]> // === [1, [2, 3, 4, 5]]

    Type parameters

    Value

    Value<T>: T extends Readonly<AnyArray> ? ArrayItem<T> : T[keyof T]

    A Union of array items or object values

    example
    type A = Value<{ foo: 'FOO', bar: 'BAR'}> // === 'FOO'|'BAR'
    type B = Value<[1, 2, 3, 4, 5]> // === 1|2|3|4|5

    Type parameters

    Generated using TypeDoc