diff --git a/types/async/test/es6-generators.ts b/types/async/test/es6-generators.ts index 92215e5deb..e0008d7d5e 100644 --- a/types/async/test/es6-generators.ts +++ b/types/async/test/es6-generators.ts @@ -14,41 +14,41 @@ async.map(collectionGenerator(), funcMapIterator, funcMapComplete); async.mapSeries(collectionGenerator(), funcMapIterator, funcMapComplete); async.mapLimit(collectionGenerator(), 2, funcMapIterator, funcMapComplete); -async.filter(collectionGenerator(), booleanIterator, function(err: Error, results: any[]) { }); -async.filterSeries(collectionGenerator(), booleanIterator, function(err: Error, results: any[]) { }); -async.filterLimit(collectionGenerator(), 2, booleanIterator, function(err: Error, results: any[]) { }); -async.select(collectionGenerator(), booleanIterator, function(err: Error, results: any[]) { }); -async.selectSeries(collectionGenerator(), booleanIterator, function(err: Error, results: any[]) { }); -async.selectLimit(collectionGenerator(), 2, booleanIterator, function(err: Error, results: any[]) { }); +async.filter(collectionGenerator(), booleanIterator, (err: Error, results: any[]) => { }); +async.filterSeries(collectionGenerator(), booleanIterator, (err: Error, results: any[]) => { }); +async.filterLimit(collectionGenerator(), 2, booleanIterator, (err: Error, results: any[]) => { }); +async.select(collectionGenerator(), booleanIterator, (err: Error, results: any[]) => { }); +async.selectSeries(collectionGenerator(), booleanIterator, (err: Error, results: any[]) => { }); +async.selectLimit(collectionGenerator(), 2, booleanIterator, (err: Error, results: any[]) => { }); -async.reject(collectionGenerator(), booleanIterator, function(err: Error, results: any[]) { }); -async.rejectSeries(collectionGenerator(), booleanIterator, function(err: Error, results: any[]) { }); -async.rejectLimit(collectionGenerator(), 2, booleanIterator, function(err: Error, results: any[]) { }); +async.reject(collectionGenerator(), booleanIterator, (err: Error, results: any[]) => { }); +async.rejectSeries(collectionGenerator(), booleanIterator, (err: Error, results: any[]) => { }); +async.rejectLimit(collectionGenerator(), 2, booleanIterator, (err: Error, results: any[]) => { }); -async.each(collectionGenerator(), eachIterator, function(err: Error) { }); -async.eachLimit(collectionGenerator(), 2, eachIterator, function(err: Error) { }); -async.eachSeries(collectionGenerator(), eachIterator, function(err: Error) { }); -async.eachOf(collectionGenerator(), eachOfIterator, function(err: Error) { }); -async.eachOfLimit(collectionGenerator(), 2, eachOfIterator, function(err: Error) { }); -async.eachOfSeries(collectionGenerator(), eachOfIterator, function(err: Error) { }); -async.forEach(collectionGenerator(), eachIterator, function(err: Error) { }); -async.forEachLimit(collectionGenerator(), 2, eachIterator, function(err: Error) { }); -async.forEachSeries(collectionGenerator(), eachIterator, function(err: Error) { }); -async.forEachOf(collectionGenerator(), eachOfIterator, function(err: Error) { }); -async.forEachOfLimit(collectionGenerator(), 2, eachOfIterator, function(err: Error) { }); -async.forEachOfSeries(collectionGenerator(), eachOfIterator, function(err: Error) { }); +async.each(collectionGenerator(), eachIterator, (err: Error) => { }); +async.eachLimit(collectionGenerator(), 2, eachIterator, (err: Error) => { }); +async.eachSeries(collectionGenerator(), eachIterator, (err: Error) => { }); +async.eachOf(collectionGenerator(), eachOfIterator, (err: Error) => { }); +async.eachOfLimit(collectionGenerator(), 2, eachOfIterator, (err: Error) => { }); +async.eachOfSeries(collectionGenerator(), eachOfIterator, (err: Error) => { }); +async.forEach(collectionGenerator(), eachIterator, (err: Error) => { }); +async.forEachLimit(collectionGenerator(), 2, eachIterator, (err: Error) => { }); +async.forEachSeries(collectionGenerator(), eachIterator, (err: Error) => { }); +async.forEachOf(collectionGenerator(), eachOfIterator, (err: Error) => { }); +async.forEachOfLimit(collectionGenerator(), 2, eachOfIterator, (err: Error) => { }); +async.forEachOfSeries(collectionGenerator(), eachOfIterator, (err: Error) => { }); -async.every(collectionGenerator(), booleanIterator, function(err: Error, res: boolean) { }); -async.everyLimit(collectionGenerator(), 2, booleanIterator, function(err: Error, res: boolean) { }); -async.everySeries(collectionGenerator(), booleanIterator, function(err: Error, res: boolean) { }); +async.every(collectionGenerator(), booleanIterator, (err: Error, res: boolean) => { }); +async.everyLimit(collectionGenerator(), 2, booleanIterator, (err: Error, res: boolean) => { }); +async.everySeries(collectionGenerator(), booleanIterator, (err: Error, res: boolean) => { }); -async.some(collectionGenerator(), booleanIterator, function(err: Error, res: boolean) { }); -async.someLimit(collectionGenerator(), 2, booleanIterator, function(err: Error, res: boolean) { }); -async.someSeries(collectionGenerator(), booleanIterator, function(err: Error, res: boolean) { }); +async.some(collectionGenerator(), booleanIterator, (err: Error, res: boolean) => { }); +async.someLimit(collectionGenerator(), 2, booleanIterator, (err: Error, res: boolean) => { }); +async.someSeries(collectionGenerator(), booleanIterator, (err: Error, res: boolean) => { }); -async.detect(collectionGenerator(), booleanIterator, function(err: Error, res: boolean) { }); -async.detectLimit(collectionGenerator(), 2, booleanIterator, function(err: Error, res: boolean) { }); -async.detectSeries(collectionGenerator(), booleanIterator, function(err: Error, res: boolean) { }); +async.detect(collectionGenerator(), booleanIterator, (err: Error, res: boolean) => { }); +async.detectLimit(collectionGenerator(), 2, booleanIterator, (err: Error, res: boolean) => { }); +async.detectSeries(collectionGenerator(), booleanIterator, (err: Error, res: boolean) => { }); async.concat(collectionGenerator(), concatIterator, (err: Error, res: any[]) => { }); async.concatSeries(collectionGenerator(), concatIterator, (err: Error, res: any[]) => { }); diff --git a/types/async/test/explicit.ts b/types/async/test/explicit.ts index 1d83173ac3..ae97888531 100644 --- a/types/async/test/explicit.ts +++ b/types/async/test/explicit.ts @@ -2,19 +2,11 @@ interface StringCallback { (err?: Error, result?: string): void; } interface AsyncStringGetter { (callback: StringCallback): void; } const taskArray: AsyncStringGetter[] = [ - function(callback) { - setTimeout(function() { - callback(undefined, 'one'); - }, 200); - }, - function(callback) { - setTimeout(function() { - callback(undefined, 'two'); - }, 100); - }, + callback => { setTimeout(() => { callback(undefined, 'one'); }, 200); }, + callback => { setTimeout(() => { callback(undefined, 'two'); }, 100); } ]; -async.series(taskArray, function(err, results) { +async.series(taskArray, (err, results) => { if (results) { const first = results[0]; if (first) { @@ -22,7 +14,8 @@ async.series(taskArray, function(err, results) { } } }); -async.parallel(taskArray, function(err, results) { + +async.parallel(taskArray, (err, results) => { if (results) { const first = results[0]; if (first) { @@ -30,7 +23,8 @@ async.parallel(taskArray, function(err, results) { } } }); -async.parallelLimit(taskArray, 3, function(err, results) { + +async.parallelLimit(taskArray, 3, (err, results) => { if (results) { const first = results[0]; if (first) { @@ -44,27 +38,21 @@ interface NumberCallback { (err?: Error, result?: number): void; } interface AsyncNumberGetter { (callback: NumberCallback): void; } const taskDict: Lookup = { - one: callback => { - setTimeout(function() { - callback(undefined, 1); - }, 200); - }, - two: callback => { - setTimeout(function() { - callback(undefined, 2); - }, 100); - } + one: callback => { setTimeout(() => { callback(undefined, 1); }, 200); }, + two: callback => { setTimeout(() => { callback(undefined, 2); }, 100); } }; -async.series(taskDict, function(err, results) { +async.series(taskDict, (err, results) => { const one = results['one']; console.log(one && one.toFixed(1)); }); -async.parallel(taskDict, function(err, results) { + +async.parallel(taskDict, (err, results) => { const one = results['one']; console.log(one && one.toFixed(1)); }); -async.parallelLimit(taskDict, 3, function(err, results) { + +async.parallelLimit(taskDict, 3, (err, results) => { const one = results['one']; console.log(one && one.toFixed(1)); }); diff --git a/types/async/test/index.ts b/types/async/test/index.ts index 633afbd575..97e888870b 100644 --- a/types/async/test/index.ts +++ b/types/async/test/index.ts @@ -12,36 +12,34 @@ declare var path: { function funcStringCbErrBoolean(v: string, cb: (err: Error, res: boolean) => void) {} function callback() { } -async.map(['file1', 'file2', 'file3'], fs.stat, function(err: Error, results: fs.Stats[]) { }); -async.mapSeries(['file1', 'file2', 'file3'], fs.stat, function(err: Error, results: fs.Stats[]) { }); -async.mapLimit(['file1', 'file2', 'file3'], 2, fs.stat, function(err: Error, results: fs.Stats[]) { }); +async.map(['file1', 'file2', 'file3'], fs.stat, (err: Error, results: fs.Stats[]) => { }); +async.mapSeries(['file1', 'file2', 'file3'], fs.stat, (err: Error, results: fs.Stats[]) => { }); +async.mapLimit(['file1', 'file2', 'file3'], 2, fs.stat, (err: Error, results: fs.Stats[]) => { }); -async.filter(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function(err: Error, results: string[]) { }); -async.filterSeries(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function(err: Error, results: string[]) { }); -async.filterLimit(['file1', 'file2', 'file3'], 2, funcStringCbErrBoolean, function(err: Error, results: string[]) { }); -async.select(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function(err: Error, results: string[]) { }); -async.selectSeries(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function(err: Error, results: string[]) { }); -async.selectLimit(['file1', 'file2', 'file3'], 2, funcStringCbErrBoolean, function(err: Error, results: string[]) { }); +async.filter(['file1', 'file2', 'file3'], funcStringCbErrBoolean, (err: Error, results: string[]) => { }); +async.filterSeries(['file1', 'file2', 'file3'], funcStringCbErrBoolean, (err: Error, results: string[]) => { }); +async.filterLimit(['file1', 'file2', 'file3'], 2, funcStringCbErrBoolean, (err: Error, results: string[]) => { }); +async.select(['file1', 'file2', 'file3'], funcStringCbErrBoolean, (err: Error, results: string[]) => { }); +async.selectSeries(['file1', 'file2', 'file3'], funcStringCbErrBoolean, (err: Error, results: string[]) => { }); +async.selectLimit(['file1', 'file2', 'file3'], 2, funcStringCbErrBoolean, (err: Error, results: string[]) => { }); -async.reject(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function(err: Error, results: string[]) { }); -async.rejectSeries(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function(err: Error, results: string[]) { }); -async.rejectLimit(['file1', 'file2', 'file3'], 2, funcStringCbErrBoolean, function(err: Error, results: string[]) { }); +async.reject(['file1', 'file2', 'file3'], funcStringCbErrBoolean, (err: Error, results: string[]) => { }); +async.rejectSeries(['file1', 'file2', 'file3'], funcStringCbErrBoolean, (err: Error, results: string[]) => { }); +async.rejectLimit(['file1', 'file2', 'file3'], 2, funcStringCbErrBoolean, (err: Error, results: string[]) => { }); async.parallel([ - function() { }, - function() { } + () => { }, + () => { } ], callback); async.series([ - function() { }, - function() { } + () => { }, + () => { } ]); const data: any[] = []; function asyncProcess(item: any, callback: (err: Error, result: any) => void) { } -async.map(data, asyncProcess, function(err, results) { - console.log(results); -}); +async.map(data, asyncProcess, (err, results) => { console.log(results); }); const openFiles = ['file1', 'file2']; const openFilesObj = { @@ -49,191 +47,107 @@ const openFilesObj = { file2: "fileTwo" }; -const saveFile = function(file: string, cb: (err: Error) => void) { }; -async.each(openFiles, saveFile, function(err: Error) { }); -async.eachSeries(openFiles, saveFile, function(err: Error) { }); +const saveFile = (file: string, cb: (err: Error) => void) => { }; +async.each(openFiles, saveFile, (err: Error) => { }); +async.eachSeries(openFiles, saveFile, (err: Error) => { }); const documents: any[] = []; -const requestApi: async.AsyncIterator = function() {}; -async.eachLimit(documents, 20, requestApi, function(err) { }); +const requestApi: async.AsyncIterator = () => { }; +async.eachLimit(documents, 20, requestApi, err => { }); // forEachOf* functions. May accept array or object. function forEachOfIterator(item: string, key: string, forEachOfIteratorCallback: any) { console.log(`ForEach: item=${item}, key=${key}`); forEachOfIteratorCallback(); } -async.forEachOf(openFiles, forEachOfIterator, function(err) { }); -async.forEachOf(openFilesObj, forEachOfIterator, function(err) { }); -async.forEachOfSeries(openFiles, forEachOfIterator, function(err) { }); -async.forEachOfSeries(openFilesObj, forEachOfIterator, function(err) { }); -async.forEachOfLimit(openFiles, 2, forEachOfIterator, function(err) { }); -async.forEachOfLimit(openFilesObj, 2, forEachOfIterator, function(err) { }); +async.forEachOf(openFiles, forEachOfIterator, err => { }); +async.forEachOf(openFilesObj, forEachOfIterator, err => { }); +async.forEachOfSeries(openFiles, forEachOfIterator, err => { }); +async.forEachOfSeries(openFilesObj, forEachOfIterator, err => { }); +async.forEachOfLimit(openFiles, 2, forEachOfIterator, err => { }); +async.forEachOfLimit(openFilesObj, 2, forEachOfIterator, err => { }); const numArray = [1, 2, 3]; function reducer(memo: any, item: any, callback: any) { - process.nextTick(function() { - callback(null, memo + item); - }); + process.nextTick(() => { callback(null, memo + item); }); } -async.reduce(numArray, 0, reducer, function(err, result) { }); -async.inject(numArray, 0, reducer, function(err, result) { }); -async.foldl(numArray, 0, reducer, function(err, result) { }); -async.reduceRight(numArray, 0, reducer, function(err, result) { }); -async.foldr(numArray, 0, reducer, function(err, result) { }); -async.detect(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function(err: Error, result: string) { }); -async.detectSeries(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function(err, result) { }); -async.detectLimit(['file1', 'file2', 'file3'], 2, funcStringCbErrBoolean, function(err, result) { }); +async.reduce(numArray, 0, reducer, (err, result) => { }); +async.inject(numArray, 0, reducer, (err, result) => { }); +async.foldl(numArray, 0, reducer, (err, result) => { }); +async.reduceRight(numArray, 0, reducer, (err, result) => { }); +async.foldr(numArray, 0, reducer, (err, result) => { }); -async.sortBy(['file1', 'file2', 'file3'], function(file, callback) { - fs.stat(file, function(err, stats) { - callback(err, stats.mtime); - }); -}, function(err, results) { }); +async.detect(['file1', 'file2', 'file3'], funcStringCbErrBoolean, (err: Error, result: string) => { }); +async.detectSeries(['file1', 'file2', 'file3'], funcStringCbErrBoolean, (err, result) => { }); +async.detectLimit(['file1', 'file2', 'file3'], 2, funcStringCbErrBoolean, (err, result) => { }); -async.some(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function(err: Error, result: boolean) { }); -async.someLimit(['file1', 'file2', 'file3'], 2, funcStringCbErrBoolean, function(err: Error, result: boolean) { }); -async.any(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function(err: Error, result: boolean) { }); +async.sortBy(['file1', 'file2', 'file3'], (file, callback) => { + fs.stat(file, (err, stats) => { callback(err, stats.mtime); }); +}, (err, results) => { }); -async.every(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function(err: Error, result: boolean) { }); -async.everyLimit(['file1', 'file2', 'file3'], 2, funcStringCbErrBoolean, function(err: Error, result: boolean) { }); -async.all(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function(err: Error, result: boolean) { }); +async.some(['file1', 'file2', 'file3'], funcStringCbErrBoolean, (err: Error, result: boolean) => { }); +async.someLimit(['file1', 'file2', 'file3'], 2, funcStringCbErrBoolean, (err: Error, result: boolean) => { }); +async.any(['file1', 'file2', 'file3'], funcStringCbErrBoolean, (err: Error, result: boolean) => { }); -async.concat(['dir1', 'dir2', 'dir3'], fs.readdir, function(err, files) { }); -async.concatSeries(['dir1', 'dir2', 'dir3'], fs.readdir, function(err, files) { }); +async.every(['file1', 'file2', 'file3'], funcStringCbErrBoolean, (err: Error, result: boolean) => { }); +async.everyLimit(['file1', 'file2', 'file3'], 2, funcStringCbErrBoolean, (err: Error, result: boolean) => { }); +async.all(['file1', 'file2', 'file3'], funcStringCbErrBoolean, (err: Error, result: boolean) => { }); + +async.concat(['dir1', 'dir2', 'dir3'], fs.readdir, (err, files) => { }); +async.concatSeries(['dir1', 'dir2', 'dir3'], fs.readdir, (err, files) => { }); // Control Flow // -async.series([ - function(callback) { - callback(undefined, 'one'); - }, - function(callback) { - callback(undefined, 'two'); - }, -], -function(err, results) { }); - -async.series([ - function(callback) { - callback(undefined, 'one'); - }, - function(callback) { - callback(undefined, 'two'); - }, -], -function(err, results) { }); +async.series([callback => { callback(undefined, 'one'); }, callback => { callback(undefined, 'two'); }], (err, results) => { }); +async.series([callback => { callback(undefined, 'one'); }, callback => { callback(undefined, 'two'); }], (err, results) => { }); async.series({ - one: callback => { - setTimeout(function() { - callback(undefined, 1); - }, 200); + one: callback => { setTimeout(() => { callback(undefined, 1); }, 200); }, + two: callback => { setTimeout(() => { callback(undefined, 2); }, 100); } }, - two: callback => { - setTimeout(function() { - callback(undefined, 2); - }, 100); - }, -}, -function(err, results) { }); + (err, results) => { }); async.series({ - one: callback => { - setTimeout(function() { - callback(undefined, 1); - }, 200); + one: callback => { setTimeout(() => { callback(undefined, 1); }, 200); }, + two: callback => { setTimeout(() => { callback(undefined, 2); }, 100); } }, - two: callback => { - setTimeout(function() { - callback(undefined, 2); - }, 100); - }, -}, -function(err, results) { }); + (err, results) => { }); -async.times(5, function(n, next) { - next(undefined as any, n); -}, function(err, results) { - console.log(results); -}); +async.times(5, (n, next) => { next(undefined as any, n); }, (err, results) => { console.log(results); }); -async.timesSeries(5, function(n, next) { - next(undefined as any, n); -}, function(err, results) { - console.log(results); -}); +async.timesSeries(5, (n, next) => { next(undefined as any, n); }, (err, results) => { console.log(results); }); async.parallel([ - function(callback) { - setTimeout(function() { - callback(undefined, 'one'); - }, 200); - }, - function(callback) { - setTimeout(function() { - callback(undefined, 'two'); - }, 100); - }, -], -function(err, results) { }); + callback => { setTimeout(() => { callback(undefined, 'one'); }, 200); }, + callback => { setTimeout(() => { callback(undefined, 'two'); }, 100); } + ], + (err, results) => { }); async.parallel([ - function(callback) { - setTimeout(function() { - callback(undefined, 'one'); - }, 200); - }, - function(callback) { - setTimeout(function() { - callback(undefined, 'two'); - }, 100); - }, -], -function(err, results) { }); + callback => { setTimeout(() => { callback(undefined, 'one'); }, 200); }, + callback => { setTimeout(() => { callback(undefined, 'two'); }, 100); } + ], + (err, results) => { }); async.parallel({ - one: callback => { - setTimeout(function() { - callback(undefined, 1); - }, 200); + one: callback => { setTimeout(() => { callback(undefined, 1); }, 200); }, + two: callback => { setTimeout(() => { callback(undefined, 2); }, 100); } }, - two: callback => { - setTimeout(function() { - callback(undefined, 2); - }, 100); - }, -}, -function(err, results) { }); + (err, results) => { }); async.parallel({ - one: callback => { - setTimeout(function() { - callback(undefined, 1); - }, 200); + one: callback => { setTimeout(() => { callback(undefined, 1); }, 200); }, + two: callback => { setTimeout(() => { callback(undefined, 2); }, 100); } }, - two: callback => { - setTimeout(function() { - callback(undefined, 2); - }, 100); - }, -}, - function(err, results) { }); + (err, results) => { }); async.parallelLimit({ - one: callback => { - setTimeout(function() { - callback(undefined, 1); - }, 200); + one: callback => { setTimeout(() => { callback(undefined, 1); }, 200); }, + two: callback => { setTimeout(() => { callback(undefined, 2); }, 100); } }, - two: callback => { - setTimeout(function() { - callback(undefined, 2); - }, 100); - }, -}, 2, - function(err, results) { } + (err, results) => { } ); function whileFn(callback: any) { @@ -244,65 +158,37 @@ function whileTest() { return count < 5; } function doWhileTest(count: number) { return count < 5; } let count = 0; -async.whilst(whileTest, whileFn, function(err) { }); -async.until(whileTest, whileFn, function(err) { }); -async.doWhilst(whileFn, doWhileTest, function(err) { }); -async.doUntil(whileFn, doWhileTest, function(err) { }); +async.whilst(whileTest, whileFn, err => { }); +async.until(whileTest, whileFn, err => { }); +async.doWhilst(whileFn, doWhileTest, err => { }); +async.doUntil(whileFn, doWhileTest, err => { }); -async.during(function(testCallback) { testCallback(new Error(), false); }, function(callback) { callback(); }, function(error) { console.log(error); }); -async.doDuring(function(callback) { callback(); }, function(testCallback) { testCallback(new Error(), false); }, function(error) { console.log(error); }); -async.forever(function(errBack) { - errBack(new Error("Not going on forever.")); -}, - function(error) { - console.log(error); - } -); +async.during(testCallback => { testCallback(new Error(), false); }, callback => { callback(); }, error => { console.log(error); }); +async.doDuring(callback => { callback(); }, testCallback => { testCallback(new Error(), false); }, error => { console.log(error); }); +async.forever(errBack => { errBack(new Error("Not going on forever.")); }, error => { console.log(error); }); async.waterfall([ - function(callback: any) { - callback(null, 'one', 'two'); - }, - function(arg1: any, arg2: any, callback: any) { - callback(null, 'three'); - }, - function(arg1: any, callback: any) { - callback(null, 'done'); - } -], function(err, result) { }); + (callback: any) => { callback(null, 'one', 'two'); }, + (arg1: any, arg2: any, callback: any) => { callback(null, 'three'); }, + (arg1: any, callback: any) => { callback(null, 'done'); } + ], + (err, result) => { }); -const q = async.queue(function(task: any, callback: (err?: Error, msg?: string) => void) { +const q = async.queue((task: any, callback: (err?: Error, msg?: string) => void) => { console.log('hello ' + task.name); callback(undefined, 'a message.'); }, 2); -q.drain = function() { - console.log('all items have been processed'); -}; +q.drain = () => { console.log('all items have been processed'); }; q.push({ name: 'foo' }); - -q.push({ name: 'bar' }, function(err) { - console.log('finished processing bar'); -}); - -q.push([{ name: 'baz' }, { name: 'bay' }, { name: 'bax' }], function(err) { - console.log('finished processing bar'); -}); - -q.push({name: 'foo'}, function(err, msg) { - console.log(`foo finished with a message "${msg!}"`); -}); +q.push({ name: 'bar' }, err => { console.log('finished processing bar'); }); +q.push([{ name: 'baz' }, { name: 'bay' }, { name: 'bax' }], err => { console.log('finished processing bar'); }); +q.push({name: 'foo'}, (err, msg) => { console.log(`foo finished with a message "${msg!}"`); }); q.unshift({ name: 'foo' }); - -q.unshift({ name: 'bar' }, function(err) { - console.log('finished processing bar'); -}); - -q.unshift([{ name: 'baz' }, { name: 'bay' }, { name: 'bax' }], function(err) { - console.log('finished processing bar'); -}); +q.unshift({ name: 'bar' }, err => { console.log('finished processing bar'); }); +q.unshift([{ name: 'baz' }, { name: 'bay' }, { name: 'bax' }], err => { console.log('finished processing bar'); }); const qLength: number = q.length(); const qStarted: boolean = q.started; @@ -310,47 +196,29 @@ const qPaused: boolean = q.paused; const qProcessingCount: number = q.running(); const qIsIdle: boolean = q.idle(); -q.saturated = function() { - console.log('queue is saturated.'); -}; +q.saturated = () => { console.log('queue is saturated.'); }; -q.empty = function() { - console.log('queue is empty.'); -}; +q.empty = () => { console.log('queue is empty.'); }; -q.drain = function() { - console.log('queue was drained.'); -}; +q.drain = () => { console.log('queue was drained.'); }; q.pause(); q.resume(); q.kill(); // tests for strongly typed tasks -const q2 = async.queue(function(task: string, callback: () => void) { +const q2 = async.queue((task: string, callback: () => void) => { console.log('Task: ' + task); callback(); }, 1); q2.push('task1'); - -q2.push('task2', function(error) { - console.log('Finished tasks'); -}); - -q2.push(['task3', 'task4', 'task5'], function(error) { - console.log('Finished tasks'); -}); +q2.push('task2', error => { console.log('Finished tasks'); }); +q2.push(['task3', 'task4', 'task5'], error => { console.log('Finished tasks'); }); q2.unshift('task1'); - -q2.unshift('task2', function(error) { - console.log('Finished tasks'); -}); - -q2.unshift(['task3', 'task4', 'task5'], function(error) { - console.log('Finished tasks'); -}); +q2.unshift('task2', error => { console.log('Finished tasks'); }); +q2.unshift(['task3', 'task4', 'task5'], error => { console.log('Finished tasks'); }); const q2Length = q2.length(); q2.push('testRemovalTask'); @@ -359,17 +227,17 @@ if (q2Length !== q2.length()) { throw new Error('Failed to remove a task from queue.'); } -const aq = async.queue(function(level: number, callback: (error?: Error, newLevel?: number) => void) { +const aq = async.queue((level: number, callback: (error?: Error, newLevel?: number) => void) => { console.log('hello ' + level); callback(undefined, level + 1); }); -aq.push(1, function(err: Error, newLevel: number) { +aq.push(1, (err: Error, newLevel: number) => { console.log('finished processing bar' + newLevel); }); // create a cargo object with payload 2 -const cargo = async.cargo(function(tasks, callback) { +const cargo = async.cargo((tasks, callback) => { for (const task of tasks) { console.log('hello ' + task.name); } @@ -377,15 +245,9 @@ const cargo = async.cargo(function(tasks, callback) { }, 2); // add some items -cargo.push({ name: 'foo' }, function(err: Error) { - console.log('finished processing foo'); -}); -cargo.push({ name: 'bar' }, function(err: Error) { - console.log('finished processing bar'); -}); -cargo.push({ name: 'baz' }, function(err: Error) { - console.log('finished processing baz'); -}); +cargo.push({ name: 'foo' }, (err: Error) => { console.log('finished processing foo'); }); +cargo.push({ name: 'bar' }, (err: Error) => { console.log('finished processing bar'); }); +cargo.push({ name: 'baz' }, (err: Error) => { console.log('finished processing baz'); }); const filename = ''; async.auto({ @@ -393,28 +255,26 @@ async.auto({ make_folder: (callback: AsyncResultCallback) => { }, // arrays with different types are not accepted by TypeScript. - write_file: ['get_data', 'make_folder', function(callback: AsyncResultCallback) { + write_file: ['get_data', 'make_folder', ((callback: AsyncResultCallback) => { callback(null, filename); - } as any], + }) as any], // arrays with different types are not accepted by TypeScript. - email_link: ['write_file', function(callback: AsyncResultCallback, results: any) { } as any] + email_link: ['write_file', ((callback: AsyncResultCallback, results: any) => { }) as any] }); async.auto({ - get_data: (callback: AsyncResultCallback) => { }, - make_folder: (callback: AsyncResultCallback) => { }, + get_data: (callback: AsyncResultCallback) => { }, + make_folder: (callback: AsyncResultCallback) => { }, - // arrays with different types are not accepted by TypeScript. - write_file: ['get_data', 'make_folder', function(callback: AsyncResultCallback) { - callback(null, filename); - } as any], + // arrays with different types are not accepted by TypeScript. + write_file: ['get_data', 'make_folder', ((callback: AsyncResultCallback) => { callback(null, filename); }) as any], - // arrays with different types are not accepted by TypeScript. - email_link: ['write_file', function(callback: AsyncResultCallback, results: any) { } as any] -}, function(err, results) { - console.log('finished auto'); -}); + // arrays with different types are not accepted by TypeScript. + email_link: ['write_file', ((callback: AsyncResultCallback, results: any) => { }) as any] + }, + (err, results) => { console.log('finished auto'); } +); interface A { get_data: any; @@ -424,33 +284,28 @@ interface A { } async.auto({ - get_data: (callback: AsyncResultCallback) => { }, - make_folder: (callback: AsyncResultCallback) => { }, + get_data: (callback: AsyncResultCallback) => { }, + make_folder: (callback: AsyncResultCallback) => { }, - // arrays with different types are not accepted by TypeScript. - write_file: ['get_data', 'make_folder', function(callback: AsyncResultCallback) { - callback(null, filename); - } as any], + // arrays with different types are not accepted by TypeScript. + write_file: ['get_data', 'make_folder', ((callback: AsyncResultCallback) => { callback(null, filename); }) as any], - // arrays with different types are not accepted by TypeScript. - email_link: ['write_file', function(callback: AsyncResultCallback, results: any) { } as any] -}, 1, function(err, results) { - console.log('finished auto'); -}); + // arrays with different types are not accepted by TypeScript. + email_link: ['write_file', ((callback: AsyncResultCallback, results: any) => { }) as any] + }, + 1, + (err, results) => { console.log('finished auto'); } +); -async.retry(3, function(callback, results) { }, function(err, result) { }); -async.retry({ times: 3, interval: 200 }, function(callback, results) { }, function(err, result) { }); -async.retry({ times: 3, interval: (retryCount) => 200 * retryCount }, function(callback, results) { }, function(err, result) { }); +async.retry(3, (callback, results) => { }, (err, result) => { }); +async.retry({ times: 3, interval: 200 }, (callback, results) => { }, (err, result) => { }); +async.retry({ times: 3, interval: (retryCount) => 200 * retryCount }, (callback, results) => { }, (err, result) => { }); async.parallel([ - function(callback: (err: Error, val: string) => void) { }, - function(callback) { } -], -function(err: Error, results: string[]) { - async.series([ - function(callback) { }, - function email_link(callback) { } - ]); + (callback: (err: Error, val: string) => void) => { }, + callback => { } + ], + (err: Error, results: string[]) => { async.series([callback => { }, function email_link(callback) { }]); }); async.parallel([ @@ -459,282 +314,258 @@ async.parallel([ ]); async.parallel([ - function(callback) { - fs.writeFile('testfile1', 'test1', callback); - }, - function(callback) { - fs.writeFile('testfile2', 'test2', callback); - }, + callback => { fs.writeFile('testfile1', 'test1', callback); }, + callback => { fs.writeFile('testfile2', 'test2', callback); } ]); const call_order: string[] = []; -async.nextTick(function() { - call_order.push('two'); -}); +async.nextTick(() => { call_order.push('two'); }); call_order.push('one'); -const slow_fn = function(name: string, callback: any) { - callback(null, 123); -}; +const slow_fn = (name: string, callback: any) => { callback(null, 123); }; const fn = async.memoize(slow_fn); -fn('some name', function() {}); + +fn('some name', () => { }); async.unmemoize(fn); -async.ensureAsync(function() { }); +async.ensureAsync(() => { }); async.constant(42); -async.asyncify(function() { }); +async.asyncify(() => { }); -async.log(function(name: any, callback: any) { - setTimeout(function() { - callback(null, 'hello ' + name); - }, 0); -}, "world" - ); +async.log( + (name: any, callback: any) => { setTimeout(() => { callback(null, 'hello ' + name); }, 0); }, + "world"); -async.dir(function(name: string, callback: any) { - setTimeout(function() { - callback(null, { hello: name }); - }, 1000); -}, "world"); +async.dir((name: string, callback: any) => { setTimeout(() => { callback(null, { hello: name }); }, 1000); }, "world"); // each -async.each({ - a: 1, - b: 2 -}, function(val: number, next: ErrorCallback): void { - setTimeout(function(): void { - console.log(`async.each: ${val}`); - next(); - }, 500); -}, function(err?: Error): void { - console.log("async.each: done."); -}); +async.each( + { a: 1, b: 2 }, + (val: number, next: ErrorCallback) => { + setTimeout(() => { + console.log(`async.each: ${val}`); + next(); + }, + 500); + }, + (err?: Error) => { console.log("async.each: done."); } +); -async.eachSeries({ - a: 1, - b: 2 -}, function(val: number, next: ErrorCallback): void { - setTimeout(function(): void { - console.log(`async.eachSeries: ${val}`); - next(); - }, 500); -}, function(err?: Error): void { - console.log("async.eachSeries: done."); -}); +async.eachSeries( + { a: 1, b: 2 }, + (val: number, next: ErrorCallback) => { + setTimeout( + () => { + console.log(`async.eachSeries: ${val}`); + next(); + }, + 500); + }, + (err?: Error) => { console.log("async.eachSeries: done."); } +); -async.eachLimit({ - a: 1, - b: 2, - c: 3, - d: 4, - e: 5, - f: 6 -}, 2, function(val: number, next: ErrorCallback): void { - setTimeout(function(): void { - console.log(`async.eachLimit: ${val}`); - next(); - }, 500); -}, function(err?: Error): void { - console.log("async.eachLimit: done."); -}); +async.eachLimit( + { a: 1, b: 2, c: 3, d: 4, e: 5, f: 6 }, + 2, + (val: number, next: ErrorCallback) => { + setTimeout(() => { + console.log(`async.eachLimit: ${val}`); + next(); + }, + 500); + }, + (err?: Error) => { console.log("async.eachLimit: done."); } +); // forEachOf/eachOf -async.eachOf({ - a: 1, - b: 2 -}, function(val: number, key: string, next: ErrorCallback): void { - setTimeout(function(): void { - console.log(`async.forEachOf/eachOf: ${key} = ${val}`); - next(); - }, 500); -}, function(err?: Error): void { - console.log("async.forEachOf/eachOf: done."); -}); +async.eachOf( + { a: 1, b: 2 }, + (val: number, key: string, next: ErrorCallback) => { + setTimeout( + () => { + console.log(`async.forEachOf/eachOf: ${key} = ${val}`); + next(); + }, + 500); + }, + (err?: Error) => { console.log("async.forEachOf/eachOf: done."); } +); -async.forEachOfSeries({ - a: 1, - b: 2 -}, function(val: number, key: string, next: ErrorCallback): void { - setTimeout(function(): void { - console.log(`async.forEachOfSeries: ${key} = ${val}`); - next(); - }, 500); -}, function(err?: Error): void { - console.log("async.forEachOfSeries: done."); -}); +async.forEachOfSeries( + { a: 1, b: 2 }, + (val: number, key: string, next: ErrorCallback) => { + setTimeout( + () => { + console.log(`async.forEachOfSeries: ${key} = ${val}`); + next(); + }, + 500); + }, + (err?: Error) => { console.log("async.forEachOfSeries: done."); } +); -async.forEachOfLimit({ - a: 1, - b: 2, - c: 3, - d: 4, - e: 5, - f: 6 -}, 2, function(val: number, key: string, next: ErrorCallback): void { - setTimeout(function(): void { - console.log(`async.forEachOfLimit: ${key} = ${val}`); - next(); - }, 500); -}, function(err?: Error): void { - console.log("async.forEachOfLimit: done."); -}); +async.forEachOfLimit( + { a: 1, b: 2, c: 3, d: 4, e: 5, f: 6 }, + 2, + (val: number, key: string, next: ErrorCallback) => { + setTimeout( + () => { + console.log(`async.forEachOfLimit: ${key} = ${val}`); + next(); + }, + 500); + }, + (err?: Error) => { console.log("async.forEachOfLimit: done."); } +); // map -async.map({ - a: 1, - b: 2, - c: 3 -}, function(val: number, next: AsyncResultCallback): void { - setTimeout(function(): void { - console.log(`async.map: ${val}`); - next(undefined as any, val.toString()); - }, 500); -}, function(err: Error, results: string[]): void { - console.log("async.map: done with results", results); -}); +async.map( + { a: 1, b: 2, c: 3 }, + (val: number, next: AsyncResultCallback) => { + setTimeout( + () => { + console.log(`async.map: ${val}`); + next(undefined as any, val.toString()); + }, + 500); + }, + (err: Error, results: string[]) => { console.log("async.map: done with results", results); } +); -async.mapSeries({ - a: 1, - b: 2, - c: 3 -}, function(val: number, next: AsyncResultCallback): void { - setTimeout(function(): void { - console.log(`async.mapSeries: ${val}`); - next(undefined as any, val.toString()); - }, 500); -}, function(err: Error, results: string[]): void { - console.log("async.mapSeries: done with results", results); -}); +async.mapSeries( + { a: 1, b: 2, c: 3 }, + (val: number, next: AsyncResultCallback) => { + setTimeout( + () => { + console.log(`async.mapSeries: ${val}`); + next(undefined as any, val.toString()); + }, + 500); + }, + (err: Error, results: string[]) => { console.log("async.mapSeries: done with results", results); } +); -async.mapLimit({ - a: 1, - b: 2, - c: 3, - d: 4, - e: 5, - f: 6 -}, 2, function(val: number, next: AsyncResultCallback): void { - setTimeout(function(): void { - console.log(`async.mapLimit: ${val}`); - next(undefined as any, val.toString()); - }, 500); -}, function(err: Error, results: string[]): void { - console.log("async.mapLimit: done with results", results); -}); +async.mapLimit( + { a: 1, b: 2, c: 3, d: 4, e: 5, f: 6 }, + 2, + (val: number, next: AsyncResultCallback) => { + setTimeout( + () => { + console.log(`async.mapLimit: ${val}`); + next(undefined as any, val.toString()); + }, + 500); + }, + (err: Error, results: string[]) => { console.log("async.mapLimit: done with results", results); } +); // mapValues -async.mapValues({ - a: 1, - b: 2, - c: 3 -}, function(val: number, key: string, next: AsyncResultCallback): void { - setTimeout(function(): void { - console.log(`async.mapValues: ${key} = ${val}`); - next(undefined as any, val.toString()); - }, 500); -}, function(err: Error, results: Dictionary): void { - console.log("async.mapValues: done with results", results); -}); +async.mapValues( + { a: 1, b: 2, c: 3 }, + (val: number, key: string, next: AsyncResultCallback) => { + setTimeout( + () => { + console.log(`async.mapValues: ${key} = ${val}`); + next(undefined as any, val.toString()); + }, + 500); + }, + (err: Error, results: Dictionary) => { console.log("async.mapValues: done with results", results); } +); -async.mapValuesSeries({ - a: 1, - b: 2, - c: 3 -}, function(val: number, key: string, next: AsyncResultCallback): void { - setTimeout(function(): void { - console.log(`async.mapValuesSeries: ${key} = ${val}`); - next(undefined as any, val.toString()); - }, 500); -}, function(err: Error, results: Dictionary): void { - console.log("async.mapValuesSeries: done with results", results); -}); +async.mapValuesSeries( + { a: 1, b: 2, c: 3 }, + (val: number, key: string, next: AsyncResultCallback) => { + setTimeout( + () => { + console.log(`async.mapValuesSeries: ${key} = ${val}`); + next(undefined as any, val.toString()); + }, + 500); + }, + (err: Error, results: Dictionary) => { console.log("async.mapValuesSeries: done with results", results); } +); // filter/select/reject -async.filter({ - a: 1, - b: 2, - c: 3 -}, function(val: number, next: AsyncBooleanResultCallback): void { - setTimeout(function(): void { - console.log(`async.filter/select: ${val}`); - next(undefined as any, val % 2 === 0); - }, 500); -}, function(err: Error, results: number[]): void { - console.log("async.filter/select: done with results", results); -}); +async.filter( + { a: 1, b: 2, c: 3 }, + (val: number, next: AsyncBooleanResultCallback) => { + setTimeout( + () => { + console.log(`async.filter/select: ${val}`); + next(undefined as any, val % 2 === 0); + }, + 500); + }, + (err: Error, results: number[]) => { console.log("async.filter/select: done with results", results); } +); -async.reject({ - a: 1, - b: 2, - c: 3 -}, function(val: number, next: AsyncBooleanResultCallback): void { - setTimeout(function(): void { - console.log(`async.reject: ${val}`); - next(undefined as any, val % 2 === 0); - }, 500); -}, function(err: Error, results: number[]): void { - console.log("async.reject: done with results", results); -}); +async.reject( + { a: 1, b: 2, c: 3 }, + (val: number, next: AsyncBooleanResultCallback) => { + setTimeout( + () => { + console.log(`async.reject: ${val}`); + next(undefined as any, val % 2 === 0); + }, + 500); + }, + (err: Error, results: number[]) => { console.log("async.reject: done with results", results); } +); // concat -async.concat({ - a: "1", - b: "2", - c: "3" -}, function(item: string, next: AsyncResultCallback): void { - console.log(`async.concat: ${item}`); - next(undefined as any, [item, item, item]); -}, function(err: Error, results: string[]) { - console.log("async.concat: done with results", results); -}); +async.concat( + { a: "1", b: "2", c: "3" }, + (item: string, next: AsyncResultCallback) => { + console.log(`async.concat: ${item}`); + next(undefined as any, [item, item, item]); + }, + (err: Error, results: string[]) => { console.log("async.concat: done with results", results); } +); // detect/find -async.detect({ - a: 1, - b: 2, - c: 3 -}, function(item: number, next: AsyncBooleanResultCallback): void { - console.log(`async.detect/find: ${item}`); - next(undefined as any, item > 1); -}, function(err: Error, result: number) { - if (err) { - console.log(err); - } else { - console.log("async.detect/find: done with result", result); +async.detect( + { a: 1, b: 2, c: 3 }, + (item: number, next: AsyncBooleanResultCallback) => { + console.log(`async.detect/find: ${item}`); + next(undefined as any, item > 1); + }, + (err: Error, result: number) => { + if (err) { + console.log(err); + } else { + console.log("async.detect/find: done with result", result); + } } -}); +); // every/all -async.every({ - a: 1, - b: 2, - c: 3 -}, function(item: number, next: AsyncBooleanResultCallback): void { - console.log(`async.every/all: ${item}`); - next(undefined as any, item > 0); -}, function(err: Error, result: boolean) { - console.log("async.every/all: done with result", result); -}); +async.every( + { a: 1, b: 2, c: 3 }, + (item: number, next: AsyncBooleanResultCallback) => { + console.log(`async.every/all: ${item}`); + next(undefined as any, item > 0); + }, + (err: Error, result: boolean) => { console.log("async.every/all: done with result", result); } +); // some/any -async.some({ - a: 1, - b: 2, - c: 3 -}, function(item: number, next: AsyncBooleanResultCallback): void { - console.log(`async.some/any: ${item}`); - next(undefined as any, item > 2); -}, function(err: Error, result: boolean) { - console.log("async.some/any: done with result", result); -}); +async.some( + { a: 1, b: 2, c: 3 }, + (item: number, next: AsyncBooleanResultCallback) => { + console.log(`async.some/any: ${item}`); + next(undefined as any, item > 2); + }, + (err: Error, result: boolean) => { console.log("async.some/any: done with result", result); } +); // timeout @@ -743,9 +574,7 @@ function myFunction1(foo: any, callback: (err?: Error, result?: any) => void): v callback(undefined, foo); } const wrapped1 = async.timeout(myFunction1, 1000); -wrapped1({ bar: 'bar' }, function(err: Error, data: any) { - console.log(`async.timeout 1 end ${data}`); -}); +wrapped1({ bar: 'bar' }, (err: Error, data: any) => { console.log(`async.timeout 1 end ${data}`); }); function myFunction2(callback: (err?: Error, result?: any) => void): void { console.log(`async.timeout 2`); @@ -753,9 +582,7 @@ function myFunction2(callback: (err?: Error, result?: any) => void): void { } const wrapped2 = async.timeout(myFunction2, 1000); -wrapped2(function(err: Error, data: any) { - console.log(`async.timeout 2 end ${data}`); -}); +wrapped2((err: Error, data: any) => { console.log(`async.timeout 2 end ${data}`); }); function myFunction3(callback: (err?: Error, result?: any) => void): void { console.log(`async.timeout 3`); @@ -763,6 +590,4 @@ function myFunction3(callback: (err?: Error, result?: any) => void): void { } const wrapped3 = async.timeout(myFunction3, 1000, { bar: 'bar' }); -wrapped3(function(err: Error, data: any) { - console.log(`async.timeout 3 end ${data}`); -}); +wrapped3((err: Error, data: any) => { console.log(`async.timeout 3 end ${data}`); }); diff --git a/types/async/tslint.json b/types/async/tslint.json index 41d9020b53..5612ed6657 100644 --- a/types/async/tslint.json +++ b/types/async/tslint.json @@ -3,7 +3,6 @@ "rules": { "ban-types": true, // PRODUCES ERRORS WHEN REMOVED "callable-types": false, // HAS ISSUES - "no-unnecessary-generics": false, // HAS ISSUES - "only-arrow-functions": false // HAS ISSUES + "no-unnecessary-generics": false // HAS ISSUES } }