limited-request-queue/lib-es5/index.js

Interactively manage concurrency for outbound requests.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = exports.ITEM_EVENT = exports.END_EVENT = exports.DEFAULT_OPTIONS = void 0;

var _events = require("events");

var _isurl = _interopRequireDefault(require("isurl"));

var _normalizeURL = _interopRequireDefault(require("./normalizeURL"));

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

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 _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(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; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }

function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }

function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }

function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }

function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }

function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }

function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }

function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }

function _classPrivateFieldGet(receiver, privateMap) { var descriptor = privateMap.get(receiver); if (!descriptor) { throw new TypeError("attempted to get private field on non-instance"); } if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }

function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = privateMap.get(receiver); if (!descriptor) { throw new TypeError("attempted to set private field on non-instance"); } if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } return value; }

var DEFAULT_OPTIONS = Object.freeze({
  ignorePorts: true,
  ignoreProtocols: true,
  ignoreSubdomains: true,
  maxSockets: Infinity,
  maxSocketsPerHost: 2,
  rateLimit: 0
});
exports.DEFAULT_OPTIONS = DEFAULT_OPTIONS;
var END_EVENT = "end";
exports.END_EVENT = END_EVENT;
var ITEM_EVENT = "item";
exports.ITEM_EVENT = ITEM_EVENT;

var RequestQueue =
/*#__PURE__*/
function (_EventEmitter) {
  _inherits(RequestQueue, _EventEmitter);

  // Socket counts stored by host
  // Items stored by ID
  // List of IDs
  function RequestQueue(options) {
    var _this;

    _classCallCheck(this, RequestQueue);

    _this = _possibleConstructorReturn(this, _getPrototypeOf(RequestQueue).call(this));

    _removeItem.add(_assertThisInitialized(_this));

    _maybeStartNext.add(_assertThisInitialized(_this));

    _getDoneCallback.add(_assertThisInitialized(_this));

    _emit.add(_assertThisInitialized(_this));

    _dequeueItem.add(_assertThisInitialized(_this));

    _activeHosts.set(_assertThisInitialized(_this), {
      writable: true,
      value: {}
    });

    _items.set(_assertThisInitialized(_this), {
      writable: true,
      value: {}
    });

    _priorityQueue.set(_assertThisInitialized(_this), {
      writable: true,
      value: []
    });

    _activeSockets.set(_assertThisInitialized(_this), {
      writable: true,
      value: 0
    });

    _idCounter.set(_assertThisInitialized(_this), {
      writable: true,
      value: 0
    });

    _isPaused.set(_assertThisInitialized(_this), {
      writable: true,
      value: false
    });

    _options.set(_assertThisInitialized(_this), {
      writable: true,
      value: void 0
    });

    _classPrivateFieldSet(_assertThisInitialized(_this), _options, _objectSpread({}, DEFAULT_OPTIONS, {}, options));

    return _this;
  }

  _createClass(RequestQueue, [{
    key: "dequeue",
    value: function dequeue(id) {
      var item = _classPrivateFieldGet(this, _items)[id];

      if (item === undefined || item.active) {
        return false;
      } else {
        _classPrivateMethodGet(this, _dequeueItem, _dequeueItem2).call(this, item);

        _classPrivateMethodGet(this, _removeItem, _removeItem2).call(this, item);

        return true;
      }
    }
    /**
     * Remove item (id) from queue, but nowhere else.
     * @param {object} item
     */

  }, {
    key: "enqueue",
    value: function enqueue(url, data, options) {
      if (!_isurl["default"].lenient(url)) {
        throw new TypeError("Invalid URL");
      } else {
        var _this$idCounter;

        var hostKey = (0, _normalizeURL["default"])(url, _classPrivateFieldGet(this, _options), options);
        var id = (_classPrivateFieldSet(this, _idCounter, (_this$idCounter = +_classPrivateFieldGet(this, _idCounter)) + 1), _this$idCounter);
        _classPrivateFieldGet(this, _items)[id] = {
          active: false,
          data: data,
          hostKey: hostKey,
          id: id,
          options: options,
          url: url
        };

        _classPrivateFieldGet(this, _priorityQueue).push(id);

        _classPrivateMethodGet(this, _maybeStartNext, _maybeStartNext2).call(this);

        return id;
      }
    }
    /**
     * Generate a `done()` function for use in resuming the queue when an item's
     * process has been completed.
     * @param {object} item
     * @returns {Function}
     */

  }, {
    key: "has",
    value: function has(id) {
      return id in _classPrivateFieldGet(this, _items);
    }
  }, {
    key: "pause",
    value: function pause() {
      _classPrivateFieldSet(this, _isPaused, true);

      return this;
    }
    /**
     * Remove item from item list and activeHosts.
     * @param {object} item
     */

  }, {
    key: "resume",
    value: function resume() {
      _classPrivateFieldSet(this, _isPaused, false);

      _classPrivateMethodGet(this, _maybeStartNext, _maybeStartNext2).call(this);

      return this;
    }
  }, {
    key: "isPaused",
    get: function get() {
      return _classPrivateFieldGet(this, _isPaused);
    }
  }, {
    key: "length",
    get: function get() {
      return _classPrivateFieldGet(this, _priorityQueue).length + _classPrivateFieldGet(this, _activeSockets);
    }
    /**
     * Start the next queue item, if it exists and if it passes any limiting.
     */

  }, {
    key: "numActive",
    get: function get() {
      return _classPrivateFieldGet(this, _activeSockets);
    }
  }, {
    key: "numQueued",
    get: function get() {
      return _classPrivateFieldGet(this, _priorityQueue).length;
    }
  }]);

  return RequestQueue;
}(_events.EventEmitter);

