@oakfinch/ts-utils

Variables

cookieStorage

cookieStorage: StorageAdapter<string> = ...

localStorage

localStorage: StorageAdapter<string> = ...

memoryStorage

memoryStorage: StorageAdapter<string> = ...

sessionStorage

sessionStorage: StorageAdapter<string> = ...

Functions

Const assign

assign<T, U>(target: T, ...sources: U): Intersection<T | U[number]>

- Defined in object/assign.ts:3
Type parameters
- T: AnyObject
- U: any[]
Parameters
- target: T
- Rest ...sources: U
Returns Intersection<T | U[number]>

Const capitalize

capitalize<T>(str: T): Capitalize

- Defined in string/capitalize.ts:1
Type parameters
- T: string
Parameters
- str: T
Returns Capitalize

Const clone

clone<T>(obj: T): T

- Defined in object/clone.ts:61
Type parameters
- T
Parameters
- obj: T
Returns T

compose

compose<T>(fn: T): T
compose<T0, T1>(fn0: T1, fn1: T0): (...args: Parameters<T0>) => ReturnType<T1>
compose<T0, T1, T2>(fn0: T2, fn1: T1, fn2: T0): (...args: Parameters<T0>) => ReturnType<T2>
compose<T0, T1, T2, T3>(fn0: T3, fn1: T2, fn2: T1, fn3: T0): (...args: Parameters<T0>) => ReturnType<T3>
compose<T0, T1, T2, T3, T4>(fn0: T4, fn1: T3, fn2: T2, fn3: T1, fn4: T0): (...args: Parameters<T0>) => ReturnType<T4>
compose<T0, T1, T2, T3, T4, T5>(fn0: T5, fn1: T4, fn2: T3, fn3: T2, fn4: T1, fn5: T0): (...args: Parameters<T0>) => ReturnType<T5>
compose<T0, T1, T2, T3, T4, T5, T6>(fn0: T6, fn1: T5, fn2: T4, fn3: T3, fn4: T2, fn5: T1, fn6: T0): (...args: Parameters<T0>) => ReturnType<T6>
compose<T0, T1, T2, T3, T4, T5, T6, T7>(fn0: T7, fn1: T6, fn2: T5, fn3: T4, fn4: T3, fn5: T2, fn6: T1, fn7: T0): (...args: Parameters<T0>) => ReturnType<T7>
compose<T0, T1, T2, T3, T4, T5, T6, T7, T8>(fn0: T8, fn1: T7, fn2: T6, fn3: T5, fn4: T4, fn5: T3, fn6: T2, fn7: T1, fn8: T0): (...args: Parameters<T0>) => ReturnType<T8>
compose<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(fn0: T9, fn1: T8, fn2: T7, fn3: T6, fn4: T5, fn5: T4, fn6: T3, fn7: T2, fn8: T1, fn9: T0): (...args: Parameters<T0>) => ReturnType<T9>
compose<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(fn0: T10, fn1: T9, fn2: T8, fn3: T7, fn4: T6, fn5: T5, fn6: T4, fn7: T3, fn8: T2, fn9: T1, fn10: T0): (...args: Parameters<T0>) => ReturnType<T10>
compose<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TRest>(fn0: T10, fn1: T9, fn2: T8, fn3: T7, fn4: T6, fn5: T5, fn6: T4, fn7: T3, fn8: T2, fn9: T1, fn10: T0, ...rest: TRest): (...args: Parameters<Last<TRest>>) => ReturnType<T10>

Creates a function that returns the result of invoking the given functions, (right-to-left), where each successive invocation is supplied the return value of the previous.

example

import { compose } from '@oakfinch/ts-utils'

const multiply20 = (price) => price * 20;
const divide100 = (price) => price / 100;
const normalizePrice = (price) => price.toFixed(2);

// instead of:
const discount = (price) => normalizePrice(divide100(multiply20(price)));

// you can do:
const discount = compose(normalizePrice, divide100, multiply20);

Type parameters

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

Parameters

fn: T

Returns T

- Defined in function/compose.ts:71
Type parameters
- T0: (...args: any[]) => any
- T1: (arg: ReturnType<T0>) => any
Parameters
- fn0: T1
- fn1: T0
Returns (...args: Parameters<T0>) => ReturnType<T1>
- - (...args: Parameters<T0>): ReturnType<T1>
  - Parameters
    - Rest ...args: Parameters<T0>
    Returns ReturnType<T1>
- Defined in function/compose.ts:72
Type parameters
- T0: (...args: any[]) => any
- T1: (arg: ReturnType<T0>) => any
- T2: (arg: ReturnType<T1>) => any
Parameters
- fn0: T2
- fn1: T1
- fn2: T0
Returns (...args: Parameters<T0>) => ReturnType<T2>
- - (...args: Parameters<T0>): ReturnType<T2>
  - Parameters
    - Rest ...args: Parameters<T0>
    Returns ReturnType<T2>
- Defined in function/compose.ts:73
Type parameters
- T0: (...args: any[]) => any
- T1: (arg: ReturnType<T0>) => any
- T2: (arg: ReturnType<T1>) => any
- T3: (arg: ReturnType<T2>) => any
Parameters
- fn0: T3
- fn1: T2
- fn2: T1
- fn3: T0
Returns (...args: Parameters<T0>) => ReturnType<T3>
- - (...args: Parameters<T0>): ReturnType<T3>
  - Parameters
    - Rest ...args: Parameters<T0>
    Returns ReturnType<T3>
- Defined in function/compose.ts:74
Type parameters
- T0: (...args: any[]) => any
- T1: (arg: ReturnType<T0>) => any
- T2: (arg: ReturnType<T1>) => any
- T3: (arg: ReturnType<T2>) => any
- T4: (arg: ReturnType<T3>) => any
Parameters
- fn0: T4
- fn1: T3
- fn2: T2
- fn3: T1
- fn4: T0
Returns (...args: Parameters<T0>) => ReturnType<T4>
- - (...args: Parameters<T0>): ReturnType<T4>
  - Parameters
    - Rest ...args: Parameters<T0>
    Returns ReturnType<T4>
- Defined in function/compose.ts:75
Type parameters
- T0: (...args: any[]) => any
- T1: (arg: ReturnType<T0>) => any
- T2: (arg: ReturnType<T1>) => any
- T3: (arg: ReturnType<T2>) => any
- T4: (arg: ReturnType<T3>) => any
- T5: (arg: ReturnType<T4>) => any
Parameters
- fn0: T5
- fn1: T4
- fn2: T3
- fn3: T2
- fn4: T1
- fn5: T0
Returns (...args: Parameters<T0>) => ReturnType<T5>
- - (...args: Parameters<T0>): ReturnType<T5>
  - Parameters
    - Rest ...args: Parameters<T0>
    Returns ReturnType<T5>
- Defined in function/compose.ts:76
Type parameters
- T0: (...args: any[]) => any
- T1: (arg: ReturnType<T0>) => any
- T2: (arg: ReturnType<T1>) => any
- T3: (arg: ReturnType<T2>) => any
- T4: (arg: ReturnType<T3>) => any
- T5: (arg: ReturnType<T4>) => any
- T6: (arg: ReturnType<T5>) => any
Parameters
- fn0: T6
- fn1: T5
- fn2: T4
- fn3: T3
- fn4: T2
- fn5: T1
- fn6: T0
Returns (...args: Parameters<T0>) => ReturnType<T6>
- - (...args: Parameters<T0>): ReturnType<T6>
  - Parameters
    - Rest ...args: Parameters<T0>
    Returns ReturnType<T6>
