@types/async 3.2.8 → 3.2.12

async/README.md

@@ -8,9 +8,9 @@ This package contains type definitions for Async (https://github.com/caolan/asyn
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/async.
 
 ### Additional Details
- * Last updated: Sat, 18 Sep 2021 09:31:20 GMT
+ * Last updated: Sun, 26 Dec 2021 12:01:22 GMT
  * Dependencies: none
  * Global values: `async`
 
 # Credits
-These definitions were written by [Boris Yankov](https://github.com/borisyankov), [Arseniy Maximov](https://github.com/kern0), [Joe Herman](https://github.com/Penryn), [Angus Fenying](https://github.com/fenying), [Pascal Martin](https://github.com/pascalmartin), [Dmitri Trofimov](https://github.com/Dmitri1337), [Etienne Rossignon](https://github.com/erossignon), [Lifeng Zhu](https://github.com/Juliiii), and [Tümay Çeber](https://github.com/brendtumi).
+These definitions were written by [Boris Yankov](https://github.com/borisyankov), [Arseniy Maximov](https://github.com/kern0), [Joe Herman](https://github.com/Penryn), [Angus Fenying](https://github.com/fenying), [Pascal Martin](https://github.com/pascalmartin), [Etienne Rossignon](https://github.com/erossignon), [Lifeng Zhu](https://github.com/Juliiii), [Tümay Çeber](https://github.com/brendtumi), and [Andrew Pensinger](https://github.com/apnsngr).

async/index.d.ts

@@ -5,10 +5,10 @@
 //                 Joe Herman <https://github.com/Penryn>
 //                 Angus Fenying <https://github.com/fenying>
 //                 Pascal Martin <https://github.com/pascalmartin>
-//                 Dmitri Trofimov <https://github.com/Dmitri1337>
 //                 Etienne Rossignon <https://github.com/erossignon>
 //                 Lifeng Zhu <https://github.com/Juliiii>
 //                 Tümay Çeber <https://github.com/brendtumi>
+//                 Andrew Pensinger <https://github.com/apnsngr>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.3
 
@@ -28,6 +28,7 @@ export interface AsyncFunctionEx<T, E = Error> { (callback: (err?: E | null, ...
 export interface AsyncIterator<T, E = Error> { (item: T, callback: ErrorCallback<E>): void; }
 export interface AsyncForEachOfIterator<T, E = Error> { (item: T, key: number|string, callback: ErrorCallback<E>): void; }
 export interface AsyncResultIterator<T, R, E = Error> { (item: T, callback: AsyncResultCallback<R, E>): void; }
+export interface AsyncResultIteratorPromise<T, R> { (item: T): Promise<R>; }
 export interface AsyncMemoIterator<T, R, E = Error> { (memo: R | undefined, item: T, callback: AsyncResultCallback<R, E>): void; }
 export interface AsyncBooleanIterator<T, E = Error> { (item: T, callback: AsyncBooleanResultCallback<E>): void; }
 
@@ -244,11 +245,26 @@ export function forEachOfLimit<T, E = Error>(obj: IterableCollection<T>, limit:
 export const eachOf: typeof forEachOf;
 export const eachOfSeries: typeof forEachOf;
 export const eachOfLimit: typeof forEachOfLimit;
-export function map<T, R, E = Error>(arr: T[] | IterableIterator<T> | Dictionary<T>, iterator: AsyncResultIterator<T, R, E>, callback: AsyncResultArrayCallback<R, E>): void;
-export function map<T, R, E = Error>(arr: T[] | IterableIterator<T> | Dictionary<T>, iterator: AsyncResultIterator<T, R, E>): Promise<R[]>;
+export function map<T, R, E = Error>(
+    arr: T[] | IterableIterator<T> | Dictionary<T>,
+    iterator: (AsyncResultIterator<T, R, E> | AsyncResultIteratorPromise<T, R>),
+    callback: AsyncResultArrayCallback<R, E>
+    ): void;
+export function map<T, R, E = Error>(
+    arr: T[] | IterableIterator<T> | Dictionary<T>,
+    iterator: (AsyncResultIterator<T, R, E> | AsyncResultIteratorPromise<T, R>)
+    ): Promise<R[]>;
+
 export const mapSeries: typeof map;
-export function mapLimit<T, R, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncResultIterator<T, R, E>, callback: AsyncResultArrayCallback<R, E>): void;
-export function mapLimit<T, R, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncResultIterator<T, R, E>): Promise<R[]>;
+export function mapLimit<T, R, E = Error>(
+    arr: IterableCollection<T>,
+    limit: number, iterator: (AsyncResultIterator<T, R, E> | AsyncResultIteratorPromise<T, R>),
+    callback: AsyncResultArrayCallback<R, E>
+    ): void;
+export function mapLimit<T, R, E = Error>(
+    arr: IterableCollection<T>,
+    limit: number, iterator: (AsyncResultIterator<T, R, E> | AsyncResultIteratorPromise<T, R>)
+    ): Promise<R[]>;
 
 export function mapValuesLimit<T, R, E = Error>(
     obj: Dictionary<T>,
@@ -302,7 +318,8 @@ export const allSeries: typeof every;
 export const allLimit: typeof everyLimit;
 
 export function concat<T, R, E = Error>(arr: IterableCollection<T>, iterator: AsyncResultIterator<T, R[], E>, callback?: AsyncResultArrayCallback<R, E>): void;
-export function concatLimit<T, R, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncResultIterator<T, R[], E>, callback?: AsyncResultArrayCallback<R, E>): void;
+export function concatLimit<T, R, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncResultIterator<T, R[], E>, callback: AsyncResultArrayCallback<R, E>): void;
+export function concatLimit<T, R, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncResultIterator<T, R[], E>): Promise<R[]>;
 export const concatSeries: typeof concat;
 
 // Control Flow
@@ -315,14 +332,44 @@ export function parallel<T, R, E = Error>(tasks: Array<AsyncFunction<T, E>> | Di
 export function parallelLimit<T, E = Error>(tasks: Array<AsyncFunction<T, E>>, limit: number, callback?: AsyncResultArrayCallback<T, E>): void;
 export function parallelLimit<T, E = Error>(tasks: Dictionary<AsyncFunction<T, E>>, limit: number, callback?: AsyncResultObjectCallback<T, E>): void;
 export function parallelLimit<T, R, E = Error>(tasks: Array<AsyncFunction<T, E>> | Dictionary<AsyncFunction<T, E>>, limit: number): Promise<R>;
-export function whilst<E = Error>(test: (cb: (err: any, truth: boolean) => boolean) => boolean, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
-export function whilst<R, E = Error>(test: (cb: (err: any, truth: boolean) => boolean) => boolean, fn: AsyncVoidFunction<E>): Promise<R>;
-export function doWhilst<T, E = Error>(fn: AsyncFunctionEx<T, E>, test: (...results: T[]) => boolean, callback: ErrorCallback<E>): void;
-export function doWhilst<T, R, E = Error>(fn: AsyncFunctionEx<T, E>, test: (...results: T[]) => boolean): Promise<R>;
-export function until<E = Error>(test: () => boolean, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
-export function until<R, E = Error>(test: () => boolean, fn: AsyncVoidFunction<E>): Promise<R>;
-export function doUntil<T, E = Error>(fn: AsyncFunctionEx<T, E>, test: (...results: T[]) => boolean, callback: ErrorCallback<E>): void;
-export function doUntil<T, R, E = Error>(fn: AsyncFunctionEx<T, E>, test: (...results: T[]) => boolean): Promise<R>;
+
+export function whilst<T, E = Error>(
+    test: (cb: AsyncBooleanResultCallback) => void,
+    fn: AsyncFunctionEx<T, E>,
+    callback: AsyncFunctionEx<T, E>
+): void;
+export function whilst<T, R, E = Error>(
+    test: (cb: AsyncBooleanResultCallback) => void,
+    fn: AsyncFunctionEx<T, E>
+): Promise<R>;
+export function doWhilst<T, E = Error>(
+    fn: AsyncFunctionEx<T, E>,
+    test: (/* ...results: T[], */ cb: AsyncBooleanResultCallback) => void,
+    callback: AsyncFunctionEx<T, E>
+): void;
+export function doWhilst<T, R, E = Error>(
+    fn: AsyncFunctionEx<T, E>,
+    test: (/* ...results: T[], */ cb: AsyncBooleanResultCallback) => void
+): Promise<R>;
+export function until<T, E = Error>(
+    test: (cb: AsyncBooleanResultCallback) => void,
+    fn: AsyncFunctionEx<T, E>,
+    callback: AsyncFunctionEx<T, E>
+): void;
+export function until<T, R, E = Error>(
+    test: (cb: AsyncBooleanResultCallback) => void,
+    fn: AsyncFunctionEx<T, E>
+): Promise<R>;
+export function doUntil<T, E = Error>(
+    fn: AsyncFunctionEx<T, E>,
+    test: (/* ...results: T[], */ cb: AsyncBooleanResultCallback) => void,
+    callback: AsyncFunctionEx<T, E>
+): void;
+export function doUntil<T, R, E = Error>(
+    fn: AsyncFunctionEx<T, E>,
+    test: (/* ...results: T[], */ cb: AsyncBooleanResultCallback) => void
+): Promise<R>;
+
 export function during<E = Error>(test: (testCallback: AsyncBooleanResultCallback<E>) => void, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
 export function doDuring<E = Error>(fn: AsyncVoidFunction<E>, test: (testCallback: AsyncBooleanResultCallback<E>) => void, callback: ErrorCallback<E>): void;
 export function forever<E = Error>(next: (next: ErrorCallback<E>) => void, errBack: ErrorCallback<E>): void;
@@ -382,11 +429,21 @@ export function reflectAll<T, E = Error>(tasks: Array<AsyncFunction<T, E>>): Arr
 export function timeout<T, E = Error>(fn: AsyncFunction<T, E>, milliseconds: number, info?: any): AsyncFunction<T, E>;
 export function timeout<T, R, E = Error>(fn: AsyncResultIterator<T, R, E>, milliseconds: number, info?: any): AsyncResultIterator<T, R, E>;
 
-export function times<T, E = Error>(n: number, iterator: AsyncResultIterator<number, T, E>, callback: AsyncResultArrayCallback<T, E>): void;
-export function times<T, E = Error>(n: number, iterator: AsyncResultIterator<number, T, E>): Promise<T>;
+export function times<T, E = Error>(n: number, iterator: (AsyncResultIterator<number, T, E> | AsyncResultIteratorPromise<number, T>), callback: AsyncResultArrayCallback<T, E>): void;
+export function times<T, E = Error>(n: number, iterator: (AsyncResultIterator<number, T, E> | AsyncResultIteratorPromise<number, T>)): Promise<T>;
+
 export const timesSeries: typeof times;
-export function timesLimit<T, E = Error>(n: number, limit: number, iterator: AsyncResultIterator<number, T, E>, callback: AsyncResultArrayCallback<T, E>): void;
-export function timesLimit<T, E = Error>(n: number, limit: number, iterator: AsyncResultIterator<number, T, E>): Promise<T>;
+export function timesLimit<T, E = Error>(
+    n: number,
+    limit: number,
+    iterator: (AsyncResultIterator<number, T, E> | AsyncResultIteratorPromise<number, T>),
+    callback: AsyncResultArrayCallback<T, E>
+    ): void;
+export function timesLimit<T, E = Error>(
+    n: number,
+    limit: number,
+    iterator: (AsyncResultIterator<number, T, E> | AsyncResultIteratorPromise<number, T>)
+    ): Promise<T>;
 
 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;
 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;

async/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/async",
-    "version": "3.2.8",
+    "version": "3.2.12",
     "description": "TypeScript definitions for Async",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/async",
     "license": "MIT",
@@ -30,11 +30,6 @@
             "url": "https://github.com/pascalmartin",
             "githubUsername": "pascalmartin"
         },
-        {
-            "name": "Dmitri Trofimov",
-            "url": "https://github.com/Dmitri1337",
-            "githubUsername": "Dmitri1337"
-        },
         {
             "name": "Etienne Rossignon",
             "url": "https://github.com/erossignon",
@@ -49,6 +44,11 @@
             "name": "Tümay Çeber",
             "url": "https://github.com/brendtumi",
             "githubUsername": "brendtumi"
+        },
+        {
+            "name": "Andrew Pensinger",
+            "url": "https://github.com/apnsngr",
+            "githubUsername": "apnsngr"
         }
     ],
     "main": "",
@@ -60,6 +60,6 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "3f35b238c96275a2c048c3cb20dc43836163366b79ac6be29293d6c83bbbafdf",
-    "typeScriptVersion": "3.7"
+    "typesPublisherContentHash": "a14b6ee9ce4edbdcc61a907887cacbfbbd4e0f6ec63b045475e37be787ce4e65",
+    "typeScriptVersion": "3.8"
 }