function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
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, _toPropertyKey(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 _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
/**
 * 监听模块
 *
 */
var Watch = /*#__PURE__*/function () {
  function Watch() {
    _classCallCheck(this, Watch);
    // 监听列表
    _defineProperty(this, "events", new Map());
    // 启用列表 - 使用数组保持顺序
    _defineProperty(this, "enableListMap", new Map());
  }
  _createClass(Watch, [{
    key: "subscribe",
    value:
    /**
     * 订阅事件
     * @param event 事件名称
     * @param callback 回调函数
     * @returns 订阅对象，可用于取消订阅
     */
    function subscribe(watchKey, event) {
      var _this = this;
      // 如果监听列表不存在，则创建
      if (!this.events.has(watchKey)) {
        this.events.set(watchKey, new Map());
      }

      // 获取监听列表
      var callbacks = this.events.get(watchKey);
      // 设置事件
      callbacks.set(event.key, event.callback);

      // 启用事件
      this.enableEvent(watchKey, event.key);
      return {
        // 取消订阅
        unsubscribe: function unsubscribe() {
          // 取消订阅事件
          _this.unsubscribe(watchKey, event);
        }
      };
    }

    /**
     * 启用事件
     * @param watchKey 监听的key
     * @param event 事件名称
     */
  }, {
    key: "enableEvent",
    value: function enableEvent(watchKey, eventKey) {
      // 获取启用列表
      var enableList = this.enableListMap.get(watchKey);
      // 如果启用列表存在，则添加事件
      if (enableList) {
        if (enableList.includes(eventKey)) {
          return;
        }
        enableList.push(eventKey);
      } else {
        // 如果启用列表不存在，则创建启用列表
        this.enableListMap.set(watchKey, [eventKey]);
      }
    }

    /**
     * 禁用某个事件
     * @param watchKey 监听的key
     * @param eventKey 事件名称
     */
  }, {
    key: "disableEvent",
    value: function disableEvent(watchKey, eventKey) {
      // 获取启用列表
      var enableList = this.enableListMap.get(watchKey);
      if (enableList) {
        // 找到当前事件的索引
        var index = enableList.indexOf(eventKey);
        if (index !== -1) {
          // 删除当前事件以及之后的所有事件
          enableList.splice(index);
        }
      }
    }

    /**
     * 冻结某个监听下的所有事件
     * @param watchKey 监听的key
     */
  }, {
    key: "disabledAllEventByWatchKey",
    value: function disabledAllEventByWatchKey(watchKey) {
      // 设置启用列表为空
      this.enableListMap.set(watchKey, []);
    }

    /**
     * 启用某个监听下的所有事件
     * @param watchKey 监听的key
     */
  }, {
    key: "enableAllEventByWatchKey",
    value: function enableAllEventByWatchKey(watchKey) {
      var _this$events$get;
      // 遍历当前监听下的所有事件， 并启用
      this.enableListMap.set(watchKey, Array.from(((_this$events$get = this.events.get(watchKey)) === null || _this$events$get === void 0 ? void 0 : _this$events$get.keys()) || []));
    }

    /**
     * 取消订阅事件
     * @param event 事件名称
     * @param callback 回调函数
     * @returns 是否成功取消订阅
     */
  }, {
    key: "unsubscribe",
    value: function unsubscribe(watchKey, event) {
      // 获取监听列表
      var callbacks = this.events.get(watchKey);
      // 如果监听列表不存在，则返回false
      if (!callbacks) {
        return;
      }
      // 禁用事件
      this.disableEvent(watchKey, event.key);
      // 删除事件
      callbacks.delete(event.key);
      return;
    }

    /**
     * 发布事件
     * @param event 事件名称
     * @param args 事件参数
     */
  }, {
    key: "publish",
    value: function publish(watchKey) {
      // 获取监听列表
      var callbacks = this.events.get(watchKey);
      // 如果监听列表不存在，则返回
      if (!callbacks) {
        return;
      }

      // 获取启用列表
      var enableList = this.enableListMap.get(watchKey);
      // 如果启用列表不存在，则返回
      if (!enableList || enableList.length === 0) {
        return;
      }

      // 只执行最后一个事件
      var lastCallbackKey = enableList.at(-1);
      // 如果最后一个事件存在，则执行
      if (lastCallbackKey) {
        try {
          var _callbacks$get;
          for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
            args[_key - 1] = arguments[_key];
          }
          (_callbacks$get = callbacks.get(lastCallbackKey)) === null || _callbacks$get === void 0 || _callbacks$get.apply(void 0, args);
        } catch (error) {
          console.error("\u6267\u884C\u4E8B\u4EF6\"".concat(watchKey, "\"\u7684\u56DE\u8C03\u65F6\u51FA\u9519:"), error);
        }
      }
    }

    /**
     * 根据事件名称发布事件
     * @param watchKey 监听的key
     * @param eventKey 事件名称
     * @param args 事件参数
     */
  }, {
    key: "publishByEventKey",
    value: function publishByEventKey(watchKey, eventKey) {
      var _callbacks$get2;
      var callbacks = this.events.get(watchKey);
      if (!callbacks) {
        return;
      }
      for (var _len2 = arguments.length, args = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
        args[_key2 - 2] = arguments[_key2];
      }
      (_callbacks$get2 = callbacks.get(eventKey)) === null || _callbacks$get2 === void 0 || _callbacks$get2.apply(void 0, args);
    }

    /**
     * 获取最后一个启用的事件
     * @param watchKey 监听的key
     * @returns 最后一个启用的事件
     */
  }, {
    key: "getLastEnableEventKey",
    value: function getLastEnableEventKey(watchKey) {
      var enableList = this.enableListMap.get(watchKey);
      console.log('enableList', enableList);
      if (!enableList) {
        return undefined;
      }
      return enableList.at(-1) || undefined;
    }

    /**
     * 移除某个事件的所有订阅
     * @param event 事件名称
     * @returns 是否成功移除
     */
  }, {
    key: "clearEvent",
    value: function clearEvent(watchKey) {
      // 禁用所有事件
      this.disabledAllEventByWatchKey(watchKey);
      // 删除监听列表
      this.events.delete(watchKey);
    }

    /**
     * 移除所有事件订阅
     */
  }, {
    key: "clearAllEvents",
    value: function clearAllEvents() {
      // 清空监听列表
      this.events.clear();
      // 清空启用列表
      this.enableListMap.clear();
    }

    /**
     * 获取事件的订阅数量
     * @param event 事件名称
     * @returns 订阅数量
     */
  }, {
    key: "getSubscriberCount",
    value: function getSubscriberCount(event) {
      // 获取监听列表
      var callbacks = this.events.get(event);
      // 如果监听列表不存在，则返回0
      return callbacks ? callbacks.size : 0;
    }

    /**
     * 检查事件是否有订阅者
     * @param event 事件名称
     * @returns 是否有订阅者
     */
  }, {
    key: "hasSubscribers",
    value: function hasSubscribers(event) {
      // 获取监听列表
      return this.getSubscriberCount(event) > 0;
    }

    /**
     * 一次性订阅事件，事件触发后自动取消订阅
     * @param event 事件名称
     * @param callback 回调函数
     * @returns 订阅对象，可用于取消订阅
     */
  }, {
    key: "once",
    value: function once(watchKey, event) {
      var _this2 = this;
      // 包装回调函数
      var wrappedCallback = function wrappedCallback() {
        // 取消订阅
        _this2.unsubscribe(watchKey, {
          key: event.key,
          callback: wrappedCallback
        });
        // 执行回调
        event.callback.apply(event, arguments);
      };
      return this.subscribe(watchKey, {
        key: event.key,
        callback: wrappedCallback
      });
    }
  }]);
  return Watch;
}(); // 创建单例实例
var watch = new Watch();
export default watch;