- Defined in function/compose.ts:77
Type parameters
- T0: (...args: any[]) => any
- T1: (arg: ReturnType<T0>) => any
- T2: (arg: ReturnType<T1>) => any
- T3: (arg: ReturnType<T2>) => any
- T4: (arg: ReturnType<T3>) => any
- T5: (arg: ReturnType<T4>) => any
- T6: (arg: ReturnType<T5>) => any
- T7: (arg: ReturnType<T6>) => any
Parameters
- fn0: T7
- fn1: T6
- fn2: T5
- fn3: T4
- fn4: T3
- fn5: T2
- fn6: T1
- fn7: T0
Returns (...args: Parameters<T0>) => ReturnType<T7>
- - (...args: Parameters<T0>): ReturnType<T7>
  - Parameters
    - Rest ...args: Parameters<T0>
    Returns ReturnType<T7>
- Defined in function/compose.ts:78
Type parameters
- T0: (...args: any[]) => any
- T1: (arg: ReturnType<T0>) => any
- T2: (arg: ReturnType<T1>) => any
- T3: (arg: ReturnType<T2>) => any
- T4: (arg: ReturnType<T3>) => any
- T5: (arg: ReturnType<T4>) => any
- T6: (arg: ReturnType<T5>) => any
- T7: (arg: ReturnType<T6>) => any
- T8: (arg: ReturnType<T7>) => any
Parameters
- fn0: T8
- fn1: T7
- fn2: T6
- fn3: T5
- fn4: T4
- fn5: T3
- fn6: T2
- fn7: T1
- fn8: T0
Returns (...args: Parameters<T0>) => ReturnType<T8>
- - (...args: Parameters<T0>): ReturnType<T8>
  - Parameters
    - Rest ...args: Parameters<T0>
    Returns ReturnType<T8>
- Defined in function/compose.ts:79
Type parameters
- T0: (...args: any[]) => any
- T1: (arg: ReturnType<T0>) => any
- T2: (arg: ReturnType<T1>) => any
- T3: (arg: ReturnType<T2>) => any
- T4: (arg: ReturnType<T3>) => any
- T5: (arg: ReturnType<T4>) => any
- T6: (arg: ReturnType<T5>) => any
- T7: (arg: ReturnType<T6>) => any
- T8: (arg: ReturnType<T7>) => any
- T9: (arg: ReturnType<T8>) => any
Parameters
- fn0: T9
- fn1: T8
- fn2: T7
- fn3: T6
- fn4: T5
- fn5: T4
- fn6: T3
- fn7: T2
- fn8: T1
- fn9: T0
Returns (...args: Parameters<T0>) => ReturnType<T9>
- - (...args: Parameters<T0>): ReturnType<T9>
  - Parameters
    - Rest ...args: Parameters<T0>
    Returns ReturnType<T9>
- Defined in function/compose.ts:80
Type parameters
- T0: (...args: any[]) => any
- T1: (arg: ReturnType<T0>) => any
- T2: (arg: ReturnType<T1>) => any
- T3: (arg: ReturnType<T2>) => any
- T4: (arg: ReturnType<T3>) => any
- T5: (arg: ReturnType<T4>) => any
- T6: (arg: ReturnType<T5>) => any
- T7: (arg: ReturnType<T6>) => any
- T8: (arg: ReturnType<T7>) => any
- T9: (arg: ReturnType<T8>) => any
- T10: (arg: ReturnType<T9>) => any
Parameters
- fn0: T10
- fn1: T9
- fn2: T8
- fn3: T7
- fn4: T6
- fn5: T5
- fn6: T4
- fn7: T3
- fn8: T2
- fn9: T1
- fn10: T0
Returns (...args: Parameters<T0>) => ReturnType<T10>
- - (...args: Parameters<T0>): ReturnType<T10>
  - Parameters
    - Rest ...args: Parameters<T0>
    Returns ReturnType<T10>
- Defined in function/compose.ts:81
Type parameters
- T0: (...args: any[]) => any
- T1: (arg: ReturnType<T0>) => any
- T2: (arg: ReturnType<T1>) => any
- T3: (arg: ReturnType<T2>) => any
- T4: (arg: ReturnType<T3>) => any
- T5: (arg: ReturnType<T4>) => any
- T6: (arg: ReturnType<T5>) => any
- T7: (arg: ReturnType<T6>) => any
- T8: (arg: ReturnType<T7>) => any
- T9: (arg: ReturnType<T8>) => any
- T10: (arg: ReturnType<T9>) => any
- TRest: ((...args: any[]) => any)[]
Parameters
- fn0: T10
- fn1: T9
- fn2: T8
- fn3: T7
- fn4: T6
- fn5: T5
- fn6: T4
- fn7: T3
- fn8: T2
- fn9: T1
- fn10: T0
- Rest ...rest: TRest
Returns (...args: Parameters<Last<TRest>>) => ReturnType<T10>
- - (...args: Parameters<Last<TRest>>): ReturnType<T10>
  - Parameters
    - Rest ...args: Parameters<Last<TRest>>
    Returns ReturnType<T10>

create

create<T>(obj: T): T
create<T>(obj: T, options: { isPublic?: true; prototype?: null }): T
create<T>(obj: T, options: { isPublic: false; prototype?: null }): Record<string, never>
create<T, U>(obj: T, options: { isPublic?: true; prototype: U }): T & U
create<T, U>(obj: T, options: { isPublic: false; prototype: U }): U

- Defined in object/create/create.ts:13
Type parameters
- T: AnyObject
Parameters
- obj: T
Returns T
- Defined in object/create/create.ts:14
Type parameters
- T: AnyObject
Parameters
- obj: T
- options: { isPublic?: true; prototype?: null }
  - Optional isPublic?: true
  - Optional prototype?: null
Returns T
- Defined in object/create/create.ts:18
Type parameters
- T: AnyObject
Parameters
- obj: T
- options: { isPublic: false; prototype?: null }
  - isPublic: false
  - Optional prototype?: null
Returns Record<string, never>
- Defined in object/create/create.ts:22
Type parameters
- T: AnyObject
- U: AnyObject
Parameters
- obj: T
- options: { isPublic?: true; prototype: U }
  - Optional isPublic?: true
  - prototype: U
Returns T & U
- Defined in object/create/create.ts:26
Type parameters
- T: AnyObject
- U: AnyObject
Parameters
- obj: T
- options: { isPublic: false; prototype: U }
  - isPublic: false
  - prototype: U
Returns U

Const deserialize

deserialize<T>(str: string): null | T

- Defined in object/serialize.ts:10
Type parameters
- T = any
Parameters
- str: string
Returns null | T

Const ellipsis

ellipsis(str: string, maxLength: number, ellipsisString?: string): string

- Defined in string/ellipsis.ts:6
Truncates a string and adds an ellipsis onto the end

Parameters
- str: string
- maxLength: number
- ellipsisString: string = '…'
Returns string

Const entries

entries<T>(obj: T): NonNullable<Value<{ [ P in string | number | symbol]: [P, T[P]] }>>[]

- Defined in object/entries.ts:3
Type parameters
- T: AnyObject
Parameters
- obj: T
Returns NonNullable<Value<{ [ P in string | number | symbol]: [P, T[P]] }>>[]

Const finiteOrNull

finiteOrNull<T>(num: T): Exclude<number, T> extends never ? null | T : T

- Defined in number/finite-or-null.ts:5
Returns num as-is, unless num is Infinity, -Infinity, or NaN, in which case it returns null

Type parameters
- T: number
Parameters
- num: T
Returns Exclude<number, T> extends never ? null | T : T

