@kdtlabs/utils 0.0.4 → 0.0.5

package/src/core/types.ts

@@ -0,0 +1,15 @@
+export type Primitive = bigint | boolean | number | string | symbol | null | undefined
+
+export type Optional<T> = T | undefined
+
+export type Nullable<T> = T | null
+
+export type Nullish<T> = T | null | undefined
+
+export type Never<T extends never = never> = T
+
+export type IsContainsType<T, U> = Extract<T, U> extends never ? false : true
+
+export type JsonablePrimitive = boolean | number | string | null
+
+export type Jsonable = Jsonable[] | JsonablePrimitive | { [key: string]: Jsonable }

package/src/errors/base-error.ts

@@ -0,0 +1,48 @@
+export type BaseErrorCode = number | string
+
+export interface BaseErrorOptions extends ErrorOptions {
+    cause?: unknown
+    code?: BaseErrorCode
+    details?: string
+    exitCode?: number
+    name?: string
+    retryable?: boolean
+    timestamp?: Date
+}
+
+export class BaseError extends Error {
+    public declare readonly timestamp: Date
+    public declare readonly code?: BaseErrorCode
+    public declare readonly cause?: unknown
+    public declare readonly details?: string
+    public declare readonly exitCode?: number
+    public declare readonly retryable?: boolean
+
+    public constructor(message: string, { code, details, exitCode, name, retryable, timestamp, ...options }: BaseErrorOptions = {}) {
+        super(message, options)
+
+        Object.setPrototypeOf(this, new.target.prototype)
+
+        this.defineValue('name', name ?? this.constructor.name)
+        this.defineValue('timestamp', timestamp ?? new Date())
+        this.defineValue('cause', options.cause)
+        this.defineValue('code', code)
+        this.defineValue('details', details)
+        this.defineValue('exitCode', exitCode)
+        this.defineValue('retryable', retryable)
+    }
+
+    public withValue<K extends string, V>(key: K, value: V): Record<K, V> & this {
+        if (Object.hasOwn(this, key)) {
+            throw new TypeError(`Cannot redefine property '${key}' on ${this.name}`)
+        }
+
+        return this.defineValue(key, value) as Record<K, V> & this
+    }
+
+    protected defineValue(key: string, value: unknown) {
+        Object.defineProperty(this, key, { configurable: false, enumerable: true, value, writable: false })
+
+        return this
+    }
+}

package/src/errors/factories.ts

@@ -0,0 +1,74 @@
+import type { Errorable, ErrorCtor, ErrorLike } from './types'
+import { isString, notNullish } from '../core'
+import { isErrorLike } from './guards'
+
+export const createAbortError = (message = 'This operation was aborted', name = 'AbortError') => new DOMException(message, name)
+
+export const createTimeoutError = (message = 'The operation was aborted due to a timeout', name = 'TimeoutError') => createAbortError(message, name)
+
+export function createAbortController(timeout?: number, timeoutError?: Errorable) {
+    const controller = new AbortController()
+
+    if (notNullish(timeout) && timeout > 0 && timeout <= Number.MAX_SAFE_INTEGER) {
+        let timeoutId: NodeJS.Timeout
+
+        const cleanup = () => {
+            clearTimeout(timeoutId)
+            controller.signal.removeEventListener('abort', cleanup)
+        }
+
+        controller.signal.addEventListener('abort', cleanup)
+        timeoutId = setTimeout(() => controller.abort(ensureError(timeoutError ?? createTimeoutError())), timeout)
+    }
+
+    return controller
+}
+
+export function ensureError(input: Errorable, ctor?: ErrorCtor) {
+    if (typeof input === 'string') {
+        return ctor ? new ctor(input) : new Error(input)
+    }
+
+    if (typeof input === 'function') {
+        return ensureError(input(), ctor)
+    }
+
+    return input
+}
+
+export function fromErrorLike({ cause, message, name, stack, ...properties }: ErrorLike, ctor?: ErrorCtor) {
+    const errorClass = ctor ?? Error
+    const error = new errorClass(message, { cause })
+
+    Object.defineProperty(error, 'name', { configurable: true, enumerable: false, value: name, writable: true })
+    Object.defineProperty(error, 'stack', { configurable: true, enumerable: false, value: stack, writable: true })
+
+    for (const [key, value] of Object.entries(properties)) {
+        Object.defineProperty(error, key, Object.getOwnPropertyDescriptor(properties, key) ?? { configurable: true, enumerable: true, value, writable: true })
+    }
+
+    return error
+}
+
+export interface NormalizeErrorOptions {
+    defaultMessage?: string
+    errorConstructor?: ErrorCtor
+}
+
+export function normalizeError(error: unknown, { defaultMessage = 'Unknown error', errorConstructor }: NormalizeErrorOptions = {}) {
+    const errorClass = errorConstructor ?? Error
+
+    if (error instanceof errorClass) {
+        return error
+    }
+
+    if (isString(error)) {
+        return ensureError(error, errorConstructor)
+    }
+
+    if (isErrorLike(error)) {
+        return fromErrorLike(error, errorConstructor)
+    }
+
+    return new errorClass(defaultMessage, { cause: error })
+}

