mergeiterator/dist/polyfills/asyncFromSync.js

merges async iterators

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.compatAsyncFromSync = compatAsyncFromSync;
exports.compatForAwaitOfSyncWrapper = compatForAwaitOfSyncWrapper;
exports.dummyAsyncFromSync = dummyAsyncFromSync;
exports.dummyForAwaitOfSyncWrapper = dummyForAwaitOfSyncWrapper;
exports.setDummyHandlers = setDummyHandlers;
exports.setCompatHandlers = setCompatHandlers;
exports.forAwaitOfSyncWrapper = exports.asyncFromSync = void 0;

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 _asyncGeneratorDelegate(inner, awaitWrap) { var iter = {}, waiting = false; function pump(key, value) { waiting = true; value = new Promise(function (resolve) { resolve(inner[key](value)); }); return { done: false, value: awaitWrap(value) }; } ; if (typeof Symbol === "function" && Symbol.iterator) { iter[Symbol.iterator] = function () { return this; }; } iter.next = function (value) { if (waiting) { waiting = false; return value; } return pump("next", value); }; if (typeof inner.throw === "function") { iter.throw = function (value) { if (waiting) { waiting = false; throw value; } return pump("throw", value); }; } if (typeof inner.return === "function") { iter.return = function (value) { if (waiting) { waiting = false; return value; } return pump("return", value); }; } return iter; }

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; }

function compatAsyncFromSync(_x) {
  return _compatAsyncFromSync.apply(this, arguments);
}

function _compatAsyncFromSync() {
  _compatAsyncFromSync = _wrapAsyncGenerator(function* (iterable) {
    const it = iterable[Symbol.iterator]();
    let needToClose;

    try {
      for (;;) {
        needToClose = false;
        const rec = it.next();
        needToClose = true;

        if (rec.done) {
          needToClose = false;
          return yield _awaitAsyncGenerator(rec.value);
        }

        yield rec.value;
      }
    } finally {
      if (needToClose) {
        var _it$return;

        yield _awaitAsyncGenerator((_it$return = it.return) === null || _it$return === void 0 ? void 0 : _it$return.call(it).value);
      }
    }
  });
  return _compatAsyncFromSync.apply(this, arguments);
}

function compatForAwaitOfSyncWrapper(iterable) {
  if (Symbol.asyncIterator in iterable) {
    return iterable;
  }

  return compatAsyncFromSync(iterable);
}

function dummyAsyncFromSync(_x2) {
  return _dummyAsyncFromSync.apply(this, arguments);
}

function _dummyAsyncFromSync() {
  _dummyAsyncFromSync = _wrapAsyncGenerator(function* (iterable) {
    yield* _asyncGeneratorDelegate(_asyncIterator(iterable), _awaitAsyncGenerator);
  });
  return _dummyAsyncFromSync.apply(this, arguments);
}

function dummyForAwaitOfSyncWrapper(iterable) {
  return iterable;
} // eslint-disable-next-line import/no-mutable-exports


let asyncFromSync; // eslint-disable-next-line import/no-mutable-exports

exports.asyncFromSync = asyncFromSync;
let forAwaitOfSyncWrapper;
exports.forAwaitOfSyncWrapper = forAwaitOfSyncWrapper;

function setDummyHandlers() {
  exports.asyncFromSync = asyncFromSync = dummyAsyncFromSync;
  exports.forAwaitOfSyncWrapper = forAwaitOfSyncWrapper = dummyForAwaitOfSyncWrapper;
}

function setCompatHandlers() {
  exports.asyncFromSync = asyncFromSync = compatAsyncFromSync;
  exports.forAwaitOfSyncWrapper = forAwaitOfSyncWrapper = compatForAwaitOfSyncWrapper;
}

async function isEngineValid() {
  let checks = 2;

  try {
    // eslint-disable-next-line @typescript-eslint/no-unused-vars
    var _iteratorNormalCompletion = true;
    var _didIteratorError = false;

    var _iteratorError;

    try {
      for (var _iterator = _asyncIterator(function* () {
        try {
          yield Promise.reject(); // istanbul ignore next

          checks = Infinity;
        } finally {
          // istanbul ignore next
          checks--;
        } // eslint-disable-next-line no-empty

      }()), _step, _value; _step = await _iterator.next(), _iteratorNormalCompletion = _step.done, _value = await _step.value, !_iteratorNormalCompletion; _iteratorNormalCompletion = true) {
        const x = _value;
      } // eslint-disable-next-line no-empty

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

  try {
    // eslint-disable-next-line @typescript-eslint/no-unused-vars
    var _iteratorNormalCompletion2 = true;
    var _didIteratorError2 = false;

    var _iteratorError2;

    try {
      for (var _iterator2 = _asyncIterator(_wrapAsyncGenerator(function* () {
        yield* _asyncGeneratorDelegate(_asyncIterator(function* () {
          try {
            yield Promise.reject(); // istanbul ignore next

            checks = Infinity;
          } finally {
            // istanbul ignore next
            checks--;
          }
        }()), _awaitAsyncGenerator); // eslint-disable-next-line no-empty
      })()), _step2, _value2; _step2 = await _iterator2.next(), _iteratorNormalCompletion2 = _step2.done, _value2 = await _step2.value, !_iteratorNormalCompletion2; _iteratorNormalCompletion2 = true) {
        const x = _value2;
      } // eslint-disable-next-line no-empty

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

  return checks === 0;
} // istanbul ignore next


async function checkEngine() {
  setCompatHandlers();

  if (await isEngineValid()) {
    setDummyHandlers();
  }
}

checkEngine();