Options
All
  • Public
  • Public/Protected
  • All
Menu

Mobius Utils API - v1.8.0

Index

Type aliases

Interfaces

Functions

Enumerations

Variables

Classes

Type aliases

NonEmptyArray

NonEmptyArray<T>: [T, ...T[]]

Get an array type which at least has one element.

see

example - For usecases, see https://github.com/ts-essentials/ts-essentials#nonemptyarray

Type parameters

  • T

KeyofBase

KeyofBase: keyof any

Primative

Primative: string | number | boolean | bigint | symbol | null | undefined

NonPrimative

NonPrimative: object

Cast

Cast<T, SafeT>: T extends SafeT ? T : SafeT

Type parameters

  • T

  • SafeT

Try

Try<T, SafeT, Catch>: T extends SafeT ? T : Catch

Type parameters

  • T

  • SafeT

  • Catch = never

IsUndefined

IsUndefined<T>: Exclude<T, undefined> extends never ? true : false

Predicate whether the target is undefined.

Type parameters

  • T

IfUndefined

IfUndefined<T, TRUE, FALSE>: IsUndefined<T> extends true ? TRUE : FALSE

Type parameters

  • T

  • TRUE = true

  • FALSE = never

CastUndefined

CastUndefined<T>: T extends undefined ? T : undefined

Type parameters

  • T

IsNull

IsNull<T>: Exclude<T, null> extends never ? true : false

Predicate whether the target is null.

Type parameters

  • T

IfNull

IfNull<T, TRUE, FALSE>: IsNull<T> extends true ? TRUE : FALSE

Type parameters

  • T

  • TRUE = true

  • FALSE = never

CastNull

CastNull<T>: T extends null ? T : null

Type parameters

  • T

IsNil

IsNil<T>: Exclude<T, undefined | null> extends never ? true : false

Predicate whether the target is null | undefined.

Type parameters

  • T

IfNil

IfNil<T, TRUE, FALSE>: IsNil<T> extends true ? TRUE : FALSE

Type parameters

  • T

  • TRUE = true

  • FALSE = never

CastNil

CastNil<T>: T extends undefined | null ? T : undefined | null

Type parameters

  • T

IsUndefinedable

IsUndefinedable<T>: T extends Exclude<T, undefined> ? false : true

Type parameters

  • T

IsNullable

IsNullable<T>: T extends Exclude<T, null> ? false : true

Type parameters

  • T

IsNilable

IsNilable<T>: T extends Exclude<T, null | undefined> ? false : true

Type parameters

  • T

IfUndefinedable

IfUndefinedable<T, TRUE, FALSE>: IsUndefinedable<T> extends true ? TRUE : FALSE

Type parameters

  • T

  • TRUE = true

  • FALSE = never

IfNullable

IfNullable<T, TRUE, FALSE>: IsNullable<T> extends true ? TRUE : FALSE

Type parameters

  • T

  • TRUE = true

  • FALSE = never

IfNilable

IfNilable<T, TRUE, FALSE>: IsNilable<T> extends true ? TRUE : FALSE

Type parameters

  • T

  • TRUE = true

  • FALSE = never

Undefinedable

Undefinedable<T>: T | undefined

Type parameters

  • T

Nullable

Nullable<T>: T | null

Type parameters

  • T

Nilable

Nilable<T>: T | null | undefined

Type parameters

  • T

NonUndefinedable

NonUndefinedable<T>: Exclude<T, undefined>

Type parameters

  • T

NonNullable

NonNullable<T>: Exclude<T, null>

Type parameters

  • T

NonNilable

NonNilable<T>: Exclude<T, null | undefined>

Type parameters

  • T

IsNever

IsNever<T>: [T] extends [never] ? true : false

Predicate whether the target is never.

Type parameters

  • T

IfNever

IfNever<T, TRUE, FALSE>: IsNever<T> extends true ? TRUE : FALSE

Type parameters

  • T

  • TRUE = true

  • FALSE = never

CastNever

CastNever<T>: T extends never ? T : never

Type parameters

  • T

IsAny

IsAny<T>: 0 extends 1 & T ? true : false

Predicate whether the target is any.

see

Copyright - The idea is get from https://stackoverflow.com/questions/49927523/disallow-call-with-any/49928360#49928360

Type parameters

  • T

IfAny

IfAny<T, TRUE, FALSE>: 0 extends 1 & T ? TRUE : FALSE

Type parameters

  • T

  • TRUE = true

  • FALSE = never

CastAny

CastAny<T>: T extends any ? T : any

Type parameters

  • T

IsUnknown

IsUnknown<T>: IsNever<T> extends true ? false : T extends unknown ? unknown extends T ? IsAny<T> extends true ? false : true : false : false

Type parameters

  • T

IfUnknown

IfUnknown<T, TRUE, FALSE>: IsUnknown<T> extends true ? TRUE : FALSE

Type parameters

  • T

  • TRUE = true

  • FALSE = never

CastUnknown

CastUnknown<T>: T extends unknown ? T : unknown

Type parameters

  • T

IsBoolean

IsBoolean<T>: T extends boolean ? true : false

Predicate whether the target is boolean.

Type parameters

  • T

IfBoolean

IfBoolean<T, TRUE, FALSE>: IsBoolean<T> extends true ? TRUE : FALSE

Type parameters

  • T

  • TRUE = true

  • FALSE = never

CastBoolean

CastBoolean<T>: T extends boolean ? T : boolean

Type parameters

  • T

IsBooleanLiteral

IsBooleanLiteral<T>: T extends boolean ? boolean extends T ? false : true : false

Type parameters

  • T

IsString

IsString<T>: T extends string ? true : false

Predicate whether the target is string.

Type parameters

  • T

IfString

IfString<T, TRUE, FALSE>: IsString<T> extends true ? TRUE : FALSE

Type parameters

  • T

  • TRUE = true

  • FALSE = never

CastString

CastString<T>: T extends string ? T : string

Type parameters

  • T

IsStringLiteral

IsStringLiteral<T>: T extends string ? string extends T ? false : true : false

Type parameters

  • T

IsNumber

IsNumber<T>: T extends number ? true : false

Predicate whether the target is number.

Type parameters

  • T

IfNumber

IfNumber<T, TRUE, FALSE>: IsNumber<T> extends true ? TRUE : FALSE

Type parameters

  • T

  • TRUE = true

  • FALSE = never

CastNumber

CastNumber<T>: T extends number ? T : number

Type parameters

  • T

IsNumberLiteral

IsNumberLiteral<T>: T extends number ? number extends T ? false : true : false

Type parameters

  • T

IsSymbol

IsSymbol<T>: T extends symbol ? true : false

Predicate whether the target is symbol.

Type parameters

  • T

IfSymbol

IfSymbol<T, TRUE, FALSE>: IsSymbol<T> extends true ? TRUE : FALSE

Type parameters

  • T

  • TRUE = true

  • FALSE = never

CastSymbol

CastSymbol<T>: T extends symbol ? T : symbol

Type parameters

  • T

IsFunction

IsFunction<T>: T extends AnyFunction ? true : false

Predicate whether the target is of type function.

Type parameters

  • T

IfFunction

IfFunction<T, TRUE, FALSE>: IsFunction<T> extends true ? TRUE : FALSE

Type parameters

  • T

  • TRUE = true

  • FALSE = never

CastFunction

CastFunction<T>: T extends AnyFunction ? T : AnyFunction

Type parameters

  • T

IsUnion

IsUnion<T>: ClosedDistribution<T> extends ExpandedDistribution<T> ? false : true

Type parameters

  • T

IfUnion

IfUnion<T, TRUE, FALSE>: IsUnion<T> extends true ? TRUE : FALSE

Type parameters

  • T

  • TRUE = true

  • FALSE = never

IsArray

IsArray<T>: T extends readonly any[] ? number extends T["length"] ? true : false : false

Predicate whether the target is Array.

Type parameters

  • T

IfArray

IfArray<T, TRUE, FALSE>: IsArray<T> extends true ? TRUE : FALSE

Type parameters

  • T

  • TRUE = true

  • FALSE = never

IsReadonlyArray

IsReadonlyArray<T>: T extends readonly any[] ? T extends any[] ? false : true : false

Type parameters

  • T

IfReadonlyArray

IfReadonlyArray<T, TRUE, FALSE>: IsReadonlyArray<T> extends true ? TRUE : FALSE

Type parameters

  • T

  • TRUE = true

  • FALSE = never

IsWritableArray

IsWritableArray<T>: T extends any[] ? number extends T["length"] ? true : false : false

Type parameters

  • T

IfWritableArray

IfWritableArray<T, TRUE, FALSE>: IsWritableArray<T> extends true ? TRUE : FALSE

Type parameters

  • T

  • TRUE = true

  • FALSE = never

IsTuple

IsTuple<T>: T extends readonly any[] ? number extends T["length"] ? false : true : false

Type parameters

  • T

IfTuple

IfTuple<T, TRUE, FALSE>: IsTuple<T> extends true ? TRUE : FALSE

Type parameters

  • T

  • TRUE = true

  • FALSE = never

IsReadonlyTuple

IsReadonlyTuple<T>: T extends readonly any[] ? T extends any[] ? false : true : false

Type parameters

  • T

IfReadonlyTuple

IfReadonlyTuple<T, TRUE, FALSE>: IsReadonlyTuple<T> extends true ? TRUE : FALSE

Type parameters

  • T

  • TRUE = true

  • FALSE = never

IsWritableTuple

IsWritableTuple<T>: T extends any[] ? number extends T["length"] ? false : true : false

Type parameters

  • T

IfWritableTuple

IfWritableTuple<T, TRUE, FALSE>: IsWritableTuple<T> extends true ? TRUE : FALSE

Type parameters

  • T

  • TRUE = true

  • FALSE = never

IsArrayOrTuple

IsArrayOrTuple<T>: T extends readonly any[] ? true : false

Predicate whether the target is Array or Tuple.

Type parameters

  • T

IfArrayOrTuple

IfArrayOrTuple<T, TRUE, FALSE>: IsArrayOrTuple<T> extends true ? TRUE : FALSE

Type parameters

  • T

  • TRUE = true

  • FALSE = never

IsRecord

IsRecord<T>: T extends Record<string | number | symbol, any> ? true : false

Type parameters

  • T

IfRecord

IfRecord<T, TRUE, FALSE>: IsRecord<T> extends true ? TRUE : FALSE

Type parameters

  • T

  • TRUE = true

  • FALSE = never

IsStringRecord

IsStringRecord<T>: T extends Record<string, any> ? true : false

Type parameters

  • T

IfStringRecord

IfStringRecord<T, TRUE, FALSE>: IsStringRecord<T> extends true ? TRUE : FALSE

Type parameters

  • T

  • TRUE = true

  • FALSE = never

IsNumberRecord

IsNumberRecord<T>: T extends Record<number, any> ? true : false

Type parameters

  • T

IfNumberRecord

IfNumberRecord<T, TRUE, FALSE>: IsNumberRecord<T> extends true ? TRUE : FALSE

Type parameters

  • T

  • TRUE = true

  • FALSE = never

IsSymbolRecord

IsSymbolRecord<T>: T extends Record<symbol, any> ? true : false

Type parameters

  • T

IfSymbolRecord

IfSymbolRecord<T, TRUE, FALSE>: IsSymbolRecord<T> extends true ? TRUE : FALSE

Type parameters

  • T

  • TRUE = true

  • FALSE = never

IsEmptyObject

IsEmptyObject<Target>: keyof Target extends never ? true : false

Predicate whether the target is Record.

Type parameters

  • Target: Record<any, any>

IfEmptyObject

IfEmptyObject<Target, TRUE, FALSE>: IsEmptyObject<Target> extends true ? TRUE : FALSE

Type parameters

  • Target: Record<any, any>

  • TRUE = true

  • FALSE = never

IsPrimative

IsPrimative<T>: T extends string ? true : T extends number ? true : T extends boolean ? true : T extends symbol ? true : T extends bigint ? true : T extends undefined ? true : T extends null ? true : false

Type parameters

  • T

IfPrimative

IfPrimative<T, TRUE, FALSE>: IsPrimative<T> extends true ? TRUE : FALSE

Type parameters

  • T

  • TRUE = true

  • FALSE = never

IsPrimativeUnion

IsPrimativeUnion<T>: T extends Primative ? true : false

Type parameters

  • T

IfPrimativeUnion

IfPrimativeUnion<T, TRUE, FALSE>: IsPrimativeUnion<T> extends true ? TRUE : FALSE

Type parameters

  • T

  • TRUE = true

  • FALSE = never

Keys

Keys<A>: A extends readonly any[] ? Exclude<keyof A, keyof any[]> | number : keyof A

Type parameters

  • A: any

If

If<T, TRUE, FALSE>: T extends true ? TRUE : FALSE

Type parameters

  • T: boolean

  • TRUE

  • FALSE = never

IsEqual