package/src/errors/guards.ts

@@ -0,0 +1,12 @@
+import type { ErrorLike } from './types'
+import { isString } from '../core'
+import { isKeysOf, isObject } from '../objects'
+import { BaseError } from './base-error'
+
+export const isError = (value: unknown): value is Error => value instanceof Error
+
+export const isBaseError = (value: unknown): value is BaseError => value instanceof BaseError
+
+export const isAbortError = (error: unknown): error is DOMException => error instanceof DOMException && error.name === 'AbortError'
+
+export const isErrorLike = (value: unknown): value is ErrorLike => isObject(value) && isKeysOf(value, 'name') && isString(value.name)

package/src/errors/index.ts

@@ -0,0 +1,7 @@
+export * from './base-error'
+export * from './factories'
+export * from './guards'
+export * from './operations'
+export * from './stringify'
+
+export type * from './types'

package/src/errors/operations.ts

@@ -0,0 +1,15 @@
+import { notNullish, type Nullish } from '../core'
+
+export function combineSignals(...signals: Array<Nullish<AbortSignal>>) {
+    const validSignals = signals.filter(notNullish)
+
+    if (validSignals.length === 0) {
+        return new AbortController().signal
+    }
+
+    if (validSignals.length === 1) {
+        return validSignals[0]!
+    }
+
+    return AbortSignal.any(validSignals)
+}

package/src/errors/stringify.ts

