From 4af081994e1cbf1ed0eb952f3c4c63c9ef83b92b Mon Sep 17 00:00:00 2001
From: Dmitri1337 <dmitri.trofimov@prime-initiative.com>
Date: Wed, 16 Jan 2019 18:40:10 +0200
Subject: [PATCH] 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<T> {
 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<E = Error>(test: () => boolean, fn: AsyncVoidFunction<E>,
 export function doWhilst<T, E = Error>(fn: AsyncFunctionEx<T, E>, test: (...results: T[]) => boolean, callback: ErrorCallback<E>): void;
 export function until<E = Error>(test: () => boolean, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
 export function doUntil<T, E = Error>(fn: AsyncFunctionEx<T, E>, test: (...results: T[]) => boolean, callback: ErrorCallback<E>): void;
-export function during<E = Error>(test: (testCallback : AsyncBooleanResultCallback<E>) => void, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
+export function during<E = Error>(test: (testCallback: AsyncBooleanResultCallback<E>) => void, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
 export function doDuring<E = Error>(fn: AsyncVoidFunction<E>, test: (testCallback: AsyncBooleanResultCallback<E>) => void, callback: ErrorCallback<E>): void;
-export function forever<E = Error>(next: (next : ErrorCallback<E>) => void, errBack: ErrorCallback<E>) : void;
+export function forever<E = Error>(next: (next: ErrorCallback<E>) => void, errBack: ErrorCallback<E>): void;
 export function waterfall<T, E = Error>(tasks: Function[], callback?: AsyncResultCallback<T, E>): void;
 export function compose(...fns: Function[]): Function;
 export function seq(...fns: Function[]): Function;
@@ -183,18 +183,18 @@ export function applyEachSeries(fns: Function[], ...argsAndCallback: any[]): voi
 export function queue<T, E = Error>(worker: AsyncWorker<T, E>, concurrency?: number): AsyncQueue<T>;
 export function queue<T, R, E = Error>(worker: AsyncResultIterator<T, R, E>, concurrency?: number): AsyncQueue<T>;
 export function priorityQueue<T, E = Error>(worker: AsyncWorker<T, E>, concurrency: number): AsyncPriorityQueue<T>;
-export function cargo<E = Error>(worker : (tasks: any[], callback : ErrorCallback<E>) => void, payload? : number) : AsyncCargo;
+export function cargo<E = Error>(worker: (tasks: any[], callback: ErrorCallback<E>) => void, payload?: number): AsyncCargo;
 export function auto<R extends Dictionary<any>, E = Error>(tasks: AsyncAutoTasks<R, E>, concurrency?: number, callback?: AsyncResultCallback<R, E>): void;
 export function auto<R extends Dictionary<any>, E = Error>(tasks: AsyncAutoTasks<R, E>, callback?: AsyncResultCallback<R, E>): void;
 export function autoInject<E = Error>(tasks: any, callback?: AsyncResultCallback<any, E>): void;
-export function retry<T, E = Error>(opts: number, task: (callback : AsyncResultCallback<T, E>, results: any) => void, callback:  AsyncResultCallback<any, E>): void;
-export function retry<T, E = Error>(opts: { times: number, interval: number|((retryCount: number) => number) }, task: (callback: AsyncResultCallback<T, E>, results : any) => void, callback:  AsyncResultCallback<any, E>): void;
+export function retry<T, E = Error>(opts: number, task: (callback: AsyncResultCallback<T, E>, results: any) => void, callback: AsyncResultCallback<any, E>): void;
+export function retry<T, E = Error>(opts: { times: number, interval: number|((retryCount: number) => number) }, task: (callback: AsyncResultCallback<T, E>, results: any) => void, callback: AsyncResultCallback<any, E>): void;
 export function retryable<T, E = Error>(opts: number | {times: number, interval: number}, task: AsyncFunction<T, E>): AsyncFunction<T, E>;
 export function apply<E = Error>(fn: Function, ...args: any[]): AsyncFunction<any, E>;
 export function nextTick(callback: Function, ...args: any[]): void;
 export const setImmediate: typeof nextTick;
 
-export function reflect<T, E = Error>(fn: AsyncFunction<T, E>) : (callback: (err: null, result: {error?: E, value?: T}) => void) => void;
+export function reflect<T, E = Error>(fn: AsyncFunction<T, E>): (callback: (err: null, result: {error?: E, value?: T}) => void) => void;
 export function reflectAll<T, E = Error>(tasks: Array<AsyncFunction<T, E>>): Array<(callback: (err: null, result: {error?: E, value?: T}) => void) => void>;
 
 export function timeout<T, E = Error>(fn: AsyncFunction<T, E>, milliseconds: number, info?: any): AsyncFunction<T, E>;
@@ -207,10 +207,10 @@ export function timesLimit<T, E = Error>(n: number, limit: number, iterator: Asy
 export function transform<T, R, E = Error>(arr: T[], iteratee: (acc: R[], item: T, key: number, callback: (error?: E) => void) => void, callback?: AsyncResultArrayCallback<T, E>): void;
 export function transform<T, R, E = Error>(arr: T[], acc: R[], iteratee: (acc: R[], item: T, key: number, callback: (error?: E) => void) => void, callback?: AsyncResultArrayCallback<T, E>): void;
 
-export function transform<T, R, E = Error>(arr: {[key: string] : T}, iteratee: (acc: {[key: string] : R}, item: T, key: string, callback: (error?: E) => void) => void, callback?: AsyncResultObjectCallback<T, E>): void;
-export function transform<T, R, E = Error>(arr: {[key: string] : T}, acc: {[key: string] : R}, iteratee: (acc: {[key: string] : R}, item: T, key: string, callback: (error?: E) => void) => void, callback?: AsyncResultObjectCallback<T, E>): void;
+export function transform<T, R, E = Error>(arr: {[key: string]: T}, iteratee: (acc: {[key: string]: R}, item: T, key: string, callback: (error?: E) => void) => void, callback?: AsyncResultObjectCallback<T, E>): void;
+export function transform<T, R, E = Error>(arr: {[key: string]: T}, acc: {[key: string]: R}, iteratee: (acc: {[key: string]: R}, item: T, key: string, callback: (error?: E) => void) => void, callback?: AsyncResultObjectCallback<T, E>): void;
 
-export function race<T, E = Error>(tasks: Array<AsyncFunction<T, E>>, callback: AsyncResultCallback<T, E>) : void;
+export function race<T, E = Error>(tasks: Array<AsyncFunction<T, E>>, callback: AsyncResultCallback<T, E>): 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<number, number>(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<number>({
 
 // 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
     }
 }