freeze

freeze<T>(obj: T): Freeze<T>
freeze<T>(obj: T): Freeze<T>

- Defined in object/freeze.ts:11
Type parameters
- T: readonly any[]
Parameters
- obj: T
Returns Freeze<T>
- Defined in object/freeze.ts:12
Type parameters
- T
Parameters
- obj: T
Returns Freeze<T>

Const fromEntries

fromEntries<T>(items: T): Simplify<FromEntriesInner<Mutable<T>, EmptyObject>>

- Defined in object/entries.ts:6
Type parameters
- T: readonly [keyof AnyObject, any][]
Parameters
- items: T
Returns Simplify<FromEntriesInner<Mutable<T>, EmptyObject>>

Const getGlobal

getGlobal(): Window & typeof globalThis

- Defined in env/get-global.ts:2
Returns Window & typeof globalThis

Const getPromise

getPromise<T>(): { promise: Promise<T>; reject: any; resolve: any }

- Defined in promise/get-promise.ts:17
Returns a promise along with the resolve and reject methods that control it.
example
```
const {promise, resolve, reject} = getPromise<{x: number, y: number}>()

element.addEventListener('click', ({ clientX: x, clientY: y }) => {
  resolve({ x, y })
})

const { x, y } = await promise
```
Type parameters
- T = void
Returns { promise: Promise<T>; reject: any; resolve: any }
- promise: Promise<T>
- reject:function
  - reject(reason?: any): never
  - - Defined in promise/get-promise.ts:20
    Parameters
    - Optional reason: any
    Returns never
- resolve:function
  - resolve(value: T): T
  - - Defined in promise/get-promise.ts:19
    Parameters
    - value: T
    Returns T

Const getScript

getScript(src: string): Promise<void>

- Defined in request/get-script.ts:3
Parameters
- src: string
Returns Promise<void>

Const getStorage

getStorage(...types: ("cookie" | "local" | "session" | "memory")[]): undefined | StorageAdapter<string>

- Defined in storage/get-storage.ts:19
Parameters
- Rest ...types: ("cookie" | "local" | "session" | "memory")[]
Returns undefined | StorageAdapter<string>

Const hasOwnProperty

hasOwnProperty<TProp, TValue, U, V>(obj: U | V, prop: TProp): obj is V

Type-garded Object.hasOwnProperty

example

const obj = getObjSomehow() as ({ foo: 'foo' } | { bar: 'bar' });

// TypeError:
// Property 'foo' does not exist on type '{ foo: "foo"; } | { bar: "bar"; }'
console.log(obj.foo);

if (hasOwnProperty(obj, 'foo')) {
  // ok!
  console.log(obj.foo);
}

Type parameters

TProp: Index
TValue
U
V: Record<TProp, TValue>

Parameters

obj: U | V

the object
prop: TProp

the property to check

Returns obj is V

Const hasProperty

hasProperty<TProp, TValue, U, V>(obj: U | V, prop: TProp): obj is V

Type-garded property check

example

const obj = getObjSomehow() as ({ foo: 'foo' } | { bar: 'bar' });

// TypeError:
// Property 'foo' does not exist on type '{ foo: "foo"; } | { bar: "bar"; }'
console.log(obj.foo);

if (hasProperty(obj, 'foo')) {
  // ok!
  console.log(obj.foo);
}

Type parameters

TProp: Index
TValue
U
V: Record<TProp, TValue>

Parameters

obj: U | V

the object
prop: TProp

the property to check

Returns obj is V

Const isArray

isArray<T, U>(arg: T | U): arg is T

- Defined in type-guards/is-array.ts:2
Type parameters
- T: readonly any[]
- U
Parameters
- arg: T | U
Returns arg is T

Const isBoolean

isBoolean<T>(arg: boolean | T): arg is boolean

- Defined in type-guards/is-boolean.ts:2
Boolean type guard

Type parameters
- T
Parameters
- arg: boolean | T
Returns arg is boolean

Const isFunction

isFunction<T, U>(arg: T | U): arg is U

- Defined in type-guards/is-function.ts:3
Function type guard

Type parameters
- T
- U: (...args: any[]) => any
Parameters
- arg: T | U
Returns arg is U

Const isIncluded

isIncluded<T, U, V>(item: U | V, array: T): item is U

Type-garded Array.includes

example

const validItems = ['a', 'b'] as const;
const array = getArraySomehow() as string[];

// TypeError: Argument of type 'string' is not assignable to parameter of type '"a" | "b"
const filtered = array.filter((item) => validItems.includes(item));

// ok!
const filtered = array.filter((item) => isIncluded(item, validItems));

Type parameters

T: readonly any[]
U: any
V

Parameters

item: U | V

the item to search for
array: T

the array to search

Returns item is U

Const isMap

isMap<T, U>(arg: T | U): arg is T

- Defined in type-guards/is-map.ts:3
Map type guard

Type parameters
- T: Map<any, any, T>
- U
Parameters
- arg: T | U
Returns arg is T

Const isNull

isNull<T>(obj: null | T): obj is null

- Defined in type-guards/is-null.ts:2
null type guard

Type parameters
- T
Parameters
- obj: null | T
Returns obj is null

Const isNullish

isNullish<T>(arg: undefined | null | T): arg is undefined | null

- Defined in type-guards/is-nullish.ts:2
nullish (null or undefined) type-guard

Type parameters
- T
Parameters
- arg: undefined | null | T
Returns arg is undefined | null

Const isNumber

isNumber<T>(arg: number | T): arg is number

- Defined in type-guards/is-number.ts:2
Number type guard

Type parameters
- T
Parameters
- arg: number | T
Returns arg is number

Const isObject

isObject<T, U>(obj: T | U): obj is T

- Defined in type-guards/is-object.ts:5
object type guard

Type parameters
- T: AnyObject
- U
Parameters
- obj: T | U
Returns obj is T

Const isPrimitive

isPrimitive<T>(obj: undefined | null | string | number | bigint | boolean | symbol | T): obj is undefined | null | string | number | bigint | boolean | symbol

- Defined in type-guards/is-primitive.ts:6
Primitive type guard

JS Primitives are: string | number | bigint | boolean | undefined | symbol | null

Type parameters
- T
Parameters
- obj: undefined | null | string | number | bigint | boolean | symbol | T
Returns obj is undefined | null | string | number | bigint | boolean | symbol

Const isPromise

isPromise<T, U>(obj: T | U): obj is U

- Defined in type-guards/is-promise.ts:2
Promise type guard

Type parameters
- T
- U: Promise<T, U>
Parameters
- obj: T | U
Returns obj is U

Const isSet

isSet<T, U>(arg: T | U): arg is T

- Defined in type-guards/is-set.ts:3
Set type guard

Type parameters
- T: Set<any, T>
- U
Parameters
- arg: T | U
Returns arg is T

Const isString

isString<T>(arg: string | T): arg is string

- Defined in type-guards/is-string.ts:2
String type guard

Type parameters
- T
Parameters
- arg: string | T
Returns arg is string

Const last

last<T, U>(arr: U): Last<U>

Returns the last item of an array

example

const array = ['foo', 'bar'] as const;
const obj = { bar: 'fizzbuzz' } as const;

// TypeError: Element implicitly has an 'any' type because expression of type
// '"foo" | "bar"' can't be used to index type '{ readonly bar: "fizzbuzz"; }'.
//     Property 'foo' does not exist on type '{ readonly bar: "fizzbuzz"; }'
const fizzbuzz = obj[array[array.length - 1]];

// ok!
const fizzbuzz = obj[last(array)];

