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