mirror of
https://github.com/gosticks/DefinitelyTyped.git
synced 2026-07-01 15:50:13 +00:00
[async] Default E to Error and add auto polymorphism for optional arg (#29825)
* feat(async): default callback error to Error type * feat(async): polymorph auto method
This commit is contained in:
Marc Ghorayeb
committed by
Sheetal Nandi
Sheetal Nandi
parent
b007f98951
commit
d2d41a9f46
154
types/async/index.d.ts
vendored
154
types/async/index.d.ts
vendored
@@ -2,34 +2,34 @@
|
||||
// Project: https://github.com/caolan/async
|
||||
// Definitions 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>
|
||||
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
|
||||
// TypeScript Version: 2.1
|
||||
// TypeScript Version: 2.3
|
||||
|
||||
export as namespace async;
|
||||
|
||||
export interface Dictionary<T> { [key: string]: T; }
|
||||
export type IterableCollection<T> = T[] | IterableIterator<T> | Dictionary<T>
|
||||
|
||||
export interface ErrorCallback<T> { (err?: T): void; }
|
||||
export interface AsyncBooleanResultCallback<E> { (err?: E, truthValue?: boolean): void; }
|
||||
export interface AsyncResultCallback<T, E> { (err?: E, result?: T): void; }
|
||||
export interface AsyncResultArrayCallback<T, E> { (err?: E, results?: Array<T | undefined>): void; }
|
||||
export interface AsyncResultObjectCallback<T, E> { (err: E | undefined, results: Dictionary<T | undefined>): void; }
|
||||
export interface ErrorCallback<E = Error> { (err?: E | null): void; }
|
||||
export interface AsyncBooleanResultCallback<E = Error> { (err?: E | null, truthValue?: boolean): void; }
|
||||
export interface AsyncResultCallback<T, E = Error> { (err?: E | null, result?: T): void; }
|
||||
export interface AsyncResultArrayCallback<T, E = Error> { (err?: E | null, results?: Array<T | undefined>): void; }
|
||||
export interface AsyncResultObjectCallback<T, E = Error> { (err: E | undefined, results: Dictionary<T | undefined>): void; }
|
||||
|
||||
export interface AsyncFunction<T, E> { (callback: (err?: E, result?: T) => void): void; }
|
||||
export interface AsyncFunctionEx<T, E> { (callback: (err?: E, ...results: T[]) => void): void; }
|
||||
export interface AsyncIterator<T, E> { (item: T, callback: ErrorCallback<E>): void; }
|
||||
export interface AsyncForEachOfIterator<T, E> { (item: T, key: number|string, callback: ErrorCallback<E>): void; }
|
||||
export interface AsyncResultIterator<T, R, E> { (item: T, callback: AsyncResultCallback<R, E>): void; }
|
||||
export interface AsyncMemoIterator<T, R, E> { (memo: R | undefined, item: T, callback: AsyncResultCallback<R, E>): void; }
|
||||
export interface AsyncBooleanIterator<T, E> { (item: T, callback: AsyncBooleanResultCallback<E>): void; }
|
||||
export interface AsyncFunction<T, E = Error> { (callback: (err?: E | null, result?: T) => void): void; }
|
||||
export interface AsyncFunctionEx<T, E = Error> { (callback: (err?: E | null, ...results: T[]) => void): void; }
|
||||
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 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; }
|
||||
|
||||
export interface AsyncWorker<T, E> { (task: T, callback: ErrorCallback<E>): void; }
|
||||
export interface AsyncVoidFunction<E> { (callback: ErrorCallback<E>): void; }
|
||||
export interface AsyncWorker<T, E = Error> { (task: T, callback: ErrorCallback<E>): void; }
|
||||
export interface AsyncVoidFunction<E = Error> { (callback: ErrorCallback<E>): void; }
|
||||
|
||||
export type AsyncAutoTasks<R extends Dictionary<any>, E> = { [K in keyof R]: AsyncAutoTask<R[K], R, E> }
|
||||
export type AsyncAutoTask<R1, R extends Dictionary<any>, E> = AsyncAutoTaskFunctionWithoutDependencies<R1, E> | (keyof R | AsyncAutoTaskFunction<R1, R, E>)[];
|
||||
export interface AsyncAutoTaskFunctionWithoutDependencies<R1, E> { (cb: AsyncResultCallback<R1, E> | ErrorCallback<E>): void; }
|
||||
export interface AsyncAutoTaskFunction<R1, R extends Dictionary<any>, E> { (results: R, cb: AsyncResultCallback<R1, E> | ErrorCallback<E>): void; }
|
||||
export interface AsyncAutoTaskFunctionWithoutDependencies<R1, E = Error> { (cb: AsyncResultCallback<R1, E> | ErrorCallback<E>): void; }
|
||||
export interface AsyncAutoTaskFunction<R1, R extends Dictionary<any>, E = Error> { (results: R, cb: AsyncResultCallback<R1, E> | ErrorCallback<E>): void; }
|
||||
|
||||
export interface AsyncQueue<T> {
|
||||
length(): number;
|
||||
@@ -37,9 +37,8 @@ export interface AsyncQueue<T> {
|
||||
running(): number;
|
||||
idle(): boolean;
|
||||
concurrency: number;
|
||||
push<E>(task: T | T[], callback?: ErrorCallback<E>): void;
|
||||
push<R,E>(task: T, callback?: AsyncResultCallback<R, E>): void;
|
||||
unshift<E>(task: T | T[], callback?: ErrorCallback<E>): void;
|
||||
push<R,E = Error>(task: T | T[], callback?: AsyncResultCallback<R, E>): void;
|
||||
unshift<E = Error>(task: T | T[], callback?: ErrorCallback<E>): void;
|
||||
saturated: () => any;
|
||||
empty: () => any;
|
||||
drain: () => any;
|
||||
@@ -61,7 +60,7 @@ export interface AsyncPriorityQueue<T> {
|
||||
concurrency: number;
|
||||
started: boolean;
|
||||
paused: boolean;
|
||||
push<R,E>(task: T | T[], priority: number, callback?: AsyncResultArrayCallback<R, E>): void;
|
||||
push<R,E = Error>(task: T | T[], priority: number, callback?: AsyncResultArrayCallback<R, E>): void;
|
||||
saturated: () => any;
|
||||
empty: () => any;
|
||||
drain: () => any;
|
||||
@@ -94,112 +93,113 @@ export interface AsyncCargo {
|
||||
}
|
||||
|
||||
// Collections
|
||||
export function each<T, E>(arr: IterableCollection<T>, iterator: AsyncIterator<T, E>, callback?: ErrorCallback<E>): void;
|
||||
export function each<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncIterator<T, E>, callback?: ErrorCallback<E>): void;
|
||||
export const eachSeries: typeof each;
|
||||
export function eachLimit<T, E>(arr: IterableCollection<T>, limit: number, iterator: AsyncIterator<T, E>, callback?: ErrorCallback<E>): void;
|
||||
export function eachLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncIterator<T, E>, callback?: ErrorCallback<E>): void;
|
||||
export const forEach: typeof each;
|
||||
export const forEachSeries: typeof each;
|
||||
export const forEachLimit: typeof eachLimit;
|
||||
export function forEachOf<T, E>(obj: IterableCollection<T>, iterator: AsyncForEachOfIterator<T, E>, callback?: ErrorCallback<E>): void;
|
||||
export function forEachOf<T, E = Error>(obj: IterableCollection<T>, iterator: AsyncForEachOfIterator<T, E>, callback?: ErrorCallback<E>): void;
|
||||
export const forEachOfSeries: typeof forEachOf;
|
||||
export function forEachOfLimit<T, E>(obj: IterableCollection<T>, limit: number, iterator: AsyncForEachOfIterator<T, E>, callback?: ErrorCallback<E>): void;
|
||||
export function forEachOfLimit<T, E = Error>(obj: IterableCollection<T>, limit: number, iterator: AsyncForEachOfIterator<T, E>, callback?: ErrorCallback<E>): void;
|
||||
export const eachOf: typeof forEachOf;
|
||||
export const eachOfSeries: typeof forEachOf;
|
||||
export const eachOfLimit: typeof forEachOfLimit;
|
||||
export function map<T, R, E>(arr: T[] | IterableIterator<T>, iterator: AsyncResultIterator<T, R, E>, callback?: AsyncResultArrayCallback<R, E>): void;
|
||||
export function map<T, R, E>(arr: Dictionary<T>, iterator: AsyncResultIterator<T, R, E>, callback?: AsyncResultArrayCallback<R, E>): void;
|
||||
export function map<T, R, E = Error>(arr: T[] | IterableIterator<T>, iterator: AsyncResultIterator<T, R, E>, callback?: AsyncResultArrayCallback<R, E>): void;
|
||||
export function map<T, R, E = Error>(arr: Dictionary<T>, iterator: AsyncResultIterator<T, R, E>, callback?: AsyncResultArrayCallback<R, E>): void;
|
||||
export const mapSeries: typeof map;
|
||||
export function mapLimit<T, R, E>(arr: IterableCollection<T>, limit: number, iterator: AsyncResultIterator<T, R, E>, callback?: AsyncResultArrayCallback<R, E>): void;
|
||||
export function mapValuesLimit<T, R, E>(obj: Dictionary<T>, limit: number, iteratee: (value: T, key: string, callback: AsyncResultCallback<R, E>) => void, callback: AsyncResultObjectCallback<R, E>): void;
|
||||
export function mapValues<T, R, E>(obj: Dictionary<T>, iteratee: (value: T, key: string, callback: AsyncResultCallback<R, E>) => void, callback: AsyncResultObjectCallback<R, E>): void;
|
||||
export function mapLimit<T, R, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncResultIterator<T, R, E>, callback?: AsyncResultArrayCallback<R, E>): void;
|
||||
export function mapValuesLimit<T, R, E = Error>(obj: Dictionary<T>, limit: number, iteratee: (value: T, key: string, callback: AsyncResultCallback<R, E>) => void, callback: AsyncResultObjectCallback<R, E>): void;
|
||||
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;
|
||||
export const mapValuesSeries: typeof mapValues;
|
||||
export function filter<T, E>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultArrayCallback<T, E>): void;
|
||||
export function filter<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultArrayCallback<T, E>): void;
|
||||
export const filterSeries: typeof filter;
|
||||
export function filterLimit<T, E>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultArrayCallback<T, E>): void;
|
||||
export function filterLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultArrayCallback<T, E>): void;
|
||||
export const select: typeof filter;
|
||||
export const selectSeries: typeof filter;
|
||||
export const selectLimit: typeof filterLimit;
|
||||
export const reject: typeof filter;
|
||||
export const rejectSeries: typeof filter;
|
||||
export const rejectLimit: typeof filterLimit;
|
||||
export function reduce<T, R, E>(arr: T[] | IterableIterator<T>, memo: R, iterator: AsyncMemoIterator<T, R, E>, callback?: AsyncResultCallback<R, E>): void;
|
||||
export function reduce<T, R, E = Error>(arr: T[] | IterableIterator<T>, memo: R, iterator: AsyncMemoIterator<T, R, E>, callback?: AsyncResultCallback<R, E>): void;
|
||||
export const inject: typeof reduce;
|
||||
export const foldl: typeof reduce;
|
||||
export const reduceRight: typeof reduce;
|
||||
export const foldr: typeof reduce;
|
||||
export function detect<T, E>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultCallback<T, E>): void;
|
||||
export function detect<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultCallback<T, E>): void;
|
||||
export const detectSeries: typeof detect;
|
||||
export function detectLimit<T, E>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultCallback<T, E>): void;
|
||||
export function detectLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultCallback<T, E>): void;
|
||||
export const find: typeof detect;
|
||||
export const findSeries: typeof detect;
|
||||
export const findLimit: typeof detectLimit;
|
||||
export function sortBy<T, V, E>(arr: T[] | IterableIterator<T>, iterator: AsyncResultIterator<T, V, E>, callback?: AsyncResultArrayCallback<T, E>): void;
|
||||
export function some<T, E>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
|
||||
export function sortBy<T, V, E = Error>(arr: T[] | IterableIterator<T>, iterator: AsyncResultIterator<T, V, E>, callback?: AsyncResultArrayCallback<T, E>): void;
|
||||
export function some<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
|
||||
export const someSeries: typeof some;
|
||||
export function someLimit<T, E>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
|
||||
export function someLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
|
||||
export const any: typeof some;
|
||||
export const anySeries: typeof someSeries;
|
||||
export const anyLimit: typeof someLimit;
|
||||
export function every<T, E>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
|
||||
export function every<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
|
||||
export const everySeries: typeof every;
|
||||
export function everyLimit<T, E>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
|
||||
export function everyLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
|
||||
export const all: typeof every;
|
||||
export const allSeries: typeof every;
|
||||
export const allLimit: typeof everyLimit;
|
||||
|
||||
export function concat<T, R, E>(arr: IterableCollection<T>, iterator: AsyncResultIterator<T, R[], E>, callback?: AsyncResultArrayCallback<R, E>): void;
|
||||
export function concatLimit<T, R, E>(arr: IterableCollection<T>, limit: number, iterator: AsyncResultIterator<T, R[], E>, callback?: AsyncResultArrayCallback<R, E>): void;
|
||||
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 const concatSeries: typeof concat;
|
||||
|
||||
// Control Flow
|
||||
export function series<T, E>(tasks: AsyncFunction<T, E>[], callback?: AsyncResultArrayCallback<T, E>): void;
|
||||
export function series<T, E>(tasks: Dictionary<AsyncFunction<T, E>>, callback?: AsyncResultObjectCallback<T, E>): void;
|
||||
export function parallel<T, E>(tasks: Array<AsyncFunction<T, E>>, callback?: AsyncResultArrayCallback<T, E>): void;
|
||||
export function parallel<T, E>(tasks: Dictionary<AsyncFunction<T, E>>, callback?: AsyncResultObjectCallback<T, E>): void;
|
||||
export function parallelLimit<T, E>(tasks: Array<AsyncFunction<T, E>>, limit: number, callback?: AsyncResultArrayCallback<T, E>): void;
|
||||
export function parallelLimit<T, E>(tasks: Dictionary<AsyncFunction<T, E>>, limit: number, callback?: AsyncResultObjectCallback<T, E>): void;
|
||||
export function whilst<E>(test: () => boolean, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
|
||||
export function doWhilst<T, E>(fn: AsyncFunctionEx<T, E>, test: (...results: T[]) => boolean, callback: ErrorCallback<E>): void;
|
||||
export function until<E>(test: () => boolean, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
|
||||
export function doUntil<T, E>(fn: AsyncFunctionEx<T, E>, test: (...results: T[]) => boolean, callback: ErrorCallback<E>): void;
|
||||
export function during<E>(test: (testCallback : AsyncBooleanResultCallback<E>) => void, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
|
||||
export function doDuring<E>(fn: AsyncVoidFunction<E>, test: (testCallback: AsyncBooleanResultCallback<E>) => void, callback: ErrorCallback<E>): void;
|
||||
export function forever<E>(next: (next : ErrorCallback<E>) => void, errBack: ErrorCallback<E>) : void;
|
||||
export function waterfall<T, E>(tasks: Function[], callback?: AsyncResultCallback<T, E | Error>): void;
|
||||
export function series<T, E = Error>(tasks: AsyncFunction<T, E>[], callback?: AsyncResultArrayCallback<T, E>): void;
|
||||
export function series<T, E = Error>(tasks: Dictionary<AsyncFunction<T, E>>, callback?: AsyncResultObjectCallback<T, E>): void;
|
||||
export function parallel<T, E = Error>(tasks: Array<AsyncFunction<T, E>>, callback?: AsyncResultArrayCallback<T, E>): void;
|
||||
export function parallel<T, E = Error>(tasks: Dictionary<AsyncFunction<T, E>>, callback?: AsyncResultObjectCallback<T, E>): void;
|
||||
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 whilst<E = Error>(test: () => boolean, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
|
||||
export function doWhilst<T, E = Error>(fn: AsyncFunctionEx<T, E>, test: (...results: T[]) => boolean, callback: ErrorCallback<E>): void;
|
||||
export function until<E = Error>(test: () => boolean, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
|
||||
export function doUntil<T, E = Error>(fn: AsyncFunctionEx<T, E>, test: (...results: T[]) => boolean, callback: ErrorCallback<E>): void;
|
||||
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;
|
||||
export function waterfall<T, E = Error>(tasks: Function[], callback?: AsyncResultCallback<T, E>): void;
|
||||
export function compose(...fns: Function[]): Function;
|
||||
export function seq(...fns: Function[]): Function;
|
||||
export function applyEach(fns: Function[], ...argsAndCallback: any[]): void; // applyEach(fns, args..., callback). TS does not support ... for a middle argument. Callback is optional.
|
||||
export function applyEachSeries(fns: Function[], ...argsAndCallback: any[]): void; // applyEachSeries(fns, args..., callback). TS does not support ... for a middle argument. Callback is optional.
|
||||
export function queue<T, E>(worker: AsyncWorker<T, E>, concurrency?: number): AsyncQueue<T>;
|
||||
export function queue<T, R, E>(worker: AsyncResultIterator<T, R, E>, concurrency?: number): AsyncQueue<T>;
|
||||
export function priorityQueue<T, E>(worker: AsyncWorker<T, E>, concurrency: number): AsyncPriorityQueue<T>;
|
||||
export function cargo<E>(worker : (tasks: any[], callback : ErrorCallback<E>) => void, payload? : number) : AsyncCargo;
|
||||
export function auto<R extends Dictionary<any>, E>(tasks: AsyncAutoTasks<R, E>, concurrency?: number, callback?: AsyncResultCallback<R, E>): void;
|
||||
export function autoInject<E>(tasks: any, callback?: AsyncResultCallback<any, E>): void;
|
||||
export function retry<T, E>(opts: number, task: (callback : AsyncResultCallback<T, E>, results: any) => void, callback: AsyncResultCallback<any, E | Error>): void;
|
||||
export function 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;
|
||||
export function retryable<T, E>(opts: number | {times: number, interval: number}, task: AsyncFunction<T, E>): AsyncFunction<T, E | Error>;
|
||||
export function apply<E>(fn: Function, ...args: any[]): AsyncFunction<any,E | Error>;
|
||||
export function queue<T, E = Error>(worker: AsyncWorker<T, E>, concurrency?: number): AsyncQueue<T>;
|
||||
export function queue<T, R, E = Error>(worker: AsyncResultIterator<T, R, E>, concurrency?: number): AsyncQueue<T>;
|
||||
export function priorityQueue<T, E = Error>(worker: AsyncWorker<T, E>, concurrency: number): AsyncPriorityQueue<T>;
|
||||
export function cargo<E = Error>(worker : (tasks: any[], callback : ErrorCallback<E>) => void, payload? : number) : AsyncCargo;
|
||||
export function auto<R extends Dictionary<any>, E = Error>(tasks: AsyncAutoTasks<R, E>, concurrency?: number, callback?: AsyncResultCallback<R, E>): void;
|
||||
export function auto<R extends Dictionary<any>, E = Error>(tasks: AsyncAutoTasks<R, E>, callback?: AsyncResultCallback<R, E>): void;
|
||||
export function autoInject<E = Error>(tasks: any, callback?: AsyncResultCallback<any, E>): void;
|
||||
export function retry<T, E = Error>(opts: number, task: (callback : AsyncResultCallback<T, E>, results: any) => void, callback: AsyncResultCallback<any, E>): void;
|
||||
export function retry<T, E = Error>(opts: { times: number, interval: number|((retryCount: number) => number) }, task: (callback: AsyncResultCallback<T, E>, results : any) => void, callback: AsyncResultCallback<any, E>): void;
|
||||
export function retryable<T, E = Error>(opts: number | {times: number, interval: number}, task: AsyncFunction<T, E>): AsyncFunction<T, E>;
|
||||
export function apply<E = Error>(fn: Function, ...args: any[]): AsyncFunction<any,E>;
|
||||
export function nextTick(callback: Function, ...args: any[]): void;
|
||||
export const setImmediate: typeof nextTick;
|
||||
|
||||
export function reflect<T, E>(fn: AsyncFunction<T, E>) : (callback: (err: null, result: {error?: E, value?: T}) => void) => void;
|
||||
export function reflectAll<T, E>(tasks: AsyncFunction<T, E>[]): ((callback: (err: null, result: {error?: E, value?: T}) => void) => void)[];
|
||||
export function reflect<T, E = Error>(fn: AsyncFunction<T, E>) : (callback: (err: null, result: {error?: E, value?: T}) => void) => void;
|
||||
export function reflectAll<T, E = Error>(tasks: AsyncFunction<T, E>[]): ((callback: (err: null, result: {error?: E, value?: T}) => void) => void)[];
|
||||
|
||||
export function timeout<T, E>(fn: AsyncFunction<T, E>, milliseconds: number, info?: any): AsyncFunction<T, E | Error>;
|
||||
export function timeout<T, R, E>(fn: AsyncResultIterator<T, R, E>, milliseconds: number, info?: any): AsyncResultIterator<T, R, E | Error>;
|
||||
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> (n: number, iterator: AsyncResultIterator<number, T, E>, callback: AsyncResultArrayCallback<T, E>): void;
|
||||
export function timesSeries<T, E>(n: number, iterator: AsyncResultIterator<number, T, E>, callback: AsyncResultArrayCallback<T, E>): void;
|
||||
export function timesLimit<T, E>(n: number, limit: number, iterator: AsyncResultIterator<number, T, E>, callback: AsyncResultArrayCallback<T, E>): void;
|
||||
export function timesSeries<T, E = Error>(n: 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>, callback: AsyncResultArrayCallback<T, E>): void;
|
||||
|
||||
export function transform<T, R, E>(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>(arr: T[], acc: R[], 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[], 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;
|
||||
|
||||
export function transform<T, R, E>(arr: {[key: string] : T}, iteratee: (acc: {[key: string] : R}, item: T, key: string, callback: (error?: E) => void) => void, callback?: AsyncResultObjectCallback<T, E>): void;
|
||||
export function 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, callback?: AsyncResultObjectCallback<T, E>): void;
|
||||
export function transform<T, R, E = Error>(arr: {[key: string] : T}, iteratee: (acc: {[key: string] : R}, item: T, key: string, callback: (error?: E) => void) => void, callback?: AsyncResultObjectCallback<T, E>): void;
|
||||
export function transform<T, R, E = Error>(arr: {[key: string] : T}, acc: {[key: string] : R}, iteratee: (acc: {[key: string] : R}, item: T, key: string, callback: (error?: E) => void) => void, callback?: AsyncResultObjectCallback<T, E>): void;
|
||||
|
||||
export function race<T, E>(tasks: (AsyncFunction<T, E>)[], callback: AsyncResultCallback<T, E | Error>) : void;
|
||||
export function race<T, E = Error>(tasks: (AsyncFunction<T, E>)[], callback: AsyncResultCallback<T, E>) : void;
|
||||
|
||||
// Utils
|
||||
export function memoize(fn: Function, hasher?: Function): Function;
|
||||
|
||||
@@ -114,7 +114,7 @@ async.series([
|
||||
],
|
||||
function (err, results) { });
|
||||
|
||||
async.series<string,Error>([
|
||||
async.series<string>([
|
||||
function (callback) {
|
||||
callback(undefined, 'one');
|
||||
},
|
||||
@@ -138,7 +138,7 @@ async.series({
|
||||
},
|
||||
function (err, results) { });
|
||||
|
||||
async.series<number,Error>({
|
||||
async.series<number>({
|
||||
one: function (callback) {
|
||||
setTimeout(function () {
|
||||
callback(undefined, 1);
|
||||
@@ -178,7 +178,7 @@ async.parallel([
|
||||
],
|
||||
function (err, results) { });
|
||||
|
||||
async.parallel<string,Error>([
|
||||
async.parallel<string>([
|
||||
function (callback) {
|
||||
setTimeout(function () {
|
||||
callback(undefined, 'one');
|
||||
@@ -207,7 +207,7 @@ async.parallel({
|
||||
},
|
||||
function (err, results) { });
|
||||
|
||||
async.parallel<number,Error>({
|
||||
async.parallel<number>({
|
||||
one: function (callback) {
|
||||
setTimeout(function () {
|
||||
callback(undefined, 1);
|
||||
@@ -273,7 +273,7 @@ async.waterfall([
|
||||
], function (err, result) { });
|
||||
|
||||
|
||||
var q = async.queue<any,Error>(function (task: any, callback: (err?:Error,msg?:string) => void) {
|
||||
var q = async.queue<any>(function (task: any, callback: (err?:Error,msg?:string) => void) {
|
||||
console.log('hello ' + task.name);
|
||||
callback(undefined,'a message.');
|
||||
}, 2);
|
||||
@@ -293,7 +293,7 @@ q.push([{ name: 'baz' }, { name: 'bay' }, { name: 'bax' }], function (err) {
|
||||
console.log('finished processing bar');
|
||||
});
|
||||
|
||||
q.push<string,Error>({name: 'foo'}, function (err,msg) {
|
||||
q.push<string>({name: 'foo'}, function (err, msg) {
|
||||
console.log('foo finished with a message "'+ msg! + '"');
|
||||
});
|
||||
|
||||
@@ -330,7 +330,7 @@ q.resume();
|
||||
q.kill();
|
||||
|
||||
// tests for strongly typed tasks
|
||||
var q2 = async.queue<string,Error>(function (task: string, callback: () => void) {
|
||||
var q2 = async.queue<string>(function (task: string, callback: () => void) {
|
||||
console.log('Task: ' + task);
|
||||
callback();
|
||||
}, 1);
|
||||
@@ -356,7 +356,7 @@ q2.unshift(['task3', 'task4', 'task5'], function (error) {
|
||||
});
|
||||
|
||||
|
||||
var aq = async.queue<number, number, Error>(function (level: number, callback: (error?: Error, newLevel?: number) => void) {
|
||||
var aq = async.queue<number, number>(function (level: number, callback: (error?: Error, newLevel?: number) => void) {
|
||||
console.log('hello ' + level);
|
||||
callback(undefined, level+1);
|
||||
});
|
||||
@@ -387,14 +387,47 @@ cargo.push({ name: 'baz' }, function (err: Error) {
|
||||
|
||||
var filename = '';
|
||||
async.auto({
|
||||
get_data: function (callback: any) { },
|
||||
make_folder: function (callback: any) { },
|
||||
get_data: function (callback: AsyncResultCallback<any>) { },
|
||||
make_folder: function (callback: AsyncResultCallback<any>) { },
|
||||
//arrays with different types are not accepted by TypeScript.
|
||||
write_file: ['get_data', 'make_folder', <any>function (callback: any) {
|
||||
write_file: ['get_data', 'make_folder', <any>function (callback: AsyncResultCallback<any>) {
|
||||
callback(null, filename);
|
||||
}],
|
||||
//arrays with different types are not accepted by TypeScript.
|
||||
email_link: ['write_file', <any>function (callback: any, results: any) { }]
|
||||
email_link: ['write_file', <any>function (callback: AsyncResultCallback<any>, results: any) { }]
|
||||
});
|
||||
|
||||
async.auto({
|
||||
get_data: function (callback: AsyncResultCallback<any>) { },
|
||||
make_folder: function (callback: AsyncResultCallback<any>) { },
|
||||
//arrays with different types are not accepted by TypeScript.
|
||||
write_file: ['get_data', 'make_folder', <any>function (callback: AsyncResultCallback<any>) {
|
||||
callback(null, filename);
|
||||
}],
|
||||
//arrays with different types are not accepted by TypeScript.
|
||||
email_link: ['write_file', <any>function (callback: AsyncResultCallback<any>, results: any) { }]
|
||||
}, function (err, results) {
|
||||
console.log('finished auto');
|
||||
});
|
||||
|
||||
interface A {
|
||||
get_data: any;
|
||||
make_folder: any;
|
||||
write_file: any;
|
||||
email_link: any;
|
||||
}
|
||||
|
||||
async.auto<A>({
|
||||
get_data: function (callback: AsyncResultCallback<any>) { },
|
||||
make_folder: function (callback: AsyncResultCallback<any>) { },
|
||||
//arrays with different types are not accepted by TypeScript.
|
||||
write_file: ['get_data', 'make_folder', <any>function (callback: AsyncResultCallback<any>) {
|
||||
callback(null, filename);
|
||||
}],
|
||||
//arrays with different types are not accepted by TypeScript.
|
||||
email_link: ['write_file', <any>function (callback: AsyncResultCallback<any>, results: any) { }]
|
||||
}, 1, function (err, results) {
|
||||
console.log('finished auto');
|
||||
});
|
||||
|
||||
async.retry(3, function (callback, results) { }, function (err, result) { });
|
||||
@@ -459,10 +492,10 @@ async.dir(function (name: string, callback: any) {
|
||||
|
||||
// each
|
||||
|
||||
async.each<number,Error>({
|
||||
async.each<number>({
|
||||
"a": 1,
|
||||
"b": 2
|
||||
}, function(val: number, next: ErrorCallback<Error>): void {
|
||||
}, function(val: number, next: ErrorCallback): void {
|
||||
|
||||
setTimeout(function(): void {
|
||||
|
||||
@@ -478,10 +511,10 @@ async.each<number,Error>({
|
||||
|
||||
});
|
||||
|
||||
async.eachSeries<number, Error>({
|
||||
async.eachSeries<number>({
|
||||
"a": 1,
|
||||
"b": 2
|
||||
}, function(val: number, next: ErrorCallback<Error>): void {
|
||||
}, function(val: number, next: ErrorCallback): void {
|
||||
|
||||
setTimeout(function(): void {
|
||||
|
||||
@@ -497,14 +530,14 @@ async.eachSeries<number, Error>({
|
||||
|
||||
});
|
||||
|
||||
async.eachLimit<number, Error>({
|
||||
async.eachLimit<number>({
|
||||
"a": 1,
|
||||
"b": 2,
|
||||
"c": 3,
|
||||
"d": 4,
|
||||
"e": 5,
|
||||
"f": 6
|
||||
}, 2, function(val: number, next: ErrorCallback<Error>): void {
|
||||
}, 2, function(val: number, next: ErrorCallback): void {
|
||||
|
||||
setTimeout(function(): void {
|
||||
|
||||
@@ -522,10 +555,10 @@ async.eachLimit<number, Error>({
|
||||
|
||||
// forEachOf/eachOf
|
||||
|
||||
async.eachOf<number, Error>({
|
||||
async.eachOf<number>({
|
||||
"a": 1,
|
||||
"b": 2
|
||||
}, function(val: number, key: string, next: ErrorCallback<Error>): void {
|
||||
}, function(val: number, key: string, next: ErrorCallback): void {
|
||||
|
||||
setTimeout(function(): void {
|
||||
|
||||
@@ -541,10 +574,10 @@ async.eachOf<number, Error>({
|
||||
|
||||
});
|
||||
|
||||
async.forEachOfSeries<number, Error>({
|
||||
async.forEachOfSeries<number>({
|
||||
"a": 1,
|
||||
"b": 2
|
||||
}, function(val: number, key: string, next: ErrorCallback<Error>): void {
|
||||
}, function(val: number, key: string, next: ErrorCallback): void {
|
||||
|
||||
setTimeout(function(): void {
|
||||
|
||||
@@ -560,14 +593,14 @@ async.forEachOfSeries<number, Error>({
|
||||
|
||||
});
|
||||
|
||||
async.forEachOfLimit<number, Error>({
|
||||
async.forEachOfLimit<number>({
|
||||
"a": 1,
|
||||
"b": 2,
|
||||
"c": 3,
|
||||
"d": 4,
|
||||
"e": 5,
|
||||
"f": 6
|
||||
}, 2, function(val: number, key: string, next: ErrorCallback<Error>): void {
|
||||
}, 2, function(val: number, key: string, next: ErrorCallback): void {
|
||||
|
||||
setTimeout(function(): void {
|
||||
|
||||
@@ -585,11 +618,11 @@ async.forEachOfLimit<number, Error>({
|
||||
|
||||
// map
|
||||
|
||||
async.map<number, string, Error>({
|
||||
async.map<number, string>({
|
||||
"a": 1,
|
||||
"b": 2,
|
||||
"c": 3
|
||||
}, function(val: number, next: AsyncResultCallback<string, Error>): void {
|
||||
}, function(val: number, next: AsyncResultCallback<string>): void {
|
||||
|
||||
setTimeout(function(): void {
|
||||
|
||||
@@ -605,11 +638,11 @@ async.map<number, string, Error>({
|
||||
|
||||
});
|
||||
|
||||
async.mapSeries<number, string, Error>({
|
||||
async.mapSeries<number, string>({
|
||||
"a": 1,
|
||||
"b": 2,
|
||||
"c": 3
|
||||
}, function(val: number, next: AsyncResultCallback<string, Error>): void {
|
||||
}, function(val: number, next: AsyncResultCallback<string>): void {
|
||||
|
||||
setTimeout(function(): void {
|
||||
|
||||
@@ -625,14 +658,14 @@ async.mapSeries<number, string, Error>({
|
||||
|
||||
});
|
||||
|
||||
async.mapLimit<number, string, Error>({
|
||||
async.mapLimit<number, string>({
|
||||
"a": 1,
|
||||
"b": 2,
|
||||
"c": 3,
|
||||
"d": 4,
|
||||
"e": 5,
|
||||
"f": 6
|
||||
}, 2, function(val: number, next: AsyncResultCallback<string, Error>): void {
|
||||
}, 2, function(val: number, next: AsyncResultCallback<string>): void {
|
||||
|
||||
setTimeout(function(): void {
|
||||
|
||||
@@ -650,11 +683,11 @@ async.mapLimit<number, string, Error>({
|
||||
|
||||
// mapValues
|
||||
|
||||
async.mapValues<number, string, Error>({
|
||||
async.mapValues<number, string>({
|
||||
"a": 1,
|
||||
"b": 2,
|
||||
"c": 3
|
||||
}, function(val: number, key: string, next: AsyncResultCallback<string, Error>): void {
|
||||
}, function(val: number, key: string, next: AsyncResultCallback<string>): void {
|
||||
|
||||
setTimeout(function(): void {
|
||||
|
||||
@@ -670,11 +703,11 @@ async.mapValues<number, string, Error>({
|
||||
|
||||
});
|
||||
|
||||
async.mapValuesSeries<number, string, Error>({
|
||||
async.mapValuesSeries<number, string>({
|
||||
"a": 1,
|
||||
"b": 2,
|
||||
"c": 3
|
||||
}, function(val: number, key: string, next: AsyncResultCallback<string, Error>): void {
|
||||
}, function(val: number, key: string, next: AsyncResultCallback<string>): void {
|
||||
|
||||
setTimeout(function(): void {
|
||||
|
||||
@@ -692,11 +725,11 @@ async.mapValuesSeries<number, string, Error>({
|
||||
|
||||
// filter/select/reject
|
||||
|
||||
async.filter<number, Error>({
|
||||
async.filter<number>({
|
||||
"a": 1,
|
||||
"b": 2,
|
||||
"c": 3
|
||||
}, function(val: number, next: AsyncBooleanResultCallback<Error>): void {
|
||||
}, function(val: number, next: AsyncBooleanResultCallback): void {
|
||||
|
||||
setTimeout(function(): void {
|
||||
|
||||
@@ -712,11 +745,11 @@ async.filter<number, Error>({
|
||||
|
||||
});
|
||||
|
||||
async.reject<number, Error>({
|
||||
async.reject<number>({
|
||||
"a": 1,
|
||||
"b": 2,
|
||||
"c": 3
|
||||
}, function(val: number, next: AsyncBooleanResultCallback<Error>): void {
|
||||
}, function(val: number, next: AsyncBooleanResultCallback): void {
|
||||
|
||||
setTimeout(function(): void {
|
||||
|
||||
@@ -734,11 +767,11 @@ async.reject<number, Error>({
|
||||
|
||||
// concat
|
||||
|
||||
async.concat<string, string, Error>({
|
||||
async.concat<string, string>({
|
||||
"a": "1",
|
||||
"b": "2",
|
||||
"c": "3"
|
||||
}, function(item: string, next: AsyncResultCallback<string[], Error>): void {
|
||||
}, function(item: string, next: AsyncResultCallback<string[]>): void {
|
||||
|
||||
console.log(`async.concat: ${item}`);
|
||||
|
||||
@@ -752,11 +785,11 @@ async.concat<string, string, Error>({
|
||||
|
||||
// detect/find
|
||||
|
||||
async.detect<number, Error>({
|
||||
async.detect<number>({
|
||||
"a": 1,
|
||||
"b": 2,
|
||||
"c": 3
|
||||
}, function(item: number, next: AsyncBooleanResultCallback<Error>): void {
|
||||
}, function(item: number, next: AsyncBooleanResultCallback): void {
|
||||
|
||||
console.log(`async.detect/find: ${item}`);
|
||||
|
||||
@@ -777,11 +810,11 @@ async.detect<number, Error>({
|
||||
|
||||
// every/all
|
||||
|
||||
async.every<number,Error>({
|
||||
async.every<number>({
|
||||
"a": 1,
|
||||
"b": 2,
|
||||
"c": 3
|
||||
}, function(item: number, next: AsyncBooleanResultCallback<Error>): void {
|
||||
}, function(item: number, next: AsyncBooleanResultCallback): void {
|
||||
|
||||
console.log(`async.every/all: ${item}`);
|
||||
|
||||
@@ -795,11 +828,11 @@ async.every<number,Error>({
|
||||
|
||||
// some/any
|
||||
|
||||
async.some<number, Error>({
|
||||
async.some<number>({
|
||||
"a": 1,
|
||||
"b": 2,
|
||||
"c": 3
|
||||
}, function(item: number, next: AsyncBooleanResultCallback<Error>): void {
|
||||
}, function(item: number, next: AsyncBooleanResultCallback): void {
|
||||
|
||||
console.log(`async.some/any: ${item}`);
|
||||
|
||||
|
||||
2
types/i2c-bus/index.d.ts
vendored
2
types/i2c-bus/index.d.ts
vendored
@@ -2,7 +2,7 @@
|
||||
// Project: https://github.com/fivdi/i2c-bus
|
||||
// Definitions by: Jason Heard <https://github.com/101100>
|
||||
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
|
||||
// TypeScript Version: 2.1
|
||||
// TypeScript Version: 2.3
|
||||
|
||||
/// <reference types="node" />
|
||||
|
||||
|
||||
2
types/libpq/index.d.ts
vendored
2
types/libpq/index.d.ts
vendored
@@ -2,7 +2,7 @@
|
||||
// Project: https://github.com/brianc/node-libpq#readme
|
||||
// Definitions by: Vlad Rindevich <https://github.com/Lodin>
|
||||
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
|
||||
// TypeScript Version: 2.2
|
||||
// TypeScript Version: 2.3
|
||||
|
||||
/// <reference types="node" />
|
||||
|
||||
|
||||
Reference in New Issue
Block a user