@kdtlabs/utils 0.0.4 → 0.0.5

package/src/objects/deep-merge.ts

@@ -0,0 +1,76 @@
+import type { AnyObject, DeepPartial } from './types'
+import { isArray } from '../arrays'
+import { unique } from '../arrays/set-operations'
+import { isPlainObject } from './guards'
+
+export type DeepMergeArrayMode = 'merge' | 'merge-dedupe' | 'replace'
+
+export interface DeepMergeOptions {
+    arrayMode?: DeepMergeArrayMode
+}
+
+const DANGEROUS_KEYS = new Set(['__proto__', 'constructor', 'prototype'])
+
+function mergeArrays(base: unknown[], override: unknown[], arrayMode: DeepMergeArrayMode): unknown[] {
+    if (arrayMode === 'replace') {
+        return override.map(deepCloneValue)
+    }
+
+    const merged = [...base, ...override]
+    const deduped = arrayMode === 'merge-dedupe' ? unique(merged) : merged
+
+    return deduped.map(deepCloneValue)
+}
+
+function deepCloneValue(value: unknown): unknown {
+    if (isPlainObject(value)) {
+        const cloned: Record<string, unknown> = {}
+
+        for (const key of Object.keys(value)) {
+            if (!DANGEROUS_KEYS.has(key)) {
+                cloned[key] = deepCloneValue(value[key])
+            }
+        }
+
+        return cloned
+    }
+
+    if (isArray(value)) {
+        return value.map(deepCloneValue)
+    }
+
+    return value
+}
+
+function mergeRecursive(base: Record<string, unknown>, override: Record<string, unknown>, arrayMode: DeepMergeArrayMode): Record<string, unknown> {
+    const result: Record<string, unknown> = {}
+
+    for (const key of Object.keys(base)) {
+        if (!DANGEROUS_KEYS.has(key)) {
+            result[key] = deepCloneValue(base[key])
+        }
+    }
+
+    for (const key of Object.keys(override)) {
+        if (DANGEROUS_KEYS.has(key)) {
+            continue
+        }
+
+        const baseVal = result[key]
+        const overrideVal = override[key]
+
+        if (isPlainObject(baseVal) && isPlainObject(overrideVal)) {
+            result[key] = mergeRecursive(baseVal, overrideVal, arrayMode)
+        } else if (isArray(baseVal) && isArray(overrideVal)) {
+            result[key] = mergeArrays(baseVal, overrideVal, arrayMode)
+        } else {
+            result[key] = deepCloneValue(overrideVal)
+        }
+    }
+
+    return result
+}
+
+export const deepMerge = <T extends AnyObject>(base: T, override: DeepPartial<T>, { arrayMode = 'replace' }: DeepMergeOptions = {}): T => (
+    mergeRecursive(base, override as Record<string, unknown>, arrayMode) as T
+)

package/src/objects/guards.ts

@@ -0,0 +1,21 @@
+import type { AnyObject, UnknownObject } from './types'
+import { isArray } from '../arrays'
+import { toString } from '../core'
+
+export const isObject = (value: unknown): value is AnyObject => value !== null && typeof value === 'object' && !isArray(value)
+
+export const isPlainObject = (value: unknown): value is UnknownObject => {
+    if (toString(value) !== '[object Object]') {
+        return false
+    }
+
+    const proto = Object.getPrototypeOf(value)
+
+    return proto === null || proto === Object.prototype
+}
+
+export const isEmptyObject = (value: AnyObject) => Object.keys(value).length === 0
+
+export const isKeyOf = <T extends AnyObject>(obj: T, name: PropertyKey): name is keyof T => name in obj
+
+export const isKeysOf = <T extends PropertyKey>(data: AnyObject, ...keys: T[]): data is Record<T, unknown> => keys.every((key) => isKeyOf(data, key))

package/src/objects/index.ts

@@ -0,0 +1,5 @@
+export * from './deep-merge'
+export * from './guards'
+export * from './transformations'
+
+export type * from './types'

package/src/objects/transformations.ts

