From 8c9df8396857ca51ce87103b61a73540aaef368c Mon Sep 17 00:00:00 2001 From: Dmitri Trofimov Date: Fri, 4 Jan 2019 09:23:57 +0200 Subject: [PATCH 01/34] added 'remove' method to async/AsyncQueue --- types/async/index.d.ts | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/types/async/index.d.ts b/types/async/index.d.ts index e6cfd3bcaa..4f5125f225 100644 --- a/types/async/index.d.ts +++ b/types/async/index.d.ts @@ -31,6 +31,10 @@ export type AsyncAutoTask, E> = AsyncAutoTaskFunct export interface AsyncAutoTaskFunctionWithoutDependencies { (cb: AsyncResultCallback | ErrorCallback): void; } export interface AsyncAutoTaskFunction, E = Error> { (results: R, cb: AsyncResultCallback | ErrorCallback): void; } +export interface DataContainer { + data: T; +} + export interface AsyncQueue { length(): number; started: boolean; @@ -39,6 +43,7 @@ export interface AsyncQueue { concurrency: number; push(task: T | T[], callback?: AsyncResultCallback): void; unshift(task: T | T[], callback?: ErrorCallback): void; + remove(filter: (node: DataContainer) => boolean): void; saturated: () => any; empty: () => any; drain: () => any; From 4b9fdb35a1eec08d8de4cdf2ffd7b471854a6e3f Mon Sep 17 00:00:00 2001 From: Dmitri Trofimov Date: Fri, 4 Jan 2019 11:01:40 +0200 Subject: [PATCH 02/34] Test attempt #1 --- types/async/test/index.ts | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/types/async/test/index.ts b/types/async/test/index.ts index 574a5ed8b9..a9272fa67a 100644 --- a/types/async/test/index.ts +++ b/types/async/test/index.ts @@ -355,6 +355,10 @@ q2.unshift(['task3', 'task4', 'task5'], function (error) { console.log('Finished tasks'); }); +let q2Length = q2.length(); +q2.push('testRemovalTask'); +q2.remove(x => x.data === 'testTaskRemoval'); +console.log('how can I fail the test?'); var aq = async.queue(function (level: number, callback: (error?: Error, newLevel?: number) => void) { console.log('hello ' + level); From 823fc6008f125c37c001544c56dffb83e141e092 Mon Sep 17 00:00:00 2001 From: Dmitri Trofimov Date: Fri, 4 Jan 2019 12:23:59 +0200 Subject: [PATCH 03/34] Test attempt #2 --- types/async/test/index.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/types/async/test/index.ts b/types/async/test/index.ts index a9272fa67a..5aff9bb1b4 100644 --- a/types/async/test/index.ts +++ b/types/async/test/index.ts @@ -358,7 +358,7 @@ q2.unshift(['task3', 'task4', 'task5'], function (error) { let q2Length = q2.length(); q2.push('testRemovalTask'); q2.remove(x => x.data === 'testTaskRemoval'); -console.log('how can I fail the test?'); +throw new Error('how can I fail the test?'); var aq = async.queue(function (level: number, callback: (error?: Error, newLevel?: number) => void) { console.log('hello ' + level); From 4c3dae63c30e6626a955c41a4cbe6cbda5c48a5c Mon Sep 17 00:00:00 2001 From: Dmitri Trofimov Date: Fri, 4 Jan 2019 16:23:40 +0200 Subject: [PATCH 04/34] Test attempt #3 --- types/async/test/index.ts | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/types/async/test/index.ts b/types/async/test/index.ts index 5aff9bb1b4..1f7c0fbb9a 100644 --- a/types/async/test/index.ts +++ b/types/async/test/index.ts @@ -358,7 +358,9 @@ q2.unshift(['task3', 'task4', 'task5'], function (error) { let q2Length = q2.length(); q2.push('testRemovalTask'); q2.remove(x => x.data === 'testTaskRemoval'); -throw new Error('how can I fail the test?'); +if (q2Length !== q2.length()) { + throw new Error('how can I fail the test?'); +} var aq = async.queue(function (level: number, callback: (error?: Error, newLevel?: number) => void) { console.log('hello ' + level); From 83f669d928aa4c9bcce903940248d0cebeeffa00 Mon Sep 17 00:00:00 2001 From: Dmitri Trofimov Date: Fri, 4 Jan 2019 16:31:11 +0200 Subject: [PATCH 05/34] fixed test error message --- types/async/test/index.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/types/async/test/index.ts b/types/async/test/index.ts index 1f7c0fbb9a..3803d77e08 100644 --- a/types/async/test/index.ts +++ b/types/async/test/index.ts @@ -359,7 +359,7 @@ let q2Length = q2.length(); q2.push('testRemovalTask'); q2.remove(x => x.data === 'testTaskRemoval'); if (q2Length !== q2.length()) { - throw new Error('how can I fail the test?'); + throw new Error('Failed to remove a task from queue.'); } var aq = async.queue(function (level: number, callback: (error?: Error, newLevel?: number) => void) { From 76de3577c706e4cda1a2280a767877ea4ca5803a Mon Sep 17 00:00:00 2001 From: Dmitri Trofimov Date: Fri, 4 Jan 2019 16:40:46 +0200 Subject: [PATCH 06/34] Added myself to the list of contributors --- types/async/index.d.ts | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/types/async/index.d.ts b/types/async/index.d.ts index 4f5125f225..2f3d37d9f2 100644 --- a/types/async/index.d.ts +++ b/types/async/index.d.ts @@ -1,6 +1,11 @@ // Type definitions for Async 2.0.1 // Project: https://github.com/caolan/async -// Definitions by: Boris Yankov , Arseniy Maximov , Joe Herman , Angus Fenying , Pascal Martin +// Definitions by: Boris Yankov +// Arseniy Maximov +// Joe Herman +// Angus Fenying +// Pascal Martin +// Dmitri Trofimov // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped // TypeScript Version: 2.3 From 602f9483ef157b48e9a7d67b2c7f512cbc281db2 Mon Sep 17 00:00:00 2001 From: Dmitri Trofimov Date: Fri, 4 Jan 2019 17:15:31 +0200 Subject: [PATCH 07/34] Increased Async version number. --- types/async/index.d.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/types/async/index.d.ts b/types/async/index.d.ts index 2f3d37d9f2..e12ac11c93 100644 --- a/types/async/index.d.ts +++ b/types/async/index.d.ts @@ -1,4 +1,4 @@ -// Type definitions for Async 2.0.1 +// Type definitions for Async 2.4.0 // Project: https://github.com/caolan/async // Definitions by: Boris Yankov // Arseniy Maximov From 395cfa4317b398f6e5442094990520623f2a1833 Mon Sep 17 00:00:00 2001 From: Dmitri Trofimov Date: Wed, 16 Jan 2019 11:50:16 +0200 Subject: [PATCH 08/34] Checked enabled lint rules that pass and marked rules that don't pass --- types/async/tslint.json | 57 ++++++++++++++++++++--------------------- 1 file changed, 28 insertions(+), 29 deletions(-) diff --git a/types/async/tslint.json b/types/async/tslint.json index 9380375afa..9aeedb8bc8 100644 --- a/types/async/tslint.json +++ b/types/async/tslint.json @@ -1,34 +1,33 @@ { "extends": "dtslint/dt.json", "rules": { - // TODOs - "arrow-return-shorthand": false, - "array-type": false, - "ban-types": false, - "callable-types": false, - "comment-format": false, - "dt-header": false, - "max-line-length": false, - "no-consecutive-blank-lines": false, - "no-padding": false, - "no-unnecessary-generics": false, - "no-var-keyword": false, - "no-void-expression": false, - "object-literal-key-quotes": false, - "object-literal-shorthand": false, - "one-line": false, - "one-variable-per-declaration": false, - "only-arrow-functions": false, - "prefer-const": false, - "prefer-for-of": false, - "prefer-method-signature": false, - "prefer-template": false, - "semicolon": false, - "space-before-function-paren": false, - "space-within-parens": false, - "trim-file": false, - "typedef-whitespace": false, - "unified-signatures": false, - "whitespace": false + "arrow-return-shorthand": false, // HAS ISSUES + "array-type": false, // HAS ISSUES + "ban-types": true, + "callable-types": false, // HAS ISSUES + "comment-format": true, + "dt-header": false, // HAS ISSUES + "max-line-length": false, // HAS ISSUES + "no-consecutive-blank-lines": false, // HAS ISSUES + "no-padding": false, // HAS ISSUES + "no-unnecessary-generics": false, // HAS ISSUES + "no-var-keyword": false, // HAS ISSUES + "no-void-expression": false, // HAS ISSUES + "object-literal-key-quotes": false, // HAS ISSUES + "object-literal-shorthand": false, // HAS ISSUES + "one-line": true, + "one-variable-per-declaration": false, // HAS ISSUES + "only-arrow-functions": false, // HAS ISSUES + "prefer-const": false, // HAS ISSUES + "prefer-for-of": false, // HAS ISSUES + "prefer-method-signature": false, // HAS ISSUES + "prefer-template": false, // HAS ISSUES + "semicolon": false, // HAS ISSUES + "space-before-function-paren": false, // HAS ISSUES + "space-within-parens": false, // HAS ISSUES + "trim-file": false, // HAS ISSUES + "typedef-whitespace": false, // HAS ISSUES + "unified-signatures": false, // HAS ISSUES + "whitespace": false // HAS ISSUES } } From d004f11f63c1959c5acd34cd3d90f01e19f67fb9 Mon Sep 17 00:00:00 2001 From: Dmitri Trofimov Date: Wed, 16 Jan 2019 11:51:01 +0200 Subject: [PATCH 09/34] Fixed "arrow-return-shorthand" lint rule --- types/async/test/index.ts | 2 +- types/async/tslint.json | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/types/async/test/index.ts b/types/async/test/index.ts index 3803d77e08..2e23b3e90b 100644 --- a/types/async/test/index.ts +++ b/types/async/test/index.ts @@ -438,7 +438,7 @@ async.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) => { return 200 * retryCount; } }, function (callback, results) { }, function (err, result) { }); +async.retry({ times: 3, interval: (retryCount) => 200 * retryCount }, function (callback, results) { }, function (err, result) { }); async.parallel([ diff --git a/types/async/tslint.json b/types/async/tslint.json index 9aeedb8bc8..d8dda64615 100644 --- a/types/async/tslint.json +++ b/types/async/tslint.json @@ -1,7 +1,7 @@ { "extends": "dtslint/dt.json", "rules": { - "arrow-return-shorthand": false, // HAS ISSUES + "arrow-return-shorthand": true, "array-type": false, // HAS ISSUES "ban-types": true, "callable-types": false, // HAS ISSUES From 06e236629e64bdc7f4182a41bd6d9eba34b0ca0a Mon Sep 17 00:00:00 2001 From: Dmitri Trofimov Date: Wed, 16 Jan 2019 11:57:03 +0200 Subject: [PATCH 10/34] Fixed "whitespace" lint rule --- types/async/tslint.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/types/async/tslint.json b/types/async/tslint.json index d8dda64615..19dbc76c7f 100644 --- a/types/async/tslint.json +++ b/types/async/tslint.json @@ -28,6 +28,6 @@ "trim-file": false, // HAS ISSUES "typedef-whitespace": false, // HAS ISSUES "unified-signatures": false, // HAS ISSUES - "whitespace": false // HAS ISSUES + "whitespace": true } } From 729642800155b579a12b9d9ef0dc61903dc6e03d Mon Sep 17 00:00:00 2001 From: Dmitri Trofimov Date: Wed, 16 Jan 2019 16:03:37 +0200 Subject: [PATCH 11/34] Removed all the passing configs from tslint.json --- types/async/tslint.json | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/types/async/tslint.json b/types/async/tslint.json index 19dbc76c7f..d973a60bcf 100644 --- a/types/async/tslint.json +++ b/types/async/tslint.json @@ -1,11 +1,10 @@ { "extends": "dtslint/dt.json", "rules": { - "arrow-return-shorthand": true, "array-type": false, // HAS ISSUES - "ban-types": true, + "ban-types": true, // PRODUCES ERRORS WHEN REMOVED "callable-types": false, // HAS ISSUES - "comment-format": true, + "comment-format": true, // PRODUCES ERRORS WHEN REMOVED "dt-header": false, // HAS ISSUES "max-line-length": false, // HAS ISSUES "no-consecutive-blank-lines": false, // HAS ISSUES @@ -15,7 +14,6 @@ "no-void-expression": false, // HAS ISSUES "object-literal-key-quotes": false, // HAS ISSUES "object-literal-shorthand": false, // HAS ISSUES - "one-line": true, "one-variable-per-declaration": false, // HAS ISSUES "only-arrow-functions": false, // HAS ISSUES "prefer-const": false, // HAS ISSUES @@ -28,6 +26,6 @@ "trim-file": false, // HAS ISSUES "typedef-whitespace": false, // HAS ISSUES "unified-signatures": false, // HAS ISSUES - "whitespace": true + "whitespace": true // PRODUCES ERRORS WHEN REMOVED } } From eeb4b9969a09ec1bebc392cfded34d2f0b831ae1 Mon Sep 17 00:00:00 2001 From: Dmitri Trofimov Date: Wed, 16 Jan 2019 16:13:17 +0200 Subject: [PATCH 12/34] Fixed "whitespace" lint rule --- types/async/index.d.ts | 6 ++-- types/async/test/index.ts | 62 +++++++++++++++++++-------------------- types/async/tslint.json | 3 +- 3 files changed, 35 insertions(+), 36 deletions(-) diff --git a/types/async/index.d.ts b/types/async/index.d.ts index e12ac11c93..87386b13ee 100644 --- a/types/async/index.d.ts +++ b/types/async/index.d.ts @@ -46,7 +46,7 @@ export interface AsyncQueue { running(): number; idle(): boolean; concurrency: number; - push(task: T | T[], callback?: AsyncResultCallback): void; + push(task: T | T[], callback?: AsyncResultCallback): void; unshift(task: T | T[], callback?: ErrorCallback): void; remove(filter: (node: DataContainer) => boolean): void; saturated: () => any; @@ -70,7 +70,7 @@ export interface AsyncPriorityQueue { concurrency: number; started: boolean; paused: boolean; - push(task: T | T[], priority: number, callback?: AsyncResultArrayCallback): void; + push(task: T | T[], priority: number, callback?: AsyncResultArrayCallback): void; saturated: () => any; empty: () => any; drain: () => any; @@ -189,7 +189,7 @@ export function autoInject(tasks: any, callback?: AsyncResultCallback export function retry(opts: number, task: (callback : AsyncResultCallback, results: any) => void, callback: AsyncResultCallback): void; export function retry(opts: { times: number, interval: number|((retryCount: number) => number) }, task: (callback: AsyncResultCallback, results : any) => void, callback: AsyncResultCallback): void; export function retryable(opts: number | {times: number, interval: number}, task: AsyncFunction): AsyncFunction; -export function apply(fn: Function, ...args: any[]): AsyncFunction; +export function apply(fn: Function, ...args: any[]): AsyncFunction; export function nextTick(callback: Function, ...args: any[]): void; export const setImmediate: typeof nextTick; diff --git a/types/async/test/index.ts b/types/async/test/index.ts index 2e23b3e90b..354103eea5 100644 --- a/types/async/test/index.ts +++ b/types/async/test/index.ts @@ -9,23 +9,23 @@ declare var path: { exists: (path: string, callback?: (err: Error, exists: boolean) => any) => void; }; -function funcStringCbErrBoolean(v:string, cb:(err:Error,res:boolean) => void) {} +function funcStringCbErrBoolean(v: string, cb: (err: Error, res: boolean) => void) {} function callback() { } -async.map(['file1', 'file2', 'file3'], fs.stat, function (err:Error, results:Array) { }); -async.mapSeries(['file1', 'file2', 'file3'], fs.stat, function (err:Error, results:Array) { }); -async.mapLimit(['file1', 'file2', 'file3'], 2, fs.stat, function (err:Error, results:Array) { }); +async.map(['file1', 'file2', 'file3'], fs.stat, function (err: Error, results: Array) { }); +async.mapSeries(['file1', 'file2', 'file3'], fs.stat, function (err: Error, results: Array) { }); +async.mapLimit(['file1', 'file2', 'file3'], 2, fs.stat, function (err: Error, results: Array) { }); -async.filter(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function (err:Error,results:Array) { }); -async.filterSeries(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function (err:Error,results:Array) { }); -async.filterLimit(['file1', 'file2', 'file3'], 2, funcStringCbErrBoolean, function (err:Error,results:Array) { }); -async.select(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function (err:Error,results:Array) { }); -async.selectSeries(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function (err:Error,results:Array) { }); -async.selectLimit(['file1', 'file2', 'file3'], 2, funcStringCbErrBoolean, function (err:Error,results:Array) { }); +async.filter(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function (err: Error, results: Array) { }); +async.filterSeries(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function (err: Error, results: Array) { }); +async.filterLimit(['file1', 'file2', 'file3'], 2, funcStringCbErrBoolean, function (err: Error, results: Array) { }); +async.select(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function (err: Error, results: Array) { }); +async.selectSeries(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function (err: Error, results: Array) { }); +async.selectLimit(['file1', 'file2', 'file3'], 2, funcStringCbErrBoolean, function (err: Error, results: Array) { }); -async.reject(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function (err:Error,results:Array) { }); -async.rejectSeries(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function (err:Error,results:Array) { }); -async.rejectLimit(['file1', 'file2', 'file3'], 2, funcStringCbErrBoolean, function (err:Error,results:Array) { }); +async.reject(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function (err: Error, results: Array) { }); +async.rejectSeries(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function (err: Error, results: Array) { }); +async.rejectLimit(['file1', 'file2', 'file3'], 2, funcStringCbErrBoolean, function (err: Error, results: Array) { }); async.parallel([ function () { }, @@ -49,9 +49,9 @@ var openFilesObj = { file2: "fileTwo" } -var saveFile = function (file:string,cb:(err:Error)=>void) { } -async.each(openFiles, saveFile, function (err:Error) { }); -async.eachSeries(openFiles, saveFile, function (err:Error) { }); +var saveFile = function (file: string, cb: (err: Error) => void) { } +async.each(openFiles, saveFile, function (err: Error) { }); +async.eachSeries(openFiles, saveFile, function (err: Error) { }); var documents: any, requestApi: any; async.eachLimit(documents, 20, requestApi, function (err) { }); @@ -80,9 +80,9 @@ 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.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.sortBy(['file1', 'file2', 'file3'], function (file, callback) { fs.stat(file, function (err, stats) { @@ -90,13 +90,13 @@ async.sortBy(['file1', 'file2', 'file3'], function (file, callback) { }); }, function (err, results) { }); -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.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.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.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.concat(['dir1', 'dir2', 'dir3'], fs.readdir, function (err, files) { }); async.concatSeries(['dir1', 'dir2', 'dir3'], fs.readdir, function (err, files) { }); @@ -273,9 +273,9 @@ async.waterfall([ ], function (err, result) { }); -var q = async.queue(function (task: any, callback: (err?:Error,msg?:string) => void) { +var q = async.queue(function (task: any, callback: (err?: Error, msg?: string) => void) { console.log('hello ' + task.name); - callback(undefined,'a message.'); + callback(undefined, 'a message.'); }, 2); @@ -294,7 +294,7 @@ q.push([{ name: 'baz' }, { name: 'bay' }, { name: 'bax' }], function (err) { }); q.push({name: 'foo'}, function (err, msg) { - console.log('foo finished with a message "'+ msg! + '"'); + console.log('foo finished with a message "' + msg! + '"'); }); q.unshift({ name: 'foo' }); @@ -364,7 +364,7 @@ if (q2Length !== q2.length()) { var aq = async.queue(function (level: number, callback: (error?: Error, newLevel?: number) => void) { console.log('hello ' + level); - callback(undefined, level+1); + callback(undefined, level + 1); }); aq.push(1, function (err : Error, newLevel : number) { @@ -442,10 +442,10 @@ async.retry({ times: 3, interval: (retryCount) => 200 * retryCount }, function ( async.parallel([ - function (callback: ( err:Error, val:string ) => void ) { }, + function (callback: ( err: Error, val: string ) => void ) { }, function (callback) { } ], -function (err:Error,results:Array) { +function (err: Error, results: Array) { async.series([ function (callback) { }, function email_link(callback) { } diff --git a/types/async/tslint.json b/types/async/tslint.json index d973a60bcf..1d2ccab47b 100644 --- a/types/async/tslint.json +++ b/types/async/tslint.json @@ -25,7 +25,6 @@ "space-within-parens": false, // HAS ISSUES "trim-file": false, // HAS ISSUES "typedef-whitespace": false, // HAS ISSUES - "unified-signatures": false, // HAS ISSUES - "whitespace": true // PRODUCES ERRORS WHEN REMOVED + "unified-signatures": false // HAS ISSUES } } From f045b26effe6934760130ee38c2daab98abd76b3 Mon Sep 17 00:00:00 2001 From: Dmitri Trofimov Date: Wed, 16 Jan 2019 17:15:44 +0200 Subject: [PATCH 13/34] Fixed "array-type" lint rule --- types/async/index.d.ts | 27 ++++++++++++++------------- types/async/test/index.ts | 26 +++++++++++++------------- types/async/tslint.json | 1 - 3 files changed, 27 insertions(+), 27 deletions(-) diff --git a/types/async/index.d.ts b/types/async/index.d.ts index 87386b13ee..f8ba7e0c2d 100644 --- a/types/async/index.d.ts +++ b/types/async/index.d.ts @@ -32,7 +32,7 @@ export interface AsyncWorker { (task: T, callback: ErrorCallback { (callback: ErrorCallback): void; } export type AsyncAutoTasks, E> = { [K in keyof R]: AsyncAutoTask } -export type AsyncAutoTask, E> = AsyncAutoTaskFunctionWithoutDependencies | (keyof R | AsyncAutoTaskFunction)[]; +export type AsyncAutoTask, E> = AsyncAutoTaskFunctionWithoutDependencies | Array>; export interface AsyncAutoTaskFunctionWithoutDependencies { (cb: AsyncResultCallback | ErrorCallback): void; } export interface AsyncAutoTaskFunction, E = Error> { (results: R, cb: AsyncResultCallback | ErrorCallback): void; } @@ -40,6 +40,14 @@ export interface DataContainer { data: T; } +export interface CallbackContainer { + callback: Function +} + +export interface PriorityContainer { + priority: number; +} + export interface AsyncQueue { length(): number; started: boolean; @@ -56,10 +64,7 @@ export interface AsyncQueue { pause(): void resume(): void; kill(): void; - workersList(): { - data: T, - callback: Function - }[]; + workersList, CallbackContainer>(): TWorker[]; error(error: Error, data: any): void; unsaturated(): void; buffer: number; @@ -79,11 +84,7 @@ export interface AsyncPriorityQueue { pause(): void; resume(): void; kill(): void; - workersList(): { - data: T, - priority: number, - callback: Function - }[]; + workersList, CallbackContainer, PriorityContainer>(): TWorker[]; error(error: Error, data: any): void; unsaturated(): void; buffer: number; @@ -161,7 +162,7 @@ export function concatLimit(arr: IterableCollection, limit: export const concatSeries: typeof concat; // Control Flow -export function series(tasks: AsyncFunction[], callback?: AsyncResultArrayCallback): void; +export function series(tasks: Array>, callback?: AsyncResultArrayCallback): void; export function series(tasks: Dictionary>, callback?: AsyncResultObjectCallback): void; export function parallel(tasks: Array>, callback?: AsyncResultArrayCallback): void; export function parallel(tasks: Dictionary>, callback?: AsyncResultObjectCallback): void; @@ -194,7 +195,7 @@ export function nextTick(callback: Function, ...args: any[]): void; export const setImmediate: typeof nextTick; export function reflect(fn: AsyncFunction) : (callback: (err: null, result: {error?: E, value?: T}) => void) => void; -export function reflectAll(tasks: AsyncFunction[]): ((callback: (err: null, result: {error?: E, value?: T}) => void) => void)[]; +export function reflectAll(tasks: Array>): Array<(callback: (err: null, result: {error?: E, value?: T}) => void) => void>; export function timeout(fn: AsyncFunction, milliseconds: number, info?: any): AsyncFunction; export function timeout(fn: AsyncResultIterator, milliseconds: number, info?: any): AsyncResultIterator; @@ -209,7 +210,7 @@ export function transform(arr: T[], acc: R[], iteratee: (acc: R export function transform(arr: {[key: string] : T}, iteratee: (acc: {[key: string] : R}, item: T, key: string, callback: (error?: E) => void) => void, callback?: AsyncResultObjectCallback): void; export function transform(arr: {[key: string] : T}, acc: {[key: string] : R}, iteratee: (acc: {[key: string] : R}, item: T, key: string, callback: (error?: E) => void) => void, callback?: AsyncResultObjectCallback): void; -export function race(tasks: (AsyncFunction)[], callback: AsyncResultCallback) : void; +export function race(tasks: Array>, callback: AsyncResultCallback) : void; // Utils export function memoize(fn: Function, hasher?: Function): Function; diff --git a/types/async/test/index.ts b/types/async/test/index.ts index 354103eea5..0818ed6669 100644 --- a/types/async/test/index.ts +++ b/types/async/test/index.ts @@ -12,20 +12,20 @@ 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: Array) { }); -async.mapSeries(['file1', 'file2', 'file3'], fs.stat, function (err: Error, results: Array) { }); -async.mapLimit(['file1', 'file2', 'file3'], 2, fs.stat, function (err: Error, results: Array) { }); +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.filter(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function (err: Error, results: Array) { }); -async.filterSeries(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function (err: Error, results: Array) { }); -async.filterLimit(['file1', 'file2', 'file3'], 2, funcStringCbErrBoolean, function (err: Error, results: Array) { }); -async.select(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function (err: Error, results: Array) { }); -async.selectSeries(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function (err: Error, results: Array) { }); -async.selectLimit(['file1', 'file2', 'file3'], 2, funcStringCbErrBoolean, function (err: Error, results: Array) { }); +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.reject(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function (err: Error, results: Array) { }); -async.rejectSeries(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function (err: Error, results: Array) { }); -async.rejectLimit(['file1', 'file2', 'file3'], 2, funcStringCbErrBoolean, function (err: Error, results: Array) { }); +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.parallel([ function () { }, @@ -445,7 +445,7 @@ async.parallel([ function (callback: ( err: Error, val: string ) => void ) { }, function (callback) { } ], -function (err: Error, results: Array) { +function (err: Error, results: string[]) { async.series([ function (callback) { }, function email_link(callback) { } diff --git a/types/async/tslint.json b/types/async/tslint.json index 1d2ccab47b..1ae3d49181 100644 --- a/types/async/tslint.json +++ b/types/async/tslint.json @@ -1,7 +1,6 @@ { "extends": "dtslint/dt.json", "rules": { - "array-type": false, // HAS ISSUES "ban-types": true, // PRODUCES ERRORS WHEN REMOVED "callable-types": false, // HAS ISSUES "comment-format": true, // PRODUCES ERRORS WHEN REMOVED From 8d29540c53bac66ee7accfc224c48a7205444880 Mon Sep 17 00:00:00 2001 From: Dmitri Trofimov Date: Wed, 16 Jan 2019 18:22:55 +0200 Subject: [PATCH 14/34] Fixed "no-padding" lint rule --- types/async/test/index.ts | 114 -------------------------------------- types/async/tslint.json | 1 - 2 files changed, 115 deletions(-) diff --git a/types/async/test/index.ts b/types/async/test/index.ts index 0818ed6669..8d9781fd4a 100644 --- a/types/async/test/index.ts +++ b/types/async/test/index.ts @@ -502,38 +502,24 @@ 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.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.eachLimit({ @@ -544,19 +530,12 @@ async.eachLimit({ "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."); - }); // forEachOf/eachOf @@ -565,38 +544,24 @@ 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.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.forEachOfLimit({ @@ -607,19 +572,12 @@ async.forEachOfLimit({ "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."); - }); // map @@ -629,19 +587,12 @@ async.map({ "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.mapSeries({ @@ -649,19 +600,12 @@ async.mapSeries({ "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.mapLimit({ @@ -672,19 +616,12 @@ async.mapLimit({ "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); - }); // mapValues @@ -694,19 +631,12 @@ async.mapValues({ "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.mapValuesSeries({ @@ -714,19 +644,12 @@ async.mapValuesSeries({ "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); - }); // filter/select/reject @@ -736,19 +659,12 @@ async.filter({ "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.reject({ @@ -756,19 +672,12 @@ async.reject({ "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); - }); // concat @@ -778,15 +687,10 @@ async.concat({ "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); - }); // detect/find @@ -796,22 +700,14 @@ async.detect({ "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); } - }); // every/all @@ -821,15 +717,10 @@ async.every({ "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); - }); // some/any @@ -839,15 +730,10 @@ async.some({ "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); - }); // timeout diff --git a/types/async/tslint.json b/types/async/tslint.json index 1ae3d49181..8a86925d1a 100644 --- a/types/async/tslint.json +++ b/types/async/tslint.json @@ -7,7 +7,6 @@ "dt-header": false, // HAS ISSUES "max-line-length": false, // HAS ISSUES "no-consecutive-blank-lines": false, // HAS ISSUES - "no-padding": false, // HAS ISSUES "no-unnecessary-generics": false, // HAS ISSUES "no-var-keyword": false, // HAS ISSUES "no-void-expression": false, // HAS ISSUES From 9bfa52c409453f02f0e3afd54be52612ed54e878 Mon Sep 17 00:00:00 2001 From: Dmitri1337 Date: Wed, 16 Jan 2019 18:28:06 +0200 Subject: [PATCH 15/34] Fixed "trim-file" lint rule --- types/async/test/explicit.ts | 3 --- types/async/test/index.ts | 1 - types/async/tslint.json | 1 - 3 files changed, 5 deletions(-) diff --git a/types/async/test/explicit.ts b/types/async/test/explicit.ts index 0c0e1a44ee..39d831fd65 100644 --- a/types/async/test/explicit.ts +++ b/types/async/test/explicit.ts @@ -1,5 +1,3 @@ - - interface StringCallback { (err?: Error, result?: string): void; } interface AsyncStringGetter { (callback: StringCallback): void; } @@ -71,4 +69,3 @@ async.parallelLimit(taskDict, 3, function(err, results) { let one = results['one']; console.log(one && one.toFixed(1)) }); - diff --git a/types/async/test/index.ts b/types/async/test/index.ts index 8d9781fd4a..1b1c794044 100644 --- a/types/async/test/index.ts +++ b/types/async/test/index.ts @@ -767,4 +767,3 @@ var wrapped3 = async.timeout(myFunction3, 1000, { bar: 'bar' }); wrapped3( function(err : Error, data : any) { console.log(`async.timeout 3 end ${data}`); }); - diff --git a/types/async/tslint.json b/types/async/tslint.json index 8a86925d1a..2074a7856c 100644 --- a/types/async/tslint.json +++ b/types/async/tslint.json @@ -21,7 +21,6 @@ "semicolon": false, // HAS ISSUES "space-before-function-paren": false, // HAS ISSUES "space-within-parens": false, // HAS ISSUES - "trim-file": false, // HAS ISSUES "typedef-whitespace": false, // HAS ISSUES "unified-signatures": false // HAS ISSUES } From 5b73d190ef56658e2e18a32f6a3a995845f871dc Mon Sep 17 00:00:00 2001 From: Dmitri1337 Date: Wed, 16 Jan 2019 18:32:50 +0200 Subject: [PATCH 16/34] Fixed "semicolon" lint rule --- types/async/index.d.ts | 8 ++-- types/async/test/es6-generators.ts | 70 +++++++++++++++--------------- types/async/test/explicit.ts | 14 +++--- types/async/test/index.ts | 30 ++++++------- types/async/tslint.json | 1 - 5 files changed, 61 insertions(+), 62 deletions(-) diff --git a/types/async/index.d.ts b/types/async/index.d.ts index f8ba7e0c2d..6260eb9344 100644 --- a/types/async/index.d.ts +++ b/types/async/index.d.ts @@ -12,7 +12,7 @@ export as namespace async; export interface Dictionary { [key: string]: T; } -export type IterableCollection = T[] | IterableIterator | Dictionary +export type IterableCollection = T[] | IterableIterator | Dictionary; export interface ErrorCallback { (err?: E | null): void; } export interface AsyncBooleanResultCallback { (err?: E | null, truthValue?: boolean): void; } @@ -31,7 +31,7 @@ export interface AsyncBooleanIterator { (item: T, callback: AsyncB export interface AsyncWorker { (task: T, callback: ErrorCallback): void; } export interface AsyncVoidFunction { (callback: ErrorCallback): void; } -export type AsyncAutoTasks, E> = { [K in keyof R]: AsyncAutoTask } +export type AsyncAutoTasks, E> = { [K in keyof R]: AsyncAutoTask }; export type AsyncAutoTask, E> = AsyncAutoTaskFunctionWithoutDependencies | Array>; export interface AsyncAutoTaskFunctionWithoutDependencies { (cb: AsyncResultCallback | ErrorCallback): void; } export interface AsyncAutoTaskFunction, E = Error> { (results: R, cb: AsyncResultCallback | ErrorCallback): void; } @@ -41,7 +41,7 @@ export interface DataContainer { } export interface CallbackContainer { - callback: Function + callback: Function; } export interface PriorityContainer { @@ -61,7 +61,7 @@ export interface AsyncQueue { empty: () => any; drain: () => any; paused: boolean; - pause(): void + pause(): void; resume(): void; kill(): void; workersList, CallbackContainer>(): TWorker[]; diff --git a/types/async/test/es6-generators.ts b/types/async/test/es6-generators.ts index b67e7daad7..ec9d51e245 100644 --- a/types/async/test/es6-generators.ts +++ b/types/async/test/es6-generators.ts @@ -10,45 +10,45 @@ function eachOfIterator(item: T, key: K, callback: (err: Error) => void function concatIterator(item: T, callback: (err: E, res: R[]) => void) { } -async.map(collectionGenerator(), funcMapIterator, funcMapComplete) -async.mapSeries(collectionGenerator(), funcMapIterator, funcMapComplete) -async.mapLimit(collectionGenerator(), 2, funcMapIterator, funcMapComplete) +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, 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.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, 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.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, 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.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, 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.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, 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.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, 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.concat(collectionGenerator(), concatIterator, (err: Error, res: any[]) => { }) -async.concatSeries(collectionGenerator(), concatIterator, (err: Error, res: any[]) => { }) +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 39d831fd65..eaa62d3f06 100644 --- a/types/async/test/explicit.ts +++ b/types/async/test/explicit.ts @@ -18,7 +18,7 @@ async.series(taskArray, function (err, results) { if (results) { let first = results[0]; if (first) { - console.log(first.match(/o/)) + console.log(first.match(/o/)); } } }); @@ -26,7 +26,7 @@ async.parallel(taskArray, function (err, results) { if (results) { let first = results[0]; if (first) { - console.log(first.match(/o/)) + console.log(first.match(/o/)); } } }); @@ -34,7 +34,7 @@ async.parallelLimit(taskArray, 3, function (err, results) { if (results) { let first = results[0]; if (first) { - console.log(first.match(/o/)) + console.log(first.match(/o/)); } } }); @@ -55,17 +55,17 @@ var taskDict: Lookup = { callback(undefined, 2); }, 100); } -} +}; async.series(taskDict, function(err, results) { let one = results['one']; - console.log(one && one.toFixed(1)) + console.log(one && one.toFixed(1)); }); async.parallel(taskDict, function(err, results) { let one = results['one']; - console.log(one && one.toFixed(1)) + console.log(one && one.toFixed(1)); }); async.parallelLimit(taskDict, 3, function(err, results) { let one = results['one']; - console.log(one && one.toFixed(1)) + console.log(one && one.toFixed(1)); }); diff --git a/types/async/test/index.ts b/types/async/test/index.ts index 1b1c794044..5117199024 100644 --- a/types/async/test/index.ts +++ b/types/async/test/index.ts @@ -47,9 +47,9 @@ var openFiles = ['file1', 'file2']; var openFilesObj = { file1: "fileOne", file2: "fileTwo" -} +}; -var saveFile = function (file: string, cb: (err: Error) => void) { } +var saveFile = function (file: string, cb: (err: Error) => void) { }; async.each(openFiles, saveFile, function (err: Error) { }); async.eachSeries(openFiles, saveFile, function (err: Error) { }); @@ -71,7 +71,7 @@ async.forEachOfLimit(openFilesObj, 2, forEachOfIterator, function (err) { }); var numArray = [1, 2, 3]; function reducer(memo: any, item: any, callback: any) { process.nextTick(function () { - callback(null, memo + item) + callback(null, memo + item); }); } async.reduce(numArray, 0, reducer, function (err, result) { }); @@ -153,16 +153,16 @@ async.series({ function (err, results) { }); async.times(5, function(n, next) { - next(undefined as any, n) + next(undefined as any, n); }, function(err, results) { - console.log(results) -}) + console.log(results); +}); async.timesSeries(5, function(n, next) { - next(undefined as any, n) + next(undefined as any, n); }, function(err, results) { - console.log(results) -}) + console.log(results); +}); async.parallel([ function (callback) { @@ -250,8 +250,8 @@ async.until(whileTest, whileFn, function (err) { }); async.doWhilst(whileFn, doWhileTest, function (err) { }); async.doUntil(whileFn, doWhileTest, function (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.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.")); }, @@ -281,7 +281,7 @@ var q = async.queue(function (task: any, callback: (err?: Error, msg?: stri q.drain = function () { console.log('all items have been processed'); -} +}; q.push({ name: 'foo' }); @@ -315,15 +315,15 @@ var qIsIdle : boolean = q.idle(); q.saturated = function() { console.log('queue is saturated.'); -} +}; q.empty = function() { console.log('queue is empty.'); -} +}; q.drain = function() { console.log('queue was drained.'); -} +}; q.pause(); q.resume(); diff --git a/types/async/tslint.json b/types/async/tslint.json index 2074a7856c..220166f178 100644 --- a/types/async/tslint.json +++ b/types/async/tslint.json @@ -18,7 +18,6 @@ "prefer-for-of": false, // HAS ISSUES "prefer-method-signature": false, // HAS ISSUES "prefer-template": false, // HAS ISSUES - "semicolon": false, // HAS ISSUES "space-before-function-paren": false, // HAS ISSUES "space-within-parens": false, // HAS ISSUES "typedef-whitespace": false, // HAS ISSUES From 4af081994e1cbf1ed0eb952f3c4c63c9ef83b92b Mon Sep 17 00:00:00 2001 From: Dmitri1337 Date: Wed, 16 Jan 2019 18:40:10 +0200 Subject: [PATCH 17/34] Fixed "typedef-whitesapce" lint rule --- types/async/index.d.ts | 20 ++++++++++---------- types/async/test/index.ts | 24 ++++++++++++------------ types/async/tslint.json | 1 - 3 files changed, 22 insertions(+), 23 deletions(-) diff --git a/types/async/index.d.ts b/types/async/index.d.ts index 6260eb9344..5b7797bde0 100644 --- a/types/async/index.d.ts +++ b/types/async/index.d.ts @@ -93,7 +93,7 @@ export interface AsyncPriorityQueue { export interface AsyncCargo { length(): number; payload?: number; - push(task: any, callback? : Function): void; + push(task: any, callback?: Function): void; saturated(): void; empty(): void; drain(): void; @@ -172,9 +172,9 @@ export function whilst(test: () => boolean, fn: AsyncVoidFunction, export function doWhilst(fn: AsyncFunctionEx, test: (...results: T[]) => boolean, callback: ErrorCallback): void; export function until(test: () => boolean, fn: AsyncVoidFunction, callback: ErrorCallback): void; export function doUntil(fn: AsyncFunctionEx, test: (...results: T[]) => boolean, callback: ErrorCallback): void; -export function during(test: (testCallback : AsyncBooleanResultCallback) => void, fn: AsyncVoidFunction, callback: ErrorCallback): void; +export function during(test: (testCallback: AsyncBooleanResultCallback) => void, fn: AsyncVoidFunction, callback: ErrorCallback): void; export function doDuring(fn: AsyncVoidFunction, test: (testCallback: AsyncBooleanResultCallback) => void, callback: ErrorCallback): void; -export function forever(next: (next : ErrorCallback) => void, errBack: ErrorCallback) : void; +export function forever(next: (next: ErrorCallback) => void, errBack: ErrorCallback): void; export function waterfall(tasks: Function[], callback?: AsyncResultCallback): void; export function compose(...fns: Function[]): Function; export function seq(...fns: Function[]): Function; @@ -183,18 +183,18 @@ export function applyEachSeries(fns: Function[], ...argsAndCallback: any[]): voi export function queue(worker: AsyncWorker, concurrency?: number): AsyncQueue; export function queue(worker: AsyncResultIterator, concurrency?: number): AsyncQueue; export function priorityQueue(worker: AsyncWorker, concurrency: number): AsyncPriorityQueue; -export function cargo(worker : (tasks: any[], callback : ErrorCallback) => void, payload? : number) : AsyncCargo; +export function cargo(worker: (tasks: any[], callback: ErrorCallback) => void, payload?: number): AsyncCargo; export function auto, E = Error>(tasks: AsyncAutoTasks, concurrency?: number, callback?: AsyncResultCallback): void; export function auto, E = Error>(tasks: AsyncAutoTasks, callback?: AsyncResultCallback): void; export function autoInject(tasks: any, callback?: AsyncResultCallback): void; -export function retry(opts: number, task: (callback : AsyncResultCallback, results: any) => void, callback: AsyncResultCallback): void; -export function retry(opts: { times: number, interval: number|((retryCount: number) => number) }, task: (callback: AsyncResultCallback, results : any) => void, callback: AsyncResultCallback): void; +export function retry(opts: number, task: (callback: AsyncResultCallback, results: any) => void, callback: AsyncResultCallback): void; +export function retry(opts: { times: number, interval: number|((retryCount: number) => number) }, task: (callback: AsyncResultCallback, results: any) => void, callback: AsyncResultCallback): void; export function retryable(opts: number | {times: number, interval: number}, task: AsyncFunction): AsyncFunction; export function apply(fn: Function, ...args: any[]): AsyncFunction; export function nextTick(callback: Function, ...args: any[]): void; export const setImmediate: typeof nextTick; -export function reflect(fn: AsyncFunction) : (callback: (err: null, result: {error?: E, value?: T}) => void) => void; +export function reflect(fn: AsyncFunction): (callback: (err: null, result: {error?: E, value?: T}) => void) => void; export function reflectAll(tasks: Array>): Array<(callback: (err: null, result: {error?: E, value?: T}) => void) => void>; export function timeout(fn: AsyncFunction, milliseconds: number, info?: any): AsyncFunction; @@ -207,10 +207,10 @@ export function timesLimit(n: number, limit: number, iterator: Asy export function transform(arr: T[], iteratee: (acc: R[], item: T, key: number, callback: (error?: E) => void) => void, callback?: AsyncResultArrayCallback): void; export function transform(arr: T[], acc: R[], iteratee: (acc: R[], item: T, key: number, callback: (error?: E) => void) => void, callback?: AsyncResultArrayCallback): void; -export function transform(arr: {[key: string] : T}, iteratee: (acc: {[key: string] : R}, item: T, key: string, callback: (error?: E) => void) => void, callback?: AsyncResultObjectCallback): void; -export function transform(arr: {[key: string] : T}, acc: {[key: string] : R}, iteratee: (acc: {[key: string] : R}, item: T, key: string, callback: (error?: E) => void) => void, callback?: AsyncResultObjectCallback): void; +export function transform(arr: {[key: string]: T}, iteratee: (acc: {[key: string]: R}, item: T, key: string, callback: (error?: E) => void) => void, callback?: AsyncResultObjectCallback): void; +export function transform(arr: {[key: string]: T}, acc: {[key: string]: R}, iteratee: (acc: {[key: string]: R}, item: T, key: string, callback: (error?: E) => void) => void, callback?: AsyncResultObjectCallback): void; -export function race(tasks: Array>, callback: AsyncResultCallback) : void; +export function race(tasks: Array>, callback: AsyncResultCallback): void; // Utils export function memoize(fn: Function, hasher?: Function): Function; diff --git a/types/async/test/index.ts b/types/async/test/index.ts index 5117199024..f2dd5bb2aa 100644 --- a/types/async/test/index.ts +++ b/types/async/test/index.ts @@ -307,11 +307,11 @@ q.unshift([{ name: 'baz' }, { name: 'bay' }, { name: 'bax' }], function (err) { console.log('finished processing bar'); }); -var qLength : number = q.length(); -var qStarted : boolean = q.started; -var qPaused : boolean = q.paused; -var qProcessingCount : number = q.running(); -var qIsIdle : boolean = q.idle(); +var qLength: number = q.length(); +var qStarted: boolean = q.started; +var qPaused: boolean = q.paused; +var qProcessingCount: number = q.running(); +var qIsIdle: boolean = q.idle(); q.saturated = function() { console.log('queue is saturated.'); @@ -367,7 +367,7 @@ var aq = async.queue(function (level: number, callback: (error?: callback(undefined, level + 1); }); -aq.push(1, function (err : Error, newLevel : number) { +aq.push(1, function (err: Error, newLevel: number) { console.log('finished processing bar' + newLevel); }); @@ -738,32 +738,32 @@ async.some({ // timeout -function myFunction1(foo : any, callback: (err?: Error, result?: any) => void ) : void { +function myFunction1(foo: any, callback: (err?: Error, result?: any) => void ): void { console.log(`async.timeout 1 ${foo}`); return callback(undefined, foo); } var wrapped1 = async.timeout(myFunction1, 1000); -wrapped1({ bar: 'bar' }, function(err : Error, data : any) { +wrapped1({ bar: 'bar' }, function(err: Error, data: any) { console.log(`async.timeout 1 end ${data}`); }); -function myFunction2(callback: (err?: Error, result?: any) => void ) : void { +function myFunction2(callback: (err?: Error, result?: any) => void ): void { console.log(`async.timeout 2`); return callback(undefined, { bar: 'bar' }); } var wrapped2 = async.timeout(myFunction2, 1000); -wrapped2( function(err : Error, data : any) { +wrapped2( function(err: Error, data: any) { console.log(`async.timeout 2 end ${data}`); }); -function myFunction3(callback: (err?: Error, result?: any) => void ) : void { +function myFunction3(callback: (err?: Error, result?: any) => void ): void { console.log(`async.timeout 3`); return callback(undefined, { bar: 'bar' }); } var wrapped3 = async.timeout(myFunction3, 1000, { bar: 'bar' }); -wrapped3( function(err : Error, data : any) { +wrapped3( function(err: Error, data: any) { console.log(`async.timeout 3 end ${data}`); }); diff --git a/types/async/tslint.json b/types/async/tslint.json index 220166f178..1da4c92ed9 100644 --- a/types/async/tslint.json +++ b/types/async/tslint.json @@ -20,7 +20,6 @@ "prefer-template": false, // HAS ISSUES "space-before-function-paren": false, // HAS ISSUES "space-within-parens": false, // HAS ISSUES - "typedef-whitespace": false, // HAS ISSUES "unified-signatures": false // HAS ISSUES } } From ced24f9e198d5303d00d45e17cab2da15c018896 Mon Sep 17 00:00:00 2001 From: Dmitri1337 Date: Wed, 16 Jan 2019 18:42:55 +0200 Subject: [PATCH 18/34] Fixed "space-within-parens" lint rule --- types/async/test/index.ts | 12 ++++++------ types/async/tslint.json | 1 - 2 files changed, 6 insertions(+), 7 deletions(-) diff --git a/types/async/test/index.ts b/types/async/test/index.ts index f2dd5bb2aa..f71c1bb53b 100644 --- a/types/async/test/index.ts +++ b/types/async/test/index.ts @@ -442,7 +442,7 @@ async.retry({ times: 3, interval: (retryCount) => 200 * retryCount }, function ( async.parallel([ - function (callback: ( err: Error, val: string ) => void ) { }, + function (callback: (err: Error, val: string) => void) { }, function (callback) { } ], function (err: Error, results: string[]) { @@ -738,7 +738,7 @@ async.some({ // timeout -function myFunction1(foo: any, callback: (err?: Error, result?: any) => void ): void { +function myFunction1(foo: any, callback: (err?: Error, result?: any) => void): void { console.log(`async.timeout 1 ${foo}`); return callback(undefined, foo); } @@ -748,22 +748,22 @@ wrapped1({ bar: 'bar' }, function(err: Error, data: any) { }); -function myFunction2(callback: (err?: Error, result?: any) => void ): void { +function myFunction2(callback: (err?: Error, result?: any) => void): void { console.log(`async.timeout 2`); return callback(undefined, { bar: 'bar' }); } var wrapped2 = async.timeout(myFunction2, 1000); -wrapped2( function(err: Error, data: any) { +wrapped2(function(err: Error, data: any) { console.log(`async.timeout 2 end ${data}`); }); -function myFunction3(callback: (err?: Error, result?: any) => void ): void { +function myFunction3(callback: (err?: Error, result?: any) => void): void { console.log(`async.timeout 3`); return callback(undefined, { bar: 'bar' }); } var wrapped3 = async.timeout(myFunction3, 1000, { bar: 'bar' }); -wrapped3( function(err: Error, data: any) { +wrapped3(function(err: Error, data: any) { console.log(`async.timeout 3 end ${data}`); }); diff --git a/types/async/tslint.json b/types/async/tslint.json index 1da4c92ed9..ca5a0426d3 100644 --- a/types/async/tslint.json +++ b/types/async/tslint.json @@ -19,7 +19,6 @@ "prefer-method-signature": false, // HAS ISSUES "prefer-template": false, // HAS ISSUES "space-before-function-paren": false, // HAS ISSUES - "space-within-parens": false, // HAS ISSUES "unified-signatures": false // HAS ISSUES } } From edf4a6cf40a3a106821ca4b2ae04c92e77e6fe03 Mon Sep 17 00:00:00 2001 From: Dmitri1337 Date: Wed, 16 Jan 2019 18:48:31 +0200 Subject: [PATCH 19/34] Fixed "space-before-function-paren" lint rule --- types/async/index.d.ts | 2 +- types/async/test/es6-generators.ts | 60 +++--- types/async/test/explicit.ts | 14 +- types/async/test/index.ts | 300 ++++++++++++++--------------- types/async/tslint.json | 1 - 5 files changed, 188 insertions(+), 189 deletions(-) diff --git a/types/async/index.d.ts b/types/async/index.d.ts index 5b7797bde0..2bfaf3d179 100644 --- a/types/async/index.d.ts +++ b/types/async/index.d.ts @@ -200,7 +200,7 @@ export function reflectAll(tasks: Array>): Arr export function timeout(fn: AsyncFunction, milliseconds: number, info?: any): AsyncFunction; export function timeout(fn: AsyncResultIterator, milliseconds: number, info?: any): AsyncResultIterator; -export function times (n: number, iterator: AsyncResultIterator, callback: AsyncResultArrayCallback): void; +export function times(n: number, iterator: AsyncResultIterator, callback: AsyncResultArrayCallback): void; export function timesSeries(n: number, iterator: AsyncResultIterator, callback: AsyncResultArrayCallback): void; export function timesLimit(n: number, limit: number, iterator: AsyncResultIterator, callback: AsyncResultArrayCallback): void; diff --git a/types/async/test/es6-generators.ts b/types/async/test/es6-generators.ts index ec9d51e245..92215e5deb 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, 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.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, 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.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, 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.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, 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.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, 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.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, 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.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 eaa62d3f06..a0f8af17b2 100644 --- a/types/async/test/explicit.ts +++ b/types/async/test/explicit.ts @@ -2,19 +2,19 @@ interface StringCallback { (err?: Error, result?: string): void; } interface AsyncStringGetter { (callback: StringCallback): void; } var taskArray: AsyncStringGetter[] = [ - function (callback) { - setTimeout(function () { + function(callback) { + setTimeout(function() { callback(undefined, 'one'); }, 200); }, - function (callback) { - setTimeout(function () { + function(callback) { + setTimeout(function() { callback(undefined, 'two'); }, 100); }, ]; -async.series(taskArray, function (err, results) { +async.series(taskArray, function(err, results) { if (results) { let first = results[0]; if (first) { @@ -22,7 +22,7 @@ async.series(taskArray, function (err, results) { } } }); -async.parallel(taskArray, function (err, results) { +async.parallel(taskArray, function(err, results) { if (results) { let first = results[0]; if (first) { @@ -30,7 +30,7 @@ async.parallel(taskArray, function (err, results) { } } }); -async.parallelLimit(taskArray, 3, function (err, results) { +async.parallelLimit(taskArray, 3, function(err, results) { if (results) { let first = results[0]; if (first) { diff --git a/types/async/test/index.ts b/types/async/test/index.ts index f71c1bb53b..71406a793f 100644 --- a/types/async/test/index.ts +++ b/types/async/test/index.ts @@ -12,34 +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, 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.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, 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.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, 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.parallel([ - function () { }, - function () { } + function() { }, + function() { } ], callback); async.series([ - function () { }, - function () { } + function() { }, + function() { } ]); var data: any[] = []; function asyncProcess(item: any, callback: (err: Error, result: any) => void) { } -async.map(data, asyncProcess, function (err, results) { +async.map(data, asyncProcess, function(err, results) { console.log(results); }); @@ -49,108 +49,108 @@ var openFilesObj = { file2: "fileTwo" }; -var saveFile = function (file: string, cb: (err: Error) => void) { }; -async.each(openFiles, saveFile, function (err: Error) { }); -async.eachSeries(openFiles, saveFile, function (err: Error) { }); +var saveFile = function(file: string, cb: (err: Error) => void) { }; +async.each(openFiles, saveFile, function(err: Error) { }); +async.eachSeries(openFiles, saveFile, function(err: Error) { }); var documents: any, requestApi: any; -async.eachLimit(documents, 20, requestApi, function (err) { }); +async.eachLimit(documents, 20, requestApi, function(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, 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) { }); var numArray = [1, 2, 3]; function reducer(memo: any, item: any, callback: any) { - process.nextTick(function () { + process.nextTick(function() { 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.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.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.sortBy(['file1', 'file2', 'file3'], function (file, callback) { - fs.stat(file, function (err, stats) { +async.sortBy(['file1', 'file2', 'file3'], function(file, callback) { + fs.stat(file, function(err, stats) { callback(err, stats.mtime); }); -}, function (err, results) { }); +}, function(err, results) { }); -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.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.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.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.concat(['dir1', 'dir2', 'dir3'], fs.readdir, function (err, files) { }); -async.concatSeries(['dir1', 'dir2', 'dir3'], fs.readdir, function (err, files) { }); +async.concat(['dir1', 'dir2', 'dir3'], fs.readdir, function(err, files) { }); +async.concatSeries(['dir1', 'dir2', 'dir3'], fs.readdir, function(err, files) { }); // Control Flow // async.series([ - function (callback) { + function(callback) { callback(undefined, 'one'); }, - function (callback) { + function(callback) { callback(undefined, 'two'); }, ], -function (err, results) { }); +function(err, results) { }); async.series([ - function (callback) { + function(callback) { callback(undefined, 'one'); }, - function (callback) { + function(callback) { callback(undefined, 'two'); }, ], -function (err, results) { }); +function(err, results) { }); async.series({ - one: function (callback) { - setTimeout(function () { + one: function(callback) { + setTimeout(function() { callback(undefined, 1); }, 200); }, - two: function (callback) { - setTimeout(function () { + two: function(callback) { + setTimeout(function() { callback(undefined, 2); }, 100); }, }, -function (err, results) { }); +function(err, results) { }); async.series({ - one: function (callback) { - setTimeout(function () { + one: function(callback) { + setTimeout(function() { callback(undefined, 1); }, 200); }, - two: function (callback) { - setTimeout(function () { + two: function(callback) { + setTimeout(function() { callback(undefined, 2); }, 100); }, }, -function (err, results) { }); +function(err, results) { }); async.times(5, function(n, next) { next(undefined as any, n); @@ -165,76 +165,76 @@ async.timesSeries(5, function(n, next) { }); async.parallel([ - function (callback) { - setTimeout(function () { + function(callback) { + setTimeout(function() { callback(undefined, 'one'); }, 200); }, - function (callback) { - setTimeout(function () { + function(callback) { + setTimeout(function() { callback(undefined, 'two'); }, 100); }, ], -function (err, results) { }); +function(err, results) { }); async.parallel([ - function (callback) { - setTimeout(function () { + function(callback) { + setTimeout(function() { callback(undefined, 'one'); }, 200); }, - function (callback) { - setTimeout(function () { + function(callback) { + setTimeout(function() { callback(undefined, 'two'); }, 100); }, ], -function (err, results) { }); +function(err, results) { }); async.parallel({ - one: function (callback) { - setTimeout(function () { + one: function(callback) { + setTimeout(function() { callback(undefined, 1); }, 200); }, - two: function (callback) { - setTimeout(function () { + two: function(callback) { + setTimeout(function() { callback(undefined, 2); }, 100); }, }, -function (err, results) { }); +function(err, results) { }); async.parallel({ - one: function (callback) { - setTimeout(function () { + one: function(callback) { + setTimeout(function() { callback(undefined, 1); }, 200); }, - two: function (callback) { - setTimeout(function () { + two: function(callback) { + setTimeout(function() { callback(undefined, 2); }, 100); }, }, - function (err, results) { }); + function(err, results) { }); async.parallelLimit({ - one: function (callback) { - setTimeout(function () { + one: function(callback) { + setTimeout(function() { callback(undefined, 1); }, 200); }, - two: function (callback) { - setTimeout(function () { + two: function(callback) { + setTimeout(function() { callback(undefined, 2); }, 100); }, }, 2, - function (err, results) { } + function(err, results) { } ); @@ -245,65 +245,65 @@ function whileFn(callback: any) { function whileTest() { return count < 5; } function doWhileTest(count: number) { return count < 5; } var 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, function(err) { }); +async.until(whileTest, whileFn, function(err) { }); +async.doWhilst(whileFn, doWhileTest, function(err) { }); +async.doUntil(whileFn, doWhileTest, function(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) { +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) { + function(error) { console.log(error); } ); async.waterfall([ - function (callback: any) { + function(callback: any) { callback(null, 'one', 'two'); }, - function (arg1: any, arg2: any, callback: any) { + function(arg1: any, arg2: any, callback: any) { callback(null, 'three'); }, - function (arg1: any, callback: any) { + function(arg1: any, callback: any) { callback(null, 'done'); } -], function (err, result) { }); +], function(err, result) { }); -var q = async.queue(function (task: any, callback: (err?: Error, msg?: string) => void) { +var q = async.queue(function(task: any, callback: (err?: Error, msg?: string) => void) { console.log('hello ' + task.name); callback(undefined, 'a message.'); }, 2); -q.drain = function () { +q.drain = function() { console.log('all items have been processed'); }; q.push({ name: 'foo' }); -q.push({ name: 'bar' }, function (err) { +q.push({ name: 'bar' }, function(err) { console.log('finished processing bar'); }); -q.push([{ name: 'baz' }, { name: 'bay' }, { name: 'bax' }], function (err) { +q.push([{ name: 'baz' }, { name: 'bay' }, { name: 'bax' }], function(err) { console.log('finished processing bar'); }); -q.push({name: 'foo'}, function (err, msg) { +q.push({name: 'foo'}, function(err, msg) { console.log('foo finished with a message "' + msg! + '"'); }); q.unshift({ name: 'foo' }); -q.unshift({ name: 'bar' }, function (err) { +q.unshift({ name: 'bar' }, function(err) { console.log('finished processing bar'); }); -q.unshift([{ name: 'baz' }, { name: 'bay' }, { name: 'bax' }], function (err) { +q.unshift([{ name: 'baz' }, { name: 'bay' }, { name: 'bax' }], function(err) { console.log('finished processing bar'); }); @@ -330,28 +330,28 @@ q.resume(); q.kill(); // tests for strongly typed tasks -var q2 = async.queue(function (task: string, callback: () => void) { +var q2 = async.queue(function(task: string, callback: () => void) { console.log('Task: ' + task); callback(); }, 1); q2.push('task1'); -q2.push('task2', function (error) { +q2.push('task2', function(error) { console.log('Finished tasks'); }); -q2.push(['task3', 'task4', 'task5'], function (error) { +q2.push(['task3', 'task4', 'task5'], function(error) { console.log('Finished tasks'); }); q2.unshift('task1'); -q2.unshift('task2', function (error) { +q2.unshift('task2', function(error) { console.log('Finished tasks'); }); -q2.unshift(['task3', 'task4', 'task5'], function (error) { +q2.unshift(['task3', 'task4', 'task5'], function(error) { console.log('Finished tasks'); }); @@ -362,17 +362,17 @@ if (q2Length !== q2.length()) { throw new Error('Failed to remove a task from queue.'); } -var aq = async.queue(function (level: number, callback: (error?: Error, newLevel?: number) => void) { +var aq = async.queue(function(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, function(err: Error, newLevel: number) { console.log('finished processing bar' + newLevel); }); // create a cargo object with payload 2 -var cargo = async.cargo(function (tasks, callback) { +var cargo = async.cargo(function(tasks, callback) { for (var i = 0; i < tasks.length; i++) { console.log('hello ' + tasks[i].name); } @@ -381,38 +381,38 @@ var cargo = async.cargo(function (tasks, callback) { // add some items -cargo.push({ name: 'foo' }, function (err: Error) { +cargo.push({ name: 'foo' }, function(err: Error) { console.log('finished processing foo'); }); -cargo.push({ name: 'bar' }, function (err: Error) { +cargo.push({ name: 'bar' }, function(err: Error) { console.log('finished processing bar'); }); -cargo.push({ name: 'baz' }, function (err: Error) { +cargo.push({ name: 'baz' }, function(err: Error) { console.log('finished processing baz'); }); var filename = ''; async.auto({ - get_data: function (callback: AsyncResultCallback) { }, - make_folder: function (callback: AsyncResultCallback) { }, + get_data: function(callback: AsyncResultCallback) { }, + make_folder: function(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', function(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] + email_link: ['write_file', function(callback: AsyncResultCallback, results: any) { } as any] }); async.auto({ - get_data: function (callback: AsyncResultCallback) { }, - make_folder: function (callback: AsyncResultCallback) { }, + get_data: function(callback: AsyncResultCallback) { }, + make_folder: function(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', function(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) { + email_link: ['write_file', function(callback: AsyncResultCallback, results: any) { } as any] +}, function(err, results) { console.log('finished auto'); }); @@ -424,30 +424,30 @@ interface A { } async.auto({ - get_data: function (callback: AsyncResultCallback) { }, - make_folder: function (callback: AsyncResultCallback) { }, + get_data: function(callback: AsyncResultCallback) { }, + make_folder: function(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', function(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) { + email_link: ['write_file', function(callback: AsyncResultCallback, results: any) { } as any] +}, 1, function(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, 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.parallel([ - function (callback: (err: Error, val: string) => void) { }, - function (callback) { } + function(callback: (err: Error, val: string) => void) { }, + function(callback) { } ], -function (err: Error, results: string[]) { +function(err: Error, results: string[]) { async.series([ - function (callback) { }, + function(callback) { }, function email_link(callback) { } ]); }); @@ -459,39 +459,39 @@ async.parallel([ async.parallel([ - function (callback) { + function(callback) { fs.writeFile('testfile1', 'test1', callback); }, - function (callback) { + function(callback) { fs.writeFile('testfile2', 'test2', callback); }, ]); var call_order: string[] = []; -async.nextTick(function () { +async.nextTick(function() { call_order.push('two'); }); call_order.push('one'); -var slow_fn = function (name: string, callback: any) { +var slow_fn = function(name: string, callback: any) { callback(null, 123); }; var fn = async.memoize(slow_fn); -fn('some name', function () {}); +fn('some name', function() {}); async.unmemoize(fn); -async.ensureAsync(function () { }); +async.ensureAsync(function() { }); async.constant(42); -async.asyncify(function () { }); +async.asyncify(function() { }); -async.log(function (name: any, callback: any) { - setTimeout(function () { +async.log(function(name: any, callback: any) { + setTimeout(function() { callback(null, 'hello ' + name); }, 0); }, "world" ); -async.dir(function (name: string, callback: any) { - setTimeout(function () { +async.dir(function(name: string, callback: any) { + setTimeout(function() { callback(null, { hello: name }); }, 1000); }, "world"); diff --git a/types/async/tslint.json b/types/async/tslint.json index ca5a0426d3..8c1a002a64 100644 --- a/types/async/tslint.json +++ b/types/async/tslint.json @@ -18,7 +18,6 @@ "prefer-for-of": false, // HAS ISSUES "prefer-method-signature": false, // HAS ISSUES "prefer-template": false, // HAS ISSUES - "space-before-function-paren": false, // HAS ISSUES "unified-signatures": false // HAS ISSUES } } From 5a6bb529e48a486244d33246b11568c5bddb306b Mon Sep 17 00:00:00 2001 From: Dmitri1337 Date: Wed, 16 Jan 2019 18:53:31 +0200 Subject: [PATCH 20/34] Fixed "prefer-template" lint rule --- types/async/test/index.ts | 4 ++-- types/async/tslint.json | 1 - 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/types/async/test/index.ts b/types/async/test/index.ts index 71406a793f..d5915ed6f0 100644 --- a/types/async/test/index.ts +++ b/types/async/test/index.ts @@ -58,7 +58,7 @@ async.eachLimit(documents, 20, requestApi, function(err) { }); // forEachOf* functions. May accept array or object. function forEachOfIterator(item: string, key: string, forEachOfIteratorCallback: any) { - console.log("ForEach: item=" + item + ", key=" + key); + console.log(`ForEach: item=${item}, key=${key}`); forEachOfIteratorCallback(); } async.forEachOf(openFiles, forEachOfIterator, function(err) { }); @@ -294,7 +294,7 @@ q.push([{ name: 'baz' }, { name: 'bay' }, { name: 'bax' }], function(err) { }); q.push({name: 'foo'}, function(err, msg) { - console.log('foo finished with a message "' + msg! + '"'); + console.log(`foo finished with a message "${msg!}"`); }); q.unshift({ name: 'foo' }); diff --git a/types/async/tslint.json b/types/async/tslint.json index 8c1a002a64..35058f4fc8 100644 --- a/types/async/tslint.json +++ b/types/async/tslint.json @@ -17,7 +17,6 @@ "prefer-const": false, // HAS ISSUES "prefer-for-of": false, // HAS ISSUES "prefer-method-signature": false, // HAS ISSUES - "prefer-template": false, // HAS ISSUES "unified-signatures": false // HAS ISSUES } } From e3dd4b2ca4182ac6ea628d728695a2639c553950 Mon Sep 17 00:00:00 2001 From: Dmitri1337 Date: Wed, 16 Jan 2019 19:08:08 +0200 Subject: [PATCH 21/34] Fixed "prefer-const" lint rule --- types/async/test/explicit.ts | 12 ++++----- types/async/test/index.ts | 49 ++++++++++++++++++------------------ types/async/tslint.json | 1 - 3 files changed, 31 insertions(+), 31 deletions(-) diff --git a/types/async/test/explicit.ts b/types/async/test/explicit.ts index a0f8af17b2..7435d9a370 100644 --- a/types/async/test/explicit.ts +++ b/types/async/test/explicit.ts @@ -16,7 +16,7 @@ var taskArray: AsyncStringGetter[] = [ async.series(taskArray, function(err, results) { if (results) { - let first = results[0]; + const first = results[0]; if (first) { console.log(first.match(/o/)); } @@ -24,7 +24,7 @@ async.series(taskArray, function(err, results) { }); async.parallel(taskArray, function(err, results) { if (results) { - let first = results[0]; + const first = results[0]; if (first) { console.log(first.match(/o/)); } @@ -32,7 +32,7 @@ async.parallel(taskArray, function(err, results) { }); async.parallelLimit(taskArray, 3, function(err, results) { if (results) { - let first = results[0]; + const first = results[0]; if (first) { console.log(first.match(/o/)); } @@ -58,14 +58,14 @@ var taskDict: Lookup = { }; async.series(taskDict, function(err, results) { - let one = results['one']; + const one = results['one']; console.log(one && one.toFixed(1)); }); async.parallel(taskDict, function(err, results) { - let one = results['one']; + const one = results['one']; console.log(one && one.toFixed(1)); }); async.parallelLimit(taskDict, 3, function(err, results) { - let one = results['one']; + 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 d5915ed6f0..e30ef8971c 100644 --- a/types/async/test/index.ts +++ b/types/async/test/index.ts @@ -37,24 +37,25 @@ async.series([ function() { } ]); -var data: any[] = []; +const data: any[] = []; function asyncProcess(item: any, callback: (err: Error, result: any) => void) { } async.map(data, asyncProcess, function(err, results) { console.log(results); }); -var openFiles = ['file1', 'file2']; -var openFilesObj = { +const openFiles = ['file1', 'file2']; +const openFilesObj = { file1: "fileOne", file2: "fileTwo" }; -var saveFile = function(file: string, cb: (err: Error) => void) { }; +const saveFile = function(file: string, cb: (err: Error) => void) { }; async.each(openFiles, saveFile, function(err: Error) { }); async.eachSeries(openFiles, saveFile, function(err: Error) { }); -var documents: any, requestApi: any; -async.eachLimit(documents, 20, requestApi, function(err) { }); +const documents: any[] = []; +const requestApi: async.AsyncIterator = function() {}; +async.eachLimit(documents, 20, requestApi, function(err) { }); // forEachOf* functions. May accept array or object. function forEachOfIterator(item: string, key: string, forEachOfIteratorCallback: any) { @@ -68,7 +69,7 @@ async.forEachOfSeries(openFilesObj, forEachOfIterator, function(err) { }); async.forEachOfLimit(openFiles, 2, forEachOfIterator, function(err) { }); async.forEachOfLimit(openFilesObj, 2, forEachOfIterator, function(err) { }); -var numArray = [1, 2, 3]; +const numArray = [1, 2, 3]; function reducer(memo: any, item: any, callback: any) { process.nextTick(function() { callback(null, memo + item); @@ -273,7 +274,7 @@ async.waterfall([ ], function(err, result) { }); -var q = async.queue(function(task: any, callback: (err?: Error, msg?: string) => void) { +const q = async.queue(function(task: any, callback: (err?: Error, msg?: string) => void) { console.log('hello ' + task.name); callback(undefined, 'a message.'); }, 2); @@ -307,11 +308,11 @@ q.unshift([{ name: 'baz' }, { name: 'bay' }, { name: 'bax' }], function(err) { console.log('finished processing bar'); }); -var qLength: number = q.length(); -var qStarted: boolean = q.started; -var qPaused: boolean = q.paused; -var qProcessingCount: number = q.running(); -var qIsIdle: boolean = q.idle(); +const qLength: number = q.length(); +const qStarted: boolean = q.started; +const qPaused: boolean = q.paused; +const qProcessingCount: number = q.running(); +const qIsIdle: boolean = q.idle(); q.saturated = function() { console.log('queue is saturated.'); @@ -330,7 +331,7 @@ q.resume(); q.kill(); // tests for strongly typed tasks -var q2 = async.queue(function(task: string, callback: () => void) { +const q2 = async.queue(function(task: string, callback: () => void) { console.log('Task: ' + task); callback(); }, 1); @@ -355,14 +356,14 @@ q2.unshift(['task3', 'task4', 'task5'], function(error) { console.log('Finished tasks'); }); -let q2Length = q2.length(); +const q2Length = q2.length(); q2.push('testRemovalTask'); q2.remove(x => x.data === 'testTaskRemoval'); if (q2Length !== q2.length()) { throw new Error('Failed to remove a task from queue.'); } -var aq = async.queue(function(level: number, callback: (error?: Error, newLevel?: number) => void) { +const aq = async.queue(function(level: number, callback: (error?: Error, newLevel?: number) => void) { console.log('hello ' + level); callback(undefined, level + 1); }); @@ -372,7 +373,7 @@ aq.push(1, function(err: Error, newLevel: number) { }); // create a cargo object with payload 2 -var cargo = async.cargo(function(tasks, callback) { +const cargo = async.cargo(function(tasks, callback) { for (var i = 0; i < tasks.length; i++) { console.log('hello ' + tasks[i].name); } @@ -391,7 +392,7 @@ cargo.push({ name: 'baz' }, function(err: Error) { console.log('finished processing baz'); }); -var filename = ''; +const filename = ''; async.auto({ get_data: function(callback: AsyncResultCallback) { }, make_folder: function(callback: AsyncResultCallback) { }, @@ -467,16 +468,16 @@ async.parallel([ }, ]); -var call_order: string[] = []; +const call_order: string[] = []; async.nextTick(function() { call_order.push('two'); }); call_order.push('one'); -var slow_fn = function(name: string, callback: any) { +const slow_fn = function(name: string, callback: any) { callback(null, 123); }; -var fn = async.memoize(slow_fn); +const fn = async.memoize(slow_fn); fn('some name', function() {}); async.unmemoize(fn); async.ensureAsync(function() { }); @@ -742,7 +743,7 @@ function myFunction1(foo: any, callback: (err?: Error, result?: any) => void): v console.log(`async.timeout 1 ${foo}`); return callback(undefined, foo); } -var wrapped1 = async.timeout(myFunction1, 1000); +const wrapped1 = async.timeout(myFunction1, 1000); wrapped1({ bar: 'bar' }, function(err: Error, data: any) { console.log(`async.timeout 1 end ${data}`); }); @@ -753,7 +754,7 @@ function myFunction2(callback: (err?: Error, result?: any) => void): void { return callback(undefined, { bar: 'bar' }); } -var wrapped2 = async.timeout(myFunction2, 1000); +const wrapped2 = async.timeout(myFunction2, 1000); wrapped2(function(err: Error, data: any) { console.log(`async.timeout 2 end ${data}`); }); @@ -763,7 +764,7 @@ function myFunction3(callback: (err?: Error, result?: any) => void): void { return callback(undefined, { bar: 'bar' }); } -var wrapped3 = async.timeout(myFunction3, 1000, { bar: 'bar' }); +const wrapped3 = async.timeout(myFunction3, 1000, { bar: 'bar' }); wrapped3(function(err: Error, data: any) { console.log(`async.timeout 3 end ${data}`); }); diff --git a/types/async/tslint.json b/types/async/tslint.json index 35058f4fc8..08dc9769c3 100644 --- a/types/async/tslint.json +++ b/types/async/tslint.json @@ -14,7 +14,6 @@ "object-literal-shorthand": false, // HAS ISSUES "one-variable-per-declaration": false, // HAS ISSUES "only-arrow-functions": false, // HAS ISSUES - "prefer-const": false, // HAS ISSUES "prefer-for-of": false, // HAS ISSUES "prefer-method-signature": false, // HAS ISSUES "unified-signatures": false // HAS ISSUES From 5146b08c03197fc557c466f90e148a4d8fb90d58 Mon Sep 17 00:00:00 2001 From: Dmitri1337 Date: Wed, 16 Jan 2019 19:11:05 +0200 Subject: [PATCH 22/34] Fixed "prefer-for-of" lint rule --- types/async/test/index.ts | 4 ++-- types/async/tslint.json | 1 - 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/types/async/test/index.ts b/types/async/test/index.ts index e30ef8971c..1190e116a5 100644 --- a/types/async/test/index.ts +++ b/types/async/test/index.ts @@ -374,8 +374,8 @@ aq.push(1, function(err: Error, newLevel: number) { // create a cargo object with payload 2 const cargo = async.cargo(function(tasks, callback) { - for (var i = 0; i < tasks.length; i++) { - console.log('hello ' + tasks[i].name); + for (const task of tasks) { + console.log('hello ' + task.name); } callback(); }, 2); diff --git a/types/async/tslint.json b/types/async/tslint.json index 08dc9769c3..38462966f1 100644 --- a/types/async/tslint.json +++ b/types/async/tslint.json @@ -14,7 +14,6 @@ "object-literal-shorthand": false, // HAS ISSUES "one-variable-per-declaration": false, // HAS ISSUES "only-arrow-functions": false, // HAS ISSUES - "prefer-for-of": false, // HAS ISSUES "prefer-method-signature": false, // HAS ISSUES "unified-signatures": false // HAS ISSUES } From 7fc4b845bdaf8997bac7d5e65facba766af0742c Mon Sep 17 00:00:00 2001 From: Dmitri1337 Date: Wed, 16 Jan 2019 19:12:18 +0200 Subject: [PATCH 23/34] Fixed "prefer-method-signature" lint rule --- types/async/tslint.json | 1 - 1 file changed, 1 deletion(-) diff --git a/types/async/tslint.json b/types/async/tslint.json index 38462966f1..87f0d7e486 100644 --- a/types/async/tslint.json +++ b/types/async/tslint.json @@ -14,7 +14,6 @@ "object-literal-shorthand": false, // HAS ISSUES "one-variable-per-declaration": false, // HAS ISSUES "only-arrow-functions": false, // HAS ISSUES - "prefer-method-signature": false, // HAS ISSUES "unified-signatures": false // HAS ISSUES } } From 055945ed042a9dee173d2efd38011518aa661d9e Mon Sep 17 00:00:00 2001 From: Dmitri1337 Date: Wed, 16 Jan 2019 19:13:17 +0200 Subject: [PATCH 24/34] Fixed "one-variable-per-declaration" lint rule --- types/async/tslint.json | 1 - 1 file changed, 1 deletion(-) diff --git a/types/async/tslint.json b/types/async/tslint.json index 87f0d7e486..3242f68010 100644 --- a/types/async/tslint.json +++ b/types/async/tslint.json @@ -12,7 +12,6 @@ "no-void-expression": false, // HAS ISSUES "object-literal-key-quotes": false, // HAS ISSUES "object-literal-shorthand": false, // HAS ISSUES - "one-variable-per-declaration": false, // HAS ISSUES "only-arrow-functions": false, // HAS ISSUES "unified-signatures": false // HAS ISSUES } From 539c368b488e72e4d21e35665b6e573e879e0e3c Mon Sep 17 00:00:00 2001 From: Dmitri1337 Date: Wed, 16 Jan 2019 19:14:31 +0200 Subject: [PATCH 25/34] Fixed "dt-header" lint rule --- types/async/index.d.ts | 2 +- types/async/tslint.json | 1 - 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/types/async/index.d.ts b/types/async/index.d.ts index 2bfaf3d179..e9e43cdd42 100644 --- a/types/async/index.d.ts +++ b/types/async/index.d.ts @@ -1,4 +1,4 @@ -// Type definitions for Async 2.4.0 +// Type definitions for Async 2.4 // Project: https://github.com/caolan/async // Definitions by: Boris Yankov // Arseniy Maximov diff --git a/types/async/tslint.json b/types/async/tslint.json index 3242f68010..37f3654327 100644 --- a/types/async/tslint.json +++ b/types/async/tslint.json @@ -4,7 +4,6 @@ "ban-types": true, // PRODUCES ERRORS WHEN REMOVED "callable-types": false, // HAS ISSUES "comment-format": true, // PRODUCES ERRORS WHEN REMOVED - "dt-header": false, // HAS ISSUES "max-line-length": false, // HAS ISSUES "no-consecutive-blank-lines": false, // HAS ISSUES "no-unnecessary-generics": false, // HAS ISSUES From 390d7b39f9233b12f996d973f4b163fe3a742409 Mon Sep 17 00:00:00 2001 From: Dmitri1337 Date: Wed, 16 Jan 2019 19:19:12 +0200 Subject: [PATCH 26/34] Fixed "max-line-length" lint rule --- types/async/index.d.ts | 34 ++++++++++++++++++++++++++++++---- types/async/tslint.json | 1 - 2 files changed, 30 insertions(+), 5 deletions(-) diff --git a/types/async/index.d.ts b/types/async/index.d.ts index e9e43cdd42..48a9d12335 100644 --- a/types/async/index.d.ts +++ b/types/async/index.d.ts @@ -120,7 +120,14 @@ export function map(arr: T[] | IterableIterator, iterator: A export function map(arr: Dictionary, iterator: AsyncResultIterator, callback?: AsyncResultArrayCallback): void; export const mapSeries: typeof map; export function mapLimit(arr: IterableCollection, limit: number, iterator: AsyncResultIterator, callback?: AsyncResultArrayCallback): void; -export function mapValuesLimit(obj: Dictionary, limit: number, iteratee: (value: T, key: string, callback: AsyncResultCallback) => void, callback: AsyncResultObjectCallback): void; + +export function mapValuesLimit( + obj: Dictionary, + limit: number, + iteratee: (value: T, key: string, callback: AsyncResultCallback) => void, + callback: AsyncResultObjectCallback + ): void; + export function mapValues(obj: Dictionary, iteratee: (value: T, key: string, callback: AsyncResultCallback) => void, callback: AsyncResultObjectCallback): void; export const mapValuesSeries: typeof mapValues; export function filter(arr: IterableCollection, iterator: AsyncBooleanIterator, callback?: AsyncResultArrayCallback): void; @@ -188,7 +195,16 @@ export function auto, E = Error>(tasks: AsyncAutoTasks export function auto, E = Error>(tasks: AsyncAutoTasks, callback?: AsyncResultCallback): void; export function autoInject(tasks: any, callback?: AsyncResultCallback): void; export function retry(opts: number, task: (callback: AsyncResultCallback, results: any) => void, callback: AsyncResultCallback): void; -export function retry(opts: { times: number, interval: number|((retryCount: number) => number) }, task: (callback: AsyncResultCallback, results: any) => void, callback: AsyncResultCallback): void; + +export function retry( + opts: { + times: number, + interval: number | ((retryCount: number) => number) + }, + task: (callback: AsyncResultCallback, results: any) => void, + callback: AsyncResultCallback + ): void; + export function retryable(opts: number | {times: number, interval: number}, task: AsyncFunction): AsyncFunction; export function apply(fn: Function, ...args: any[]): AsyncFunction; export function nextTick(callback: Function, ...args: any[]): void; @@ -207,8 +223,18 @@ export function timesLimit(n: number, limit: number, iterator: Asy export function transform(arr: T[], iteratee: (acc: R[], item: T, key: number, callback: (error?: E) => void) => void, callback?: AsyncResultArrayCallback): void; export function transform(arr: T[], acc: R[], iteratee: (acc: R[], item: T, key: number, callback: (error?: E) => void) => void, callback?: AsyncResultArrayCallback): void; -export function transform(arr: {[key: string]: T}, iteratee: (acc: {[key: string]: R}, item: T, key: string, callback: (error?: E) => void) => void, callback?: AsyncResultObjectCallback): void; -export function transform(arr: {[key: string]: T}, acc: {[key: string]: R}, iteratee: (acc: {[key: string]: R}, item: T, key: string, callback: (error?: E) => void) => void, callback?: AsyncResultObjectCallback): void; +export function transform( + arr: {[key: string]: T}, + iteratee: (acc: {[key: string]: R}, item: T, key: string, callback: (error?: E) => void) => void, + callback?: AsyncResultObjectCallback + ): void; + +export function transform( + arr: {[key: string]: T}, + acc: {[key: string]: R}, + iteratee: (acc: {[key: string]: R}, item: T, key: string, callback: (error?: E) => void) => void, + callback?: AsyncResultObjectCallback + ): void; export function race(tasks: Array>, callback: AsyncResultCallback): void; diff --git a/types/async/tslint.json b/types/async/tslint.json index 37f3654327..94e7dc42fd 100644 --- a/types/async/tslint.json +++ b/types/async/tslint.json @@ -4,7 +4,6 @@ "ban-types": true, // PRODUCES ERRORS WHEN REMOVED "callable-types": false, // HAS ISSUES "comment-format": true, // PRODUCES ERRORS WHEN REMOVED - "max-line-length": false, // HAS ISSUES "no-consecutive-blank-lines": false, // HAS ISSUES "no-unnecessary-generics": false, // HAS ISSUES "no-var-keyword": false, // HAS ISSUES From 58192b28b855312e2275b1ab4cd60d94ee50a862 Mon Sep 17 00:00:00 2001 From: Dmitri1337 Date: Wed, 16 Jan 2019 19:21:25 +0200 Subject: [PATCH 27/34] Fixed "no-consecutive-blank-lines" lint rule --- types/async/test/explicit.ts | 1 - types/async/test/index.ts | 9 --------- types/async/tslint.json | 1 - 3 files changed, 11 deletions(-) diff --git a/types/async/test/explicit.ts b/types/async/test/explicit.ts index 7435d9a370..8f910e4b37 100644 --- a/types/async/test/explicit.ts +++ b/types/async/test/explicit.ts @@ -39,7 +39,6 @@ async.parallelLimit(taskArray, 3, function(err, results) { } }); - interface Lookup { [key: string]: T; } interface NumberCallback { (err?: Error, result?: number): void; } interface AsyncNumberGetter { (callback: NumberCallback): void; } diff --git a/types/async/test/index.ts b/types/async/test/index.ts index 1190e116a5..9a7e033e2a 100644 --- a/types/async/test/index.ts +++ b/types/async/test/index.ts @@ -102,7 +102,6 @@ async.all(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function(err: Err async.concat(['dir1', 'dir2', 'dir3'], fs.readdir, function(err, files) { }); async.concatSeries(['dir1', 'dir2', 'dir3'], fs.readdir, function(err, files) { }); - // Control Flow // async.series([ @@ -193,7 +192,6 @@ async.parallel([ ], function(err, results) { }); - async.parallel({ one: function(callback) { setTimeout(function() { @@ -238,7 +236,6 @@ async.parallelLimit({ function(err, results) { } ); - function whileFn(callback: any) { setTimeout(() => callback(null, ++count), 1000); } @@ -273,13 +270,11 @@ async.waterfall([ } ], function(err, result) { }); - const q = async.queue(function(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'); }; @@ -380,7 +375,6 @@ const cargo = async.cargo(function(tasks, callback) { callback(); }, 2); - // add some items cargo.push({ name: 'foo' }, function(err: Error) { console.log('finished processing foo'); @@ -441,7 +435,6 @@ 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.parallel([ function(callback: (err: Error, val: string) => void) { }, function(callback) { } @@ -458,7 +451,6 @@ async.parallel([ async.apply(fs.writeFile, 'testfile2', 'test2'), ]); - async.parallel([ function(callback) { fs.writeFile('testfile1', 'test1', callback); @@ -748,7 +740,6 @@ wrapped1({ bar: 'bar' }, function(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`); return callback(undefined, { bar: 'bar' }); diff --git a/types/async/tslint.json b/types/async/tslint.json index 94e7dc42fd..825ad443c1 100644 --- a/types/async/tslint.json +++ b/types/async/tslint.json @@ -4,7 +4,6 @@ "ban-types": true, // PRODUCES ERRORS WHEN REMOVED "callable-types": false, // HAS ISSUES "comment-format": true, // PRODUCES ERRORS WHEN REMOVED - "no-consecutive-blank-lines": false, // HAS ISSUES "no-unnecessary-generics": false, // HAS ISSUES "no-var-keyword": false, // HAS ISSUES "no-void-expression": false, // HAS ISSUES From ae3fbb870e14a67ac7e04c95941cd2e9e8717fed Mon Sep 17 00:00:00 2001 From: Dmitri1337 Date: Wed, 16 Jan 2019 19:23:45 +0200 Subject: [PATCH 28/34] Fixed "no-var-keyword" lint rule --- types/async/test/explicit.ts | 4 ++-- types/async/test/index.ts | 3 ++- types/async/tslint.json | 1 - 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/types/async/test/explicit.ts b/types/async/test/explicit.ts index 8f910e4b37..5c2e5e46e6 100644 --- a/types/async/test/explicit.ts +++ b/types/async/test/explicit.ts @@ -1,7 +1,7 @@ interface StringCallback { (err?: Error, result?: string): void; } interface AsyncStringGetter { (callback: StringCallback): void; } -var taskArray: AsyncStringGetter[] = [ +const taskArray: AsyncStringGetter[] = [ function(callback) { setTimeout(function() { callback(undefined, 'one'); @@ -43,7 +43,7 @@ interface Lookup { [key: string]: T; } interface NumberCallback { (err?: Error, result?: number): void; } interface AsyncNumberGetter { (callback: NumberCallback): void; } -var taskDict: Lookup = { +const taskDict: Lookup = { one: function(callback) { setTimeout(function() { callback(undefined, 1); diff --git a/types/async/test/index.ts b/types/async/test/index.ts index 9a7e033e2a..8b764d0c10 100644 --- a/types/async/test/index.ts +++ b/types/async/test/index.ts @@ -242,7 +242,8 @@ function whileFn(callback: any) { function whileTest() { return count < 5; } function doWhileTest(count: number) { return count < 5; } -var count = 0; + +let count = 0; async.whilst(whileTest, whileFn, function(err) { }); async.until(whileTest, whileFn, function(err) { }); async.doWhilst(whileFn, doWhileTest, function(err) { }); diff --git a/types/async/tslint.json b/types/async/tslint.json index 825ad443c1..e898fbac8d 100644 --- a/types/async/tslint.json +++ b/types/async/tslint.json @@ -5,7 +5,6 @@ "callable-types": false, // HAS ISSUES "comment-format": true, // PRODUCES ERRORS WHEN REMOVED "no-unnecessary-generics": false, // HAS ISSUES - "no-var-keyword": false, // HAS ISSUES "no-void-expression": false, // HAS ISSUES "object-literal-key-quotes": false, // HAS ISSUES "object-literal-shorthand": false, // HAS ISSUES From 75c54e1e18179c8275e00e3b21a06bc6cb8eee8a Mon Sep 17 00:00:00 2001 From: Dmitri1337 Date: Wed, 16 Jan 2019 19:26:51 +0200 Subject: [PATCH 29/34] Fixed "no-void-expression" lint rule --- types/async/test/index.ts | 6 +++--- types/async/tslint.json | 1 - 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/types/async/test/index.ts b/types/async/test/index.ts index 8b764d0c10..829e19bc2f 100644 --- a/types/async/test/index.ts +++ b/types/async/test/index.ts @@ -734,7 +734,7 @@ async.some({ function myFunction1(foo: any, callback: (err?: Error, result?: any) => void): void { console.log(`async.timeout 1 ${foo}`); - return callback(undefined, foo); + callback(undefined, foo); } const wrapped1 = async.timeout(myFunction1, 1000); wrapped1({ bar: 'bar' }, function(err: Error, data: any) { @@ -743,7 +743,7 @@ wrapped1({ bar: 'bar' }, function(err: Error, data: any) { function myFunction2(callback: (err?: Error, result?: any) => void): void { console.log(`async.timeout 2`); - return callback(undefined, { bar: 'bar' }); + callback(undefined, { bar: 'bar' }); } const wrapped2 = async.timeout(myFunction2, 1000); @@ -753,7 +753,7 @@ wrapped2(function(err: Error, data: any) { function myFunction3(callback: (err?: Error, result?: any) => void): void { console.log(`async.timeout 3`); - return callback(undefined, { bar: 'bar' }); + callback(undefined, { bar: 'bar' }); } const wrapped3 = async.timeout(myFunction3, 1000, { bar: 'bar' }); diff --git a/types/async/tslint.json b/types/async/tslint.json index e898fbac8d..40d16f9bbd 100644 --- a/types/async/tslint.json +++ b/types/async/tslint.json @@ -5,7 +5,6 @@ "callable-types": false, // HAS ISSUES "comment-format": true, // PRODUCES ERRORS WHEN REMOVED "no-unnecessary-generics": false, // HAS ISSUES - "no-void-expression": false, // HAS ISSUES "object-literal-key-quotes": false, // HAS ISSUES "object-literal-shorthand": false, // HAS ISSUES "only-arrow-functions": false, // HAS ISSUES From 022c73d972c46e6af0be26b7fdb0f92893673e9f Mon Sep 17 00:00:00 2001 From: Dmitri1337 Date: Wed, 16 Jan 2019 19:30:04 +0200 Subject: [PATCH 30/34] Fixed "object-literal-key-quotes" lint rule --- types/async/test/index.ts | 112 +++++++++++++++++++------------------- types/async/tslint.json | 1 - 2 files changed, 56 insertions(+), 57 deletions(-) diff --git a/types/async/test/index.ts b/types/async/test/index.ts index 829e19bc2f..1470bf8580 100644 --- a/types/async/test/index.ts +++ b/types/async/test/index.ts @@ -493,8 +493,8 @@ async.dir(function(name: string, callback: any) { // each async.each({ - "a": 1, - "b": 2 + a: 1, + b: 2 }, function(val: number, next: ErrorCallback): void { setTimeout(function(): void { console.log(`async.each: ${val}`); @@ -505,8 +505,8 @@ async.each({ }); async.eachSeries({ - "a": 1, - "b": 2 + a: 1, + b: 2 }, function(val: number, next: ErrorCallback): void { setTimeout(function(): void { console.log(`async.eachSeries: ${val}`); @@ -517,12 +517,12 @@ async.eachSeries({ }); async.eachLimit({ - "a": 1, - "b": 2, - "c": 3, - "d": 4, - "e": 5, - "f": 6 + 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}`); @@ -535,8 +535,8 @@ async.eachLimit({ // forEachOf/eachOf async.eachOf({ - "a": 1, - "b": 2 + a: 1, + b: 2 }, function(val: number, key: string, next: ErrorCallback): void { setTimeout(function(): void { console.log(`async.forEachOf/eachOf: ${key} = ${val}`); @@ -547,8 +547,8 @@ async.eachOf({ }); async.forEachOfSeries({ - "a": 1, - "b": 2 + a: 1, + b: 2 }, function(val: number, key: string, next: ErrorCallback): void { setTimeout(function(): void { console.log(`async.forEachOfSeries: ${key} = ${val}`); @@ -559,12 +559,12 @@ async.forEachOfSeries({ }); async.forEachOfLimit({ - "a": 1, - "b": 2, - "c": 3, - "d": 4, - "e": 5, - "f": 6 + 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}`); @@ -577,9 +577,9 @@ async.forEachOfLimit({ // map async.map({ - "a": 1, - "b": 2, - "c": 3 + a: 1, + b: 2, + c: 3 }, function(val: number, next: AsyncResultCallback): void { setTimeout(function(): void { console.log(`async.map: ${val}`); @@ -590,9 +590,9 @@ async.map({ }); async.mapSeries({ - "a": 1, - "b": 2, - "c": 3 + a: 1, + b: 2, + c: 3 }, function(val: number, next: AsyncResultCallback): void { setTimeout(function(): void { console.log(`async.mapSeries: ${val}`); @@ -603,12 +603,12 @@ async.mapSeries({ }); async.mapLimit({ - "a": 1, - "b": 2, - "c": 3, - "d": 4, - "e": 5, - "f": 6 + 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}`); @@ -621,9 +621,9 @@ async.mapLimit({ // mapValues async.mapValues({ - "a": 1, - "b": 2, - "c": 3 + a: 1, + b: 2, + c: 3 }, function(val: number, key: string, next: AsyncResultCallback): void { setTimeout(function(): void { console.log(`async.mapValues: ${key} = ${val}`); @@ -634,9 +634,9 @@ async.mapValues({ }); async.mapValuesSeries({ - "a": 1, - "b": 2, - "c": 3 + a: 1, + b: 2, + c: 3 }, function(val: number, key: string, next: AsyncResultCallback): void { setTimeout(function(): void { console.log(`async.mapValuesSeries: ${key} = ${val}`); @@ -649,9 +649,9 @@ async.mapValuesSeries({ // filter/select/reject async.filter({ - "a": 1, - "b": 2, - "c": 3 + a: 1, + b: 2, + c: 3 }, function(val: number, next: AsyncBooleanResultCallback): void { setTimeout(function(): void { console.log(`async.filter/select: ${val}`); @@ -662,9 +662,9 @@ async.filter({ }); async.reject({ - "a": 1, - "b": 2, - "c": 3 + a: 1, + b: 2, + c: 3 }, function(val: number, next: AsyncBooleanResultCallback): void { setTimeout(function(): void { console.log(`async.reject: ${val}`); @@ -677,9 +677,9 @@ async.reject({ // concat async.concat({ - "a": "1", - "b": "2", - "c": "3" + a: "1", + b: "2", + c: "3" }, function(item: string, next: AsyncResultCallback): void { console.log(`async.concat: ${item}`); next(undefined as any, [item, item, item]); @@ -690,9 +690,9 @@ async.concat({ // detect/find async.detect({ - "a": 1, - "b": 2, - "c": 3 + a: 1, + b: 2, + c: 3 }, function(item: number, next: AsyncBooleanResultCallback): void { console.log(`async.detect/find: ${item}`); next(undefined as any, item > 1); @@ -707,9 +707,9 @@ async.detect({ // every/all async.every({ - "a": 1, - "b": 2, - "c": 3 + a: 1, + b: 2, + c: 3 }, function(item: number, next: AsyncBooleanResultCallback): void { console.log(`async.every/all: ${item}`); next(undefined as any, item > 0); @@ -720,9 +720,9 @@ async.every({ // some/any async.some({ - "a": 1, - "b": 2, - "c": 3 + a: 1, + b: 2, + c: 3 }, function(item: number, next: AsyncBooleanResultCallback): void { console.log(`async.some/any: ${item}`); next(undefined as any, item > 2); diff --git a/types/async/tslint.json b/types/async/tslint.json index 40d16f9bbd..a88c87d354 100644 --- a/types/async/tslint.json +++ b/types/async/tslint.json @@ -5,7 +5,6 @@ "callable-types": false, // HAS ISSUES "comment-format": true, // PRODUCES ERRORS WHEN REMOVED "no-unnecessary-generics": false, // HAS ISSUES - "object-literal-key-quotes": false, // HAS ISSUES "object-literal-shorthand": false, // HAS ISSUES "only-arrow-functions": false, // HAS ISSUES "unified-signatures": false // HAS ISSUES From ad2722e2a7c0044b809698ec21a90b3107c0d925 Mon Sep 17 00:00:00 2001 From: Dmitri1337 Date: Wed, 16 Jan 2019 19:35:08 +0200 Subject: [PATCH 31/34] Fixed "object-literal-shorthand" lint rule --- types/async/test/explicit.ts | 4 ++-- types/async/test/index.ts | 32 ++++++++++++++++---------------- types/async/tslint.json | 1 - 3 files changed, 18 insertions(+), 19 deletions(-) diff --git a/types/async/test/explicit.ts b/types/async/test/explicit.ts index 5c2e5e46e6..1d83173ac3 100644 --- a/types/async/test/explicit.ts +++ b/types/async/test/explicit.ts @@ -44,12 +44,12 @@ interface NumberCallback { (err?: Error, result?: number): void; } interface AsyncNumberGetter { (callback: NumberCallback): void; } const taskDict: Lookup = { - one: function(callback) { + one: callback => { setTimeout(function() { callback(undefined, 1); }, 200); }, - two: function(callback) { + two: callback => { setTimeout(function() { callback(undefined, 2); }, 100); diff --git a/types/async/test/index.ts b/types/async/test/index.ts index 1470bf8580..c01e0837c9 100644 --- a/types/async/test/index.ts +++ b/types/async/test/index.ts @@ -125,12 +125,12 @@ async.series([ function(err, results) { }); async.series({ - one: function(callback) { + one: callback => { setTimeout(function() { callback(undefined, 1); }, 200); }, - two: function(callback) { + two: callback => { setTimeout(function() { callback(undefined, 2); }, 100); @@ -139,12 +139,12 @@ async.series({ function(err, results) { }); async.series({ - one: function(callback) { + one: callback => { setTimeout(function() { callback(undefined, 1); }, 200); }, - two: function(callback) { + two: callback => { setTimeout(function() { callback(undefined, 2); }, 100); @@ -193,12 +193,12 @@ async.parallel([ function(err, results) { }); async.parallel({ - one: function(callback) { + one: callback => { setTimeout(function() { callback(undefined, 1); }, 200); }, - two: function(callback) { + two: callback => { setTimeout(function() { callback(undefined, 2); }, 100); @@ -207,12 +207,12 @@ async.parallel({ function(err, results) { }); async.parallel({ - one: function(callback) { + one: callback => { setTimeout(function() { callback(undefined, 1); }, 200); }, - two: function(callback) { + two: callback => { setTimeout(function() { callback(undefined, 2); }, 100); @@ -221,12 +221,12 @@ async.parallel({ function(err, results) { }); async.parallelLimit({ - one: function(callback) { + one: callback => { setTimeout(function() { callback(undefined, 1); }, 200); }, - two: function(callback) { + two: callback => { setTimeout(function() { callback(undefined, 2); }, 100); @@ -389,8 +389,8 @@ cargo.push({ name: 'baz' }, function(err: Error) { const filename = ''; async.auto({ - get_data: function(callback: AsyncResultCallback) { }, - make_folder: function(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); @@ -400,8 +400,8 @@ async.auto({ }); async.auto({ - get_data: function(callback: AsyncResultCallback) { }, - make_folder: function(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); @@ -420,8 +420,8 @@ interface A { } async.auto({ - get_data: function(callback: AsyncResultCallback) { }, - make_folder: function(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); diff --git a/types/async/tslint.json b/types/async/tslint.json index a88c87d354..eec2a23e08 100644 --- a/types/async/tslint.json +++ b/types/async/tslint.json @@ -5,7 +5,6 @@ "callable-types": false, // HAS ISSUES "comment-format": true, // PRODUCES ERRORS WHEN REMOVED "no-unnecessary-generics": false, // HAS ISSUES - "object-literal-shorthand": false, // HAS ISSUES "only-arrow-functions": false, // HAS ISSUES "unified-signatures": false // HAS ISSUES } From 912d3ff409ef72660c0ba26ed4cf54ac188765b3 Mon Sep 17 00:00:00 2001 From: Dmitri1337 Date: Thu, 17 Jan 2019 10:56:15 +0200 Subject: [PATCH 32/34] Fixed "unified-signatures" lint rule --- types/async/index.d.ts | 6 ++---- types/async/test/index.ts | 18 ++++++++++++------ types/async/tslint.json | 3 +-- 3 files changed, 15 insertions(+), 12 deletions(-) diff --git a/types/async/index.d.ts b/types/async/index.d.ts index 48a9d12335..05d99e5968 100644 --- a/types/async/index.d.ts +++ b/types/async/index.d.ts @@ -116,8 +116,7 @@ export function forEachOfLimit(obj: IterableCollection, limit: export const eachOf: typeof forEachOf; export const eachOfSeries: typeof forEachOf; export const eachOfLimit: typeof forEachOfLimit; -export function map(arr: T[] | IterableIterator, iterator: AsyncResultIterator, callback?: AsyncResultArrayCallback): void; -export function map(arr: Dictionary, iterator: AsyncResultIterator, callback?: AsyncResultArrayCallback): void; +export function map(arr: T[] | IterableIterator | Dictionary, iterator: AsyncResultIterator, callback?: AsyncResultArrayCallback): void; export const mapSeries: typeof map; export function mapLimit(arr: IterableCollection, limit: number, iterator: AsyncResultIterator, callback?: AsyncResultArrayCallback): void; @@ -194,10 +193,9 @@ export function cargo(worker: (tasks: any[], callback: ErrorCallback< export function auto, E = Error>(tasks: AsyncAutoTasks, concurrency?: number, callback?: AsyncResultCallback): void; export function auto, E = Error>(tasks: AsyncAutoTasks, callback?: AsyncResultCallback): void; export function autoInject(tasks: any, callback?: AsyncResultCallback): void; -export function retry(opts: number, task: (callback: AsyncResultCallback, results: any) => void, callback: AsyncResultCallback): void; export function retry( - opts: { + opts: number | { times: number, interval: number | ((retryCount: number) => number) }, diff --git a/types/async/test/index.ts b/types/async/test/index.ts index c01e0837c9..633afbd575 100644 --- a/types/async/test/index.ts +++ b/types/async/test/index.ts @@ -391,22 +391,26 @@ const filename = ''; async.auto({ get_data: (callback: AsyncResultCallback) => { }, make_folder: (callback: AsyncResultCallback) => { }, - //arrays with different types are not accepted by TypeScript. + + // 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. + + // arrays with different types are not accepted by TypeScript. email_link: ['write_file', function(callback: AsyncResultCallback, results: any) { } as any] }); async.auto({ get_data: (callback: AsyncResultCallback) => { }, make_folder: (callback: AsyncResultCallback) => { }, - //arrays with different types are not accepted by TypeScript. + + // 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. + + // 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'); @@ -422,11 +426,13 @@ interface A { async.auto({ get_data: (callback: AsyncResultCallback) => { }, make_folder: (callback: AsyncResultCallback) => { }, - //arrays with different types are not accepted by TypeScript. + + // 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. + + // 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'); diff --git a/types/async/tslint.json b/types/async/tslint.json index eec2a23e08..e9c86307b2 100644 --- a/types/async/tslint.json +++ b/types/async/tslint.json @@ -5,7 +5,6 @@ "callable-types": false, // HAS ISSUES "comment-format": true, // PRODUCES ERRORS WHEN REMOVED "no-unnecessary-generics": false, // HAS ISSUES - "only-arrow-functions": false, // HAS ISSUES - "unified-signatures": false // HAS ISSUES + "only-arrow-functions": false // HAS ISSUES } } From 41337e57485a6b61ef57c973b92f772ad64e2e0a Mon Sep 17 00:00:00 2001 From: Dmitri1337 Date: Thu, 17 Jan 2019 10:57:50 +0200 Subject: [PATCH 33/34] Fixed "comment-format" lint rule --- types/async/tslint.json | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/types/async/tslint.json b/types/async/tslint.json index e9c86307b2..41d9020b53 100644 --- a/types/async/tslint.json +++ b/types/async/tslint.json @@ -3,8 +3,7 @@ "rules": { "ban-types": true, // PRODUCES ERRORS WHEN REMOVED "callable-types": false, // HAS ISSUES - "comment-format": true, // PRODUCES ERRORS WHEN REMOVED "no-unnecessary-generics": false, // HAS ISSUES - "only-arrow-functions": false // HAS ISSUES + "only-arrow-functions": false // HAS ISSUES } } From e5fa3ccfe5bd8ae1e00758d9bef581a2fb9a1c44 Mon Sep 17 00:00:00 2001 From: Dmitri1337 Date: Thu, 17 Jan 2019 15:06:17 +0200 Subject: [PATCH 34/34] Fixed "only-arrow-functions" lint rule --- types/async/test/es6-generators.ts | 60 +- types/async/test/explicit.ts | 40 +- types/async/test/index.ts | 869 ++++++++++++----------------- types/async/tslint.json | 3 +- 4 files changed, 392 insertions(+), 580 deletions(-) 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 } }