1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 |
|
7 |
|
8 |
|
9 |
|
10 |
|
11 |
|
12 |
|
13 |
|
14 |
|
15 | export as namespace async;
|
16 |
|
17 | export interface Dictionary<T> { [key: string]: T; }
|
18 | export type IterableCollection<T> = T[] | IterableIterator<T> | Dictionary<T>;
|
19 |
|
20 | export interface ErrorCallback<E = Error> { (err?: E | null): void; }
|
21 | export interface AsyncBooleanResultCallback<E = Error> { (err?: E | null, truthValue?: boolean): void; }
|
22 | export interface AsyncResultCallback<T, E = Error> { (err?: E | null, result?: T): void; }
|
23 | export interface AsyncResultArrayCallback<T, E = Error> { (err?: E | null, results?: Array<T | undefined>): void; }
|
24 | export interface AsyncResultObjectCallback<T, E = Error> { (err: E | undefined, results: Dictionary<T | undefined>): void; }
|
25 |
|
26 | export interface AsyncFunction<T, E = Error> { (callback: (err?: E | null, result?: T) => void): void; }
|
27 | export interface AsyncFunctionEx<T, E = Error> { (callback: (err?: E | null, ...results: T[]) => void): void; }
|
28 | export interface AsyncIterator<T, E = Error> { (item: T, callback: ErrorCallback<E>): void; }
|
29 | export interface AsyncForEachOfIterator<T, E = Error> { (item: T, key: number|string, callback: ErrorCallback<E>): void; }
|
30 | export interface AsyncResultIterator<T, R, E = Error> { (item: T, callback: AsyncResultCallback<R, E>): void; }
|
31 | export interface AsyncMemoIterator<T, R, E = Error> { (memo: R | undefined, item: T, callback: AsyncResultCallback<R, E>): void; }
|
32 | export interface AsyncBooleanIterator<T, E = Error> { (item: T, callback: AsyncBooleanResultCallback<E>): void; }
|
33 |
|
34 | export interface AsyncWorker<T, E = Error> { (task: T, callback: ErrorCallback<E>): void; }
|
35 | export interface AsyncVoidFunction<E = Error> { (callback: ErrorCallback<E>): void; }
|
36 |
|
37 | export type AsyncAutoTasks<R extends Dictionary<any>, E> = { [K in keyof R]: AsyncAutoTask<R[K], R, E> };
|
38 | export type AsyncAutoTask<R1, R extends Dictionary<any>, E> = AsyncAutoTaskFunctionWithoutDependencies<R1, E> | Array<keyof R | AsyncAutoTaskFunction<R1, R, E>>;
|
39 | export interface AsyncAutoTaskFunctionWithoutDependencies<R1, E = Error> { (cb: AsyncResultCallback<R1, E> | ErrorCallback<E>): void; }
|
40 | export interface AsyncAutoTaskFunction<R1, R extends Dictionary<any>, E = Error> { (results: R, cb: AsyncResultCallback<R1, E> | ErrorCallback<E>): void; }
|
41 |
|
42 | export interface DataContainer<T> {
|
43 | data: T;
|
44 | priority: number;
|
45 | }
|
46 |
|
47 | export interface CallbackContainer {
|
48 | callback: Function;
|
49 | }
|
50 |
|
51 | export interface PriorityContainer {
|
52 | priority: number;
|
53 | }
|
54 |
|
55 | export interface QueueObject<T> {
|
56 | |
57 |
|
58 |
|
59 | length(): number;
|
60 |
|
61 | |
62 |
|
63 |
|
64 | started: boolean;
|
65 |
|
66 | |
67 |
|
68 |
|
69 | running(): number;
|
70 |
|
71 | |
72 |
|
73 |
|
74 | workersList<TWorker extends DataContainer<T>, CallbackContainer>(): TWorker[];
|
75 |
|
76 | |
77 |
|
78 |
|
79 | idle(): boolean;
|
80 |
|
81 | |
82 |
|
83 |
|
84 |
|
85 | concurrency: number;
|
86 |
|
87 | |
88 |
|
89 |
|
90 |
|
91 | payload: number;
|
92 |
|
93 | |
94 |
|
95 |
|
96 |
|
97 |
|
98 |
|
99 |
|
100 | push<R>(task: T | T[]): Promise<R>;
|
101 | push<R, E = Error>(task: T | T[], callback: AsyncResultCallback<R, E>): void;
|
102 |
|
103 | |
104 |
|
105 |
|
106 | unshift<R>(task: T | T[]): Promise<R>;
|
107 | unshift<R, E = Error>(task: T | T[], callback: AsyncResultCallback<R, E>): void;
|
108 |
|
109 | |
110 |
|
111 |
|
112 |
|
113 | pushAsync<R>(task: T | T[]): Promise<R>;
|
114 |
|
115 | |
116 |
|
117 |
|
118 |
|
119 | unshiftAsync<R>(task: T | T[]): Promise<R>;
|
120 |
|
121 | |
122 |
|
123 |
|
124 |
|
125 |
|
126 | remove(filter: (node: DataContainer<T>) => boolean): void;
|
127 |
|
128 | |
129 |
|
130 |
|
131 |
|
132 |
|
133 |
|
134 |
|
135 |
|
136 | saturated(): Promise<void>;
|
137 | saturated(handler: () => void): void;
|
138 |
|
139 | |
140 |
|
141 |
|
142 |
|
143 |
|
144 |
|
145 |
|
146 |
|
147 | unsaturated(): Promise<void>;
|
148 | unsaturated(handler: () => void): void;
|
149 |
|
150 | |
151 |
|
152 |
|
153 | buffer: number;
|
154 |
|
155 | |
156 |
|
157 |
|
158 |
|
159 |
|
160 |
|
161 | empty(): Promise<void>;
|
162 | empty(handler: () => void): void;
|
163 |
|
164 | |
165 |
|
166 |
|
167 |
|
168 |
|
169 |
|
170 | drain(): Promise<void>;
|
171 | drain(handler: () => void): void;
|
172 |
|
173 | |
174 |
|
175 |
|
176 |
|
177 |
|
178 | error(): Promise<never>;
|
179 | error(handler: (error: Error, task: T) => void): void;
|
180 |
|
181 | |
182 |
|
183 |
|
184 | paused: boolean;
|
185 |
|
186 | |
187 |
|
188 |
|
189 | pause(): void;
|
190 |
|
191 | |
192 |
|
193 |
|
194 |
|
195 | resume(): void;
|
196 |
|
197 | |
198 |
|
199 |
|
200 |
|
201 |
|
202 | kill(): void;
|
203 | }
|
204 |
|
205 |
|
206 |
|
207 |
|
208 |
|
209 |
|
210 |
|
211 |
|
212 |
|
213 | export interface AsyncPriorityQueue<T> extends Pick<QueueObject<T>, Exclude<keyof QueueObject<T>, 'push' | 'unshift'>> {
|
214 | push<R>(task: T | T[], priority?: number): Promise<R>;
|
215 | push<R, E = Error>(task: T | T[], priority: number, callback: AsyncResultCallback<R, E>): void;
|
216 | }
|
217 |
|
218 |
|
219 |
|
220 |
|
221 |
|
222 | export type AsyncQueue<T> = QueueObject<T>;
|
223 |
|
224 |
|
225 |
|
226 |
|
227 |
|
228 | export type AsyncCargoQueue<T = any> = QueueObject<T>;
|
229 |
|
230 |
|
231 | export function each<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncIterator<T, E>, callback: ErrorCallback<E>): void;
|
232 | export function each<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncIterator<T, E>): Promise<void>;
|
233 | export const eachSeries: typeof each;
|
234 | export function eachLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncIterator<T, E>, callback: ErrorCallback<E>): void;
|
235 | export function eachLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncIterator<T, E>): Promise<void>;
|
236 | export const forEach: typeof each;
|
237 | export const forEachSeries: typeof each;
|
238 | export const forEachLimit: typeof eachLimit;
|
239 | export function forEachOf<T, E = Error>(obj: IterableCollection<T>, iterator: AsyncForEachOfIterator<T, E>, callback: ErrorCallback<E>): void;
|
240 | export function forEachOf<T, E = Error>(obj: IterableCollection<T>, iterator: AsyncForEachOfIterator<T, E>): Promise<void>;
|
241 | export const forEachOfSeries: typeof forEachOf;
|
242 | export function forEachOfLimit<T, E = Error>(obj: IterableCollection<T>, limit: number, iterator: AsyncForEachOfIterator<T, E>, callback: ErrorCallback<E>): void;
|
243 | export function forEachOfLimit<T, E = Error>(obj: IterableCollection<T>, limit: number, iterator: AsyncForEachOfIterator<T, E>): Promise<void>;
|
244 | export const eachOf: typeof forEachOf;
|
245 | export const eachOfSeries: typeof forEachOf;
|
246 | export const eachOfLimit: typeof forEachOfLimit;
|
247 | export function map<T, R, E = Error>(arr: T[] | IterableIterator<T> | Dictionary<T>, iterator: AsyncResultIterator<T, R, E>, callback: AsyncResultArrayCallback<R, E>): void;
|
248 | export function map<T, R, E = Error>(arr: T[] | IterableIterator<T> | Dictionary<T>, iterator: AsyncResultIterator<T, R, E>): Promise<R[]>;
|
249 | export const mapSeries: typeof map;
|
250 | export function mapLimit<T, R, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncResultIterator<T, R, E>, callback: AsyncResultArrayCallback<R, E>): void;
|
251 | export function mapLimit<T, R, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncResultIterator<T, R, E>): Promise<R[]>;
|
252 |
|
253 | export function mapValuesLimit<T, R, E = Error>(
|
254 | obj: Dictionary<T>,
|
255 | limit: number,
|
256 | iteratee: (value: T, key: string, callback: AsyncResultCallback<R, E>) => void,
|
257 | callback: AsyncResultObjectCallback<R, E>
|
258 | ): void;
|
259 | export function mapValuesLimit<T, R, E = Error>(
|
260 | obj: Dictionary<T>,
|
261 | limit: number,
|
262 | iteratee: (value: T, key: string, callback: AsyncResultCallback<R, E>) => void
|
263 | ): Promise<R>;
|
264 |
|
265 | export function mapValues<T, R, E = Error>(obj: Dictionary<T>, iteratee: (value: T, key: string, callback: AsyncResultCallback<R, E>) => void, callback: AsyncResultObjectCallback<R, E>): void;
|
266 | export function mapValues<T, R, E = Error>(obj: Dictionary<T>, iteratee: (value: T, key: string, callback: AsyncResultCallback<R, E>) => void): Promise<R>;
|
267 | export const mapValuesSeries: typeof mapValues;
|
268 | export function filter<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback: AsyncResultArrayCallback<T, E>): void;
|
269 | export function filter<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>): Promise<T[]>;
|
270 | export const filterSeries: typeof filter;
|
271 | export function filterLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback: AsyncResultArrayCallback<T, E>): void;
|
272 | export function filterLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>): Promise<T[]>;
|
273 | export const select: typeof filter;
|
274 | export const selectSeries: typeof filter;
|
275 | export const selectLimit: typeof filterLimit;
|
276 | export const reject: typeof filter;
|
277 | export const rejectSeries: typeof filter;
|
278 | export const rejectLimit: typeof filterLimit;
|
279 | export function reduce<T, R, E = Error>(arr: T[] | IterableIterator<T>, memo: R, iterator: AsyncMemoIterator<T, R, E>, callback?: AsyncResultCallback<R, E>): void;
|
280 | export const inject: typeof reduce;
|
281 | export const foldl: typeof reduce;
|
282 | export const reduceRight: typeof reduce;
|
283 | export const foldr: typeof reduce;
|
284 | export function detect<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultCallback<T, E>): void;
|
285 | export const detectSeries: typeof detect;
|
286 | export function detectLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultCallback<T, E>): void;
|
287 | export const find: typeof detect;
|
288 | export const findSeries: typeof detect;
|
289 | export const findLimit: typeof detectLimit;
|
290 | export function sortBy<T, V, E = Error>(arr: T[] | IterableIterator<T>, iterator: AsyncResultIterator<T, V, E>, callback?: AsyncResultArrayCallback<T, E>): void;
|
291 | export function some<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
|
292 | export const someSeries: typeof some;
|
293 | export function someLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
|
294 | export const any: typeof some;
|
295 | export const anySeries: typeof someSeries;
|
296 | export const anyLimit: typeof someLimit;
|
297 | export function every<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
|
298 | export const everySeries: typeof every;
|
299 | export function everyLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
|
300 | export const all: typeof every;
|
301 | export const allSeries: typeof every;
|
302 | export const allLimit: typeof everyLimit;
|
303 |
|
304 | export function concat<T, R, E = Error>(arr: IterableCollection<T>, iterator: AsyncResultIterator<T, R[], E>, callback?: AsyncResultArrayCallback<R, E>): void;
|
305 | export function concatLimit<T, R, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncResultIterator<T, R[], E>, callback?: AsyncResultArrayCallback<R, E>): void;
|
306 | export const concatSeries: typeof concat;
|
307 |
|
308 |
|
309 | export function series<T, E = Error>(tasks: Array<AsyncFunction<T, E>>, callback?: AsyncResultArrayCallback<T, E>): void;
|
310 | export function series<T, E = Error>(tasks: Dictionary<AsyncFunction<T, E>>, callback?: AsyncResultObjectCallback<T, E>): void;
|
311 | export function series<T, R, E = Error>(tasks: Array<AsyncFunction<T, E>> | Dictionary<AsyncFunction<T, E>>): Promise<R>;
|
312 | export function parallel<T, E = Error>(tasks: Array<AsyncFunction<T, E>>, callback?: AsyncResultArrayCallback<T, E>): void;
|
313 | export function parallel<T, E = Error>(tasks: Dictionary<AsyncFunction<T, E>>, callback?: AsyncResultObjectCallback<T, E>): void;
|
314 | export function parallel<T, R, E = Error>(tasks: Array<AsyncFunction<T, E>> | Dictionary<AsyncFunction<T, E>>): Promise<R>;
|
315 | export function parallelLimit<T, E = Error>(tasks: Array<AsyncFunction<T, E>>, limit: number, callback?: AsyncResultArrayCallback<T, E>): void;
|
316 | export function parallelLimit<T, E = Error>(tasks: Dictionary<AsyncFunction<T, E>>, limit: number, callback?: AsyncResultObjectCallback<T, E>): void;
|
317 | export function parallelLimit<T, R, E = Error>(tasks: Array<AsyncFunction<T, E>> | Dictionary<AsyncFunction<T, E>>, limit: number): Promise<R>;
|
318 | export function whilst<E = Error>(test: (cb: (err: any, truth: boolean) => boolean) => boolean, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
|
319 | export function whilst<R, E = Error>(test: (cb: (err: any, truth: boolean) => boolean) => boolean, fn: AsyncVoidFunction<E>): Promise<R>;
|
320 | export function doWhilst<T, E = Error>(fn: AsyncFunctionEx<T, E>, test: (...results: T[]) => boolean, callback: ErrorCallback<E>): void;
|
321 | export function doWhilst<T, R, E = Error>(fn: AsyncFunctionEx<T, E>, test: (...results: T[]) => boolean): Promise<R>;
|
322 | export function until<E = Error>(test: () => boolean, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
|
323 | export function until<R, E = Error>(test: () => boolean, fn: AsyncVoidFunction<E>): Promise<R>;
|
324 | export function doUntil<T, E = Error>(fn: AsyncFunctionEx<T, E>, test: (...results: T[]) => boolean, callback: ErrorCallback<E>): void;
|
325 | export function doUntil<T, R, E = Error>(fn: AsyncFunctionEx<T, E>, test: (...results: T[]) => boolean): Promise<R>;
|
326 | export function during<E = Error>(test: (testCallback: AsyncBooleanResultCallback<E>) => void, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
|
327 | export function doDuring<E = Error>(fn: AsyncVoidFunction<E>, test: (testCallback: AsyncBooleanResultCallback<E>) => void, callback: ErrorCallback<E>): void;
|
328 | export function forever<E = Error>(next: (next: ErrorCallback<E>) => void, errBack: ErrorCallback<E>): void;
|
329 | export function waterfall<T, E = Error>(tasks: Function[], callback?: AsyncResultCallback<T, E>): void;
|
330 | export function compose(...fns: Function[]): Function;
|
331 | export function seq(...fns: Function[]): Function;
|
332 | export function applyEach(fns: Function[], ...argsAndCallback: any[]): void;
|
333 | export function applyEachSeries(fns: Function[], ...argsAndCallback: any[]): void;
|
334 | export function queue<T, E = Error>(worker: AsyncWorker<T, E>, concurrency?: number): QueueObject<T>;
|
335 | export function queue<T, R, E = Error>(worker: AsyncResultIterator<T, R, E>, concurrency?: number): QueueObject<T>;
|
336 | export function priorityQueue<T, E = Error>(worker: AsyncWorker<T, E>, concurrency?: number): AsyncPriorityQueue<T>;
|
337 | export function cargo<T, E = Error>(worker: AsyncWorker<T[], E>, payload?: number): QueueObject<T>;
|
338 | export function cargoQueue<T, E = Error>(
|
339 | worker: AsyncWorker<T[], E>,
|
340 | concurrency?: number,
|
341 | payload?: number,
|
342 | ): QueueObject<T>;
|
343 | export function auto<R extends Dictionary<any>, E = Error>(tasks: AsyncAutoTasks<R, E>, concurrency?: number, callback?: AsyncResultCallback<R, E>): void;
|
344 | export function auto<R extends Dictionary<any>, E = Error>(tasks: AsyncAutoTasks<R, E>, callback?: AsyncResultCallback<R, E>): void;
|
345 | export function autoInject<E = Error>(tasks: any, callback?: AsyncResultCallback<any, E>): void;
|
346 |
|
347 | export interface RetryOptions<E> {
|
348 | times?: number;
|
349 | interval?: number | ((retryCount: number) => number);
|
350 | errorFilter?: (error: E) => boolean;
|
351 | }
|
352 | export function retry<T, E = Error>(
|
353 | task: (() => Promise<T>) | ((callback: AsyncResultCallback<T, E>) => void),
|
354 | ): Promise<T>;
|
355 | export function retry<T, E = Error>(
|
356 | opts: number | RetryOptions<E>,
|
357 | task: (() => Promise<T>) | ((callback: AsyncResultCallback<T, E>) => void),
|
358 | ): Promise<T>;
|
359 | export function retry<T, E = Error>(
|
360 | task: (() => Promise<T>) | ((callback: AsyncResultCallback<T, E>) => void),
|
361 | callback: AsyncResultCallback<T, E>,
|
362 | ): void;
|
363 | export function retry<T, E = Error>(
|
364 | opts: number | RetryOptions<E>,
|
365 | task: (() => Promise<T>) | ((callback: AsyncResultCallback<T, E>) => void),
|
366 | callback: AsyncResultCallback<T, E>,
|
367 | ): void;
|
368 |
|
369 | export function retryable<T, E = Error>(task: AsyncFunction<T, E>): AsyncFunction<T, E>;
|
370 | export function retryable<T, E = Error>(
|
371 | opts: number | (RetryOptions<E> & { arity?: number }),
|
372 | task: AsyncFunction<T, E>,
|
373 | ): AsyncFunction<T, E>;
|
374 | export function apply<E = Error>(fn: Function, ...args: any[]): AsyncFunction<any, E>;
|
375 | export function nextTick(callback: Function, ...args: any[]): void;
|
376 | export const setImmediate: typeof nextTick;
|
377 |
|
378 | export function reflect<T, E = Error>(fn: AsyncFunction<T, E>): (callback: (err: null, result: {error?: E, value?: T}) => void) => void;
|
379 | export function reflectAll<T, E = Error>(tasks: Array<AsyncFunction<T, E>>): Array<(callback: (err: null, result: {error?: E, value?: T}) => void) => void>;
|
380 |
|
381 | export function timeout<T, E = Error>(fn: AsyncFunction<T, E>, milliseconds: number, info?: any): AsyncFunction<T, E>;
|
382 | export function timeout<T, R, E = Error>(fn: AsyncResultIterator<T, R, E>, milliseconds: number, info?: any): AsyncResultIterator<T, R, E>;
|
383 |
|
384 | export function times<T, E = Error>(n: number, iterator: AsyncResultIterator<number, T, E>, callback: AsyncResultArrayCallback<T, E>): void;
|
385 | export function times<T, E = Error>(n: number, iterator: AsyncResultIterator<number, T, E>): Promise<T>;
|
386 | export const timesSeries: typeof times;
|
387 | export function timesLimit<T, E = Error>(n: number, limit: number, iterator: AsyncResultIterator<number, T, E>, callback: AsyncResultArrayCallback<T, E>): void;
|
388 | export function timesLimit<T, E = Error>(n: number, limit: number, iterator: AsyncResultIterator<number, T, E>): Promise<T>;
|
389 |
|
390 | export function transform<T, R, E = Error>(arr: T[], iteratee: (acc: R[], item: T, key: number, callback: (error?: E) => void) => void, callback?: AsyncResultArrayCallback<T, E>): void;
|
391 | export function transform<T, R, E = Error>(arr: T[], acc: R[], iteratee: (acc: R[], item: T, key: number, callback: (error?: E) => void) => void, callback?: AsyncResultArrayCallback<T, E>): void;
|
392 |
|
393 | export function transform<T, R, E = Error>(
|
394 | arr: {[key: string]: T},
|
395 | iteratee: (acc: {[key: string]: R}, item: T, key: string, callback: (error?: E) => void) => void,
|
396 | callback?: AsyncResultObjectCallback<T, E>
|
397 | ): void;
|
398 |
|
399 | export function transform<T, R, E = Error>(
|
400 | arr: {[key: string]: T},
|
401 | acc: {[key: string]: R},
|
402 | iteratee: (acc: {[key: string]: R}, item: T, key: string, callback: (error?: E) => void) => void,
|
403 | callback?: AsyncResultObjectCallback<T, E>
|
404 | ): void;
|
405 |
|
406 | export function race<T, E = Error>(tasks: Array<AsyncFunction<T, E>>, callback: AsyncResultCallback<T, E>): void;
|
407 |
|
408 |
|
409 | export function memoize(fn: Function, hasher?: Function): Function;
|
410 | export function unmemoize(fn: Function): Function;
|
411 | export function ensureAsync(fn: (... argsAndCallback: any[]) => void): Function;
|
412 | export function constant(...values: any[]): AsyncFunction<any>;
|
413 | export function asyncify(fn: Function): (...args: any[]) => any;
|
414 | export function wrapSync(fn: Function): Function;
|
415 | export function log(fn: Function, ...args: any[]): void;
|
416 | export function dir(fn: Function, ...args: any[]): void;
|