secure-event-emitter/SecureEventEmitter.js

SecureEventEmitter is a tiny javascript package that uses restrict rules and mechanisms to build safer and protected event-driven architecture. It's similar to nodejs EventEmitter, but dictates stricter rules to prevent misuse.

"use strict";

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); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }

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

function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }

function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }

function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }

function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }

function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }

function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }

function _classApplyDescriptorSet(receiver, descriptor, value) { 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; } }

var _require = require('./errors'),
    error_if_invalid_emitterKey = _require.error_if_invalid_emitterKey,
    error_if_unlock_failed = _require.error_if_unlock_failed,
    error_if_invalid_eventType = _require.error_if_invalid_eventType,
    error_if_invalid_eventTypes = _require.error_if_invalid_eventTypes,
    error_if_eventType_not_exist = _require.error_if_eventType_not_exist,
    error_if_invalid_validate = _require.error_if_invalid_validate,
    error_if_validation_failed = _require.error_if_validation_failed,
    error_if_invalid_listener = _require.error_if_invalid_listener;

var _listenersMap = /*#__PURE__*/new WeakMap();

var _emitterKey = /*#__PURE__*/new WeakMap();

var _eventTypes = /*#__PURE__*/new WeakMap();

var _validatorFunction = /*#__PURE__*/new WeakMap();

var _emit = /*#__PURE__*/new WeakMap();

var SecureEventEmitter = /*#__PURE__*/_createClass(function SecureEventEmitter(eventTypes, _emitterKey2, validatorFunction) {
  var _this = this;

  _classCallCheck(this, SecureEventEmitter);

  _classPrivateFieldInitSpec(this, _listenersMap, {
    writable: true,
    value: {}
  });

  _classPrivateFieldInitSpec(this, _emitterKey, {
    writable: true,
    value: void 0
  });

  _classPrivateFieldInitSpec(this, _eventTypes, {
    writable: true,
    value: []
  });

  _classPrivateFieldInitSpec(this, _validatorFunction, {
    writable: true,
    value: void 0
  });

  _defineProperty(this, "on", function (eventType, listener) {
    error_if_invalid_eventType(eventType);
    error_if_eventType_not_exist(eventType, _classPrivateFieldGet(_this, _eventTypes));
    error_if_invalid_listener(listener);

    if (!_classPrivateFieldGet(_this, _listenersMap)[eventType].includes(listener)) {
      _classPrivateFieldGet(_this, _listenersMap)[eventType].push(listener);
    }
  });

  _defineProperty(this, "off", function (eventType, listener) {
    error_if_invalid_eventType(eventType);
    error_if_eventType_not_exist(eventType, _classPrivateFieldGet(_this, _eventTypes));
    error_if_invalid_listener(listener);
    _classPrivateFieldGet(_this, _listenersMap)[eventType] = _classPrivateFieldGet(_this, _listenersMap)[eventType].filter(function (l) {
      return l !== listener;
    });
  });

  _defineProperty(this, "unlock", function (emitterKey) {
    error_if_unlock_failed(emitterKey, _classPrivateFieldGet(_this, _emitterKey));
    return {
      emit: _classPrivateFieldGet(_this, _emit)
    };
  });

  _classPrivateFieldInitSpec(this, _emit, {
    writable: true,
    value: function value(eventType) {
      error_if_invalid_eventType(eventType);
      error_if_eventType_not_exist(eventType, _classPrivateFieldGet(_this, _eventTypes));

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

      error_if_validation_failed(_classPrivateFieldGet(_this, _validatorFunction), args);

      var listeners = _classPrivateFieldGet(_this, _listenersMap)[eventType];

      for (var i = 0; i < listeners.length; ++i) {
        listeners[i].apply(listeners, args);
      }
    }
  });

  error_if_invalid_eventTypes(eventTypes);
  error_if_invalid_emitterKey(_emitterKey2);
  error_if_invalid_validate(validatorFunction);

  _classPrivateFieldSet(this, _eventTypes, eventTypes);

  _classPrivateFieldSet(this, _emitterKey, _emitterKey2);

  _classPrivateFieldSet(this, _validatorFunction, validatorFunction);

  for (var i = 0; i < eventTypes.length; ++i) {
    _classPrivateFieldGet(this, _listenersMap)[eventTypes[i]] = [];
  }
} /////// PUBLIC METHODS ////////
);

module.exports = {
  SecureEventEmitter: SecureEventEmitter
};