the-forest/client/node_modules/promise-limit/index.d.ts
2024-09-17 20:35:18 -04:00

46 lines
1.8 KiB
TypeScript

export = limitFactory
declare namespace limitFactory {}
/**
* Returns a function that can be used to wrap promise returning functions,
* limiting them to concurrency outstanding calls.
* @param concurrency the concurrency, i.e. 1 will limit calls to one at a
* time, effectively in sequence or serial. 2 will allow two at a time, etc.
* 0 or undefined specify no limit, and all calls will be run in parallel.
*/
declare function limitFactory<T>(concurrency?: number): limit<T>
declare type limit<T> = limitFunc<T> & limitInterface<T>
declare interface limitInterface<T> {
/**
* Maps an array of items using mapper, but limiting the number of concurrent
* calls to mapper with the concurrency of limit. If at least one call to
* mapper returns a rejected promise, the result of map is a the same rejected
* promise, and no further calls to mapper are made.
* @param items any items
* @param mapper iterator
*/
map<U>(items: ReadonlyArray<T>, mapper: (value: T) => Promise<U>): Promise<U[]>
/**
* Returns the queue length, the number of jobs that are waiting to be started.
* You could use this to throttle incoming jobs, so the queue doesn't
* overwhealm the available memory - for e.g. pause() a stream.
*/
queue: number
}
/**
* A function that limits calls to fn, based on concurrency above. Returns a
* promise that resolves or rejects the same value or error as fn. All functions
* are executed in the same order in which they were passed to limit. fn must
* return a promise.
* @param fn a function that is called with no arguments and returns a promise.
* You can pass arguments to your function by putting it inside another function,
* i.e. `() -> myfunc(a, b, c)`.
*/
declare type limitFunc<T> = (fn: () => Promise<T>) => Promise<T>