eachSeries.js

  1. 'use strict';
  3. const { AigleProxy } = require('aigle-core');
  5. const Aigle = require('./aigle');
  6. const { INTERNAL, PENDING } = require('./internal/util');
  7. const { execute, setSeries } = require('./internal/collection');
  9. class EachSeries extends AigleProxy {
  10.   constructor(collection, iterator, set = setDefault) {
  11.     super();
  12.     this._iterator = iterator;
  13.     this._promise = new Aigle(INTERNAL);
  14.     this._index = 0;
  15.     this._coll = undefined;
  16.     this._rest = undefined;
  17.     this._size = undefined;
  18.     this._keys = undefined;
  19.     this._result = undefined;
  20.     this._iterate = undefined;
  21.     if (collection === PENDING) {
  22.       this._set = set;
  23.       this._iterate = this._callResolve;
  24.       this._callResolve = execute;
  25.     } else {
  26.       set.call(this, collection);
  27.     }
  28.   }
  30.   _execute() {
  31.     if (this._rest === 0) {
  32.       this._promise._resolve(this._result);
  33.     } else {
  34.       this._iterate();
  35.     }
  36.     return this._promise;
  37.   }
  39.   _callResolve(value) {
  40.     if (--this._rest === 0 || value === false) {
  41.       this._promise._resolve(this._result);
  42.     } else {
  43.       this._iterate();
  44.     }
  45.   }
  47.   _callReject(reason) {
  48.     this._promise._reject(reason);
  49.   }
  50. }
  52. module.exports = { eachSeries, EachSeries };
  54. function setDefault(collection) {
  55.   setSeries.call(this, collection);
  56.   this._result = collection;
  57.   return this;
  58. }
  60. /**
  61.  * `Aigle.eachSeries` is almost the same as [`Aigle.each`](https://suguru03.github.io/aigle/docs/Aigle.html#each), but it will work in series.
  62.  * @param {Array|Object} collection
  63.  * @param {Function} iterator
  64.  * @return {Aigle} Returns an Aigle instance
  65.  * @example
  66.  * const order = [];
  67.  * const collection = [1, 4, 2];
  68.  * const iterator = num => {
  69.  *   return Aigle.delay(num * 10)
  70.  *     .then(() => order.push(num));
  71.  * };
  72.  * Aigle.eachSeries(collection, iterator)
  73.  *   .then(value => {
  74.  *     console.log(value); // undefined
  75.  *     console.log(order); // [1, 4, 2];
  76.  *   });
  77.  *
  78.  * @example
  79.  * const order = [];
  80.  * const collection = { a: 1, b: 4, c: 2 };
  81.  * const iterator = num => {
  82.  *   return Aigle.delay(num * 10)
  83.  *     .then(() => order.push(num));
  84.  * };
  85.  * Aigle.eachSeries(collection, iterator)
  86.  *   .then(value => {
  87.  *     console.log(value); // undefined
  88.  *     console.log(order); // [1, 4, 2];
  89.  *   });
  90.  *
  91.  * @example
  92.  * const order = [];
  93.  * const collection = [1, 4, 2];
  94.  * const iterator = num => {
  95.  *   return Aigle.delay(num * 10)
  96.  *     .then(() => {
  97.  *       order.push(num);
  98.  *       return num !== 4; // break
  99.  *     });
  100.  * };
  101.  * Aigle.eachSeries(collection, iterator)
  102.  *   .then(value => {
  103.  *     console.log(value); // undefined
  104.  *     console.log(order); // [1, 4];
  105.  *   });
  106.  */
  107. function eachSeries(collection, iterator) {
  108.   return new EachSeries(collection, iterator)._execute();
  109. }