Options
All
  • Public
  • Public/Protected
  • All
Menu

Module types

Index

Type aliases

Type aliases

PredicateCallback

PredicateCallback<T>: (value: T) => unknown

Type parameters

  • T

Type declaration

    • (value: T): unknown

    • Parameters

      • value: T

      Returns unknown

PickObject

PickObject<T, D>: Pick<T, keyof D extends keyof T ? keyof D : keyof Partial<T>>

Type parameters

  • T: Object

  • D: Object

DeepPartial

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

deep partial

Type parameters

  • T

PickRestrictedObject

PickRestrictedObject<T, R>: Pick<T, { [ P in keyof T]: T[P] extends R ? P : never }[keyof T]>

Constructs a type by picking restricted object value

Type parameters

  • T: object

  • R: unknown

PickUnion

PickUnion<T, K>: K extends K ? { [ P in K]: T[P] } : never

pick union type

example

PickUnion<{ a: number, b: string }, 'a' | 'b'>

// => { a: number } | { b: string }

Type parameters

  • T

  • K: keyof T

AddStringPrefix

AddStringPrefix<T, P>: `${P}${Capitalize<T extends string ? T : never>}`

Type parameters

  • T

  • P: string

AddPrefix

AddPrefix<T, D>: T extends object ? { [ P in keyof T as AddStringPrefix<P, D>]: T[P] } : AddStringPrefix<T, D>

add prefix

example

AddPrefix<{ ob: string, cb: number }, 'My'>

// => { MyOb: string, MyCb: number }

AddPrefix<'func', 'My'>

// => 'MyFunc'

Type parameters

  • T

  • D: string

PartialOptional

PartialOptional<T, K>: Omit<T, K> & Partial<Pick<T, K>>

partial with optional

example

PartialOptional<{ a: string; b: number }, 'a'>

// => { a?: string; b: number }

Type parameters

  • T

  • K: keyof T

ObjectLike

ObjectLike: {}

Type declaration

  • [key: string]: unknown

Values

Values<T>: T[keyof T]

Type parameters

  • T

UnionToTuple

UnionToTuple<T, P>: UnionToFn<T> extends () => infer R ? Exclude<T, R> extends never ? [...P, R] : UnionToTuple<Exclude<T, R>, [...P, R]> : never

Type parameters

  • T

  • P: any[] = []

SplitObject

SplitObject<T>: UnionToTuple<keyof T> extends keyof T[] ? ObjectTuple<T, UnionToTuple<keyof T>> : never

split a ObjectLike into array.

example

Type parameters

DeepAssignWith

DeepAssignWith<T, U>: T extends ObjectLike ? U extends [infer First, ...infer Rest] ? Values<First> extends ObjectLike ? keyof First extends keyof T ? Copy<DeepAssignWith<Omit<T, keyof First> & { [ key in keyof First]: DeepAssign<Values<Pick<T, keyof First>>, Values<First>> }, Rest>> : never : Copy<DeepAssignWith<Omit<T, keyof First> & First, Rest>> : T : never

Type parameters

  • T

  • U: unknown[]

DeepAssign

DeepAssign<A, B>: A extends ObjectLike ? B extends ObjectLike ? DeepAssignWith<A, SplitObject<B>> : A : never

Type parameters

  • A

  • B

Generated using TypeDoc