Type parameters

T
U: readonly T[]

Parameters

arr: U

Returns Last<U>

Const lowercase

lowercase<T>(str: T): Lowercase

- Defined in string/lowercase.ts:1
Type parameters
- T: string
Parameters
- str: T
Returns Lowercase

Const makeCookieStorage

makeCookieStorage(__namedParameters?: { deserialize?: <T>(str: string) => null | T; document?: Pick<Document, "cookie">; serialize?: <T>(obj: T) => null | string }): StorageAdapter<string>

- Defined in storage/adapters/cookie/make-cookie-storage.ts:14
Parameters
- __namedParameters: { deserialize?: <T>(str: string) => null | T; document?: Pick<Document, "cookie">; serialize?: <T>(obj: T) => null | string } = {}
  - Optional deserialize?: <T>(str: string) => null | T
    - - <T>(str: string): null | T
      - Type parameters
        T = any
        Parameters
        str: string
        Returns null | T
  - Optional document?: Pick<Document, "cookie">
  - Optional serialize?: <T>(obj: T) => null | string
    - - <T>(obj: T): null | string
      - Type parameters
        T
        Parameters
        obj: T
        Returns null | string
Returns StorageAdapter<string>

Const makeFactory

makeFactory<Props, Interface>(prototype: Interface & ThisType<Interface & Props>): <T>(props: T & ThisType<Interface & T>) => Interface

- Defined in object/make-factory.ts:3
Type parameters
- Props
- Interface
Parameters
- prototype: Interface & ThisType<Interface & Props>
Returns <T>(props: T & ThisType<Interface & T>) => Interface
- - <T>(props: T & ThisType<Interface & T>): Interface
  - Type parameters
    - T
    Parameters
    - props: T & ThisType<Interface & T>
    Returns Interface

Const makeLocalStorage

makeLocalStorage(__namedParameters?: { deserialize?: <T>(str: string) => null | T; serialize?: <T>(obj: T) => null | string; storage?: Storage }): StorageAdapter<string>

- Defined in storage/adapters/local-storage/make-local-storage.ts:10
Parameters
- __namedParameters: { deserialize?: <T>(str: string) => null | T; serialize?: <T>(obj: T) => null | string; storage?: Storage } = {}
  - Optional deserialize?: <T>(str: string) => null | T
    - - <T>(str: string): null | T
      - Type parameters
        T = any
        Parameters
        str: string
        Returns null | T
  - Optional serialize?: <T>(obj: T) => null | string
    - - <T>(obj: T): null | string
      - Type parameters
        T
        Parameters
        obj: T
        Returns null | string
  - Optional storage?: Storage
Returns StorageAdapter<string>

Const makeMemoryStorage

makeMemoryStorage(): StorageAdapter<string>

- Defined in storage/adapters/memory/make-memory-storage.ts:19
Returns StorageAdapter<string>

Const makePromiseObserver

makePromiseObserver(__namedParameters: { onBeforeChange?: Callback; onChange?: Callback }): PromiseObserver

- Defined in promise/make-promise-observer.ts:12
Parameters
- __namedParameters: { onBeforeChange?: Callback; onChange?: Callback }
  - Optional onBeforeChange?: Callback
  - Optional onChange?: Callback
Returns PromiseObserver

Const makeSessionStorage

makeSessionStorage(__namedParameters?: { deserialize?: <T>(str: string) => null | T; serialize?: <T>(obj: T) => null | string; storage?: Storage }): StorageAdapter<string>

- Defined in storage/adapters/session-storage/make-session-storage.ts:5
Parameters
- __namedParameters: { deserialize?: <T>(str: string) => null | T; serialize?: <T>(obj: T) => null | string; storage?: Storage } = {}
  - Optional deserialize?: <T>(str: string) => null | T
    - - <T>(str: string): null | T
      - Type parameters
        T = any
        Parameters
        str: string
        Returns null | T
  - Optional serialize?: <T>(obj: T) => null | string
    - - <T>(obj: T): null | string
      - Type parameters
        T
        Parameters
        obj: T
        Returns null | string
  - Optional storage?: Storage
Returns StorageAdapter<string>

Const memoize

memoize<T>(fn: T, maxAge?: number): T

- Defined in function/memoize.ts:5
Type parameters
- T: AnyFunction<any[], any>
Parameters
- fn: T
- maxAge: number = 1000
Returns T

merge

merge<T, U>(a: T, b: U, options?: { deep?: false }): T & U
merge<T, U>(a: T, b: U, options?: { deep: true }): DeepMerge<T, U>

- Defined in object/merge.ts:16
Type parameters
- T: AnyObject
- U: AnyObject
Parameters
- a: T
- b: U
- Optional options: { deep?: false }
  - Optional deep?: false
Returns T & U
- Defined in object/merge.ts:21
Type parameters
- T: AnyObject
- U: AnyObject
Parameters
- a: T
- b: U
- Optional options: { deep: true }
  - deep: true
Returns DeepMerge<T, U>

Const noop

noop(): void

- Defined in function/noop.ts:1
Returns void

partial

partial<T>(fn: T): T
partial<T, U, V>(fn: V, ...args: T): (...rest: Slice<Parameters<V>, T["length"]>) => ReturnType<V>

Creates a function that invokes fn with the args prepended to the arguments that it recieves.

example

import { partial } from '@oakfinch/ts-utils'

const original = (a, b, c, d) = a + b + c + d;

// instead of:
const fn = (a) = original(1, 2, 3, a);

// you can do:
const fn = partial(original, 1, 2, 3);

Type parameters

T: AnyFunction<any[], any>

Parameters

fn: T

the original function

Returns T

- Defined in function/partial.ts:23
Type parameters
- T: readonly any[]
- U: readonly any[]
- V: (...args: [...T[], ...U[]]) => any
Parameters
- fn: V
- Rest ...args: T
Returns (...rest: Slice<Parameters<V>, T["length"]>) => ReturnType<V>
- - (...rest: Slice<Parameters<V>, T["length"]>): ReturnType<V>
  - Parameters
    - Rest ...rest: Slice<Parameters<V>, T["length"]>
    Returns ReturnType<V>

pipe

pipe<T>(fn: T): T
pipe<T0, T1>(fn0: T0, fn1: T1): (...args: Parameters<T0>) => ReturnType<T1>
pipe<T0, T1, T2>(fn0: T0, fn1: T1, fn2: T2): (...args: Parameters<T0>) => ReturnType<T2>
pipe<T0, T1, T2, T3>(fn0: T0, fn1: T1, fn2: T2, fn3: T3): (...args: Parameters<T0>) => ReturnType<T3>
pipe<T0, T1, T2, T3, T4>(fn0: T0, fn1: T1, fn2: T2, fn3: T3, fn4: T4): (...args: Parameters<T0>) => ReturnType<T4>
pipe<T0, T1, T2, T3, T4, T5>(fn0: T0, fn1: T1, fn2: T2, fn3: T3, fn4: T4, fn5: T5): (...args: Parameters<T0>) => ReturnType<T5>
pipe<T0, T1, T2, T3, T4, T5, T6>(fn0: T0, fn1: T1, fn2: T2, fn3: T3, fn4: T4, fn5: T5, fn6: T6): (...args: Parameters<T0>) => ReturnType<T6>
pipe<T0, T1, T2, T3, T4, T5, T6, T7>(fn0: T0, fn1: T1, fn2: T2, fn3: T3, fn4: T4, fn5: T5, fn6: T6, fn7: T7): (...args: Parameters<T0>) => ReturnType<T7>
pipe<T0, T1, T2, T3, T4, T5, T6, T7, T8>(fn0: T0, fn1: T1, fn2: T2, fn3: T3, fn4: T4, fn5: T5, fn6: T6, fn7: T7, fn8: T8): (...args: Parameters<T0>) => ReturnType<T8>
pipe<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(fn0: T0, fn1: T1, fn2: T2, fn3: T3, fn4: T4, fn5: T5, fn6: T6, fn7: T7, fn8: T8, fn9: T9): (...args: Parameters<T0>) => ReturnType<T9>
pipe<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(fn0: T0, fn1: T1, fn2: T2, fn3: T3, fn4: T4, fn5: T5, fn6: T6, fn7: T7, fn8: T8, fn9: T9, fn10: T10): (...args: Parameters<T0>) => ReturnType<T10>
pipe<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TRest>(fn0: T0, fn1: T1, fn2: T2, fn3: T3, fn4: T4, fn5: T5, fn6: T6, fn7: T7, fn8: T8, fn9: T9, fn10: T10, ...rest: TRest): (...args: Parameters<T0>) => ReturnType<Last<TRest>>