@@ -0,0 +1,34 @@
+import type { AnyObject, FilterPredicate } from './types'
+import { isNullish, type Nullish } from '../core'
+
+export const entries = <O extends AnyObject>(obj: O) => Object.entries(obj) as Array<[keyof O, O[keyof O]]>
+
+export const filter = <O extends AnyObject>(obj: O, predicate: FilterPredicate<O, keyof O>): Partial<O> => (
+    Object.fromEntries(entries(obj).filter(([key, value], index) => predicate(key, value, index))) as Partial<O>
+)
+
+export const filterByValue = <O extends AnyObject>(obj: O, predicate: (value: O[keyof O]) => boolean) => filter(obj, (_, value) => predicate(value))
+
+export const pick = <O extends AnyObject, K extends keyof O>(obj: O, ...keys: K[]) => {
+    const set = new Set<PropertyKey>(keys)
+
+    return filter(obj, (key) => set.has(key)) as Pick<O, K>
+}
+
+export const omit = <O extends AnyObject, K extends keyof O>(object: O, ...keys: K[]) => {
+    const set = new Set<PropertyKey>(keys)
+
+    return filter(object, (key) => !set.has(key)) as Omit<O, K>
+}
+
+export const map = <K extends PropertyKey, V, NK extends PropertyKey, NV>(obj: Record<K, V>, fn: (k: K, v: V, i: number) => [NK, NV]) => (
+    Object.fromEntries(entries(obj).map(([k, v], i) => fn(k, v, i))) as Record<NK, NV>
+)
+
+export function resolveOptions<T extends AnyObject>(options: Nullish<T | boolean>, defaultValue: T | false): T | false {
+    if (options === false) {
+        return false
+    }
+
+    return isNullish(options) || options === true ? defaultValue : options
+}

package/src/objects/types.ts

