emithor/dist/index.js

Simple Event Machine for JS

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = exports.getChannels = exports.unsubscribe = exports.publish = exports.fire = exports.subscribe = exports.register = exports.getEvents = exports.trigger = exports.remove = exports.on = 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.function.name");

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

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

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

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

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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

// Private-like symbols for members
var addEvent = Symbol();
var deleteEvent = Symbol();
var getEvent = Symbol();
var addCallback = Symbol();
var deleteCallback = Symbol();
var events = Symbol();
/**
 * Class representation of pub-sub
 *
 * @class
 */

var Emithor = function Emithor() {
  var _this = this;

  _classCallCheck(this, Emithor);

  _defineProperty(this, "on", function (eventName, callback) {
    var ctx = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
    var once = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
    if (typeof eventName !== 'string' || eventName === '' || typeof callback !== 'function') return;
    var newCallback = {
      fn: callback,
      once: once,
      ctx: ctx // Add new event if that event don't exist already

    };
    var event = _this[getEvent](eventName) || null;

    if (!event) {
      _this[addEvent](eventName, newCallback, ctx, once);

      return;
    } // Register callback to event if that callback
    // is not yet registered on that event


    var isCallbackRegistered = !!(event && event.cbs.find(function (cb) {
      return cb.fn === callback;
    }));

    if (!isCallbackRegistered) {
      _this[addCallback](eventName, newCallback);
    }
  });

  _defineProperty(this, "trigger", function (eventName, contextOverride) {
    for (var _len = arguments.length, payload = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
      payload[_key - 2] = arguments[_key];
    }

    var event = _this[getEvent](eventName);

    if (!event) return;
    event.cbs.forEach(function (cb) {
      try {
        var _cb$fn;

        (_cb$fn = cb.fn).call.apply(_cb$fn, [contextOverride || cb.ctx].concat(payload));
      } catch (error) {
        throw new Error(error);
      }

      if (cb.once) {
        _this[deleteCallback](eventName, cb.fn);
      }
    });
  });

  _defineProperty(this, "remove", function (eventName) {
    var callback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
    var event = _this[getEvent](eventName) || null;
    if (!event) return;

    if (callback) {
      _this[deleteCallback](eventName, callback);
    } else {
      _this[deleteEvent](eventName);
    }
  });

  _defineProperty(this, "getEvents", function () {
    return _toConsumableArray(_this[events]);
  });

  _defineProperty(this, addEvent, function (eventName, newCallback) {
    var newEvent = {
      name: eventName,
      cbs: [newCallback]
    };
    _this[events] = [].concat(_toConsumableArray(_this[events]), [newEvent]);
  });

  _defineProperty(this, deleteEvent, function (eventName) {
    _this[events] = _toConsumableArray(_this[events]).filter(function (event) {
      return event.name !== eventName;
    });
  });

  _defineProperty(this, addCallback, function (eventName, callback) {
    _this[events] = _toConsumableArray(_this[events]).map(function (e) {
      if (e.name === eventName) {
        e.cbs = [].concat(_toConsumableArray(e.cbs), [callback]);
      }

      return e;
    });
  });

  _defineProperty(this, deleteCallback, function (eventName, callback) {
    _this[events] = _toConsumableArray(_this[events]).map(function (event) {
      if (event.name === eventName) {
        event.cbs = _toConsumableArray(event.cbs).filter(function (cb) {
          return cb.fn !== callback;
        });
      }

      return event;
    });

    if (!_this[getEvent](eventName).cbs.length) {
      _this[deleteEvent](eventName);
    }
  });

  _defineProperty(this, getEvent, function (eventName) {
    return _this[events].find(function (event) {
      return event.name === eventName;
    });
  });

  this[events] = [];
}
/**
 * Registers callback to specifeid event.
 *
 * @function
 * @public
 * @param {string} eventName - Can't be empty string
 * @param {function} callback
 * @param {object} ctx - Context which is to be provided to callback
 * @param {boolean} once - Controls if callback is going to be invoked only once
 */
; // Private Emithor instace used to expose api


var emithor = new Emithor();
var on = emithor.on,
    remove = emithor.remove,
    trigger = emithor.trigger,
    getEvents = emithor.getEvents,
    register = emithor.on,
    subscribe = emithor.on,
    fire = emithor.trigger,
    publish = emithor.trigger,
    unsubscribe = emithor.remove,
    getChannels = emithor.getEvents; // Exposing constructor

exports.getChannels = getChannels;
exports.unsubscribe = unsubscribe;
exports.publish = publish;
exports.fire = fire;
exports.subscribe = subscribe;
exports.register = register;
exports.getEvents = getEvents;
exports.trigger = trigger;
exports.remove = remove;
exports.on = on;
var _default = Emithor;
exports.default = _default;