From eadbc0cd3badb6f402d66311b171e57d860f0b84 Mon Sep 17 00:00:00 2001
From: Erik Krogh Kristensen <erik@webbies.dk>
Date: Mon, 6 Mar 2017 15:32:29 +0100
Subject: [PATCH] async: Various fixes, mostly related to strict-nulls. Also
 some places where the error type was wrong.

---
 async/index.d.ts | 34 ++++++++++++++++------------------
 1 file changed, 16 insertions(+), 18 deletions(-)

diff --git a/async/index.d.ts b/async/index.d.ts
index e3fbe7e512..7f71f3b9bc 100644
--- a/async/index.d.ts
+++ b/async/index.d.ts
@@ -6,17 +6,16 @@
 interface Dictionary<T> { [key: string]: T; }
 
 interface ErrorCallback<T> { (err?: T): void; }
-interface AsyncWaterfallCallback<E> { (err: E, ...args: any[]): void; }
-interface AsyncBooleanResultCallback<E> { (err: E, truthValue: boolean): void; }
-interface AsyncResultCallback<T, E> { (err: E, result: T): void; }
-interface AsyncResultArrayCallback<T, E> { (err: E, results: T[]): void; }
-interface AsyncResultObjectCallback<T, E> { (err: E, results: Dictionary<T>): void; }
+interface AsyncBooleanResultCallback<E> { (err?: E, truthValue?: boolean): void; }
+interface AsyncResultCallback<T, E> { (err?: E, result?: T): void; }
+interface AsyncResultArrayCallback<T, E> { (err?: E, results?: (T | undefined)[]): void; }
+interface AsyncResultObjectCallback<T, E> { (err: E | undefined, results: Dictionary<T>): void; }
 
-interface AsyncFunction<T, E> { (callback: (err?: E, result?: T) => void): void; }
+interface AsyncFunction<T, E> { (callback: (err?: E, result?: T) => void): any; }
 interface AsyncIterator<T, E> { (item: T, callback: ErrorCallback<E>): void; }
 interface AsyncForEachOfIterator<T, E> { (item: T, key: number|string, callback: ErrorCallback<E>): void; }
 interface AsyncResultIterator<T, R, E> { (item: T, callback: AsyncResultCallback<R, E>): void; }
-interface AsyncMemoIterator<T, R, E> { (memo: R, item: T, callback: AsyncResultCallback<R, E>): void; }
+interface AsyncMemoIterator<T, R, E> { (memo: R | undefined, item: T, callback: AsyncResultCallback<R, E>): void; }
 interface AsyncBooleanIterator<T, E> { (item: T, callback: AsyncBooleanResultCallback<E>): void; }
 
 interface AsyncWorker<T, E> { (task: T, callback: ErrorCallback<E>): void; }
@@ -76,7 +75,7 @@ interface AsyncPriorityQueue<T> {
 
 interface AsyncCargo {
     length(): number;
-    payload: number;
+    payload?: number;
     push(task: any, callback? : Function): void;
     push(task: any[], callback? : Function): void;
     saturated(): void;
@@ -186,25 +185,25 @@ interface Async {
     cargo<E>(worker : (tasks: any[], callback : ErrorCallback<E>) => void, payload? : number) : AsyncCargo;
     auto<E>(tasks: any, concurrency?: number, callback?: AsyncResultCallback<any, E>): void;
     autoInject<E>(tasks: any, callback?: AsyncResultCallback<any, E>): void;
-    retry<T, E>(opts: number, task: (callback : AsyncResultCallback<T, E>, results: any) => void, callback:  AsyncResultCallback<any, E>): void;
-    retry<T, E>(opts: { times: number, interval: number|((retryCount: number) => number) }, task: (callback: AsyncResultCallback<T, E>, results : any) => void, callback:  AsyncResultCallback<any, E>): void;
-    retryable<T, E>(opts: number | {times: number, interval: number}, task: AsyncFunction<T, E>): AsyncFunction<T, E>;
-    apply<E>(fn: Function, ...arguments: any[]): AsyncFunction<any,E>;
+    retry<T, E>(opts: number, task: (callback : AsyncResultCallback<T, E>, results: any) => void, callback:  AsyncResultCallback<any, E | Error>): void;
+    retry<T, E>(opts: { times: number, interval: number|((retryCount: number) => number) }, task: (callback: AsyncResultCallback<T, E>, results : any) => void, callback:  AsyncResultCallback<any, E | Error>): void;
+    retryable<T, E>(opts: number | {times: number, interval: number}, task: AsyncFunction<T, E>): AsyncFunction<T, E | Error>;
+    apply<E>(fn: Function, ...arguments: any[]): AsyncFunction<any,E | Error>;
     nextTick(callback: Function, ...args: any[]): void;
     setImmediate: typeof async.nextTick;
 
-    reflect<T, E>(fn: AsyncFunction<T, E>) : (callback: (err: void, result: {error?: Error, value?: T}) => void) => void;
-    reflectAll<T, E>(tasks: AsyncFunction<T, E>[]): ((callback: (err: void, result: {error?: Error, value?: T}) => void) => void)[];
+    reflect<T, E>(fn: AsyncFunction<T, E>) : (callback: (err: null, result: {error?: E, value?: T}) => void) => void;
+    reflectAll<T, E>(tasks: AsyncFunction<T, E>[]): ((callback: (err: undefined, result: {error?: E, value?: T}) => void) => void)[];
 
-    timeout<T, E>(fn: AsyncFunction<T, E>, milliseconds: number, info?: any): AsyncFunction<T, E>;
-    timeout<T, R, E>(fn: AsyncResultIterator<T, R, E>, milliseconds: number, info?: any): AsyncResultIterator<T, R, E>;
+    timeout<T, E>(fn: AsyncFunction<T, E>, milliseconds: number, info?: any): AsyncFunction<T, E | Error>;
+    timeout<T, R, E>(fn: AsyncResultIterator<T, R, E>, milliseconds: number, info?: any): AsyncResultIterator<T, R, E | Error>;
 
     times<T, E> (n: number, iterator: AsyncResultIterator<number, T, E>, callback: AsyncResultArrayCallback<T, E>): void;
     timesSeries<T, E>(n: number, iterator: AsyncResultIterator<number, T, E>, callback: AsyncResultArrayCallback<T, E>): void;
     timesLimit<T, E>(n: number, limit: number, iterator: AsyncResultIterator<number, T, E>, callback: AsyncResultArrayCallback<T, E>): void;
 
     transform<T, R, E>(arr: T[], iteratee: (acc: R[], item: T, key: string, callback: (error?: E) => void) => void): void;
-    transform<T, R, E>(arr: T[], acc: R[], iteratee: (acc: R[], item: T, key: string, callback: (error?: E) => void) => void): void;
+    transform<T, R, E>(arr: T[], acc: R[], iteratee: (acc: R[] | null, item: T | undefined[], key?: string, callback?: (error?: E) => void) => void): void;
     transform<T, R, E>(arr: {[key: string] : T}, iteratee: (acc: {[key: string] : R}, item: T, key: string, callback: (error?: E) => void) => void): void;
     transform<T, R, E>(arr: {[key: string] : T}, acc: {[key: string] : R}, iteratee: (acc: {[key: string] : R}, item: T, key: string, callback: (error?: E) => void) => void): void;
 
@@ -226,4 +225,3 @@ declare var async: Async;
 declare module "async" {
     export = async;
 }
-