exports["default"] = RequestQueue;

var _activeHosts = new WeakMap();

var _items = new WeakMap();

var _priorityQueue = new WeakMap();

var _activeSockets = new WeakMap();

var _idCounter = new WeakMap();

var _isPaused = new WeakMap();

var _options = new WeakMap();

var _dequeueItem = new WeakSet();

var _emit = new WeakSet();

var _getDoneCallback = new WeakSet();

var _maybeStartNext = new WeakSet();

var _removeItem = new WeakSet();

var _dequeueItem2 = function _dequeueItem2(_ref) {
  var id = _ref.id;

  var itemIndex = _classPrivateFieldGet(this, _priorityQueue).indexOf(id);

  _classPrivateFieldGet(this, _priorityQueue).splice(itemIndex, 1);
};

var _emit2 = function _emit2(event, args, timeout) {
  var _this2 = this;

  if (timeout > 0) {
    setTimeout(function () {
      var _get2;

      return (_get2 = _get(_getPrototypeOf(RequestQueue.prototype), "emit", _this2)).call.apply(_get2, [_this2, event].concat(_toConsumableArray(args)));
    }, timeout);
  } else {
    var _get3;

    (_get3 = _get(_getPrototypeOf(RequestQueue.prototype), "emit", this)).call.apply(_get3, [this, event].concat(_toConsumableArray(args)));
  }
};

var _getDoneCallback2 = function _getDoneCallback2(item) {
  var _this3 = this;

  return function () {
    var _this$activeSockets;

    _classPrivateFieldSet(_this3, _activeSockets, (_this$activeSockets = +_classPrivateFieldGet(_this3, _activeSockets)) - 1), _this$activeSockets;

    _classPrivateMethodGet(_this3, _removeItem, _removeItem2).call(_this3, item);

    _classPrivateMethodGet(_this3, _maybeStartNext, _maybeStartNext2).call(_this3);
  };
};

var _maybeStartNext2 = function _maybeStartNext2() {
  var availableSockets = _classPrivateFieldGet(this, _options).maxSockets - _classPrivateFieldGet(this, _activeSockets);

  if (!_classPrivateFieldGet(this, _isPaused) && availableSockets > 0) {
    var i = 0;

    while (i < _classPrivateFieldGet(this, _priorityQueue).length) {
      var _ref2, _item$options;

      var canStart = false;

      var item = _classPrivateFieldGet(this, _items)[_classPrivateFieldGet(this, _priorityQueue)[i]];

      var maxSocketsPerHost = (_ref2 = (_item$options = item.options) === null || _item$options === void 0 ? void 0 : _item$options.maxSocketsPerHost) !== null && _ref2 !== void 0 ? _ref2 : _classPrivateFieldGet(this, _options).maxSocketsPerHost; // Not important, but feature complete

      if (maxSocketsPerHost > 0) {
        if (_classPrivateFieldGet(this, _activeHosts)[item.hostKey] === undefined) {
          // Create key with first count
          _classPrivateFieldGet(this, _activeHosts)[item.hostKey] = 1;
          canStart = true;
        } else if (_classPrivateFieldGet(this, _activeHosts)[item.hostKey] < maxSocketsPerHost) {
          _classPrivateFieldGet(this, _activeHosts)[item.hostKey]++;
          canStart = true;
        }
      }

      if (canStart) {
        var _this$activeSockets2, _ref3, _item$options2;

        _classPrivateFieldSet(this, _activeSockets, (_this$activeSockets2 = +_classPrivateFieldGet(this, _activeSockets)) + 1), _this$activeSockets2;
        availableSockets--;
        item.active = true;

        _classPrivateMethodGet(this, _dequeueItem, _dequeueItem2).call(this, item);

        var rateLimit = (_ref3 = (_item$options2 = item.options) === null || _item$options2 === void 0 ? void 0 : _item$options2.rateLimit) !== null && _ref3 !== void 0 ? _ref3 : _classPrivateFieldGet(this, _options).rateLimit;

        _classPrivateMethodGet(this, _emit, _emit2).call(this, ITEM_EVENT, [item.url, item.data, _classPrivateMethodGet(this, _getDoneCallback, _getDoneCallback2).call(this, item)], rateLimit);

        if (availableSockets <= 0) {
          break;
        }
      } else {
        // Move onto next
        i++;
      }
    }
  }
};

var _removeItem2 = function _removeItem2(_ref4) {
  var hostKey = _ref4.hostKey,
      id = _ref4.id;

  if (--_classPrivateFieldGet(this, _activeHosts)[hostKey] <= 0) {
    delete _classPrivateFieldGet(this, _activeHosts)[hostKey];
  }

  delete _classPrivateFieldGet(this, _items)[id];

  if (_classPrivateFieldGet(this, _priorityQueue).length <= 0 && _classPrivateFieldGet(this, _activeSockets) <= 0) {
    _classPrivateFieldSet(this, _idCounter, 0); // reset


    _get(_getPrototypeOf(RequestQueue.prototype), "emit", this).call(this, END_EVENT);
  }
};
//# sourceMappingURL=index.js.map