Creates a function that returns the result of invoking the given functions, (left-to-right), where each successive invocation is supplied the return value of the previous.

example

import { pipe } from '@oakfinch/ts-utils'

const multiply20 = (price) => price * 20;
const divide100 = (price) => price / 100;
const normalizePrice = (price) => price.toFixed(2);

// instead of:
const discount = (price) => normalizePrice(divide100(multiply20(price)));

// you can do:
const discount = pipe(multiply20, divide100, normalizePrice);

Type parameters

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

Parameters

fn: T

Returns T

- Defined in function/compose.ts:26
Type parameters
- T0: (...args: any[]) => any
- T1: (arg: ReturnType<T0>) => any
Parameters
- fn0: T0
- fn1: T1
Returns (...args: Parameters<T0>) => ReturnType<T1>
- - (...args: Parameters<T0>): ReturnType<T1>
  - Parameters
    - Rest ...args: Parameters<T0>
    Returns ReturnType<T1>
- Defined in function/compose.ts:27
Type parameters
- T0: (...args: any[]) => any
- T1: (arg: ReturnType<T0>) => any
- T2: (arg: ReturnType<T1>) => any
Parameters
- fn0: T0
- fn1: T1
- fn2: T2
Returns (...args: Parameters<T0>) => ReturnType<T2>
- - (...args: Parameters<T0>): ReturnType<T2>
  - Parameters
    - Rest ...args: Parameters<T0>
    Returns ReturnType<T2>
- Defined in function/compose.ts:28
Type parameters
- T0: (...args: any[]) => any
- T1: (arg: ReturnType<T0>) => any
- T2: (arg: ReturnType<T1>) => any
- T3: (arg: ReturnType<T2>) => any
Parameters
- fn0: T0
- fn1: T1
- fn2: T2
- fn3: T3
Returns (...args: Parameters<T0>) => ReturnType<T3>
- - (...args: Parameters<T0>): ReturnType<T3>
  - Parameters
    - Rest ...args: Parameters<T0>
    Returns ReturnType<T3>
- Defined in function/compose.ts:29
Type parameters
- T0: (...args: any[]) => any
- T1: (arg: ReturnType<T0>) => any
- T2: (arg: ReturnType<T1>) => any
- T3: (arg: ReturnType<T2>) => any
- T4: (arg: ReturnType<T3>) => any
Parameters
- fn0: T0
- fn1: T1
- fn2: T2
- fn3: T3
- fn4: T4
Returns (...args: Parameters<T0>) => ReturnType<T4>
- - (...args: Parameters<T0>): ReturnType<T4>
  - Parameters
    - Rest ...args: Parameters<T0>
    Returns ReturnType<T4>
- Defined in function/compose.ts:30
Type parameters
- T0: (...args: any[]) => any
- T1: (arg: ReturnType<T0>) => any
- T2: (arg: ReturnType<T1>) => any
- T3: (arg: ReturnType<T2>) => any
- T4: (arg: ReturnType<T3>) => any
- T5: (arg: ReturnType<T4>) => any
Parameters
- fn0: T0
- fn1: T1
- fn2: T2
- fn3: T3
- fn4: T4
- fn5: T5
Returns (...args: Parameters<T0>) => ReturnType<T5>
- - (...args: Parameters<T0>): ReturnType<T5>
  - Parameters
    - Rest ...args: Parameters<T0>
    Returns ReturnType<T5>
- Defined in function/compose.ts:31
Type parameters
- T0: (...args: any[]) => any
- T1: (arg: ReturnType<T0>) => any
- T2: (arg: ReturnType<T1>) => any
- T3: (arg: ReturnType<T2>) => any
- T4: (arg: ReturnType<T3>) => any
- T5: (arg: ReturnType<T4>) => any
- T6: (arg: ReturnType<T5>) => any
Parameters
- fn0: T0
- fn1: T1
- fn2: T2
- fn3: T3
- fn4: T4
- fn5: T5
- fn6: T6
Returns (...args: Parameters<T0>) => ReturnType<T6>
- - (...args: Parameters<T0>): ReturnType<T6>
  - Parameters
    - Rest ...args: Parameters<T0>
    Returns ReturnType<T6>
- Defined in function/compose.ts:32
Type parameters
- T0: (...args: any[]) => any
- T1: (arg: ReturnType<T0>) => any
- T2: (arg: ReturnType<T1>) => any
- T3: (arg: ReturnType<T2>) => any
- T4: (arg: ReturnType<T3>) => any
- T5: (arg: ReturnType<T4>) => any
- T6: (arg: ReturnType<T5>) => any
- T7: (arg: ReturnType<T6>) => any
Parameters
- fn0: T0
- fn1: T1
- fn2: T2
- fn3: T3
- fn4: T4
- fn5: T5
- fn6: T6
- fn7: T7
Returns (...args: Parameters<T0>) => ReturnType<T7>
- - (...args: Parameters<T0>): ReturnType<T7>
  - Parameters
    - Rest ...args: Parameters<T0>
    Returns ReturnType<T7>
- Defined in function/compose.ts:33
Type parameters
- T0: (...args: any[]) => any
- T1: (arg: ReturnType<T0>) => any
- T2: (arg: ReturnType<T1>) => any
- T3: (arg: ReturnType<T2>) => any
- T4: (arg: ReturnType<T3>) => any
- T5: (arg: ReturnType<T4>) => any
- T6: (arg: ReturnType<T5>) => any
- T7: (arg: ReturnType<T6>) => any
- T8: (arg: ReturnType<T7>) => any
Parameters
- fn0: T0
- fn1: T1
- fn2: T2
- fn3: T3
- fn4: T4
- fn5: T5
- fn6: T6
- fn7: T7
- fn8: T8
Returns (...args: Parameters<T0>) => ReturnType<T8>
- - (...args: Parameters<T0>): ReturnType<T8>
  - Parameters
    - Rest ...args: Parameters<T0>
    Returns ReturnType<T8>
- Defined in function/compose.ts:34
Type parameters
- T0: (...args: any[]) => any
- T1: (arg: ReturnType<T0>) => any
- T2: (arg: ReturnType<T1>) => any
- T3: (arg: ReturnType<T2>) => any
- T4: (arg: ReturnType<T3>) => any
- T5: (arg: ReturnType<T4>) => any
- T6: (arg: ReturnType<T5>) => any
- T7: (arg: ReturnType<T6>) => any
- T8: (arg: ReturnType<T7>) => any
- T9: (arg: ReturnType<T8>) => any
Parameters
- fn0: T0
- fn1: T1
- fn2: T2
- fn3: T3
- fn4: T4
- fn5: T5
- fn6: T6
- fn7: T7
- fn8: T8
- fn9: T9
Returns (...args: Parameters<T0>) => ReturnType<T9>
- - (...args: Parameters<T0>): ReturnType<T9>
  - Parameters
    - Rest ...args: Parameters<T0>
    Returns ReturnType<T9>
