moltres-utils/dist/common/rate.js

Utils for Moltres apps

"use strict";

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

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

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

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

require("core-js/modules/es6.regexp.to-string");

require("core-js/modules/es6.date.to-string");

require("core-js/modules/es7.symbol.async-iterator");

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

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

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

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

require("core-js/modules/es6.date.now");

require("regenerator-runtime/runtime");

var _ramda = require("ramda");

var _deferredPromise = _interopRequireDefault(require("./deferredPromise"));

var _delay = _interopRequireDefault(require("./delay"));

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

function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }

function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }

function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }

function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }

function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }

var rate = function rate(fn, max, duration) {
  var queue = [];
  var invocations = [];

  var clearInvocations = function clearInvocations(now) {
    // drop all invocations that are over duration
    invocations = (0, _ramda.dropWhile)(function (_ref) {
      var invokedAt = _ref.invokedAt;
      return now - invokedAt > duration;
    }, invocations);
  };

  var doInvoke =
  /*#__PURE__*/
  function () {
    var _ref2 = _asyncToGenerator(
    /*#__PURE__*/
    regeneratorRuntime.mark(function _callee(invocation) {
      var result;
      return regeneratorRuntime.wrap(function _callee$(_context) {
        while (1) {
          switch (_context.prev = _context.next) {
            case 0:
              invocation.invokedAt = Date.now(); // eslint-disable-line no-param-reassign

              invocations = (0, _ramda.append)(invocation, invocations);
              _context.prev = 2;
              _context.next = 5;
              return fn.apply(void 0, _toConsumableArray(invocation.args));

            case 5:
              result = _context.sent;
              invocation.promise.resolve(result);
              _context.next = 12;
              break;

            case 9:
              _context.prev = 9;
              _context.t0 = _context["catch"](2);
              invocation.promise.reject(_context.t0);

            case 12:
            case "end":
              return _context.stop();
          }
        }
      }, _callee, this, [[2, 9]]);
    }));

    return function doInvoke(_x) {
      return _ref2.apply(this, arguments);
    };
  }();

  var delayQueueProcessing = function delayQueueProcessing(now) {
    var _invocations = invocations,
        _invocations2 = _slicedToArray(_invocations, 1),
        firstInvocation = _invocations2[0];

    var waitFor = duration - (now - firstInvocation.invokedAt);
    (0, _delay.default)(processQueue, waitFor); // eslint-disable-line no-use-before-define
  };

  var invoke =
  /*#__PURE__*/
  function () {
    var _ref3 = _asyncToGenerator(
    /*#__PURE__*/
    regeneratorRuntime.mark(function _callee2() {
      var _len,
          args,
          _key,
          now,
          invocation,
          _args2 = arguments;

      return regeneratorRuntime.wrap(function _callee2$(_context2) {
        while (1) {
          switch (_context2.prev = _context2.next) {
            case 0:
              for (_len = _args2.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
                args[_key] = _args2[_key];
              }

              now = Date.now();
              clearInvocations(now);
              invocation = {
                args: args,
                promise: (0, _deferredPromise.default)(),
                invoke: function invoke() {
                  doInvoke(invocation);
                  return invocation.promise;
                }
              };

              if (!((0, _ramda.length)(invocations) >= max)) {
                _context2.next = 8;
                break;
              }

              queue = (0, _ramda.append)(invocation, queue);
              delayQueueProcessing(now);
              return _context2.abrupt("return", invocation.promise);

            case 8:
              return _context2.abrupt("return", invocation.invoke());

            case 9:
            case "end":
              return _context2.stop();
          }
        }
      }, _callee2, this);
    }));

    return function invoke() {
      return _ref3.apply(this, arguments);
    };
  }();

  function processQueue() {
    var now = Date.now();
    clearInvocations(now);
    var numInvokable = max - (0, _ramda.length)(invocations);
    var numInvoked = 0;
    queue = (0, _ramda.dropWhile)(function (invocation) {
      if (numInvoked < numInvokable) {
        invocation.invoke();
        numInvoked += 1;
        return true;
      }

      return false;
    }, queue);

    if ((0, _ramda.length)(queue) > 0) {
      delayQueueProcessing(now);
    }
  }

  return invoke;
};

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