react-promise-tracker/lib/tinyEmmiter.js

Simple React Promise tracker Hook/HOC helper to add loading spinner indicators

"use strict";

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

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

// Based on:
// https://github.com/scottcorgan/tiny-emitter
// class based
var Emitter =
/*#__PURE__*/
function () {
  function Emitter() {
    _classCallCheck(this, Emitter);
  }

  _createClass(Emitter, [{
    key: "emit",
    value: function emit(event) {
      if (!event) return this;

      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
        args[_key - 1] = arguments[_key];
      }

      var _iteratorNormalCompletion = true;
      var _didIteratorError = false;
      var _iteratorError = undefined;

      try {
        for (var _iterator = this._e(event)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
          var fn = _step.value;
          fn.apply(fn.ctx, [].concat(args));
          if (fn.off_event == true) this.off(event, fn);
        }
      } catch (err) {
        _didIteratorError = true;
        _iteratorError = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion && _iterator.return != null) {
            _iterator.return();
          }
        } finally {
          if (_didIteratorError) {
            throw _iteratorError;
          }
        }
      }

      return this;
    }
  }, {
    key: "on",
    value: function on(event, fn, ctx) {
      if (!event) return this;
      fn.ctx = ctx;

      this._e(event).push(fn);

      return this;
    }
  }, {
    key: "once",
    value: function once(event, fn, ctx) {
      if (!event) return this;
      fn.ctx = ctx;
      fn.off_event = true;
      return this.on(event, fn);
    }
  }, {
    key: "off",
    value: function off(event, fn) {
      if (!event) return this;
      if (!this[event]) return this;

      var e = this._e(event);

      if (!fn) {
        delete this[event];
        return this;
      }

      this[event] = e.filter(function (f) {
        return f != fn;
      });
      return this;
    }
  }, {
    key: "_e",
    value: function _e(e) {
      return this[e] || (this[e] = []);
    }
  }]);

  return Emitter;
}();

exports.Emitter = Emitter;