update

Author: chenzhihao

.editorconfig

@@ -0,0 +1,5 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2

.gitignore

@@ -1 +1,2 @@
 node_modules
+coverage

README.md

@@ -76,8 +76,6 @@ pq.add(() => {
 });
 
 // syntax sugar:
-pq.add([promiseThunk, promiseThunk, promiseThunk]);
-// is equal to:
 pq.add(promiseThunk).add(promiseThunk).add(promiseThunk);
 // is equal to:
 pq.add(promiseThunk);

README_CN.md

@@ -75,8 +75,6 @@ pq.add(() => {
 });
 
 // syntax sugar: 
-pq.add([promiseThunk, promiseThunk, promiseThunk]);
-// is equal to:
 pq.add(promiseThunk).add(promiseThunk).add(promiseThunk);
 // is equal to:
 pq.add(promiseThunk);

jest.config.js

@@ -0,0 +1,32 @@
+
+module.exports = {
+  collectCoverage: true,
+  collectCoverageFrom:
+    [
+      'src/**/*.ts'
+    ],
+  coveragePathIgnorePatterns:
+    [
+      '/coverage/',
+      '/node_modules/',
+      '.config.js'
+    ],
+  coverageDirectory: './coverage',
+  moduleFileExtensions: [
+    "ts",
+    "tsx",
+    "js"
+  ],
+  transform: {
+    "^.+\\.(ts|tsx)$":
+      "ts-jest"
+  },
+  globals: {
+    "ts-jest": {
+      "tsConfig": "tsconfig.json"
+    }
+  },
+  testMatch: [
+    "**/test/*.+(ts|tsx|js)"
+  ]
+};

package.json

@@ -23,6 +23,10 @@
     "waterfall"
   ],
   "devDependencies": {
+    "@types/jest": "^23.3.10",
+    "@types/node": "^10.12.15",
+    "jest": "^23.6.0",
+    "ts-jest": "^23.10.5",
     "tslint": "^5.11.0",
     "typescript": "^3.2.2"
   },

src/PromiseQueue.ts

@@ -1,5 +1,3 @@
-import * as utils from "./typeCheck";
-
 interface IPromiseQueueOpts {
   concurrency: number;
 }
@@ -34,35 +32,29 @@ class PromiseQueue {
     this._next();
   }
 