@@ -0,0 +1,131 @@
+import { isString, notNullish } from '../core'
+import { isObject } from '../objects'
+import { normalizeError, type NormalizeErrorOptions } from './factories'
+
+export interface StringifyErrorFormatters {
+    code?: (code: string) => string
+    message?: (message: string) => string
+    name?: (name: string) => string
+}
+
+export interface StringifyErrorOptions extends NormalizeErrorOptions {
+    causeIndent?: number
+    causePrefix?: string
+    circularReferenceMessage?: string
+    formatters?: StringifyErrorFormatters
+    includeCause?: boolean
+    includeCode?: boolean
+    includeName?: boolean
+    maxCauseDepth?: number
+}
+
+export const DEFAULT_STRINGIFY_FORMATTERS: Required<StringifyErrorFormatters> = {
+    code: (value) => `[${value}]`,
+    message: (value) => value,
+    name: (value) => `${value}:`,
+}
+
+export interface StringifyErrorState {
+    causeIndent: number
+    causePrefix: string
+    circularReferenceMessage: string
+    defaultMessage: string
+    formatters: Required<StringifyErrorFormatters>
+    includeCause: boolean
+    includeCode: boolean
+    includeName: boolean
+    maxCauseDepth: number
+    normalizeOptions: NormalizeErrorOptions
+    visited: Set<unknown>
+}
+
+export function collectCauses(error: Error, depth: number, indent: string, state: StringifyErrorState) {
+    const childIndent = indent + ' '.repeat(state.causeIndent)
+    const pointers: string[] = []
+
+    if (error instanceof AggregateError && error.errors.length > 0) {
+        for (const subError of error.errors) {
+            pointers.push(stringifyErrorNode(subError, depth - 1, childIndent, state.causePrefix, state))
+        }
+    }
+
+    if (isObject(error.cause) || isString(error.cause)) {
+        pointers.push(stringifyErrorNode(error.cause, depth - 1, childIndent, state.causePrefix, state))
+    }
+
+    return pointers
+}
+
+export function appendCauses(parts: string[], error: Error, error_: unknown, depth: number, indent: string, state: StringifyErrorState) {
+    if (!state.includeCause || depth <= 0 || (error !== error_ && error.cause === error_)) {
+        return
+    }
+
+    const pointers = collectCauses(error, depth, indent, state)
+
+    if (pointers.length > 0) {
+        parts.push(`\n${pointers.join('\n')}`)
+    }
+}
+
+export function buildErrorParts(error: Error, state: StringifyErrorState) {
+    const parts: string[] = []
+
+    if (state.includeCode && 'code' in error && notNullish(error.code)) {
+        parts.push(state.formatters.code(String(error.code)))
+    }
+
+    if (state.includeName) {
+        parts.push(state.formatters.name(error.name))
+    }
+
+    parts.push(state.formatters.message(error.message || state.defaultMessage))
+
+    return parts
+}
+
+export function stringifyErrorNode(error_: unknown, depth: number, indent: string, prefix: string, state: StringifyErrorState): string {
+    if (state.visited.has(error_)) {
+        return `${indent}${prefix}${state.circularReferenceMessage}`
+    }
+
+    if (error_ instanceof Error) {
+        state.visited.add(error_)
+    }
+
+    if (error_ instanceof Error && error_.toString !== Error.prototype.toString) {
+        const parts = [error_.toString()]
+        appendCauses(parts, error_, error_, depth, indent, state)
+
+        return indent + prefix + parts.join(' ')
+    }
+
+    const error = normalizeError(error_, { ...state.normalizeOptions, defaultMessage: state.defaultMessage })
+
+    state.visited.add(error)
+
+    const parts = buildErrorParts(error, state)
+    appendCauses(parts, error, error_, depth, indent, state)
+
+    return indent + prefix + parts.join(' ')
+}
+
+export function stringifyError(error: unknown, options: StringifyErrorOptions = {}) {
+    const { causeIndent = 2, causePrefix = '-> ', circularReferenceMessage = '[Circular Reference]', defaultMessage = 'Unknown error', formatters: formatters_ = {}, includeCause = true, includeCode = true, includeName = true, maxCauseDepth = Number.POSITIVE_INFINITY, ...normalizeOptions } = options
+
+    const state: StringifyErrorState = {
+        causeIndent,
+        causePrefix,
+        circularReferenceMessage,
+        defaultMessage,
+        formatters: { ...DEFAULT_STRINGIFY_FORMATTERS, ...formatters_ },
+        includeCause,
+        includeCode,
+        includeName,
+        maxCauseDepth,
+        normalizeOptions,
+        visited: new Set<unknown>(),
+    }
+
+    return stringifyErrorNode(error, maxCauseDepth, '', '', state)
+}

package/src/errors/types.ts

@@ -0,0 +1,11 @@
+export type Errorable = Error | (() => Error | string) | string
+
+export type ErrorCtor = new (message?: string, options?: ErrorOptions) => Error
+
+export interface ErrorLike {
+    [key: string]: unknown
+    cause?: unknown
+    message?: string
+    name: string
+    stack?: string
+}

package/src/events/emitter.ts