- Defined in function/compose.ts:35
Type parameters
- T0: (...args: any[]) => any
- T1: (arg: ReturnType<T0>) => any
- T2: (arg: ReturnType<T1>) => any
- T3: (arg: ReturnType<T2>) => any
- T4: (arg: ReturnType<T3>) => any
- T5: (arg: ReturnType<T4>) => any
- T6: (arg: ReturnType<T5>) => any
- T7: (arg: ReturnType<T6>) => any
- T8: (arg: ReturnType<T7>) => any
- T9: (arg: ReturnType<T8>) => any
- T10: (arg: ReturnType<T9>) => any
Parameters
- fn0: T0
- fn1: T1
- fn2: T2
- fn3: T3
- fn4: T4
- fn5: T5
- fn6: T6
- fn7: T7
- fn8: T8
- fn9: T9
- fn10: T10
Returns (...args: Parameters<T0>) => ReturnType<T10>
- - (...args: Parameters<T0>): ReturnType<T10>
  - Parameters
    - Rest ...args: Parameters<T0>
    Returns ReturnType<T10>
- Defined in function/compose.ts:36
Type parameters
- T0: (...args: any[]) => any
- T1: (arg: ReturnType<T0>) => any
- T2: (arg: ReturnType<T1>) => any
- T3: (arg: ReturnType<T2>) => any
- T4: (arg: ReturnType<T3>) => any
- T5: (arg: ReturnType<T4>) => any
- T6: (arg: ReturnType<T5>) => any
- T7: (arg: ReturnType<T6>) => any
- T8: (arg: ReturnType<T7>) => any
- T9: (arg: ReturnType<T8>) => any
- T10: (arg: ReturnType<T9>) => any
- TRest: ((...args: any[]) => any)[]
Parameters
- fn0: T0
- fn1: T1
- fn2: T2
- fn3: T3
- fn4: T4
- fn5: T5
- fn6: T6
- fn7: T7
- fn8: T8
- fn9: T9
- fn10: T10
- Rest ...rest: TRest
Returns (...args: Parameters<T0>) => ReturnType<Last<TRest>>
- - (...args: Parameters<T0>): ReturnType<Last<TRest>>
  - Parameters
    - Rest ...args: Parameters<T0>
    Returns ReturnType<Last<TRest>>

Const pop

pop<T>(arr: T): T extends readonly [T0, T1] ? [T1, T0] : [Value<T>, Value<T>[]]

Similar to Array.pop, but returns an array along with the "popped" item instead of modifying the original array.

example

const original = [1, 2, 3, 4, 5];
const [last, modified] = pop(original);
// original is [1, 2, 3, 4, 5]
// modified is [1, 2, 3, 4]
// last == 5

// as opposed to:
const original = [1, 2, 3, 4, 5]
const last = original.pop();
// original == [1, 2, 3, 4]
// last == 5

Type parameters

T: readonly any[]

Parameters

arr: T

Returns T extends readonly [T0, T1] ? [T1, T0] : [Value<T>, Value<T>[]]

promisify

promisify<TArgs, TReturn, TCustomNames>(fn: (...args: [...TArgs[], (error: any, ...rest: TReturn) => any]) => any, keys: TCustomNames): (...args: TArgs) => Promise<FromEntries<MergeArrays<TCustomNames, FromArgs<TReturn>>>>
promisify<TReturn, TCustomNames>(fn: (cb: (error: any, ...rest: TReturn) => any) => any, keys: TCustomNames): () => Promise<FromEntries<MergeArrays<TCustomNames, FromArgs<TReturn>>>>
promisify<TArgs, TReturn>(fn: (...args: [...TArgs[], (error: any, value: undefined | TReturn, ...rest: any[]) => any]) => any): (...args: TArgs) => Promise<TReturn>
promisify<TReturn>(fn: (cb: (error: any, value: undefined | TReturn, ...rest: any[]) => any) => any): () => Promise<TReturn>
promisify<TArgs>(fn: (...args: [...TArgs[], (error: any) => any]) => any): (...args: TArgs) => Promise<void>
promisify(fn: (cb: (error: any) => any) => any): () => Promise<void>

Takes in a callback-based function and returns a promise-based function

The callback must be a node-style callback whose first argument is an error when the function fails, or null when it succeeds. The second argument is the result.

example

// https://nodejs.org/api/fs.html#fs_fs_readfile_path_options_callback
import { readFile } from 'fs'
import { promisify } from '@oakfinch/ts-utils'

// reading a file using a promisified `readFile`
const readFilePromise = promisify(readFile)
const contents = await readFilePromise('/some/file', 'utf8')

// reading a file using the callback-based `readFile`
const contents = await new Promise((resolve, reject) => {
  readFile('/some/file', 'utf8', (err, data) => {
    if (err) {
      reject(err)
    } else {
      resolve(data)
    }
  })
})

Type parameters

TArgs: any[]
TReturn: any[]
TCustomNames: readonly string[]

Parameters

fn: (...args: [...TArgs[], (error: any, ...rest: TReturn) => any]) => any

the callback-based function to promisify
- - (...args: [...TArgs[], (error: any, ...rest: TReturn) => any]): any
  - Parameters
    - Rest ...args: [...TArgs[], (error: any, ...rest: TReturn) => any]
    Returns any
keys: TCustomNames

Returns (...args: TArgs) => Promise<FromEntries<MergeArrays<TCustomNames, FromArgs<TReturn>>>>

a promise-based function

(...args: TArgs): Promise<FromEntries<MergeArrays<TCustomNames, FromArgs<TReturn>>>>

Takes in a callback-based function and returns a promise-based function

The callback must be a node-style callback whose first argument is an error when the function fails, or null when it succeeds. The second argument is the result.

example

// https://nodejs.org/api/fs.html#fs_fs_readfile_path_options_callback
import { readFile } from 'fs'
import { promisify } from '@oakfinch/ts-utils'

// reading a file using a promisified `readFile`
const readFilePromise = promisify(readFile)
const contents = await readFilePromise('/some/file', 'utf8')

// reading a file using the callback-based `readFile`
const contents = await new Promise((resolve, reject) => {
  readFile('/some/file', 'utf8', (err, data) => {
    if (err) {
      reject(err)
    } else {
      resolve(data)
    }
  })
})

Parameters

Rest ...args: TArgs

Returns Promise<FromEntries<MergeArrays<TCustomNames, FromArgs<TReturn>>>>

a promise-based function

- Defined in function/promisify.ts:44
Type parameters
- TReturn: any[]
- TCustomNames: readonly string[]
Parameters
- fn: (cb: (error: any, ...rest: TReturn) => any) => any
  - - (cb: (error: any, ...rest: TReturn) => any): any
    - Parameters
      - cb: (error: any, ...rest: TReturn) => any
        (error: any, ...rest: TReturn): any
        Parameters
        error: any
        Rest ...rest: TReturn
        Returns any
      Returns any
- keys: TCustomNames
Returns () => Promise<FromEntries<MergeArrays<TCustomNames, FromArgs<TReturn>>>>
- - (): Promise<FromEntries<MergeArrays<TCustomNames, FromArgs<TReturn>>>>
  - Returns Promise<FromEntries<MergeArrays<TCustomNames, FromArgs<TReturn>>>>