IsEqual<A, B>: (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2 ? true : false

Type parameters

  • A

  • B

IfEqual

IfEqual<X, Y, TRUE, FALSE>: (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? TRUE : FALSE

Type parameters

  • X

  • Y

  • TRUE = true

  • FALSE = false

BooleanNot

BooleanNot<T>: T extends true ? false : true
example
  // Expect: true
type test1 = BooleanNot<false>
// Expect: false
type test2 = BooleanNot<true>

Type parameters

  • T: boolean

BooleanAnd

BooleanAnd<T, U>: T extends true ? U extends true ? true : false : false
example
  // Expect: true
type test1 = BooleanAnd<true, true>
// Expect: false
type test2 = BooleanAnd<true, false>
// Expect: false
type test3 = BooleanAnd<false, true>
// Expect: false
type test4 = BooleanAnd<false, false>

Type parameters

  • T: boolean

  • U: boolean

BooleanNand

BooleanNand<T, U>: T extends true ? U extends true ? false : true : true
example
  // Expect: false
type test1 = BooleanNand<true, true>
// Expect: true
type test2 = BooleanNand<true, false>
// Expect: true
type test3 = BooleanNand<false, true>
// Expect: true
type test4 = BooleanNand<false, false>

Type parameters

  • T: boolean

  • U: boolean

BooleanOr

BooleanOr<T, U>: T extends true ? true : U extends true ? true : false
example
  // Expect: true
type test1 = BooleanOr<true, false>
// Expect: false
type test2 = BooleanOr<false, false>
// Expect: true
type test3 = BooleanOr<false, true>
// Expect: true
type test4 = BooleanOr<true, true>

Type parameters

  • T: boolean

  • U: boolean

BooleanNor

BooleanNor<T, U>: T extends true ? false : U extends true ? false : true
example
  // Expect: false
type test1 = BooleanNor<true, false>
// Expect: true
type test2 = BooleanNor<false, false>
// Expect: false
type test3 = BooleanNor<false, true>
// Expect: false
type test4 = BooleanNor<true, true>

Type parameters

  • T: boolean

  • U: boolean

BooleanXor

BooleanXor<T, U>: T extends true ? U extends true ? false : true : U extends true ? true : false
example
  // Expect: true
type test1 = BooleanXor<true, false>
// Expect: false
type test2 = BooleanXor<false, false>
// Expect: true
type test3 = BooleanXor<false, true>
// Expect: false
type test4 = BooleanXor<true, true>

Type parameters

  • T: boolean

  • U: boolean

BooleanXnor

BooleanXnor<T, U>: T extends true ? U extends true ? true : false : U extends true ? false : true
example
  // Expect: false
type test1 = BooleanXnor<true, false>
// Expect: true
type test2 = BooleanXnor<false, false>
// Expect: false
type test3 = BooleanXnor<false, true>
// Expect: true
type test4 = BooleanXnor<true, true>

Type parameters

  • T: boolean

  • U: boolean

AnyConstructor

AnyConstructor: new (...args: any[]) => any

Type declaration

    • new (...args: any[]): any
    • Parameters

      • Rest ...args: any[]

      Returns any

AnyConstructorOf

AnyConstructorOf<TargetClass>: new (...args: any[]) => TargetClass

Type parameters

  • TargetClass

Type declaration

    • new (...args: any[]): TargetClass
    • Parameters

      • Rest ...args: any[]

      Returns TargetClass

ConstructorOf

ConstructorOf<TargetClass, ARGS>: new (...args: ARGS) => TargetClass

Type parameters

  • TargetClass = any

  • ARGS: any[] = any[]

Type declaration

    • new (...args: ARGS): TargetClass
    • Parameters

      • Rest ...args: ARGS

      Returns TargetClass

SynthesizeEvent

SynthesizeEvent<Patch>: Event & { target: Patch }

Type parameters

  • Patch

EventHandler

EventHandler<Target>: (event: SynthesizeEvent<Target>) => void

Type parameters

  • Target: EventTarget | null = EventTarget | null

Type declaration

AnyFunction

AnyFunction: (...args: any[]) => any

Type declaration

    • (...args: any[]): any
    • Parameters

      • Rest ...args: any[]

      Returns any

AnyFunctionOfTake

AnyFunctionOfTake<A>: A extends any[] ? IsUnion<A> extends true ? (...args: [...A]) => any : (arg: A) => any : (arg: A) => any

Type parameters

  • A

AnyFunctionOfReturn

AnyFunctionOfReturn<T>: (...args: any[]) => T

Type parameters

  • T

Type declaration

    • (...args: any[]): T
    • Parameters

      • Rest ...args: any[]

      Returns T

Noop

Noop: (...args: any[]) => void

Type declaration

    • (...args: any[]): void
    • Parameters

      • Rest ...args: any[]

      Returns void

FunctionLength

FunctionLength<Target>: Target extends (...args: infer Parameters) => any ? Parameters["length"] : never
example
  type Temp = (a: number, b: string) => string
type Temp2 = (...arg: string[]) => string
// Expect: 2
type test1 = FunctionLength<Temp>
// Expect: number
type test2 = FunctionLength<Temp2>

Type parameters

  • Target

PredicateTypeOf

PredicateTypeOf<Predicator>: Predicator extends (target: unknown, ...rest: any[]) => target is infer P ? P : never

Type parameters

FunctionPromisify

FunctionPromisify<Target>: (...args: Parameters<Target>) => Promise<ReturnType<Target>>

Type parameters

Type declaration

    • (...args: Parameters<Target>): Promise<ReturnType<Target>>
    • example
        type Temp = (a: number, b: string) => string
      // Expect: (a: number, b: string) => Promise<string>
      type test1 = FunctionPromisify<Temp>

      Parameters

      • Rest ...args: Parameters<Target>

      Returns Promise<ReturnType<Target>>

Has

Has<T, U>: IsAny<T> extends true ? true : IsAny<U> extends true ? false : Extract<T, U> extends never ? false : true

Checks if type T has the specified type U.

see

Copyright - The code is copy from https://github.com/dsherret/conditional-type-checks/blob/fc9ed57bc0b5a65bc1e3bfcbc5299a7c157b2e2e/mod.ts#L26

Type parameters

  • T

  • U

NotHas

NotHas<T, U>: Has<T, U> extends false ? true : false

Checks if type T does not have the specified type U.

see

Copyright - The code is copy from https://github.com/dsherret/conditional-type-checks/blob/fc9ed57bc0b5a65bc1e3bfcbc5299a7c157b2e2e/mod.ts#L34

Type parameters

  • T

  • U

StrictOmit

StrictOmit<T, K>: Omit<T, K>

Strict version of Omit, K must be subset of typeof T.

Type parameters

  • T

  • K: keyof T

StringRecord

StringRecord<T>: Record<string, T>

Type parameters

  • T

NumberRecord

NumberRecord<T>: Record<number, T>

Type parameters

  • T

SymbolRecord

SymbolRecord<T>: Record<symbol, T>

Type parameters

  • T

HybridRecord

HybridRecord<T>: Record<string | number | symbol, T>

Type parameters

  • T

AnyStringRecord

AnyStringRecord: StringRecord<any>

AnyNumberRecord

AnyNumberRecord: NumberRecord<any>

AnySymbolRecord

AnySymbolRecord: SymbolRecord<any>

AnyHybridRecord

AnyHybridRecord: Record<string | number | symbol, any>

AnyRecordUnion

ObjectPrettify

ObjectPrettify<Target>: Pick<Target, keyof Target>

Type parameters

UndefinedableByKeys

UndefinedableByKeys<Target, Keys>: { [ Key in keyof Target]: Key extends Keys ? Undefinedable<Target[Key]> : Target[Key] }
example
  interface Temp { a: string, b: number, c?: boolean }
// Expect to be: { a: string | undefined, b: number, c?: boolean }
type test1 = UndefinedableByKeys<Temp, 'a'>

Type parameters

  • Target

  • Keys

UndefinedableAllKeys

UndefinedableAllKeys<Target>: UndefinedableByKeys<Target, keyof Target>

Type parameters

  • Target

NullableByKeys

NullableByKeys<Target, Keys>: { [ Key in keyof Target]: Key extends Keys ? Nullable<Target[Key]> : Target[Key] }
example
  interface Temp { a: string, b: number, c?: boolean }
// Expect to be: { a: string | null, b: number, c?: boolean }
type test1 = NullableByKeys<Temp, 'a'>

Type parameters

  • Target

  • Keys

NullableAllKeys

NullableAllKeys<Target>: NullableByKeys<Target, keyof Target>

Type parameters

  • Target

NilableByKeys

NilableByKeys<Target, Keys>: { [ Key in keyof Target]: Key extends Keys ? Nilable<Target[Key]> : Target[Key] }
example
  interface Temp { a: string, b: number, c?: boolean }
// Expect to be: { a: string | null | undefined, b: number, c?: boolean }
type test1 = NilableByKeys<Temp, 'a'>

Type parameters

  • Target

  • Keys

NilableAllKeys

NilableAllKeys<Target>: NilableByKeys<Target, keyof Target>

Type parameters

  • Target

NonUndefinedableAllKeys

NonUndefinedableAllKeys<Target>: { [ Key in keyof Target]: NonUndefinedable<Target[Key]> }
example
  interface Temp { a: string | undefined, b: number, c?: boolean | undefined }
// Expect to be: { a: string, b: number, c?: boolean }
type test1 = NonUndefinedableAllKeys<Temp>

Type parameters

  • Target

NonUndefinedableByKeys

NonUndefinedableByKeys<Target, Keys>: ObjectPrettify<NonUndefinedableAllKeys<Pick<Target, SetIntersection<RequiredKeys<Target>, Keys>>> & Pick<Target, SetDifference<RequiredKeys<Target>, Keys>> & Partial<NonUndefinedableAllKeys<Pick<Target, SetIntersection<OptionalKeys<Target>, Keys>>>> & Pick<Target, SetDifference<OptionalKeys<Target>, Keys>>>
example
  interface Temp { a: string | undefined, b: number, c?: boolean }
// Expect to be: { a: string, b: number, c?: boolean }
type test1 = NonUndefinedableByKeys<Temp, 'a'>
type test2 = NonUndefinedableByKeys<Temp, 'a' | 'b'>

interface Temp { a: string | undefined, b: number, c?: boolean | undefined }
// Expect to be: { a: string, b: number, c?: boolean }
type test3 = NonUndefinedableByKeys<Temp, 'a' | 'c'>
// Expect to be: { a: string | undefined, b: number, c?: boolean }
type test4 = NonUndefinedableByKeys<Temp, 'c'>

Type parameters

  • Target

  • Keys

NonNullableAllKeys

NonNullableAllKeys<Target>: { [ Key in keyof Target]: NonNullable<Target[Key]> }
example
  interface Temp { a: string | null, b: number, c?: boolean | null }
// Expect to be: { a: string, b: number, c?: boolean }
type test1 = NonNullableAllKeys<Temp>

Type parameters

  • Target

NonNullableByKeys

NonNullableByKeys<Target, Keys>: ObjectPrettify<NonNullableAllKeys<Pick<Target, SetIntersection<RequiredKeys<Target>, Keys>>> & Pick<Target, SetDifference<RequiredKeys<Target>, Keys>> & Partial<NonNullableAllKeys<Pick<Target, SetIntersection<OptionalKeys<Target>, Keys>>>> & Pick<Target, SetDifference<OptionalKeys<Target>, Keys>>>
example
  interface Temp { a: string | null, b: number, c?: boolean }
// Expect to be: { a: string, b: number, c?: boolean }
type test1 = NonNullableByKeys<Temp, 'a'>
type test2 = NonNullableByKeys<Temp, 'a' | 'b'>

interface Temp { a: string | null, b: number, c?: boolean | null }
// Expect to be: { a: string, b: number, c?: boolean }
type test3 = NonNullableByKeys<Temp, 'a' | 'c'>
// Expect to be: { a: string | null, b: number, c?: boolean }
type test4 = NonNullableByKeys<Temp, 'c'>

Type parameters

  • Target

  • Keys

NonNilableAllKeys

NonNilableAllKeys<Target>: { [ Key in keyof Target]: NonNilable<Target[Key]> }
example
  interface Temp { a: string | null | undefined, b: number, c?: boolean | null }
// Expect to be: { a: string, b: number, c?: boolean }
type test1 = NonNilableAllKeys<Temp>

Type parameters

  • Target

NonNilableByKeys

NonNilableByKeys<Target, Keys>: ObjectPrettify<NonNilableAllKeys<Pick<Target, SetIntersection<RequiredKeys<Target>, Keys>>> & Pick<Target, SetDifference<RequiredKeys<Target>, Keys>> & Partial<NonNilableAllKeys<Pick<Target, SetIntersection<OptionalKeys<Target>, Keys>>>> & Pick<Target, SetDifference<OptionalKeys<Target>, Keys>>>
example
  interface Temp { a: string | null | undefined, b: number, c?: boolean }
// Expect to be: { a: string, b: number, c?: boolean }
type test1 = NonNilableByKeys<Temp, 'a'>
type test2 = NonNilableByKeys<Temp, 'a' | 'b'>

interface Temp { a: string | null | undefined, b: number, c?: boolean | null | undefined }
// Expect to be: { a: string, b: number, c?: boolean }
type test3 = NonNilableByKeys<Temp, 'a' | 'c'>
// Expect to be: { a: string | null | undefined, b: number, c?: boolean }
type test4 = NonNilableByKeys<Temp, 'c'>

Type parameters

  • Target

  • Keys

ReadonlyAllKeys

ReadonlyAllKeys<Target>: { readonly [ Key in keyof Target]: Target[Key] }
example
 interface Temp { a?: string | undefined, b?: number, c?: boolean }
// Expect to be: { readonly a: string | undefined, readonly b: number, readonly c: boolean }
type test1 = ReadonlyAllKeys<Temp>

Type parameters

  • Target

ReadonlyByKeys

ReadonlyByKeys<Target, Keys>: ObjectPrettify<ReadonlyAllKeys<Pick<Target, SetIntersection<keyof Target, Keys>>> & Pick<Target, SetDifference<keyof Target, Keys>>>
example
 interface Temp { a?: string | undefined, b?: number, c?: boolean }
// Expect to be: { readonly a: string | undefined, readonly b: number, readonly c: boolean }
type test1 = ReadonlyByKeys<Temp, 'a' | 'b' | 'c'>

Type parameters

  • Target

  • Keys

WritableAllKeys

WritableAllKeys<Target>: { -readonly [ Key in keyof Target]: Target[Key] }
example
 interface Temp { readonly a?: string | undefined, readonly b?: number, readonly c?: boolean }
// Expect to be: { a: string | undefined, b: number, c: boolean }
type test1 = WritableAllKeys<Temp>

Type parameters

  • Target

WritableByKeys

WritableByKeys<Target, Keys>: ObjectPrettify<WritableAllKeys<Pick<Target, SetIntersection<keyof Target, Keys>>> & Pick<Target, SetDifference<keyof Target, Keys>>>
example
 interface Temp { readonly a?: string | undefined, readonly b?: number, readonly c?: boolean }
// Expect to be: { a: string | undefined, b: number, c: boolean }
type test1 = WritableByKeys<Temp, 'a' | 'b' | 'c'>

Type parameters

  • Target

  • Keys

RequiredAllKeys

RequiredAllKeys<Target>: { [ Key in keyof Target]-?: Target[Key] }
example
 interface Temp { a?: string | undefined, b?: number, c?: boolean }
// Expect to be: { a: string | undefined, b: number, c: boolean }
type test1 = RequiredAllKeys<Temp>

Type parameters

  • Target

RequiredByKeys

RequiredByKeys<Target, Keys>: ObjectPrettify<RequiredAllKeys<Pick<Target, SetIntersection<keyof Target, Keys>>> & Pick<Target, SetDifference<keyof Target, Keys>>>
example
 interface Temp { a?: string | undefined, b?: number, c?: boolean }
// Expect to be: { a: string | undefined, b: number, c: boolean }
type test1 = RequiredByKeys<Temp, 'a' | 'b' | 'c'>

Type parameters

  • Target

  • Keys

OptionalAllKeys

OptionalAllKeys<Target>: { [ Key in keyof Target]?: Target[Key] }
example
 interface Temp { a: string | undefined, b: number, c?: boolean | undefined }
// Expect to be: { a?: string | undefined, b?: number, c?: boolean | undefined }
type test1 = OptionalAllKeys<Temp>

Type parameters

  • Target

OptionalByKeys

OptionalByKeys<Target, Keys>: ObjectPrettify<OptionalAllKeys<Pick<Target, SetIntersection<keyof Target, Keys>>> & Pick<Target, SetDifference<keyof Target, Keys>>>
example
 interface Temp { a: string | undefined, b: number, c?: boolean | undefined }
// Expect to be: { a?: string | undefined, b?: number, c?: boolean }
type test1 = OptionalByKeys<Temp, 'a' | 'b' | 'c'>

Type parameters

  • Target

  • Keys

ReverseOptional

ReverseOptional<Target>: ObjectPrettify<Required<Pick<Target, OptionalKeys<Target>>> & OptionalAllKeys<Omit<Target, OptionalKeys<Target>>>>

Given a type { a?: string, b: number }, return { a: string, b?: number }.

see

ReverseRequired

see

Reference - The solution is refer to https://stackoverflow.com/questions/57593022/reverse-required-and-optional-properties

Type parameters

  • Target

ReverseRequired

ReverseRequired<Target>: ReverseOptional<Target>

Type parameters

  • Target

ReverseOptionalByKeys

ReverseOptionalByKeys<Target, Keys>: ObjectPrettify<Omit<Target, Keys> & ReverseOptional<Pick<Target, Keys>>>
example
  interface Temp { a: string, b?: number, c?: boolean }

// Expect: { a: string, b: number, c?: boolean }
type test1 = ReverseOptionalByKeys<Temp, 'b'>

Type parameters

  • Target

  • Keys: keyof Target

ReverseRequiredByKeys

ReverseRequiredByKeys<Target, Keys>: ReverseOptionalByKeys<Target, Keys>

Type parameters

  • Target

  • Keys: keyof Target

ObjectKeys

ObjectKeys<Target>: Target extends AnyHybridRecord ? keyof Target : never

ObjectValues

description

Get the union type of all the values in target object.

example
  interface Props { name: string, age: number, visible: boolean }
// Expect: 'name' | 'age' | 'visible'
type Keys = ObjectKeys<Props>

Type parameters

  • Target

ObjectValues

ObjectValues<Target>: Target extends AnyHybridRecord ? Target[keyof Target] : never

ObjectValues

description

Get the union type of all the values in target object.

example
  interface Props { name: string, age: number, visible: boolean }
// Expect: string | number | boolean
type PropsValues = ObjectValues<Props>

Type parameters

  • Target

FunctionKeys

FunctionKeys<Target>: { [ Key in keyof Target]-?: NonUndefinedable<Target[Key]> extends Function ? Key : never }[keyof Target]

FunctionKeys

description

Get union type of keys that are functions in object type Target

example
 type MixedProps = {name: string; setName: (name: string) => void; someKeys?: string; someFn?: (...args: any) => any;};

// Expect: "setName | someFn"
type Keys = FunctionKeys<MixedProps>
see

Copyright - The code is copy from https://github.com/piotrwitek/utility-types/blob/master/src/mapped-types.ts

Type parameters

NonFunctionKeys

NonFunctionKeys<Target>: { [ Key in keyof Target]-?: NonUndefinedable<Target[Key]> extends Function ? never : Key }[keyof Target]

NonFunctionKeys

description

Get union type of keys that are non-functions in object type Target

example
  type MixedProps = {name: string; setName: (name: string) => void; someKeys?: string; someFn?: (...args: any) => any;};

// Expect: "name | someKey"
type Keys = NonFunctionKeys<MixedProps>
see

Copyright - The code is copy from https://github.com/piotrwitek/utility-types/blob/master/src/mapped-types.ts

Type parameters

ReadonlyKeys

ReadonlyKeys<Target>: { [ Key in keyof Target]-?: IfEquals<{ [ Q in Key]: Target[Key] }, { -readonly [ Q in Key]: Target[Key] }, never, Key> }[keyof Target]

ReadonlyKeys

description

Get union type of keys that are readonly in object type Target Credit: Matt McCutchen https://stackoverflow.com/questions/52443276/how-to-exclude-getter-only-properties-from-type-in-typescript

example
  type Props = { readonly foo: string; bar: number };

// Expect: "foo"
type Keys = ReadonlyKeys<Props>
see

Copyright - The code is copy from https://github.com/piotrwitek/utility-types/blob/master/src/mapped-types.ts

Type parameters

WritableKeys

WritableKeys<Target>: { [ Key in keyof Target]-?: IfEquals<{ [ Q in Key]: Target[Key] }, { -readonly [ Q in Key]: Target[Key] }, Key, never> }[keyof Target]

WritableKeys

description

Get union type of keys that are mutable in object type Target Credit: Matt McCutchen https://stackoverflow.com/questions/52443276/how-to-exclude-getter-only-properties-from-type-in-typescript

example
  interface Props { readonly foo: string, bar: number }

// Expect: "bar"
type Keys = WritableKeys<Props>
see

Copyright - The code is copy from https://github.com/piotrwitek/utility-types/blob/master/src/mapped-types.ts

Type parameters

RequiredKeys

RequiredKeys<Target>: { [ Key in keyof Target]-?: Record<string | number | symbol, never> extends Pick<Target, Key> ? never : Key }[keyof Target]

RequiredKeys

description

Get union type of keys that are required in object type Target

see

https://stackoverflow.com/questions/52984808/is-there-a-way-to-get-all-required-properties-of-a-typescript-object

example
  type Props = { req: number; reqUndef: number | undefined; opt?: string; optUndef?: number | undefined; };

// Expect: "req" | "reqUndef"
type Keys = RequiredKeys<Props>
see

Copyright - The code is copy from https://github.com/piotrwitek/utility-types/blob/master/src/mapped-types.ts

Type parameters

  • Target

OptionalKeys

OptionalKeys<Target>: { [ Key in keyof Target]-?: Record<string | number | symbol, never> extends Pick<Target, Key> ? Key : never }[keyof Target]

OptionalKeys

description

Get union type of keys that are optional in object type Target

see

https://stackoverflow.com/questions/52984808/is-there-a-way-to-get-all-required-properties-of-a-typescript-object

example
  type Props = { req: number; reqUndef: number | undefined; opt?: string; optUndef?: number | undefined; };

// Expect: "opt" | "optUndef"
type Keys = OptionalKeys<Props>
see

Copyright - The code is copy from https://github.com/piotrwitek/utility-types/blob/master/src/mapped-types.ts

Type parameters

  • Target

PickKeysByValue

PickKeysByValue<Target, ValueType>: { [ Key in keyof Target]-?: Target[Key] extends ValueType ? Key : never }[keyof Target]

PickKeysByValue

example
  interface Temp { req: number, reqUndef: number | undefined, opt?: string }
// Expect: 'req'
type test1 = PickKeysByValue<Temp, number>
// Expect: 'req' | 'reqUndef'
type test2 = PickKeysByValue<Temp, number | undefined>
attention

(For ALL ByValue utilities) When we want to get 'opt' as result in above example, PickKeysByValue<Temp, string> will not work. We should use PickKeysByValue<Temp, string | undefined> instead. It's so weird that we don't always know whether the target key is optional or not in actual most of situations so we have to include undefined in the target matching ValueType's union. It's unnecessary and redundant.

       On the other hand, normal keys and optional keys are quite different. We indeed need an approach to
distinguish them. Seems like add `undefined` to the union of optional keys' value type is a reasonable way.

Here our final choice is give `undefined` a chance until we get a more fantastic solution. Meanwhile, turn the
`exactOptionalPropertyTypes: true` typescript's compiler option on. It will make the use of `undefined` on optional
properties more reasonable. For more information on it: see <a href="https://www.typescriptlang.org/tsconfig#exactOptionalPropertyTypes" class="external">https://www.typescriptlang.org/tsconfig#exactOptionalPropertyTypes</a>,
there's also a use guide on that information, see <a href="https://tkdodo.eu/blog/optional-vs-undefined" class="external">https://tkdodo.eu/blog/optional-vs-undefined</a>.

Type parameters

  • Target

  • ValueType

PickByValue

PickByValue<Target, ValueType>: Pick<Target, PickKeysByValue<Target, ValueType>>

PickByValue

description

From Target pick a set of properties by value matching ValueType. Credit: Piotr Lewandowski

example
  interface Temp { req: number, reqUndef: number | undefined, opt?: string }

// Expect: { req: number }
type test1 = PickByValue<Temp, number>
// Expect: { req: number; reqUndef: number | undefined; }
type test2 = PickByValue<Temp, number | undefined>
see

Type parameters

  • Target

  • ValueType

PickKeysByValueExact

PickKeysByValueExact<Target, ValueType>: { [ Key in keyof Target]-?: [ValueType] extends [Target[Key]] ? [Target[Key]] extends [ValueType] ? Key : never : never }[keyof Target]

PickKeysByValue

example
  interface Temp { req: number, reqUndef: number | undefined, opt?: string }
// Expect: 'req'
type test1 = PickKeysByValue<Temp, number>
// Expect: 'reqUndef'
type test2 = PickKeysByValue<Temp, number | undefined>

Type parameters

  • Target

  • ValueType

PickByValueExact

PickByValueExact<Target, ValueType>: Pick<Target, PickKeysByValueExact<Target, ValueType>>

PickByValueExact

description

From Target pick a set of properties by value matching exact ValueType.

example
  interface Temp { req: number, reqUndef: number | undefined, opt?: string }

// Expect: { req: number }
type test1 = PickByValueExact<Temp, number>
// Expect: { reqUndef: number | undefined; }
type test2 = PickByValueExact<Temp, number | undefined>
see

Copyright - The code is copy from https://github.com/piotrwitek/utility-types/blob/master/src/mapped-types.ts

Type parameters

  • Target

  • ValueType

OmitByValue

OmitByValue<Target, ValueType>: Omit<Target, PickKeysByValue<Target, ValueType>>

OmitByValue

description

From Target remove a set of properties by value matching ValueType. Credit: Piotr Lewandowski

example
  interface Temp { req: number, reqUndef: number | undefined, opt?: string }

// Expect: { reqUndef: number | undefined; opt?: string; }
type test1 = OmitByValue<Temp, number>
// Expect: { opt?: string; }
type test2 = OmitByValue<Temp, number | undefined>
see

Type parameters

  • Target

  • ValueType

OmitByValueExact

OmitByValueExact<Target, ValueType>: Omit<Target, PickKeysByValueExact<Target, ValueType>>

OmitByValueExact

description

From Target remove a set of properties by value matching exact ValueType.

example
  interface Temp { req: number, reqUndef: number | undefined, opt?: string }

// Expect: { reqUndef: number | undefined; opt?: string; }
type test1 = OmitByValueExact<Temp, number>
// Expect: { req: number; opt?: string }
type test2 = OmitByValueExact<Temp, number | undefined>
see

Copyright - The code is copy from https://github.com/piotrwitek/utility-types/blob/master/src/mapped-types.ts

Type parameters

  • Target

  • ValueType

ObjectIntersection

ObjectIntersection<T, U>: Pick<T, SetIntersection<keyof T, keyof U>>

ObjectIntersection

description

From T pick properties that exist in U.

example
  type Props = { name: string; age: number; visible: boolean };
type DefaultProps = { age: number };

// Expect: { age: number; }
type DuplicateProps = ObjectIntersection<Props, DefaultProps>
see

Copyright - The code is copy from https://github.com/piotrwitek/utility-types/blob/master/src/mapped-types.ts

Type parameters

ObjectDifference

ObjectDifference<T, U>: Pick<T, SetDifference<keyof T, keyof U>>

ObjectDifference

description

From T remove properties that exist in U.

example
  type Props = { name: string; age: number; visible: boolean };
type DefaultProps = { age: number };

// Expect: { name: string; visible: boolean; }
type DiffProps = ObjectDifference<Props, DefaultProps>
see

Copyright - The code is copy from https://github.com/piotrwitek/utility-types/blob/master/src/mapped-types.ts

Type parameters

ObjectComplement

ObjectComplement<T, SuperT>: Pick<T, SetComplement<keyof T, keyof SuperT>>

ObjectComplement

description

From T remove properties that exist in SuperT (SuperT has a subset of the properties of T)

example
  type Props = { name: string; age: number; visible: boolean };
type DefaultProps = { age: number };

// Expect: { name: string; visible: boolean; }
type RestProps = ObjectComplement<Props, DefaultProps>
see

Copyright - The code is copy from https://github.com/piotrwitek/utility-types/blob/master/src/mapped-types.ts

Type parameters

ObjectSymmetricDifference

ObjectSymmetricDifference<T, U>: ObjectPrettify<ObjectDifference<T, U> & ObjectDifference<U, T>>

ObjectSymmetricDifference

example
  interface PropsA { name: string, age: number, visible: boolean }
interface PropsB { age: number, sex: string }

// Expect: { name: string; visible: boolean; sex: string };
type ResultProps = ObjectSymmetricDifference<PropsA, PropsB>
// Expect: 'name' | 'visible' | 'sex'
type ResultProps = keyof ObjectSymmetricDifference<PropsA, PropsB>

Type parameters

ObjectOverwrite

ObjectOverwrite<Target, Patch>: ObjectPrettify<ObjectDifference<Target, Patch> & ObjectIntersection<Patch, Target>>

ObjectOverwrite

description

From U overwrite properties to T.

example
  interface Props { name: string, age: number, visible: boolean }
interface NewProps { age: string, other: string }

// Expect: { name: string; age: string; visible: boolean; }
type ReplacedProps = ObjectOverwrite<Props, NewProps>
see

Copyright - The code is copy from https://github.com/piotrwitek/utility-types/blob/master/src/mapped-types.ts

Type parameters

ObjectAssign

ObjectAssign<Target, Patch>: ObjectPrettify<Omit<Target, keyof Patch> & Patch>

ObjectAssign

description

From U assign properties to T (just like object assign).

example
  interface Props { name: string, age: number, visible: boolean }
interface NewProps { age: string, other: string }

// Expect: { name: string; age: string; visible: boolean; other: string; }
type ExtendedProps = ObjectAssign<Props, NewProps>
see

Copyright - The code is copy from https://github.com/piotrwitek/utility-types/blob/master/src/mapped-types.ts

Type parameters

ObjectMerge

ObjectMerge<Target, Patch>: ObjectAssign<Target, Patch>

Alias for ObjectAssign, defined for semantic of ObjectMergeN.

see

ObjectAssign

Type parameters

ObjectMergeN

ObjectMergeN<Targets>: ObjectPrettify<_ObjectMergeN<Targets, {}>>
example
  interface a { a: string }
interface b { readonly b: string }
interface c { c?: string }
// Expect: { a: string; readonly b: string; c?: string; }
type Result = ObjectMergeN<[a, b, c]>

Type parameters

ObjectUnionize

ObjectUnionize<Target>: { [ Key in keyof Target]: { [ Q in Key]: Target[Key] } }[keyof Target]

ObjectUnionize

desc

Disjoin object to form union of objects, each with single property.

example
  interface Props { name: string, age: number, visible: boolean }

// Expect: { name: string; } | { age: number; } | { visible: boolean; }
type UnionizedType = ObjectUnionize<Props>
see

Copyright - The code is copy from https://github.com/piotrwitek/utility-types/blob/master/src/mapped-types.ts

Type parameters

ObjectDeepWritable

ObjectDeepWritable<Target>: { -readonly [ Key in keyof Target]: Target[Key] extends AnyStringRecord | undefined ? ObjectDeepWritable<NonUndefinedable<Target[Key]>> : Target[Key] }
example
  interface Temp {
readonly grandpa: {
readonly name: string
father?: {
readonly name?: string
son: {
readonly name?: string
}
}
}
}
// Expect: { grandpa?: { name?: string, father?: { name?: string, son?: { name?: string } } } }
type test1 = ObjectDeepWritable<Temp>

Type parameters

ObjectDeepReadonly

ObjectDeepReadonly<Target>: { readonly [ Key in keyof Target]: Target[Key] extends AnyStringRecord | undefined ? ObjectDeepReadonly<NonUndefinedable<Target[Key]>> : Target[Key] }
example
  interface Temp {
grandpa: {
name: string
father?: {
name?: string
son: {
name?: string
}
}
}
}
// Expect: { readonly grandpa?: {
// readonly name?: string, readonly father?: { readonly name?: string, readonly son?: { readonly name?: string } }
// } }
type test1 = ObjectDeepReadonly<Temp>

Type parameters

ObjectDeepRequired

ObjectDeepRequired<Target>: { [ Key in keyof Target]-?: Target[Key] extends AnyStringRecord | undefined ? ObjectDeepRequired<NonUndefinedable<Target[Key]>> : Target[Key] }
example
  interface Temp {
grandpa: {
name: string
father?: {
name?: string
son: {
name?: string
}
}
}
}
// Expect: { grandpa: { name: string, father: { name: string, son: { name: string } } } }
type test1 = ObjectDeepRequired<Temp>

Type parameters

ObjectDeepOptional

ObjectDeepOptional<Target>: { [ Key in keyof Target]?: Target[Key] extends AnyStringRecord | undefined ? ObjectDeepOptional<NonUndefinedable<Target[Key]>> : Target[Key] }
example
  interface Temp {
grandpa: {
name: string
father?: {
name?: string
son: {
name?: string
}
}
}
}
// Expect: { grandpa?: { name?: string, father?: { name?: string, son?: { name?: string } } } }
type test1 = ObjectDeepOptional<Temp>

Type parameters

ObjectNonEmpty

ObjectNonEmpty<Target>: keyof Target extends never ? never : Target

If the Target is an empty Record/Object, then return never.

see

example - For usecases, see https://github.com/ts-essentials/ts-essentials#nonemptyobject

Type parameters

ObjectNamedKeys

ObjectNamedKeys<Target>: keyof { [ Key in keyof Target as string extends Key ? never : number extends Key ? never : symbol extends Key ? never : Key]: Target[Key] }

ObjectNamedKeys

example
  interface Temp {
name: string
age?: number
[key: string]: string | number
}
// Expect: 'name' | 'age'
type test1 = ObjectNamedKeys<Temp>
see

Copyright - The code is copy from https://github.com/millsp/ts-toolbelt/blob/319e55123b9571d49f34eca3e5926e41ca73e0f3/sources/Any/KnownKeys.ts#L11

see

Issue - https://github.com/millsp/ts-toolbelt/issues/164

see

Reference - https://stackoverflow.com/questions/51465182/how-to-remove-index-signature-using-mapped-types/51956054#51956054

Type parameters

  • Target

ObjectNamedParts

ObjectNamedParts<Target>: ObjectPrettify<Pick<Target, ObjectNamedKeys<Target>>>

Type parameters

  • Target

ObjectIndexedParts

ObjectIndexedParts<Target>: ObjectPrettify<Omit<Target, ObjectNamedKeys<Target>>>

Type parameters

  • Target

ObjectHasNamedKeys

ObjectHasNamedKeys<Target>: ObjectNamedKeys<Target> extends never ? false : true

Type parameters

  • Target

ObjectHasIndexedKeys

ObjectHasIndexedKeys<Target>: keyof ObjectIndexedParts<Target> extends never ? false : true

Type parameters

  • Target

Brand

Brand<Target, Token>: Token extends StringLiteral<Token> ? Target & { __brand__: Token } : never

Brand

desc

Define nominal type of U based on type of T. Similar to Opaque types in Flow.

example

type USD = Brand<number, "USD"> type EUR = Brand<number, "EUR">

const tax = 5 as USD; const usd = 10 as USD; const eur = 10 as EUR;

function gross(net: USD): USD { return (net + tax) as USD; }

// Expect: No compile error gross(usd); // Expect: Compile error (Type '"EUR"' is not assignable to type '"USD"'.) gross(eur);

see

Copyright - The code is copy from https://github.com/piotrwitek/utility-types/blob/master/src/mapped-types.ts , mixed with https://github.com/ts-essentials/ts-essentials/blob/5aa1f264e77fb36bb3f673c49f00927c7c181a7f/lib/types.ts#L416

see

Alternative - Name it as Type or Opaque, https://millsp.github.io/ts-toolbelt/modules/any_type.html

Type parameters

  • Target

  • Token: string

Exact

Exact<Target, Shape>: Target extends Shape ? Exclude<keyof Target, keyof Shape> extends never ? Target : never : never

Type parameters

  • Target

  • Shape

StringLiteral

StringLiteral<T>: T extends string ? string extends T ? never : T : never
example
  type Temp = 'mobius'
// Expect: 'mobius'
type test1 = StringLiteral<Temp>

Type parameters

  • T

Assert

Assert<Target, Expected>: never

Type parameters

  • Target: boolean

  • Expected: Target

AssertTrue

AssertTrue<Target>: never

Type parameters

  • Target: true

AssertFalse

AssertFalse<Target>: never

Type parameters

  • Target: false

First

First<Tuple, Default>: Tuple extends [any, ...any[]] ? Tuple[0] : Default
example
type Foo = First<['a', 'b', 'c']> // Expect: 'a'

Type parameters

  • Tuple: any[]

  • Default = never

Last

Last<Tuple, Default>: Tuple extends [] ? Default : Tuple extends [infer SoleElement] ? SoleElement : Tuple extends infer Element[] ? Element[] extends Tuple ? Element : Tuple extends [any, ...infer Next] ? Last<Next> : Default : never
example
type Foo = Last<['a', 'b', 'c']> // Expect: 'c'

Type parameters

  • Tuple: any[]

  • Default = never

StrictExtract

StrictExtract<T, U>: Extract<T, U>

Strict version of builtin Extract, U must be subset of T.

Type parameters

  • T

  • U: T

StrictExclude

StrictExclude<T, U>: Exclude<T, U>

Strict version of builtin Exclude, U must be subset of T.

Type parameters

  • T

  • U: T

SetIntersection

SetIntersection<SetA, SetB>: SetA extends SetB ? SetA : never

SetIntersection (same as Extract)

description

Set intersection of given union types SetA and SetB.

example
  // Expect: "2" | "3"
SetIntersection<'1' | '2' | '3', '2' | '3' | '4'>;

// Expect: () => void
SetIntersection<string | number | (() => void), Function>;
see

Copyright - The code is copy from https://github.com/piotrwitek/utility-types/blob/master/src/mapped-types.ts

Type parameters

  • SetA

  • SetB

SetDifference

SetDifference<SetA, SetB>: SetA extends SetB ? never : SetA

SetDifference (same as Exclude)

description

Set difference of given union types SetA and SetB.

example
  // Expect: "1"
SetDifference<'1' | '2' | '3', '2' | '3' | '4'>;

// Expect: string | number
SetDifference<string | number | (() => void), Function>;
see

Copyright - The code is copy from https://github.com/piotrwitek/utility-types/blob/master/src/mapped-types.ts

Type parameters

  • SetA

  • SetB

SetComplement

SetComplement<Set, SubSet>: SetDifference<Set, SubSet>

SetComplement

description

Set complement of given union types SetA and it's SubSet.

example
  // Expect: "1"
SetComplement<'1' | '2' | '3', '2' | '3'>;
see

Copyright - The code is copy from https://github.com/piotrwitek/utility-types/blob/master/src/mapped-types.ts

Type parameters

  • Set

  • SubSet: Set

SetSymmetricDifference

SetSymmetricDifference<SetA, SetB>: SetDifference<SetA | SetB, SetA & SetB>

SetSymmetricDifference

desc

Set difference of union and intersection of given union types SetA and SetB.

example
  // Expect: "1" | "4"
SymmetricDifference<'1' | '2' | '3', '2' | '3' | '4'>;
see

Copyright - The code is copy from https://github.com/piotrwitek/utility-types/blob/master/src/mapped-types.ts

Type parameters

  • SetA

  • SetB

UnionToIntersection

UnionToIntersection<Target>: (Target extends any ? (_: Target) => void : never) extends (_: infer Result) => void ? Result : never

UnionToIntersection

desc

Get intersection type given union type Target. Credit: jcalz

see

https://stackoverflow.com/a/50375286/7381355

example
  // Expect: { name: string } & { age: number } & { visible: boolean }
UnionToIntersection<{ name: string } | { age: number } | { visible: boolean }>
see

Copyright - The code is copy from https://github.com/piotrwitek/utility-types/blob/master/src/mapped-types.ts

Type parameters

  • Target

UnionHas

UnionHas<T, U>: [U] extends [T] ? true : false

Type parameters

  • T

  • U

DataLike

DataLike<V>: Data<V> | DataMediator<V>

Type parameters

  • V = any

MutationLike

MutationLike<P, C>: Mutation<P, C> | MutationMediator<P, C>

Type parameters

  • P = any

  • C = any

AtomLikeOfAny

AtomLikeOfAny: Data<any> | DataMediator<any> | Mutation<any, any> | MutationMediator<any, any>

AtomLike that can take any as input and any as output.

AtomLikeOfInput

AtomLikeOfInput<I>: Data<I> | DataMediator<I> | Mutation<I, any> | MutationMediator<I, any>

AtomLike that can take I as input.

Type parameters

  • I = any

AtomLikeOfOutput

AtomLikeOfOutput<O>: Data<O> | DataMediator<O> | Mutation<any, O> | MutationMediator<any, O>

AtomLike that can emit O as output.

Type parameters

  • O = any

InternalTrigger

InternalTrigger<Accepted>: (accepted: Accepted, ...args: any[]) => void

Type parameters

  • Accepted = any

Type declaration

    • (accepted: Accepted, ...args: any[]): void
    • Parameters

      • accepted: Accepted
      • Rest ...args: any[]

      Returns void

Trigger

Trigger<Accepted>: (internalTrigger: InternalTrigger<Accepted>) => TriggerController

Type parameters

  • Accepted = any

Type declaration

DatarConsumer

DatarConsumer<V>: (datar: Datar<V>, data: DataLike<V>) => void

Type parameters

  • V = any

Type declaration

ValueConsumer

ValueConsumer<V>: (value: V, data: DataLike<V>) => void

Type parameters

  • V = any

Type declaration

    • Parameters

      Returns void

DataConsumer

DataConsumer<V>: DatarConsumer<V> | ValueConsumer<V>

Type parameters

  • V = any

DataTriggerAccepted

DataTriggerAccepted<V>: V | Datar<V>

Type parameters

  • V = any

DataTrigger

DataTrigger<V>: Trigger<DataTriggerAccepted<V>>

Type parameters

  • V = any

MutatorConsumer

MutatorConsumer<P, C>: (mutator: Mutator<P, C>, mutation: MutationLike<P, C>) => void

Type parameters

  • P = any

  • C = any

Type declaration

TransformationConsumer

TransformationConsumer<P, C>: (transformation: (current: Datar<C>, ...args: any[]) => C, mutation: MutationLike<P, C>) => void

Type parameters

  • P = any

  • C = any

Type declaration

    • (transformation: (current: Datar<C>, ...args: any[]) => C, mutation: MutationLike<P, C>): void
    • Parameters

      • transformation: (current: Datar<C>, ...args: any[]) => C
          • (current: Datar<C>, ...args: any[]): C
          • Parameters

            • current: Datar<C>
            • Rest ...args: any[]

            Returns C

      • mutation: MutationLike<P, C>

      Returns void

MutationConsumer

MutationConsumer<P, C>: MutatorConsumer<P, C> | TransformationConsumer<P, C>

Type parameters

  • P = any

  • C = any

MutationTriggerAccepted

MutationTriggerAccepted<P, C>: Mutator<P, C> | ((...args: any[]) => C) | C

Type parameters

  • P = any

  • C = any

MutationTrigger

MutationTrigger<P, C>: Trigger<MutationTriggerAccepted<P, C>>

Type parameters

  • P = any

  • C = any

DriverMaker

DriverMaker<Options, Instance>: (options?: Options) => Instance

Type parameters

Type declaration

    • (options?: Options): Instance
    • Parameters

      • Optional options: Options

      Returns Instance

WrapDataInArray

WrapDataInArray<T>: IsArray<T> extends true ? T extends any[] ? T extends infer U[] ? WrapToData<U>[] : never : T extends ReadonlyArray<infer U> ? ReadonlyArray<WrapToData<U>> : never : IsTuple<T> extends true ? T extends any[] ? T extends [infer First, ...infer Rest] ? [WrapToData<First>, ...WrapDataInArray<Rest>] : [] : T extends readonly [infer First, ...infer Rest] ? readonly [WrapToData<First>, ...WrapDataInArray<Rest>] : readonly [] : never

Type parameters

  • T: readonly any[]

ForceWrapDataInArray

ForceWrapDataInArray<T>: IsArray<T> extends true ? T extends any[] ? T extends infer U[] ? Data<U>[] : never : T extends ReadonlyArray<infer U> ? ReadonlyArray<Data<U>> : never : IsTuple<T> extends true ? T extends any[] ? T extends [infer First, ...infer Rest] ? [Data<First>, ...ForceWrapDataInArray<Rest>] : [] : T extends readonly [infer First, ...infer Rest] ? readonly [Data<First>, ...ForceWrapDataInArray<Rest>] : readonly [] : never

Type parameters

  • T: readonly any[]

MutationToData

MutationToData<Target>: Target extends Mutation<any, infer C> ? Data<C> : Target extends ReplayMutationMediator<any, infer C> ? ReplayDataMediator<C> : never

Type parameters

  • Target = any

DataToMutation

DataToMutation<Target>: Target extends Data<infer V> ? Mutation<V, V> : Target extends ReplayDataMediator<infer V> ? ReplayMutationMediator<V, V> : never

Type parameters

  • Target = any

MediatorTypeMaker

MediatorTypeMaker<T>: T & _MediatorTypeSymbol

Type parameters

  • T: string

MediatorType

MediatorType: string & _MediatorTypeSymbol

ReplayMediatorUnion

ReplayMediatorUnion: ReplayDataMediator<any> | ReplayMutationMediator<any, any>

TriggerMediatorUnion

TriggerMediatorUnion: TriggerDataMediator<any> | TriggerMutationMediator<any, any>

OrMeta

OrMeta<T>: T | Meta

Type parameters

  • T

ExcludeMeta

ExcludeMeta<T>: Exclude<T, Meta>

Type parameters

  • T

Vacuo

Vacuo: ((...args: any[]) => Vacuo) & { __type__: "Vacuo" } & Meta

A value that can serve as the value (for Datar, or transformation for Mutator) of Datar and Mutator at the same time. Base on feature of "JavaScript Function is also an Object", Vacuo can be both Datar's and Mutator's value, says Empty Datar and Empty Mutator respectively.

Content security policy compatible version of Vacuo. The "class Vacuo extends Function" syntax can not use in strict browsers. reference: https://developer.chrome.com/docs/apps/contentSecurityPolicy/

TransformationLiftPositions

TransformationLiftPositions: "unknown" | "both" | "left" | "right" | "none"

MutatorTransformation

MutatorTransformation<P, C, Contexts>: (previous: Chaos | Datar<P>, current: Datar<C>, mutation?: MutationLike<P, C>, ...contexts: Contexts) => C

Type parameters

  • P = any

  • C = any

  • Contexts: any[] = any[]

Type declaration

LiftBothTransformation

LiftBothTransformation<P, C, Contexts>: (previous: Vacuo | P, current: C, mutation?: MutationLike<P, C>, ...contexts: Contexts) => C

Type parameters

  • P = any

  • C = any

  • Contexts: any[] = any[]

Type declaration

    • (previous: Vacuo | P, current: C, mutation?: MutationLike<P, C>, ...contexts: Contexts): C
    • Parameters

      • previous: Vacuo | P
      • current: C
      • Optional mutation: MutationLike<P, C>
      • Rest ...contexts: Contexts

      Returns C

LiftLeftTransformation

LiftLeftTransformation<P, C, Contexts>: (previous: Vacuo | P, current: Datar<C>, mutation?: MutationLike<P, C>, ...contexts: Contexts) => C

Type parameters

  • P = any

  • C = any

  • Contexts: any[] = any[]

Type declaration

LiftRightTransformation

LiftRightTransformation<P, C, Contexts>: (previous: Chaos | Datar<P>, current: C, mutation?: MutationLike<P, C>, ...contexts: Contexts) => C

Type parameters

  • P = any

  • C = any

  • Contexts: any[] = any[]

Type declaration

MutatorOriginalTransformationUnion

MutatorOriginalTransformationUnion<P, C, Contexts>: MutatorTransformation<P, C, Contexts> | LiftBothTransformation<P, C, Contexts> | LiftLeftTransformation<P, C, Contexts> | LiftRightTransformation<P, C, Contexts>

Type parameters

  • P = any

  • C = any

  • Contexts: any[] = any[]

Tache

Tache<Sources, Out>: (...sources: [...Sources]) => Out

Type parameters

  • Sources: any[] = any[]

  • Out = any

Type declaration

    • (...sources: [...Sources]): Out
    • Parameters

      • Rest ...sources: [...Sources]

      Returns Out

ArrayMSTache

ArrayMSTache<Ps, C, AN>: (...sources: WrapArrayToAtomLikeOfOutput<Ps, AN> | [WrapArrayToAtomLikeOfOutput<Ps, AN>]) => Data<C>

Type parameters

  • Ps

  • C

  • AN

    The type of acceptNonAtom

Type declaration

    • (...sources: WrapArrayToAtomLikeOfOutput<Ps, AN> | [WrapArrayToAtomLikeOfOutput<Ps, AN>]): Data<C>
    • Parameters

      • Rest ...sources: WrapArrayToAtomLikeOfOutput<Ps, AN> | [WrapArrayToAtomLikeOfOutput<Ps, AN>]

      Returns Data<C>

ObjectMSTache

ObjectMSTache<Ps, C, AN>: (sources: WrapObjectToAtomLikeOfOutput<Ps, AN>) => Data<C>

Type parameters

  • Ps

  • C

  • AN

    The type of acceptNonAtom

Type declaration

    • (sources: WrapObjectToAtomLikeOfOutput<Ps, AN>): Data<C>
    • Parameters

      • sources: WrapObjectToAtomLikeOfOutput<Ps, AN>

      Returns Data<C>

ArraySMTache

ArraySMTache<P>: (source: AtomLikeOfOutput<P>) => Data<any>[]

Type parameters

  • P = any

Type declaration

ObjectSMTache

ObjectSMTache<P>: (source: AtomLikeOfOutput<P>) => Record<string, Data<any>>

Type parameters

  • P = any

Type declaration

SSTache

SSTache<P, C>: (source: AtomLikeOfOutput<P>) => Data<C>

Type parameters

  • P = any

  • C = any

Type declaration

ClassString

ClassString: string

ClassArray

ClassArray: string[]

ClassObject

ClassObject: Record<string, boolean>

ClassUnion

EnvironmentUnion

EnvironmentUnion: "wxmina" | "web" | "node" | "unknown"

SyntheticDocumentEvent

SyntheticDocumentEvent: SynthesizeEvent<Document>

SyntheticWindowEvent

SyntheticWindowEvent: SynthesizeEvent<Window & typeof globalThis>

BiuRequestResource

BiuRequestResource: string

BiuRequestMethod

BiuRequestMethod: "get" | "GET" | "delete" | "DELETE" | "head" | "HEAD" | "options" | "OPTIONS" | "post" | "POST" | "put" | "PUT" | "patch" | "PATCH" | "purge" | "PURGE" | "link" | "LINK" | "unlink" | "UNLINK"

BiuRequestHeaders

BiuRequestHeaders: Record<string, string>

BiuRequestBody

BiuRequestBody: ReadableStream | Blob | BufferSource | FormData | URLSearchParams | string

BiuRequestMode

BiuRequestMode: "cors" | "navigate" | "no-cors" | "same-origin"

BiuRequestCredentials

BiuRequestCredentials: "include" | "omit" | "same-origin"

BiuResponseType

BiuResponseType: "text" | "json" | "arraybuffer" | "formdata" | "blob" | "stream"

BiuReceivedDataType

BiuReceivedDataType: "json" | "custom" | "other"

ConstructorOfRequestEngine

ConstructorOfRequestEngine<SuccessData, FailData, ErrorData, SendData>: ConstructorOf<RequestEngine, [options: Required<BiuOptions<SuccessData, FailData, ErrorData, SendData>>, contexts: RequestEngineContexts<SuccessData, FailData, ErrorData, SendData>]> & StaticRequestEngineClass

Type parameters

ResponseUnion

ResponseUnion<SD, FD, ED>: SuccessResponse<SD> | FailResponse<FD> | ErrorResponse<ED> | UnknownResponse<EmptyInterface>

Type parameters

CurriedNFunctionOrReturnValue

CurriedNFunctionOrReturnValue<EXPECTED_ARGS, RETURN_TYPE, PROVIDED, LOOSE>: GapsOf<PROVIDED, EXPECTED_ARGS, false> extends [any, ...any[]] ? CurriedNFunction<EXPECTED_ARGS, RETURN_TYPE, PROVIDED, LOOSE> : RETURN_TYPE

Type parameters

  • EXPECTED_ARGS: any[]

  • RETURN_TYPE: any

  • PROVIDED: any[]

  • LOOSE: boolean = false

CurriedNFunction

CurriedNFunction<EXPECTED_ARGS, RETURN_TYPE, PROVIDED, LOOSE>: <APPENDING_ARGS>(...args: APPENDING_ARGS) => ConcatGaps<PROVIDED, APPENDING_ARGS, true> extends infer ___ ? CurriedNFunctionOrReturnValue<EXPECTED_ARGS, RETURN_TYPE, Cast<___, any[]>, LOOSE> : never

Type parameters

  • EXPECTED_ARGS: any[]

  • RETURN_TYPE: any

  • PROVIDED: any[]

  • LOOSE: boolean = false

Type declaration

    • <APPENDING_ARGS>(...args: APPENDING_ARGS): ConcatGaps<PROVIDED, APPENDING_ARGS, true> extends infer ___ ? CurriedNFunctionOrReturnValue<EXPECTED_ARGS, RETURN_TYPE, Cast<___, any[]>, LOOSE> : never
    • Type parameters

      • APPENDING_ARGS: GapsOf<PROVIDED, EXPECTED_ARGS, LOOSE> extends infer __ ? LOOSE extends true ? Gaps<Loose<Cast<__, any[]>>> : Gaps<Cast<__, any[]>> : never

      Parameters

      • Rest ...args: APPENDING_ARGS

      Returns ConcatGaps<PROVIDED, APPENDING_ARGS, true> extends infer ___ ? CurriedNFunctionOrReturnValue<EXPECTED_ARGS, RETURN_TYPE, Cast<___, any[]>, LOOSE> : never

InvertFunctionReturn

InvertFunctionReturn<FN>: FN extends (...args: unknown[]) => infer R ? (...args: Parameters<FN>) => BooleanNot<CastBoolean<R>> : never

Type parameters

GuardCondition

GuardCondition<V>: [judgement: boolean, value: V]

Type parameters

  • V

CaseCondition

CaseCondition<P, V>: [predicate: (predicated?: P) => boolean, value: V]

Type parameters

  • P

  • V

PropPath

PropPath: number | string | (number | string)[]

Functions

Const isExactType

  • isExactType<ExpectedShape>(): <ActualShape>(x: Exact<ActualShape, ExpectedShape>) => ExpectedShape

Const typeAssert

  • typeAssert<T>(expectTrue: T): void

Const isAtomLike

  • isAtomLike(target: any): target is AtomLike
  • Target will be considered AtomLike when its isAtom property is true, etc. Data, Mutation, DataMediator, MutationMediator.

    Parameters

    • target: any

    Returns target is AtomLike

isDataLike

isMutationLike

Const isAtom

isData

  • isData<V>(target: Data<V>): target is Data<V>
  • isData<V>(target: unknown): target is Data<V>

isMutation

  • isMutation<P, C>(target: Mutation<P, C>): target is Mutation<P, C>
  • isMutation<P, C>(target: unknown): target is Mutation<P, C>

Const createGeneralDriver

  • createGeneralDriver<Options, DLC, DSLC, Instance>(createOptions?: GeneralDriverCreateOptions<Options, DLC, DSLC, Instance> | PrepareDriverSingletonLevelContexts<Options, DLC, DSLC>): DriverMaker<Options, Instance>

Const connectDriverInterfaces

  • connectDriverInterfaces(up: AtomLike, down: any): void
  • connectDriverInterfaces(up: any, down: AtomLike): void
  • connectDriverInterfaces(up: Record<string, any>, down: Record<string, any>): void
  • connectDriverInterfaces(up: any[], down: any[]): void

Const useGeneralDriver

  • useGeneralDriver<Options, Instance>(driver: DriverMaker<Options, Instance>, driverOptions: undefined | Options, interfaces: ConnectedInterfacesOf<Instance>): Instance

Const useGeneralDriver_

  • useGeneralDriver_<Options, Instance>(driver: DriverMaker<Options, Instance>, driverOptions: undefined | Options, interfaces: ConnectedInterfacesOf<Instance>): Instance
  • useGeneralDriver_<Options, Instance>(driver: DriverMaker<Options, Instance>, driverOptions: undefined | Options): (interfaces: ConnectedInterfacesOf<Instance>) => Instance
  • useGeneralDriver_<Options, Instance>(driver: DriverMaker<Options, Instance>): IPartialUseGeneralDriver_<Options, Instance>

Const getAtomType

  • getAtomType(target: any): undefined | AtomType

Const isSameTypeOfAtom

  • isSameTypeOfAtom(targetA: any, targetB: any): boolean
  • Check whether the given targets are both Atom instance and in same Atom type.

    Parameters

    • targetA: any
    • targetB: any

    Returns boolean

    whether the given targets are in same type of Atom.

Const isSameTypeOfAtom_

  • isSameTypeOfAtom_(targetA: any): (targetB: any) => boolean
  • isSameTypeOfAtom_(targetA: any, targetB: any): boolean

Const isSameTypeOfMediator

  • isSameTypeOfMediator(targetA: any, targetB: any): boolean
  • Check whether the given targets are both Mediator instance and in same Mediator type.

    Parameters

    • targetA: any
    • targetB: any

    Returns boolean

    whether the given targets are in same type of Mediator.

Const isSameTypeOfMediator_

  • isSameTypeOfMediator_(targetA: any): (targetB: any) => boolean
  • isSameTypeOfMediator_(targetA: any, targetB: any): boolean

makeDataInArray

  • makeDataInArray<V>(targets: V, options?: BatchMakeOptions & { forceWrap: false }): WrapDataInArray<V>
  • makeDataInArray<V>(targets: V, options?: BatchMakeOptions & { forceWrap: true }): ForceWrapDataInArray<V>
  • forceWrap - true: items will be wrapped in Data. See {@link forceWrapToData}.

    forceWrap - false: Mutations will be transform to Data, Datas will not be handled, other values will be wrapped in Data. See {@link wrapToData}.

    example
      const tupleA: [number, Data<number>, number] = [1, Data.of(2), 3]
    const arrayA = [1, 2, 3]
    // Expect: [Data<number>, Data<number>, Data<number>]
    const dataInTupleA = makeDataInArray(tupleA)
    // Expect: Data<number>[]
    const dataInArrayA = makeDataInArray(arrayA)

    Type parameters

    • V: readonly any[] = any

    Parameters

    • targets: V
    • Optional options: BatchMakeOptions & { forceWrap: false }

    Returns WrapDataInArray<V>

  • Type parameters

    • V: readonly any[] = any

    Parameters

    • targets: V
    • Optional options: BatchMakeOptions & { forceWrap: true }

    Returns ForceWrapDataInArray<V>

Const makeDataInArray_

  • makeDataInArray_(...args: any[]): any

makeDataInObject

  • makeDataInObject<V>(targets: V, options?: BatchMakeOptions & { forceWrap: false }): WrapDataInObject<V>
  • makeDataInObject<V>(targets: V, options?: BatchMakeOptions & { forceWrap: true }): ForceWrapDataInObject<V>
  • forceWrap - true: items will be wrapped in Data. See {@link forceWrapToData}.

    forceWrap - false: Mutations will be transform to Data, Datas will not be handled, other values will be wrapped in Data. See {@link wrapToData}.

    example
      const indexedObject: { [key: string]: number } = { a: 1, b: 2, c: 3 }
    // Expect: Record<string, Data<number>>
    const dataInIndexedObject = makeDataInObject(indexedObject)
    const namedObject = { a: 1, b: Data.of(2), c: 3 }
    // Expect: { a: Data<number>, b: Data<number>, c: Data<number> }
    const dataInNamedObject = makeDataInObject(namedObject)

    Type parameters

    • V: Record<any, any>

    Parameters

    • targets: V
    • Optional options: BatchMakeOptions & { forceWrap: false }

    Returns WrapDataInObject<V>

  • Type parameters

    • V: Record<any, any>

    Parameters

    • targets: V
    • Optional options: BatchMakeOptions & { forceWrap: true }

    Returns ForceWrapDataInObject<V>

Const makeDataInObject_

  • makeDataInObject_(...args: any[]): any

Const createMutationInArray

  • createMutationInArray<V>(arr: V[], options?: BatchMakeOptions): MutationLike<any, any>[]
  • forceWrap - true: items will be wrapped in Mutation.

    forceWrap - false: Datas will be transform to Mutation, Mutations will not be handled, other values will be wrapped in Mutation.

    Type parameters

    • V

    Parameters

    • arr: V[]
    • options: BatchMakeOptions = DEFAULT_BATCH_MAKE_OPTIONS

    Returns MutationLike<any, any>[]

Const createMutationInArray_

  • createMutationInArray_(...args: any[]): any

Const createMutationInObject

  • createMutationInObject<V>(obj: Record<string, V>, options?: BatchMakeOptions): Record<string, MutationLike<any, any>>
  • forceWrap - true: items will be wrapped in Mutation.

    forceWrap - false: Datas will be transform to Mutation, Mutations will not be handled, other values will be wrapped in Mutation.

    Type parameters

    • V

    Parameters

    • obj: Record<string, V>
    • options: BatchMakeOptions = DEFAULT_BATCH_MAKE_OPTIONS

    Returns Record<string, MutationLike<any, any>>

Const createMutationInObject_

  • createMutationInObject_(...args: any[]): any

Const createAtomInArray

  • createAtomInArray<V>(arr: V[], options?: BatchMakeOptions): (DataLike<any> | MutationLike<any, any>)[]
  • forceWrap - true: functions will be wrapped in Mutation, other values will be wrapped in Data.

    forceWrap - false: Atoms will not be handled, functions will be wrapped in Mutation, other values will be wrapped in Data.

    Type parameters

    • V

    Parameters

    • arr: V[]
    • options: BatchMakeOptions = DEFAULT_BATCH_MAKE_OPTIONS

    Returns (DataLike<any> | MutationLike<any, any>)[]

Const createAtomInArray_

  • createAtomInArray_(...args: any[]): any

Const createAtomInObject

  • createAtomInObject<V>(obj: Record<string, V>, options?: BatchMakeOptions): Record<string, DataLike<any> | MutationLike<any, any>>
  • forceWrap - true: functions will be wrapped in Mutation, other values will be wrapped in Data.

    forceWrap - false: Atoms will not be handled, functions will be wrapped in Mutation, other values will be wrapped in Data.

    Type parameters

    • V

    Parameters

    • obj: Record<string, V>
    • options: BatchMakeOptions = DEFAULT_BATCH_MAKE_OPTIONS

    Returns Record<string, DataLike<any> | MutationLike<any, any>>

Const createAtomInObject_

  • createAtomInObject_(...args: any[]): any

Const createIterableTrigger

  • createIterableTrigger<V, R>(options: IterableTriggerCreateOptions<V, R>): Trigger<R>

Const createDataFromIterable

Const createMutationFromIterable

Const createEventTrigger

  • createEventTrigger<Target, Returned>(options: EventTriggerCreateOptions<Target, Returned>): Trigger<Returned>

Const createDataFromEvent

Const createMutationFromEvent

Const createIntervalTrigger

  • createIntervalTrigger<R>(options: IntervalTriggerCreateOptions<R>): Trigger<R>

Const createDataFromInterval

Const createMutationFromInterval

Const createTimeoutTrigger

  • createTimeoutTrigger<R>(options: TimeoutTriggerCreateOptions<R>): Trigger<R>

Const createDataFromTimeout

Const createMutationFromTimeout

Const createObservableTrigger

  • createObservableTrigger<V, R>(options: ObservableTriggerCreateOptions<V, R>): Trigger<R>

Const createDataFromObservable

Const createMutationFromObservable

Const createFunctionTrigger

  • createFunctionTrigger<P, R>(options: FunctionTriggerCreateOptions<P, R>): Trigger<R>
  • example
    //                                  slow usecase
    // first create an emit variable which used to hold the real emit function,
    // we can separately call this function to emit values to our trigger later
    let emit

    // then we create an agent function, which takes an inner emit function as 1st argument,
    // and internally assign the inner emit function to the emit variable which we created in last step
    const agent = (innerEmit) => {
    emit = innerEmit
    }

    // then create a trigger, specify the agent function
    // and the handler function which will be called with the arguments passed to emit function later
    // the return value will be passed to the trigger
    const trigger = createFunctionTrigger({ agent, handler: (score) => score + 1 })

    // call the emit function which hold be the pre-declared variable
    // the trigger will emit 100 (which equals to `99 + 1`)
    emit(99)

    // quick usecase
    // create all we need using the `createFunctionTriggerAgent` function
    // only need to specify the handler function
    const agent = createFunctionTriggerAgent((score: number) => score + 1)

    // then pass the created agent to the FunctionTrigger creator using the spread operator
    const const trigger = createFunctionTrigger({ ...agent })

    // call the emit function hold by `agent` to trigger value
    agent.emit(99)

    Type parameters

    • P: any[] = any[]

    • R = any

    Parameters

    • options: FunctionTriggerCreateOptions<P, R>

    Returns Trigger<R>

Const createDataFromFunction

Const createMutationFromFunction

Const createFunctionTriggerAgent

  • createFunctionTriggerAgent<P, R>(handler: (...args: [...P[]]) => R): FunctionTriggerAgent<[...P[]], R>
  • Function Trigger Agent is designed to be passed to createFunctionTrigger function as part of its options.

    example
    createFunctionTrigger({ ...createFunctionTriggerAgent(handler), ...otherOptions })
    

    Type parameters

    • P: any[] = any[]

    • R = any

    Parameters

    • handler: (...args: [...P[]]) => R
        • (...args: [...P[]]): R
        • Parameters

          • Rest ...args: [...P[]]

          Returns R

    Returns FunctionTriggerAgent<[...P[]], R>

data

  • data<V>(value: V): Data<V>
  • data<V>(value: V, options: GeneralDataMakeOptions & { isReplay: false }): Data<V>
  • data<V>(value: V, options: GeneralDataMakeOptions & { isReplay: true }): ReplayDataMediator<V>

mutation

Const withMediator

Const withMediator_

  • withMediator_(...args: any[]): any

Const withTriggerMediator

Const withTriggerMediator_

  • withTriggerMediator_(...args: any[]): any

Const withReplayMediator

Const withReplayMediator_

  • withReplayMediator_(...args: any[]): any

Const withFlatMediator

Const withFlatMediator_

  • withFlatMediator_(...args: any[]): any

Const createDataWithTriggerMediator

Const createDataWithTriggerMediator_

  • createDataWithTriggerMediator_(...args: any[]): any

Const createMutationWithTriggerMediator

Const createMutationWithTriggerMediator_

  • createMutationWithTriggerMediator_(...args: any[]): any

Const createDataWithReplayMediator

Const createDataWithReplayMediator_

  • createDataWithReplayMediator_(...args: any[]): any

Const createMutationWithReplayMediator

Const createMutationWithReplayMediator_

  • createMutationWithReplayMediator_(...args: any[]): any

Const createDataWithFlatMediator

Const createDataWithFlatMediator_

  • createDataWithFlatMediator_(...args: any[]): any

Const createMutationWithFlatMediator

Const createMutationWithFlatMediator_

  • createMutationWithFlatMediator_(...args: any[]): any

Const createDataWithTrigger

Const createDataWithTrigger_

  • createDataWithTrigger_(...args: any[]): any

Const createMutationWithTrigger

Const createMutationWithTrigger_

  • createMutationWithTrigger_(...args: any[]): any

Const createDataWithReplay

Const createDataWithReplay_

  • createDataWithReplay_(...args: any[]): any

Const createMutationWithReplay

Const createMutationWithReplay_

  • createMutationWithReplay_(...args: any[]): any

Const createDataWithFlat

Const createDataWithFlat_

  • createDataWithFlat_(...args: any[]): any

Const createMutationWithFlat

Const createMutationWithFlat_

  • createMutationWithFlat_(...args: any[]): any

binaryHyperPipeAtom

  • binaryHyperPipeAtom<T>(targets: [...T[]]): AtomLike[]
  • binaryHyperPipeAtom<T>(...targets: [...T[]]): AtomLike[]

binaryHyperComposeAtom

  • binaryHyperComposeAtom<T>(targets: [...T[]]): AtomLike[]
  • binaryHyperComposeAtom<T>(...targets: [...T[]]): AtomLike[]

nAryHyperPipeAtom

  • nAryHyperPipeAtom<T>(targets: [...T[]]): AtomLike[]
  • nAryHyperPipeAtom<T>(...targets: [...T[]]): AtomLike[]

Const hyperPipeAtom

  • hyperPipeAtom<T>(targets: [...T[]]): AtomLike[]
  • hyperPipeAtom<T>(...targets: [...T[]]): AtomLike[]

nAryHyperComposeAtom

  • nAryHyperComposeAtom<T>(targets: [...T[]]): AtomLike[]
  • nAryHyperComposeAtom<T>(...targets: [...T[]]): AtomLike[]

Const hyperComposeAtom

  • hyperComposeAtom<T>(targets: [...T[]]): AtomLike[]
  • hyperComposeAtom<T>(...targets: [...T[]]): AtomLike[]

liftAtom

  • liftAtom<A>(target: A): A
  • liftAtom<A, B>(target: Mutator<A, B>): Mutation<A, B>
  • liftAtom<R>(target: (...args: any[]) => R): Mutation<any, R>
  • liftAtom<A>(target: A): Data<A>

binaryLiftPipeAtom

  • binaryLiftPipeAtom<T>(targets: [...T[]]): AtomLike[]
  • binaryLiftPipeAtom<T>(...targets: [...T[]]): AtomLike[]

binaryLiftComposeAtom

  • binaryLiftComposeAtom<T>(targets: [...T[]]): AtomLike[]
  • binaryLiftComposeAtom<T>(...targets: [...T[]]): AtomLike[]

nAryLiftPipeAtom

  • nAryLiftPipeAtom<T>(targets: [...T[]]): AtomLike[]
  • nAryLiftPipeAtom<T>(...targets: [...T[]]): AtomLike[]

Const liftPipeAtom

  • liftPipeAtom<T>(targets: [...T[]]): AtomLike[]
  • liftPipeAtom<T>(...targets: [...T[]]): AtomLike[]

nAryLiftComposeAtom

  • nAryLiftComposeAtom<T>(targets: [...T[]]): AtomLike[]
  • nAryLiftComposeAtom<T>(...targets: [...T[]]): AtomLike[]

Const liftComposeAtom

  • liftComposeAtom<T>(targets: [...T[]]): AtomLike[]
  • liftComposeAtom<T>(...targets: [...T[]]): AtomLike[]

pipeAtom

  • pipeAtom<T>(atoms: [...T[]]): T
  • pipeAtom<T>(...atoms: [...T[]]): T

composeAtom

  • composeAtom<T>(atoms: [...T[]]): T
  • composeAtom<T>(...atoms: [...T[]]): T

Const makeEmptyDatar

Const makeEmptyMutator

Const makeDatarOf

  • makeDatarOf<V>(value: V, mutator?: ValidMutatorOfDatar<V>, options?: DatarOptions): Datar<V>

Const makeMutatorOf

Const makeMutatorOfLift

Const makeMutatorOfLiftLeft

Const makeMutatorOfLiftRight

Const makeMutatorOfLiftBoth

Const makeEmptyData

Const makeEmptyMutation

Const makeDataOf

Const makeMutationOf

Const makeMutationofLift

Const makeMutationOfLiftLeft

Const makeMutationOfLiftRight

Const makeMutationOfLiftBoth

mutationToDataS

Const mutationToDataS_

  • mutationToDataS_(...args: any[]): any

mutationToData

Const mutationToData_

  • mutationToData_(...args: any[]): any

dataToData

Const dataToData_

  • dataToData_(...args: any[]): any

atomToData

Const atomToData_

  • atomToData_(...args: any[]): any

dataToMutationS

Const dataToMutationS_

  • dataToMutationS_(...args: any[]): any

dataToMutation

Const dataToMutation_

  • dataToMutation_(...args: any[]): any

mutationToMutation

Const mutationToMutation_

  • mutationToMutation_(...args: any[]): any

atomToMutation

Const atomToMutation_

  • atomToMutation_(...args: any[]): any

Const tweenAtom

tweenAtoms

  • tweenAtoms<T>(atoms: [...T[]]): AtomLike[]
  • tweenAtoms<T>(...atoms: [...T[]]): AtomLike[]

binaryTweenPipeAtom

  • binaryTweenPipeAtom<T>(atoms: [...T[]]): AtomLike[]
  • binaryTweenPipeAtom<T>(...atoms: [...T[]]): AtomLike[]

binaryTweenComposeAtom

  • binaryTweenComposeAtom<T>(atoms: [...T[]]): AtomLike[]
  • binaryTweenComposeAtom<T>(...atoms: [...T[]]): AtomLike[]

nAryTweenPipeAtom

  • nAryTweenPipeAtom<T>(atoms: [...T[]]): AtomLike[]
  • nAryTweenPipeAtom<T>(...atoms: [...T[]]): AtomLike[]

Const tweenPipeAtom

  • tweenPipeAtom<T>(atoms: [...T[]]): AtomLike[]
  • tweenPipeAtom<T>(...atoms: [...T[]]): AtomLike[]

nAryTweenComposeAtom

  • nAryTweenComposeAtom<T>(atoms: [...T[]]): AtomLike[]
  • nAryTweenComposeAtom<T>(...atoms: [...T[]]): AtomLike[]

Const tweenComposeAtom

  • tweenComposeAtom<T>(atoms: [...T[]]): AtomLike[]
  • tweenComposeAtom<T>(...atoms: [...T[]]): AtomLike[]

Const isMediator

Const isDataMediator

Const isMutationMediator

Const isFlatMediator

  • isFlatMediator(tar: any): tar is FlatMediatorUnion

Const withValueFlatted

Const isReplayMediator

Const replayWithoutLatest

Const replayWithLatest

Const isTriggerMediator

Const isMeta

  • isMeta(target: any): target is Meta

Const isVacuo

  • isVacuo(target: any): target is Vacuo

Const isVoid

  • isVoid(target: any): target is Void

Const isPausor

  • isPausor(target: any): target is Pausor

Const isTerminator

Const makeVacuo

Const isParticle

  • isParticle(target: any): target is Particle

Const isChaos

  • isChaos(target: any): target is Chaos

isDatar

  • isDatar<V>(target: Datar<V>): target is Datar<V>
  • isDatar<V>(target: unknown): target is Datar<V>

isMutator

  • isMutator<P, C>(target: Mutator<P, C>): target is Mutator<P, C>
  • isMutator<P, C>(target: unknown): target is Mutator<P, C>

isValidMutatorOfDatar

  • isValidMutatorOfDatar<V>(target: ValidMutatorOfDatar<V>): target is ValidMutatorOfDatar<V>
  • isValidMutatorOfDatar<V>(target: unknown): target is ValidMutatorOfDatar<V>
  • Type parameters

    • V = any

    Parameters

    • target: ValidMutatorOfDatar<V>

    Returns target is ValidMutatorOfDatar<V>

    whether the target is a valid mutator of datar

  • Type parameters

    • V = any

    Parameters

    • target: unknown

    Returns target is ValidMutatorOfDatar<V>

isValidDatarOfMutator

  • isValidDatarOfMutator<P, C>(target: ValidDatarOfMutator<P, C>): target is ValidDatarOfMutator<P, C>
  • isValidDatarOfMutator<P, C>(target: unknown): target is ValidDatarOfMutator<P, C>
  • Predicate whether the target is a valid datar of mutator, i.e. Chaos or Datar.

    Type parameters

    • P = any

    • C = any

    Parameters

    • target: ValidDatarOfMutator<P, C>

    Returns target is ValidDatarOfMutator<P, C>

  • Type parameters

    • P = any

    • C = any

    Parameters

    • target: unknown

    Returns target is ValidDatarOfMutator<P, C>

Const createGeneralTache

  • createGeneralTache<Options, TLC, Sources, In, Mid, Out>(createOptions: GeneralTacheCreateOptions<Options, TLC, Sources, In, Mid, Out> | PrepareMidpiece<Options, TLC, In, Mid>, tacheOptions?: Options): Tache<Sources, Out>

Const createGeneralTache_

  • createGeneralTache_<Options, TLC, Sources, In, Mid, Out>(createOptions: GeneralTacheCreateOptions<Options, TLC, Sources, In, Mid, Out> | PrepareMidpiece<Options, TLC, In, Mid>, tacheOptions: Options): Tache<Sources, Out>
  • createGeneralTache_<Options, TLC, Sources, In, Mid, Out>(createOptions: GeneralTacheCreateOptions<Options, TLC, Sources, In, Mid, Out> | PrepareMidpiece<Options, TLC, In, Mid>): (tacheOptions?: Options) => Tache<Sources, Out>

Const useGeneralTache

  • useGeneralTache<Options, Sources, Out>(tacheMaker: (options: Options) => Tache<Sources, Out>, tacheOptions: Options, ...sources: Sources): Out
  • Type parameters

    • Options = any

    • Sources: any[] = any[]

    • Out = any

    Parameters

    • tacheMaker: (options: Options) => Tache<Sources, Out>

      partial applied createGeneralTache

        • (options: Options): Tache<Sources, Out>
        • Parameters

          • options: Options

          Returns Tache<Sources, Out>

    • tacheOptions: Options
    • Rest ...sources: Sources

    Returns Out

Const useGeneralTache_

  • useGeneralTache_<Options, Sources, Out>(tacheMaker: (options: Options) => Tache<Sources, Out>, tacheOptions: Options, ...sources: Sources): Out
  • useGeneralTache_<Options, Sources, Out>(tacheMaker: (options: Options) => Tache<Sources, Out>, tacheOptions: Options): (...sources: Sources) => Out
  • useGeneralTache_<Options, Sources, Out>(tacheMaker: (options: Options) => Tache<Sources, Out>): IPartialUseGeneralTache_<Options, Sources, Out>

Const createMMTache

  • createMMTache(): void

createArrayMSTache

  • createArrayMSTache<Ps, C, AN, CT, LT>(config: ArrayMSTacheConfig<Ps, Terminator | C, AN, CT, LT>): ArrayMSTache<Ps, C, AN>
  • Type parameters

    • Ps: any[]

    • C

    • AN: boolean = boolean

      The type of acceptNonAtom

    • CT: CustomizeTypes = CustomizeTypes

      The type of customizeTypes

    • LT: LiftTypes = LiftTypes

      The type of MutationLiftPosition

    Parameters

    • config: ArrayMSTacheConfig<Ps, Terminator | C, AN, CT, LT>

    Returns ArrayMSTache<Ps, C, AN>

Const createObjectMSTache

  • createObjectMSTache<Ps, C, AN, CT, LT>(config: ObjectMSTacheConfig<Ps, Terminator | C, AN, CT, LT>): ObjectMSTache<Ps, C, AN>
  • Type parameters

    • Ps: Record<any, any>

    • C

    • AN: boolean = boolean

      The type of acceptNonAtom

    • CT: CustomizeTypes = CustomizeTypes

      The type of customizeTypes

    • LT: LiftTypes = LiftTypes

      The type of MutationLiftPosition

    Parameters

    • config: ObjectMSTacheConfig<Ps, Terminator | C, AN, CT, LT>

    Returns ObjectMSTache<Ps, C, AN>

Const createMSTache

  • createMSTache<Ps, C, AN, CT, LT>(config: ArrayMSTacheConfig<Ps, Terminator | C, AN, CT, LT>): ArrayMSTache<Ps, C, AN>
  • createMSTache<Ps, C, AN, CT, LT>(config: ObjectMSTacheConfig<Ps, Terminator | C, AN, CT, LT>): ObjectMSTache<Ps, C, AN>

Const createArraySMTache

  • createArraySMTache<P>(configArr: ArraySMTacheConfig<P>[]): ArraySMTache<P>

Const createObjectSMTache

  • createObjectSMTache<P>(configObj: Record<string, ObjectSMTacheConfig<P>>): ObjectSMTache<P>

Const createSMTache

  • createSMTache<P>(config: ArraySMTacheConfig<P>[]): ArraySMTache<P>
  • createSMTache<P>(config: Record<string, ObjectSMTacheConfig<P>>): ObjectSMTache<P>

Const createSSTache

Const caseT

Const caseT_

  • caseT_(...args: any[]): any

Const arrayCaseT

Const arrayCaseT_

  • arrayCaseT_(...args: any[]): any

Const dynamicArrayCaseT

Const dynamicArrayCaseT_

  • dynamicArrayCaseT_(...args: any[]): any

Const staticArrayCaseT

Const staticArrayCaseT_

  • staticArrayCaseT_(...args: any[]): any

Const objectCaseT

Const objectCaseT_

  • objectCaseT_(...args: any[]): any

Const dynamicObjectCaseT

Const dynamicObjectCaseT_

  • dynamicObjectCaseT_(...args: any[]): any

Const staticObjectCaseT

Const staticObjectCaseT_

  • staticObjectCaseT_(...args: any[]): any

Const combineT

Const arrayCombineT

Const objectCombineT

Const combineLatestT

  • combineLatestT<V>(...sources: [[...V[]]]): Data<ExtractAtomValueInArray<V>>
  • combineLatestT<V>(...sources: [...V[]]): Data<ExtractAtomValueInArray<V>>
  • combineLatestT<V>(sources: V): Data<ExtractAtomValueInObject<V>>

Const arrayCombineLatestT

  • arrayCombineLatestT<V>(...sources: [[...V[]]]): Data<ExtractAtomValueInArray<V>>
  • arrayCombineLatestT<V>(...sources: [...V[]]): Data<ExtractAtomValueInArray<V>>

Const objectCombineLatestT

  • objectCombineLatestT<V>(sources: V): Data<ExtractAtomValueInObject<V>>

Const convergeT

Const debounceTimeT

Const deboundeTimeT_

Const dynamicDebounceTimeT

Const dynamicDebounceTimeT_

Const staticDebounceTimeT

Const staticDebounceTimeT_

Const defaultToT

Const defaultToT_

Const dynamicDefaultToT

Const dynamicDefaultToT_

Const staticDefaultToT

Const staticDefaultToT_

Const distinctEverT

Const distinctEverT_

Const dynamicDistinctEverT

Const dynamicDistinctEverT_

Const staticDistinctEverT

Const staticDistinctEverT_

Const asIsDistinctEverT

Const distinctPreviousT

Const distinctPreviousT_

Const dynamicDistinctPreviousT

Const dynamicDistinctPreviousT_

Const staticDistinctPreviousT

Const staticDistinctPreviousT_

Const asIsDistinctPreviousT

Const effectT

  • effectT transfer the value's emittion authority to the effect function, so developer can control whether, when and what value will be emitted.

    see

    dynamicEffectT, staticEffectT

    Type parameters

    • V

    • T

    Parameters

    • effect: Effect<V, T>

      A function that controls the value's emittion. When there is a target value received, the effect function will be invoked. It takes an emit function as first argument, invoke it with the value to emit it. And takes the target value as second argument, an value set function whose value will be emitted just after effect function's execution.

    • target: AtomLikeOfOutput<T>

      Atom

    Returns Data<V>

    Data

Const effectT_

Const dynamicEffectT

Const dynamicEffectT_

Const staticEffectT

Const staticEffectT_

Const emptyStartWithT

Const emptyStartWithT_

Const dynamicEmptyStartWithT

Const dynamicEmptyStartWithT_

Const staticEmptyStartWithT

Const staticEmptyStartWithT_

Const filterT

Const filterT_

Const dynamicFilterT

Const dynamicFilterT_

Const staticFilterT

Const staticFilterT_

Const holdLatestUntilT

Const holdLatestUntilT_

Const iifT

Const iifT_

  • iifT_(...args: any[]): any

Const dynamicIifT

Const dynamicIifT_

  • dynamicIifT_(...args: any[]): any

Const staticIifT

Const staticIifT_

  • staticIifT_(...args: any[]): any

Const mapT

Const mapT_

Const dynamicMapT

Const dynamicMapT_

Const staticMapT

Const staticMapT_

Const nilToVoidT

Const partitionT

Const pluckT

Const pluckT_

Const dynamicPluckT

Const dynamicPluckT_

Const staticPluckT

Const staticPluckT_

Const skipT

Const skipT_

Const dynamicSkipT

Const dynamicSkipT_

Const staticSkipT

Const staticSkipT_

Const skipUntilT

Const skipUntilT_

Const skipWhileT

Const skipWhileT_

Const startWithT

Const startWithT_

Const dynamicStartWithT

Const dynamicStartWithT_

Const staticStartWithT

Const staticStartWithT_

Const switchT

Const switchT_

Const dynamicSwitchT

Const dynamicSwitchT_

Const staticSwitchT

Const staticSwitchT_

Const promiseSwitchT

Const promiseSwitchT_

Const takeT

Const takeT_

Const dynamicTakeT

Const dynamicTakeT_

Const staticTakeT

Const staticTakeT_

Const takeBeforeSwitchT

Const takeBeforeSwitchT_

Const takeUntilT

Const takeUntilT_

Const takeWhileT

Const takeWhileT_

Const tapT

  • tapT<T>(effect: (target: T) => void, target: T): T
  • Do something with the target, then pass target through.

    Type parameters

    • T

    Parameters

    • effect: (target: T) => void
        • (target: T): void
        • Parameters

          • target: T

          Returns void

    • target: T

    Returns T

Const tapT_

  • tapT_<T>(effect: (target: T) => void, target: T): T
  • tapT_<T>(effect: (target: T) => void): (target: T) => T
  • see

    tapT

    Type parameters

    • T

    Parameters

    • effect: (target: T) => void
        • (target: T): void
        • Parameters

          • target: T

          Returns void

    • target: T

    Returns T

  • see

    tapT

    Type parameters

    • T

    Parameters

    • effect: (target: T) => void
        • (target: T): void
        • Parameters

          • target: T

          Returns void

    Returns (target: T) => T

      • (target: T): T
      • Parameters

        • target: T

        Returns T

Const tapValueT

  • tapValueT<V>(name: string | { name?: string; level: 0 | 1 | 2 | "LOG" | "INFO" | "WARN" | "ERROR" | 3 }, target: V): V

Const tapValueT_

  • tapValueT_<V>(name: string | { name?: string; level: 0 | 1 | 2 | "LOG" | "INFO" | "WARN" | "ERROR" | 3 }, target: V): V
  • tapValueT_<V>(name: string | { name?: string; level: 0 | 1 | 2 | "LOG" | "INFO" | "WARN" | "ERROR" | 3 }): (target: V) => V

Const throttleTimeT

Const throttleTimeT_

Const dynamicThrottleTimeT

Const dynamicThrottleTimeT_

Const staticThrottleTimeT

Const staticThrottleTimeT_

Const withHistoryT

Const withHistoryT_

Const withDynamicHistoryT

Const withDynamicHistoryT_

Const withStaticHistoryT

Const withStaticHistoryT_

Const pairwiseT

Const truthyPairwiseT

Const withLatestFromT

Const withLatestFromT_

Const promiseWithLatestFromT

Const promiseWithLatestFromT_

Const zipLatestT

Const arrayZipLatestT

Const objectZipLatestT

Const isVain

  • isVain(target: any): target is Vain

Const globalVar

  • globalVar<V>(key: any, value?: V): V
  • Set or get global variable.

    Type parameters

    • V = any

    Parameters

    • key: any
    • Optional value: V

    Returns V

Const makeElementBasedMessageProxy

  • makeElementBasedMessageProxy(id: string, type: string, name: string): ElementBasedMessageProxy
  • Different proxy can use same type of event on same element, so the proxy's can live in different sandbox such as contentScript & injectScript.

    Parameters

    • id: string

      element id

    • type: string

      event type on element

    • name: string

      name of proxy instance

    Returns ElementBasedMessageProxy

    ElementBasedMessageProxy

Const makeCallback

makeGeneralCallback

  • makeGeneralCallback<Value, Returned>(handler?: (value: Value) => Returned): [...GeneralCallbackBatch<Value, Returned>]
  • Type parameters

    • Value = any

    • Returned = Value

    Parameters

    • Optional handler: (value: Value) => Returned
        • (value: Value): Returned
        • Parameters

          • value: Value

          Returns Returned

    Returns [...GeneralCallbackBatch<Value, Returned>]

Const neatenClassString

  • neatenClassString(str: string): string
  • example
    'mobius-base mobius-theme--light' 👉 'mobius-base mobius-theme--light'
    '.mobius-base.mobius-theme--light' 👉 'mobius-base mobius-theme--light'
    '.mobius-base mobius-theme--light' 👉 'mobius-base mobius-theme--light'
    ' .mobius-base mobius-theme--light ' 👉 'mobius-base mobius-theme--light'

    Parameters

    • str: string

      same as value of class attribute on HTML tags

    Returns string

    formatted class string

Const classStringToClassArray

  • Format target string to standard class string using neatenClassString, then split it to array by space.

    example
    'mobius-base mobius-theme--light' 👉 ['mobius-base', 'mobius-theme--light']
    '.mobius-base.mobius-theme--light' 👉 ['mobius-base', 'mobius-theme--light']
    '.mobius-base mobius-theme--light' 👉 ['mobius-base', 'mobius-theme--light']
    ' .mobius-base mobius-theme--light ' 👉 ['mobius-base', 'mobius-theme--light']

    Parameters

    • str: string

      class string

    Returns ClassArray

    array of classnames

Const classArrayToClassObject

  • example
    ['mobius-base', 'mobius-theme--light']
    👇
    {
    'mobius-base': true,
    'mobius-theme--light': true
    }

    Parameters

    Returns ClassObject

    PlainObject which use classname as key and exist of classname as value

Const classStringToClassObject

  • Equal to pipe(classStringToClassArray, classArrayToClassObject).

    Parameters

    • str: string

      class string

    Returns ClassObject

    PlainObject which use classname as key and exist of classname as value

Const classObjectToClassArray

Const classArrayToClassString

Const classObjectToClassString

Const toClassString

Const toClassArray

Const toClassObject

Const formatClassTo

  • formatClassTo(...args: any[]): any

Const prefixClassWith

  • prefixClassWith(...args: any[]): any
  • Curried.

    Parameters

    • Rest ...args: any[]

    Returns any

    typeof param class, says classString | classArray | classObject

Const removePrefixOfClass

  • removePrefixOfClass(...args: any[]): any
  • Curried.

    Parameters

    • Rest ...args: any[]

    Returns any

    typeof param class, says classString | classArray | classObject

Const addClass

  • addClass(...args: any[]): any
  • Curried.

    Parameters

    • Rest ...args: any[]

    Returns any

    typeof param class, says classString | classArray | classObject

Const removeClass

  • removeClass(...args: any[]): any
  • Curried.

    Parameters

    • Rest ...args: any[]

    Returns any

    typeof param class, says classString | classArray | classObject

Const toggleClass

  • toggleClass(...args: any[]): any
  • Curried.

    Parameters

    • Rest ...args: any[]

    Returns any

    typeof param class, says classString | classArray | classObject

Const replaceClass

  • replaceClass(...args: any[]): any
  • Curried.

    Parameters

    • Rest ...args: any[]

    Returns any

    typeof param class, says classString | classArray | classObject

Const containClass

  • containClass(...args: any[]): any

Const stdLineLog

  • stdLineLog(...args: any[]): any
  • deprecated

    重新规划一个更好的日志方案,支持运行时日志和应用监控两个主要场景

    Parameters

    • Rest ...args: any[]

    Returns any

    no return value

Const inspect

  • inspect(x: any): string

Const injectScript

  • injectScript(src: string, onload?: null | ((ev: Event) => any), removeAfterLoaded?: boolean): HTMLScriptElement
  • Parameters

    • src: string
    • onload: null | ((ev: Event) => any) = null
    • removeAfterLoaded: boolean = false

    Returns HTMLScriptElement

Const pollingToGetElement

  • pollingToGetElement(selector: string, interval: number, callback: (node: Element) => void): void
  • Parameters

    • selector: string

      element's id or selector

    • interval: number

      polling interval (in ms)

    • callback: (node: Element) => void
        • (node: Element): void
        • Parameters

          • node: Element

          Returns void

    Returns void

    no return value

Const pollingToGetElement_

  • pollingToGetElement_(selector: string, interval: number, callback: (node: Element) => void): void
  • pollingToGetElement_(selector: string): (interval: number, callback: (node: Element) => void) => void
  • pollingToGetElement_(selector: string, interval: number): (callback: (node: Element) => void) => void
  • pollingToGetElement_(selector: string): (interval: number) => (callback: (node: Element) => void) => void
  • Parameters

    • selector: string
    • interval: number
    • callback: (node: Element) => void
        • (node: Element): void
        • Parameters

          • node: Element

          Returns void

    Returns void

  • Parameters

    • selector: string

    Returns (interval: number, callback: (node: Element) => void) => void

      • (interval: number, callback: (node: Element) => void): void
      • Parameters

        • interval: number
        • callback: (node: Element) => void
            • (node: Element): void
            • Parameters

              • node: Element

              Returns void

        Returns void

  • Parameters

    • selector: string
    • interval: number

    Returns (callback: (node: Element) => void) => void

      • (callback: (node: Element) => void): void
      • Parameters

        • callback: (node: Element) => void
            • (node: Element): void
            • Parameters

              • node: Element

              Returns void

        Returns void

  • Parameters

    • selector: string

    Returns (interval: number) => (callback: (node: Element) => void) => void

      • (interval: number): (callback: (node: Element) => void) => void
      • Parameters

        • interval: number

        Returns (callback: (node: Element) => void) => void

          • (callback: (node: Element) => void): void
          • Parameters

            • callback: (node: Element) => void
                • (node: Element): void
                • Parameters

                  • node: Element

                  Returns void

            Returns void

Const isInWXMINAEnvironment

  • isInWXMINAEnvironment(): boolean
  • Predicate whether the enviroment is Wexin Mini Program (MINA: MINA is not App). NOTE: typeof operator can operate on non-exist variable.

    check

    wx, wx.canIUse

    Returns boolean

Const isInWebEnvironment

  • isInWebEnvironment(): boolean

Const isInBrowserEnvironment

  • isInBrowserEnvironment(): boolean

Const isInNodeEnvironment

  • isInNodeEnvironment(): boolean

Const adaptMultipleEnvironments

Const adaptMultipleEnvironmentsAsync

Const makeCustomEvent

  • makeCustomEvent<Detail>(type: string, detail?: Detail, options?: CustomEventOptions): CustomEvent<{ eventType: string } & Detail>
  • "event.detail" is always of type object which has an "eventType" property in it, "eventType"'s value equals to name of custom type.

    Type parameters

    • Detail: Record<string, any>

    Parameters

    Returns CustomEvent<{ eventType: string } & Detail>

Const makeEventHandler

makeGeneralEventHandler

  • makeGeneralEventHandler<Target, Returned>(handler?: (event: SynthesizeEvent<Target>) => Returned): [...GeneralEventHandlerBatch<Target, Returned>]

Const registerCatchallExceptionHandler

  • registerCatchallExceptionHandler(catchallHandler?: (message: string) => void): void
  • Parameters

    • Optional catchallHandler: (message: string) => void
        • (message: string): void
        • Parameters

          • message: string

          Returns void

    Returns void

Const removeRepetition

  • removeRepetition(strings: string[]): string[]

Const removeRepetitionOf

  • removeRepetitionOf(ofList: string[], targetStrings: string[]): string[]
  • signature

    removeRepetitionOf :: [a] -> ([a] -> [a])

    Parameters

    • ofList: string[]
    • targetStrings: string[]

    Returns string[]

Const removeRepetitionExcept

  • removeRepetitionExcept(exceptList: string[], targetStrings: string[]): string[]
  • signature

    removeRepetitionExcept :: [a] -> ([a] -> [a])

    Parameters

    • exceptList: string[]
    • targetStrings: string[]

    Returns string[]

Const removeRepetitionOfEmpty

  • removeRepetitionOfEmpty(strings: string[]): string[]

Const removeRepetitionOfSlash

  • removeRepetitionOfSlash(strings: string[]): string[]

Const neatenPathname

  • neatenPathname(pathname: PathnameUnion): PathnameUnion
    • remove repetition of slash & empty char
    • add '' or '/' as prefix of pathname

    Parameters

    • pathname: PathnameUnion

    Returns PathnameUnion

Const pathnameToArray

  • pathnameToArray(pathname: PathnameUnion): PathnameArray
  • example
    pathnameToArray(['']) 👉 ['', '']
    pathnameToArray(['', '']) 👉 ['', '']
    pathnameToArray(['app', 'page']) 👉 [ '', 'app', 'page' ]
    pathnameToArray(['', 'app', 'page']) 👉 [ '', 'app', 'page']
    pathnameToArray(['', 'app', '', 'page']) 👉 [ '', 'app', 'page']
    pathnameToArray(['', 'app', '', 'page', '']) 👉 [ '', 'app', 'page', '']
    pathnameToArray(['', '', 'app', '', 'page', '']) 👉 [ '', 'app', 'page', '']
    pathnameToArray(['', '', 'app', '', '', 'page', '']) 👉 [ '', 'app', 'page', '']
    pathnameToArray(['', '', 'app', '', '', 'page', '', '']) 👉 [ '', 'app', 'page', '']
    pathnameToArray('app/page') 👉 [ '', 'app', 'page' ]
    pathnameToArray('/app/page') 👉 [ '', 'app', 'page' ]
    pathnameToArray('/app/page/') 👉 [ '', 'app', 'page', '' ]
    pathnameToArray('//app/page/') 👉 [ '', 'app', 'page', '' ]
    pathnameToArray('//app//page/') 👉 [ '', 'app', 'page', '' ]
    pathnameToArray('//app//page//') 👉 [ '', 'app', 'page', '' ]

    Parameters

    • pathname: PathnameUnion

    Returns PathnameArray

Const pathnameToString

  • pathnameToString(pathname: PathnameUnion): string
  • example
    pathnameToString(['']) // '/'
    pathnameToString(['', '']) // '/'
    pathnameToString(['app', 'page']) // '/app/page'
    pathnameToString(['', 'app', 'page']) // '/app/page'
    pathnameToString(['app', '', 'page']) // '/app/page'
    pathnameToString(['app', 'page', '']) // '/app/page/'
    pathnameToString(['', 'app', '', 'page', '']) // '/app/page/'
    pathnameToString(['', '', 'app', '', '', 'page', '', '']) // '/app/page/'
    pathnameToString('') // '/'
    pathnameToString('/') // '/'
    pathnameToString('//') // '/'
    pathnameToString('/app/page') // '/app/page'
    pathnameToString('//app/page') // '/app/page'
    pathnameToString('//app//page') // '/app/page'
    pathnameToString('//app//page/') // '/app/page/'
    pathnameToString('//app//page//') // '/app/page/'

    Parameters

    • pathname: PathnameUnion

    Returns string

Const isPathnameStrictEqual

  • isPathnameStrictEqual(pathname1: PathnameUnion, pathname2: PathnameUnion): boolean
  • (strict) judge whether two pathname are equal.

    • strict mode: pathname must be equal
    • loose mode: pathname must be equal despite the last '/'
    example
    '/app/page' equals '/app/page'
    '/app/page' not equals '/app/page/'

    Parameters

    • pathname1: PathnameUnion
    • pathname2: PathnameUnion

    Returns boolean

Const isPathnameLooseEqual

  • isPathnameLooseEqual(pathname1: PathnameUnion, pathname2: PathnameUnion): boolean
  • (loose) judge whether two pathname are equal.

    • loose mode: pathname must be equal despite the last '/'
    • strict mode: pathname must be equal
    example
    '/app/page' equals '/app/page'
    '/app/page' equals '/app/page/'

    Parameters

    • pathname1: PathnameUnion
    • pathname2: PathnameUnion

    Returns boolean

Const isPathnameEqual

  • isPathnameEqual(mode: "strict" | "loose", pathname1: PathnameUnion, pathname2: PathnameUnion): boolean
  • judge whether two pathname are equal.

    Parameters

    • mode: "strict" | "loose"

      mode of comparing

    • pathname1: PathnameUnion
    • pathname2: PathnameUnion

    Returns boolean

    whether two pathname are equal

Const neatenSearch

  • neatenSearch(str: string): string
  • example
    '?name=cigaret' 👉 '?name=cigaret'
    'name=cigaret' 👉 '?name=cigaret'

    Parameters

    • str: string

    Returns string

    search string

Const neatenQueryStr

  • neatenQueryStr(str: string): string
  • example
    '?name=cigaret' 👉 'name=cigaret'
    'name=cigaret' 👉 'name=cigaret'

    Parameters

    • str: string

    Returns string

    query string

Const queryStrToQueryObj

  • queryStrToQueryObj(str: string): QueryObject
  • example
    'name=cigaret' 👉 { name: 'cigaret' }
    

    Parameters

    • str: string

    Returns QueryObject

    query object

Const queryObjToQueryStr

  • queryObjToQueryStr(obj: QueryObject): string
  • example
    { name: 'cigaret' } 👉 'name=cigaret'
    

    Parameters

    • obj: QueryObject

    Returns string

    query string

Const searchToQueryStr

  • searchToQueryStr(str: string): string

Const searchToQueryObj

  • searchToQueryObj(str: string): QueryObject

Const queryStrToSearch

  • queryStrToSearch(str: string): string

Const queryObjToSearch

  • queryObjToSearch(str: QueryObject): string

Const toSearch

  • toSearch(tar: QueryUnion): string

Const toQueryStr

  • toQueryStr(tar: QueryUnion): string

Const toQueryObj

  • toQueryObj(tar: QueryUnion): QueryObject

Const biu

Const isRequestEngineClass

  • isRequestEngineClass<SuccessData, FailData, ErrorData, SendData>(tar: any): tar is ConstructorOfRequestEngine<SuccessData, FailData, ErrorData, SendData>

Const isRequestEngine

  • isRequestEngine<SuccessData, FailData, ErrorData, SendData>(tar: any): tar is RequestEngine<SuccessData, FailData, ErrorData, SendData>

Const createFetchRequestEngine

  • createFetchRequestEngine<SuccessData, FailData, ErrorData, SendData>(fetchLike: FetchLike, environment: BiuRequestSupportEnvironments): ConstructorOfRequestEngine<SuccessData, FailData, ErrorData, SendData>

Const createNodeFetchRequestEngine

Const initializeBiutor

  • initializeBiutor(): void

Const isResponseCode

Const isResponse

  • isResponse<SD, FD, ED>(tar: any): tar is ResponseUnion<SD, FD, ED>

Const isResponseLike

  • isResponseLike(tar: any): boolean

Const isSuccessResponse

Const isFailResponse

Const isErrorResponse

Const isUnknowResponse

Const makeSuccessResponse

  • makeSuccessResponse<D>(__namedParameters: Partial<StatusSpecifiedResponse<D>>): SuccessResponse<D>

Const makeFailResponse

  • makeFailResponse<D>(__namedParameters: Partial<StatusSpecifiedResponse<D>>): FailResponse<D>

Const makeErrorResponse

  • makeErrorResponse<D>(__namedParameters: Partial<StatusSpecifiedResponse<D>>): ErrorResponse<D>

Const makeUnknownResponse

  • makeUnknownResponse<D>(__namedParameters: Partial<StatusSpecifiedResponse<D>>): UnknownResponse<D>

Const dataToResponse

Const errorToResponse

Const syncScheduler

  • syncScheduler(target: () => void): void

Const asyncScheduler

  • asyncScheduler(target: () => void): void

Const isScopeManager

  • isScopeManager<Creator>(tar: any): tar is ScopeManager<Creator>

Const v1UUID

  • v1UUID<T>(options: undefined | null | V1Options, buffer: T, offset?: number): T
  • v1UUID(options?: V1Options): string
  • timestamp UUID

    Type parameters

    • T: ArrayLike<number, T>

    Parameters

    • options: undefined | null | V1Options
    • buffer: T
    • Optional offset: number

    Returns T

  • timestamp UUID

    Parameters

    • Optional options: V1Options

    Returns string

Const v4UUID

  • v4UUID<T>(options: undefined | null | V4Options, buffer: T, offset?: number): T
  • v4UUID(options?: V4Options): string
  • random UUID

    Type parameters

    • T: ArrayLike<number, T>

    Parameters

    • options: undefined | null | V4Options
    • buffer: T
    • Optional offset: number

    Returns T

  • random UUID

    Parameters

    • Optional options: V4Options

    Returns string

Const isUUID

  • isUUID(str: string): boolean

Const versionOfUUID

  • versionOfUUID(str: string): number

Const isUUIDv1

  • isUUIDv1(str: string): boolean

Const isUUIDv3

  • isUUIDv3(str: string): boolean

Const isUUIDv4

  • isUUIDv4(str: string): boolean

Const isUUIDv5

  • isUUIDv5(str: string): boolean

Const urlUUID

  • urlUUID(): string

Const makeUniqueString

  • makeUniqueString(prefix?: string, fingerPrint?: string): string
  • 获取当前运行时唯一的字符串,可用于标识组件

    Parameters

    • prefix: string = 'mobius'

      default to mobius

    • fingerPrint: string = 'cigaret'

      default to cigaret

    Returns string

    A string that is unique to the current runtime

Const identity

  • identity<T>(x: T): T

Const omega

  • omega<T>(f: Fn<T>): T

Const constant

  • constant<T>(x: T): (...args: any[]) => T
  • K, Kestrel

    haskell

    const

    use

    true, first, const

    signature

    constant :: a -> b -> a

    Type parameters

    • T = any

    Parameters

    • x: T

    Returns (...args: any[]) => T

      • (...args: any[]): T
      • Parameters

        • Rest ...args: any[]

        Returns T

Const always

  • always<T>(x: T): (...args: any[]) => T

Const kite

  • kite<T>(...args: any[]): (b: T) => T
  • KI, Kite = KI = CK

    haskell

    const id

    derived

    constant(identity)

    use

    false, second

    signature

    kite :: a -> b -> b

    Type parameters

    • T = any

    Parameters

    • Rest ...args: any[]

    Returns (b: T) => T

      • (b: T): T
      • Parameters

        • b: T

        Returns T

Const flip

  • flip(...args: any[]): any
  • C, Cardinal

    haskell

    flip

    use

    reverse arguments

    signature

    flip :: (a -> b -> c) -> b -> a -> c

    Parameters

    • Rest ...args: any[]

    Returns any

Const flipS

  • flipS(...args: any[]): any

Const apply

  • apply(...args: any[]): any

Const applyTo

  • applyTo(...args: any[]): any
  • T, Thrush = CI

    haskell

    flip id

    use

    hold an argument

    signature

    thrush :: a -> (a -> b) -> b

    Parameters

    • Rest ...args: any[]

    Returns any

Const thrush

  • thrush(...args: any[]): any

Const vireo

  • vireo(...args: any[]): any
  • V, Vireo = BCT

    haskell

    flip . flip id

    use

    hold a pair of args

    signature

    vireo :: a -> b -> (a -> b -> c) -> c

    Parameters

    • Rest ...args: any[]

    Returns any

Const vireoS

  • vireoS(...args: any[]): any

Const duplication

  • duplication(...args: any[]): any

Const duplicationS

  • duplicationS(...args: any[]): any

Const substitution

  • substitution(...args: any[]): any

Const substitutionS

  • substitutionS(...args: any[]): any

Const substitution2

  • substitution2(...args: any[]): any

Const substitution2S

  • substitution2S(...args: any[]): any

Const converge

  • converge(...args: any[]): any

Const convergeS

  • convergeS(...args: any[]): any

Const compose2

  • compose2(...args: any[]): any

Const compose2S

  • compose2S(...args: any[]): any

Const psi

  • psi(...args: any[]): any

Const psiS

  • psiS(...args: any[]): any

Const composeB

  • composeB(...args: any[]): any

Const composeBS

  • composeBS(...args: any[]): any

Const Z

  • Z<Y>(g: (arg: (...args: Parameters<Y>) => ReturnType<Y>) => Y): (...args: Parameters<Y>) => ReturnType<Y>
  • Z

    description

    Y Combinator's variation in JavaScript

    signature

    Z :: ((a -> b) -> a -> b) -> a -> b

    example
    const f = g => n => n === 0 ? 1 : n * g(n - 1)
    console.log(Z(f)(5))

    Type parameters

    • Y: (...args: any[]) => any

    Parameters

    • g: (arg: (...args: Parameters<Y>) => ReturnType<Y>) => Y
        • (arg: (...args: Parameters<Y>) => ReturnType<Y>): Y
        • Parameters

          • arg: (...args: Parameters<Y>) => ReturnType<Y>
              • (...args: Parameters<Y>): ReturnType<Y>
              • Parameters

                • Rest ...args: Parameters<Y>

                Returns ReturnType<Y>

          Returns Y

    Returns (...args: Parameters<Y>) => ReturnType<Y>

      • (...args: Parameters<Y>): ReturnType<Y>
      • Parameters

        • Rest ...args: Parameters<Y>

        Returns ReturnType<Y>

Const isArgPlaceholder

  • isArgPlaceholder(tar: any): tar is ArgPlaceholder

Const looseCurryS

  • looseCurryS<FN, EXISTING_ARGS>(targetFn: FN, ...existingArgs: EXISTING_ARGS): SimpleCurriedFunction<EXISTING_ARGS, FN, true>
  • Simple curry function - loose version

    Loose simple curry will pass all of the args it received to target function, even if the arg's length is greater than target function's arity.

    Type parameters

    • FN: (...args: any[]) => any

    • EXISTING_ARGS: [...NonNull<PartialTuple<Parameters<FN>, []>>[], ...any[]]

    Parameters

    • targetFn: FN
    • Rest ...existingArgs: EXISTING_ARGS

    Returns SimpleCurriedFunction<EXISTING_ARGS, FN, true>

Const curryS

  • curryS<FN, EXISTING_ARGS>(targetFn: FN, ...existingArgs: EXISTING_ARGS): SimpleCurriedFunction<EXISTING_ARGS, FN, false>
  • Simple curry function - strict version

    Strict simple curry will take exactly the required args that target function needs, redundant args will be ignored.

    Type parameters

    • FN: (...args: any[]) => any

    • EXISTING_ARGS: NonNull<PartialTuple<Parameters<FN>, []>>

    Parameters

    • targetFn: FN
    • Rest ...existingArgs: EXISTING_ARGS

    Returns SimpleCurriedFunction<EXISTING_ARGS, FN, false>

Const looseCurry

  • looseCurry(fn: AnyFunction, ...args: any[]): AnyFunction
  • Internal curry function - loose version

    Loose internal curry will pass all of the args it received to target function, even if the arg's length is greater than target function's arity.

    Parameters

    • fn: AnyFunction
    • Rest ...args: any[]

    Returns AnyFunction

Const curry

  • curry(fn: AnyFunction, ...args: any[]): AnyFunction
  • Internal curry function - strict version

    Strict internal curry will take exactly the required args that target function needs, redundant args will be ignored.

    Parameters

    • fn: AnyFunction
    • Rest ...args: any[]

    Returns AnyFunction

Const looseCurryN

  • looseCurryN(targetArity: number, fn: AnyFunction, ...args: any[]): AnyFunction
  • Internal curryN function - loose version

    Loose internal curry will pass all of the args it received to target function, even if the arg's length is greater than specified arity.

    Parameters

    • targetArity: number
    • fn: AnyFunction
    • Rest ...args: any[]

    Returns AnyFunction

Const curryN

  • curryN(targetArity: number, fn: AnyFunction, ...args: any[]): AnyFunction
  • Internal curryN function - strict version

    Strict internal curry will take exactly the required arity that specified, redundant args will be ignored.

    Parameters

    • targetArity: number
    • fn: AnyFunction
    • Rest ...args: any[]

    Returns AnyFunction

Const composeL

  • composeL(): <T>(target: T, ...args: unknown[]) => T
  • composeL<A, B>(fn1: NAryF<A, B>): NAryF<A, B>
  • composeL<A, B, C>(fn1: NAryF<A, B>, fn2: UnaryF<B, C>): NAryF<A, C>
  • composeL<A, B, C, D>(fn1: NAryF<A, B>, fn2: UnaryF<B, C>, fn3: UnaryF<C, D>): NAryF<A, D>
  • composeL<A, B, C, D, E>(fn1: NAryF<A, B>, fn2: UnaryF<B, C>, fn3: UnaryF<C, D>, fn4: UnaryF<D, E>): NAryF<A, E>
  • composeL<A, B, C, D, E, F>(fn1: NAryF<A, B>, fn2: UnaryF<B, C>, fn3: UnaryF<C, D>, fn4: UnaryF<D, E>, fn5: UnaryF<E, F>): NAryF<A, F>
  • composeL<A, B, C, D, E, F, G>(fn1: NAryF<A, B>, fn2: UnaryF<B, C>, fn3: UnaryF<C, D>, fn4: UnaryF<D, E>, fn5: UnaryF<E, F>, fn6: UnaryF<F, G>): NAryF<A, G>
  • composeL<A, B, C, D, E, F, G, H>(fn1: NAryF<A, B>, fn2: UnaryF<B, C>, fn3: UnaryF<C, D>, fn4: UnaryF<D, E>, fn5: UnaryF<E, F>, fn6: UnaryF<F, G>, fn7: UnaryF<G, H>): NAryF<A, H>
  • composeL<A, B, C, D, E, F, G, H, I>(fn1: NAryF<A, B>, fn2: UnaryF<B, C>, fn3: UnaryF<C, D>, fn4: UnaryF<D, E>, fn5: UnaryF<E, F>, fn6: UnaryF<F, G>, fn7: UnaryF<G, H>, fn8: UnaryF<H, I>): NAryF<A, I>
  • composeL<A, B, C, D, E, F, G, H, I, J>(fn1: NAryF<A, B>, fn2: UnaryF<B, C>, fn3: UnaryF<C, D>, fn4: UnaryF<D, E>, fn5: UnaryF<E, F>, fn6: UnaryF<F, G>, fn7: UnaryF<G, H>, fn8: UnaryF<H, I>, fn9: UnaryF<I, J>): NAryF<A, J>
  • composeL<A, B, C, D, E, F, G, H, I, J, K>(fn1: NAryF<A, B>, fn2: UnaryF<B, C>, fn3: UnaryF<C, D>, fn4: UnaryF<D, E>, fn5: UnaryF<E, F>, fn6: UnaryF<F, G>, fn7: UnaryF<G, H>, fn8: UnaryF<H, I>, fn9: UnaryF<I, J>, fn10: UnaryF<J, K>): NAryF<A, K>
  • composeL<A, B, C, D, E, F, G, H, I, J, K>(fn1: NAryF<A, B>, fn2: UnaryF<B, C>, fn3: UnaryF<C, D>, fn4: UnaryF<D, E>, fn5: UnaryF<E, F>, fn6: UnaryF<F, G>, fn7: UnaryF<G, H>, fn8: UnaryF<H, I>, fn9: UnaryF<I, J>, fn10: UnaryF<J, K>, ...fns: UnaryF<any, any>[]): NAryF<A, any>
  • Returns <T>(target: T, ...args: unknown[]) => T

      • <T>(target: T, ...args: unknown[]): T
      • Type parameters

        • T = unknown

        Parameters

        • target: T
        • Rest ...args: unknown[]

        Returns T

  • Type parameters

    • A: any[]

    • B = any

    Parameters

    • fn1: NAryF<A, B>

    Returns NAryF<A, B>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    Parameters

    • fn1: NAryF<A, B>
    • fn2: UnaryF<B, C>

    Returns NAryF<A, C>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    Parameters

    • fn1: NAryF<A, B>
    • fn2: UnaryF<B, C>
    • fn3: UnaryF<C, D>

    Returns NAryF<A, D>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    Parameters

    • fn1: NAryF<A, B>
    • fn2: UnaryF<B, C>
    • fn3: UnaryF<C, D>
    • fn4: UnaryF<D, E>

    Returns NAryF<A, E>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    • F = any

    Parameters

    • fn1: NAryF<A, B>
    • fn2: UnaryF<B, C>
    • fn3: UnaryF<C, D>
    • fn4: UnaryF<D, E>
    • fn5: UnaryF<E, F>

    Returns NAryF<A, F>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    • F = any

    • G = any

    Parameters

    • fn1: NAryF<A, B>
    • fn2: UnaryF<B, C>
    • fn3: UnaryF<C, D>
    • fn4: UnaryF<D, E>
    • fn5: UnaryF<E, F>
    • fn6: UnaryF<F, G>

    Returns NAryF<A, G>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    • F = any

    • G = any

    • H = any

    Parameters

    • fn1: NAryF<A, B>
    • fn2: UnaryF<B, C>
    • fn3: UnaryF<C, D>
    • fn4: UnaryF<D, E>
    • fn5: UnaryF<E, F>
    • fn6: UnaryF<F, G>
    • fn7: UnaryF<G, H>

    Returns NAryF<A, H>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    • F = any

    • G = any

    • H = any

    • I = any

    Parameters

    • fn1: NAryF<A, B>
    • fn2: UnaryF<B, C>
    • fn3: UnaryF<C, D>
    • fn4: UnaryF<D, E>
    • fn5: UnaryF<E, F>
    • fn6: UnaryF<F, G>
    • fn7: UnaryF<G, H>
    • fn8: UnaryF<H, I>

    Returns NAryF<A, I>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    • F = any

    • G = any

    • H = any

    • I = any

    • J = any

    Parameters

    • fn1: NAryF<A, B>
    • fn2: UnaryF<B, C>
    • fn3: UnaryF<C, D>
    • fn4: UnaryF<D, E>
    • fn5: UnaryF<E, F>
    • fn6: UnaryF<F, G>
    • fn7: UnaryF<G, H>
    • fn8: UnaryF<H, I>
    • fn9: UnaryF<I, J>

    Returns NAryF<A, J>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    • F = any

    • G = any

    • H = any

    • I = any

    • J = any

    • K = any

    Parameters

    • fn1: NAryF<A, B>
    • fn2: UnaryF<B, C>
    • fn3: UnaryF<C, D>
    • fn4: UnaryF<D, E>
    • fn5: UnaryF<E, F>
    • fn6: UnaryF<F, G>
    • fn7: UnaryF<G, H>
    • fn8: UnaryF<H, I>
    • fn9: UnaryF<I, J>
    • fn10: UnaryF<J, K>

    Returns NAryF<A, K>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    • F = any

    • G = any

    • H = any

    • I = any

    • J = any

    • K = any

    Parameters

    • fn1: NAryF<A, B>
    • fn2: UnaryF<B, C>
    • fn3: UnaryF<C, D>
    • fn4: UnaryF<D, E>
    • fn5: UnaryF<E, F>
    • fn6: UnaryF<F, G>
    • fn7: UnaryF<G, H>
    • fn8: UnaryF<H, I>
    • fn9: UnaryF<I, J>
    • fn10: UnaryF<J, K>
    • Rest ...fns: UnaryF<any, any>[]

    Returns NAryF<A, any>

Const composeR

  • composeR(): <T>(target: T, ...args: unknown[]) => T
  • composeR<A, B>(fn1: NAryF<A, B>): NAryF<A, B>
  • composeR<A, B, C>(fn2: UnaryF<B, C>, fn1: NAryF<A, B>): NAryF<A, C>
  • composeR<A, B, C, D>(fn3: UnaryF<C, D>, fn2: UnaryF<B, C>, fn1: NAryF<A, B>): NAryF<A, D>
  • composeR<A, B, C, D, E>(fn4: UnaryF<D, E>, fn3: UnaryF<C, D>, fn2: UnaryF<B, C>, fn1: NAryF<A, B>): NAryF<A, E>
  • composeR<A, B, C, D, E, F>(fn5: UnaryF<D, E>, fn4: UnaryF<C, D>, fn3: UnaryF<B, C>, fn2: UnaryF<B, C>, fn1: NAryF<A, B>): NAryF<A, F>
  • composeR<A, B, C, D, E, F, G>(fn6: UnaryF<E, F>, fn5: UnaryF<D, E>, fn4: UnaryF<C, D>, fn3: UnaryF<B, C>, fn2: UnaryF<B, C>, fn1: NAryF<A, B>): NAryF<A, G>
  • composeR<A, B, C, D, E, F, G, H>(fn7: UnaryF<F, G>, fn6: UnaryF<E, F>, fn5: UnaryF<D, E>, fn4: UnaryF<C, D>, fn3: UnaryF<B, C>, fn2: UnaryF<B, C>, fn1: NAryF<A, B>): NAryF<A, H>
  • composeR<A, B, C, D, E, F, G, H, I>(fn8: UnaryF<G, H>, fn7: UnaryF<F, G>, fn6: UnaryF<E, F>, fn5: UnaryF<D, E>, fn4: UnaryF<C, D>, fn3: UnaryF<B, C>, fn2: UnaryF<B, C>, fn1: NAryF<A, B>): NAryF<A, I>
  • composeR<A, B, C, D, E, F, G, H, I, J>(fn9: UnaryF<H, I>, fn8: UnaryF<G, H>, fn7: UnaryF<F, G>, fn6: UnaryF<E, F>, fn5: UnaryF<D, E>, fn4: UnaryF<C, D>, fn3: UnaryF<B, C>, fn2: UnaryF<B, C>, fn1: NAryF<A, B>): NAryF<A, J>
  • composeR<A, B, C, D, E, F, G, H, I, J, K>(fn10: UnaryF<I, J>, fn9: UnaryF<H, I>, fn8: UnaryF<G, H>, fn7: UnaryF<F, G>, fn6: UnaryF<E, F>, fn5: UnaryF<D, E>, fn4: UnaryF<C, D>, fn3: UnaryF<B, C>, fn2: UnaryF<B, C>, fn1: NAryF<A, B>): NAryF<A, K>
  • Returns <T>(target: T, ...args: unknown[]) => T

      • <T>(target: T, ...args: unknown[]): T
      • Type parameters

        • T = unknown

        Parameters

        • target: T
        • Rest ...args: unknown[]

        Returns T

  • Type parameters

    • A: any[]

    • B = any

    Parameters

    • fn1: NAryF<A, B>

    Returns NAryF<A, B>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    Parameters

    • fn2: UnaryF<B, C>
    • fn1: NAryF<A, B>

    Returns NAryF<A, C>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    Parameters

    • fn3: UnaryF<C, D>
    • fn2: UnaryF<B, C>
    • fn1: NAryF<A, B>

    Returns NAryF<A, D>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    Parameters

    • fn4: UnaryF<D, E>
    • fn3: UnaryF<C, D>
    • fn2: UnaryF<B, C>
    • fn1: NAryF<A, B>

    Returns NAryF<A, E>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    • F = any

    Parameters

    • fn5: UnaryF<D, E>
    • fn4: UnaryF<C, D>
    • fn3: UnaryF<B, C>
    • fn2: UnaryF<B, C>
    • fn1: NAryF<A, B>

    Returns NAryF<A, F>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    • F = any

    • G = any

    Parameters

    • fn6: UnaryF<E, F>
    • fn5: UnaryF<D, E>
    • fn4: UnaryF<C, D>
    • fn3: UnaryF<B, C>
    • fn2: UnaryF<B, C>
    • fn1: NAryF<A, B>

    Returns NAryF<A, G>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    • F = any

    • G = any

    • H = any

    Parameters

    • fn7: UnaryF<F, G>
    • fn6: UnaryF<E, F>
    • fn5: UnaryF<D, E>
    • fn4: UnaryF<C, D>
    • fn3: UnaryF<B, C>
    • fn2: UnaryF<B, C>
    • fn1: NAryF<A, B>

    Returns NAryF<A, H>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    • F = any

    • G = any

    • H = any

    • I = any

    Parameters

    • fn8: UnaryF<G, H>
    • fn7: UnaryF<F, G>
    • fn6: UnaryF<E, F>
    • fn5: UnaryF<D, E>
    • fn4: UnaryF<C, D>
    • fn3: UnaryF<B, C>
    • fn2: UnaryF<B, C>
    • fn1: NAryF<A, B>

    Returns NAryF<A, I>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    • F = any

    • G = any

    • H = any

    • I = any

    • J = any

    Parameters

    • fn9: UnaryF<H, I>
    • fn8: UnaryF<G, H>
    • fn7: UnaryF<F, G>
    • fn6: UnaryF<E, F>
    • fn5: UnaryF<D, E>
    • fn4: UnaryF<C, D>
    • fn3: UnaryF<B, C>
    • fn2: UnaryF<B, C>
    • fn1: NAryF<A, B>

    Returns NAryF<A, J>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    • F = any

    • G = any

    • H = any

    • I = any

    • J = any

    • K = any

    Parameters

    • fn10: UnaryF<I, J>
    • fn9: UnaryF<H, I>
    • fn8: UnaryF<G, H>
    • fn7: UnaryF<F, G>
    • fn6: UnaryF<E, F>
    • fn5: UnaryF<D, E>
    • fn4: UnaryF<C, D>
    • fn3: UnaryF<B, C>
    • fn2: UnaryF<B, C>
    • fn1: NAryF<A, B>

    Returns NAryF<A, K>

Const pipeL

  • pipeL(): <T>(target: T, ...args: unknown[]) => T
  • pipeL<A, B>(fn1: NAryF<A, B>): NAryF<A, B>
  • pipeL<A, B, C>(fn1: NAryF<A, B>, fn2: UnaryF<B, C>): NAryF<A, C>
  • pipeL<A, B, C, D>(fn1: NAryF<A, B>, fn2: UnaryF<B, C>, fn3: UnaryF<C, D>): NAryF<A, D>
  • pipeL<A, B, C, D, E>(fn1: NAryF<A, B>, fn2: UnaryF<B, C>, fn3: UnaryF<C, D>, fn4: UnaryF<D, E>): NAryF<A, E>
  • pipeL<A, B, C, D, E, F>(fn1: NAryF<A, B>, fn2: UnaryF<B, C>, fn3: UnaryF<C, D>, fn4: UnaryF<D, E>, fn5: UnaryF<E, F>): NAryF<A, F>
  • pipeL<A, B, C, D, E, F, G>(fn1: NAryF<A, B>, fn2: UnaryF<B, C>, fn3: UnaryF<C, D>, fn4: UnaryF<D, E>, fn5: UnaryF<E, F>, fn6: UnaryF<F, G>): NAryF<A, G>
  • pipeL<A, B, C, D, E, F, G, H>(fn1: NAryF<A, B>, fn2: UnaryF<B, C>, fn3: UnaryF<C, D>, fn4: UnaryF<D, E>, fn5: UnaryF<E, F>, fn6: UnaryF<F, G>, fn7: UnaryF<G, H>): NAryF<A, H>
  • pipeL<A, B, C, D, E, F, G, H, I>(fn1: NAryF<A, B>, fn2: UnaryF<B, C>, fn3: UnaryF<C, D>, fn4: UnaryF<D, E>, fn5: UnaryF<E, F>, fn6: UnaryF<F, G>, fn7: UnaryF<G, H>, fn8: UnaryF<H, I>): NAryF<A, I>
  • pipeL<A, B, C, D, E, F, G, H, I, J>(fn1: NAryF<A, B>, fn2: UnaryF<B, C>, fn3: UnaryF<C, D>, fn4: UnaryF<D, E>, fn5: UnaryF<E, F>, fn6: UnaryF<F, G>, fn7: UnaryF<G, H>, fn8: UnaryF<H, I>, fn9: UnaryF<I, J>): NAryF<A, J>
  • pipeL<A, B, C, D, E, F, G, H, I, J, K>(fn1: NAryF<A, B>, fn2: UnaryF<B, C>, fn3: UnaryF<C, D>, fn4: UnaryF<D, E>, fn5: UnaryF<E, F>, fn6: UnaryF<F, G>, fn7: UnaryF<G, H>, fn8: UnaryF<H, I>, fn9: UnaryF<I, J>, fn10: UnaryF<J, K>): NAryF<A, K>
  • pipeL<A, B, C, D, E, F, G, H, I, J, K>(fn1: NAryF<A, B>, fn2: UnaryF<B, C>, fn3: UnaryF<C, D>, fn4: UnaryF<D, E>, fn5: UnaryF<E, F>, fn6: UnaryF<F, G>, fn7: UnaryF<G, H>, fn8: UnaryF<H, I>, fn9: UnaryF<I, J>, fn10: UnaryF<J, K>, ...fns: UnaryF<any, any>[]): NAryF<A, any>
  • Returns <T>(target: T, ...args: unknown[]) => T

      • <T>(target: T, ...args: unknown[]): T
      • Type parameters

        • T = unknown

        Parameters

        • target: T
        • Rest ...args: unknown[]

        Returns T

  • Type parameters

    • A: any[]

    • B = any

    Parameters

    • fn1: NAryF<A, B>

    Returns NAryF<A, B>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    Parameters

    • fn1: NAryF<A, B>
    • fn2: UnaryF<B, C>

    Returns NAryF<A, C>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    Parameters

    • fn1: NAryF<A, B>
    • fn2: UnaryF<B, C>
    • fn3: UnaryF<C, D>

    Returns NAryF<A, D>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    Parameters

    • fn1: NAryF<A, B>
    • fn2: UnaryF<B, C>
    • fn3: UnaryF<C, D>
    • fn4: UnaryF<D, E>

    Returns NAryF<A, E>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    • F = any

    Parameters

    • fn1: NAryF<A, B>
    • fn2: UnaryF<B, C>
    • fn3: UnaryF<C, D>
    • fn4: UnaryF<D, E>
    • fn5: UnaryF<E, F>

    Returns NAryF<A, F>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    • F = any

    • G = any

    Parameters

    • fn1: NAryF<A, B>
    • fn2: UnaryF<B, C>
    • fn3: UnaryF<C, D>
    • fn4: UnaryF<D, E>
    • fn5: UnaryF<E, F>
    • fn6: UnaryF<F, G>

    Returns NAryF<A, G>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    • F = any

    • G = any

    • H = any

    Parameters

    • fn1: NAryF<A, B>
    • fn2: UnaryF<B, C>
    • fn3: UnaryF<C, D>
    • fn4: UnaryF<D, E>
    • fn5: UnaryF<E, F>
    • fn6: UnaryF<F, G>
    • fn7: UnaryF<G, H>

    Returns NAryF<A, H>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    • F = any

    • G = any

    • H = any

    • I = any

    Parameters

    • fn1: NAryF<A, B>
    • fn2: UnaryF<B, C>
    • fn3: UnaryF<C, D>
    • fn4: UnaryF<D, E>
    • fn5: UnaryF<E, F>
    • fn6: UnaryF<F, G>
    • fn7: UnaryF<G, H>
    • fn8: UnaryF<H, I>

    Returns NAryF<A, I>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    • F = any

    • G = any

    • H = any

    • I = any

    • J = any

    Parameters

    • fn1: NAryF<A, B>
    • fn2: UnaryF<B, C>
    • fn3: UnaryF<C, D>
    • fn4: UnaryF<D, E>
    • fn5: UnaryF<E, F>
    • fn6: UnaryF<F, G>
    • fn7: UnaryF<G, H>
    • fn8: UnaryF<H, I>
    • fn9: UnaryF<I, J>

    Returns NAryF<A, J>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    • F = any

    • G = any

    • H = any

    • I = any

    • J = any

    • K = any

    Parameters

    • fn1: NAryF<A, B>
    • fn2: UnaryF<B, C>
    • fn3: UnaryF<C, D>
    • fn4: UnaryF<D, E>
    • fn5: UnaryF<E, F>
    • fn6: UnaryF<F, G>
    • fn7: UnaryF<G, H>
    • fn8: UnaryF<H, I>
    • fn9: UnaryF<I, J>
    • fn10: UnaryF<J, K>

    Returns NAryF<A, K>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    • F = any

    • G = any

    • H = any

    • I = any

    • J = any

    • K = any

    Parameters

    • fn1: NAryF<A, B>
    • fn2: UnaryF<B, C>
    • fn3: UnaryF<C, D>
    • fn4: UnaryF<D, E>
    • fn5: UnaryF<E, F>
    • fn6: UnaryF<F, G>
    • fn7: UnaryF<G, H>
    • fn8: UnaryF<H, I>
    • fn9: UnaryF<I, J>
    • fn10: UnaryF<J, K>
    • Rest ...fns: UnaryF<any, any>[]

    Returns NAryF<A, any>

Const pipeR

  • pipeR(): <T>(target: T, ...args: unknown[]) => T
  • pipeR<A, B>(fn1: NAryF<A, B>): NAryF<A, B>
  • pipeR<A, B, C>(fn2: UnaryF<B, C>, fn1: NAryF<A, B>): NAryF<A, C>
  • pipeR<A, B, C, D>(fn3: UnaryF<C, D>, fn2: UnaryF<B, C>, fn1: NAryF<A, B>): NAryF<A, D>
  • pipeR<A, B, C, D, E>(fn4: UnaryF<D, E>, fn3: UnaryF<C, D>, fn2: UnaryF<B, C>, fn1: NAryF<A, B>): NAryF<A, E>
  • pipeR<A, B, C, D, E, F>(fn5: UnaryF<D, E>, fn4: UnaryF<C, D>, fn3: UnaryF<B, C>, fn2: UnaryF<B, C>, fn1: NAryF<A, B>): NAryF<A, F>
  • pipeR<A, B, C, D, E, F, G>(fn6: UnaryF<E, F>, fn5: UnaryF<D, E>, fn4: UnaryF<C, D>, fn3: UnaryF<B, C>, fn2: UnaryF<B, C>, fn1: NAryF<A, B>): NAryF<A, G>
  • pipeR<A, B, C, D, E, F, G, H>(fn7: UnaryF<F, G>, fn6: UnaryF<E, F>, fn5: UnaryF<D, E>, fn4: UnaryF<C, D>, fn3: UnaryF<B, C>, fn2: UnaryF<B, C>, fn1: NAryF<A, B>): NAryF<A, H>
  • pipeR<A, B, C, D, E, F, G, H, I>(fn8: UnaryF<G, H>, fn7: UnaryF<F, G>, fn6: UnaryF<E, F>, fn5: UnaryF<D, E>, fn4: UnaryF<C, D>, fn3: UnaryF<B, C>, fn2: UnaryF<B, C>, fn1: NAryF<A, B>): NAryF<A, I>
  • pipeR<A, B, C, D, E, F, G, H, I, J>(fn9: UnaryF<H, I>, fn8: UnaryF<G, H>, fn7: UnaryF<F, G>, fn6: UnaryF<E, F>, fn5: UnaryF<D, E>, fn4: UnaryF<C, D>, fn3: UnaryF<B, C>, fn2: UnaryF<B, C>, fn1: NAryF<A, B>): NAryF<A, J>
  • pipeR<A, B, C, D, E, F, G, H, I, J, K>(fn10: UnaryF<I, J>, fn9: UnaryF<H, I>, fn8: UnaryF<G, H>, fn7: UnaryF<F, G>, fn6: UnaryF<E, F>, fn5: UnaryF<D, E>, fn4: UnaryF<C, D>, fn3: UnaryF<B, C>, fn2: UnaryF<B, C>, fn1: NAryF<A, B>): NAryF<A, K>
  • Returns <T>(target: T, ...args: unknown[]) => T

      • <T>(target: T, ...args: unknown[]): T
      • Type parameters

        • T = unknown

        Parameters

        • target: T
        • Rest ...args: unknown[]

        Returns T

  • Type parameters

    • A: any[]

    • B = any

    Parameters

    • fn1: NAryF<A, B>

    Returns NAryF<A, B>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    Parameters

    • fn2: UnaryF<B, C>
    • fn1: NAryF<A, B>

    Returns NAryF<A, C>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    Parameters

    • fn3: UnaryF<C, D>
    • fn2: UnaryF<B, C>
    • fn1: NAryF<A, B>

    Returns NAryF<A, D>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    Parameters

    • fn4: UnaryF<D, E>
    • fn3: UnaryF<C, D>
    • fn2: UnaryF<B, C>
    • fn1: NAryF<A, B>

    Returns NAryF<A, E>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    • F = any

    Parameters

    • fn5: UnaryF<D, E>
    • fn4: UnaryF<C, D>
    • fn3: UnaryF<B, C>
    • fn2: UnaryF<B, C>
    • fn1: NAryF<A, B>

    Returns NAryF<A, F>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    • F = any

    • G = any

    Parameters

    • fn6: UnaryF<E, F>
    • fn5: UnaryF<D, E>
    • fn4: UnaryF<C, D>
    • fn3: UnaryF<B, C>
    • fn2: UnaryF<B, C>
    • fn1: NAryF<A, B>

    Returns NAryF<A, G>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    • F = any

    • G = any

    • H = any

    Parameters

    • fn7: UnaryF<F, G>
    • fn6: UnaryF<E, F>
    • fn5: UnaryF<D, E>
    • fn4: UnaryF<C, D>
    • fn3: UnaryF<B, C>
    • fn2: UnaryF<B, C>
    • fn1: NAryF<A, B>

    Returns NAryF<A, H>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    • F = any

    • G = any

    • H = any

    • I = any

    Parameters

    • fn8: UnaryF<G, H>
    • fn7: UnaryF<F, G>
    • fn6: UnaryF<E, F>
    • fn5: UnaryF<D, E>
    • fn4: UnaryF<C, D>
    • fn3: UnaryF<B, C>
    • fn2: UnaryF<B, C>
    • fn1: NAryF<A, B>

    Returns NAryF<A, I>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    • F = any

    • G = any

    • H = any

    • I = any

    • J = any

    Parameters

    • fn9: UnaryF<H, I>
    • fn8: UnaryF<G, H>
    • fn7: UnaryF<F, G>
    • fn6: UnaryF<E, F>
    • fn5: UnaryF<D, E>
    • fn4: UnaryF<C, D>
    • fn3: UnaryF<B, C>
    • fn2: UnaryF<B, C>
    • fn1: NAryF<A, B>

    Returns NAryF<A, J>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    • F = any

    • G = any

    • H = any

    • I = any

    • J = any

    • K = any

    Parameters

    • fn10: UnaryF<I, J>
    • fn9: UnaryF<H, I>
    • fn8: UnaryF<G, H>
    • fn7: UnaryF<F, G>
    • fn6: UnaryF<E, F>
    • fn5: UnaryF<D, E>
    • fn4: UnaryF<C, D>
    • fn3: UnaryF<B, C>
    • fn2: UnaryF<B, C>
    • fn1: NAryF<A, B>

    Returns NAryF<A, K>

Const compose

  • compose(): <T>(target: T, ...args: unknown[]) => T
  • compose<A, B>(fn1: NAryF<A, B>): NAryF<A, B>
  • compose<A, B, C>(fn2: UnaryF<B, C>, fn1: NAryF<A, B>): NAryF<A, C>
  • compose<A, B, C, D>(fn3: UnaryF<C, D>, fn2: UnaryF<B, C>, fn1: NAryF<A, B>): NAryF<A, D>
  • compose<A, B, C, D, E>(fn4: UnaryF<D, E>, fn3: UnaryF<C, D>, fn2: UnaryF<B, C>, fn1: NAryF<A, B>): NAryF<A, E>
  • compose<A, B, C, D, E, F>(fn5: UnaryF<D, E>, fn4: UnaryF<C, D>, fn3: UnaryF<B, C>, fn2: UnaryF<B, C>, fn1: NAryF<A, B>): NAryF<A, F>
  • compose<A, B, C, D, E, F, G>(fn6: UnaryF<E, F>, fn5: UnaryF<D, E>, fn4: UnaryF<C, D>, fn3: UnaryF<B, C>, fn2: UnaryF<B, C>, fn1: NAryF<A, B>): NAryF<A, G>
  • compose<A, B, C, D, E, F, G, H>(fn7: UnaryF<F, G>, fn6: UnaryF<E, F>, fn5: UnaryF<D, E>, fn4: UnaryF<C, D>, fn3: UnaryF<B, C>, fn2: UnaryF<B, C>, fn1: NAryF<A, B>): NAryF<A, H>
  • compose<A, B, C, D, E, F, G, H, I>(fn8: UnaryF<G, H>, fn7: UnaryF<F, G>, fn6: UnaryF<E, F>, fn5: UnaryF<D, E>, fn4: UnaryF<C, D>, fn3: UnaryF<B, C>, fn2: UnaryF<B, C>, fn1: NAryF<A, B>): NAryF<A, I>
  • compose<A, B, C, D, E, F, G, H, I, J>(fn9: UnaryF<H, I>, fn8: UnaryF<G, H>, fn7: UnaryF<F, G>, fn6: UnaryF<E, F>, fn5: UnaryF<D, E>, fn4: UnaryF<C, D>, fn3: UnaryF<B, C>, fn2: UnaryF<B, C>, fn1: NAryF<A, B>): NAryF<A, J>
  • compose<A, B, C, D, E, F, G, H, I, J, K>(fn10: UnaryF<I, J>, fn9: UnaryF<H, I>, fn8: UnaryF<G, H>, fn7: UnaryF<F, G>, fn6: UnaryF<E, F>, fn5: UnaryF<D, E>, fn4: UnaryF<C, D>, fn3: UnaryF<B, C>, fn2: UnaryF<B, C>, fn1: NAryF<A, B>): NAryF<A, K>
  • Returns <T>(target: T, ...args: unknown[]) => T

      • <T>(target: T, ...args: unknown[]): T
      • Type parameters

        • T = unknown

        Parameters

        • target: T
        • Rest ...args: unknown[]

        Returns T

  • Type parameters

    • A: any[]

    • B = any

    Parameters

    • fn1: NAryF<A, B>

    Returns NAryF<A, B>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    Parameters

    • fn2: UnaryF<B, C>
    • fn1: NAryF<A, B>

    Returns NAryF<A, C>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    Parameters

    • fn3: UnaryF<C, D>
    • fn2: UnaryF<B, C>
    • fn1: NAryF<A, B>

    Returns NAryF<A, D>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    Parameters

    • fn4: UnaryF<D, E>
    • fn3: UnaryF<C, D>
    • fn2: UnaryF<B, C>
    • fn1: NAryF<A, B>

    Returns NAryF<A, E>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    • F = any

    Parameters

    • fn5: UnaryF<D, E>
    • fn4: UnaryF<C, D>
    • fn3: UnaryF<B, C>
    • fn2: UnaryF<B, C>
    • fn1: NAryF<A, B>

    Returns NAryF<A, F>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    • F = any

    • G = any

    Parameters

    • fn6: UnaryF<E, F>
    • fn5: UnaryF<D, E>
    • fn4: UnaryF<C, D>
    • fn3: UnaryF<B, C>
    • fn2: UnaryF<B, C>
    • fn1: NAryF<A, B>

    Returns NAryF<A, G>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    • F = any

    • G = any

    • H = any

    Parameters

    • fn7: UnaryF<F, G>
    • fn6: UnaryF<E, F>
    • fn5: UnaryF<D, E>
    • fn4: UnaryF<C, D>
    • fn3: UnaryF<B, C>
    • fn2: UnaryF<B, C>
    • fn1: NAryF<A, B>

    Returns NAryF<A, H>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    • F = any

    • G = any

    • H = any

    • I = any

    Parameters

    • fn8: UnaryF<G, H>
    • fn7: UnaryF<F, G>
    • fn6: UnaryF<E, F>
    • fn5: UnaryF<D, E>
    • fn4: UnaryF<C, D>
    • fn3: UnaryF<B, C>
    • fn2: UnaryF<B, C>
    • fn1: NAryF<A, B>

    Returns NAryF<A, I>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    • F = any

    • G = any

    • H = any

    • I = any

    • J = any

    Parameters

    • fn9: UnaryF<H, I>
    • fn8: UnaryF<G, H>
    • fn7: UnaryF<F, G>
    • fn6: UnaryF<E, F>
    • fn5: UnaryF<D, E>
    • fn4: UnaryF<C, D>
    • fn3: UnaryF<B, C>
    • fn2: UnaryF<B, C>
    • fn1: NAryF<A, B>

    Returns NAryF<A, J>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    • F = any

    • G = any

    • H = any

    • I = any

    • J = any

    • K = any

    Parameters

    • fn10: UnaryF<I, J>
    • fn9: UnaryF<H, I>
    • fn8: UnaryF<G, H>
    • fn7: UnaryF<F, G>
    • fn6: UnaryF<E, F>
    • fn5: UnaryF<D, E>
    • fn4: UnaryF<C, D>
    • fn3: UnaryF<B, C>
    • fn2: UnaryF<B, C>
    • fn1: NAryF<A, B>

    Returns NAryF<A, K>

Const pipe

  • pipe(): <T>(target: T, ...args: unknown[]) => T
  • pipe<A, B>(fn1: NAryF<A, B>): NAryF<A, B>
  • pipe<A, B, C>(fn1: NAryF<A, B>, fn2: UnaryF<B, C>): NAryF<A, C>
  • pipe<A, B, C, D>(fn1: NAryF<A, B>, fn2: UnaryF<B, C>, fn3: UnaryF<C, D>): NAryF<A, D>
  • pipe<A, B, C, D, E>(fn1: NAryF<A, B>, fn2: UnaryF<B, C>, fn3: UnaryF<C, D>, fn4: UnaryF<D, E>): NAryF<A, E>
  • pipe<A, B, C, D, E, F>(fn1: NAryF<A, B>, fn2: UnaryF<B, C>, fn3: UnaryF<C, D>, fn4: UnaryF<D, E>, fn5: UnaryF<E, F>): NAryF<A, F>
  • pipe<A, B, C, D, E, F, G>(fn1: NAryF<A, B>, fn2: UnaryF<B, C>, fn3: UnaryF<C, D>, fn4: UnaryF<D, E>, fn5: UnaryF<E, F>, fn6: UnaryF<F, G>): NAryF<A, G>
  • pipe<A, B, C, D, E, F, G, H>(fn1: NAryF<A, B>, fn2: UnaryF<B, C>, fn3: UnaryF<C, D>, fn4: UnaryF<D, E>, fn5: UnaryF<E, F>, fn6: UnaryF<F, G>, fn7: UnaryF<G, H>): NAryF<A, H>
  • pipe<A, B, C, D, E, F, G, H, I>(fn1: NAryF<A, B>, fn2: UnaryF<B, C>, fn3: UnaryF<C, D>, fn4: UnaryF<D, E>, fn5: UnaryF<E, F>, fn6: UnaryF<F, G>, fn7: UnaryF<G, H>, fn8: UnaryF<H, I>): NAryF<A, I>
  • pipe<A, B, C, D, E, F, G, H, I, J>(fn1: NAryF<A, B>, fn2: UnaryF<B, C>, fn3: UnaryF<C, D>, fn4: UnaryF<D, E>, fn5: UnaryF<E, F>, fn6: UnaryF<F, G>, fn7: UnaryF<G, H>, fn8: UnaryF<H, I>, fn9: UnaryF<I, J>): NAryF<A, J>
  • pipe<A, B, C, D, E, F, G, H, I, J, K>(fn1: NAryF<A, B>, fn2: UnaryF<B, C>, fn3: UnaryF<C, D>, fn4: UnaryF<D, E>, fn5: UnaryF<E, F>, fn6: UnaryF<F, G>, fn7: UnaryF<G, H>, fn8: UnaryF<H, I>, fn9: UnaryF<I, J>, fn10: UnaryF<J, K>): NAryF<A, K>
  • pipe<A, B, C, D, E, F, G, H, I, J, K>(fn1: NAryF<A, B>, fn2: UnaryF<B, C>, fn3: UnaryF<C, D>, fn4: UnaryF<D, E>, fn5: UnaryF<E, F>, fn6: UnaryF<F, G>, fn7: UnaryF<G, H>, fn8: UnaryF<H, I>, fn9: UnaryF<I, J>, fn10: UnaryF<J, K>, ...fns: UnaryF<any, any>[]): NAryF<A, any>
  • Returns <T>(target: T, ...args: unknown[]) => T

      • <T>(target: T, ...args: unknown[]): T
      • Type parameters

        • T = unknown

        Parameters

        • target: T
        • Rest ...args: unknown[]

        Returns T

  • Type parameters

    • A: any[]

    • B = any

    Parameters

    • fn1: NAryF<A, B>

    Returns NAryF<A, B>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    Parameters

    • fn1: NAryF<A, B>
    • fn2: UnaryF<B, C>

    Returns NAryF<A, C>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    Parameters

    • fn1: NAryF<A, B>
    • fn2: UnaryF<B, C>
    • fn3: UnaryF<C, D>

    Returns NAryF<A, D>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    Parameters

    • fn1: NAryF<A, B>
    • fn2: UnaryF<B, C>
    • fn3: UnaryF<C, D>
    • fn4: UnaryF<D, E>

    Returns NAryF<A, E>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    • F = any

    Parameters

    • fn1: NAryF<A, B>
    • fn2: UnaryF<B, C>
    • fn3: UnaryF<C, D>
    • fn4: UnaryF<D, E>
    • fn5: UnaryF<E, F>

    Returns NAryF<A, F>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    • F = any

    • G = any

    Parameters

    • fn1: NAryF<A, B>
    • fn2: UnaryF<B, C>
    • fn3: UnaryF<C, D>
    • fn4: UnaryF<D, E>
    • fn5: UnaryF<E, F>
    • fn6: UnaryF<F, G>

    Returns NAryF<A, G>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    • F = any

    • G = any

    • H = any

    Parameters

    • fn1: NAryF<A, B>
    • fn2: UnaryF<B, C>
    • fn3: UnaryF<C, D>
    • fn4: UnaryF<D, E>
    • fn5: UnaryF<E, F>
    • fn6: UnaryF<F, G>
    • fn7: UnaryF<G, H>

    Returns NAryF<A, H>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    • F = any

    • G = any

    • H = any

    • I = any

    Parameters

    • fn1: NAryF<A, B>
    • fn2: UnaryF<B, C>
    • fn3: UnaryF<C, D>
    • fn4: UnaryF<D, E>
    • fn5: UnaryF<E, F>
    • fn6: UnaryF<F, G>
    • fn7: UnaryF<G, H>
    • fn8: UnaryF<H, I>

    Returns NAryF<A, I>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    • F = any

    • G = any

    • H = any

    • I = any

    • J = any

    Parameters

    • fn1: NAryF<A, B>
    • fn2: UnaryF<B, C>
    • fn3: UnaryF<C, D>
    • fn4: UnaryF<D, E>
    • fn5: UnaryF<E, F>
    • fn6: UnaryF<F, G>
    • fn7: UnaryF<G, H>
    • fn8: UnaryF<H, I>
    • fn9: UnaryF<I, J>

    Returns NAryF<A, J>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    • F = any

    • G = any

    • H = any

    • I = any

    • J = any

    • K = any

    Parameters

    • fn1: NAryF<A, B>
    • fn2: UnaryF<B, C>
    • fn3: UnaryF<C, D>
    • fn4: UnaryF<D, E>
    • fn5: UnaryF<E, F>
    • fn6: UnaryF<F, G>
    • fn7: UnaryF<G, H>
    • fn8: UnaryF<H, I>
    • fn9: UnaryF<I, J>
    • fn10: UnaryF<J, K>

    Returns NAryF<A, K>

  • Type parameters

    • A: any[]

    • B = any

    • C = any

    • D = any

    • E = any

    • F = any

    • G = any

    • H = any

    • I = any

    • J = any

    • K = any

    Parameters

    • fn1: NAryF<A, B>
    • fn2: UnaryF<B, C>
    • fn3: UnaryF<C, D>
    • fn4: UnaryF<D, E>
    • fn5: UnaryF<E, F>
    • fn6: UnaryF<F, G>
    • fn7: UnaryF<G, H>
    • fn8: UnaryF<H, I>
    • fn9: UnaryF<I, J>
    • fn10: UnaryF<J, K>
    • Rest ...fns: UnaryF<any, any>[]

    Returns NAryF<A, any>

Const defaultMemorizeHasher

  • defaultMemorizeHasher(...args: any[]): string

Const memorize

  • memorize<FN>(fn: FN, hasher: (...args: Parameters<FN>) => any): (...args: Parameters<FN>) => ReturnType<FN>
  • Return a new function which bind to a cache map. When the function is called, it will first check the cache map, if the result is found, return it. Otherwise, call the function and cache the result.

    Type parameters

    • FN: AnyFunction

    Parameters

    • fn: FN
    • hasher: (...args: Parameters<FN>) => any
        • (...args: Parameters<FN>): any
        • Parameters

          • Rest ...args: Parameters<FN>

          Returns any

    Returns (...args: Parameters<FN>) => ReturnType<FN>

      • (...args: Parameters<FN>): ReturnType<FN>
      • Parameters

        • Rest ...args: Parameters<FN>

        Returns ReturnType<FN>

Const invoker

  • invoker(arity: number, key: string): AnyFunction

Const looseInvoker

  • looseInvoker(arity: number, key: string): AnyFunction

Const nAry

  • nAry(...args: any[]): any

Const looseNAry

  • looseNAry(...args: any[]): any

Const quaternary

  • quaternary(fn: AnyFunction): AnyFunction

Const looseQuaternary

  • looseQuaternary(fn: AnyFunction): AnyFunction

Const ternary

  • ternary(fn: AnyFunction): AnyFunction

Const looseTernary

  • looseTernary(fn: AnyFunction): AnyFunction

Const binary

  • binary(fn: AnyFunction): AnyFunction

Const looseBinary

  • looseBinary(fn: AnyFunction): AnyFunction

Const unary

  • unary(fn: AnyFunction): AnyFunction

Const looseUnary

  • looseUnary(fn: AnyFunction): AnyFunction

Const tap

  • tap(fn: AnyFunction): <T>(...args: [...any[], T]) => T
  • Parameters

    • fn: AnyFunction

    Returns <T>(...args: [...any[], T]) => T

      • <T>(...args: [...any[], T]): T
      • Type parameters

        • T: unknown

        Parameters

        • Rest ...args: [...any[], T]

        Returns T

Const execute

  • execute<FN>(fn: FN, ...args: [...Parameters<FN>[], ...any[]]): ReturnType<FN>

Const spreadToArray

  • spreadToArray<T>(target: Iterable<T>): T[]
  • Use spread operator to spread the iterable target into the array.

    Type parameters

    • T = any

    Parameters

    • target: Iterable<T>

    Returns T[]

Const arrayLength

  • arrayLength(targetArray: any[]): number

Const arrayPop

  • arrayPop<T>(targetArray: T[]): T[]
  • Returns a copy of targetArray in which last element has been removed. New array's length is targetArray.length - 1.

    see

    arrayPush, arrayShift

    Type parameters

    • T = any

    Parameters

    • targetArray: T[]

    Returns T[]

Const arrayPush

  • arrayPush<T>(item: T, targetArray: T[]): T[]

Const arrayAppend

  • arrayAppend<T>(item: T, targetArray: T[]): T[]

Const arrayUnshift

  • arrayUnshift<T>(item: T, targetArray: T[]): T[]

Const arrayPrepend

  • arrayPrepend<T>(item: T, targetArray: T[]): T[]

Const arrayShift

  • arrayShift<T>(targetArray: T[]): T[]
  • Returns a copy of targetArray in which first element has been removed. New array's length is targetArray's length - 1.

    see

    arrayUnshift, arrayPop

    Type parameters

    • T = any

    Parameters

    • targetArray: T[]

    Returns T[]

Const arrayHead

  • arrayHead<T>(targetArray: T[]): undefined | T

Const arrayTail

  • arrayTail<T>(targetArray: T[]): T[]

Const arrayInit

  • arrayInit<T>(targetArray: T[]): T[]

Const arrayLast

  • arrayLast<T>(targetArray: T[]): undefined | T

Const arraySlice

  • arraySlice<T>(start: number, end: number, targetArray: T[]): T[]

Const arraySliceTail

  • arraySliceTail<T>(start: number, targetArray: T[]): T[]

Const arrayDrop

  • arrayDrop<T>(n: number, targetArray: T[]): T[]

Const arraySliceInit

  • arraySliceInit<T>(end: number, targetArray: T[]): T[]

Const arrayDropLast

  • arrayDropLast<T>(n: number, targetArray: T[]): T[]

Const arrayRemoveIndex

  • arrayRemoveIndex<T>(index: number, targetArray: T[]): T[]

Const arrayConcat

  • arrayConcat<T>(appendedArray: T[], targetArray: T[]): T[]
  • Combines two array. appendedArray will be appended to the end of targetArray.

    see

    {@link Array.concat}

    Type parameters

    • T = any

    Parameters

    • appendedArray: T[]
    • targetArray: T[]

    Returns T[]

Const arrayJoin

  • arrayJoin(separator: string, targetArray: any[]): string
  • Adds all the elements of an array into a string, separated by the specified separator string.

    see

    {@link Array.join}

    Parameters

    • separator: string
    • targetArray: any[]

    Returns string

Const arrayIndexOf

  • arrayIndexOf(searchElement: any, targetArray: any[]): number

Const arrayLastIndexOf

  • arrayLastIndexOf(searchElement: any, targetArray: any[]): number

Const arrayIncludes

  • arrayIncludes<T>(searchElement: T, targetArray: T[]): boolean
  • Predicate whether the target array includes the searchElement.

    see

    {@link Array.includes}

    Type parameters

    • T = any

    Parameters

    • searchElement: T
    • targetArray: T[]

    Returns boolean

arrayEvery

  • arrayEvery<T, S>(predicate: (item: T, index: number, array: T[]) => item is S, targetArray: T[]): targetArray is S[]
  • arrayEvery<T>(predicate: (item: T, index: number, array: T[]) => boolean, targetArray: T[]): boolean
  • see

    {@link Array.every}

    Type parameters

    • T = any

    • S = T

    Parameters

    • predicate: (item: T, index: number, array: T[]) => item is S
        • (item: T, index: number, array: T[]): item is S
        • Parameters

          • item: T
          • index: number
          • array: T[]

          Returns item is S

    • targetArray: T[]

    Returns targetArray is S[]

  • Type parameters

    • T = any

    Parameters

    • predicate: (item: T, index: number, array: T[]) => boolean
        • (item: T, index: number, array: T[]): boolean
        • Parameters

          • item: T
          • index: number
          • array: T[]

          Returns boolean

    • targetArray: T[]

    Returns boolean

Const arrayAll

  • arrayAll<T, S>(predicate: (item: T, index: number, array: T[]) => item is S, targetArray: T[]): targetArray is S[]
  • arrayAll<T>(predicate: (item: T, index: number, array: T[]) => boolean, targetArray: T[]): boolean

Const arraySome

  • arraySome<T>(predicate: (item: T, index: number, array: T[]) => boolean, targetArray: T[]): boolean
  • see

    {@link Array.some}

    Type parameters

    • T = any

    Parameters

    • predicate: (item: T, index: number, array: T[]) => boolean
        • (item: T, index: number, array: T[]): boolean
        • Parameters

          • item: T
          • index: number
          • array: T[]

          Returns boolean

    • targetArray: T[]

    Returns boolean

Const arrayAny

  • arrayAny<T>(predicate: (item: T, index: number, array: T[]) => boolean, targetArray: T[]): boolean

Const arrayForEach

  • arrayForEach<T>(callback: (item: T, index: number, array: T[]) => void, targetArray: T[]): void
  • see

    {@link Array.forEach}

    Type parameters

    • T = any

    Parameters

    • callback: (item: T, index: number, array: T[]) => void
        • (item: T, index: number, array: T[]): void
        • Parameters

          • item: T
          • index: number
          • array: T[]

          Returns void

    • targetArray: T[]

    Returns void

arrayFilter

  • arrayFilter<T, S>(predicate: (item: T, index: number, array: T[]) => item is S, targetArray: T[]): S[]
  • arrayFilter<T>(predicate: (item: T, index: number, array: T[]) => boolean, targetArray: T[]): T[]
  • see

    {@link Array.filter}, arrayReject

    Type parameters

    • T = any

    • S = T

    Parameters

    • predicate: (item: T, index: number, array: T[]) => item is S
        • (item: T, index: number, array: T[]): item is S
        • Parameters

          • item: T
          • index: number
          • array: T[]

          Returns item is S

    • targetArray: T[]

    Returns S[]

  • Type parameters

    • T = any

    Parameters

    • predicate: (item: T, index: number, array: T[]) => boolean
        • (item: T, index: number, array: T[]): boolean
        • Parameters

          • item: T
          • index: number
          • array: T[]

          Returns boolean

    • targetArray: T[]

    Returns T[]

Const arrayReject

  • arrayReject<T>(predicate: (item: T, index: number, array: T[]) => boolean, targetArray: T[]): T[]
  • Type parameters

    • T = any

    Parameters

    • predicate: (item: T, index: number, array: T[]) => boolean
        • (item: T, index: number, array: T[]): boolean
        • Parameters

          • item: T
          • index: number
          • array: T[]

          Returns boolean

    • targetArray: T[]

    Returns T[]

Const arrayPartition

  • arrayPartition<T>(predicate: (item: T, index: number, array: T[]) => boolean, targetArray: T[]): [T[], T[]]
  • Type parameters

    • T = any

    Parameters

    • predicate: (item: T, index: number, array: T[]) => boolean
        • (item: T, index: number, array: T[]): boolean
        • Parameters

          • item: T
          • index: number
          • array: T[]

          Returns boolean

    • targetArray: T[]

    Returns [T[], T[]]

Const arrayMap

  • arrayMap<T, R>(transformation: (item: T, index: number, array: T[]) => R, targetArray: T[]): R[]
  • see

    {@link Array.map}

    Type parameters

    • T = any

    • R = any

    Parameters

    • transformation: (item: T, index: number, array: T[]) => R
        • (item: T, index: number, array: T[]): R
        • Parameters

          • item: T
          • index: number
          • array: T[]

          Returns R

    • targetArray: T[]

    Returns R[]

Const arrayFlat

  • arrayFlat<T, D>(depth: D, targetArray: T[]): FlatArray<T[], D>[]

Const arrayFlatMap

  • arrayFlatMap<T, R>(transformation: (item: T, index: number, array: T[]) => R | R[], targetArray: T[]): R[]
  • see

    {@link Array.flatMap}, arrayMap, arrayFlat

    Type parameters

    • T = any

    • R = any

    Parameters

    • transformation: (item: T, index: number, array: T[]) => R | R[]
        • (item: T, index: number, array: T[]): R | R[]
        • Parameters

          • item: T
          • index: number
          • array: T[]

          Returns R | R[]

    • targetArray: T[]

    Returns R[]

Const arrayReduce

  • arrayReduce<T, R>(reducer: (accumulated: R, item: T, index: number, array: T[]) => R, initialValue: R, targetArray: T[]): R
  • see

    {@link Array.reduce}, arrayReduceLeft, arrayReduceRight

    Type parameters

    • T = any

    • R = any

    Parameters

    • reducer: (accumulated: R, item: T, index: number, array: T[]) => R
        • (accumulated: R, item: T, index: number, array: T[]): R
        • Parameters

          • accumulated: R
          • item: T
          • index: number
          • array: T[]

          Returns R

    • initialValue: R
    • targetArray: T[]

    Returns R

Const arrayReduceLeft

  • arrayReduceLeft<T, R>(reducer: (accumulated: R, item: T, index: number, array: T[]) => R, initialValue: R, targetArray: T[]): R
  • see

    {@link Array.reduce}, arrayReduceLeft, arrayReduceRight

    Type parameters

    • T = any

    • R = any

    Parameters

    • reducer: (accumulated: R, item: T, index: number, array: T[]) => R
        • (accumulated: R, item: T, index: number, array: T[]): R
        • Parameters

          • accumulated: R
          • item: T
          • index: number
          • array: T[]

          Returns R

    • initialValue: R
    • targetArray: T[]

    Returns R

Const arrayReduceRight

  • arrayReduceRight<T, R>(reducer: (accumulated: R, item: T, index: number, array: T[]) => R, initialValue: R, targetArray: T[]): R
  • see

    {@link Array.reduce}, arrayReduceLeft, arrayReduceRight

    Type parameters

    • T = any

    • R = any

    Parameters

    • reducer: (accumulated: R, item: T, index: number, array: T[]) => R
        • (accumulated: R, item: T, index: number, array: T[]): R
        • Parameters

          • accumulated: R
          • item: T
          • index: number
          • array: T[]

          Returns R

    • initialValue: R
    • targetArray: T[]

    Returns R

Const arrayUnique

  • arrayUnique<T>(targetArray: T[]): T[]
  • Returns a new array containing only one copy of each element in the original array.

    Type parameters

    • T = any

    Parameters

    • targetArray: T[]

    Returns T[]

Const arrayUniqueBy

  • arrayUniqueBy<T>(uniqueFunction: (item: T) => any, targetArray: T[]): T[]
  • Type parameters

    • T = any

    Parameters

    • uniqueFunction: (item: T) => any
        • (item: T): any
        • Parameters

          • item: T

          Returns any

    • targetArray: T[]

    Returns T[]

Const arrayUnion

  • arrayUnion<T>(firstArray: T[], secondArray: T[]): T[]

Const arrayIntersection

  • arrayIntersection<T>(firstArray: T[], secondArray: T[]): T[]

Const arrayReverse

  • arrayReverse<T>(targetArray: T[]): T[]

Const arraySort

  • arraySort<T>(compareFunction: (a: T, b: T) => number, targetArray: T[]): T[]
  • see

    {@link Array.sort}

    Type parameters

    • T = any

    Parameters

    • compareFunction: (a: T, b: T) => number

      compareFunction is expected to return

      • a negative value if the first argument is less than the second,
      • a positive value if it is greater than the second,
      • or zero if they are equivalent.
        • (a: T, b: T): number
        • Parameters

          • a: T
          • b: T

          Returns number

    • targetArray: T[]

    Returns T[]

Const shuffle

  • shuffle<T>(target: T[]): T[]

Const arrayAdjust

  • arrayAdjust<T>(index: number, transformation: (item: T) => T, targetArray: T[]): T[]
  • Applies a function to the value at the given index of an array, returning a new copy of the array with the element at the given index replaced with the result of the function application.

    see

    https://ramdajs.com/docs/#adjust

    Type parameters

    • T = any

    Parameters

    • index: number
    • transformation: (item: T) => T
        • (item: T): T
        • Parameters

          • item: T

          Returns T

    • targetArray: T[]

    Returns T[]

Const arrayUpdate

  • arrayUpdate<T>(index: number, newItem: T, targetArray: T[]): T[]

Const isUndefined

  • isUndefined(target: unknown): target is undefined

Const isDefined

  • isDefined<T>(target: T): target is T

Const isBoolean

  • isBoolean(target: unknown): target is boolean

Const isString

  • isString(target: unknown): target is string

Const isNumber

  • isNumber(target: any): target is number

Const isFiniteNumber

  • isFiniteNumber(target: unknown): target is number

Const isInfiniteNumber

  • isInfiniteNumber(target: unknown): target is number

Const isNaN

  • isNaN(target: unknown): boolean

Const isBigInt

  • isBigInt(target: unknown): target is bigint

Const isSymbol

  • isSymbol(target: unknown): target is symbol

Const isNull

  • isNull(target: unknown): target is null

Const isPrimative

  • isPrimative(target: unknown): target is Primative

Const isNonPrimative

  • isNonPrimative(target: unknown): target is object

Const isObject

  • isObject(target: unknown): target is Object

Const isGeneralObject

  • isGeneralObject(target: unknown): target is Object
  • Predicate whether the targetget is a general object, use typeof operator to check.

    A general object is an object that is:

    • not null, not a function, not a primitive.

    Any other object is a general object:

    • Array instance, Map instance, WeakMap instance, Set instance, Date instance, etc.
    code
    typeof null // => 'object'
    typeof [] // => 'object'
    typeof {} // => 'object'
    typeof { a: 1 } // => 'object'
    typeof (new Map()) // => 'object'
    typeof (new WeakMap()) // => 'object'
    typeof (new Set()) // => 'object'
    typeof (new WeakSet()) // => 'object'
    typeof (new Date()) // => 'object'
    typeof window // => 'object'
    typeof document // => 'object'
    see

    isObject, isPlainObject

    Parameters

    • target: unknown

    Returns target is Object

Const isPlainObject

  • Predicate whether the targetget is a plain object.

    A plain object is an object that is:

    • not null, not a function, not a primitive type,
    • not an Array, not a RegExp, not a Date, not a Map, not a Set, not a WeakMap,
    • not window, not a DOM element, not an Error,
    • not any other customize object type.
    see

    isObject, isGeneralObject

    Parameters

    • target: unknown

    Returns target is PlainObject

isArray

  • isArray<T>(target: T[]): target is T[]
  • isArray<T>(target: unknown): target is T[]

isArrayLike

  • isArrayLike<T>(target: ArrayLike<T>): target is ArrayLike<T>
  • isArrayLike<T>(target: unknown): target is ArrayLike<T>

isMap

  • isMap<K, V>(target: Map<K, V>): target is Map<K, V>
  • isMap<K, V>(target: unknown): target is Map<K, V>

isWeakMap

  • isWeakMap<K, V>(target: WeakMap<K, V>): target is WeakMap<K, V>
  • isWeakMap<K, V>(target: unknown): target is WeakMap<K, V>

isSet

  • isSet<T>(target: Set<T>): target is Set<T>
  • isSet<T>(target: unknown): target is Set<T>

isWeakSet

  • isWeakSet<T>(target: WeakSet<T>): target is WeakSet<T>
  • isWeakSet<T>(target: unknown): target is WeakSet<T>

Const isDate

  • isDate(target: unknown): target is Date

Const isRegExp

  • isRegExp(target: unknown): target is RegExp

Const isError

  • isError(target: unknown): target is Error

Const isFunction

  • isFunction(target: unknown): target is Function

Const isNormalFunction

  • isNormalFunction(target: unknown): target is Function

Const isAsyncFunction

  • isAsyncFunction(target: unknown): target is Function

Const isGeneratorFunction

  • isGeneratorFunction(target: unknown): target is Function

Const isAsyncGeneratorFunction

  • isAsyncGeneratorFunction(target: unknown): target is Function

isPromise

  • isPromise<T>(target: Promise<T>): target is Promise<T>
  • isPromise<T>(target: unknown): target is Promise<T>

Const isEmptyString

  • isEmptyString(target: unknown): target is ""

Const isEmptyArray

  • isEmptyArray(target: unknown): target is []

Const isEmptyPlainObject

  • isEmptyPlainObject(target: unknown): target is PlainObject

Const isEmptyObject

  • isEmptyObject(target: unknown): target is {}

Const isEmpty

  • isEmpty(target: any): boolean

Const isNil

  • isNil(target: unknown): target is undefined | null

Const isWindow

  • isWindow(target: unknown): target is Window
  • Check target and Window is both defined before use the instanceof operator to check target is instanceof Window.

    Parameters

    • target: unknown

    Returns target is Window

Const isElement

  • isElement(target: unknown): target is Element
  • Check target and Element is both defined before use the instanceof operator to check target is instanceof Element.

    Parameters

    • target: unknown

    Returns target is Element

Const isNode

  • isNode(target: unknown): target is Node
  • Check target and Node is both defined before use the instanceof operator to check target is instanceof Node.

    Parameters

    • target: unknown

    Returns target is Node

Const isHTMLElement

  • isHTMLElement(target: unknown): target is HTMLElement
  • Check target and HTMLElement is both defined before use the instanceof operator to check target is instanceof HTMLElement.

    Parameters

    • target: unknown

    Returns target is HTMLElement

Const isHTMLCollection

  • isHTMLCollection(target: unknown): target is HTMLCollection
  • Check target and HTMLCollection is both defined before use the instanceof operator to check target is instanceof HTMLCollection.

    Parameters

    • target: unknown

    Returns target is HTMLCollection

Const isDocument

  • isDocument(target: unknown): target is Document
  • Check target and Document is both defined before use the instanceof operator to check target is instanceof Document.

    Parameters

    • target: unknown

    Returns target is Document

Const isEventTarget

  • isEventTarget(target: unknown): target is EventTarget

isIterable

  • isIterable<T>(target: Iterable<T>): target is Iterable<T>
  • isIterable<T>(target: unknown): target is Iterable<T>

isAsyncIterable

  • isAsyncIterable<T>(target: AsyncIterable<T>): target is AsyncIterable<T>
  • isAsyncIterable<T>(target: unknown): target is AsyncIterable<T>

isIterator

  • isIterator<T, TReturn, TNext>(target: Iterator<T, TReturn, TNext>): target is Iterator<T, TReturn, TNext>
  • isIterator<T, TReturn, TNext>(target: unknown): target is Iterator<T, TReturn, TNext>

isAsyncIterator

  • isAsyncIterator<T, TReturn, TNext>(target: AsyncIterator<T, TReturn, TNext>): target is AsyncIterator<T, TReturn, TNext>
  • isAsyncIterator<T, TReturn, TNext>(target: unknown): target is AsyncIterator<T, TReturn, TNext>
  • Type parameters

    • T

    • TReturn = unknown

    • TNext = undefined

    Parameters

    • target: AsyncIterator<T, TReturn, TNext>

    Returns target is AsyncIterator<T, TReturn, TNext>

  • Type parameters

    • T

    • TReturn = unknown

    • TNext = undefined

    Parameters

    • target: unknown

    Returns target is AsyncIterator<T, TReturn, TNext>

isObservable

  • isObservable<T>(target: Observable<T>): target is Observable<T>
  • isObservable<T>(target: unknown): target is Observable<T>

Const asIs

  • asIs<T>(target: T, ...args: unknown[]): T

Const asUndefined

  • asUndefined(...target: unknown[]): undefined

Const asNull

  • asNull(...target: unknown[]): null

Const asVoid

  • asVoid(...target: unknown[]): void

not

  • not(b: true): false
  • not(b: false): true
  • not(b: boolean): boolean
  • not(b: unknown): boolean

Const and

  • and(x: unknown, y: unknown): boolean

Const and_

  • and_(...args: any[]): any

Const or

  • or(x: unknown, y: unknown): boolean

Const or_

  • or_(...args: any[]): any

Const nand

  • nand(x: unknown, y: unknown): boolean

Const nand_

  • nand_(...args: any[]): any

Const nor

  • nor(x: unknown, y: unknown): boolean

Const nor_

  • nor_(...args: any[]): any

Const xor

  • xor(x: unknown, y: unknown): boolean

Const xor_

  • xor_(...args: any[]): any

Const xnor

  • xnor(x: unknown, y: unknown): boolean

Const xnor_

  • xnor_(...args: any[]): any

Const complement

  • Take a function that returns a boolean value, return a complement function that return the opposite boolean value. i.e. whenever target function return true, the complement function will return false, and vice versa.

    Type parameters

    Parameters

    • fn: FN

      The function returns boolean.

    Returns InvertFunctionReturn<FN>

Const isTrue

  • isTrue(v: unknown): boolean

Const isFalse

  • isFalse(v: unknown): boolean

Const isTruthy

  • isTruthy(v: unknown): boolean

Const isFalsy

  • isFalsy(v: unknown): boolean

Const isStrictEqual

  • isStrictEqual(v1: unknown, v2: unknown): boolean

Const isStrictEqual_

  • isStrictEqual_(...args: any[]): any

Const isLooseEqual

  • isLooseEqual(v1: unknown, v2: unknown): boolean

Const isLooseEqual_

  • isLooseEqual_(...args: any[]): any

Const isObjetEqual

  • isObjetEqual(v1: unknown, v2: unknown): boolean

Const isObjectEqual_

  • isObjectEqual_(...args: any[]): any

Const ifElse

  • ifElse<X, TR, ER>(pred: unknown, thenFn: (x?: X) => TR, elseFn: (x?: X) => ER, x?: X): TR | ER
  • Invoke the conditional function with the target value, according to the predicate result.

    Type parameters

    • X = unknown

    • TR = unknown

      The return type of thenFn.

    • ER = unknown

      The return type of elseFn.

    Parameters

    • pred: unknown

      Value of type any, the value will be converted to boolean using bool function. If pred is of type NormalFunction, it will be invoked with provided x. then the invoke result will be converted to boolean using bool function.

    • thenFn: (x?: X) => TR

      The function to be invoked if pred result is truthy.

        • (x?: X): TR
        • Parameters

          • Optional x: X

          Returns TR

    • elseFn: (x?: X) => ER

      The function to be invoked if pred result is falsy.

        • (x?: X): ER
        • Parameters

          • Optional x: X

          Returns ER

    • Optional x: X

      The target value, which will be pass to pred | thenFn | elseFn.

    Returns TR | ER

Const ifElse_

  • ifElse_(...args: any[]): any

when

  • when<X, WR>(pred: unknown, whenFn: (x?: X) => WR): WR
  • when<X, WR>(pred: unknown, whenFn: (x?: X) => WR, x: X): WR | X
  • Invoke the target function with target value, when the predicate result is truthy.

    Type parameters

    • X = unknown

      The type of the target value.

    • WR = unknown

      The return type of whenFn.

    Parameters

    • pred: unknown

      Value of type any, the value will be converted to boolean using bool function. If pred is of type NormalFunction, and x is provided, it will be invoked with provided x. then the invoke result will be converted to boolean using bool function.

    • whenFn: (x?: X) => WR
        • (x?: X): WR
        • Parameters

          • Optional x: X

          Returns WR

    Returns WR

  • Type parameters

    • X = unknown

    • WR = unknown

    Parameters

    • pred: unknown
    • whenFn: (x?: X) => WR
        • (x?: X): WR
        • Parameters

          • Optional x: X

          Returns WR

    • x: X

    Returns WR | X

Const when_

  • when_(...args: any[]): any

unless

  • unless<X, UR>(pred: unknown, unlessFn: (x?: X) => UR): UR
  • unless<X, UR>(pred: unknown, unlessFn: (x?: X) => UR, x: X): UR
  • Invoke the target function with target value, unless the predicate result is truthy.

    Type parameters

    • X = unknown

      The type of the target value.

    • UR = unknown

      The return type of unlessFn.

    Parameters

    • pred: unknown

      Value of type any, the value will be converted to boolean using bool function. If pred is of type NormalFunction, and x is provided, it will be invoked with provided x. then the invoke result will be converted to boolean using bool function.

    • unlessFn: (x?: X) => UR

      The function to be invoked if pred result is falsy. If x is provided, it will be passed to unlessFn.

        • (x?: X): UR
        • Parameters

          • Optional x: X

          Returns UR

    Returns UR

  • Type parameters

    • X = unknown

    • UR = unknown

    Parameters

    • pred: unknown
    • unlessFn: (x?: X) => UR
        • (x?: X): UR
        • Parameters

          • Optional x: X

          Returns UR

    • x: X

    Returns UR

Const unless_

  • unless_(...args: any[]): any

Const iif

  • iif<X, Y>(cond: unknown, trueValue: X, falseValue: Y): X | Y
  • IIF: Immediate If Function

    see

    bool

    Type parameters

    • X = unknown

      Type of the trueValue.

    • Y = unknown

      Type of the falseValue.

    Parameters

    • cond: unknown

      Value of type any, the value will be converted to boolean using bool function. If cond is of type NormalFunction, it will be invoked with provided trueValue then the invoke result will be converted to boolean using bool function.

    • trueValue: X
    • falseValue: Y

    Returns X | Y

Const iif_

  • iif_(...args: any[]): any

Const guards

Const cases

  • cases<P, V>(predicated: P, conditions: CaseCondition<P, V>[], defaultValue: V): V

Const isOutDated

  • isOutDated(tar: any): boolean

Const humanize

  • humanize(timestamp: number): string

Const extendBigInt

  • extendBigInt(): void

tryCatch

  • tryCatch<Target>(tryer: () => Target, catcher: (exception: unknown) => Target): Target
  • tryCatch<Target>(tryer: () => Target, catchallValue: Target): Target
  • tryCatch<Target>(tryer: () => Target): Target | undefined
  • tryCatch(tryer: () => void): void
  • Type parameters

    • Target = any

    Parameters

    • tryer: () => Target
        • (): Target
        • Returns Target

    • catcher: (exception: unknown) => Target
        • (exception: unknown): Target
        • Parameters

          • exception: unknown

          Returns Target

    Returns Target

  • Type parameters

    • Target = any

    Parameters

    • tryer: () => Target
        • (): Target
        • Returns Target

    • catchallValue: Target

    Returns Target

  • 未提供 catcher 或 catchallValue 的情况下,若 tryer 抛出异常,则返回 undefined

    Type parameters

    • Target = any

    Parameters

    • tryer: () => Target
        • (): Target
        • Returns Target

    Returns Target | undefined

  • Parameters

    • tryer: () => void
        • (): void
        • Returns void

    Returns void

Const iife

  • iife<T>(fn: T, ...args: [...Parameters<T>[], ...any[]]): ReturnType<T>

Const once

  • once<T>(fn: T, callback?: (times: number) => void): (...args: [...Parameters<T>[], ...any[]]) => ReturnType<T>
  • Generate a one-off function for a given function.

    Type parameters

    Parameters

    • fn: T

      The function to generate a one-off function for.

    • Optional callback: (times: number) => void

      The callback to call when the one-off function is called twice or more.

        • (times: number): void
        • Parameters

          • times: number

          Returns void

    Returns (...args: [...Parameters<T>[], ...any[]]) => ReturnType<T>

      • (...args: [...Parameters<T>[], ...any[]]): ReturnType<T>
      • Parameters

        • Rest ...args: [...Parameters<T>[], ...any[]]

        Returns ReturnType<T>

Const debounceS

  • debounceS<T>(fn: T, ms: number): (...args: [...Parameters<T>[], ...any[]]) => void
  • Type parameters

    Parameters

    • fn: T
    • ms: number

    Returns (...args: [...Parameters<T>[], ...any[]]) => void

      • (...args: [...Parameters<T>[], ...any[]]): void
      • Parameters

        • Rest ...args: [...Parameters<T>[], ...any[]]

        Returns void

Const debounce

  • debounce<T>(fn: T, ms: number): (...args: [...Parameters<T>[], ...any[]]) => Promise<ReturnType<T>>
  • Type parameters

    Parameters

    • fn: T
    • ms: number

    Returns (...args: [...Parameters<T>[], ...any[]]) => Promise<ReturnType<T>>

      • (...args: [...Parameters<T>[], ...any[]]): Promise<ReturnType<T>>
      • Parameters

        • Rest ...args: [...Parameters<T>[], ...any[]]

        Returns Promise<ReturnType<T>>

Const throttleTimeS

  • throttleTimeS<T>(fn: T, ms: number, strict?: boolean): (...args: [...Parameters<T>[], ...any[]]) => void
  • Type parameters

    Parameters

    • fn: T
    • ms: number
    • Optional strict: boolean

    Returns (...args: [...Parameters<T>[], ...any[]]) => void

    Throttled function

      • (...args: [...Parameters<T>[], ...any[]]): void
      • Parameters

        • Rest ...args: [...Parameters<T>[], ...any[]]

        Returns void

Const throttleS

  • throttleS<T>(fn: T, ms: number): (...args: [...Parameters<T>[], ...any[]]) => void
  • Type parameters

    Parameters

    • fn: T
    • ms: number

    Returns (...args: [...Parameters<T>[], ...any[]]) => void

      • (...args: [...Parameters<T>[], ...any[]]): void
      • Parameters

        • Rest ...args: [...Parameters<T>[], ...any[]]

        Returns void

Const throttleTime

  • throttleTime<T>(fn: T, ms: number, strict?: boolean): (...args: [...Parameters<T>[], ...any[]]) => Promise<ReturnType<T>>
  • Type parameters

    Parameters

    • fn: T
    • ms: number
    • Optional strict: boolean

    Returns (...args: [...Parameters<T>[], ...any[]]) => Promise<ReturnType<T>>

    Throttled function

      • (...args: [...Parameters<T>[], ...any[]]): Promise<ReturnType<T>>
      • Parameters

        • Rest ...args: [...Parameters<T>[], ...any[]]

        Returns Promise<ReturnType<T>>

Const throttle

  • throttle<T>(fn: T): (...args: [...Parameters<T>[], ...any[]]) => Promise<ReturnType<T>>
  • Type parameters

    Parameters

    • fn: T

    Returns (...args: [...Parameters<T>[], ...any[]]) => Promise<ReturnType<T>>

      • (...args: [...Parameters<T>[], ...any[]]): Promise<ReturnType<T>>
      • Parameters

        • Rest ...args: [...Parameters<T>[], ...any[]]

        Returns Promise<ReturnType<T>>

Const filterTruthy

  • filterTruthy<T>(targetArray: T[]): T[]

Const filterFalsy

  • filterFalsy<T>(targetArray: T[]): T[]

Const isEven

  • isEven(x: number): boolean

Const isOdd

  • isOdd(x: number): boolean

Const maxTo

  • maxTo(max: number, x: number): number

Const maxTo_

  • maxTo_(...args: any[]): any

Const minTo

  • minTo(min: number, x: number): number

Const minTo_

  • minTo_(...args: any[]): any

Const minOf

  • minOf(x: number, y: number): number

Const minOf_

  • minOf_(...args: any[]): any

Const maxOf

  • maxOf(x: number, y: number): number

Const maxOf_

  • maxOf_(...args: any[]): any

Const between

  • between(a: number, b: number, x: number): number

Const between_

  • between_(...args: any[]): any

Const prop

  • prop(...args: any[]): any

Const propEq

  • propEq(...args: any[]): any

Const propEqBy

  • propEqBy(...args: any[]): any

Const entries

  • entries<T>(o: {} | ArrayLike<T>): [string, T][]
  • entries(o: {}): [string, any][]

Const keys

  • keys(o: object): string[]
  • keys(o: {}): string[]

Const values

  • values<T>(o: {} | ArrayLike<T>): T[]
  • values(o: {}): any[]

Const truthyKeys

  • truthyKeys<V>(obj: {} | ArrayLike<V>): string[]

Const truthyValues

  • truthyValues<V>(obj: {} | ArrayLike<V>): V[]

Const falsyKeys

  • falsyKeys<V>(obj: {} | ArrayLike<V>): string[]

Const falsyValues

  • falsyValues<V>(obj: {} | ArrayLike<V>): V[]

Const hasOwnProperty

  • hasOwnProperty(...args: any[]): any

Const assign

  • assign(...args: any[]): any

Const assignTo

  • assignTo(...args: any[]): any

Const getPropByPath

  • getPropByPath(...args: any[]): any

Const setPropByPath

  • setPropByPath(...args: any[]): any

Const copyByJSON

  • copyByJSON(tar: any): any

Const deepCopy

  • deepCopy(tar: any): any

Const deepMerge

  • deepMerge(...args: any[]): any
  • todo:

    支持保留循环引用关系,通过添加一个额外的 Map 作为参数实现

    Parameters

    • Rest ...args: any[]

    Returns any

    target

Const emptifyObj

Const thenDo

  • thenDo<T, R>(doer: (value: T) => R | PromiseLike<R>, target: Promise<T>): Promise<R>

Const catchReject

  • catchReject<T, R>(catcher: (reason: any) => R | PromiseLike<R>, target: Promise<T>): Promise<T | R>
  • see

    thenDo

    Type parameters

    • T = any

    • R = any

    Parameters

    • catcher: (reason: any) => R | PromiseLike<R>
        • (reason: any): R | PromiseLike<R>
        • Parameters

          • reason: any

          Returns R | PromiseLike<R>

    • target: Promise<T>

    Returns Promise<T | R>

Const isFailedPromiseResult

Const filterSuccessfulPromiseResults

Const filterFailedPromiseResults

Const queuePromises

Const retryPromiseWhile

Const retryPromiseUntil

Const intervalPromise

  • intervalPromise<T>(interval: number, promiseMaker: (time: number) => Promise<T>): () => void
  • Type parameters

    • T = any

    Parameters

    • interval: number
    • promiseMaker: (time: number) => Promise<T>
        • (time: number): Promise<T>
        • Parameters

          • time: number

          Returns Promise<T>

    Returns () => void

      • (): void
      • Returns void

Const foreverPromise

Const isPhoneNum

  • isPhoneNum(v: string): boolean

Const isTelNum

  • isTelNum(v: string): boolean

Const isQQId

  • isQQId(v: string): boolean

Const isEmailAddress

  • isEmailAddress(v: string): boolean

Const toString

  • toString(...args: any[]): any

Const toLowerCase

  • toLowerCase(...args: any[]): any

Const toUpperCase

  • toUpperCase(...args: any[]): any

Const trim

  • trim(...args: any[]): any

Const trimRight

  • trimRight(...args: any[]): any

Const trimLeft

  • trimLeft(...args: any[]): any

Const indexOf

  • indexOf(...args: any[]): any

Const split

  • split(...args: any[]): any

Const replace

  • replace(...args: any[]): any

Const isStartWith

  • isStartWith(...args: any[]): any

Const isAllSpace

  • isAllSpace(str: string): boolean

Const randomString

  • randomString(...args: any[]): any

Variables

DEFAULT_BASEATOM_OPTIONS

DEFAULT_BASEATOM_OPTIONS: Required<BaseAtomOptions> = ...

DEFAULT_SUBSCRIBE_OPTIONS

DEFAULT_SUBSCRIBE_OPTIONS: Required<SubscribeOptions> = ...

DEFAULT_ATOM_TRIGGER_REGISTER_OPTIONS

DEFAULT_ATOM_TRIGGER_REGISTER_OPTIONS: Required<AtomTriggerRegisterOptions> = ...

DEFAULT_DATA_OPTIONS

DEFAULT_DATA_OPTIONS: Required<DataOptions> = ...

GC_DATA

GC_DATA: Data<symbol> = ...

GC, aka. Garbage Clean, used by mediator to release memories.

DEFAULT_MUTATION_OPTIONS

DEFAULT_MUTATION_OPTIONS: Required<MutationOptions<any, any, any[]>> = ...

GC_MUTATION

GC_MUTATION: Mutation<any, symbol> = ...

GC, aka. Garbage Clean, used by mediator to release memories.

DEFAULT_DRIVER_OPTIONS

DEFAULT_DRIVER_OPTIONS: Required<DriverOptions> = {}

DEFAULT_DRIVER_LEVEL_CONTEXTS

DEFAULT_DRIVER_LEVEL_CONTEXTS: Required<DriverLevelContexts> = ...

DEFAULT_SINGLETON_LEVEL_CONTEXTS

DEFAULT_SINGLETON_LEVEL_CONTEXTS: Required<DriverSingletonLevelContexts> = ...

DEFAULT_GENERAL_DATA_MAKE_OPTIONS

DEFAULT_GENERAL_DATA_MAKE_OPTIONS: Required<Omit<GeneralDataMakeOptions, "replayOptions">> = ...

DEFAULT_GENERAL_MUTATION_MAKE_OPTIONS

DEFAULT_GENERAL_MUTATION_MAKE_OPTIONS: Required<Omit<GeneralMutationMakeOptions, "replayOptions">> = ...

FlatMediatorType

FlatMediatorType: MediatorTypeMaker<"[mediator Flat]"> = ...

DEFAULT_FLAT_MEDIATOR_OPTIONS

DEFAULT_FLAT_MEDIATOR_OPTIONS: Required<FlatMediatorOptions> = ...

ReplayMediatorType

ReplayMediatorType: MediatorTypeMaker<"[mediator Replay]"> = ...

DEFAULT_REPLAY_MEDIATOR_OPTIONS

DEFAULT_REPLAY_MEDIATOR_OPTIONS: Required<ReplayMediatorOptions> = ...

TriggerMediatorType

TriggerMediatorType: MediatorTypeMaker<"[mediator Trigger]"> = ...

DEFAULT_TRIGGER_MEDIATOR_OPTIONS

DEFAULT_TRIGGER_MEDIATOR_OPTIONS: Required<TriggerMediatorOptions> = {}

VACUO

VACUO: Vacuo = ...

Global Vacuo instance.

see

makeVacuo

VOID

VOID: Void = ...

Global Void instance.

see

Void

PAUSOR

PAUSOR: Pausor = ...

Global Pausor instance.

see

Pausor

TERMINATOR

TERMINATOR: Terminator = ...

Global Terminator instance.

see

Terminator

DEFAULT_BASE_PARTICLE_OPTIONS

DEFAULT_BASE_PARTICLE_OPTIONS: Required<BaseParticleOptions> = ...

CHAOS

CHAOS: Chaos = ...

Global Chaos instance.

see

Chaos

DEFAULT_DATAR_OPTIONS

DEFAULT_DATAR_OPTIONS: Required<DatarOptions> = ...

DEFAULT_TRANSFORMATION_LIFT_OPTIONS

DEFAULT_TRANSFORMATION_LIFT_OPTIONS: Required<TransformationLiftOptions> = ...

DEFAULT_MUTATOR_OPTIONS

DEFAULT_MUTATOR_OPTIONS: Required<MutatorOptions> = ...

DEFAULT_TACHE_OPTIONS

DEFAULT_TACHE_OPTIONS: Required<TacheOptions> = {}

DEFAULT_TACHE_LEVEL_CONTEXTS

DEFAULT_TACHE_LEVEL_CONTEXTS: Required<TacheLevelContexts> = {}

DEFAULT_GENERAL_TACHE_CREATE_OPTIONS

DEFAULT_GENERAL_TACHE_CREATE_OPTIONS: Required<GeneralTacheCreateOptions<any, any, any, any, any, any>> = ...

perf

perf: { get now(): number } = ...

Type declaration

  • get now(): number

WEB_ENV_CONTEXTS

WEB_ENV_CONTEXTS: WebEnvContexts = ...

NODE_ENV_CONTEXTS

NODE_ENV_CONTEXTS: NodeEnvContexts = ...

WXMINA_ENV_CONTEXTS

WXMINA_ENV_CONTEXTS: WXMINAEnvContexts = ...

DEFAULT_ENV_CONTEXTS

DEFAULT_ENV_CONTEXTS: DefaultEnvContexts = ...

domLoadedD

domLoadedD: Data<SynthesizeEvent<Document>> = ...

domLoadedRD

domLoadedRD: ReplayDataMediator<SynthesizeEvent<Document>> = ...

windowLoadedD

windowLoadedD: Data<SynthesizeEvent<Window & typeof globalThis>> = ...

windowLoadedRD

windowLoadedRD: ReplayDataMediator<SynthesizeEvent<Window & typeof globalThis>> = ...

readyStateD

readyStateD: Data<DocumentReadyState> = ...

readyStateRD

readyStateRD: ReplayDataMediator<DocumentReadyState> = ...

interactiveStateD

interactiveStateD: Data<DocumentReadyState> = ...

interactiveStateRD

interactiveStateRD: ReplayDataMediator<DocumentReadyState> = ...

completeStateD

completeStateD: Data<DocumentReadyState> = ...

completeStateRD

completeStateRD: ReplayDataMediator<DocumentReadyState> = ...

windowResizeD

windowResizeD: Data<UIEvent> = ...

windowResizeRD

windowResizeRD: ReplayDataMediator<UIEvent> = ...

windowD

windowD: Data<Window & typeof globalThis> = ...

windowRD

windowRD: ReplayDataMediator<Window & typeof globalThis> = ...

documentD

documentD: Data<Document> = ...

documentRD

documentRD: ReplayDataMediator<Document> = ...

modifyBiuConfig

modifyBiuConfig: any = ...

asPostRequest

asPostRequest: any = ...

asGetRequest

asGetRequest: any = ...

withJSONContent

withJSONContent: any = ...

WebFetchRequestEngine

DEFAULT_SUCCESS_RESPONSE_CODE

DEFAULT_SUCCESS_RESPONSE_CODE: ResponseCode = ...

DEFAULT_FAIL_RESPONSE_CODE

DEFAULT_FAIL_RESPONSE_CODE: ResponseCode = ...

DEFAULT_ERROR_RESPONSE_CODE

DEFAULT_ERROR_RESPONSE_CODE: ResponseCode = ...

DEFAULT_UNKNOWN_RESPONSE_CODE

DEFAULT_UNKNOWN_RESPONSE_CODE: ResponseCode = ...

v3UUID

v3UUID: v3 = uuid.v3

namespace UUID(MD5)

v5UUID

v5UUID: v5 = uuid.v5

namespace UUID(SHA-1)

argPlaceholder

argPlaceholder: ArgPlaceholder = ...

bool

bool: BooleanConstructor = Boolean

DEFAULT_QUEUE_PROMISES_OPTIONS

DEFAULT_QUEUE_PROMISES_OPTIONS: Required<QueuePromiseOptions> = ...

DEFAULT_RETRY_PROMISES_OPTIONS

DEFAULT_RETRY_PROMISES_OPTIONS: Required<RetryPromiseOptions> = ...

DEFAULT_FOREVER_PROMISES_OPTIONS

DEFAULT_FOREVER_PROMISES_OPTIONS: Required<Omit<ForeverPromiseOptions, "onRejected">> = ...