-  public add(fn: () => Promise<any> | Array<() => Promise<any>>): PromiseQueue | TypeError {
-    if (utils.isArray(fn) && fn.every(utils.isFunction)) {
-      return fn.length > 1 ? this.add(fn.shift()).add(fn) : this.add(fn[0]);
-    } else if (utils.isFunction(fn)) {
-      new Promise((resolve, reject) => {
-        const run = () => {
-          this._ongoingCount++;
-          fn().then(
-            (val: any) => {
-              resolve(val);
-              this._next();
-            },
-            (err: Error) => {
-              reject(err);
-              this._next();
-            }
-          );
-        };
-
-        if (this._ongoingCount < this._concurrency && !this._pause) {
-          run();
-        } else {
-          this._queue.push(run);
-        }
-      });
-      return this;
-    } else {
-      throw new TypeError('Expected `arg` in add(arg) must be a function which return a Promise, or an array of function which return a Promise');
-    }
+  public add(fn: () => Promise<any>): PromiseQueue | TypeError {
+    new Promise((resolve, reject) => {
+      const run = () => {
+        this._ongoingCount++;
+        fn().then(
+          (val: any) => {
+            resolve(val);
+            this._next();
+          },
+          (err: Error) => {
+            reject(err);
+            this._next();
+          }
+        );
+      };
+
+      if (this._ongoingCount < this._concurrency && !this._pause) {
+        run();
+      } else {
+        this._queue.push(run);
+      }
+    });
+    return this;
   }
 
   // Promises which are not ready yet to run in the queue.

src/typeCheck.ts

@@ -6,7 +6,7 @@ describe('When the concurrency limit is 1', function () {
     const promiseQueue = new PromiseQueue({concurrency: 1});
     promiseQueue.add(() => {
       return new Promise(resolve => {
-        assert.equal(promiseQueue.ongoingCount, 1);
+        assert.strictEqual(promiseQueue.ongoingCount, 1);
         setTimeout(function () {
           resolve(1);
         }, 500)
@@ -17,7 +17,7 @@ describe('When the concurrency limit is 1', function () {
       return new Promise(resolve => {
         setTimeout(function () {
           resolve(1);
-          assert.equal(promiseQueue.ongoingCount, 1);
+          assert.strictEqual(promiseQueue.ongoingCount, 1);
         }, 500)
       })
     });
@@ -26,17 +26,17 @@ describe('When the concurrency limit is 1', function () {
       return new Promise(resolve => {
         setTimeout(function () {
           resolve(1);
-          assert.equal(promiseQueue.ongoingCount, 1);
+          assert.strictEqual(promiseQueue.ongoingCount, 1);
           done();
         }, 500)
       })
     });
 
     // only one promise is waiting to run
-    assert.equal(promiseQueue.waitingCount, 2);
+    assert.strictEqual(promiseQueue.waitingCount, 2);
 
     // only one promise is running
-    assert.equal(promiseQueue.ongoingCount, 1);
+    assert.strictEqual(promiseQueue.ongoingCount, 1);
   });
 });
 
@@ -47,7 +47,7 @@ describe('When the concurrency limit is 2', function () {
       return new Promise(resolve => {
         setTimeout(function () {
           resolve(1);
-          assert.equal(promiseQueue.ongoingCount, 2);
+          assert.strictEqual(promiseQueue.ongoingCount, 2);
         }, 500)
       })
     });
@@ -56,7 +56,7 @@ describe('When the concurrency limit is 2', function () {
       return new Promise(resolve => {
         setTimeout(function () {
           resolve(1);
-          assert.equal(promiseQueue.ongoingCount, 2);
+          assert.strictEqual(promiseQueue.ongoingCount, 2);
         }, 500)
       })
     });
@@ -65,7 +65,7 @@ describe('When the concurrency limit is 2', function () {
       return new Promise(resolve => {
         setTimeout(function () {
           resolve(1);
-          assert.equal(promiseQueue.ongoingCount, 2);
+          assert.strictEqual(promiseQueue.ongoingCount, 2);
         }, 500)
       })
     });
@@ -81,10 +81,10 @@ describe('When the concurrency limit is 2', function () {
     });
 
     // only two promise is waiting to run
-    assert.equal(promiseQueue.waitingCount, 2);
+    assert.strictEqual(promiseQueue.waitingCount, 2);
 
     // only two promises is running
-    assert.equal(promiseQueue.ongoingCount, 2);
+    assert.strictEqual(promiseQueue.ongoingCount, 2);
   });
 });
 
@@ -93,7 +93,7 @@ describe('"Add" method can be chaining', function () {
     const promiseQueue = new PromiseQueue({concurrency: 1});
     let pqInstance = promiseQueue.add(() => {
       return new Promise(resolve => {
-        assert.equal(promiseQueue.ongoingCount, 1);
+        assert.strictEqual(promiseQueue.ongoingCount, 1);
         setTimeout(function () {
           resolve(1);
         }, 500)
@@ -102,20 +102,23 @@ describe('"Add" method can be chaining', function () {
 
     assert.ok(pqInstance instanceof PromiseQueue);
 
-    pqInstance.add(() => {
-      return new Promise(resolve => {
-        setTimeout(function () {
-          resolve(1);
-          assert.equal(promiseQueue.ongoingCount, 1);
-          done();
-        }, 500)
-      })
-    });
+    if (!(pqInstance instanceof TypeError)) {
+      pqInstance.add(() => {
+        return new Promise(resolve => {
+          setTimeout(function () {
+            resolve(1);
+            assert.strictEqual(promiseQueue.ongoingCount, 1);
+            done();
+          }, 500)
+        })
+      });
+    }
 
     // only one promise is waiting to run
-    assert.equal(promiseQueue.waitingCount, 1);
+    assert.strictEqual(promiseQueue.waitingCount, 1);
 
     // only one promise is running
-    assert.equal(promiseQueue.ongoingCount, 1);
+    assert.strictEqual(promiseQueue.ongoingCount, 1);
   });
+
 });