@@ -0,0 +1,33 @@
+import type { Primitive } from '../core'
+
+export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>
+
+export type RequiredBy<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>
+
+export type Mutable<T> = { -readonly [K in keyof T]: T[K] }
+
+export type DeepPartial<T> = T extends object ? { [K in keyof T]?: DeepPartial<T[K]> } : T
+
+export type DeepReadonly<T> = T extends Primitive ? T : T extends Array<infer U> ? ReadonlyArray<DeepReadonly<U>> : { readonly [K in keyof T]: DeepReadonly<T[K]> }
+
+export type KeysOfType<T, V> = { [K in keyof T]-?: T[K] extends V ? K : never }[keyof T]
+
+export type StringKeys<T> = Extract<keyof T, string>
+
+export type Dictionary<T = unknown> = Record<string, T>
+
+export type DiscriminateUnion<T, K extends keyof T, V extends T[K]> = T extends Record<K, V> ? T : never
+
+export type AnyObject = Record<string, any>
+
+export type UnknownObject = Record<string, unknown>
+
+export type Constructor<T> = new (...args: any[]) => T
+
+export type ClassMethods<T> = { [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never }[keyof T]
+
+export type ClassMethodArgs<T, M extends ClassMethods<T>> = T[M] extends (...args: infer A) => any ? A : never
+
+export type ClassMethodReturn<T, M extends ClassMethods<T>> = T[M] extends (...args: any[]) => infer R ? R : never
+
+export type FilterPredicate<O, K extends keyof O> = (key: K, value: O[K], index: number) => boolean

package/src/promises/abortable.ts

@@ -0,0 +1,37 @@
+import { createAbortError, ensureError, type Errorable } from '../errors'
+
+export function abortable<T>(promise: Promise<T>, signal?: AbortSignal, error?: Errorable): Promise<T> {
+    if (!signal) {
+        return promise
+    }
+
+    const createError = () => (error ? ensureError(error) : (signal.reason ?? createAbortError()))
+
+    if (signal.aborted) {
+        return Promise.reject(createError())
+    }
+
+    return new Promise<T>((resolve, reject) => {
+        let isSettled = false
+        let onAbort: () => void
+
+        const cleanup = (afterCleanup?: () => void) => {
+            if (!isSettled) {
+                isSettled = true
+                signal.removeEventListener('abort', onAbort)
+                afterCleanup?.()
+            }
+        }
+
+        onAbort = () => {
+            cleanup(() => reject(createError()))
+        }
+
+        signal.addEventListener('abort', onAbort)
+
+        promise.then(
+            (value) => cleanup(() => resolve(value)),
+            (error_) => cleanup(() => reject(error_)),
+        )
+    })
+}

package/src/promises/compositions.ts

@@ -0,0 +1,18 @@
+import type { Awaitable } from './types'
+
+export const pTap = <T>(fn: (value: T) => Awaitable<unknown>) => async (value: T): Promise<T> => {
+    return Promise.resolve(fn(value)).then(() => value)
+}
+
+pTap.catch = (fn: (error: unknown) => Awaitable<unknown>) => async (error: unknown): Promise<never> => {
+    await fn(error)
+    throw error
+}
+
+export async function tryCatchAsync<T>(fn: () => Awaitable<T>, fallback: (error: unknown) => Awaitable<T>) {
+    try {
+        return await fn()
+    } catch (error) {
+        return await fallback(error)
+    }
+}

package/src/promises/deferred.ts

@@ -0,0 +1,131 @@
+import { combineSignals, createAbortController, createAbortError, type Errorable } from '../errors'
+
+export interface DeferredPromiseOptions<T> {
+    onCallbackError?: (error: unknown) => void
+    onReject?: (reason: unknown) => void
+    onResolve?: (value: PromiseLike<T> | T) => void
+    onSettle?: () => void
+    signal?: AbortSignal
+    synchronousCallbacks?: boolean
+}
+
+export interface DeferredPromise<T> extends Promise<T> {
+    isPending: boolean
+    isRejected: boolean
+    isResolved: boolean
+    isSettled: boolean
+    reject: (reason?: unknown) => void
+    resolve: (value: PromiseLike<T> | T) => void
+}
+
+export function cleanupAbortSignal(signal: AbortSignal | undefined, abortHandler: (() => void) | undefined) {
+    if (abortHandler) {
+        signal?.removeEventListener('abort', abortHandler)
+    }
+}
+
+export function setupAbortSignal(signal: AbortSignal | undefined, onAbort: () => void) {
+    const abortHandler = () => onAbort()
+
+    if (signal?.aborted) {
+        onAbort()
+    } else {
+        signal?.addEventListener('abort', abortHandler)
+    }
+
+    return abortHandler
+}
+
+export function invokeSettleCallback(cb: () => void, onSettle: (() => void) | undefined, onCallbackError: ((error: unknown) => void) | undefined, synchronousCallbacks: boolean) {
+    const callback = () => {
+        try {
+            cb()
+        } catch (error) {
+            onCallbackError?.(error)
+        }
+
+        try {
+            onSettle?.()
+        } catch (error) {
+            onCallbackError?.(error)
+        }
+    }
+
+    if (synchronousCallbacks) {
+        callback()
+    } else {
+        queueMicrotask(callback)
+    }
+}
+
+export function createDeferred<T>({ onCallbackError, onReject, onResolve, onSettle, signal, synchronousCallbacks = false }: DeferredPromiseOptions<T> = {}): DeferredPromise<T> {
+    let resolveFn: (value: PromiseLike<T> | T) => void
+    let rejectFn: (reason?: unknown) => void
+    let abortHandler: (() => void) | undefined
+
+    let isSettled = false
+    let isResolved = false
+    let isRejected = false
+
+    const promise = <DeferredPromise<T>> new Promise<T>((resolve, reject) => {
+        resolveFn = resolve
+        rejectFn = reject
+    })
+
+    const afterSettle = (cb: () => void) => {
+        cleanupAbortSignal(signal, abortHandler)
+        invokeSettleCallback(cb, onSettle, onCallbackError, synchronousCallbacks)
+    }
+
+    Object.defineProperty(promise, 'isSettled', { enumerable: true, get: () => isSettled })
+    Object.defineProperty(promise, 'isPending', { enumerable: true, get: () => !isSettled })
+    Object.defineProperty(promise, 'isResolved', { enumerable: true, get: () => isResolved })
+    Object.defineProperty(promise, 'isRejected', { enumerable: true, get: () => isRejected })
+
+    promise.resolve = (value: PromiseLike<T> | T) => {
+        if (isSettled) {
+            return
+        }
+
+        isSettled = true
+        isResolved = true
+
+        resolveFn(value)
+        afterSettle(() => onResolve?.(value))
+    }
+
+    promise.reject = (reason?: unknown) => {
+        if (isSettled) {
+            return
+        }
+
+        isSettled = true
+        isRejected = true
+
+        rejectFn(reason)
+        afterSettle(() => onReject?.(reason))
+    }
+
+    abortHandler = setupAbortSignal(signal, () => {
+        promise.reject(signal?.reason ?? createAbortError())
+    })
+
+    return promise
+}
+
+export interface DeferredPromiseWithTimeoutOptions<T> extends DeferredPromiseOptions<T> {
+    error?: Errorable
+}
+
+export const createDeferredWithTimeout = <T>(ms: number, { error, signal, ...options }: DeferredPromiseWithTimeoutOptions<T> = {}) => {
+    const timeoutController = createAbortController(ms, error)
+
+    return createDeferred<T>({
+        ...options,
+        onSettle() {
+            timeoutController.abort()
+            options.onSettle?.()
+        },
+        signal: combineSignals(signal, timeoutController.signal),
+    })
+}

package/src/promises/guards.ts

@@ -0,0 +1,8 @@
+import { isFunction } from '../functions'
+import { isObject } from '../objects'
+
+export const isPromiseLike = <T>(value: unknown): value is PromiseLike<T> => isObject(value) && isFunction(value.then)
+
+export const isPromise = <T>(value: unknown): value is Promise<T> => (
+    isObject(value) && isFunction(value.then) && isFunction(value.catch) && isFunction(value.finally)
+)

package/src/promises/index.ts

@@ -0,0 +1,10 @@
+export * from './abortable'
+export * from './compositions'
+export * from './deferred'
+export * from './guards'
+export * from './pipe'
+export * from './poll'
+export * from './retry'
+export * from './timers'
+
+export type * from './types'

package/src/promises/pipe.ts

@@ -0,0 +1,39 @@
+import type { Awaitable } from './types'
+import { isNonEmptyArray } from '../arrays'
+
+export async function pPipe(): Promise<void>
+export async function pPipe<T>(fn: () => Awaitable<T>): Promise<T>
+export async function pPipe<T1, T2>(fn1: () => Awaitable<T1>, fn2: (arg: T1) => Awaitable<T2>): Promise<T2>
+export async function pPipe<T1, T2, T3>(fn1: () => Awaitable<T1>, fn2: (arg: T1) => Awaitable<T2>, fn3: (arg: T2) => Awaitable<T3>): Promise<T3>
+export async function pPipe<T1, T2, T3, T4>(fn1: () => Awaitable<T1>, fn2: (arg: T1) => Awaitable<T2>, fn3: (arg: T2) => Awaitable<T3>, fn4: (arg: T3) => Awaitable<T4>): Promise<T4>
+export async function pPipe<T1, T2, T3, T4, T5>(fn1: () => Awaitable<T1>, fn2: (arg: T1) => Awaitable<T2>, fn3: (arg: T2) => Awaitable<T3>, fn4: (arg: T3) => Awaitable<T4>, fn5: (arg: T4) => Awaitable<T5>): Promise<T5>
+export async function pPipe<T1, T2, T3, T4, T5, T6>(fn1: () => Awaitable<T1>, fn2: (arg: T1) => Awaitable<T2>, fn3: (arg: T2) => Awaitable<T3>, fn4: (arg: T3) => Awaitable<T4>, fn5: (arg: T4) => Awaitable<T5>, fn6: (arg: T5) => Awaitable<T6>): Promise<T6>
+export async function pPipe<T1, T2, T3, T4, T5, T6, T7>(fn1: () => Awaitable<T1>, fn2: (arg: T1) => Awaitable<T2>, fn3: (arg: T2) => Awaitable<T3>, fn4: (arg: T3) => Awaitable<T4>, fn5: (arg: T4) => Awaitable<T5>, fn6: (arg: T5) => Awaitable<T6>, fn7: (arg: T6) => Awaitable<T7>): Promise<T7>
+export async function pPipe<T1, T2, T3, T4, T5, T6, T7, T8>(fn1: () => Awaitable<T1>, fn2: (arg: T1) => Awaitable<T2>, fn3: (arg: T2) => Awaitable<T3>, fn4: (arg: T3) => Awaitable<T4>, fn5: (arg: T4) => Awaitable<T5>, fn6: (arg: T5) => Awaitable<T6>, fn7: (arg: T6) => Awaitable<T7>, fn8: (arg: T7) => Awaitable<T8>): Promise<T8>
+export async function pPipe<T1, T2, T3, T4, T5, T6, T7, T8, T9>(fn1: () => Awaitable<T1>, fn2: (arg: T1) => Awaitable<T2>, fn3: (arg: T2) => Awaitable<T3>, fn4: (arg: T3) => Awaitable<T4>, fn5: (arg: T4) => Awaitable<T5>, fn6: (arg: T5) => Awaitable<T6>, fn7: (arg: T6) => Awaitable<T7>, fn8: (arg: T7) => Awaitable<T8>, fn9: (arg: T8) => Awaitable<T9>): Promise<T9>
+export async function pPipe<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(fn1: () => Awaitable<T1>, fn2: (arg: T1) => Awaitable<T2>, fn3: (arg: T2) => Awaitable<T3>, fn4: (arg: T3) => Awaitable<T4>, fn5: (arg: T4) => Awaitable<T5>, fn6: (arg: T5) => Awaitable<T6>, fn7: (arg: T6) => Awaitable<T7>, fn8: (arg: T7) => Awaitable<T8>, fn9: (arg: T8) => Awaitable<T9>, fn10: (arg: T9) => Awaitable<T10>): Promise<T10>
+export async function pPipe<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(fn1: () => Awaitable<T1>, fn2: (arg: T1) => Awaitable<T2>, fn3: (arg: T2) => Awaitable<T3>, fn4: (arg: T3) => Awaitable<T4>, fn5: (arg: T4) => Awaitable<T5>, fn6: (arg: T5) => Awaitable<T6>, fn7: (arg: T6) => Awaitable<T7>, fn8: (arg: T7) => Awaitable<T8>, fn9: (arg: T8) => Awaitable<T9>, fn10: (arg: T9) => Awaitable<T10>, fn11: (arg: T10) => Awaitable<T11>): Promise<T11>
+export async function pPipe<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(fn1: () => Awaitable<T1>, fn2: (arg: T1) => Awaitable<T2>, fn3: (arg: T2) => Awaitable<T3>, fn4: (arg: T3) => Awaitable<T4>, fn5: (arg: T4) => Awaitable<T5>, fn6: (arg: T5) => Awaitable<T6>, fn7: (arg: T6) => Awaitable<T7>, fn8: (arg: T7) => Awaitable<T8>, fn9: (arg: T8) => Awaitable<T9>, fn10: (arg: T9) => Awaitable<T10>, fn11: (arg: T10) => Awaitable<T11>, fn12: (arg: T11) => Awaitable<T12>): Promise<T12>
+export async function pPipe<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(fn1: () => Awaitable<T1>, fn2: (arg: T1) => Awaitable<T2>, fn3: (arg: T2) => Awaitable<T3>, fn4: (arg: T3) => Awaitable<T4>, fn5: (arg: T4) => Awaitable<T5>, fn6: (arg: T5) => Awaitable<T6>, fn7: (arg: T6) => Awaitable<T7>, fn8: (arg: T7) => Awaitable<T8>, fn9: (arg: T8) => Awaitable<T9>, fn10: (arg: T9) => Awaitable<T10>, fn11: (arg: T10) => Awaitable<T11>, fn12: (arg: T11) => Awaitable<T12>, fn13: (arg: T12) => Awaitable<T13>): Promise<T13>
+export async function pPipe<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(fn1: () => Awaitable<T1>, fn2: (arg: T1) => Awaitable<T2>, fn3: (arg: T2) => Awaitable<T3>, fn4: (arg: T3) => Awaitable<T4>, fn5: (arg: T4) => Awaitable<T5>, fn6: (arg: T5) => Awaitable<T6>, fn7: (arg: T6) => Awaitable<T7>, fn8: (arg: T7) => Awaitable<T8>, fn9: (arg: T8) => Awaitable<T9>, fn10: (arg: T9) => Awaitable<T10>, fn11: (arg: T10) => Awaitable<T11>, fn12: (arg: T11) => Awaitable<T12>, fn13: (arg: T12) => Awaitable<T13>, fn14: (arg: T13) => Awaitable<T14>): Promise<T14>
+export async function pPipe<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(fn1: () => Awaitable<T1>, fn2: (arg: T1) => Awaitable<T2>, fn3: (arg: T2) => Awaitable<T3>, fn4: (arg: T3) => Awaitable<T4>, fn5: (arg: T4) => Awaitable<T5>, fn6: (arg: T5) => Awaitable<T6>, fn7: (arg: T6) => Awaitable<T7>, fn8: (arg: T7) => Awaitable<T8>, fn9: (arg: T8) => Awaitable<T9>, fn10: (arg: T9) => Awaitable<T10>, fn11: (arg: T10) => Awaitable<T11>, fn12: (arg: T11) => Awaitable<T12>, fn13: (arg: T12) => Awaitable<T13>, fn14: (arg: T13) => Awaitable<T14>, fn15: (arg: T14) => Awaitable<T15>): Promise<T15>
+export async function pPipe<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(fn1: () => Awaitable<T1>, fn2: (arg: T1) => Awaitable<T2>, fn3: (arg: T2) => Awaitable<T3>, fn4: (arg: T3) => Awaitable<T4>, fn5: (arg: T4) => Awaitable<T5>, fn6: (arg: T5) => Awaitable<T6>, fn7: (arg: T6) => Awaitable<T7>, fn8: (arg: T7) => Awaitable<T8>, fn9: (arg: T8) => Awaitable<T9>, fn10: (arg: T9) => Awaitable<T10>, fn11: (arg: T10) => Awaitable<T11>, fn12: (arg: T11) => Awaitable<T12>, fn13: (arg: T12) => Awaitable<T13>, fn14: (arg: T13) => Awaitable<T14>, fn15: (arg: T14) => Awaitable<T15>, fn16: (arg: T15) => Awaitable<T16>): Promise<T16>
+export async function pPipe<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>(fn1: () => Awaitable<T1>, fn2: (arg: T1) => Awaitable<T2>, fn3: (arg: T2) => Awaitable<T3>, fn4: (arg: T3) => Awaitable<T4>, fn5: (arg: T4) => Awaitable<T5>, fn6: (arg: T5) => Awaitable<T6>, fn7: (arg: T6) => Awaitable<T7>, fn8: (arg: T7) => Awaitable<T8>, fn9: (arg: T8) => Awaitable<T9>, fn10: (arg: T9) => Awaitable<T10>, fn11: (arg: T10) => Awaitable<T11>, fn12: (arg: T11) => Awaitable<T12>, fn13: (arg: T12) => Awaitable<T13>, fn14: (arg: T13) => Awaitable<T14>, fn15: (arg: T14) => Awaitable<T15>, fn16: (arg: T15) => Awaitable<T16>, fn17: (arg: T16) => Awaitable<T17>): Promise<T17>
+export async function pPipe<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>(fn1: () => Awaitable<T1>, fn2: (arg: T1) => Awaitable<T2>, fn3: (arg: T2) => Awaitable<T3>, fn4: (arg: T3) => Awaitable<T4>, fn5: (arg: T4) => Awaitable<T5>, fn6: (arg: T5) => Awaitable<T6>, fn7: (arg: T6) => Awaitable<T7>, fn8: (arg: T7) => Awaitable<T8>, fn9: (arg: T8) => Awaitable<T9>, fn10: (arg: T9) => Awaitable<T10>, fn11: (arg: T10) => Awaitable<T11>, fn12: (arg: T11) => Awaitable<T12>, fn13: (arg: T12) => Awaitable<T13>, fn14: (arg: T13) => Awaitable<T14>, fn15: (arg: T14) => Awaitable<T15>, fn16: (arg: T15) => Awaitable<T16>, fn17: (arg: T16) => Awaitable<T17>, fn18: (arg: T17) => Awaitable<T18>): Promise<T18>
+export async function pPipe<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>(fn1: () => Awaitable<T1>, fn2: (arg: T1) => Awaitable<T2>, fn3: (arg: T2) => Awaitable<T3>, fn4: (arg: T3) => Awaitable<T4>, fn5: (arg: T4) => Awaitable<T5>, fn6: (arg: T5) => Awaitable<T6>, fn7: (arg: T6) => Awaitable<T7>, fn8: (arg: T7) => Awaitable<T8>, fn9: (arg: T8) => Awaitable<T9>, fn10: (arg: T9) => Awaitable<T10>, fn11: (arg: T10) => Awaitable<T11>, fn12: (arg: T11) => Awaitable<T12>, fn13: (arg: T12) => Awaitable<T13>, fn14: (arg: T13) => Awaitable<T14>, fn15: (arg: T14) => Awaitable<T15>, fn16: (arg: T15) => Awaitable<T16>, fn17: (arg: T16) => Awaitable<T17>, fn18: (arg: T17) => Awaitable<T18>, fn19: (arg: T18) => Awaitable<T19>): Promise<T19>
+export async function pPipe<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>(fn1: () => Awaitable<T1>, fn2: (arg: T1) => Awaitable<T2>, fn3: (arg: T2) => Awaitable<T3>, fn4: (arg: T3) => Awaitable<T4>, fn5: (arg: T4) => Awaitable<T5>, fn6: (arg: T5) => Awaitable<T6>, fn7: (arg: T6) => Awaitable<T7>, fn8: (arg: T7) => Awaitable<T8>, fn9: (arg: T8) => Awaitable<T9>, fn10: (arg: T9) => Awaitable<T10>, fn11: (arg: T10) => Awaitable<T11>, fn12: (arg: T11) => Awaitable<T12>, fn13: (arg: T12) => Awaitable<T13>, fn14: (arg: T13) => Awaitable<T14>, fn15: (arg: T14) => Awaitable<T15>, fn16: (arg: T15) => Awaitable<T16>, fn17: (arg: T16) => Awaitable<T17>, fn18: (arg: T17) => Awaitable<T18>, fn19: (arg: T18) => Awaitable<T19>, fn20: (arg: T19) => Awaitable<T20>): Promise<T20>
+export async function pPipe(...fns: CallableFunction[]): Promise<unknown>
+
+export async function pPipe(...fns: CallableFunction[]) {
+    if (!isNonEmptyArray(fns)) {
+        return
+    }
+
+    let result = await fns[0]()
+
+    for (let i = 1; i < fns.length; i++) {
+        result = await fns[i]!(result)
+    }
+
+    return result
+}

package/src/promises/poll.ts

@@ -0,0 +1,92 @@
+import type { Awaitable } from './types'
+import { assertParam } from '../common'
+import { createAbortController, isAbortError } from '../errors'
+import { isFunction } from '../functions'
+import { isPlainObject } from '../objects'
+import { abortable } from './abortable'
+import { sleep } from './timers'
+
+export interface PollOptions {
+    delay?: number
+    immediately?: boolean
+    onError?: (error: unknown) => void
+    stopOnError?: boolean
+}
+
+export type PollFn = (signal: AbortSignal) => Awaitable<void>
+
+export function poll(fn: PollFn, options?: PollOptions): () => Promise<void>
+export function poll(options: PollOptions, fn: PollFn): () => Promise<void>
+
+export function poll(fnOrOptions: PollFn | PollOptions, optionsOrFn: PollFn | PollOptions = {}) {
+    let fn: PollFn
+    let options: PollOptions
+
+    if (isFunction(fnOrOptions) && isPlainObject(optionsOrFn)) {
+        fn = fnOrOptions
+        options = optionsOrFn
+    } else {
+        assertParam(isPlainObject(fnOrOptions), 'options must be an object')
+        assertParam(isFunction(optionsOrFn), 'fn must be a function')
+
+        fn = optionsOrFn
+        options = fnOrOptions
+    }
+
+    const { delay = 0, immediately = true, onError, stopOnError = true } = options
+    const abortController = createAbortController()
+
+    let isActive = true
+    let currentTask: Promise<void> | undefined
+
+    const stop = () => {
+        isActive = false
+        abortController.abort()
+
+        return currentTask ?? Promise.resolve()
+    }
+
+    let startRun: () => void
+
+    const run = async () => {
+        if (!isActive) {
+            return
+        }
+
+        try {
+            await abortable(Promise.resolve(fn(abortController.signal)), abortController.signal)
+
+            if (isActive) {
+                await sleep(delay, { signal: abortController.signal })
+            }
+        } catch (error) {
+            if (isAbortError(error) && !isActive) {
+                return
+            }
+
+            onError?.(error)
+
+            if (stopOnError) {
+                stop()
+
+                return
+            }
+        }
+
+        setTimeout(startRun, 0)
+    }
+
+    startRun = () => {
+        currentTask = run().finally(() => {
+            currentTask = undefined
+        })
+    }
+
+    if (immediately) {
+        Promise.resolve().then(startRun)
+    } else {
+        setTimeout(startRun, delay)
+    }
+
+    return stop
+}

package/src/promises/retry.ts

@@ -0,0 +1,138 @@
+import type { Awaitable } from './types'
+import { isAbortError } from '../errors'
+import { clamp } from '../numbers'
+import { abortable } from './abortable'
+import { sleep } from './timers'
+
+export interface GetRetryDelayOptions {
+    backoff?: number
+    delay?: number
+    jitter?: number
+    maxDelay?: number
+}
+
+export function getRetryDelay(attempts: number, { backoff = 2, delay = 1000, jitter = 0.01, maxDelay = 10_000 }: GetRetryDelayOptions = {}) {
+    const exponentialDelay = delay * backoff ** (attempts - 1)
+    const clampedDelay = clamp(exponentialDelay, 0, maxDelay)
+
+    if (jitter <= 0) {
+        return clampedDelay
+    }
+
+    const jitterRange = clampedDelay * jitter
+    const jitterOffset = (Math.random() - 0.5) * 2 * jitterRange
+
+    return clamp(clampedDelay + jitterOffset, 0, maxDelay)
+}
+
+export interface WithRetryContext {
+    attempts: number
+    retriesLeft: number
+    signal?: AbortSignal
+}
+
+export interface WithRetryOptions<T> extends GetRetryDelayOptions {
+    maxAttempts?: number
+    onBeforeWaitForNextAttempt?: (delay: number, context: WithRetryContext) => Awaitable<void>
+    onFailedAttempt?: (error: unknown, context: WithRetryContext) => Awaitable<void>
+    onSuccessAttempt?: (response: T, context: WithRetryContext) => Awaitable<void>
+    shouldRetry?: (error: unknown, context: WithRetryContext) => Awaitable<boolean>
+    shouldRetryOnSuccess?: (result: T, context: WithRetryContext) => Awaitable<boolean>
+    signal?: AbortSignal
+}
+
+export function createRetryError(errors: unknown[]) {
+    if (errors.length === 1) {
+        return errors[0]
+    }
+
+    return new AggregateError(errors, 'All retry attempts failed')
+}
+
+export function rethrowNonAbortError(error: unknown) {
+    if (!isAbortError(error)) {
+        throw error
+    }
+}
+
+export async function waitForNextRetryAttempt(attempts: number, delayOptions: GetRetryDelayOptions, onBeforeWaitForNextAttempt: WithRetryOptions<unknown>['onBeforeWaitForNextAttempt'], signal: AbortSignal | undefined, context: WithRetryContext) {
+    const delay = getRetryDelay(attempts, delayOptions)
+
+    await onBeforeWaitForNextAttempt?.(delay, context)
+    await sleep(delay, { signal }).catch(rethrowNonAbortError)
+}
+
+export async function handleRetryFailure<T>(error: unknown, errors: unknown[], retriesLeft: number, shouldRetry: WithRetryOptions<T>['shouldRetry'], onFailedAttempt: WithRetryOptions<T>['onFailedAttempt'], context: WithRetryContext) {
+    if (isAbortError(error)) {
+        throw error
+    }
+
+    errors.push(error)
+
+    if (retriesLeft <= 0) {
+        throw createRetryError(errors)
+    }
+
+    if (shouldRetry && !(await shouldRetry(error, context))) {
+        throw createRetryError(errors)
+    }
+
+    await onFailedAttempt?.(error, context)
+}
+
+export async function handleRetrySuccess<T>(result: T, errors: unknown[], retriesLeft: number, shouldRetryOnSuccess: WithRetryOptions<T>['shouldRetryOnSuccess'], onSuccessAttempt: WithRetryOptions<T>['onSuccessAttempt'], context: WithRetryContext): Promise<boolean> {
+    if (!shouldRetryOnSuccess || !(await shouldRetryOnSuccess(result, context))) {
+        return true
+    }
+
+    if (retriesLeft <= 0) {
+        throw createRetryError(errors)
+    }
+
+    await onSuccessAttempt?.(result, context)
+
+    return false
+}
+
+export async function withRetry<T>(fn: (signal?: AbortSignal) => Awaitable<T>, { maxAttempts = 3, onBeforeWaitForNextAttempt, onFailedAttempt, onSuccessAttempt, shouldRetry, shouldRetryOnSuccess, signal, ...delayOptions }: WithRetryOptions<T> = {}): Promise<T> {
+    if (maxAttempts < 1) {
+        throw new RangeError('maxAttempts must be at least 1')
+    }
+
+    if (signal) {
+        signal.throwIfAborted()
+    }
+
+    let attempts = 0
+    let result: T
+
+    const errors: unknown[] = []
+
+    while (attempts < maxAttempts) {
+        const retriesLeft = maxAttempts - ((attempts++) + 1)
+        const context = { attempts, retriesLeft, signal }
+
+        try {
+            if (signal) {
+                signal.throwIfAborted()
+            }
+
+            result = await abortable(Promise.resolve(fn(signal)), signal)
+        } catch (error) {
+            await handleRetryFailure(error, errors, retriesLeft, shouldRetry, onFailedAttempt, context)
+            await waitForNextRetryAttempt(attempts, delayOptions, onBeforeWaitForNextAttempt, signal, context)
+
+            continue
+        }
+
+        const shouldReturn = await handleRetrySuccess(result, errors, retriesLeft, shouldRetryOnSuccess, onSuccessAttempt, context)
+
+        if (shouldReturn) {
+            return result
+        }
+
+        await waitForNextRetryAttempt(attempts, delayOptions, onBeforeWaitForNextAttempt, signal, context)
+    }
+
+    throw createRetryError(errors)
+}