moltres-utils/dist/common/iteratorResolver.js

Utils for Moltres apps

"use strict";

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

require("core-js/modules/es6.array.for-each");

require("core-js/modules/es6.array.filter");

require("core-js/modules/web.dom.iterable");

require("core-js/modules/es6.array.iterator");

require("core-js/modules/es6.object.keys");

require("core-js/modules/es6.object.define-property");

var _isResolved = require("./isResolved");

var _resolveWith = require("./resolveWith");

var _isIterator = _interopRequireDefault(require("../lang/isIterator"));

var _toString = _interopRequireDefault(require("../lang/toString"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

var iterateAt = function iterateAt(iterator, history, pending, index) {
  if (history[index]) {
    return history[index];
  }

  if (pending[index]) {
    return pending[index];
  }

  var next = iterator.next();
  pending[index] = next;
  history[index] = null;
  return (0, _resolveWith.baseResolveWith)(function (resolvedNext) {
    pending[index] = null;

    if (!resolvedNext.done) {
      history[index] = resolvedNext;
    }

    return resolvedNext;
  }, next);
};

var fastForward = function fastForward(histIterator) {
  var next = {
    done: false
  };

  while (!next.done) {
    next = histIterator.next();

    if (!(0, _isResolved.baseIsResolved)(next)) {
      return (0, _resolveWith.baseResolveWith)(function (resolvedNext) {
        if (!resolvedNext.done) {
          return fastForward(histIterator);
        }

        return histIterator;
      }, next);
    }
  }

  return histIterator;
};

var iterAt = function iterAt(index, history) {
  if (index >= 0 && history[index]) {
    var iter = history[index];
    return _objectSpread({}, iter, {
      index: index,
      kdx: index
    });
  }

  return {
    done: true
  };
};

var prevIterAt = function prevIterAt(index, history) {
  if (index >= 0 && history[index]) {
    var iter = history[index];
    return _objectSpread({}, iter, {
      index: index,
      kdx: index
    });
  }
};

var historicIterator = function historicIterator(iterator) {
  var start = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'START';
  var history = [];
  var pending = [];
  var index = 0;
  var histIterator = {
    next: function next() {
      var iter = iterateAt(iterator, history, pending, index);
      return (0, _resolveWith.baseResolveWith)(function (resolvedIter) {
        var prev = prevIterAt(index - 1, history);

        if (!resolvedIter.done) {
          resolvedIter = iterAt(index, history);
          index += 1;
        }

        return _objectSpread({}, resolvedIter, {
          prev: prev
        });
      }, iter);
    },
    previous: function previous() {
      var iter = iterAt(index - 1, history);
      var prev = prevIterAt(index, history);

      if (index >= 0) {
        index -= 1;
      }

      return _objectSpread({}, iter, {
        prev: prev
      });
    }
  };

  if (start === 'END') {
    return fastForward(histIterator);
  }

  return histIterator;
};
/**
 * Returns iterator capable of resolving iterators that might be async, wrapping it in additional functionality.
 *
 * @function
 * @since v0.0.16
 * @category common
 * @param {Iterator} iterator The iterator to wrap
 * @param {string} start The positin to start at.
 * @return {Iterator} A new iterator for the given iterator
 * @example
 *
 * iteratorResolver(
 *  (['write', 'more'])[Symbol.iterator]()
 * )
 * //=> {
 * //   next: () => ({
 * //     value: *,
 * //     done: boolean,
 * //     kdx: integer,
 * //     index: integer
 * //   }),
 * //   previous: () => ({
 * //     value: *,
 * //     done: boolean,
 * //     kdx: integer,
 * //     index: integer
 * //   })
 * // }
 */


var iteratorResolver = function iteratorResolver(iterator) {
  var start = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'START';

  if (!(0, _isIterator.default)(iterator)) {
    throw new TypeError("iteratorResolver expected iterator to be an Iterator value. Instead received ".concat((0, _toString.default)(iterator)));
  } // NOTE BRN: Optimization here of reassigning histIterator so that we don't have to resolve it on every iteration.


  var histIterator;
  histIterator = (0, _resolveWith.baseResolveWith)(function (resolvedIterator) {
    histIterator = resolvedIterator;
    return histIterator;
  }, historicIterator(iterator, start));
  return {
    next: function next() {
      return (0, _resolveWith.baseResolveWith)(function (resolvedIterator) {
        return resolvedIterator.next();
      }, histIterator);
    },
    previous: function previous() {
      return (0, _resolveWith.baseResolveWith)(function (resolvedIterator) {
        return resolvedIterator.previous();
      }, histIterator);
    }
  };
};

var _default = iteratorResolver;
exports.default = _default;
//# sourceMappingURL=iteratorResolver.js.map