- Defined in function/promisify.ts:49
Type parameters
- TArgs: any[]
- TReturn
Parameters
- fn: (...args: [...TArgs[], (error: any, value: undefined | TReturn, ...rest: any[]) => any]) => any
  - - (...args: [...TArgs[], (error: any, value: undefined | TReturn, ...rest: any[]) => any]): any
    - Parameters
      - Rest ...args: [...TArgs[], (error: any, value: undefined | TReturn, ...rest: any[]) => any]
      Returns any
Returns (...args: TArgs) => Promise<TReturn>
- - (...args: TArgs): Promise<TReturn>
  - Parameters
    - Rest ...args: TArgs
    Returns Promise<TReturn>
- Defined in function/promisify.ts:53
Type parameters
- TReturn
Parameters
- fn: (cb: (error: any, value: undefined | TReturn, ...rest: any[]) => any) => any
  - - (cb: (error: any, value: undefined | TReturn, ...rest: any[]) => any): any
    - Parameters
      - cb: (error: any, value: undefined | TReturn, ...rest: any[]) => any
        (error: any, value: undefined | TReturn, ...rest: any[]): any
        Parameters
        error: any
        value: undefined | TReturn
        Rest ...rest: any[]
        Returns any
      Returns any
Returns () => Promise<TReturn>
- - (): Promise<TReturn>
  - Returns Promise<TReturn>
- Defined in function/promisify.ts:57
Type parameters
- TArgs: any[]
Parameters
- fn: (...args: [...TArgs[], (error: any) => any]) => any
  - - (...args: [...TArgs[], (error: any) => any]): any
    - Parameters
      - Rest ...args: [...TArgs[], (error: any) => any]
      Returns any
Returns (...args: TArgs) => Promise<void>
- - (...args: TArgs): Promise<void>
  - Parameters
    - Rest ...args: TArgs
    Returns Promise<void>
- Defined in function/promisify.ts:61
Parameters
- fn: (cb: (error: any) => any) => any
  - - (cb: (error: any) => any): any
    - Parameters
      - cb: (error: any) => any
        (error: any): any
        Parameters
        error: any
        Returns any
      Returns any
Returns () => Promise<void>
- - (): Promise<void>
  - Returns Promise<void>

Const push

push<T, U>(arr: T, item: U): [...T[], U]

- Defined in array/push.ts:19
Similar to Array.push, but returns a new array instead of modifying the original array.
example
```
const a = [1, 2, 3, 4];
const b = push(a, 5);
// a is [1, 2, 3, 4]
// b is [1, 2, 3, 4, 5]

// as opposed to:
const a = [1, 2, 3, 4]
a.push(5)
// a is [1, 2, 3, 4, 5]
```
Type parameters
- T: readonly any[]
- U
Parameters
- arr: T
- item: U
Returns [...T[], U]

quote

quote<T>(str: T): `"${T}"`
quote<T, Q>(str: T, quo: Q): `${Q}${T}${Q}`
quote<T, L, R>(str: T, lquo: L, rquo: R): `${L}${T}${R}`

- Defined in string/quote.ts:15
Wraps a string in quotes
example
```
quote('hello') // returns `"hello"`
quote('hello', '#') // returns `#hello#`
quote('hello', '<', '>') // returns `<hello>`
```
Type parameters
- T: string
Parameters
- str: T
  
  the string to wrap
Returns `"${T}"`
the quoted string
- Defined in string/quote.ts:16
Type parameters
- T: string
- Q: string
Parameters
- str: T
- quo: Q
Returns `${Q}${T}${Q}`
- Defined in string/quote.ts:17
Type parameters
- T: string
- L: string
- R: string
Parameters
- str: T
- lquo: L
- rquo: R
Returns `${L}${T}${R}`

Const remove

remove<T>(item: T[number], arr: T): T

- Defined in array/remove.ts:3
Type parameters
- T: any[]
Parameters
- item: T[number]
- arr: T
Returns T

replace

replace(source: string, searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string
replace(source: string, searchValue: string | RegExp, replaceValue: string): string
replace(source: string, searchReplaceMap: {}): string

- Defined in string/replace.ts:6
Alias of String.replace

Parameters
- source: string
- searchValue: string | RegExp
- replacer: (substring: string, ...args: any[]) => string
  - - (substring: string, ...args: any[]): string
    - Parameters
      - substring: string
      - Rest ...args: any[]
      Returns string
Returns string
- Defined in string/replace.ts:15
Alias of String.replace

Parameters
- source: string
- searchValue: string | RegExp
- replaceValue: string
Returns string
- Defined in string/replace.ts:21
Iterates over searchReplaceMap, calling source.replace(key, value) for each entry in the object

Parameters
- source: string
- searchReplaceMap: {}
  - [index: string]: string | ((substring: string, ...args: any[]) => string)
Returns string

Const request

request<T>(url?: string, options?: RequestInit): Promise<T>

- Defined in request/request.ts:16
Type parameters
- T = any
Parameters
- url: string = ''
- options: RequestInit = {}
Returns Promise<T>

requestTimeout

requestTimeout(fn: (deadline: IdleDeadline) => void): Promise<void> & { cancel: any }
requestTimeout(fn: (deadline: IdleDeadline) => void, type: "idle"): Promise<void> & { cancel: any }
requestTimeout(fn: (deadline: IdleDeadline) => void, options: IdleRequestOptions): Promise<void> & { cancel: any }
requestTimeout(fn: (time: number) => void, type: "animationFrame"): Promise<void> & { cancel: any }
requestTimeout(fn: () => void, type: number): Promise<void> & { cancel: any }

A combined interface for setTimeout, requestIdleCallback, and requestAnimationFrame

example

import { timeout } from '@oakfinch/ts-utils'

timeout(() => { console.log('this will be called when idle') })

await timeout(() => { console.log('you can await the result as well') })

timeout(
  () => { console.log('this calls requestIdleCallback') },
  'idle'
)

timeout(
  () => { console.log('this calls requestAnimationFrame') },
  'animationFrame'
)

timeout(
  () => { console.log('this calls setTimeout') },
  100
)

const { cancel } = timeout(
  () => { console.log('this will be canceled!') },
  100
)
cancel()

const promise = timeout(
  () => {
    console.log('this will be canceled and the promise will reject')
  },
  100
)
timeout(() => { promise.cancel({ error: true }) })
await promise

Parameters

fn: (deadline: IdleDeadline) => void

callback function
- - (deadline: IdleDeadline): void
  - Parameters
    - deadline: IdleDeadline
    Returns void

Returns Promise<void> & { cancel: any }

returns a promise-like function that, when called, will cancel the timeout. When await-ed, it will resolve with the return value of the callback once it is called, or will reject

- Defined in function/request-timeout/request-timeout.ts:64
Parameters
- fn: (deadline: IdleDeadline) => void
  - - (deadline: IdleDeadline): void
    - Parameters
      - deadline: IdleDeadline
      Returns void
- type: "idle"
Returns Promise<void> & { cancel: any }
- Defined in function/request-timeout/request-timeout.ts:68
Parameters
- fn: (deadline: IdleDeadline) => void
  - - (deadline: IdleDeadline): void
    - Parameters
      - deadline: IdleDeadline
      Returns void
- options: IdleRequestOptions
Returns Promise<void> & { cancel: any }
- Defined in function/request-timeout/request-timeout.ts:72
Parameters
- fn: (time: number) => void
  - - (time: number): void
    - Parameters
      - time: number
      Returns void
- type: "animationFrame"
Returns Promise<void> & { cancel: any }
- Defined in function/request-timeout/request-timeout.ts:76
Parameters
- fn: () => void
  - - (): void
    - Returns void
- type: number
Returns Promise<void> & { cancel: any }

Const safe

safe<T>(fn: () => T): undefined | T

- Defined in function/safe.ts:21
A helper for handling awkward try/catch blocks
example
```
// instead of:
let value: string;
try {
  value = getValue(12345);
} catch (error) {
  value = 'some fallback';
}

