| 123456789101112131415161718192021222324252627282930313233343536373839404142434445 |
- 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>
|
