choerodon-ui/es/_util/EventManager.js

An enterprise-class UI design language and React-based implementation

import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
import _createClass from "@babel/runtime/helpers/createClass";
import { __decorate } from "tslib";
import { action } from 'mobx';

function on(eventName, fn, el, useCapture) {
  if (el) {
    if (el.addEventListener) {
      el.addEventListener(eventName, fn, useCapture);
    } else if (el.attachEvent) {
      el.attachEvent("on".concat(eventName), fn);
    }
  }
}

function off(eventName, fn, el, useCapture) {
  if (el) {
    if (el.removeEventListener) {
      el.removeEventListener(eventName, fn, useCapture);
    } else if (el.attachEvent) {
      el.detachEvent("on".concat(eventName), fn);
    }
  }
}

var EventManager =
/*#__PURE__*/
function () {
  function EventManager(el) {
    _classCallCheck(this, EventManager);

    this.events = {};
    this.el = el;
  }

  _createClass(EventManager, [{
    key: "addEventListener",
    value: function addEventListener(eventName, fn) {
      var useCapture = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
      eventName = eventName.toLowerCase();
      var events = this.events[eventName] || [];
      var index = events.findIndex(function (_ref) {
        var _ref2 = _slicedToArray(_ref, 1),
            event = _ref2[0];

        return event === fn;
      });

      if (index === -1) {
        events.push([fn, useCapture]);
        this.events[eventName] = events;
        on(eventName, fn, this.el, useCapture);
      }

      return this;
    }
  }, {
    key: "removeEventListener",
    value: function removeEventListener(eventName, fn) {
      var _this = this;

      var useCapture = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
      eventName = eventName.toLowerCase();
      var events = this.events[eventName];

      if (events) {
        if (fn) {
          var index = events.findIndex(function (_ref3) {
            var _ref4 = _slicedToArray(_ref3, 1),
                event = _ref4[0];

            return event === fn;
          });

          if (index !== -1) {
            events.splice(index, 1);
          }

          off(eventName, fn, this.el, useCapture);
        } else {
          this.events[eventName] = this.el ? (this.events[eventName] || []).filter(function (_ref5) {
            var _ref6 = _slicedToArray(_ref5, 2),
                event = _ref6[0],
                capture = _ref6[1];

            off(eventName, event, _this.el, capture);
            return false;
          }) : [];
        }
      }

      return this;
    }
  }, {
    key: "fireEventSync",
    value: function fireEventSync(eventName) {
      for (var _len = arguments.length, rest = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
        rest[_key - 1] = arguments[_key];
      }

      var events = this.events[eventName.toLowerCase()];
      return events ? events.every(function (_ref7) {
        var _ref8 = _slicedToArray(_ref7, 1),
            fn = _ref8[0];

        return fn.apply(void 0, rest) !== false;
      }) : true;
    }
  }, {
    key: "fireEvent",
    value: function fireEvent(eventName) {
      for (var _len2 = arguments.length, rest = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
        rest[_key2 - 1] = arguments[_key2];
      }

      var events = this.events[eventName.toLowerCase()];
      return events ? Promise.all(events.map(function (_ref9) {
        var _ref10 = _slicedToArray(_ref9, 1),
            fn = _ref10[0];

        return fn.apply(void 0, rest);
      })).then(function (all) {
        return all.every(function (result) {
          return result !== false;
        });
      }) : Promise.resolve(true);
    }
  }, {
    key: "clear",
    value: function clear() {
      var _this2 = this;

      if (this.el) {
        Object.keys(this.events).forEach(function (eventName) {
          return _this2.removeEventListener(eventName);
        });
      }

      this.events = {};
      return this;
    }
  }]);

  return EventManager;
}();

export { EventManager as default };

__decorate([action], EventManager.prototype, "fireEventSync", null);

__decorate([action], EventManager.prototype, "fireEvent", null);

export function preventDefault(e) {
  e.preventDefault();
}
export function stopPropagation(e) {
  e.stopPropagation();
}
export function stopEvent(e) {
  preventDefault(e);
  stopPropagation(e);
}
//# sourceMappingURL=EventManager.js.map