@@ -0,0 +1,117 @@
+import type { EventArgs, EventListener, EventListenerMap, EventMap, EventNames } from './types'
+
+export class Emitter<TEventMap = EventMap, TStrict extends boolean = false> {
+    protected readonly eventListeners: EventListenerMap
+    protected readonly onceListeners: EventListenerMap
+
+    public constructor() {
+        this.eventListeners = new Map()
+        this.onceListeners = new Map()
+    }
+
+    public listeners<TEventName extends EventNames<TEventMap, TStrict>>(eventName: TEventName): Array<EventListener<EventArgs<TEventMap, TEventName, TStrict>>> {
+        const listeners = this.eventListeners.get(eventName) ?? []
+        const onceListeners = this.onceListeners.get(eventName) ?? []
+
+        return [...listeners, ...onceListeners]
+    }
+
+    public listenersCount<TEventName extends EventNames<TEventMap, TStrict>>(eventName: TEventName) {
+        const listeners = this.eventListeners.get(eventName)
+        const onceListeners = this.onceListeners.get(eventName)
+
+        return (listeners?.size ?? 0) + (onceListeners?.size ?? 0)
+    }
+
+    public eventNames(): Array<PropertyKey | keyof TEventMap> {
+        return [...new Set([...this.eventListeners.keys(), ...this.onceListeners.keys()])]
+    }
+
+    public on<TEventName extends EventNames<TEventMap, TStrict>>(eventName: TEventName, listener: EventListener<EventArgs<TEventMap, TEventName, TStrict>>): this {
+        this.#addTo(this.eventListeners, eventName, listener)
+
+        return this
+    }
+
+    public once<TEventName extends EventNames<TEventMap, TStrict>>(eventName: TEventName, listener: EventListener<EventArgs<TEventMap, TEventName, TStrict>>): this {
+        this.#addTo(this.onceListeners, eventName, listener)
+
+        return this
+    }
+
+    public off<TEventName extends EventNames<TEventMap, TStrict>>(eventName: TEventName, listener: EventListener<EventArgs<TEventMap, TEventName, TStrict>>): this {
+        this.#removeFrom(this.eventListeners, eventName, listener)
+        this.#removeFrom(this.onceListeners, eventName, listener)
+
+        return this
+    }
+
+    public emit<TEventName extends EventNames<TEventMap, TStrict>>(eventName: TEventName, ...args: EventArgs<TEventMap, TEventName, TStrict>): boolean {
+        const regularSnapshot = this.#takeSnapshot(this.eventListeners.get(eventName))
+        const onceSnapshot = this.#takeSnapshot(this.onceListeners.get(eventName))
+
+        this.onceListeners.delete(eventName)
+
+        const fromRegular = this.#emitSnapshot(regularSnapshot, args)
+        const fromOnce = this.#emitSnapshot(onceSnapshot, args)
+
+        return fromRegular || fromOnce
+    }
+
+    public removeAllListeners<TEventName extends EventNames<TEventMap, TStrict>>(eventName?: TEventName): this {
+        if (eventName === undefined) {
+            this.eventListeners.clear()
+            this.onceListeners.clear()
+        } else {
+            this.eventListeners.delete(eventName)
+            this.onceListeners.delete(eventName)
+        }
+
+        return this
+    }
+
+    #addTo(map: EventListenerMap, eventName: PropertyKey, listener: EventListener) {
+        let set = map.get(eventName)
+
+        if (!set) {
+            set = new Set()
+            map.set(eventName, set)
+        }
+
+        set.add(listener)
+    }
+
+    #removeFrom(map: EventListenerMap, eventName: PropertyKey, listener: EventListener) {
+        const set = map.get(eventName)
+
+        if (!set) {
+            return
+        }
+
+        set.delete(listener)
+
+        if (set.size === 0) {
+            map.delete(eventName)
+        }
+    }
+
+    #takeSnapshot(set: Set<EventListener> | undefined) {
+        if (!set || set.size === 0) {
+            return []
+        }
+
+        return [...set]
+    }
+
+    #emitSnapshot(snapshot: EventListener[], args: any[]) {
+        if (snapshot.length === 0) {
+            return false
+        }
+
+        for (const listener of snapshot) {
+            listener(...args)
+        }
+
+        return true
+    }
+}

package/src/events/index.ts

@@ -0,0 +1,2 @@
+export * from './emitter'
+export type * from './types'

package/src/events/types.ts

@@ -0,0 +1,11 @@
+export type EventMap = Record<PropertyKey, any[]>
+
+export type EventNames<TEventMap, TStrict extends boolean> = TStrict extends true ? keyof TEventMap : keyof TEventMap | string
+
+export type ResolveEventArgs<TEventMap, TEventName> = TEventName extends keyof TEventMap ? TEventMap[TEventName] extends any[] ? TEventMap[TEventName] : any[] : any[]
+
+export type EventArgs<TEventMap, TEventName, TStrict extends boolean> = TStrict extends true ? TEventName extends keyof TEventMap ? ResolveEventArgs<TEventMap, TEventName> : never : ResolveEventArgs<TEventMap, TEventName>
+
+export type EventListener<TArgs = any[]> = (...args: TArgs extends any[] ? TArgs : any[]) => void
+
+export type EventListenerMap = Map<PropertyKey, Set<EventListener>>

package/src/functions/compositions.ts

