secure-event-emitter/singular-event-emitter.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 _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct.bind(); } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }

function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

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

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('./SecureEventEmitter'),
    SecureEventEmitter = _require.SecureEventEmitter;

var EVENT_TYPE = 'singular-event';

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

var SingularEventEmitter = /*#__PURE__*/_createClass(function SingularEventEmitter() {
  var _this = this;

  _classCallCheck(this, SingularEventEmitter);

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

  _defineProperty(this, "on", function () {
    var _classPrivateFieldGet2;

    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
      args[_key2] = arguments[_key2];
    }

    return (_classPrivateFieldGet2 = _classPrivateFieldGet(_this, _secureEventEmitter)).on.apply(_classPrivateFieldGet2, [EVENT_TYPE].concat(args));
  });

  _defineProperty(this, "off", function () {
    var _classPrivateFieldGet3;

    for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
      args[_key3] = arguments[_key3];
    }

    return (_classPrivateFieldGet3 = _classPrivateFieldGet(_this, _secureEventEmitter)).off.apply(_classPrivateFieldGet3, [EVENT_TYPE].concat(args));
  });

  _defineProperty(this, "unlock", function () {
    var _classPrivateFieldGet5;

    var _classPrivateFieldGet4 = (_classPrivateFieldGet5 = _classPrivateFieldGet(_this, _secureEventEmitter)).unlock.apply(_classPrivateFieldGet5, arguments),
        _emit = _classPrivateFieldGet4.emit;

    return {
      emit: function emit() {
        for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
          args[_key4] = arguments[_key4];
        }

        return _emit.apply(void 0, [EVENT_TYPE].concat(args));
      }
    };
  });

  for (var _len = arguments.length, _args = new Array(_len), _key = 0; _key < _len; _key++) {
    _args[_key] = arguments[_key];
  }

  _classPrivateFieldSet(this, _secureEventEmitter, _construct(SecureEventEmitter, [[EVENT_TYPE]].concat(_args)));
});

module.exports = {
  SingularEventEmitter: SingularEventEmitter
};