add hw2
This commit is contained in:
nik
549
node_modules/@antfu/utils/dist/index.d.mts
generated
vendored
Normal file
549
node_modules/@antfu/utils/dist/index.d.mts
generated
vendored
Normal file
@@ -0,0 +1,549 @@
|
||||
/**
|
||||
* Promise, or maybe not
|
||||
*/
|
||||
type Awaitable<T> = T | PromiseLike<T>;
|
||||
/**
|
||||
* Null or whatever
|
||||
*/
|
||||
type Nullable<T> = T | null | undefined;
|
||||
/**
|
||||
* Array, or not yet
|
||||
*/
|
||||
type Arrayable<T> = T | Array<T>;
|
||||
/**
|
||||
* Function
|
||||
*/
|
||||
type Fn<T = void> = () => T;
|
||||
/**
|
||||
* Constructor
|
||||
*/
|
||||
type Constructor<T = void> = new (...args: any[]) => T;
|
||||
/**
|
||||
* Infers the element type of an array
|
||||
*/
|
||||
type ElementOf<T> = T extends (infer E)[] ? E : never;
|
||||
/**
|
||||
* Defines an intersection type of all union items.
|
||||
*
|
||||
* @param U Union of any types that will be intersected.
|
||||
* @returns U items intersected
|
||||
* @see https://stackoverflow.com/a/50375286/9259330
|
||||
*/
|
||||
type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
|
||||
/**
|
||||
* Infers the arguments type of a function
|
||||
*/
|
||||
type ArgumentsType<T> = T extends ((...args: infer A) => any) ? A : never;
|
||||
type MergeInsertions<T> = T extends object ? {
|
||||
[K in keyof T]: MergeInsertions<T[K]>;
|
||||
} : T;
|
||||
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;
|
||||
}>;
|
||||
|
||||
/**
|
||||
* Convert `Arrayable<T>` to `Array<T>`
|
||||
*
|
||||
* @category Array
|
||||
*/
|
||||
declare function toArray<T>(array?: Nullable<Arrayable<T>>): Array<T>;
|
||||
/**
|
||||
* Convert `Arrayable<T>` to `Array<T>` and flatten it
|
||||
*
|
||||
* @category Array
|
||||
*/
|
||||
declare function flattenArrayable<T>(array?: Nullable<Arrayable<T | Array<T>>>): Array<T>;
|
||||
/**
|
||||
* Use rest arguments to merge arrays
|
||||
*
|
||||
* @category Array
|
||||
*/
|
||||
declare function mergeArrayable<T>(...args: Nullable<Arrayable<T>>[]): Array<T>;
|
||||
type PartitionFilter<T> = (i: T, idx: number, arr: readonly T[]) => any;
|
||||
/**
|
||||
* Divide an array into two parts by a filter function
|
||||
*
|
||||
* @category Array
|
||||
* @example const [odd, even] = partition([1, 2, 3, 4], i => i % 2 != 0)
|
||||
*/
|
||||
declare function partition<T>(array: readonly T[], f1: PartitionFilter<T>): [T[], T[]];
|
||||
declare function partition<T>(array: readonly T[], f1: PartitionFilter<T>, f2: PartitionFilter<T>): [T[], T[], T[]];
|
||||
declare function partition<T>(array: readonly T[], f1: PartitionFilter<T>, f2: PartitionFilter<T>, f3: PartitionFilter<T>): [T[], T[], T[], T[]];
|
||||
declare function partition<T>(array: readonly T[], f1: PartitionFilter<T>, f2: PartitionFilter<T>, f3: PartitionFilter<T>, f4: PartitionFilter<T>): [T[], T[], T[], T[], T[]];
|
||||
declare function partition<T>(array: readonly T[], f1: PartitionFilter<T>, f2: PartitionFilter<T>, f3: PartitionFilter<T>, f4: PartitionFilter<T>, f5: PartitionFilter<T>): [T[], T[], T[], T[], T[], T[]];
|
||||
declare function partition<T>(array: readonly T[], f1: PartitionFilter<T>, f2: PartitionFilter<T>, f3: PartitionFilter<T>, f4: PartitionFilter<T>, f5: PartitionFilter<T>, f6: PartitionFilter<T>): [T[], T[], T[], T[], T[], T[], T[]];
|
||||
/**
|
||||
* Unique an Array
|
||||
*
|
||||
* @category Array
|
||||
*/
|
||||
declare function uniq<T>(array: readonly T[]): T[];
|
||||
/**
|
||||
* Unique an Array by a custom equality function
|
||||
*
|
||||
* @category Array
|
||||
*/
|
||||
declare function uniqueBy<T>(array: readonly T[], equalFn: (a: any, b: any) => boolean): T[];
|
||||
/**
|
||||
* Get last item
|
||||
*
|
||||
* @category Array
|
||||
*/
|
||||
declare function last(array: readonly []): undefined;
|
||||
declare function last<T>(array: readonly T[]): T;
|
||||
/**
|
||||
* Remove an item from Array
|
||||
*
|
||||
* @category Array
|
||||
*/
|
||||
declare function remove<T>(array: T[], value: T): boolean;
|
||||
/**
|
||||
* Get nth item of Array. Negative for backward
|
||||
*
|
||||
* @category Array
|
||||
*/
|
||||
declare function at(array: readonly [], index: number): undefined;
|
||||
declare function at<T>(array: readonly T[], index: number): T;
|
||||
/**
|
||||
* Genrate a range array of numbers. The `stop` is exclusive.
|
||||
*
|
||||
* @category Array
|
||||
*/
|
||||
declare function range(stop: number): number[];
|
||||
declare function range(start: number, stop: number, step?: number): number[];
|
||||
/**
|
||||
* Move element in an Array
|
||||
*
|
||||
* @category Array
|
||||
* @param arr
|
||||
* @param from
|
||||
* @param to
|
||||
*/
|
||||
declare function move<T>(arr: T[], from: number, to: number): T[];
|
||||
/**
|
||||
* Clamp a number to the index range of an array
|
||||
*
|
||||
* @category Array
|
||||
*/
|
||||
declare function clampArrayRange(n: number, arr: readonly unknown[]): number;
|
||||
/**
|
||||
* Get random item(s) from an array
|
||||
*
|
||||
* @param arr
|
||||
* @param quantity - quantity of random items which will be returned
|
||||
*/
|
||||
declare function sample<T>(arr: T[], quantity: number): T[];
|
||||
/**
|
||||
* Shuffle an array. This function mutates the array.
|
||||
*
|
||||
* @category Array
|
||||
*/
|
||||
declare function shuffle<T>(array: T[]): T[];
|
||||
/**
|
||||
* Filter out items from an array in place.
|
||||
* This function mutates the array.
|
||||
* `predicate` get through the array from the end to the start for performance.
|
||||
*
|
||||
* Expect this function to be faster than using `Array.prototype.filter` on large arrays.
|
||||
*
|
||||
* @category Array
|
||||
*/
|
||||
declare function filterInPlace<T>(array: T[], predicate: (item: T, index: number, arr: T[]) => unknown): T[];
|
||||
|
||||
declare function assert(condition: boolean, message: string): asserts condition;
|
||||
declare const toString: (v: any) => string;
|
||||
declare function getTypeName(v: any): string;
|
||||
declare function noop(): void;
|
||||
|
||||
declare function isDeepEqual(value1: any, value2: any): boolean;
|
||||
|
||||
/**
|
||||
* Call every function in an array
|
||||
*/
|
||||
declare function batchInvoke(functions: Nullable<Fn>[]): void;
|
||||
/**
|
||||
* Call the function, returning the result
|
||||
*/
|
||||
declare function invoke<T>(fn: () => T): T;
|
||||
/**
|
||||
* Pass the value through the callback, and return the value
|
||||
*
|
||||
* @example
|
||||
* ```
|
||||
* function createUser(name: string): User {
|
||||
* return tap(new User, user => {
|
||||
* user.name = name
|
||||
* })
|
||||
* }
|
||||
* ```
|
||||
*/
|
||||
declare function tap<T>(value: T, callback: (value: T) => void): T;
|
||||
|
||||
/**
|
||||
* Type guard to filter out null-ish values
|
||||
*
|
||||
* @category Guards
|
||||
* @example array.filter(notNullish)
|
||||
*/
|
||||
declare function notNullish<T>(v: T | null | undefined): v is NonNullable<T>;
|
||||
/**
|
||||
* Type guard to filter out null values
|
||||
*
|
||||
* @category Guards
|
||||
* @example array.filter(noNull)
|
||||
*/
|
||||
declare function noNull<T>(v: T | null): v is Exclude<T, null>;
|
||||
/**
|
||||
* Type guard to filter out null-ish values
|
||||
*
|
||||
* @category Guards
|
||||
* @example array.filter(notUndefined)
|
||||
*/
|
||||
declare function notUndefined<T>(v: T): v is Exclude<T, undefined>;
|
||||
/**
|
||||
* Type guard to filter out falsy values
|
||||
*
|
||||
* @category Guards
|
||||
* @example array.filter(isTruthy)
|
||||
*/
|
||||
declare function isTruthy<T>(v: T): v is NonNullable<T>;
|
||||
|
||||
declare const isDef: <T = any>(val?: T) => val is T;
|
||||
declare const isBoolean: (val: any) => val is boolean;
|
||||
declare const isFunction: <T extends Function>(val: any) => val is T;
|
||||
declare const isNumber: (val: any) => val is number;
|
||||
declare const isString: (val: unknown) => val is string;
|
||||
declare const isObject: (val: any) => val is object;
|
||||
declare const isUndefined: (val: any) => val is undefined;
|
||||
declare const isNull: (val: any) => val is null;
|
||||
declare const isRegExp: (val: any) => val is RegExp;
|
||||
declare const isDate: (val: any) => val is Date;
|
||||
/**
|
||||
* Check if a value is primitive
|
||||
*/
|
||||
declare function isPrimitive(val: any): val is string | number | boolean | symbol | bigint | null | undefined;
|
||||
declare const isWindow: (val: any) => boolean;
|
||||
declare const isBrowser: boolean;
|
||||
|
||||
declare function clamp(n: number, min: number, max: number): number;
|
||||
declare function sum(...args: number[] | number[][]): number;
|
||||
/**
|
||||
* Linearly interpolates between `min` and `max` based on `t`
|
||||
*
|
||||
* @category Math
|
||||
* @param min The minimum value
|
||||
* @param max The maximum value
|
||||
* @param t The interpolation value clamped between 0 and 1
|
||||
* @example
|
||||
* ```
|
||||
* const value = lerp(0, 2, 0.5) // value will be 1
|
||||
* ```
|
||||
*/
|
||||
declare function lerp(min: number, max: number, t: number): number;
|
||||
/**
|
||||
* Linearly remaps a clamped value from its source range [`inMin`, `inMax`] to the destination range [`outMin`, `outMax`]
|
||||
*
|
||||
* @category Math
|
||||
* @example
|
||||
* ```
|
||||
* const value = remap(0.5, 0, 1, 200, 400) // value will be 300
|
||||
* ```
|
||||
*/
|
||||
declare function remap(n: number, inMin: number, inMax: number, outMin: number, outMax: number): number;
|
||||
|
||||
/**
|
||||
* 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 string | number | symbol = K, NV = V>(obj: Record<K, V>, fn: (key: K, value: V) => [NK, NV] | undefined): Record<NK, NV>;
|
||||
/**
|
||||
* Type guard for any key, `k`.
|
||||
* Marks `k` as a key of `T` if `k` is in `obj`.
|
||||
*
|
||||
* @category Object
|
||||
* @param obj object to query for key `k`
|
||||
* @param k key to check existence in `obj`
|
||||
*/
|
||||
declare function isKeyOf<T extends object>(obj: T, k: keyof any): k is keyof T;
|
||||
/**
|
||||
* Strict typed `Object.keys`
|
||||
*
|
||||
* @category Object
|
||||
*/
|
||||
declare function objectKeys<T extends object>(obj: T): Array<`${keyof T & (string | number | boolean | null | undefined)}`>;
|
||||
/**
|
||||
* Strict typed `Object.entries`
|
||||
*
|
||||
* @category Object
|
||||
*/
|
||||
declare function objectEntries<T extends object>(obj: T): Array<[keyof T, T[keyof T]]>;
|
||||
/**
|
||||
* 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.
|
||||
*
|
||||
* @category Object
|
||||
*/
|
||||
declare function deepMergeWithArray<T extends object = object, S extends object = T>(target: T, ...sources: S[]): DeepMerge<T, S>;
|
||||
/**
|
||||
* Create a new subset object by giving keys
|
||||
*
|
||||
* @category Object
|
||||
*/
|
||||
declare function objectPick<O extends object, T extends keyof O>(obj: O, keys: T[], omitUndefined?: boolean): Pick<O, T>;
|
||||
/**
|
||||
* Clear undefined fields from an object. It mutates the object
|
||||
*
|
||||
* @category Object
|
||||
*/
|
||||
declare function clearUndefined<T extends object>(obj: T): T;
|
||||
/**
|
||||
* Determines whether an object has a property with the specified name
|
||||
*
|
||||
* @see https://eslint.org/docs/rules/no-prototype-builtins
|
||||
* @category Object
|
||||
*/
|
||||
declare function hasOwnProperty<T>(obj: T, v: PropertyKey): boolean;
|
||||
/**
|
||||
* Get an object's unique identifier
|
||||
*
|
||||
* Same object will always return the same id
|
||||
*
|
||||
* Expect argument to be a non-primitive object/array. Primitive values will be returned as is.
|
||||
*
|
||||
* @category Object
|
||||
*/
|
||||
declare function objectId(obj: WeakKey): string;
|
||||
|
||||
interface POptions {
|
||||
/**
|
||||
* How many promises are resolved at the same time.
|
||||
*/
|
||||
concurrency?: number | undefined;
|
||||
}
|
||||
declare class PInstance<T = any> extends Promise<Awaited<T>[]> {
|
||||
items: Iterable<T>;
|
||||
options?: POptions | undefined;
|
||||
private promises;
|
||||
get promise(): Promise<Awaited<T>[]>;
|
||||
constructor(items?: Iterable<T>, options?: POptions | undefined);
|
||||
add(...args: (T | Promise<T>)[]): void;
|
||||
map<U>(fn: (value: Awaited<T>, index: number) => U): PInstance<Promise<U>>;
|
||||
filter(fn: (value: Awaited<T>, index: number) => boolean | Promise<boolean>): PInstance<Promise<T>>;
|
||||
forEach(fn: (value: Awaited<T>, index: number) => void): Promise<void>;
|
||||
reduce<U>(fn: (previousValue: U, currentValue: Awaited<T>, currentIndex: number, array: Awaited<T>[]) => U, initialValue: U): Promise<U>;
|
||||
clear(): void;
|
||||
then<TResult1 = Awaited<T>[], TResult2 = never>(onfulfilled?: ((value: Awaited<T>[]) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
|
||||
catch(fn?: (err: unknown) => PromiseLike<any>): Promise<any>;
|
||||
finally(fn?: () => void): Promise<Awaited<T>[]>;
|
||||
}
|
||||
/**
|
||||
* Utility for managing multiple promises.
|
||||
*
|
||||
* @see https://github.com/antfu/utils/tree/main/docs/p.md
|
||||
* @category Promise
|
||||
* @example
|
||||
* ```
|
||||
* import { p } from '@antfu/utils'
|
||||
*
|
||||
* const items = [1, 2, 3, 4, 5]
|
||||
*
|
||||
* await p(items)
|
||||
* .map(async i => await multiply(i, 3))
|
||||
* .filter(async i => await isEven(i))
|
||||
* // [6, 12]
|
||||
* ```
|
||||
*/
|
||||
declare function p<T = any>(items?: Iterable<T>, options?: POptions): PInstance<T>;
|
||||
|
||||
interface SingletonPromiseReturn<T> {
|
||||
(): Promise<T>;
|
||||
/**
|
||||
* Reset current staled promise.
|
||||
* Await it to have proper shutdown.
|
||||
*/
|
||||
reset: () => Promise<void>;
|
||||
}
|
||||
/**
|
||||
* Create singleton promise function
|
||||
*
|
||||
* @category Promise
|
||||
*/
|
||||
declare function createSingletonPromise<T>(fn: () => Promise<T>): SingletonPromiseReturn<T>;
|
||||
/**
|
||||
* Promised `setTimeout`
|
||||
*
|
||||
* @category Promise
|
||||
*/
|
||||
declare function sleep(ms: number, callback?: Fn<any>): Promise<void>;
|
||||
/**
|
||||
* Create a promise lock
|
||||
*
|
||||
* @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
|
||||
*/
|
||||
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
|
||||
*
|
||||
* @category Promise
|
||||
* @example
|
||||
* ```
|
||||
* const promise = createControlledPromise()
|
||||
*
|
||||
* await promise
|
||||
*
|
||||
* // in anther context:
|
||||
* promise.resolve(data)
|
||||
* ```
|
||||
*/
|
||||
declare function createControlledPromise<T>(): ControlledPromise<T>;
|
||||
|
||||
/**
|
||||
* Replace backslash to slash
|
||||
*
|
||||
* @category String
|
||||
*/
|
||||
declare function slash(str: string): string;
|
||||
/**
|
||||
* Ensure prefix of a string
|
||||
*
|
||||
* @category String
|
||||
*/
|
||||
declare function ensurePrefix(prefix: string, str: string): string;
|
||||
/**
|
||||
* Ensure suffix of a string
|
||||
*
|
||||
* @category String
|
||||
*/
|
||||
declare function ensureSuffix(suffix: string, str: string): string;
|
||||
/**
|
||||
* Dead simple template engine, just like Python's `.format()`
|
||||
* Support passing variables as either in index based or object/name based approach
|
||||
* While using object/name based approach, you can pass a fallback value as the third argument
|
||||
*
|
||||
* @category String
|
||||
* @example
|
||||
* ```
|
||||
* const result = template(
|
||||
* 'Hello {0}! My name is {1}.',
|
||||
* 'Inès',
|
||||
* 'Anthony'
|
||||
* ) // Hello Inès! My name is Anthony.
|
||||
* ```
|
||||
*
|
||||
* ```
|
||||
* const result = namedTemplate(
|
||||
* '{greet}! My name is {name}.',
|
||||
* { greet: 'Hello', name: 'Anthony' }
|
||||
* ) // Hello! My name is Anthony.
|
||||
* ```
|
||||
*
|
||||
* const result = namedTemplate(
|
||||
* '{greet}! My name is {name}.',
|
||||
* { greet: 'Hello' }, // name isn't passed hence fallback will be used for name
|
||||
* 'placeholder'
|
||||
* ) // Hello! My name is placeholder.
|
||||
* ```
|
||||
*/
|
||||
declare function template(str: string, object: Record<string | number, any>, fallback?: string | ((key: string) => string)): string;
|
||||
declare function template(str: string, ...args: (string | number | bigint | undefined | null)[]): string;
|
||||
/**
|
||||
* Generate a random string
|
||||
* @category String
|
||||
*/
|
||||
declare function randomStr(size?: number, dict?: string): string;
|
||||
/**
|
||||
* First letter uppercase, other lowercase
|
||||
* @category string
|
||||
* @example
|
||||
* ```
|
||||
* capitalize('hello') => 'Hello'
|
||||
* ```
|
||||
*/
|
||||
declare function capitalize(str: string): string;
|
||||
/**
|
||||
* Remove common leading whitespace from a template string.
|
||||
* Will also remove empty lines at the beginning and end.
|
||||
* @category string
|
||||
* @example
|
||||
* ```ts
|
||||
* const str = unindent`
|
||||
* if (a) {
|
||||
* b()
|
||||
* }
|
||||
* `
|
||||
*/
|
||||
declare function unindent(str: TemplateStringsArray | string): string;
|
||||
|
||||
declare const timestamp: () => number;
|
||||
|
||||
interface CancelOptions {
|
||||
upcomingOnly?: boolean;
|
||||
}
|
||||
interface ReturnWithCancel<T extends (...args: any[]) => any> {
|
||||
(...args: Parameters<T>): void;
|
||||
cancel: (options?: CancelOptions) => void;
|
||||
}
|
||||
declare function throttle<T extends (...args: any[]) => any>(...args: any[]): ReturnWithCancel<T>;
|
||||
declare function debounce<T extends (...args: any[]) => any>(...args: any[]): ReturnWithCancel<T>;
|
||||
|
||||
export { assert, at, batchInvoke, capitalize, clamp, clampArrayRange, clearUndefined, createControlledPromise, createPromiseLock, createSingletonPromise, debounce, deepMerge, deepMergeWithArray, ensurePrefix, ensureSuffix, filterInPlace, flattenArrayable, getTypeName, hasOwnProperty, invoke, isBoolean, isBrowser, isDate, isDeepEqual, isDef, isFunction, isKeyOf, isNull, isNumber, isObject, isPrimitive, isRegExp, isString, isTruthy, isUndefined, isWindow, last, lerp, mergeArrayable, move, noNull, noop, notNullish, notUndefined, objectEntries, objectId, objectKeys, objectMap, objectPick, p, partition, randomStr, range, remap, remove, sample, shuffle, slash, sleep, sum, tap, template, throttle, timestamp, toArray, toString, unindent, uniq, uniqueBy };
|
||||
export type { ArgumentsType, Arrayable, Awaitable, Constructor, ControlledPromise, DeepMerge, ElementOf, Fn, MergeInsertions, Nullable, PartitionFilter, SingletonPromiseReturn, UnionToIntersection };
|
||||
837
node_modules/@antfu/utils/dist/index.mjs
generated
vendored
Normal file
837
node_modules/@antfu/utils/dist/index.mjs
generated
vendored
Normal file
@@ -0,0 +1,837 @@
|
||||
function clamp(n, min, max) {
|
||||
return Math.min(max, Math.max(min, n));
|
||||
}
|
||||
function sum(...args) {
|
||||
return flattenArrayable(args).reduce((a, b) => a + b, 0);
|
||||
}
|
||||
function lerp(min, max, t) {
|
||||
const interpolation = clamp(t, 0, 1);
|
||||
return min + (max - min) * interpolation;
|
||||
}
|
||||
function remap(n, inMin, inMax, outMin, outMax) {
|
||||
const interpolation = (n - inMin) / (inMax - inMin);
|
||||
return lerp(outMin, outMax, interpolation);
|
||||
}
|
||||
|
||||
function toArray(array) {
|
||||
array = array ?? [];
|
||||
return Array.isArray(array) ? array : [array];
|
||||
}
|
||||
function flattenArrayable(array) {
|
||||
return toArray(array).flat(1);
|
||||
}
|
||||
function mergeArrayable(...args) {
|
||||
return args.flatMap((i) => toArray(i));
|
||||
}
|
||||
function partition(array, ...filters) {
|
||||
const result = Array.from({ length: filters.length + 1 }).fill(null).map(() => []);
|
||||
array.forEach((e, idx, arr) => {
|
||||
let i = 0;
|
||||
for (const filter of filters) {
|
||||
if (filter(e, idx, arr)) {
|
||||
result[i].push(e);
|
||||
return;
|
||||
}
|
||||
i += 1;
|
||||
}
|
||||
result[i].push(e);
|
||||
});
|
||||
return result;
|
||||
}
|
||||
function uniq(array) {
|
||||
return Array.from(new Set(array));
|
||||
}
|
||||
function uniqueBy(array, equalFn) {
|
||||
return array.reduce((acc, cur) => {
|
||||
const index = acc.findIndex((item) => equalFn(cur, item));
|
||||
if (index === -1)
|
||||
acc.push(cur);
|
||||
return acc;
|
||||
}, []);
|
||||
}
|
||||
function last(array) {
|
||||
return at(array, -1);
|
||||
}
|
||||
function remove(array, value) {
|
||||
if (!array)
|
||||
return false;
|
||||
const index = array.indexOf(value);
|
||||
if (index >= 0) {
|
||||
array.splice(index, 1);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function at(array, index) {
|
||||
const len = array.length;
|
||||
if (!len)
|
||||
return void 0;
|
||||
if (index < 0)
|
||||
index += len;
|
||||
return array[index];
|
||||
}
|
||||
function range(...args) {
|
||||
let start, stop, step;
|
||||
if (args.length === 1) {
|
||||
start = 0;
|
||||
step = 1;
|
||||
[stop] = args;
|
||||
} else {
|
||||
[start, stop, step = 1] = args;
|
||||
}
|
||||
const arr = [];
|
||||
let current = start;
|
||||
while (current < stop) {
|
||||
arr.push(current);
|
||||
current += step || 1;
|
||||
}
|
||||
return arr;
|
||||
}
|
||||
function move(arr, from, to) {
|
||||
arr.splice(to, 0, arr.splice(from, 1)[0]);
|
||||
return arr;
|
||||
}
|
||||
function clampArrayRange(n, arr) {
|
||||
return clamp(n, 0, arr.length - 1);
|
||||
}
|
||||
function sample(arr, quantity) {
|
||||
return Array.from({ length: quantity }, (_) => arr[Math.round(Math.random() * (arr.length - 1))]);
|
||||
}
|
||||
function shuffle(array) {
|
||||
for (let i = array.length - 1; i > 0; i--) {
|
||||
const j = Math.floor(Math.random() * (i + 1));
|
||||
[array[i], array[j]] = [array[j], array[i]];
|
||||
}
|
||||
return array;
|
||||
}
|
||||
function filterInPlace(array, predicate) {
|
||||
for (let i = array.length; i--; i >= 0) {
|
||||
if (!predicate(array[i], i, array))
|
||||
array.splice(i, 1);
|
||||
}
|
||||
return array;
|
||||
}
|
||||
|
||||
function assert(condition, message) {
|
||||
if (!condition)
|
||||
throw new Error(message);
|
||||
}
|
||||
const toString = (v) => Object.prototype.toString.call(v);
|
||||
function getTypeName(v) {
|
||||
if (v === null)
|
||||
return "null";
|
||||
const type = toString(v).slice(8, -1).toLowerCase();
|
||||
return typeof v === "object" || typeof v === "function" ? type : typeof v;
|
||||
}
|
||||
function noop() {
|
||||
}
|
||||
|
||||
function isDeepEqual(value1, value2) {
|
||||
const type1 = getTypeName(value1);
|
||||
const type2 = getTypeName(value2);
|
||||
if (type1 !== type2)
|
||||
return false;
|
||||
if (type1 === "array") {
|
||||
if (value1.length !== value2.length)
|
||||
return false;
|
||||
return value1.every((item, i) => {
|
||||
return isDeepEqual(item, value2[i]);
|
||||
});
|
||||
}
|
||||
if (type1 === "object") {
|
||||
const keyArr = Object.keys(value1);
|
||||
if (keyArr.length !== Object.keys(value2).length)
|
||||
return false;
|
||||
return keyArr.every((key) => {
|
||||
return isDeepEqual(value1[key], value2[key]);
|
||||
});
|
||||
}
|
||||
return Object.is(value1, value2);
|
||||
}
|
||||
|
||||
function batchInvoke(functions) {
|
||||
functions.forEach((fn) => fn && fn());
|
||||
}
|
||||
function invoke(fn) {
|
||||
return fn();
|
||||
}
|
||||
function tap(value, callback) {
|
||||
callback(value);
|
||||
return value;
|
||||
}
|
||||
|
||||
function notNullish(v) {
|
||||
return v != null;
|
||||
}
|
||||
function noNull(v) {
|
||||
return v !== null;
|
||||
}
|
||||
function notUndefined(v) {
|
||||
return v !== void 0;
|
||||
}
|
||||
function isTruthy(v) {
|
||||
return Boolean(v);
|
||||
}
|
||||
|
||||
const isDef = (val) => typeof val !== "undefined";
|
||||
const isBoolean = (val) => typeof val === "boolean";
|
||||
const isFunction = (val) => typeof val === "function";
|
||||
const isNumber = (val) => typeof val === "number";
|
||||
const isString = (val) => typeof val === "string";
|
||||
const isObject = (val) => toString(val) === "[object Object]";
|
||||
const isUndefined = (val) => toString(val) === "[object Undefined]";
|
||||
const isNull = (val) => toString(val) === "[object Null]";
|
||||
const isRegExp = (val) => toString(val) === "[object RegExp]";
|
||||
const isDate = (val) => toString(val) === "[object Date]";
|
||||
function isPrimitive(val) {
|
||||
return !val || Object(val) !== val;
|
||||
}
|
||||
const isWindow = (val) => typeof window !== "undefined" && toString(val) === "[object Window]";
|
||||
const isBrowser = typeof window !== "undefined";
|
||||
|
||||
function slash(str) {
|
||||
return str.replace(/\\/g, "/");
|
||||
}
|
||||
function ensurePrefix(prefix, str) {
|
||||
if (!str.startsWith(prefix))
|
||||
return prefix + str;
|
||||
return str;
|
||||
}
|
||||
function ensureSuffix(suffix, str) {
|
||||
if (!str.endsWith(suffix))
|
||||
return str + suffix;
|
||||
return str;
|
||||
}
|
||||
function template(str, ...args) {
|
||||
const [firstArg, fallback] = args;
|
||||
if (isObject(firstArg)) {
|
||||
const vars = firstArg;
|
||||
return str.replace(/\{(\w+)\}/g, (_, key) => vars[key] || ((typeof fallback === "function" ? fallback(key) : fallback) ?? key));
|
||||
} else {
|
||||
return str.replace(/\{(\d+)\}/g, (_, key) => {
|
||||
const index = Number(key);
|
||||
if (Number.isNaN(index))
|
||||
return key;
|
||||
return args[index];
|
||||
});
|
||||
}
|
||||
}
|
||||
const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
|
||||
function randomStr(size = 16, dict = urlAlphabet) {
|
||||
let id = "";
|
||||
let i = size;
|
||||
const len = dict.length;
|
||||
while (i--)
|
||||
id += dict[Math.random() * len | 0];
|
||||
return id;
|
||||
}
|
||||
function capitalize(str) {
|
||||
return str[0].toUpperCase() + str.slice(1).toLowerCase();
|
||||
}
|
||||
const _reFullWs = /^\s*$/;
|
||||
function unindent(str) {
|
||||
const lines = (typeof str === "string" ? str : str[0]).split("\n");
|
||||
const whitespaceLines = lines.map((line) => _reFullWs.test(line));
|
||||
const commonIndent = lines.reduce((min, line, idx) => {
|
||||
if (whitespaceLines[idx])
|
||||
return min;
|
||||
const indent = line.match(/^\s*/)?.[0].length;
|
||||
return indent === void 0 ? min : Math.min(min, indent);
|
||||
}, Number.POSITIVE_INFINITY);
|
||||
let emptyLinesHead = 0;
|
||||
while (emptyLinesHead < lines.length && whitespaceLines[emptyLinesHead])
|
||||
emptyLinesHead++;
|
||||
let emptyLinesTail = 0;
|
||||
while (emptyLinesTail < lines.length && whitespaceLines[lines.length - emptyLinesTail - 1])
|
||||
emptyLinesTail++;
|
||||
return lines.slice(emptyLinesHead, lines.length - emptyLinesTail).map((line) => line.slice(commonIndent)).join("\n");
|
||||
}
|
||||
|
||||
function objectMap(obj, fn) {
|
||||
return Object.fromEntries(
|
||||
Object.entries(obj).map(([k, v]) => fn(k, v)).filter(notNullish)
|
||||
);
|
||||
}
|
||||
function isKeyOf(obj, k) {
|
||||
return k in obj;
|
||||
}
|
||||
function objectKeys(obj) {
|
||||
return Object.keys(obj);
|
||||
}
|
||||
function objectEntries(obj) {
|
||||
return Object.entries(obj);
|
||||
}
|
||||
function deepMerge(target, ...sources) {
|
||||
if (!sources.length)
|
||||
return target;
|
||||
const source = sources.shift();
|
||||
if (source === void 0)
|
||||
return target;
|
||||
if (isMergableObject(target) && isMergableObject(source)) {
|
||||
objectKeys(source).forEach((key) => {
|
||||
if (key === "__proto__" || key === "constructor" || key === "prototype")
|
||||
return;
|
||||
if (isMergableObject(source[key])) {
|
||||
if (!target[key])
|
||||
target[key] = {};
|
||||
if (isMergableObject(target[key])) {
|
||||
deepMerge(target[key], source[key]);
|
||||
} else {
|
||||
target[key] = source[key];
|
||||
}
|
||||
} else {
|
||||
target[key] = source[key];
|
||||
}
|
||||
});
|
||||
}
|
||||
return deepMerge(target, ...sources);
|
||||
}
|
||||
function deepMergeWithArray(target, ...sources) {
|
||||
if (!sources.length)
|
||||
return target;
|
||||
const source = sources.shift();
|
||||
if (source === void 0)
|
||||
return target;
|
||||
if (Array.isArray(target) && Array.isArray(source))
|
||||
target.push(...source);
|
||||
if (isMergableObject(target) && isMergableObject(source)) {
|
||||
objectKeys(source).forEach((key) => {
|
||||
if (key === "__proto__" || key === "constructor" || key === "prototype")
|
||||
return;
|
||||
if (Array.isArray(source[key])) {
|
||||
if (!target[key])
|
||||
target[key] = [];
|
||||
deepMergeWithArray(target[key], source[key]);
|
||||
} else if (isMergableObject(source[key])) {
|
||||
if (!target[key])
|
||||
target[key] = {};
|
||||
deepMergeWithArray(target[key], source[key]);
|
||||
} else {
|
||||
target[key] = source[key];
|
||||
}
|
||||
});
|
||||
}
|
||||
return deepMergeWithArray(target, ...sources);
|
||||
}
|
||||
function isMergableObject(item) {
|
||||
return isObject(item) && !Array.isArray(item);
|
||||
}
|
||||
function objectPick(obj, keys, omitUndefined = false) {
|
||||
return keys.reduce((n, k) => {
|
||||
if (k in obj) {
|
||||
if (!omitUndefined || obj[k] !== void 0)
|
||||
n[k] = obj[k];
|
||||
}
|
||||
return n;
|
||||
}, {});
|
||||
}
|
||||
function clearUndefined(obj) {
|
||||
Object.keys(obj).forEach((key) => obj[key] === void 0 ? delete obj[key] : {});
|
||||
return obj;
|
||||
}
|
||||
function hasOwnProperty(obj, v) {
|
||||
if (obj == null)
|
||||
return false;
|
||||
return Object.prototype.hasOwnProperty.call(obj, v);
|
||||
}
|
||||
const _objectIdMap = /* @__PURE__ */ new WeakMap();
|
||||
function objectId(obj) {
|
||||
if (isPrimitive(obj))
|
||||
return obj;
|
||||
if (!_objectIdMap.has(obj)) {
|
||||
_objectIdMap.set(obj, randomStr());
|
||||
}
|
||||
return _objectIdMap.get(obj);
|
||||
}
|
||||
|
||||
/*
|
||||
How it works:
|
||||
`this.#head` is an instance of `Node` which keeps track of its current value and nests another instance of `Node` that keeps the value that comes after it. When a value is provided to `.enqueue()`, the code needs to iterate through `this.#head`, going deeper and deeper to find the last value. However, iterating through every single item is slow. This problem is solved by saving a reference to the last value as `this.#tail` so that it can reference it to add a new value.
|
||||
*/
|
||||
|
||||
class Node {
|
||||
value;
|
||||
next;
|
||||
|
||||
constructor(value) {
|
||||
this.value = value;
|
||||
}
|
||||
}
|
||||
|
||||
class Queue {
|
||||
#head;
|
||||
#tail;
|
||||
#size;
|
||||
|
||||
constructor() {
|
||||
this.clear();
|
||||
}
|
||||
|
||||
enqueue(value) {
|
||||
const node = new Node(value);
|
||||
|
||||
if (this.#head) {
|
||||
this.#tail.next = node;
|
||||
this.#tail = node;
|
||||
} else {
|
||||
this.#head = node;
|
||||
this.#tail = node;
|
||||
}
|
||||
|
||||
this.#size++;
|
||||
}
|
||||
|
||||
dequeue() {
|
||||
const current = this.#head;
|
||||
if (!current) {
|
||||
return;
|
||||
}
|
||||
|
||||
this.#head = this.#head.next;
|
||||
this.#size--;
|
||||
return current.value;
|
||||
}
|
||||
|
||||
peek() {
|
||||
if (!this.#head) {
|
||||
return;
|
||||
}
|
||||
|
||||
return this.#head.value;
|
||||
|
||||
// TODO: Node.js 18.
|
||||
// return this.#head?.value;
|
||||
}
|
||||
|
||||
clear() {
|
||||
this.#head = undefined;
|
||||
this.#tail = undefined;
|
||||
this.#size = 0;
|
||||
}
|
||||
|
||||
get size() {
|
||||
return this.#size;
|
||||
}
|
||||
|
||||
* [Symbol.iterator]() {
|
||||
let current = this.#head;
|
||||
|
||||
while (current) {
|
||||
yield current.value;
|
||||
current = current.next;
|
||||
}
|
||||
}
|
||||
|
||||
* drain() {
|
||||
while (this.#head) {
|
||||
yield this.dequeue();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function pLimit(concurrency) {
|
||||
validateConcurrency(concurrency);
|
||||
|
||||
const queue = new Queue();
|
||||
let activeCount = 0;
|
||||
|
||||
const resumeNext = () => {
|
||||
// Process the next queued function if we're under the concurrency limit
|
||||
if (activeCount < concurrency && queue.size > 0) {
|
||||
activeCount++;
|
||||
queue.dequeue()();
|
||||
}
|
||||
};
|
||||
|
||||
const next = () => {
|
||||
activeCount--;
|
||||
resumeNext();
|
||||
};
|
||||
|
||||
const run = async (function_, resolve, arguments_) => {
|
||||
// Execute the function and capture the result promise
|
||||
const result = (async () => function_(...arguments_))();
|
||||
|
||||
// Resolve immediately with the promise (don't wait for completion)
|
||||
resolve(result);
|
||||
|
||||
// Wait for the function to complete (success or failure)
|
||||
// We catch errors here to prevent unhandled rejections,
|
||||
// but the original promise rejection is preserved for the caller
|
||||
try {
|
||||
await result;
|
||||
} catch {}
|
||||
|
||||
// Decrement active count and process next queued function
|
||||
next();
|
||||
};
|
||||
|
||||
const enqueue = (function_, resolve, arguments_) => {
|
||||
// Queue the internal resolve function instead of the run function
|
||||
// to preserve the asynchronous execution context.
|
||||
new Promise(internalResolve => { // eslint-disable-line promise/param-names
|
||||
queue.enqueue(internalResolve);
|
||||
}).then(run.bind(undefined, function_, resolve, arguments_)); // eslint-disable-line promise/prefer-await-to-then
|
||||
|
||||
// Start processing immediately if we haven't reached the concurrency limit
|
||||
if (activeCount < concurrency) {
|
||||
resumeNext();
|
||||
}
|
||||
};
|
||||
|
||||
const generator = (function_, ...arguments_) => new Promise(resolve => {
|
||||
enqueue(function_, resolve, arguments_);
|
||||
});
|
||||
|
||||
Object.defineProperties(generator, {
|
||||
activeCount: {
|
||||
get: () => activeCount,
|
||||
},
|
||||
pendingCount: {
|
||||
get: () => queue.size,
|
||||
},
|
||||
clearQueue: {
|
||||
value() {
|
||||
queue.clear();
|
||||
},
|
||||
},
|
||||
concurrency: {
|
||||
get: () => concurrency,
|
||||
|
||||
set(newConcurrency) {
|
||||
validateConcurrency(newConcurrency);
|
||||
concurrency = newConcurrency;
|
||||
|
||||
queueMicrotask(() => {
|
||||
// eslint-disable-next-line no-unmodified-loop-condition
|
||||
while (activeCount < concurrency && queue.size > 0) {
|
||||
resumeNext();
|
||||
}
|
||||
});
|
||||
},
|
||||
},
|
||||
map: {
|
||||
async value(array, function_) {
|
||||
const promises = array.map((value, index) => this(function_, value, index));
|
||||
return Promise.all(promises);
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
return generator;
|
||||
}
|
||||
|
||||
function validateConcurrency(concurrency) {
|
||||
if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
|
||||
throw new TypeError('Expected `concurrency` to be a number from 1 and up');
|
||||
}
|
||||
}
|
||||
|
||||
const VOID = Symbol("p-void");
|
||||
class PInstance extends Promise {
|
||||
constructor(items = [], options) {
|
||||
super(() => {
|
||||
});
|
||||
this.items = items;
|
||||
this.options = options;
|
||||
}
|
||||
promises = /* @__PURE__ */ new Set();
|
||||
get promise() {
|
||||
let batch;
|
||||
const items = [...Array.from(this.items), ...Array.from(this.promises)];
|
||||
if (this.options?.concurrency) {
|
||||
const limit = pLimit(this.options.concurrency);
|
||||
batch = Promise.all(items.map((p2) => limit(() => p2)));
|
||||
} else {
|
||||
batch = Promise.all(items);
|
||||
}
|
||||
return batch.then((l) => l.filter((i) => i !== VOID));
|
||||
}
|
||||
add(...args) {
|
||||
args.forEach((i) => {
|
||||
this.promises.add(i);
|
||||
});
|
||||
}
|
||||
map(fn) {
|
||||
return new PInstance(
|
||||
Array.from(this.items).map(async (i, idx) => {
|
||||
const v = await i;
|
||||
if (v === VOID)
|
||||
return VOID;
|
||||
return fn(v, idx);
|
||||
}),
|
||||
this.options
|
||||
);
|
||||
}
|
||||
filter(fn) {
|
||||
return new PInstance(
|
||||
Array.from(this.items).map(async (i, idx) => {
|
||||
const v = await i;
|
||||
const r = await fn(v, idx);
|
||||
if (!r)
|
||||
return VOID;
|
||||
return v;
|
||||
}),
|
||||
this.options
|
||||
);
|
||||
}
|
||||
forEach(fn) {
|
||||
return this.map(fn).then();
|
||||
}
|
||||
reduce(fn, initialValue) {
|
||||
return this.promise.then((array) => array.reduce(fn, initialValue));
|
||||
}
|
||||
clear() {
|
||||
this.promises.clear();
|
||||
}
|
||||
then(onfulfilled, onrejected) {
|
||||
return this.promise.then(onfulfilled, onrejected);
|
||||
}
|
||||
catch(fn) {
|
||||
return this.promise.catch(fn);
|
||||
}
|
||||
finally(fn) {
|
||||
return this.promise.finally(fn);
|
||||
}
|
||||
}
|
||||
function p(items, options) {
|
||||
return new PInstance(items, options);
|
||||
}
|
||||
|
||||
function createSingletonPromise(fn) {
|
||||
let _promise;
|
||||
function wrapper() {
|
||||
if (!_promise)
|
||||
_promise = fn();
|
||||
return _promise;
|
||||
}
|
||||
wrapper.reset = async () => {
|
||||
const _prev = _promise;
|
||||
_promise = void 0;
|
||||
if (_prev)
|
||||
await _prev;
|
||||
};
|
||||
return wrapper;
|
||||
}
|
||||
function sleep(ms, callback) {
|
||||
return new Promise(
|
||||
(resolve) => setTimeout(async () => {
|
||||
await callback?.();
|
||||
resolve();
|
||||
}, ms)
|
||||
);
|
||||
}
|
||||
function createPromiseLock() {
|
||||
const locks = [];
|
||||
return {
|
||||
async run(fn) {
|
||||
const p = fn();
|
||||
locks.push(p);
|
||||
try {
|
||||
return await p;
|
||||
} finally {
|
||||
remove(locks, p);
|
||||
}
|
||||
},
|
||||
async wait() {
|
||||
await Promise.allSettled(locks);
|
||||
},
|
||||
isWaiting() {
|
||||
return Boolean(locks.length);
|
||||
},
|
||||
clear() {
|
||||
locks.length = 0;
|
||||
}
|
||||
};
|
||||
}
|
||||
function createControlledPromise() {
|
||||
let resolve, reject;
|
||||
const promise = new Promise((_resolve, _reject) => {
|
||||
resolve = _resolve;
|
||||
reject = _reject;
|
||||
});
|
||||
promise.resolve = resolve;
|
||||
promise.reject = reject;
|
||||
return promise;
|
||||
}
|
||||
|
||||
const timestamp = () => +Date.now();
|
||||
|
||||
/* eslint-disable no-undefined,no-param-reassign,no-shadow */
|
||||
|
||||
/**
|
||||
* Throttle execution of a function. Especially useful for rate limiting
|
||||
* execution of handlers on events like resize and scroll.
|
||||
*
|
||||
* @param {number} delay - A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher)
|
||||
* are most useful.
|
||||
* @param {Function} 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 {object} [options] - An object to configure options.
|
||||
* @param {boolean} [options.noTrailing] - 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).
|
||||
* @param {boolean} [options.noLeading] - 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.
|
||||
* @param {boolean} [options.debounceMode] - If `debounceMode` is true (at begin), schedule `clear` to execute after `delay` ms. If `debounceMode` is
|
||||
* false (at end), schedule `callback` to execute after `delay` ms.
|
||||
*
|
||||
* @returns {Function} A new, throttled, function.
|
||||
*/
|
||||
function throttle$1 (delay, callback, options) {
|
||||
var _ref = options || {},
|
||||
_ref$noTrailing = _ref.noTrailing,
|
||||
noTrailing = _ref$noTrailing === void 0 ? false : _ref$noTrailing,
|
||||
_ref$noLeading = _ref.noLeading,
|
||||
noLeading = _ref$noLeading === void 0 ? false : _ref$noLeading,
|
||||
_ref$debounceMode = _ref.debounceMode,
|
||||
debounceMode = _ref$debounceMode === void 0 ? undefined : _ref$debounceMode;
|
||||
/*
|
||||
* After wrapper has stopped being called, this timeout ensures that
|
||||
* `callback` is executed at the proper times in `throttle` and `end`
|
||||
* debounce modes.
|
||||
*/
|
||||
|
||||
|
||||
var timeoutID;
|
||||
var cancelled = false; // Keep track of the last time `callback` was executed.
|
||||
|
||||
var lastExec = 0; // Function to clear existing timeout
|
||||
|
||||
function clearExistingTimeout() {
|
||||
if (timeoutID) {
|
||||
clearTimeout(timeoutID);
|
||||
}
|
||||
} // Function to cancel next exec
|
||||
|
||||
|
||||
function cancel(options) {
|
||||
var _ref2 = options || {},
|
||||
_ref2$upcomingOnly = _ref2.upcomingOnly,
|
||||
upcomingOnly = _ref2$upcomingOnly === void 0 ? false : _ref2$upcomingOnly;
|
||||
|
||||
clearExistingTimeout();
|
||||
cancelled = !upcomingOnly;
|
||||
}
|
||||
/*
|
||||
* The `wrapper` function encapsulates all of the throttling / debouncing
|
||||
* functionality and when executed will limit the rate at which `callback`
|
||||
* is executed.
|
||||
*/
|
||||
|
||||
|
||||
function wrapper() {
|
||||
for (var _len = arguments.length, arguments_ = new Array(_len), _key = 0; _key < _len; _key++) {
|
||||
arguments_[_key] = arguments[_key];
|
||||
}
|
||||
|
||||
var self = this;
|
||||
var elapsed = Date.now() - lastExec;
|
||||
|
||||
if (cancelled) {
|
||||
return;
|
||||
} // Execute `callback` and update the `lastExec` timestamp.
|
||||
|
||||
|
||||
function exec() {
|
||||
lastExec = Date.now();
|
||||
callback.apply(self, arguments_);
|
||||
}
|
||||
/*
|
||||
* If `debounceMode` is true (at begin) this is used to clear the flag
|
||||
* to allow future `callback` executions.
|
||||
*/
|
||||
|
||||
|
||||
function clear() {
|
||||
timeoutID = undefined;
|
||||
}
|
||||
|
||||
if (!noLeading && debounceMode && !timeoutID) {
|
||||
/*
|
||||
* Since `wrapper` is being called for the first time and
|
||||
* `debounceMode` is true (at begin), execute `callback`
|
||||
* and noLeading != true.
|
||||
*/
|
||||
exec();
|
||||
}
|
||||
|
||||
clearExistingTimeout();
|
||||
|
||||
if (debounceMode === undefined && elapsed > delay) {
|
||||
if (noLeading) {
|
||||
/*
|
||||
* In throttle mode with noLeading, if `delay` time has
|
||||
* been exceeded, update `lastExec` and schedule `callback`
|
||||
* to execute after `delay` ms.
|
||||
*/
|
||||
lastExec = Date.now();
|
||||
|
||||
if (!noTrailing) {
|
||||
timeoutID = setTimeout(debounceMode ? clear : exec, delay);
|
||||
}
|
||||
} else {
|
||||
/*
|
||||
* In throttle mode without noLeading, if `delay` time has been exceeded, execute
|
||||
* `callback`.
|
||||
*/
|
||||
exec();
|
||||
}
|
||||
} else if (noTrailing !== true) {
|
||||
/*
|
||||
* In trailing throttle mode, since `delay` time has not been
|
||||
* exceeded, schedule `callback` to execute `delay` ms after most
|
||||
* recent execution.
|
||||
*
|
||||
* If `debounceMode` is true (at begin), schedule `clear` to execute
|
||||
* after `delay` ms.
|
||||
*
|
||||
* If `debounceMode` is false (at end), schedule `callback` to
|
||||
* execute after `delay` ms.
|
||||
*/
|
||||
timeoutID = setTimeout(debounceMode ? clear : exec, debounceMode === undefined ? delay - elapsed : delay);
|
||||
}
|
||||
}
|
||||
|
||||
wrapper.cancel = cancel; // Return the wrapper function.
|
||||
|
||||
return wrapper;
|
||||
}
|
||||
|
||||
/* eslint-disable no-undefined */
|
||||
/**
|
||||
* 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.
|
||||
*
|
||||
* @param {number} delay - A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher) are most useful.
|
||||
* @param {Function} 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 {object} [options] - An object to configure options.
|
||||
* @param {boolean} [options.atBegin] - Optional, defaults to false. 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).
|
||||
*
|
||||
* @returns {Function} A new, debounced function.
|
||||
*/
|
||||
|
||||
function debounce$1 (delay, callback, options) {
|
||||
var _ref = options || {},
|
||||
_ref$atBegin = _ref.atBegin,
|
||||
atBegin = _ref$atBegin === void 0 ? false : _ref$atBegin;
|
||||
|
||||
return throttle$1(delay, callback, {
|
||||
debounceMode: atBegin !== false
|
||||
});
|
||||
}
|
||||
|
||||
function throttle(...args) {
|
||||
return throttle$1(...args);
|
||||
}
|
||||
function debounce(...args) {
|
||||
return debounce$1(...args);
|
||||
}
|
||||
|
||||
export { assert, at, batchInvoke, capitalize, clamp, clampArrayRange, clearUndefined, createControlledPromise, createPromiseLock, createSingletonPromise, debounce, deepMerge, deepMergeWithArray, ensurePrefix, ensureSuffix, filterInPlace, flattenArrayable, getTypeName, hasOwnProperty, invoke, isBoolean, isBrowser, isDate, isDeepEqual, isDef, isFunction, isKeyOf, isNull, isNumber, isObject, isPrimitive, isRegExp, isString, isTruthy, isUndefined, isWindow, last, lerp, mergeArrayable, move, noNull, noop, notNullish, notUndefined, objectEntries, objectId, objectKeys, objectMap, objectPick, p, partition, randomStr, range, remap, remove, sample, shuffle, slash, sleep, sum, tap, template, throttle, timestamp, toArray, toString, unindent, uniq, uniqueBy };
|
||||
Reference in New Issue
Block a user