awv3/core/events.js

⚡ AWV3 embedded CAD

var Events =
/*#__PURE__*/
function () {
  function Events() {
    this._callbacks = undefined;
    this._inspectors = undefined;
  }

  var _proto = Events.prototype;

  _proto.subscribe = function subscribe(arg1, arg2, options) {
    return this.on(arg1, arg2, options).removeListener.bind(this, arg1, arg2);
  };

  _proto.once = function once(type, callback) {
    this.on(type, callback, {
      remove: true
    });
  };

  _proto.onFirst = function onFirst(type, callback) {
    this.on(type, callback, {
      priority: 1
    });
  };

  _proto.onLast = function onLast(type, callback) {
    this.on(type, callback, {
      priority: -1
    });
  };

  _proto.on = function on(arg1, arg2, options) {
    if (arg1 === void 0) {
      arg1 = {};
    }

    if (arg2 === void 0) {
      arg2 = undefined;
    }

    if (options === void 0) {
      options = {};
    }

    if (Array.isArray(arg1)) {
      // (Array of types) & callback
      for (var _iterator = arg1, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
        var _ref;

        if (_isArray) {
          if (_i >= _iterator.length) break;
          _ref = _iterator[_i++];
        } else {
          _i = _iterator.next();
          if (_i.done) break;
          _ref = _i.value;
        }

        var _type = _ref;
        this.on(_type, arg2, options);
      }
    } else if (typeof arg1 === 'object') {
      // Object with 'Type: Callback' pairs
      if (typeof arg2 === 'object') options = arg2;

      var _arr = Object.entries(arg1);

      for (var _i2 = 0; _i2 < _arr.length; _i2++) {
        var _ref2 = _arr[_i2];
        var key = _ref2[0];
        var callback = _ref2[1];
        if (typeof callback === 'function') this.on(key, callback, options);
      }
    } else if (typeof arg1 === 'string' && typeof arg2 === 'function') {
      // Type & Callback
      var _type2 = arg1,
          _callback = arg2;
      var _options = options,
          _options$remove = _options.remove,
          remove = _options$remove === void 0 ? false : _options$remove,
          _options$priority = _options.priority,
          priority = _options$priority === void 0 ? 0 : _options$priority,
          _options$sync = _options.sync,
          sync = _options$sync === void 0 ? false : _options$sync;
      if (!this._callbacks) this._callbacks = {};
      var listeners = this._callbacks[_type2];
      if (!listeners) listeners = this._callbacks[_type2] = []; // note: do not add duplicate callbacks

      if (listeners.indexOf(_callback) < 0) {
        _callback.remove = remove;
        _callback.sync = sync;
        _callback.priority = priority;
        listeners.push(_callback);
        listeners.sort(function (a, b) {
          return b.priority - a.priority;
        });

        if (this._inspectors) {
          for (var _iterator2 = this._inspectors, _isArray2 = Array.isArray(_iterator2), _i3 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
            var _ref3;

            if (_isArray2) {
              if (_i3 >= _iterator2.length) break;
              _ref3 = _iterator2[_i3++];
            } else {
              _i3 = _iterator2.next();
              if (_i3.done) break;
              _ref3 = _i3.value;
            }

            var _inspector = _ref3;

            _inspector({
              action: 'Add',
              type: _type2,
              callback: _callback
            });
          }
        }
      }
    }

    return this;
  };

  _proto.inspect = function inspect(callback) {
    if (!this._inspectors) this._inspectors = [];

    this._inspectors.push(callback);
  };

  _proto.removeListener = function removeListener(types, callback) {
    if (!Array.isArray(types) && typeof types === 'object' && callback === undefined) {
      // Object of 'Type: Callback'
      var _arr2 = Object.entries(types);

      for (var _i4 = 0; _i4 < _arr2.length; _i4++) {
        var _ref4 = _arr2[_i4];
        var type = _ref4[0];
        var _callback2 = _ref4[1];
        this.removeListener(type, _callback2);
      }

      return this;
    }

    if (!this._callbacks) this._callbacks = {};
    types = Array.isArray(types) ? types : [types];

    for (var _iterator3 = types, _isArray3 = Array.isArray(_iterator3), _i5 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
      var _ref5;

      if (_isArray3) {
        if (_i5 >= _iterator3.length) break;
        _ref5 = _iterator3[_i5++];
      } else {
        _i5 = _iterator3.next();
        if (_i5.done) break;
        _ref5 = _i5.value;
      }

      var _type4 = _ref5;
      var listeners = this._callbacks[_type4];
      if (!listeners) continue;

      if (!callback) {
        delete this._callbacks[_type4];

        if (this._inspectors) {
          for (var _iterator4 = this._inspectors, _isArray4 = Array.isArray(_iterator4), _i6 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) {
            var _ref6;

            if (_isArray4) {
              if (_i6 >= _iterator4.length) break;
              _ref6 = _iterator4[_i6++];
            } else {
              _i6 = _iterator4.next();
              if (_i6.done) break;
              _ref6 = _i6.value;
            }

            var _inspector2 = _ref6;

            _inspector2({
              action: 'Remove',
              type: _type4,
              callback: undefined
            });
          }
        }
      } else {
        var index = listeners.indexOf(callback);
        index > -1 && listeners.splice(index, 1);

        if (this._inspectors) {
          for (var _iterator5 = this._inspectors, _isArray5 = Array.isArray(_iterator5), _i7 = 0, _iterator5 = _isArray5 ? _iterator5 : _iterator5[Symbol.iterator]();;) {
            var _ref7;

            if (_isArray5) {
              if (_i7 >= _iterator5.length) break;
              _ref7 = _iterator5[_i7++];
            } else {
              _i7 = _iterator5.next();
              if (_i7.done) break;
              _ref7 = _i7.value;
            }

            var _inspector4 = _ref7;

            _inspector4({
              action: 'Remove',
              type: _type4,
              callback: callback
            });
          }
        }
      }
    }

    return this;
  };

  _proto.removeListeners = function removeListeners() {
    this._callbacks = undefined;
  };

  _proto.removeInspectors = function removeInspectors() {
    this._inspectors = undefined;
  };

  _proto.emit = function emit(type) {
    var _this = this;

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

    if (!this._callbacks) this._callbacks = {};
    var listeners = this._callbacks[type]; //clone listeners array to ensure safe callbacks removal

    listeners = listeners ? listeners.concat() : []; //call all synchronous events first;

    for (var _iterator6 = listeners, _isArray6 = Array.isArray(_iterator6), _i8 = 0, _iterator6 = _isArray6 ? _iterator6 : _iterator6[Symbol.iterator]();;) {
      var _ref8;

      if (_isArray6) {
        if (_i8 >= _iterator6.length) break;
        _ref8 = _iterator6[_i8++];
      } else {
        _i8 = _iterator6.next();
        if (_i8.done) break;
        _ref8 = _i8.value;
      }

      var _listener2 = _ref8;

      if (_listener2.sync) {
        if (_listener2.remove) this.removeListener(type, _listener2);

        _listener2.call.apply(_listener2, [this].concat(args));
      }
    } //call all asynchronous events in promise chain


    var sequence = Promise.resolve();

    var _loop = function _loop(_listener) {
      if (!_listener.sync) {
        sequence = sequence.then(function () {
          if (_listener.remove) _this.removeListener(type, _listener);
          return _listener.call.apply(_listener, [_this].concat(args));
        });
      }
    };

    for (var _iterator7 = listeners, _isArray7 = Array.isArray(_iterator7), _i9 = 0, _iterator7 = _isArray7 ? _iterator7 : _iterator7[Symbol.iterator]();;) {
      var _ref9;

      if (_isArray7) {
        if (_i9 >= _iterator7.length) break;
        _ref9 = _iterator7[_i9++];
      } else {
        _i9 = _iterator7.next();
        if (_i9.done) break;
        _ref9 = _i9.value;
      }

      var _listener = _ref9;

      _loop(_listener);
    }

    return sequence;
  }; //TODO: does it work properly?
  //what about case when listeners = []


  _proto.bubble = function bubble(type) {
    if (!this._callbacks) this._callbacks = {};
    var listeners = this._callbacks[type];

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

    if (listeners) {
      return this.emit.apply(this, [type].concat(args));
    } else if (this.parent) {
      var _parent;

      // No listener found, just bubble up ...
      return (_parent = this.parent).bubble.apply(_parent, [type].concat(args));
    }

    return Promise.resolve();
  };

  _proto.findListener = function findListener(type) {
    if (!this._callbacks) this._callbacks = {};
    var listeners = this._callbacks[type];

    if (listeners) {
      return this;
    } else if (this.parent) {
      // No listener found, just bubble up ...
      return this.parent.find(type);
    }

    return undefined;
  };

  _proto.hasListener = function hasListener(type, callback) {
    if (callback === void 0) {
      callback = undefined;
    }

    if (!this._callbacks) this._callbacks = {};
    var listener = this._callbacks[type];
    return !!listener && (!callback || callback === listener);
  };

  Events.mixin = function mixin(object, handlers) {
    if (handlers === void 0) {
      handlers = null;
    }

    object.hasListener = Events.prototype.hasListener;
    object.subscribe = Events.prototype.subscribe;
    object.on = Events.prototype.on;
    object.once = Events.prototype.once;
    object.onFirst = Events.prototype.onFirst;
    object.onLast = Events.prototype.onLast;
    object.inspect = Events.prototype.inspect;
    object.removeListener = Events.prototype.removeListener;
    object.removeListeners = Events.prototype.removeListeners;
    object.removeInspectors = Events.prototype.removeInspectors;
    object.emit = Events.prototype.emit;
    object.bubble = Events.prototype.bubble;
    object.findListener = Events.prototype.findListener;
    if (handlers) object.on.bind(object)(handlers);
  };

  return Events;
}();

export { Events as default };