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