1358 lines
36 KiB
TypeScript
1358 lines
36 KiB
TypeScript
/**
|
||
* Type Helpers
|
||
*
|
||
* @module Types
|
||
*/
|
||
/**
|
||
* Promise, or maybe not
|
||
* @category Types
|
||
*/
|
||
type Awaitable<T> = T | PromiseLike<T>;
|
||
/**
|
||
* Function
|
||
* @category Types
|
||
*/
|
||
type Fn<T = void> = (...args: any[]) => T;
|
||
/**
|
||
* Async Function
|
||
* @category Types
|
||
*/
|
||
type AsyncFn<T = void> = (...args: any[]) => Promise<T>;
|
||
/**
|
||
* The return type of an async function
|
||
* @category Types
|
||
*/
|
||
type AsyncReturnType<T extends AsyncFn> = Awaited<ReturnType<T>>;
|
||
/**
|
||
* null or whatever
|
||
* @category Types
|
||
*/
|
||
type Nullable<T> = T | null | undefined;
|
||
/**
|
||
* array or not yet
|
||
* @category Types
|
||
*/
|
||
type Arrayable<T> = T | T[];
|
||
/**
|
||
* Constructor
|
||
* @category Types
|
||
*/
|
||
type Constructor<T = void> = new (...arg: any[]) => T;
|
||
/**
|
||
* Infers the element type of an array
|
||
* @category Types
|
||
*/
|
||
type ElementOf<T> = T extends (infer E)[] ? E : never;
|
||
|
||
/**
|
||
* Processing array-type data
|
||
*
|
||
* 处理数组类型的数据
|
||
*
|
||
* @module Array
|
||
*/
|
||
|
||
/**
|
||
* Convert `Arrayable<T>` to `Array<T>`
|
||
*
|
||
* 将 `Arrayable<T>` 转换为 `Array<T>`
|
||
*
|
||
* @category Array
|
||
* @example
|
||
* ```ts
|
||
* toArray(null) // => []
|
||
* toArray(undefined) // => []
|
||
* toArray([]) // => []
|
||
* toArray(1) // => [1]
|
||
* ```
|
||
*/
|
||
declare function toArray<T>(v: Nullable<Arrayable<T>>): Array<T>;
|
||
/**
|
||
* Unique array
|
||
*
|
||
* 数组去重
|
||
*
|
||
* @category Array
|
||
* @example
|
||
* ```ts
|
||
* uniq([1, 1, 2, 2, 3, 3]) // => [1, 2, 3]
|
||
* ```
|
||
*/
|
||
declare function uniq<T>(v: T[]): T[];
|
||
/**
|
||
* Unique array by a custom equality function
|
||
*
|
||
* 通过自定义相等函数实现数组去重
|
||
*
|
||
* @category Array
|
||
* @example
|
||
* ```ts
|
||
* uniqueBy([1, 1, 2, 2, 3, 3], (a, b) => a === b) // => [1, 2, 3]
|
||
* ```
|
||
*/
|
||
declare function uniqueBy<T>(array: T[], equalFn: (a: T, b: T) => boolean): T[];
|
||
/**
|
||
* Remove value from array
|
||
*
|
||
* 从数组中移除值
|
||
*
|
||
* @category Array
|
||
*
|
||
* @param array - the array
|
||
* @param value - the value to remove - 待移除的值
|
||
* @returns - if `true`, the value is removed, `false` otherwise.
|
||
* - 如果成功移除,返回 `true`, 否则返回 `false`
|
||
*
|
||
* @example
|
||
* ```ts
|
||
* const arr = [1, 2, 3]
|
||
* remove(arr, 2) // => true
|
||
* console.log(arr) // => [1, 3]
|
||
* remove(arr, 4) // => false
|
||
* ```
|
||
*/
|
||
declare function remove<T>(array: T[], value: T): boolean;
|
||
/**
|
||
* Generate a range array of numbers starting from `0`. The `stop` is exclusive.
|
||
*
|
||
* 从 `0` 开始生成一个数字范围的数组, `stop` 是不包含的。
|
||
*
|
||
* @category Array
|
||
*
|
||
* @param stop - the end of the range. 范围结束数字。
|
||
*
|
||
* @example
|
||
* ```ts
|
||
* range(5) // => [0, 1, 2, 3, 4]
|
||
* ```
|
||
*/
|
||
declare function range(stop: number): number[];
|
||
/**
|
||
* Generate a range array of numbers. The `stop` is exclusive.
|
||
*
|
||
* 生成一个数字范围的数组, `stop` 是不包含的。
|
||
*
|
||
* @category Array
|
||
*
|
||
* @param start - the start of the range. 范围开始数字
|
||
* @param stop - the end of the range. 范围结束数字
|
||
* @param step - the step of the range. 步进
|
||
*
|
||
* @example
|
||
* ```ts
|
||
* range(5, 10) // => [5, 6, 7, 8, 9]
|
||
* range(5, 10, 2) // => [5, 7, 9]
|
||
* ```
|
||
*/
|
||
declare function range(start: number, stop: number, step?: number): number[];
|
||
/**
|
||
* Move item in an array
|
||
*
|
||
* 移动数组中的项
|
||
*
|
||
* @category Array
|
||
*
|
||
* @param arr - the array
|
||
* @param from - the index of the item to move. 要移动的项的索引
|
||
* @param to - the index to move to. 要移动到的索引
|
||
* @returns the array with the item moved. 返回移动后的数组
|
||
* @example
|
||
* ```ts
|
||
* move([1, 2, 3], 0, 2) // => [3, 1, 2]
|
||
* ```
|
||
*/
|
||
declare function move<T>(arr: T[], from: number, to: number): T[];
|
||
/**
|
||
* Shuffle array
|
||
*
|
||
* 数组洗牌，随机打乱数组中的顺序
|
||
*
|
||
* @category Array
|
||
* @example
|
||
* ```ts
|
||
* shuffle([1, 2, 3]) // => [1, 3, 2]
|
||
* ```
|
||
*/
|
||
declare function shuffle<T>(array: T[]): T[];
|
||
/**
|
||
* Sort array
|
||
*
|
||
* 数组排序
|
||
*
|
||
* @category Array
|
||
* @example
|
||
* ```ts
|
||
* const arr = [
|
||
* { name: 'Mark', age: 20 },
|
||
* { name: 'John', age: 18 },
|
||
* { name: 'Jack', age: 21 },
|
||
* { name: 'Tom', age: 18 },
|
||
* ]
|
||
* sortBy(arr, (item) => item.age) // => [ { name: 'John', age: 18 }, { name: 'Tom', age: 18 }, { name: 'Mark', age: 20 }, { name: 'Jack', age: 21 } ]
|
||
* ```
|
||
*/
|
||
declare function sortBy<T>(array: T[], cb: (item: T) => number): T[];
|
||
/**
|
||
* Split array into chunks
|
||
*
|
||
* 将数组拆分成块
|
||
*
|
||
* @category Array
|
||
*
|
||
* @param input - the array
|
||
* @param size - the chunk size. 块的大小
|
||
*
|
||
* @example
|
||
* ```ts
|
||
* chunk([1, 2, 3, 4, 5], 2) // => [[1, 2], [3, 4], [5]]
|
||
* ```
|
||
*/
|
||
declare function chunk<T>(input: T[], size?: number): T[][];
|
||
/**
|
||
* Union two arrays
|
||
*
|
||
* 两个数组的并集
|
||
*
|
||
* @category Array
|
||
*
|
||
* @example
|
||
* ```ts
|
||
* union([1, 2, 3], [2, 4, 5, 6]) // => [1, 2, 3, 4, 5, 6]
|
||
* ```
|
||
*/
|
||
declare function union<T>(a: T[], b: T[]): T[];
|
||
/**
|
||
* Intersection of two arrays
|
||
*
|
||
* 两个数组的交集
|
||
*
|
||
* @category Array
|
||
* @example
|
||
* ```ts
|
||
* intersection([1, 2, 3], [2, 4, 5, 6]) // => [2]
|
||
* ```
|
||
*/
|
||
declare function intersection<T>(firstArr: readonly T[], secondArr: readonly T[]): T[];
|
||
|
||
/**
|
||
* clone data
|
||
*
|
||
* 克隆数据
|
||
*
|
||
* @module Clone
|
||
*/
|
||
/**
|
||
* simple clone, use JSON.parse and JSON.stringify
|
||
*
|
||
* 简单的克隆,使用 JSON.parse 和 JSON.stringify
|
||
* @category Clone
|
||
*/
|
||
declare function simpleClone<T = any>(source: T): T;
|
||
/**
|
||
* shallow clone, only clone the first level
|
||
*
|
||
* 浅克隆,只克隆第一层
|
||
*
|
||
* @category Clone
|
||
*/
|
||
declare function shallowClone<T = any>(source: T): T;
|
||
/**
|
||
* Deep Clone.
|
||
*
|
||
* 深度克隆
|
||
*
|
||
* @category Clone
|
||
*/
|
||
declare function deepClone<T = any>(source: T): T;
|
||
|
||
/**
|
||
* Common functions
|
||
*
|
||
* @module Common
|
||
*/
|
||
/**
|
||
* Asserts that a condition is true
|
||
*
|
||
* @param condition the condition to assert
|
||
* @param message the message to display if the condition is false
|
||
*
|
||
* @category Common
|
||
*/
|
||
declare function assert(condition: unknown, message?: string): asserts condition;
|
||
/**
|
||
* Get the string representation of a value
|
||
*
|
||
* 获取值的字符串表示
|
||
*
|
||
* @category Common
|
||
*/
|
||
declare function toString(s: unknown): string;
|
||
/**
|
||
* Get type name of a value
|
||
*
|
||
* 获取值的类型名称
|
||
*
|
||
* @category Common
|
||
* @example
|
||
* ```ts
|
||
* getTypeName(null) // => 'null'
|
||
* getTypeName(undefined) // => 'undefined'
|
||
* getTypeName({}) // => 'object'
|
||
* ```
|
||
*/
|
||
declare function getTypeName(s: unknown): string;
|
||
|
||
/**
|
||
* Equal
|
||
*
|
||
* @module Equal
|
||
*/
|
||
/**
|
||
* Deep equality two values, support array and object
|
||
*
|
||
* @category Equal
|
||
*/
|
||
declare function deepEqual(v1: any, v2: any): boolean;
|
||
|
||
/**
|
||
* Base Event
|
||
*
|
||
* @module Event
|
||
*/
|
||
/**
|
||
* @category Event
|
||
*/
|
||
declare class BaseEvent {
|
||
private _listeners;
|
||
constructor();
|
||
/**
|
||
* Adds a listener to the specified event.
|
||
*
|
||
* @param event - the event to listen for
|
||
* @param listener - the listener function to be called when the event is triggered
|
||
* @return
|
||
*/
|
||
on(event: string, listener: (...args: any[]) => void): void;
|
||
/**
|
||
* Emits the specified event with the given arguments to all registered listeners.
|
||
*
|
||
* @param event - the name of the event to emit
|
||
* @param args - the arguments to pass to the event listeners
|
||
* @return
|
||
*/
|
||
emit(event: string, ...args: any[]): void;
|
||
/**
|
||
* Turn off the specified event listener.
|
||
*
|
||
* @param event - the name of the event to turn off
|
||
* @param listener - (optional) the listener function to turn off
|
||
*/
|
||
off(event: string, listener?: (...args: any[]) => void): void;
|
||
/**
|
||
* Execute the listener at most once for a particular event.
|
||
*
|
||
* @param event - the event to listen for
|
||
* @param listener - the function to be executed once for the event
|
||
*/
|
||
once(event: string, listener: (...args: any[]) => void): void;
|
||
}
|
||
|
||
/**
|
||
* Function Helpers
|
||
*
|
||
* @module Function
|
||
*/
|
||
|
||
/**
|
||
* noop function
|
||
*
|
||
* 空函数
|
||
*
|
||
* @category Function
|
||
*/
|
||
declare function noop(): void;
|
||
/**
|
||
* Create a function that can only be called once,
|
||
* and repeated calls return the result of the first call
|
||
*
|
||
* 创建只能被调用一次的函数，重复调用返回第一次调用的结果
|
||
*
|
||
* @category Function
|
||
*/
|
||
declare function once<T extends (...args: any[]) => any>(func: T): T;
|
||
/**
|
||
* call the function
|
||
*
|
||
* 调用函数
|
||
*
|
||
* @category Function
|
||
*/
|
||
declare function invoke<T>(fn: Fn<T>): T;
|
||
/**
|
||
* call every functions in an array
|
||
*
|
||
* 调用数组中的每个函数
|
||
*
|
||
* @category Function
|
||
*
|
||
* @param fns - an array of functions
|
||
*/
|
||
declare function invoke(fns: Nullable<Fn>[]): void;
|
||
type ComposeFn = (...args: any[]) => any;
|
||
type LastArray<T extends any[]> = T extends [...any[], infer U] ? U : Fn;
|
||
type FirstArray<T extends any[]> = T extends [infer U, ...any[]] ? U : Fn;
|
||
/**
|
||
* compose multiple functions, right to left
|
||
*
|
||
* 组合多个函数，从右到左执行
|
||
*
|
||
* @category Function
|
||
* @example
|
||
* ```ts
|
||
* const add = (a) => a + 1
|
||
* const subtract = (a) => a - 2
|
||
* const multiply = (a, b) => a * b
|
||
* compose(add, subtract, multiply)(1, 2) => (1 * 2) - 2 + 1 = 1
|
||
* ```
|
||
*/
|
||
declare function compose<T extends ComposeFn[] = ComposeFn[]>(...fns: T): (...args: Parameters<LastArray<T>>) => ReturnType<FirstArray<T>>;
|
||
|
||
/**
|
||
* guard function that returns if val is truthy
|
||
*
|
||
* 守卫函数，返回 val 是否为真值
|
||
*
|
||
* @category Function
|
||
* @example
|
||
* ```ts
|
||
* [1, 2, 3, '', false, undefined].filter(isTruthy) // => [1, 2, 3]
|
||
* ```
|
||
*/
|
||
declare function isTruthy(val: unknown): boolean;
|
||
/**
|
||
* guard function that returns if val is not undefined
|
||
*
|
||
* 守卫函数，返回 val 不为 undefined
|
||
*
|
||
* @category Function
|
||
* @example
|
||
* ```ts
|
||
* [1, '', false, undefined].filter(NotUndefined) // => [1, '', false]
|
||
* ```
|
||
*/
|
||
declare function notUndefined(val: unknown): boolean;
|
||
/**
|
||
* guard function that returns if val is not null or undefined
|
||
*
|
||
* 守卫函数，返回 val 不为 null 或 undefined
|
||
*
|
||
* @category Function
|
||
* @example
|
||
* ```ts
|
||
* [1, '', false, null, undefined].filter(notNullish) // => [1, '', false]
|
||
* ```
|
||
*/
|
||
declare function notNullish<T>(val: T | null | undefined): val is NonNullable<T>;
|
||
|
||
/**
|
||
* Checks if the input is defined
|
||
* @category Is
|
||
*/
|
||
declare function isDef<T = any>(v?: T): v is T;
|
||
/**
|
||
* Checks if the input is a primitive
|
||
* @category Is
|
||
*/
|
||
declare function isPrimitive(v: unknown): v is null | undefined | boolean | number | string | symbol | bigint;
|
||
/**
|
||
* Checks if the input is a boolean
|
||
* @category Is
|
||
*/
|
||
declare function isBoolean(v: unknown): v is boolean;
|
||
/**
|
||
* Checks if the input is a function.
|
||
* @category Is
|
||
*/
|
||
declare function isFunction<T extends (...args: any[]) => any>(v: unknown): v is T;
|
||
/**
|
||
* Checks if the input is a number
|
||
* @category Is
|
||
*/
|
||
declare function isNumber(v: unknown): v is number;
|
||
/**
|
||
* Checks if the input is a string
|
||
* @category Is
|
||
*/
|
||
declare function isString(v: unknown): v is string;
|
||
/**
|
||
* Checks if the input is a symbol
|
||
* @category Is
|
||
*/
|
||
declare function isSymbol(v: unknown): v is symbol;
|
||
/**
|
||
* Checks if the input is an object
|
||
* @category Is
|
||
*/
|
||
declare function isPlainObject(v: unknown): v is Record<PropertyKey, unknown>;
|
||
/**
|
||
* Checks if the input is an array
|
||
* @category Is
|
||
*/
|
||
declare function isArray<T>(v: unknown): v is T[];
|
||
/**
|
||
* Checks if the input is undefined
|
||
*/
|
||
declare function isUndefined(v: unknown): v is undefined;
|
||
/**
|
||
* Checks if the input is null
|
||
* @category Is
|
||
*/
|
||
declare function isNull(v: unknown): v is null;
|
||
/**
|
||
* Checks if the input is a regexp
|
||
* @category Is
|
||
*/
|
||
declare function isRegexp(v: unknown): v is RegExp;
|
||
/**
|
||
* Checks if the input is a date
|
||
* @category Is
|
||
*/
|
||
declare function isDate(v: unknown): v is Date;
|
||
/**
|
||
* Checks if the input is an empty object
|
||
* @category Is
|
||
*/
|
||
declare function isEmptyObject(v: unknown): boolean;
|
||
/**
|
||
* Checks if the input is a blob
|
||
* @category Is
|
||
*/
|
||
declare function isBlob(v: unknown): v is Blob;
|
||
/**
|
||
* Checks if the input is a typed array
|
||
* @category Is
|
||
*/
|
||
declare function isTypedArray(v: unknown): v is Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array;
|
||
/**
|
||
* Checks if the input is a window
|
||
* @category Is
|
||
*/
|
||
declare function isWindow(v: unknown): boolean;
|
||
/**
|
||
* Checks if the input is a browser
|
||
* @category Is
|
||
*/
|
||
declare function isBrowser(): boolean;
|
||
/**
|
||
* Checks if a value is a JSON object.
|
||
* @category Is
|
||
*/
|
||
declare function isJSONObject(obj: unknown): obj is Record<string, any>;
|
||
/**
|
||
* Checks if a given value is a valid JSON array.
|
||
* @category Is
|
||
*/
|
||
declare function isJSONArray(value: unknown): value is any[];
|
||
/**
|
||
* Checks if a given value is a valid JSON value.
|
||
* @category Is
|
||
*/
|
||
declare function isJSONValue(value: unknown): value is Record<string, any> | any[] | string | number | boolean | null;
|
||
|
||
/**
|
||
* Math Helpers
|
||
*
|
||
* @module Math
|
||
*/
|
||
/**
|
||
* Clamp a number between min and max
|
||
*
|
||
* 返回一个介于最小值和最大值之间的数字
|
||
*
|
||
* @category Math
|
||
*/
|
||
declare function clamp(n: number, min: number, max: number): number;
|
||
/**
|
||
* Check if a number is in range [0, max]
|
||
*
|
||
* 检查一个数字是否在 [0, max] 范围内
|
||
*
|
||
* @category Math
|
||
*
|
||
* @param n - the number
|
||
* @param max - the maximum number
|
||
* @example
|
||
* ```ts
|
||
* inRange(5, 10) // => true
|
||
* inRange(10, 5) // => false
|
||
* ```
|
||
*/
|
||
declare function inRange(n: number, max: number): boolean;
|
||
/**
|
||
* Check if a number is in range [min, max]
|
||
*
|
||
* 检查一个数字是否在 [min, max] 范围内
|
||
*
|
||
* @category Math
|
||
*
|
||
* @param n - the number
|
||
* @param min - the minimum number
|
||
* @param max - the maximum number
|
||
* @example
|
||
* ```ts
|
||
* inRange(5, 0, 10) // => true
|
||
* inRange(10, 0, 5) // => false
|
||
* ```
|
||
*/
|
||
declare function inRange(n: number, min: number, max: number): boolean;
|
||
/**
|
||
* Random number
|
||
*
|
||
* 返回一个介于 0 和 max 之间的随机数
|
||
*
|
||
* @category Math
|
||
*
|
||
* @param max - the maximum number. 最大值
|
||
* @param float - (optional) if `true`, returns a floating-point number. 是否返回浮点数
|
||
*
|
||
* @example
|
||
* ```ts
|
||
* random(5) // => an integer between 0 and 5
|
||
* random(5, true) // => a floating-point number between 0 and 5
|
||
* ```
|
||
*/
|
||
declare function random(max: number, float?: boolean): number;
|
||
/**
|
||
* Random number between min and max
|
||
*
|
||
* 返回一个介于 min 和 max 之间的随机数
|
||
*
|
||
* @category Math
|
||
*
|
||
* @param min - the minimum number. 最小值
|
||
* @param max - the maximum number. 最大值
|
||
* @param float - (optional) if `true`, returns a floating-point number. 是否返回浮点数
|
||
*
|
||
* @example
|
||
* ```ts
|
||
* random(1, 5) // => an integer between 1 and 5
|
||
* random(1, 5, true) // => a floating-point number between 1 and 5
|
||
* ```
|
||
*/
|
||
declare function random(min: number, max: number, float?: boolean): number;
|
||
|
||
type GenNode<K extends string | number, IsRoot extends boolean> = IsRoot extends true ? `${K}` : `.${K}` | (K extends number ? `[${K}]` | `.[${K}]` : never);
|
||
/**
|
||
* Object key paths
|
||
* @category Types
|
||
*/
|
||
type ObjectKeyPaths<T extends object, IsRoot extends boolean = true, K extends keyof T = keyof T> = K extends string | number ? GenNode<K, IsRoot> | (T[K] extends object ? `${GenNode<K, IsRoot>}${ObjectKeyPaths<T[K], false>}` : never) : never;
|
||
type KeysPaths<T extends string, O extends string = ''> = T extends `${infer R}['${infer K}']${infer Rest}` ? KeysPaths<Rest, `${O extends '' ? O : `${O}.`}${R}.${K}`> : T extends `${infer R}["${infer K}"]${infer Rest}` ? KeysPaths<Rest, `${O extends '' ? O : `${O}.`}${R}.${K}`> : T extends `${infer R}[${infer K}]${infer Rest}` ? KeysPaths<Rest, `${O extends '' ? O : `${O}.`}${R}.${K}`> : T extends '' ? O : `${O extends '' ? O : `${O}.`}${T}`;
|
||
/**
|
||
* Get a value from an object
|
||
* @category Types
|
||
*/
|
||
type ObjectGet<T extends Record<PropertyKey, any>, P extends string> = KeysPaths<P> extends `${infer R}.${infer Rest}` ? ObjectGet<T[R], Rest> : T[P];
|
||
type MergeInsertions<T> = T extends object ? {
|
||
[K in keyof T]: MergeInsertions<T[K]>;
|
||
} : T;
|
||
/**
|
||
* Deep merge
|
||
* @category Types
|
||
*/
|
||
type DeepMerge<F, S> = MergeInsertions<{
|
||
[K in keyof F | keyof S]: K extends keyof S & keyof F ? DeepMerge<F[K], S[K]> : K extends keyof S ? S[K] : K extends keyof F ? F[K] : never;
|
||
}>;
|
||
|
||
/**
|
||
* Object Helpers
|
||
*
|
||
* @module Object
|
||
*/
|
||
|
||
/**
|
||
* Check if an object has a non-inherited property
|
||
*
|
||
* 检查一个对象是否具有非继承属性
|
||
*
|
||
* @category Object
|
||
*/
|
||
declare function hasOwn<T>(obj: T, key: keyof any): key is keyof T;
|
||
/**
|
||
* Freeze an object recursively and its properties
|
||
*
|
||
* 递归冻结一个对象及其属性
|
||
*
|
||
* @category Object
|
||
*/
|
||
declare function deepFreeze<T>(obj: T): T;
|
||
/**
|
||
* Check if an object has a property
|
||
*
|
||
* 检查一个对象是否有属性
|
||
*
|
||
* @category Object
|
||
*/
|
||
declare function isKeyof<T extends object>(obj: T, key: keyof any): key is keyof T;
|
||
/**
|
||
* Get a value from an object
|
||
*
|
||
* 从一个对象中获取一个值
|
||
*
|
||
* @category Object
|
||
* @example
|
||
* ```ts
|
||
* objectGet({ a: 1 }, 'a') // => 1
|
||
* objectGet({ a: { b: 2 } }, 'a.b') // => 2
|
||
* objectGet({ a: [{ b: 2 }] }, 'a[0].b') // => 2
|
||
* ```
|
||
*/
|
||
declare function objectGet<T extends Record<PropertyKey, any>, P extends ObjectKeyPaths<T>>(source: T, path: P): ObjectGet<T, P>;
|
||
/**
|
||
* Map key/value pairs for an object, and construct a new one
|
||
*
|
||
* 为一个对象映射键值对，并构造一个新对象
|
||
*
|
||
* @category Object
|
||
*
|
||
* Transform:
|
||
* @example
|
||
* ```
|
||
* objectMap({ a: 1, b: 2 }, (k, v) => [k.toString().toUpperCase(), v.toString()])
|
||
* // { A: '1', B: '2' }
|
||
* ```
|
||
*
|
||
* Swap key/value:
|
||
* @example
|
||
* ```
|
||
* objectMap({ a: 1, b: 2 }, (k, v) => [v, k])
|
||
* // { 1: 'a', 2: 'b' }
|
||
* ```
|
||
*
|
||
* Filter keys:
|
||
* @example
|
||
* ```
|
||
* objectMap({ a: 1, b: 2 }, (k, v) => k === 'a' ? undefined : [k, v])
|
||
* // { b: 2 }
|
||
* ```
|
||
*/
|
||
declare function objectMap<K extends string, V, NK extends PropertyKey = K, NV = V>(obj: Record<K, V>, fn: (key: K, value: V) => [NK, NV] | undefined): Record<NK, NV>;
|
||
/**
|
||
* Strict typed `Object.keys`
|
||
*
|
||
* @category Object
|
||
* @example
|
||
* ```ts
|
||
* objectKeys({ a: 1, b: 2 }) // => ['a', 'b']
|
||
* ```
|
||
*/
|
||
declare function objectKeys<T extends object>(obj: T): Array<`${keyof T & (string | number | boolean | null | undefined)}`>;
|
||
/**
|
||
* Strict typed `Object.entries`
|
||
*
|
||
* @category Object
|
||
* @example
|
||
* ```ts
|
||
* objectEntries({ a: 1, b: 2 }) // => [['a', 1], ['b', 2]]
|
||
* ```
|
||
*/
|
||
declare function objectEntries<T extends object>(obj: T): Array<[keyof T, T[keyof T]]>;
|
||
/**
|
||
* Creates a new object with specified keys omitted.
|
||
*
|
||
* 创建一个新对象，省略指定的键。
|
||
*
|
||
* @category Object
|
||
* @example
|
||
* ```ts
|
||
* omit({ a: 1, b: 2 }, ['a']) // => { b: 2 }
|
||
* ```
|
||
*/
|
||
declare function omit<T extends object = object, K extends keyof T = keyof T>(obj: T, keys: readonly K[]): Omit<T, K>;
|
||
/**
|
||
* Creates a new object composed of the picked object properties.
|
||
*
|
||
* 创建一个由所选对象属性组成的新对象。
|
||
*
|
||
* @category Object
|
||
* @example
|
||
* ```ts
|
||
* pick({ a: 1, b: 2 }, ['a']) // => { a: 1 }
|
||
* ```
|
||
*/
|
||
declare function pick<T extends object = object, K extends keyof T = keyof T>(obj: T, keys: K[]): Pick<T, K>;
|
||
/**
|
||
* Deep merge
|
||
*
|
||
* The first argument is the target object, the rest are the sources.
|
||
* The target object will be mutated and returned.
|
||
*
|
||
* 深度合并
|
||
*
|
||
* 第一个参数是目标对象，其余的是源对象。
|
||
* 目标对象将被修改并返回。
|
||
*
|
||
* @category Object
|
||
*/
|
||
declare function deepMerge<T extends object = object, S extends object = T>(target: T, ...sources: S[]): DeepMerge<T, S>;
|
||
/**
|
||
* Deep merge
|
||
*
|
||
* Differs from `deepMerge` in that it merges arrays instead of overriding them.
|
||
*
|
||
* The first argument is the target object, the rest are the sources.
|
||
* The target object will be mutated and returned.
|
||
*
|
||
* 深度合并
|
||
*
|
||
* 与 `deepMerge` 不同，它合并数组而不是覆盖它们。
|
||
*
|
||
* 第一个参数是目标对象，其余的是源。
|
||
* 目标对象将被修改并返回。
|
||
*
|
||
* @category Object
|
||
*/
|
||
declare function deepMergeWithArray<T extends object = object, S extends object = T>(target: T, ...sources: S[]): DeepMerge<T, S>;
|
||
|
||
/**
|
||
* Promise Helpers
|
||
*
|
||
* @module Promise
|
||
*/
|
||
|
||
/**
|
||
* Sleeps for the given number of milliseconds.
|
||
*
|
||
* 给定毫秒数睡眠。
|
||
* @param ms - the number of milliseconds to sleep. 睡眠的毫秒数
|
||
* @param callback - (optional) the function to execute after the sleep. 睡眠完成后执行的函数。
|
||
* @returns a promise
|
||
*/
|
||
declare function sleep(ms: number, callback?: Fn<any>): Promise<void>;
|
||
/**
|
||
* Executes an array of promises in parallel with a given concurrency. The function
|
||
* returns a Promise that resolves with an array containing the resolved values of
|
||
* each promise.
|
||
* If any promise is rejected, the returned promise will be rejected.
|
||
*
|
||
* 以指定的并发数并行执行一组 promise。该函数返回一个 promise，该承诺解析为一个数组，包含每个 promise 的解析值。
|
||
* 任意一个 promise 拒绝，返回的 promise 将被拒绝。
|
||
*
|
||
* @category Promise
|
||
*
|
||
* @param promises - the array of promises to execute
|
||
* @param concurrency - (optional) the maximum number of promises to execute in parallel 最大并发数
|
||
*/
|
||
declare function promiseParallel(promises: (PromiseLike<any> | (() => PromiseLike<any>))[], concurrency?: number): Promise<any[]>;
|
||
/**
|
||
* Creates a promise that is resolved with an array of promise settlement results,
|
||
* in the same order as the input promises array.
|
||
* The returned promise will be fulfilled when all of the input promises have settled,
|
||
* either fulfilled or rejected.
|
||
*
|
||
* 创建一个以输入 promise 数组的结果数组解决的 promise，
|
||
* 按照输入 promise 数组的相同顺序。
|
||
* 当所有输入 promise 都已解决时，返回的 promise将被实现，
|
||
* 要么实现，要么拒绝。
|
||
*
|
||
* @category Promise
|
||
*
|
||
* @param promises - the array of promises to execute
|
||
* @param concurrency - (optional) the maximum number of promises to execute in parallel
|
||
*/
|
||
declare function promiseParallelSettled(promises: (PromiseLike<any> | (() => PromiseLike<any>))[], concurrency?: number): Promise<PromiseSettledResult<any>[]>;
|
||
/**
|
||
* An error class representing an timeout operation.
|
||
* @category Promise
|
||
* @augments Error
|
||
*/
|
||
declare class TimeoutError extends Error {
|
||
constructor(message?: string);
|
||
}
|
||
/**
|
||
* Returns a promise that rejects with a `TimeoutError` after a specified delay.
|
||
*
|
||
* 返回一个 promise，该 promise 在指定的延迟时间后拒绝，抛出一个 `TimeoutError`。
|
||
*
|
||
* @category Promise
|
||
* @param ms - the number of milliseconds to wait before rejecting the promise. 超时的毫秒数
|
||
* @throws Throws a `TimeoutError` after the specified delay.
|
||
* @example
|
||
* ```ts
|
||
* @example
|
||
* ```
|
||
* try {
|
||
* await timeout(1000); // Timeout exception after 1 second
|
||
* } catch (error) {
|
||
* console.error(error); // Will log 'The operation was timed out'
|
||
* }
|
||
* ```
|
||
*/
|
||
declare function timeout(ms: number): Promise<never>;
|
||
/**
|
||
* Executes an async function and enforces a timeout.
|
||
*
|
||
* 执行异步函数, 超时则强制拒绝
|
||
*
|
||
* @category Promise
|
||
* @param run - the async function to execute.
|
||
* @param ms - the number of milliseconds to wait before rejecting the promise.
|
||
* @returns A promise that resolves with the result of the async function, or rejects with a `TimeoutError` if the function does not resolve within the specified timeout. 一个 promise，它将解析为异步函数的结果，或者如果在指定超时内函数未解析，则拒绝并抛出`TimeoutError`。
|
||
* @example
|
||
* ```ts
|
||
* async function fetchData() {
|
||
* const response = await fetch('https://example.com/data');
|
||
* return response.json();
|
||
* }
|
||
*
|
||
* try {
|
||
* const data = await withTimeout(fetchData, 1000);
|
||
* console.log(data); // Logs the fetched data if `fetchData` is resolved within 1 second.
|
||
* } catch (error) {
|
||
* console.error(error); // Will log 'TimeoutError' if `fetchData` is not resolved within 1 second.
|
||
* }
|
||
* ```
|
||
*/
|
||
declare function withTimeout<T>(run: () => Promise<T>, ms: number): Promise<T>;
|
||
interface SingletonPromiseReturn<T> {
|
||
(): Promise<T>;
|
||
/**
|
||
* Reset current staled promise.
|
||
* Await it to have proper shutdown.
|
||
*/
|
||
reset: () => Promise<void>;
|
||
}
|
||
/**
|
||
* Create singleton promise function
|
||
*
|
||
* 创建单例 promise
|
||
*
|
||
* @category Promise
|
||
*/
|
||
declare function createSingletonPromise<T>(fn: () => Promise<T>): SingletonPromiseReturn<T>;
|
||
/**
|
||
* Create a promise lock
|
||
*
|
||
* 创建一个 promise 锁
|
||
*
|
||
* @category Promise
|
||
* @example
|
||
* ```
|
||
* const lock = createPromiseLock()
|
||
*
|
||
* lock.run(async () => {
|
||
* await doSomething()
|
||
* })
|
||
*
|
||
* // in anther context:
|
||
* await lock.wait() // it will wait all tasking finished
|
||
* ```
|
||
*/
|
||
declare function createPromiseLock(): {
|
||
run: <T = void>(fn: () => Promise<T>) => Promise<T>;
|
||
wait: () => Promise<void>;
|
||
isWaiting: () => boolean;
|
||
clear: () => void;
|
||
};
|
||
/**
|
||
* Promise with `resolve` and `reject` methods of itself
|
||
*
|
||
* @category Promise
|
||
*/
|
||
interface ControlledPromise<T = void> extends Promise<T> {
|
||
resolve: (value: T | PromiseLike<T>) => void;
|
||
reject: (reason?: any) => void;
|
||
}
|
||
/**
|
||
* Return a Promise with `resolve` and `reject` methods
|
||
*
|
||
* 返回一个 Promise，带有 `resolve` 和 `reject` 方法
|
||
*
|
||
* @category Promise
|
||
* @example
|
||
* ```
|
||
* const promise = createControlledPromise()
|
||
*
|
||
* await promise
|
||
*
|
||
* // in anther context:
|
||
* promise.resolve(data)
|
||
* ```
|
||
*/
|
||
declare function createControlledPromise<T>(): ControlledPromise<T>;
|
||
|
||
/**
|
||
* String Helpers
|
||
*
|
||
* @module String
|
||
*/
|
||
/**
|
||
* Ensure prefix, if str does not start with prefix, it will be added
|
||
*
|
||
* 确保前缀，如果字符串不以前缀开头，则将添加前缀。
|
||
*
|
||
* @category String
|
||
*
|
||
* @example
|
||
* ```ts
|
||
* ensurePrefix('http://', 'example.com') // => http://example.com
|
||
* ensurePrefix('//', '//example.com') // => //example.com
|
||
* ```
|
||
*/
|
||
declare function ensurePrefix(prefix: string, str: string): string;
|
||
/**
|
||
* Ensure suffix, if str does not end with suffix, it will be added
|
||
*
|
||
* 确保后缀，如果字符串不以该后缀结尾，则将添加该后缀。
|
||
*
|
||
* @category String
|
||
*
|
||
* @example
|
||
* ```ts
|
||
* ensureSuffix('.com', 'example.com') // => example.com
|
||
* ensureSuffix('.com', 'example') // => example.com
|
||
* ```
|
||
*/
|
||
declare function ensureSuffix(suffix: string, str: string): string;
|
||
declare const CASE_SPLIT_PATTERN: RegExp;
|
||
/**
|
||
* Split string into as words array
|
||
*
|
||
* 将字符串拆分为单词数组
|
||
*
|
||
* @category String
|
||
* @example
|
||
* ```ts
|
||
* words('helloWorld🚀') // => ['hello', 'world', '🚀']
|
||
* ```
|
||
*/
|
||
declare function words(str: string): string[];
|
||
/**
|
||
* First letter uppercase, other lowercase
|
||
* @category String
|
||
* @example
|
||
* ```ts
|
||
* capitalize('hello') // 'Hello'
|
||
* ```
|
||
*/
|
||
declare function capitalize(s: string): string;
|
||
/**
|
||
* Convert string to kebab-case
|
||
* @category String
|
||
*
|
||
* @example
|
||
* ```ts
|
||
* kebabCase('a b c') // => a-b-c
|
||
* kebabCase('orderBy') // => order-by
|
||
* ```
|
||
*/
|
||
declare function kebabCase(str: string): string;
|
||
/**
|
||
* Convert string to snake_case
|
||
* @category String
|
||
* @example
|
||
* ```ts
|
||
* snakeCase('a b c') // => a_b_c
|
||
* snakeCase('orderBy') // => order_by
|
||
* ```
|
||
*/
|
||
declare function snakeCase(str: string): string;
|
||
/**
|
||
* Convert string to camelCase
|
||
*
|
||
* @category String
|
||
*
|
||
* @example
|
||
* ```ts
|
||
* camelCase('foo bar') // => fooBar
|
||
* camelCase('foo-bar') // => fooBar
|
||
* ```
|
||
*/
|
||
declare function camelCase(str: string): string;
|
||
/**
|
||
* Convert string to lowercase
|
||
* @category String
|
||
* @example
|
||
* ```ts
|
||
* lowerCase('Hello World') // => 'hello world'
|
||
* lowerCase('HELLO WORLD') // => 'hello world'
|
||
* lowerCase('order-by') // => 'order by'
|
||
* ```
|
||
*/
|
||
declare function lowerCase(str: string): string;
|
||
/**
|
||
* Convert string to uppercase
|
||
* @category String
|
||
* @example
|
||
* ```ts
|
||
* upperCase('Hello World') // => 'HELLO WORLD'
|
||
* upperCase('hello world') // => 'HELLO WORLD'
|
||
* upperCase('order-by') // => 'ORDER BY'
|
||
* ```
|
||
*/
|
||
declare function upperCase(str: string): string;
|
||
/**
|
||
* Converts a string to Pascal case.
|
||
* @category String
|
||
* @example
|
||
* ```ts
|
||
* pascalCase('foo bar') // => FooBar
|
||
* pascalCase('foo-bar') // => FooBar
|
||
* ```
|
||
*/
|
||
declare function pascalCase(str: string): string;
|
||
/**
|
||
* Converts the characters "&", "<", ">", '"', and "'" in `str` to their corresponding HTML entities.
|
||
*
|
||
* 将`str`中的字符"&"、"<"、">"、'"'和"'"转换为对应的HTML实体。
|
||
*
|
||
* @category String
|
||
* @example
|
||
* ```ts
|
||
* escape('<script>alert(1)</script>') // => <script>alert(1)</script>
|
||
* ```
|
||
*/
|
||
declare function escape(str: string): string;
|
||
/**
|
||
* Escapes the RegExp special characters "^", "$", "\\", ".", "*", "+", "?", "(", ")", "[", "]", "{", "}", and "|" in `str`.
|
||
*
|
||
* 转义`str`中的正则表达式特殊字符"^"、"$"、"\\"、"."、"*"、"+"、"?"、"("、")"、"["、"]"、"{"、"}"以及"|"。
|
||
*
|
||
* @category String
|
||
* @example
|
||
* ```ts
|
||
* escapeRegExp('[link](https://sub.domain.com/)'); // '\[link\]\(https://sub\.domain\.com/\)'
|
||
* ```
|
||
*/
|
||
declare function escapeRegExp(str: string): string;
|
||
/**
|
||
* Converts the HTML entities `&`, `<`, `>`, `"`, and `'` in `str` to their corresponding characters.
|
||
* It is the inverse of `escape`.
|
||
*
|
||
* 将`str`中的HTML实体`&`、`<`、`>`、`"`和`'`转换回对应的字符。
|
||
* 此操作是`escape`的逆向过程。
|
||
*
|
||
* @category String
|
||
* @example
|
||
* ```ts
|
||
* unescape('<script>alert(1)</script>') // => <script>alert(1)</script>
|
||
* ```
|
||
*/
|
||
declare function unescape(str: string): string;
|
||
|
||
/**
|
||
* Throttle Options
|
||
* @category Types
|
||
*/
|
||
interface ThrottleOptions {
|
||
/**
|
||
* Optional, defaults to false. If noTrailing is true, callback will only execute
|
||
* every `delay` milliseconds while the throttled-function is being called. If
|
||
* noTrailing is false or unspecified, callback will be executed one final time
|
||
* after the last throttled-function call. (After the throttled-function has not
|
||
* been called for `delay` milliseconds, the internal counter is reset)
|
||
*/
|
||
noTrailing?: boolean;
|
||
/**
|
||
* Optional, defaults to false. If noLeading is false, the first throttled-function
|
||
* call will execute callback immediately. If noLeading is true, the first the
|
||
* callback execution will be skipped. It should be noted that callback will never
|
||
* executed if both noLeading = true and noTrailing = true.
|
||
*/
|
||
noLeading?: boolean;
|
||
/**
|
||
* If `debounceMode` is true (at begin), schedule
|
||
* `callback` to execute after `delay` ms. If `debounceMode` is false (at end),
|
||
* schedule `callback` to execute after `delay` ms.
|
||
*/
|
||
debounceMode?: boolean;
|
||
}
|
||
interface CancelOptions {
|
||
upcomingOnly?: boolean;
|
||
}
|
||
interface Cancel {
|
||
cancel: (options?: CancelOptions) => void;
|
||
}
|
||
interface NoReturn<T extends (...args: any[]) => any> {
|
||
(...args: Parameters<T>): void;
|
||
}
|
||
/**
|
||
* Throttle execution of a function. Especially useful for rate limiting
|
||
* execution of handlers on events like resize and scroll.
|
||
*
|
||
* @category Function
|
||
*
|
||
* @param delay
|
||
* A zero-or-greater delay in milliseconds. For event callbacks, values around
|
||
* 100 or 250 (or even higher) are most useful.
|
||
*
|
||
* @param callback
|
||
* A function to be executed after delay milliseconds. The `this` context and
|
||
* all arguments are passed through, as-is, to `callback` when the
|
||
* throttled-function is executed.
|
||
*
|
||
* @param options
|
||
* An object to configure options.
|
||
*
|
||
* @return
|
||
* A new, throttled, function.
|
||
*/
|
||
declare function throttle<T extends (...args: any[]) => any>(delay: number, callback: T, options?: ThrottleOptions): NoReturn<T> & Cancel;
|
||
/**
|
||
* Debounce Options
|
||
* @category Types
|
||
*/
|
||
interface DebounceOptions {
|
||
/**
|
||
* If atBegin is false or unspecified, callback will only be executed `delay`
|
||
* milliseconds after the last debounced-function call. If atBegin is true,
|
||
* callback will be executed only at the first debounced-function call. (After
|
||
* the throttled-function has not been called for `delay` milliseconds, the
|
||
* internal counter is reset).
|
||
*/
|
||
atBegin?: boolean;
|
||
}
|
||
/**
|
||
* Debounce execution of a function. Debouncing, unlike throttling,
|
||
* guarantees that a function is only executed a single time, either at the
|
||
* very beginning of a series of calls, or at the very end.
|
||
*
|
||
* @category Functions
|
||
*
|
||
* @param delay
|
||
* A zero-or-greater delay in milliseconds. For event callbacks, values around
|
||
* 100 or 250 (or even higher) are most useful.
|
||
*
|
||
* @param callback
|
||
* A function to be executed after delay milliseconds. The `this` context and
|
||
* all arguments are passed through, as-is, to `callback` when the
|
||
* debounced-function is executed.
|
||
*
|
||
* @param options
|
||
* An object to configure options.
|
||
*
|
||
* @return
|
||
* A new, debounced function.
|
||
*/
|
||
declare function debounce<T extends (...args: any[]) => any>(delay: number, callback: T, options?: DebounceOptions): NoReturn<T> & Cancel;
|
||
|
||
/**
|
||
* Recommended time library:
|
||
*
|
||
* - [dayjs](https://day.js.org/)
|
||
* - [date-fns](https://date-fns.org)
|
||
*
|
||
* @module
|
||
*/
|
||
/**
|
||
* Get current timestamp
|
||
* @category Time
|
||
*/
|
||
declare function timestamp(): number;
|
||
/**
|
||
* Check if two dates is same day
|
||
* @category Time
|
||
*/
|
||
declare function isSameDay(date1: Date | number | string, date2?: Date | number | string): boolean;
|
||
|
||
/**
|
||
* URL Helpers
|
||
*
|
||
* @module URL
|
||
*/
|
||
/**
|
||
* Replace all backslashes with forward slashes
|
||
*
|
||
* 将所有反斜杠替换为正斜杠
|
||
*
|
||
* @category String
|
||
* @example
|
||
* ```ts
|
||
* slash('foo\\bar') // => foo/bar
|
||
* ```
|
||
*/
|
||
declare function slash(s: string): string;
|
||
/**
|
||
* Ensure leading slash, if str does not start with slash, it will be added
|
||
*
|
||
* 确保前缀，如果字符串不以斜杠开头，则将添加斜杠
|
||
*
|
||
* @category String
|
||
* @example
|
||
* ```ts
|
||
* ensureLeadingSlash('foo/bar') // => /foo/bar
|
||
* ```
|
||
*/
|
||
declare function ensureLeadingSlash(str: string): string;
|
||
/**
|
||
* Ensure trailing slash, if str does not end with slash, it will be added
|
||
*
|
||
* 确保后缀，如果字符串不以斜杠结尾，则将添加斜杠
|
||
*
|
||
* @category String
|
||
* @example
|
||
* ```ts
|
||
* ensureTrailingSlash('/foo/bar') // => /foo/bar/
|
||
* ```
|
||
*/
|
||
declare function ensureTrailingSlash(str: string): string;
|
||
/**
|
||
* Remove leading slash, if str starts with slash, it will be removed
|
||
*
|
||
* 删除斜杆前缀，如果字符串以斜杠开头，则将删除
|
||
*
|
||
* @category String
|
||
* @example
|
||
* ```ts
|
||
* removeLeadingSlash('/foo/bar') // => foo/bar
|
||
* ```
|
||
*/
|
||
declare function removeLeadingSlash(str: string): string;
|
||
/**
|
||
* Remove trailing slash, if str ends with slash, it will be removed
|
||
*
|
||
* 删除斜杆后缀，如果字符串以斜杠结尾，则将删除
|
||
*
|
||
* @category String
|
||
* @example
|
||
* ```ts
|
||
* removeTrailingSlash('/foo/bar/') // => /foo/bar
|
||
* ```
|
||
*/
|
||
declare function removeTrailingSlash(str: string): string;
|
||
/**
|
||
* Check if url is http
|
||
* @category URL
|
||
*/
|
||
declare function isHttp(url: string): boolean;
|
||
/**
|
||
* Check if url is valid
|
||
* @category URL
|
||
*/
|
||
declare function isUrl(url: string): boolean;
|
||
/**
|
||
* combines urls
|
||
* @category URL
|
||
* @example
|
||
* ```ts
|
||
* combineURLs('http://example.com', 'foo', 'bar') // => http://example.com/foo/bar
|
||
* combineURLs('//example.com', '/foo') // => //example.com/foo
|
||
* combineURLs('/foo', 'bar', 'index.html') // => /foo/bar/index.html
|
||
* ```
|
||
*/
|
||
declare function combineURLs(baseUrl: string, ...urls: string[]): string;
|
||
/**
|
||
* Parse protocol from url
|
||
*
|
||
* @category URL
|
||
* @example
|
||
* ```ts
|
||
* parseProtocol('http://example.com') // => http
|
||
* parseProtocol('mailto:user@example.com') // => mailto
|
||
* ```
|
||
*/
|
||
declare function parseProtocol(url: string): string;
|
||
|
||
export { BaseEvent, CASE_SPLIT_PATTERN, TimeoutError, assert, camelCase, capitalize, chunk, clamp, combineURLs, compose, createControlledPromise, createPromiseLock, createSingletonPromise, debounce, deepClone, deepEqual, deepFreeze, deepMerge, deepMergeWithArray, ensureLeadingSlash, ensurePrefix, ensureSuffix, ensureTrailingSlash, escape, escapeRegExp, getTypeName, hasOwn, inRange, intersection, invoke, isArray, isBlob, isBoolean, isBrowser, isDate, isDef, isEmptyObject, isFunction, isHttp, isJSONArray, isJSONObject, isJSONValue, isKeyof, isNull, isNumber, isPlainObject, isPrimitive, isRegexp, isSameDay, isString, isSymbol, isTruthy, isTypedArray, isUndefined, isUrl, isWindow, kebabCase, lowerCase, move, noop, notNullish, notUndefined, objectEntries, objectGet, objectKeys, objectMap, omit, once, parseProtocol, pascalCase, pick, promiseParallel, promiseParallelSettled, random, range, remove, removeLeadingSlash, removeTrailingSlash, shallowClone, shuffle, simpleClone, slash, sleep, snakeCase, sortBy, throttle, timeout, timestamp, toArray, toString, unescape, union, uniq, uniqueBy, upperCase, withTimeout, words };
|
||
export type { Arrayable, AsyncFn, AsyncReturnType, Awaitable, Constructor, ControlledPromise, DebounceOptions, ElementOf, Fn, Nullable, SingletonPromiseReturn, ThrottleOptions };
|