feat: add method whileSeries

modules/-all/index.ts

@@ -48,4 +48,5 @@ export { default as timesParallel } from '@promises/times-parallel/add';
 export { default as timesSeries } from '@promises/times-series/add';
 export { default as toCallback } from '@promises/to-callback/add';
 export { default as whileParallel } from '@promises/while-parallel/add';
+export { default as whileSeries } from '@promises/while-series/add';
 export { default as wrap } from '@promises/wrap/add';

modules/-all/package.json

@@ -76,6 +76,7 @@
     "@promises/times-series": "^0.2.0",
     "@promises/to-callback": "^0.2.0",
     "@promises/while-parallel": "NEXT-PLACEHOLDER",
+    "@promises/while-series": "NEXT-PLACEHOLDER",
     "@promises/wrap": "^0.2.0"
   }
 }

modules/-constructor/index.ts

@@ -24,4 +24,5 @@ export {default as timeout} from '@promises/timeout/add';
 export {default as timesParallel} from '@promises/times-parallel/add';
 export {default as timesSeries} from '@promises/times-series/add';
 export {default as whileParallel} from '@promises/while-parallel/add';
+export {default as whileSeries} from '@promises/while-series/add';
 export {default as wrap} from '@promises/wrap/add';

modules/-constructor/package.json

@@ -52,6 +52,7 @@
     "@promises/times-parallel": "^0.2.0",
     "@promises/times-series": "^0.2.0",
     "@promises/while-parallel": "NEXT-PLACEHOLDER",
+    "@promises/while-series": "NEXT-PLACEHOLDER",
     "@promises/wrap": "^0.2.0"
   }
 }

modules/-series/index.ts

@@ -18,3 +18,4 @@ export { default as rejectSeries } from '@promises/reject-series/add';
 export { default as series } from '@promises/series/add';
 export { default as someSeries } from '@promises/some-series/add';
 export { default as timesSeries } from '@promises/times-series/add';
+export { default as whileSeries } from '@promises/while-series/add';

modules/-series/package.json

@@ -45,6 +45,7 @@
     "@promises/reject-series": "^0.2.0",
     "@promises/series": "^0.2.0",
     "@promises/some-series": "^0.2.0",
-    "@promises/times-series": "^0.2.0"
+    "@promises/times-series": "^0.2.0",
+    "@promises/while-series": "NEXT-PLACEHOLDER"
   }
 }

modules/while-series/add.ts

@@ -0,0 +1,37 @@
+import Promises from '@promises/core';
+import { IOptionalPromise } from '@promises/interfaces';
+import whileSeries from './';
+
+Promises._setOnConstructor('whileSeries', whileSeries);
+
+export default whileSeries;
+
+declare module '@promises/core' {
+    namespace Promises {
+        /**
+         * @example
+         *
+         * ```typescript
+         * let index: number = 0;
+         * Promises.whileSeries(() => {
+         *  console.log(`test ${index}`);
+         *  return index++ < 3;
+         * }, () => Promises.timeout((resolve) => {
+         *  console.log(`iteratee ${index}`);
+         *  resolve();
+         * }, 4 - index)).then(() => {
+         *  console.log('completed');
+         * });
+         * // => 'test 0'
+         * // => 'iteratee 1'
+         * // => 'test 1'
+         * // => 'iteratee 2'
+         * // => 'test 2'
+         * // => 'iteratee 3'
+         * // => 'test 3'
+         * // => 'completed'
+         * ```
+         */
+        export function whileSeries(test: () => IOptionalPromise<boolean>, iteratee?: () => IOptionalPromise<any>): Promises<void>;
+    }
+}

modules/while-series/index.ts

@@ -0,0 +1,43 @@
+/**
+ * @module @promises/while-series
+ * @copyright © 2017 Yisrael Eliav <[email protected]> (https://github.com/yisraelx)
+ * @license MIT
+ */
+
+import { IOptionalPromise } from '@promises/interfaces';
+import exec from '@promises/exec';
+import doWhileSeries from '@promises/do-while-series';
+
+/**
+ * @example
+ *
+ * ```typescript
+ * let index: number = 0;
+ * whileSeries(() => {
+ *  console.log(`test ${index}`);
+ *  return index++ < 3;
+ * }, () => timeout((resolve) => {
+ *  console.log(`iteratee ${index}`);
+ *  resolve();
+ * }, 4 - index)).then(() => {
+ *  console.log('completed');
+ * });
+ * // => 'test 0'
+ * // => 'iteratee 1'
+ * // => 'test 1'
+ * // => 'iteratee 2'
+ * // => 'test 2'
+ * // => 'iteratee 3'
+ * // => 'test 3'
+ * // => 'completed'
+ * ```
+ */
+function whileSeries(test: () => IOptionalPromise<boolean>, iteratee: () => IOptionalPromise<any> = () => { }): Promise<void> {
+    return exec(test).then((isPass: boolean) => {
+        if (isPass) {
+            return doWhileSeries(test, iteratee);
+        }
+    });
+}
+
+export default whileSeries;

