From 1043ffe71c4cdea7f0a0e97f022e70c018e1e01f Mon Sep 17 00:00:00 2001
From: Paul Isache <paul@isache.com>
Date: Fri, 27 Jan 2017 08:49:48 +0200
Subject: [PATCH] Steed - declare namespace and modify tests

---
 steed/index.d.ts     |  79 +++++++++++++-------------
 steed/steed-tests.ts | 129 +++++++++++++++++--------------------------
 2 files changed, 92 insertions(+), 116 deletions(-)

diff --git a/steed/index.d.ts b/steed/index.d.ts
index f88669e92c..ba4b199999 100644
--- a/steed/index.d.ts
+++ b/steed/index.d.ts
@@ -3,48 +3,49 @@
 // Definitions by: Paul Isache <https://github.com/Paul-Isache>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-interface Dictionary<T> { [key: string]: T; }
-interface ErrorCallback<T> { (err?: T): void; }
 
-interface SteedResultCallback<T, E> { (err: E, result: T): void; }
-interface SteedResultArrayCallback<T, E> { (err: E, results: T[]): void; }
-interface SteedResultObjectCallback<T, E> { (err: E, results: Dictionary<T>): void; }
+declare namespace steed {
+    interface Dictionary<T> { [key: string]: T; }
+    interface ErrorCallback<T> { (err?: T): void; }
 
-interface SteedWorker<T, E> { (task: T, callback: ErrorCallback<E>): void; }
-interface SteedIterator<T, E> { (item: T, callback: ErrorCallback<E>): void; }
-interface SteedResultIterator<T, R, E> { (item: T, callback: SteedResultCallback<R, E>): void; }
-interface SteedFunction<T, E> { (callback: (err?: E, result?: T) => void): void; }
+    interface SteedResultCallback<T, E> { (err: E, result: T): void; }
+    interface SteedResultArrayCallback<T, E> { (err: E, results: T[]): void; }
+    interface SteedResultObjectCallback<T, E> { (err: E, results: Dictionary<T>): void; }
 
-interface SteedQueue<T> {
-    push<E>(task: T | T[], callback?: ErrorCallback<E> | SteedResultCallback<T, E>): void;
-    unshift<E>(task: T | T[], callback?: ErrorCallback<E>): void;
-    pause(): void;
-    resume(): void;
-    idle(): boolean;
-    length(): number;
-    kill(): void;
-    concurrency: number;
-    drain: () => any;
-    empty: () => any;
-    saturated: () => any;
+    interface SteedWorker<T, E> { (task: T, callback: ErrorCallback<E>): void; }
+    interface SteedIterator<T, E> { (item: T, callback: ErrorCallback<E>): void; }
+    interface SteedResultIterator<T, R, E> { (item: T, callback: SteedResultCallback<R, E>): void; }
+    interface SteedFunction<T, E> { (callback: (err?: E, result?: T) => void): void; }
+
+    interface SteedQueue<T> {
+        push<E>(task: T | T[], callback?: ErrorCallback<E> | SteedResultCallback<T, E>): void;
+        unshift<E>(task: T | T[], callback?: ErrorCallback<E>): void;
+        pause(): void;
+        resume(): void;
+        idle(): boolean;
+        length(): number;
+        kill(): void;
+        concurrency: number;
+        drain: () => any;
+        empty: () => any;
+        saturated: () => any;
+    }
+
+    interface Steed {
+        parallel<T, E>(tasks: Array<SteedFunction<T, E>>, callback?: SteedResultArrayCallback<T, E>): void;
+        parallel<T, E>(tasks: Dictionary<SteedFunction<T, E>>, callback?: SteedResultObjectCallback<T, E>): void;
+        series<T, E>(tasks: Array<SteedFunction<T, E>>, callback?: SteedResultArrayCallback<T, E>): void;
+        series<T, E>(tasks: Dictionary<SteedFunction<T, E>>, callback?: SteedResultObjectCallback<T, E>): void;
+        waterfall<T, E>(tasks: Function[], callback?: SteedResultCallback<T, E>): void;
+        each<T, E>(arr: T[] | Dictionary<T>, iterator: SteedIterator<T, E>, callback?: ErrorCallback<E>): void;
+        eachSeries: typeof steed.each;
+        map<T, R, E>(arr: T[] | Dictionary<T>, iterator: SteedResultIterator<T, R, E>, callback?: SteedResultArrayCallback<R, E>): void;
+        mapSeries: typeof steed.map;
+        queue<T, E>(worker: SteedWorker<T, E>, concurrency?: number): SteedQueue<T>;
+        queue<T, R, E>(worker: SteedResultIterator<T, R, E>, concurrency?: number): SteedQueue<T>;
+    }
 }
 
-interface Steed {
-    parallel<T, E>(tasks: Array<SteedFunction<T, E>>, callback?: SteedResultArrayCallback<T, E>): void;
-    parallel<T, E>(tasks: Dictionary<SteedFunction<T, E>>, callback?: SteedResultObjectCallback<T, E>): void;
-    series<T, E>(tasks: Array<SteedFunction<T, E>>, callback?: SteedResultArrayCallback<T, E>): void;
-    series<T, E>(tasks: Dictionary<SteedFunction<T, E>>, callback?: SteedResultObjectCallback<T, E>): void;
-    waterfall<T, E>(tasks: Function[], callback?: SteedResultCallback<T, E>): void;
-    each<T, E>(arr: T[] | Dictionary<T>, iterator: SteedIterator<T, E>, callback?: ErrorCallback<E>): void;
-    eachSeries: typeof steed.each;
-    map<T, R, E>(arr: T[] | Dictionary<T>, iterator: SteedResultIterator<T, R, E>, callback?: SteedResultArrayCallback<R, E>): void;
-    mapSeries: typeof steed.map;
-    queue<T, E>(worker: SteedWorker<T, E>, concurrency?: number): SteedQueue<T>;
-    queue<T, R, E>(worker: SteedResultIterator<T, R, E>, concurrency?: number): SteedQueue<T>;
-}
+declare const steed: steed.Steed;
 
-declare const steed: Steed;
-
-declare module "steed" {
-    export = steed;
-}
+export = steed;
diff --git a/steed/steed-tests.ts b/steed/steed-tests.ts
index 729e59472f..685654cc52 100644
--- a/steed/steed-tests.ts
+++ b/steed/steed-tests.ts
@@ -1,19 +1,14 @@
 /// <reference types="node" />
 
-import fs = require("fs");
-import process = require("process");
+import steed = require('steed')
 
 declare var path: {
-    exists: (path: string, callback?: (err: Error, exists: boolean) => any) => void;
+    exists: (path: string, callback?: (error: Error, exists: boolean) => any) => void;
 };
 
-function funcStringCbErrBoolean(v:string, cb:(err:Error,res:boolean) => void) {}
+function funcStringCbErrBoolean(v: string, cb: (error: Error, res: boolean) => void) { }
 function callback() { }
 
-steed.map(['file1', 'file2', 'file3'], fs.stat, function (err:Error, results:Array<fs.Stats>) { });
-steed.mapSeries(['file1', 'file2', 'file3'], fs.stat, function (err:Error, results:Array<fs.Stats>) { });
-
-
 steed.parallel([
     function () { },
     function () { }
@@ -25,16 +20,16 @@ steed.series([
 ]);
 
 var data: any[] = [];
-function steedProcess(item: any, callback: (err: Error, result: any) => void) { }
-steed.map(data, steedProcess, function (err, results) {
+function steedProcess(item: any, callback: (error: Error, result: any) => void) { }
+steed.map(data, steedProcess, function (error, results) {
     console.log(results);
 });
 
 var openFiles = ['file1', 'file2'];
 
-var saveFile = function (file:string,cb:(err:Error)=>void) { }
-steed.each(openFiles, saveFile, function (err:Error) { });
-steed.eachSeries(openFiles, saveFile, function (err:Error) { });
+var saveFile = function (file: string, cb: (error: Error) => void) { }
+steed.each(openFiles, saveFile, function (error: Error) { });
+steed.eachSeries(openFiles, saveFile, function (error: Error) { });
 
 // Control Flow //
 
@@ -46,9 +41,9 @@ steed.series([
         callback(undefined, 'two');
     },
 ],
-function (err, results) { });
+    function (error, results) { });
 
-steed.series<string,Error>([
+steed.series<string, Error>([
     function (callback) {
         callback(undefined, 'one');
     },
@@ -56,7 +51,7 @@ steed.series<string,Error>([
         callback(undefined, 'two');
     },
 ],
-function (err, results) { });
+    function (error, results) { });
 
 steed.series({
     one: function (callback) {
@@ -70,9 +65,9 @@ steed.series({
         }, 100);
     },
 },
-function (err, results) { });
+    function (error, results) { });
 
-steed.series<number,Error>({
+steed.series<number, Error>({
     one: function (callback) {
         setTimeout(function () {
             callback(undefined, 1);
@@ -84,7 +79,7 @@ steed.series<number,Error>({
         }, 100);
     },
 },
-function (err, results) { });
+    function (error, results) { });
 
 steed.parallel([
     function (callback) {
@@ -98,9 +93,9 @@ steed.parallel([
         }, 100);
     },
 ],
-function (err, results) { });
+    function (error, results) { });
 
-steed.parallel<string,Error>([
+steed.parallel<string, Error>([
     function (callback) {
         setTimeout(function () {
             callback(undefined, 'one');
@@ -112,7 +107,7 @@ steed.parallel<string,Error>([
         }, 100);
     },
 ],
-function (err, results) { });
+    function (error, results) { });
 
 
 steed.parallel({
@@ -127,9 +122,9 @@ steed.parallel({
         }, 100);
     },
 },
-function (err, results) { });
+    function (error, results) { });
 
-steed.parallel<number,Error>({
+steed.parallel<number, Error>({
     one: function (callback) {
         setTimeout(function () {
             callback(undefined, 1);
@@ -141,7 +136,7 @@ steed.parallel<number,Error>({
         }, 100);
     },
 },
-    function (err, results) { });
+    function (error, results) { });
 
 function whileFn(callback: any) {
     count++;
@@ -161,10 +156,10 @@ steed.waterfall([
     function (arg1: any, callback: any) {
         callback(null, 'done');
     }
-], function (err, result) { });
+], function (error, result) { });
 
 
-var q = steed.queue<any,Error>(function (task: any, callback: () => void) {
+var q = steed.queue<any, Error>(function (task: any, callback: () => void) {
     console.log('hello ' + task.name);
     callback();
 }, 2);
@@ -180,7 +175,7 @@ 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 (error: Error) {
     console.log('finished processing bar');
 });
 
@@ -190,22 +185,22 @@ 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 (error: Error) {
     console.log('finished processing bar');
 });
 
-var qLength : number = q.length();
-var qIsIdle : boolean = q.idle();
+var qLength: number = q.length();
+var qIsIdle: boolean = q.idle();
 
-q.saturated = function() {
+q.saturated = function () {
     console.log('queue is saturated.');
 }
 
-q.empty = function() {
+q.empty = function () {
     console.log('queue is empty.');
 }
 
-q.drain = function() {
+q.drain = function () {
     console.log('queue was drained.');
 }
 
@@ -214,7 +209,7 @@ q.resume();
 q.kill();
 
 // tests for strongly typed tasks
-var q2 = steed.queue<string,Error>(function (task: string, callback: () => void) {
+var q2 = steed.queue<string, Error>(function (task: string, callback: () => void) {
     console.log('Task: ' + task);
     callback();
 }, 1);
@@ -225,7 +220,7 @@ q2.push('task2', function (error) {
     console.log('Finished tasks');
 });
 
-q2.push(['task3', 'task4', 'task5'], function (error) {
+q2.push(['task3', 'task4', 'task5'], function (error: Error) {
     console.log('Finished tasks');
 });
 
@@ -235,49 +230,29 @@ q2.unshift('task2', function (error) {
     console.log('Finished tasks');
 });
 
-q2.unshift(['task3', 'task4', 'task5'], function (error) {
+q2.unshift(['task3', 'task4', 'task5'], function (error: Error) {
     console.log('Finished tasks');
 });
 
-
-// var aq = steed.queue<number, number, Error>(function (level: number, callback: (error : Error, newLevel: number) => void) {
-//     console.log('hello ' + level);
-//     callback(null, level+1);
-// });
-//
-// aq.push(1, function (err : Error, newLevel : number) {
-//     console.log('finished processing bar' + newLevel);
-// });
-
-
 steed.parallel([
-    function (callback: ( err:Error, val:string ) => void ) { },
+    function (callback: (error: Error, val: string) => void) { },
     function (callback) { }
 ],
-function (err:Error,results:Array<string>) {
-    steed.series([
-        function (callback) { },
-        function email_link(callback) { }
-    ]);
-});
-
-steed.parallel([
-    function (callback) {
-        fs.writeFile('testfile1', 'test1', callback);
-    },
-    function (callback) {
-        fs.writeFile('testfile2', 'test2', callback);
-    },
-]);
+    function (error: Error, results: Array<string>) {
+        steed.series([
+            function (callback) { },
+            function email_link(callback) { }
+        ]);
+    });
 
 // each
 
-steed.each<number,Error>({
+steed.each<number, Error>({
     "a": 1,
     "b": 2
-}, function(val: number, next: ErrorCallback<Error>): void {
+}, function (val: number, next: steed.ErrorCallback<Error>): void {
 
-    setTimeout(function(): void {
+    setTimeout(function (): void {
 
         console.log(`steed.each: ${val}`);
 
@@ -285,7 +260,7 @@ steed.each<number,Error>({
 
     }, 500);
 
-}, function(err?: Error): void {
+}, function (err?: Error): void {
 
     console.log("steed.each: done.");
 
@@ -294,9 +269,9 @@ steed.each<number,Error>({
 steed.eachSeries<number, Error>({
     "a": 1,
     "b": 2
-}, function(val: number, next: ErrorCallback<Error>): void {
+}, function (val: number, next: steed.ErrorCallback<Error>): void {
 
-    setTimeout(function(): void {
+    setTimeout(function (): void {
 
         console.log(`steed.eachSeries: ${val}`);
 
@@ -304,7 +279,7 @@ steed.eachSeries<number, Error>({
 
     }, 500);
 
-}, function(err?: Error): void {
+}, function (err?: Error): void {
 
     console.log("steed.eachSeries: done.");
 
@@ -316,9 +291,9 @@ steed.map<number, string, Error>({
     "a": 1,
     "b": 2,
     "c": 3
-}, function(val: number, next: SteedResultCallback<string, Error>): void {
+}, function (val: number, next: steed.SteedResultCallback<string, Error>): void {
 
-    setTimeout(function(): void {
+    setTimeout(function (): void {
 
         console.log(`steed.map: ${val}`);
 
@@ -326,7 +301,7 @@ steed.map<number, string, Error>({
 
     }, 500);
 
-}, function(err: Error, results: string[]): void {
+}, function (error: Error, results: string[]): void {
 
     console.log("steed.map: done with results", results);
 
@@ -336,9 +311,9 @@ steed.mapSeries<number, string, Error>({
     "a": 1,
     "b": 2,
     "c": 3
-}, function(val: number, next: SteedResultCallback<string, Error>): void {
+}, function (val: number, next: steed.SteedResultCallback<string, Error>): void {
 
-    setTimeout(function(): void {
+    setTimeout(function (): void {
 
         console.log(`steed.mapSeries: ${val}`);
 
@@ -346,7 +321,7 @@ steed.mapSeries<number, string, Error>({
 
     }, 500);
 
-}, function(err: Error, results: string[]): void {
+}, function (error: Error, results: string[]): void {
 
     console.log("steed.mapSeries: done with results", results);