@@ -0,0 +1,17 @@
+import { isFunction } from './guards'
+
+export function tap<T>(value: T, callback: (value: T) => void) {
+    callback(value)
+
+    return value
+}
+
+export const transform = <T, R>(value: T, callback: (value: T) => R) => callback(value)
+
+export function tryCatch<T>(fn: () => T, fallback: T | ((error: unknown) => T)) {
+    try {
+        return fn()
+    } catch (error) {
+        return isFunction(fallback) ? fallback(error) : fallback
+    }
+}

package/src/functions/debounce.ts

@@ -0,0 +1,34 @@
+import type { Args, Fn, TimingControlled } from './types'
+import { createTimerState, flushTimer, invokeTimer } from './timer-state'
+
+export type Debounced<T extends Fn> = TimingControlled<T>
+
+export function debounce<T extends Fn>(fn: T, wait: number): Debounced<T> {
+    const state = createTimerState<T>()
+    const invoke = () => invokeTimer(state, fn)
+
+    const debounced: Debounced<T> = function (this: unknown, ...args: Args<T>) {
+        state.lastArgs = args
+        state.lastThis = this
+
+        if (state.timeoutId !== undefined) {
+            clearTimeout(state.timeoutId)
+        }
+
+        state.timeoutId = setTimeout(invoke, wait)
+    }
+
+    debounced.cancel = () => {
+        if (state.timeoutId !== undefined) {
+            clearTimeout(state.timeoutId)
+            state.timeoutId = undefined
+            state.lastArgs = undefined
+        }
+    }
+
+    debounced.flush = () => {
+        return flushTimer(state, invoke)
+    }
+
+    return debounced
+}

package/src/functions/executions.ts

@@ -0,0 +1,12 @@
+import type { Nullish } from '../core'
+import type { Fn } from './types'
+
+export const noop = () => void 0
+
+export const invoke = <T>(fn: () => T) => fn()
+
+export function invokes(functions: Array<Nullish<Fn>>) {
+    for (const fn of functions) {
+        fn?.()
+    }
+}

package/src/functions/guards.ts

@@ -0,0 +1,5 @@
+import type { Fn } from './types'
+
+export const isFunction = <T extends Fn>(value: unknown): value is T => (
+    typeof value === 'function'
+)

package/src/functions/index.ts

@@ -0,0 +1,11 @@
+export * from './compositions'
+export * from './debounce'
+export * from './executions'
+export * from './guards'
+export * from './memoize'
+export * from './once'
+export * from './pipe'
+export * from './throttle'
+export * from './timer-state'
+
+export type * from './types'

package/src/functions/memoize.ts

@@ -0,0 +1,33 @@
+import type { Args, Fn } from './types'
+
+export interface MemoizeCache<V = unknown> {
+    delete(key: unknown): boolean
+    get(key: unknown): V | undefined
+    has(key: unknown): boolean
+    set(key: unknown, value: V): void
+}
+
+export interface MemoizeOptions<T extends Fn> {
+    cache?: MemoizeCache<ReturnType<T>>
+    resolver?: (...args: Args<T>) => unknown
+}
+
+export function memoize<T extends Fn>(fn: T, { cache = new Map(), resolver }: MemoizeOptions<T> = {}) {
+    const memoized = function (this: unknown, ...args: Args<T>) {
+        const key = resolver ? resolver(...args) : args[0]
+
+        if (cache.has(key)) {
+            return cache.get(key)
+        }
+
+        const result = fn.apply(this, args)
+
+        cache.set(key, result)
+
+        return result
+    } as T & { cache: MemoizeCache<ReturnType<T>> }
+
+    memoized.cache = cache
+
+    return memoized
+}

package/src/functions/once.ts

@@ -0,0 +1,33 @@
+import type { Args, Fn } from './types'
+import { normalizeError } from '../errors'
+
+export function once<T extends Fn>(fn: T) {
+    let called = false
+    let result: ReturnType<T>
+    let error: unknown
+
+    const cb = (...args: Args<T>): ReturnType<T> => {
+        if (called) {
+            if (error) {
+                throw normalizeError(error)
+            }
+
+            return result
+        }
+
+        called = true
+
+        try {
+            return (result = fn(...args))
+        } catch (error_) {
+            throw error = normalizeError(error_)
+        }
+    }
+
+    cb.reset = () => {
+        called = false
+        error = undefined
+    }
+
+    return cb
+}

package/src/functions/pipe.ts

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