modules/while-series/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@promises/while-series",
+  "version": "NEXT-PLACEHOLDER",
+  "description": "While Series is package from Promises library",
+  "main": "es5.js",
+  "browser": "umd.min.js",
+  "module": "index.js",
+  "es2015": "index.js",
+  "typings": "index.d.ts",
+  "bundle": "bundle.min.js",
+  "author": {
+    "name": "Yisrael Eliev",
+    "url": "https://github.com/yisraelx",
+    "email": "[email protected]"
+  },
+  "license": "MIT",
+  "keywords": [
+    "promise",
+    "promises",
+    "utility",
+    "modules",
+    "async",
+    "await",
+    "deferred"
+  ],
+  "homepage": "https://github.com/yisraelx/promises#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yisraelx/promises.git"
+  },
+  "bugs": {
+    "url": "https://github.com/yisraelx/promises/issues"
+  },
+  "optionalDependencies": {
+    "@promises/core": "^0.2.0"
+  },
+  "dependencies": {
+    "@promises/do-while-series": "NEXT-PLACEHOLDER",
+    "@promises/exec": "^0.2.0",
+    "@promises/interfaces": "^0.2.0"
+  }
+}

test/while-series.spec.ts

@@ -0,0 +1,109 @@
+import whileSeries from '@promises/while-series';
+import timeout from '@promises/timeout';
+
+describe('whileSeries', () => {
+
+    it('should be not iteratee if test not pass', () => {
+        let test = 0;
+        let iteratee = 0;
+        return whileSeries(() => {
+            test++;
+            return false;
+        }, () => {
+            iteratee++;
+        }).then(() => {
+            expect(test).toBe(1);
+            expect(iteratee).toBe(0);
+        });
+    });
+
+    it('should be iteratee without iteratee function', () => {
+        let index = 0;
+        return whileSeries(() => {
+            return index++ < 5;
+        }).then(() => {
+            expect(index).toBe(6);
+        });
+    });
+
+    it('should be reject on test error', () => {
+        return whileSeries(() => {
+            throw 'test';
+        }, () => {
+            throw 'iteratee';
+        }).then(() => {
+            throw 'resolve';
+        }).catch((error) => {
+            expect(error).toBe('test');
+        });
+    });
+
+    it('should be reject on iteratee error', () => {
+        let stop = false;
+        return whileSeries(() => {
+            return stop = !stop;
+        }, () => {
+            throw 'iteratee';
+        }).then(() => {
+            throw 'resolve';
+        }).catch((error) => {
+            expect(error).toBe('iteratee');
+        });
+    });
+
+    it('should be iteratee series 5 times', () => {
+        let count = 0;
+        let length = 5;
+        let test = [];
+        let iteratee = [];
+        return whileSeries(() => {
+            test.push(count);
+            return count++ < length;
+        }, () => {
+            iteratee.push(count);
+        }).then(() => {
+            expect(count).toBe(6);
+            expect(test).toEqual([0, 1, 2, 3, 4, 5]);
+            expect(iteratee).toEqual([1, 2, 3, 4, 5]);
+        });
+    });
+
+    it('should be iteratee series 5 times with promise iteratee', () => {
+        let count = 0;
+        let length = 5;
+        let test = [];
+        let iteratee = [];
+        return whileSeries(() => {
+            test.push(count);
+            return count++ < length;
+        }, () => {
+            return timeout((resolve) => {
+                iteratee.push(count);
+                resolve();
+            }, length - count);
+        }).then(() => {
+            expect(count).toBe(6);
+            expect(test).toEqual([0, 1, 2, 3, 4, 5]);
+            expect(iteratee).toEqual([1, 2, 3, 4, 5]);
+        });
+    });
+
+    it('should be iteratee series 5 times with promise test', () => {
+        let count = 0;
+        let length = 5;
+        let test = [];
+        let iteratee = [];
+        return whileSeries(() => {
+            return timeout((resolve) => {
+                test.push(count);
+                resolve(count++ < length);
+            });
+        }, () => {
+            iteratee.push(count);
+        }).then(() => {
+            expect(count).toBe(6);
+            expect(test).toEqual([0, 1, 2, 3, 4, 5]);
+            expect(iteratee).toEqual([1, 2, 3, 4, 5]);
+        });
+    });
+});