mergeiterator/dist/mergeiterator.js

merges async iterators

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.merge = merge;

var _asyncFromSync = require("./polyfills/asyncFromSync");

function _asyncIterator(iterable) { var method; if (typeof Symbol !== "undefined") { if (Symbol.asyncIterator) { method = iterable[Symbol.asyncIterator]; if (method != null) return method.call(iterable); } if (Symbol.iterator) { method = iterable[Symbol.iterator]; if (method != null) return method.call(iterable); } } throw new TypeError("Object is not async iterable"); }

function _awaitAsyncGenerator(value) { return new _AwaitValue(value); }

function _wrapAsyncGenerator(fn) { return function () { return new _AsyncGenerator(fn.apply(this, arguments)); }; }

function _AsyncGenerator(gen) { var front, back; function send(key, arg) { return new Promise(function (resolve, reject) { var request = { key: key, arg: arg, resolve: resolve, reject: reject, next: null }; if (back) { back = back.next = request; } else { front = back = request; resume(key, arg); } }); } function resume(key, arg) { try { var result = gen[key](arg); var value = result.value; var wrappedAwait = value instanceof _AwaitValue; Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) { if (wrappedAwait) { resume(key === "return" ? "return" : "next", arg); return; } settle(result.done ? "return" : "normal", arg); }, function (err) { resume("throw", err); }); } catch (err) { settle("throw", err); } } function settle(type, value) { switch (type) { case "return": front.resolve({ value: value, done: true }); break; case "throw": front.reject(value); break; default: front.resolve({ value: value, done: false }); break; } front = front.next; if (front) { resume(front.key, front.arg); } else { back = null; } } this._invoke = send; if (typeof gen.return !== "function") { this.return = undefined; } }

if (typeof Symbol === "function" && Symbol.asyncIterator) { _AsyncGenerator.prototype[Symbol.asyncIterator] = function () { return this; }; }

_AsyncGenerator.prototype.next = function (arg) { return this._invoke("next", arg); };

_AsyncGenerator.prototype.throw = function (arg) { return this._invoke("throw", arg); };

_AsyncGenerator.prototype.return = function (arg) { return this._invoke("return", arg); };

function _AwaitValue(value) { this.wrapped = value; }

/**
 * Merges async or sync iterables into async one.
 */
function merge(_x) {
  return _merge.apply(this, arguments);
}

function _merge() {
  _merge = _wrapAsyncGenerator(function* (sequences) {
    //
    let onDataNeeded = () => {};

    let dataNeeded = new Promise(setOnDataNeeded);

    let onStateChanged = () => {}; // should be called whenever values used in the main `while` loop have been changed. These are: iteratorsCount > 0 and values


    const values = [];
    let iteratorsCount = 0;
    let mergeDone = false;
    let normalReturn = true;
    countIterator(readRoot());

    try {
      while (iteratorsCount > 0) {
        const oldOnDataNeeded = onDataNeeded;
        dataNeeded = new Promise(setOnDataNeeded);
        const stateChanged = new Promise(setOnStateChanged);
        oldOnDataNeeded();
        yield _awaitAsyncGenerator(stateChanged);

        while (values.length > 0) {
          yield values.shift();
        }
      }
    } catch (error) {
      normalReturn = false;
      throw error;
    } finally {
      mergeDone = true;
      onDataNeeded();

      while (iteratorsCount > 0) {
        yield _awaitAsyncGenerator(new Promise(setOnStateChanged));
      } // Do not hide an exception if it's been already raised.


      if (normalReturn) {
        // Raise possible exceptions on iterators interruption.
        while (values.length > 0) {
          yield _awaitAsyncGenerator(values.shift());
        }
      }
    }

    async function readRoot() {
      var _iteratorNormalCompletion = true;
      var _didIteratorError = false;

      var _iteratorError;

      try {
        for (var _iterator = _asyncIterator((0, _asyncFromSync.forAwaitOfSyncWrapper)((await sequences))), _step, _value; _step = await _iterator.next(), _iteratorNormalCompletion = _step.done, _value = await _step.value, !_iteratorNormalCompletion; _iteratorNormalCompletion = true) {
          const sequence = _value;

          if (mergeDone) {
            break;
          }

          countIterator(readChild(sequence));

          if (values.length > 0) {
            await dataNeeded;
          }

          if (mergeDone) {
            break;
          }
        }
      } catch (err) {
        _didIteratorError = true;
        _iteratorError = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion && _iterator.return != null) {
            await _iterator.return();
          }
        } finally {
          if (_didIteratorError) {
            throw _iteratorError;
          }
        }
      }
    }

    async function readChild(sequence) {
      var _iteratorNormalCompletion2 = true;
      var _didIteratorError2 = false;

      var _iteratorError2;

      try {
        for (var _iterator2 = _asyncIterator((0, _asyncFromSync.forAwaitOfSyncWrapper)(sequence)), _step2, _value2; _step2 = await _iterator2.next(), _iteratorNormalCompletion2 = _step2.done, _value2 = await _step2.value, !_iteratorNormalCompletion2; _iteratorNormalCompletion2 = true) {
          const value = _value2;
          values.push(value);
          onStateChanged();
          await dataNeeded;

          if (mergeDone) {
            break;
          }
        }
      } catch (err) {
        _didIteratorError2 = true;
        _iteratorError2 = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
            await _iterator2.return();
          }
        } finally {
          if (_didIteratorError2) {
            throw _iteratorError2;
          }
        }
      }
    }

    function countIterator(reader) {
      iteratorsCount++;
      reader.then(() => {
        iteratorsCount--;

        if (iteratorsCount === 0) {
          onStateChanged();
        }
      }, error => {
        iteratorsCount--;
        values.push(getError(error));
        onStateChanged();
      });
    }

    function setOnStateChanged(resolve) {
      onStateChanged = resolve;
    }

    function setOnDataNeeded(resolve) {
      onDataNeeded = resolve;
    }
  });
  return _merge.apply(this, arguments);
}

function getError(error) {
  return {
    then: (resolve, reject) => reject(error)
  };
}