Options
All
  • Public
  • Public/Protected
  • All
Menu

Index

Type aliases

UnionToIntersection

UnionToIntersection<U>: (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never

Union to Intersection

UnionToIntersection<{ a: 1 } | { b: 2 } | { c: 3 }> => { a: 1 } & { b: 2 } & { c: 3 }

Type parameters

  • U

LastOfUnion

LastOfUnion<T>: UnionToIntersection<T extends any ? () => T : never> extends () => infer R ? R : never

Last of Union

LastOfUnion<1 | 2 | 3> => 3
deprecated

Black Magic

deprecated

Not recommended, rely on compiler internal implementation

Type parameters

  • T

UnionToTuple

UnionToTuple<T>: _UnionToTuple<T>

Union to Tuple

UnionToTuple<1 | 2 | 3> => [1, 2, 3]
deprecated

Black Magic

deprecated

Not recommended, rely on compiler internal implementation

Type parameters

  • T

TuplePush

TuplePush<T, V>: [...T, V]
TuplePush<[1, 2], 3> => [1, 2, 3]

Type parameters

  • T: any[]

  • V

TupleUnshift

TupleUnshift<T, V>: [V, ...T]
TupleUnshift<[1, 2], 3> => [3, 1, 2]

Type parameters

  • T: any[]

  • V

TupleTail

TupleTail<T>: T extends [any, ...infer R] ? R : never
TupleTail<[1, 2, 3]> => [2, 3]

Type parameters

  • T: any[]

TupleFirst

TupleFirst<T>: T extends [infer F, ...any[]] ? F : never
TupleFirst<[1, 2, 3]> => 1

Type parameters

  • T: any[]

TupleLast

TupleLast<T>: T[TupleTail<T>["length"]]
TupleLast<[1, 2, 3]> => 3

Type parameters

  • T: any[]

TupleBody

TupleBody<T>: T extends [...infer B, ...[any]] ? B : never
TupleBody<[1, 2, 3]> => [1, 2]

Type parameters

  • T: any[]

TupleConcat

TupleConcat<L, R>: [...L, ...R]
TupleConcat<[1, 2, 3], [4, 5]> => [1, 2, 3, 4, 5]

Type parameters

  • L: any[]

  • R: any[]

TupleN

TupleN<T, N>: number extends N ? T[] : _TupleN<T, N>
TupleN<T, 5> => [T, T, T, T, T]

Type parameters

  • T

  • N: number

Writeable

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

Make all properties in T writeable

Writeable<readonly [1, 2, 3]> => [1, 2, 3]

Type parameters

  • T

DeepWriteable

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

Make all properties in T writeable

DeepWriteable<readonly [readonly [1]]> => [[1]]

Type parameters

  • T

DeepReadonly

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

Make all properties in T readonly

DeepReadonly<[[1]]> => readonly [readonly [1]]

Type parameters

  • T

DeepPartial

DeepPartial<T>: { [ P in keyof T]?: DeepPartial<T[P]> }

Make all properties in T optional

DeepPartial<{ a: { b: 1 } }> => { a?: { b?: 1 } }

Type parameters

  • T

DeepRequired

DeepRequired<T>: { [ P in keyof T]-?: DeepRequired<T[P]> }

Make all properties in T required

DeepRequired<{ a?: { b?: 1 } }> => { a: { b: 1 } }

Type parameters

  • T

AssertType

AssertType<E, A>: A extends E ? A : never

If A does not extends E, return never

Type parameters

  • E

  • A

MapKey

MapKey<M>: M extends MapLike<infer K, any> ? K : never
MapKey<Map<K, V>> => K

Type parameters

MapValue

MapValue<M>: M extends MapLike<any, infer V> ? V : never
MapValue<Map<K, V>> => V

Type parameters

SetValue

SetValue<S>: S extends SetLike<infer V> ? V : never
SetValue<Set<T>> => T

Type parameters

GetKey

GetKey<T, V>: { [ K in keyof T]: T[K] extends V ? K : never }[keyof T]
GetKey<{ a: 1 }, 1> => 'a'
enum Foo { A, B, C }
GetKey<typeof Foo, Foo.B> => 'B'

Type parameters

  • T

  • V

PromiseValue

PromiseValue<T>: T extends PromiseLike<infer V> ? V : never
PromiseValue<Promise<T>> => T
deprecated

use Awaited<T> in > ts 4.5

Type parameters

  • T: PromiseLike<any>

LiteralObj

LiteralObj<T>: T extends object ? { [ K in keyof T]: T[K] } : never
LiteralObj<{ a: 1 } & { b: 2 }> => { a: 1, b: 2 }

Type parameters

  • T

LinkedTuple

LinkedTuple<T>: [T] | [T, LinkedTuple<T>]

Structure like a linked list

Type parameters

  • T

LinkedTupleUnion

LinkedTupleUnion<T>: T extends LinkedTuple<infer R> ? R : never

Take the union of depth tuple items, same as T[number] on Array

LinkedTupleUnion<[1, [2, [3]]]> => 1 | 2 | 3

Type parameters

  • T

ArrayElement

ArrayElement<A>: A extends infer T[] ? T : never

Take Array Element Type

ArrayElement<1[]> => 1

Type parameters

  • A

ArrayGuard

ArrayGuard<A>: A extends any[] ? A : never

Prompt typescript this type is an array

Type parameters

  • A: any[]

FlatTuple

FlatTuple<A>: _FlatTuple<A>

Flatten deep tuples

FlatTuple<[[1,[2]], [[[3]]]]> => [1, 2, 3]

Type parameters

  • A: any[]

KeyofExcludeValue

KeyofExcludeValue<T, V>: { [ K in keyof T]: T[K] extends V ? never : K }[keyof T]

Take key extract some value

KeyofExcludeValue<{ a: 1, b: 2, c: 3 }, 2 | 3> => 'a'

Type parameters

  • T

  • V: T[keyof T]

KeyofExtractValue

KeyofExtractValue<T, V>: { [ K in keyof T]: T[K] extends V ? K : never }[keyof T]

Take key extract some value

KeyofExtractValue<{ a: 1, b: 2, c: 3 }, 2 | 3> => 'b' | 'c'

Type parameters

  • T

  • V: T[keyof T]

PickValue

PickValue<T, V>: Pick<T, KeyofExtractValue<T, V>>

Pick object by value

PickValue<{ a: 1, b: 2, c: 3 }, 2 | 3> => { b: 2, c: 3 }

Type parameters

  • T

  • V: T[keyof T]

OmitValue

OmitValue<T, V>: Pick<T, KeyofExcludeValue<T, V>>

Omit object by value

OmitValue<{ a: 1, b: 2, c: 3 }, 2 | 3> => { a: 1 }

Type parameters

  • T

  • V: T[keyof T]

ObjFromEntries

ObjFromEntries<T>: LiteralObj<UnionToIntersection<T extends [infer K, infer V] ? { [ P in Extract<K, PropertyKey>]: V } : never>>

Build Object from Entries

ObjFromEntries<['a', 1] | ['b', 2]> =>  { a: 1, b: 2 }

Type parameters

  • T: [PropertyKey, any]

ObjKeys

ObjKeys<T>: keyof T
ObjKeys<{ a: 1, b: 2, c: 3 }> => 'a' | 'b' | 'c'

Type parameters

  • T

ObjVals

ObjVals<T>: T[keyof T]
ObjKeys<{ a: 1, b: 2, c: 3 }> => 1 | 2 | 3

Type parameters

  • T

ObjEntry

ObjEntry<T>: _ObjEntry<T, keyof T>

Type parameters

  • T

EntryValue

EntryValue<E, K>: E extends [infer P, infer V] ? P extends K ? V : K extends P ? V : never : never

Get value by key for object key value entries

EntryValue<['a', 1] | ['b', 2], 'a'> => 1

Type parameters

  • E: [any, any]

  • K: E[0]

EntryKey

EntryKey<E, V>: E extends [infer K, V] ? K : never

Get key by value object key value entries

EntryKey<['a', 1] | ['b', 2], 1> => 'a'

Type parameters

  • E: [any, any]

  • V: E[1]

ObjPath

ObjPath<T>: T extends object ? Extract<keyof T, string | number> | `${Extract<keyof T, string | number>}` | { [ K in Extract<keyof T, string | number>]: `${K}.${ObjPath<T[K]>}` }[Extract<keyof T, string | number>] : never

Get all object field path deeply

ObjPath<{ a: { b: { c: 1 } }[] }> => "a" | `a.${number}` | "a.length" | "a.toString" | "a.toLocaleString" | "a.pop" | "a.push" | "a.concat" | "a.join" | "a.reverse" | "a.shift" | "a.slice" | "a.sort" | "a.splice" | "a.unshift" | ... 18 more ... | `a.${number}.b.c`

Type parameters

  • T

ValByPath

ValByPath<T, K>: ObjPathEntry<T> extends [any, any] ? EntryValue<ObjPathEntry<T>, K> : never

Get object value by field path deeply

ValByPath<{ a: { b: { c: 1 } }[] }, 'a.0.b.c'> => 1

Type parameters

ObjPathEntry

ObjPathEntry<T>: _ObjPathEntry<T>

Get all object [field path, value] entry deeply

ObjPathEntry<{ a: { b: { c: 1 } } }> => ["a", { b: { c: 1 } }] | ["a.b", { c: 1 }] | ["a.b.c", 1]

Type parameters

  • T

Pair

Pair<K, V>: [K, V]

Key Value Pairl

Type parameters

  • K

  • V

ReadonlyPair

ReadonlyPair<K, V>: readonly [K, V]

Readonly Key Value Pairl

Type parameters

  • K

  • V

AnyPair

AnyPair<K, V>: Pair<K, V> | ReadonlyPair<K, V>

Any Pair

Type parameters

  • K

  • V

PairKey

PairKey<T>: T extends AnyPair<infer K, any> ? K : never

Get Key of Pair

Type parameters

  • T

PairValue

PairValue<T>: T extends AnyPair<any, infer V> ? V : never

Get Key of Pair

Type parameters

  • T

Generated using TypeDoc