1 | export as namespace async;
|
2 |
|
3 | export interface Dictionary<T> {
|
4 | [key: string]: T;
|
5 | }
|
6 | export type IterableCollection<T> = T[] | IterableIterator<T> | AsyncIterable<T> | Dictionary<T>;
|
7 |
|
8 | export interface ErrorCallback<E = Error> {
|
9 | (err?: E | null): void;
|
10 | }
|
11 | export interface AsyncBooleanResultCallback<E = Error> {
|
12 | (err?: E | null, truthValue?: boolean): void;
|
13 | }
|
14 | export interface AsyncResultCallback<T, E = Error> {
|
15 | (err?: E | null, result?: T): void;
|
16 | }
|
17 | export interface AsyncResultArrayCallback<T, E = Error> {
|
18 | (err?: E | null, results?: Array<T | undefined>): void;
|
19 | }
|
20 | export interface AsyncResultObjectCallback<T, E = Error> {
|
21 | (err: E | undefined, results: Dictionary<T | undefined>): void;
|
22 | }
|
23 | export interface AsyncResultRestCallback<T, E = Error> {
|
24 | (err?: E | null, ...results: T[]): void;
|
25 | }
|
26 |
|
27 | export interface AsyncFunction<T, E = Error> {
|
28 | (callback: (err?: E | null, result?: T) => void): void;
|
29 | }
|
30 | export interface AsyncFunctionEx<T, E = Error> {
|
31 | (callback: (err?: E | null, ...results: T[]) => void): void;
|
32 | }
|
33 | export interface AsyncIterator<T, E = Error> {
|
34 | (item: T, callback: ErrorCallback<E>): void;
|
35 | }
|
36 | export interface AsyncForEachOfIterator<T, E = Error> {
|
37 | (item: T, key: number | string, callback: ErrorCallback<E>): void;
|
38 | }
|
39 | export interface AsyncResultIterator<T, R, E = Error> {
|
40 | (item: T, callback: AsyncResultCallback<R, E>): void;
|
41 | }
|
42 | export interface AsyncResultIteratorPromise<T, R> {
|
43 | (item: T): Promise<R>;
|
44 | }
|
45 | export interface AsyncMemoIterator<T, R, E = Error> {
|
46 | (memo: R | undefined, item: T, callback: AsyncResultCallback<R, E>): void;
|
47 | }
|
48 | export interface AsyncBooleanIterator<T, E = Error> {
|
49 | (item: T, callback: AsyncBooleanResultCallback<E>): void;
|
50 | }
|
51 |
|
52 | export interface AsyncWorker<T, E = Error> {
|
53 | (task: T, callback: ErrorCallback<E>): void;
|
54 | }
|
55 | export interface AsyncVoidFunction<E = Error> {
|
56 | (callback: ErrorCallback<E>): void;
|
57 | }
|
58 |
|
59 | export type AsyncAutoTasks<R extends Dictionary<any>, E> = { [K in keyof R]: AsyncAutoTask<R[K], R, E> };
|
60 | export type AsyncAutoTask<R1, R extends Dictionary<any>, E> =
|
61 | | AsyncAutoTaskFunctionWithoutDependencies<R1, E>
|
62 | | Array<keyof R | AsyncAutoTaskFunction<R1, R, E>>;
|
63 | export interface AsyncAutoTaskFunctionWithoutDependencies<R1, E = Error> {
|
64 | (cb: AsyncResultCallback<R1, E> | ErrorCallback<E>): void;
|
65 | }
|
66 | export interface AsyncAutoTaskFunction<R1, R extends Dictionary<any>, E = Error> {
|
67 | (results: R, cb: AsyncResultCallback<R1, E> | ErrorCallback<E>): void;
|
68 | }
|
69 |
|
70 | export interface DataContainer<T> {
|
71 | data: T;
|
72 | priority: number;
|
73 | }
|
74 |
|
75 | export interface CallbackContainer {
|
76 | callback: Function;
|
77 | }
|
78 |
|
79 | export interface PriorityContainer {
|
80 | priority: number;
|
81 | }
|
82 |
|
83 | export interface QueueObject<T> {
|
84 | |
85 |
|
86 |
|
87 | length(): number;
|
88 |
|
89 | |
90 |
|
91 |
|
92 | started: boolean;
|
93 |
|
94 | |
95 |
|
96 |
|
97 | running(): number;
|
98 |
|
99 | |
100 |
|
101 |
|
102 | workersList<TWorker extends DataContainer<T>, CallbackContainer>(): TWorker[];
|
103 |
|
104 | |
105 |
|
106 |
|
107 | idle(): boolean;
|
108 |
|
109 | |
110 |
|
111 |
|
112 |
|
113 | concurrency: number;
|
114 |
|
115 | |
116 |
|
117 |
|
118 |
|
119 | payload: number;
|
120 |
|
121 | |
122 |
|
123 |
|
124 |
|
125 |
|
126 |
|
127 |
|
128 | push<R>(task: T | T[]): Promise<R>;
|
129 | push<R, E = Error>(task: T | T[], callback: AsyncResultCallback<R, E>): void;
|
130 |
|
131 | |
132 |
|
133 |
|
134 | unshift<R>(task: T | T[]): Promise<R>;
|
135 | unshift<R, E = Error>(task: T | T[], callback: AsyncResultCallback<R, E>): void;
|
136 |
|
137 | |
138 |
|
139 |
|
140 |
|
141 | pushAsync<R>(task: T | T[]): Promise<R>;
|
142 |
|
143 | |
144 |
|
145 |
|
146 |
|
147 | unshiftAsync<R>(task: T | T[]): Promise<R>;
|
148 |
|
149 | |
150 |
|
151 |
|
152 |
|
153 |
|
154 | remove(filter: (node: DataContainer<T>) => boolean): void;
|
155 |
|
156 | |
157 |
|
158 |
|
159 |
|
160 |
|
161 |
|
162 |
|
163 |
|
164 | saturated(): Promise<void>;
|
165 | saturated(handler: () => void): void;
|
166 |
|
167 | |
168 |
|
169 |
|
170 |
|
171 |
|
172 |
|
173 |
|
174 |
|
175 | unsaturated(): Promise<void>;
|
176 | unsaturated(handler: () => void): void;
|
177 |
|
178 | |
179 |
|
180 |
|
181 | buffer: number;
|
182 |
|
183 | |
184 |
|
185 |
|
186 |
|
187 |
|
188 |
|
189 | empty(): Promise<void>;
|
190 | empty(handler: () => void): void;
|
191 |
|
192 | |
193 |
|
194 |
|
195 |
|
196 |
|
197 |
|
198 | drain(): Promise<void>;
|
199 | drain(handler: () => void): void;
|
200 |
|
201 | |
202 |
|
203 |
|
204 |
|
205 |
|
206 | error(): Promise<never>;
|
207 | error(handler: (error: Error, task: T) => void): void;
|
208 |
|
209 | |
210 |
|
211 |
|
212 | paused: boolean;
|
213 |
|
214 | |
215 |
|
216 |
|
217 | pause(): void;
|
218 |
|
219 | |
220 |
|
221 |
|
222 |
|
223 | resume(): void;
|
224 |
|
225 | |
226 |
|
227 |
|
228 |
|
229 |
|
230 | kill(): void;
|
231 | }
|
232 |
|
233 |
|
234 |
|
235 |
|
236 |
|
237 |
|
238 |
|
239 |
|
240 |
|
241 | export interface AsyncPriorityQueue<T> extends Pick<QueueObject<T>, Exclude<keyof QueueObject<T>, "push" | "unshift">> {
|
242 | push<R>(task: T | T[], priority?: number): Promise<R>;
|
243 | push<R, E = Error>(task: T | T[], priority: number, callback: AsyncResultCallback<R, E>): void;
|
244 | }
|
245 |
|
246 |
|
247 |
|
248 |
|
249 |
|
250 | export type AsyncQueue<T> = QueueObject<T>;
|
251 |
|
252 |
|
253 |
|
254 |
|
255 |
|
256 | export type AsyncCargoQueue<T = any> = QueueObject<T>;
|
257 |
|
258 |
|
259 | export function each<T, E = Error>(
|
260 | arr: IterableCollection<T>,
|
261 | iterator: AsyncIterator<T, E>,
|
262 | callback: ErrorCallback<E>,
|
263 | ): void;
|
264 | export function each<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncIterator<T, E>): Promise<void>;
|
265 | export const eachSeries: typeof each;
|
266 | export function eachLimit<T, E = Error>(
|
267 | arr: IterableCollection<T>,
|
268 | limit: number,
|
269 | iterator: AsyncIterator<T, E>,
|
270 | callback: ErrorCallback<E>,
|
271 | ): void;
|
272 | export function eachLimit<T, E = Error>(
|
273 | arr: IterableCollection<T>,
|
274 | limit: number,
|
275 | iterator: AsyncIterator<T, E>,
|
276 | ): Promise<void>;
|
277 | export const forEach: typeof each;
|
278 | export const forEachSeries: typeof each;
|
279 | export const forEachLimit: typeof eachLimit;
|
280 | export function forEachOf<T, E = Error>(
|
281 | obj: IterableCollection<T>,
|
282 | iterator: AsyncForEachOfIterator<T, E>,
|
283 | callback: ErrorCallback<E>,
|
284 | ): void;
|
285 | export function forEachOf<T, E = Error>(
|
286 | obj: IterableCollection<T>,
|
287 | iterator: AsyncForEachOfIterator<T, E>,
|
288 | ): Promise<void>;
|
289 | export const forEachOfSeries: typeof forEachOf;
|
290 | export function forEachOfLimit<T, E = Error>(
|
291 | obj: IterableCollection<T>,
|
292 | limit: number,
|
293 | iterator: AsyncForEachOfIterator<T, E>,
|
294 | callback: ErrorCallback<E>,
|
295 | ): void;
|
296 | export function forEachOfLimit<T, E = Error>(
|
297 | obj: IterableCollection<T>,
|
298 | limit: number,
|
299 | iterator: AsyncForEachOfIterator<T, E>,
|
300 | ): Promise<void>;
|
301 | export const eachOf: typeof forEachOf;
|
302 | export const eachOfSeries: typeof forEachOf;
|
303 | export const eachOfLimit: typeof forEachOfLimit;
|
304 | export function map<T, R, E = Error>(
|
305 | arr: IterableCollection<T>,
|
306 | iterator: AsyncResultIterator<T, R, E> | AsyncResultIteratorPromise<T, R>,
|
307 | callback: AsyncResultArrayCallback<R, E>,
|
308 | ): void;
|
309 | export function map<T, R, E = Error>(
|
310 | arr: IterableCollection<T>,
|
311 | iterator: AsyncResultIterator<T, R, E> | AsyncResultIteratorPromise<T, R>,
|
312 | ): Promise<R[]>;
|
313 |
|
314 | export const mapSeries: typeof map;
|
315 | export function mapLimit<T, R, E = Error>(
|
316 | arr: IterableCollection<T>,
|
317 | limit: number,
|
318 | iterator: AsyncResultIterator<T, R, E> | AsyncResultIteratorPromise<T, R>,
|
319 | callback: AsyncResultArrayCallback<R, E>,
|
320 | ): void;
|
321 | export function mapLimit<T, R, E = Error>(
|
322 | arr: IterableCollection<T>,
|
323 | limit: number,
|
324 | iterator: AsyncResultIterator<T, R, E> | AsyncResultIteratorPromise<T, R>,
|
325 | ): Promise<R[]>;
|
326 |
|
327 | export function mapValuesLimit<T, R, E = Error>(
|
328 | obj: Dictionary<T>,
|
329 | limit: number,
|
330 | iteratee: (value: T, key: string, callback: AsyncResultCallback<R, E>) => void,
|
331 | callback: AsyncResultObjectCallback<R, E>,
|
332 | ): void;
|
333 | export function mapValuesLimit<T, R, E = Error>(
|
334 | obj: Dictionary<T>,
|
335 | limit: number,
|
336 | iteratee: (value: T, key: string, callback: AsyncResultCallback<R, E>) => void,
|
337 | ): Promise<R>;
|
338 |
|
339 | export function mapValues<T, R, E = Error>(
|
340 | obj: Dictionary<T>,
|
341 | iteratee: (value: T, key: string, callback: AsyncResultCallback<R, E>) => void,
|
342 | callback: AsyncResultObjectCallback<R, E>,
|
343 | ): void;
|
344 | export function mapValues<T, R, E = Error, C = unknown>(
|
345 | obj: Dictionary<T>,
|
346 | iteratee: (
|
347 | value: T,
|
348 | key: string,
|
349 | callback: C extends undefined ? never : AsyncResultCallback<R, E>,
|
350 | // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
|
351 | ) => C extends undefined ? Promise<R> : void,
|
352 | ): Promise<Dictionary<R>>;
|
353 | export const mapValuesSeries: typeof mapValues;
|
354 | export function filter<T, E = Error>(
|
355 | arr: IterableCollection<T>,
|
356 | iterator: AsyncBooleanIterator<T, E>,
|
357 | callback: AsyncResultArrayCallback<T, E>,
|
358 | ): void;
|
359 | export function filter<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>): Promise<T[]>;
|
360 | export const filterSeries: typeof filter;
|
361 | export function filterLimit<T, E = Error>(
|
362 | arr: IterableCollection<T>,
|
363 | limit: number,
|
364 | iterator: AsyncBooleanIterator<T, E>,
|
365 | callback: AsyncResultArrayCallback<T, E>,
|
366 | ): void;
|
367 | export function filterLimit<T, E = Error>(
|
368 | arr: IterableCollection<T>,
|
369 | limit: number,
|
370 | iterator: AsyncBooleanIterator<T, E>,
|
371 | ): Promise<T[]>;
|
372 | export const select: typeof filter;
|
373 | export const selectSeries: typeof filter;
|
374 | export const selectLimit: typeof filterLimit;
|
375 | export const reject: typeof filter;
|
376 | export const rejectSeries: typeof filter;
|
377 | export const rejectLimit: typeof filterLimit;
|
378 | export function reduce<T, R, E = Error>(
|
379 | arr: T[] | IterableIterator<T>,
|
380 | memo: R,
|
381 | iterator: AsyncMemoIterator<T, R, E>,
|
382 | callback: AsyncResultCallback<R, E>,
|
383 | ): void;
|
384 | export function reduce<T, R, E = Error>(
|
385 | arr: T[] | IterableIterator<T>,
|
386 | memo: R,
|
387 | iterator: AsyncMemoIterator<T, R, E>,
|
388 | ): Promise<R>;
|
389 | export const inject: typeof reduce;
|
390 | export const foldl: typeof reduce;
|
391 | export const reduceRight: typeof reduce;
|
392 | export const foldr: typeof reduce;
|
393 | export function detect<T, E = Error>(
|
394 | arr: IterableCollection<T>,
|
395 | iterator: AsyncBooleanIterator<T, E>,
|
396 | callback: AsyncResultCallback<T, E>,
|
397 | ): void;
|
398 | export function detect<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>): Promise<T>;
|
399 | export const detectSeries: typeof detect;
|
400 | export function detectLimit<T, E = Error>(
|
401 | arr: IterableCollection<T>,
|
402 | limit: number,
|
403 | iterator: AsyncBooleanIterator<T, E>,
|
404 | callback: AsyncResultCallback<T, E>,
|
405 | ): void;
|
406 | export function detectLimit<T, E = Error>(
|
407 | arr: IterableCollection<T>,
|
408 | limit: number,
|
409 | iterator: AsyncBooleanIterator<T, E>,
|
410 | ): Promise<T>;
|
411 | export const find: typeof detect;
|
412 | export const findSeries: typeof detect;
|
413 | export const findLimit: typeof detectLimit;
|
414 | export function sortBy<T, V, E = Error>(
|
415 | arr: T[] | IterableIterator<T>,
|
416 | iterator: AsyncResultIterator<T, V, E>,
|
417 | callback: AsyncResultArrayCallback<T, E>,
|
418 | ): void;
|
419 | export function sortBy<T, V, E = Error>(
|
420 | arr: T[] | IterableIterator<T>,
|
421 | iterator: AsyncResultIterator<T, V, E>,
|
422 | ): Promise<T[]>;
|
423 | export function some<T, E = Error>(
|
424 | arr: IterableCollection<T>,
|
425 | iterator: AsyncBooleanIterator<T, E>,
|
426 | callback: AsyncBooleanResultCallback<E>,
|
427 | ): void;
|
428 | export function some<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>): Promise<boolean>;
|
429 | export const someSeries: typeof some;
|
430 | export function someLimit<T, E = Error>(
|
431 | arr: IterableCollection<T>,
|
432 | limit: number,
|
433 | iterator: AsyncBooleanIterator<T, E>,
|
434 | callback?: AsyncBooleanResultCallback<E>,
|
435 | ): void;
|
436 | export const any: typeof some;
|
437 | export const anySeries: typeof someSeries;
|
438 | export const anyLimit: typeof someLimit;
|
439 | export function every<T, E = Error>(
|
440 | arr: IterableCollection<T>,
|
441 | iterator: AsyncBooleanIterator<T, E>,
|
442 | callback: AsyncBooleanResultCallback<E>,
|
443 | ): void;
|
444 | export function every<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>): Promise<boolean>;
|
445 | export const everySeries: typeof every;
|
446 | export function everyLimit<T, E = Error>(
|
447 | arr: IterableCollection<T>,
|
448 | limit: number,
|
449 | iterator: AsyncBooleanIterator<T, E>,
|
450 | callback: AsyncBooleanResultCallback<E>,
|
451 | ): void;
|
452 | export function everyLimit<T, E = Error>(
|
453 | arr: IterableCollection<T>,
|
454 | limit: number,
|
455 | iterator: AsyncBooleanIterator<T, E>,
|
456 | ): Promise<boolean>;
|
457 | export const all: typeof every;
|
458 | export const allSeries: typeof every;
|
459 | export const allLimit: typeof everyLimit;
|
460 |
|
461 | export function concat<T, R, E = Error>(
|
462 | arr: IterableCollection<T>,
|
463 | iterator: AsyncResultIterator<T, R[], E>,
|
464 | callback: AsyncResultArrayCallback<R, E>,
|
465 | ): void;
|
466 | export function concat<T, R, E = Error>(
|
467 | arr: IterableCollection<T>,
|
468 | iterator: AsyncResultIterator<T, R[], E>,
|
469 | ): Promise<R[]>;
|
470 | export function concatLimit<T, R, E = Error>(
|
471 | arr: IterableCollection<T>,
|
472 | limit: number,
|
473 | iterator: AsyncResultIterator<T, R[], E>,
|
474 | callback: AsyncResultArrayCallback<R, E>,
|
475 | ): void;
|
476 | export function concatLimit<T, R, E = Error>(
|
477 | arr: IterableCollection<T>,
|
478 | limit: number,
|
479 | iterator: AsyncResultIterator<T, R[], E>,
|
480 | ): Promise<R[]>;
|
481 | export const concatSeries: typeof concat;
|
482 | export const flatMap: typeof concat;
|
483 | export const flatMapLimit: typeof concatLimit;
|
484 | export const flatMapSeries: typeof concatSeries;
|
485 |
|
486 | export function groupBy<T, K, E = Error>(
|
487 | iterable: IterableCollection<T>,
|
488 | iterator: AsyncResultIterator<T, K, E>,
|
489 | callback: AsyncResultCallback<Record<string, T[]>, E>,
|
490 | ): void;
|
491 | export function groupBy<T, K, E = Error>(
|
492 | iterable: IterableCollection<T>,
|
493 | iterator: AsyncResultIterator<T, K, E>,
|
494 | ): Promise<Record<string, T[]>>;
|
495 | export function groupByLimit<T, K, E = Error>(
|
496 | iterable: IterableCollection<T>,
|
497 | limit: number,
|
498 | iterator: AsyncResultIterator<T, K, E>,
|
499 | callback: AsyncResultCallback<Record<string, T[]>, E>,
|
500 | ): void;
|
501 | export function groupByLimit<T, K, E = Error>(
|
502 | iterable: IterableCollection<T>,
|
503 | limit: number,
|
504 | iterator: AsyncResultIterator<T, K, E>,
|
505 | ): Promise<Record<string, T[]>>;
|
506 | export const groupBySeries: typeof groupBy;
|
507 |
|
508 |
|
509 | export function series<T, E = Error>(tasks: Array<AsyncFunction<T, E>>, callback: AsyncResultArrayCallback<T, E>): void;
|
510 | export function series<T, E = Error>(
|
511 | tasks: Dictionary<AsyncFunction<T, E>>,
|
512 | callback: AsyncResultObjectCallback<T, E>,
|
513 | ): void;
|
514 | export function series<T, E = Error>(tasks: Array<AsyncFunction<T, E>>): Promise<T[]>;
|
515 | export function series<T, E = Error>(tasks: Dictionary<AsyncFunction<T, E>>): Promise<Dictionary<T>>;
|
516 | export function parallel<T, E = Error>(
|
517 | tasks: Array<AsyncFunction<T, E>>,
|
518 | callback: AsyncResultArrayCallback<T, E>,
|
519 | ): void;
|
520 | export function parallel<T, E = Error>(
|
521 | tasks: Dictionary<AsyncFunction<T, E>>,
|
522 | callback: AsyncResultObjectCallback<T, E>,
|
523 | ): void;
|
524 | export function parallel<T, R, E = Error>(
|
525 | tasks: Array<AsyncFunction<T, E>> | Dictionary<AsyncFunction<T, E>>,
|
526 | ): Promise<R>;
|
527 | export function parallelLimit<T, E = Error>(
|
528 | tasks: Array<AsyncFunction<T, E>>,
|
529 | limit: number,
|
530 | callback: AsyncResultArrayCallback<T, E>,
|
531 | ): void;
|
532 | export function parallelLimit<T, E = Error>(
|
533 | tasks: Dictionary<AsyncFunction<T, E>>,
|
534 | limit: number,
|
535 | callback: AsyncResultObjectCallback<T, E>,
|
536 | ): void;
|
537 | export function parallelLimit<T, R, E = Error>(
|
538 | tasks: Array<AsyncFunction<T, E>> | Dictionary<AsyncFunction<T, E>>,
|
539 | limit: number,
|
540 | ): Promise<R>;
|
541 |
|
542 | export function whilst<T, E = Error>(
|
543 | test: (cb: AsyncBooleanResultCallback) => void,
|
544 | fn: AsyncFunctionEx<T, E>,
|
545 | callback: AsyncResultRestCallback<T, E>,
|
546 | ): void;
|
547 | export function whilst<T, R, E = Error>(
|
548 | test: (cb: AsyncBooleanResultCallback) => void,
|
549 | fn: AsyncFunctionEx<T, E>,
|
550 | ): Promise<R>;
|
551 | export function doWhilst<T, E = Error>(
|
552 | fn: AsyncFunctionEx<T, E>,
|
553 | test: (/* ...results: T[], */ cb: AsyncBooleanResultCallback) => void,
|
554 | callback: AsyncResultRestCallback<T, E>,
|
555 | ): void;
|
556 | export function doWhilst<T, R, E = Error>(
|
557 | fn: AsyncFunctionEx<T, E>,
|
558 | test: (/* ...results: T[], */ cb: AsyncBooleanResultCallback) => void,
|
559 | ): Promise<R>;
|
560 | export function until<T, E = Error>(
|
561 | test: (cb: AsyncBooleanResultCallback) => void,
|
562 | fn: AsyncFunctionEx<T, E>,
|
563 | callback: AsyncResultRestCallback<T, E>,
|
564 | ): void;
|
565 | export function until<T, R, E = Error>(
|
566 | test: (cb: AsyncBooleanResultCallback) => void,
|
567 | fn: AsyncFunctionEx<T, E>,
|
568 | ): Promise<R>;
|
569 | export function doUntil<T, E = Error>(
|
570 | fn: AsyncFunctionEx<T, E>,
|
571 | test: (/* ...results: T[], */ cb: AsyncBooleanResultCallback) => void,
|
572 | callback: AsyncResultRestCallback<T, E>,
|
573 | ): void;
|
574 | export function doUntil<T, R, E = Error>(
|
575 | fn: AsyncFunctionEx<T, E>,
|
576 | test: (/* ...results: T[], */ cb: AsyncBooleanResultCallback) => void,
|
577 | ): Promise<R>;
|
578 |
|
579 | export function during<E = Error>(
|
580 | test: (testCallback: AsyncBooleanResultCallback<E>) => void,
|
581 | fn: AsyncVoidFunction<E>,
|
582 | callback: ErrorCallback<E>,
|
583 | ): void;
|
584 | export function doDuring<E = Error>(
|
585 | fn: AsyncVoidFunction<E>,
|
586 | test: (testCallback: AsyncBooleanResultCallback<E>) => void,
|
587 | callback: ErrorCallback<E>,
|
588 | ): void;
|
589 | export function forever<E = Error>(next: (next: ErrorCallback<E>) => void, errBack: ErrorCallback<E>): void;
|
590 | export function waterfall<T>(tasks: Function[]): Promise<T>;
|
591 | export function waterfall<T, E = Error>(tasks: Function[], callback: AsyncResultCallback<T, E>): void;
|
592 | export function compose(...fns: Function[]): Function;
|
593 | export function seq(...fns: Function[]): Function;
|
594 | export function applyEach(fns: Function[], ...argsAndCallback: any[]): void;
|
595 | export function applyEachSeries(fns: Function[], ...argsAndCallback: any[]): void;
|
596 | export function queue<T, E = Error>(worker: AsyncWorker<T, E>, concurrency?: number): QueueObject<T>;
|
597 | export function queue<T, R, E = Error>(worker: AsyncResultIterator<T, R, E>, concurrency?: number): QueueObject<T>;
|
598 | export function priorityQueue<T, E = Error>(worker: AsyncWorker<T, E>, concurrency?: number): AsyncPriorityQueue<T>;
|
599 | export function cargo<T, E = Error>(worker: AsyncWorker<T[], E>, payload?: number): QueueObject<T>;
|
600 | export function cargoQueue<T, E = Error>(
|
601 | worker: AsyncWorker<T[], E>,
|
602 | concurrency?: number,
|
603 | payload?: number,
|
604 | ): QueueObject<T>;
|
605 | export function auto<R extends Dictionary<any>, E = Error>(
|
606 | tasks: AsyncAutoTasks<R, E>,
|
607 | concurrency?: number,
|
608 | ): Promise<R>;
|
609 | export function auto<R extends Dictionary<any>, E = Error>(
|
610 | tasks: AsyncAutoTasks<R, E>,
|
611 | concurrency: number,
|
612 | callback: AsyncResultCallback<R, E>,
|
613 | ): void;
|
614 | export function auto<R extends Dictionary<any>, E = Error>(
|
615 | tasks: AsyncAutoTasks<R, E>,
|
616 | callback: AsyncResultCallback<R, E>,
|
617 | ): void;
|
618 | export function autoInject<E = Error>(tasks: any, callback?: AsyncResultCallback<any, E>): void;
|
619 |
|
620 | export interface RetryOptions<E> {
|
621 | times?: number | undefined;
|
622 | interval?: number | ((retryCount: number) => number) | undefined;
|
623 | errorFilter?: ((error: E) => boolean) | undefined;
|
624 | }
|
625 | export function retry<T, E = Error>(
|
626 | task: (() => Promise<T>) | ((callback: AsyncResultCallback<T, E>) => void),
|
627 | ): Promise<T>;
|
628 | export function retry<T, E = Error>(
|
629 | opts: number | RetryOptions<E>,
|
630 | task: (() => Promise<T>) | ((callback: AsyncResultCallback<T, E>) => void),
|
631 | ): Promise<T>;
|
632 | export function retry<T, E = Error>(
|
633 | task: (() => Promise<T>) | ((callback: AsyncResultCallback<T, E>) => void),
|
634 | callback: AsyncResultCallback<T, E>,
|
635 | ): void;
|
636 | export function retry<T, E = Error>(
|
637 | opts: number | RetryOptions<E>,
|
638 | task: (() => Promise<T>) | ((callback: AsyncResultCallback<T, E>) => void),
|
639 | callback: AsyncResultCallback<T, E>,
|
640 | ): void;
|
641 |
|
642 | export function retryable<T, E = Error>(task: AsyncFunction<T, E>): AsyncFunction<T, E>;
|
643 | export function retryable<T, E = Error>(
|
644 | opts: number | (RetryOptions<E> & { arity?: number | undefined }),
|
645 | task: AsyncFunction<T, E>,
|
646 | ): AsyncFunction<T, E>;
|
647 | export function apply<E = Error>(fn: Function, ...args: any[]): AsyncFunction<any, E>;
|
648 | export function nextTick(callback: Function, ...args: any[]): void;
|
649 | export const setImmediate: typeof nextTick;
|
650 |
|
651 | export function reflect<T, E = Error>(
|
652 | fn: AsyncFunction<T, E>,
|
653 | ): (callback: (err: null, result: { error?: E | undefined; value?: T | undefined }) => void) => void;
|
654 | export function reflectAll<T, E = Error>(
|
655 | tasks: Array<AsyncFunction<T, E>>,
|
656 | ): Array<(callback: (err: null, result: { error?: E | undefined; value?: T | undefined }) => void) => void>;
|
657 |
|
658 | export function timeout<T, E = Error>(fn: AsyncFunction<T, E>, milliseconds: number, info?: any): AsyncFunction<T, E>;
|
659 | export function timeout<T, R, E = Error>(
|
660 | fn: AsyncResultIterator<T, R, E>,
|
661 | milliseconds: number,
|
662 | info?: any,
|
663 | ): AsyncResultIterator<T, R, E>;
|
664 |
|
665 | export function times<T, E = Error>(
|
666 | n: number,
|
667 | iterator: AsyncResultIterator<number, T, E> | AsyncResultIteratorPromise<number, T>,
|
668 | callback: AsyncResultArrayCallback<T, E>,
|
669 | ): void;
|
670 | export function times<T, E = Error>(
|
671 | n: number,
|
672 | iterator: AsyncResultIterator<number, T, E> | AsyncResultIteratorPromise<number, T>,
|
673 | ): Promise<T>;
|
674 |
|
675 | export const timesSeries: typeof times;
|
676 | export function timesLimit<T, E = Error>(
|
677 | n: number,
|
678 | limit: number,
|
679 | iterator: AsyncResultIterator<number, T, E> | AsyncResultIteratorPromise<number, T>,
|
680 | callback: AsyncResultArrayCallback<T, E>,
|
681 | ): void;
|
682 | export function timesLimit<T, E = Error>(
|
683 | n: number,
|
684 | limit: number,
|
685 | iterator: AsyncResultIterator<number, T, E> | AsyncResultIteratorPromise<number, T>,
|
686 | ): Promise<T>;
|
687 |
|
688 | export function transform<T, R, E = Error>(
|
689 | arr: T[],
|
690 | iteratee: (acc: R[], item: T, key: number, callback: (error?: E) => void) => void,
|
691 | callback?: AsyncResultArrayCallback<T, E>,
|
692 | ): void;
|
693 | export function transform<T, R, E = Error>(
|
694 | arr: T[],
|
695 | acc: R[],
|
696 | iteratee: (acc: R[], item: T, key: number, callback: (error?: E) => void) => void,
|
697 | callback?: AsyncResultArrayCallback<T, E>,
|
698 | ): void;
|
699 |
|
700 | export function transform<T, R, E = Error>(
|
701 | arr: { [key: string]: T },
|
702 | iteratee: (acc: { [key: string]: R }, item: T, key: string, callback: (error?: E) => void) => void,
|
703 | callback?: AsyncResultObjectCallback<T, E>,
|
704 | ): void;
|
705 |
|
706 | export function transform<T, R, E = Error>(
|
707 | arr: { [key: string]: T },
|
708 | acc: { [key: string]: R },
|
709 | iteratee: (acc: { [key: string]: R }, item: T, key: string, callback: (error?: E) => void) => void,
|
710 | callback?: AsyncResultObjectCallback<T, E>,
|
711 | ): void;
|
712 |
|
713 | export function race<T, E = Error>(tasks: Array<AsyncFunction<T, E>>, callback: AsyncResultCallback<T, E>): void;
|
714 |
|
715 | export function tryEach<T, E = Error>(
|
716 | tasks: IterableCollection<AsyncFunction<T>>,
|
717 | callback: AsyncResultCallback<T, E>,
|
718 | ): void;
|
719 | export function tryEach<T>(tasks: IterableCollection<AsyncFunction<T>>): Promise<T>;
|
720 |
|
721 |
|
722 | export function memoize(fn: Function, hasher?: Function): Function;
|
723 | export function unmemoize(fn: Function): Function;
|
724 | export function ensureAsync(fn: (...argsAndCallback: any[]) => void): Function;
|
725 | export function constant(...values: any[]): AsyncFunction<any>;
|
726 | export function asyncify(fn: Function): (...args: any[]) => any;
|
727 | export function wrapSync(fn: Function): Function;
|
728 | export function log(fn: Function, ...args: any[]): void;
|
729 | export function dir(fn: Function, ...args: any[]): void;
|