// you can do:
const value = safe(() => getValue(12345)) ?? 'some fallback';
```
Type parameters
- T
Parameters
- fn: () => T
  
  a function that has no arguments
  - - (): T
    - Returns T
Returns undefined | T
the return value of fn, or undefined if fn throws an error

Const serialize

serialize<T>(obj: T): null | string

- Defined in object/serialize.ts:1
Type parameters
- T
Parameters
- obj: T
Returns null | string

Const shift

shift<T, U>(arr: T, item: U): [U, ...T[]]

- Defined in array/shift.ts:2
Type parameters
- T: readonly any[]
- U
Parameters
- arr: T
- item: U
Returns [U, ...T[]]

Const template

template<T>(strings: TemplateStringsArray, ...expressions: T): (replacements: { [ P in string]: string }) => string

- Defined in string/template.ts:19
Simple tagged template literal that returns a string render function
example
```
import { template } from '@oakfinch/ts-utils'

const greet = template`${'greeting'}, how are you today ${'name'}?`;

// returns 'Hello, how are you today Bob?'
greet({ greeting: 'Hello', name: 'Bob' });

// returns 'Good afternoon, how are you today Sally?'
greet({ greeting: 'Good afternoon', name: 'Sally' });
```
Type parameters
- T: readonly string[]
Parameters
- strings: TemplateStringsArray
- Rest ...expressions: T
Returns (replacements: { [ P in string]: string }) => string
- - (replacements: { [ P in string]: string }): string
  - Parameters
    - replacements: { [ P in string]: string }
    Returns string

to

to<T>(fn: () => Promise<T>): Promise<[T, undefined] | [undefined, unknown]>
to<T>(fn: () => T): [T, undefined] | [undefined, unknown]
to<T>(promise: Promise<T>): Promise<[T, undefined] | [undefined, unknown]>
to<T>(arg: T): [T, undefined]

- Defined in function/to.ts:26
A helper for handling awkward try/catch blocks
example
```
// instead of:
let value: string;
try {
  value = await getValue(12345);
} catch (error) {
  value = 'some fallback';
}

// you can do:
const [value = 'some fallback', error] = await to(() => getValue(12345));
```
Type parameters
- T
Parameters
- fn: () => Promise<T>
  
  a function that has no arguments and returns a promise
  - - (): Promise<T>
    - Returns Promise<T>
Returns Promise<[T, undefined] | [undefined, unknown]>
a promise that resolves to [undefined, error] if the promise rejects, and [value, undefined] if the promise resolves
- Defined in function/to.ts:47
A helper for handling awkward try/catch blocks
example
```
// instead of:
let value: string;
try {
  value = getValue(12345);
} catch (error) {
  value = 'some fallback';
}

// you can do:
const [value = 'some fallback', error] = to(() => getValue(12345));
```
Type parameters
- T
Parameters
- fn: () => T
  
  a function that has no arguments
  - - (): T
    - Returns T
Returns [T, undefined] | [undefined, unknown]
if function throws an error, and [value, undefined] if it succeeds
- Defined in function/to.ts:68
A helper for handling awkward try/catch blocks
example
```
// instead of:
let value: string;
try {
  value = await somePromise;
} catch (error) {
  value = 'some fallback';
}

// you can do:
const [value = 'some fallback', error] = await to(somePromise);
```
Type parameters
- T
Parameters
- promise: Promise<T>
  
  a promise
Returns Promise<[T, undefined] | [undefined, unknown]>
if the promise rejects, and [value, undefined] if it resolves
- Defined in function/to.ts:69
Type parameters
- T
Parameters
- arg: T
Returns [T, undefined]

Const trigger

trigger<T>(name: string, detail?: T): void

- Defined in events/trigger.ts:1
Type parameters
- T
Parameters
- name: string
- Optional detail: T
Returns void

Const truncate

truncate(str: string, maxLength: number): string

- Defined in string/truncate.ts:4
Truncates a string

Parameters
- str: string
- maxLength: number
Returns string

Const uncapitalize

uncapitalize<T>(str: T): Uncapitalize

- Defined in string/uncapitalize.ts:1
Type parameters
- T: string
Parameters
- str: T
Returns Uncapitalize

Const unique

unique<T>(arr: T): T[number][]

- Defined in array/unique.ts:3
Type parameters
- T: readonly any[]
Parameters
- arr: T
Returns T[number][]

Const unshift

unshift<T>(arr: T): T extends readonly [T0, T1] ? [T1, T0] : [Value<T>, Value<T>[]]

Similar to Array.pop, but returns an array along with the "popped" item instead of modifying the original array.

example

const original = [1, 2, 3, 4, 5];
const [last, modified] = pop(original);
// original == [1, 2, 3, 4, 5]
// modified == [1, 2, 3, 4]
// last == 5

// as opposed to:
const original = [1, 2, 3, 4, 5]
const last = original.pop();
// original == [1, 2, 3, 4]
// last == 5

Type parameters

T: readonly any[]

Parameters

arr: T

Returns T extends readonly [T0, T1] ? [T1, T0] : [Value<T>, Value<T>[]]

Const uppercase

uppercase<T>(str: T): Uppercase

- Defined in string/uppercase.ts:1
Type parameters
- T: string
Parameters
- str: T
Returns Uppercase

Index

Variables

Functions

Variables

cookieStorage

localStorage

memoryStorage

sessionStorage

Functions

Const assign

Type parameters

T: AnyObject

U: any[]

Parameters

target: T

Rest ...sources: U

Returns Intersection<T | U[number]>

Const capitalize

Type parameters

T: string

Parameters

str: T

Returns Capitalize

Const clone

Type parameters

T

Parameters

obj: T

Returns T

compose

Type parameters

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

Parameters

fn: T

Returns T

Type parameters

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

T1: (arg: ReturnType<T0>) => any

Parameters

fn0: T1

fn1: T0

Returns (...args: Parameters<T0>) => ReturnType<T1>

Parameters

Rest ...args: Parameters<T0>

Returns ReturnType<T1>

Type parameters

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

T1: (arg: ReturnType<T0>) => any

T2: (arg: ReturnType<T1>) => any

Parameters

fn0: T2

fn1: T1

fn2: T0

Returns (...args: Parameters<T0>) => ReturnType<T2>

Parameters

Rest ...args: Parameters<T0>

Returns ReturnType<T2>

Type parameters

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

T1: (arg: ReturnType<T0>) => any

T2: (arg: ReturnType<T1>) => any

T3: (arg: ReturnType<T2>) => any

Parameters

fn0: T3

fn1: T2

fn2: T1

fn3: T0

Returns (...args: Parameters<T0>) => ReturnType<T3>

Parameters

Rest ...args: Parameters<T0>

Returns ReturnType<T3>

Type parameters

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

T1: (arg: ReturnType<T0>) => any

T2: (arg: ReturnType<T1>) => any

T3: (arg: ReturnType<T2>) => any

T4: (arg: ReturnType<T3>) => any

Parameters

fn0: T4

fn1: T3