@nimbus2d/core 0.0.1

package/src/core/EventBus/EventBus.js

@@ -0,0 +1,797 @@
+// ============================================================================
+// Nimbus2D - EventBus 全局事件总线
+// ----------------------------------------------------------------------------
+// 职责：
+//   1. 重量级设计：on/off/once/emit/emitAsync
+//   2. 命名空间 + 优先级（数字越大越先调用）
+//   3. wildcard 通配符订阅（'scene:*'、'*'）
+//   4. 可阻止型拦截器（返回 false 阻止传播）
+//   5. 中间件链（Express风格，支持过滤/变换/缓冲）
+//   6. 全局错误处理 + 性能统计
+//   7. 事件传播顺序：拦截器 → 中间件链 → 精确匹配监听器（按优先级降序）→ 通配符监听器
+//
+// 继承关系：
+//   EventEmitter → EventBus（基础设施，不被 Lifecycle 调度）
+// ============================================================================
+
+import { EventEmitter } from '../../base/EventEmitter.js'
+import { PerformanceStats } from './PerformanceStats.js'
+
+class EventBus extends EventEmitter {
+  /**
+   * 构造函数
+   */
+  constructor() {
+    super()
+
+    /**
+     * 精确匹配监听器映射
+     * @type {Map<string, Array<{fn: Function, priority: number, once: boolean}>>}
+     */
+    this._exactListeners = new Map()
+
+    /**
+     * 通配符监听器列表
+     * @type {Array<{pattern: string, fn: Function, priority: number, once: boolean}>}
+     */
+    this._wildcardListeners = []
+
+    /**
+     * 事件类型拦截器映射
+     * @type {Map<string, Array<Function>>}
+     */
+    this._interceptors = new Map()
+
+    /**
+     * 全局拦截器列表
+     * @type {Array<Function>}
+     */
+    this._globalInterceptors = []
+
+    /** @type {PerformanceStats} 性能统计 */
+    this._stats = new PerformanceStats()
+
+    /**
+     * 中间件列表（按注册顺序执行）
+     * 中间件签名：(eventType, data, next) => void
+     * data 为信封格式 { payload: any }，中间件可修改 payload
+     * 不调 next() 阻止事件传播
+     * @type {Array<Function>}
+     */
+    this._middlewares = []
+
+    /** @type {boolean} 是否已初始化 */
+    this._isInitialized = false
+
+    /**
+     * 递归保护标志：正在分发 error 事件时为 true
+     * 防止 error 监听器自身抛错导致无限递归
+     * @type {boolean}
+     * @private
+     */
+    this._isEmittingError = false
+  }
+
+  // --------------------------------------------------------------------------
+  // 监听器管理（重写 EventEmitter 方法）
+  // --------------------------------------------------------------------------
+
+  /**
+   * 注册监听器
+   * 支持精确匹配（'scene:start'）和通配符（'scene:*'、'*'）
+   * @param {string} eventType - 事件类型
+   * @param {Function} listener - 监听器函数
+   * @param {Object} [options={}] - 选项
+   * @param {number} [options.priority=0] - 优先级（数字越大越先调用）
+   * @returns {Function} 取消注册函数
+   */
+  on(eventType, listener, options = {}) {
+    if (this._destroyed) return () => {}
+    if (typeof listener !== 'function') {
+      console.warn(`[EventBus] on() 监听器必须是函数: ${eventType}`)
+      return () => {}
+    }
+
+    const priority = options.priority ?? 0
+    const isWildcard = eventType.includes('*')
+
+    if (isWildcard) {
+      // 通配符监听器
+      const entry = { pattern: eventType, fn: listener, priority, once: false }
+      this._wildcardListeners.push(entry)
+      this._sortWildcardListeners()
+      return () => this._removeWildcardListener(entry)
+    }
+
+    // 精确匹配监听器
+    if (!this._exactListeners.has(eventType)) {
+      this._exactListeners.set(eventType, [])
+    }
+    const list = this._exactListeners.get(eventType)
+    const entry = { fn: listener, priority, once: false }
+    list.push(entry)
+    this._sortListeners(list)
+    this._stats.setListenersCount(this._countAllListeners())
+
+    return () => this.off(eventType, listener)
+  }
+
+  /**
+   * 注册一次性监听器
+   * @param {string} eventType - 事件类型
+   * @param {Function} listener - 监听器函数
+   * @param {Object} [options={}] - 选项
+   * @returns {Function} 取消注册函数
+   */
+  once(eventType, listener, options = {}) {
+    if (this._destroyed) return () => {}
+    if (typeof listener !== 'function') {
+      console.warn(`[EventBus] once() 监听器必须是函数: ${eventType}`)
+      return () => {}
+    }
+
+    const priority = options.priority ?? 0
+    const isWildcard = eventType.includes('*')
+
+    if (isWildcard) {
+      const entry = { pattern: eventType, fn: listener, priority, once: true }
+      this._wildcardListeners.push(entry)
+      this._sortWildcardListeners()
+      return () => this._removeWildcardListener(entry)
+    }
+
+    if (!this._exactListeners.has(eventType)) {
+      this._exactListeners.set(eventType, [])
+    }
+    const list = this._exactListeners.get(eventType)
+    const entry = { fn: listener, priority, once: true }
+    list.push(entry)
+    this._sortListeners(list)
+    this._stats.setListenersCount(this._countAllListeners())
+
+    return () => this.off(eventType, listener)
+  }
+
+  /**
+   * 注销监听器
+   * @param {string} eventType - 事件类型
+   * @param {Function} listener - 监听器函数
+   * @returns {boolean} 是否注销成功
+   */
+  off(eventType, listener) {
+    if (this._destroyed) return false
+
+    // 尝试从精确匹配中移除
+    const list = this._exactListeners.get(eventType)
+    if (list) {
+      const index = list.findIndex((entry) => entry.fn === listener)
+      if (index !== -1) {
+        list.splice(index, 1)
+        if (list.length === 0) {
+          this._exactListeners.delete(eventType)
+        }
+        this._stats.setListenersCount(this._countAllListeners())
+        return true
+      }
+    }
+
+    // 尝试从通配符中移除
+    const wcIndex = this._wildcardListeners.findIndex((entry) => entry.fn === listener)
+    if (wcIndex !== -1) {
+      this._wildcardListeners.splice(wcIndex, 1)
+      this._stats.setListenersCount(this._countAllListeners())
+      return true
+    }
+
+    return false
+  }
+
+  /**
+   * 触发事件
+   * 执行流程：
+   *   1. 检查全局拦截器（返回 false 阻止传播）
+   *   2. 检查事件类型拦截器（返回 false 阻止传播）
+   *   3. 执行中间件链（按注册顺序，不调 next() 阻止传播）
+   *   4. 调用精确匹配监听器（按优先级降序）
+   *   5. 调用通配符监听器（scene:* 和 *）
+   * @param {string} eventType - 事件类型
+   * @param {...*} args - 参数
+   * @returns {boolean} true 表示未被拦截器/中间件阻止，false 表示被阻止
+   */
+  emit(eventType, ...args) {
+    if (this._destroyed) return false
+
+    const startTime = performance.now()
+
+    // 1. 检查全局拦截器
+    for (const interceptor of this._globalInterceptors) {
+      try {
+        if (interceptor(eventType, ...args) === false) {
+          this._stats.recordBlock()
+          return false
+        }
+      } catch (e) {
+        console.error(`[EventBus] 全局拦截器执行出错:`, e)
+      }
+    }
+
+    // 2. 检查事件类型拦截器
+    const typeInterceptors = this._interceptors.get(eventType)
+    if (typeInterceptors) {
+      for (const interceptor of typeInterceptors) {
+        try {
+          if (interceptor(...args) === false) {
+            this._stats.recordBlock()
+            return false
+          }
+        } catch (e) {
+          console.error(`[EventBus] 拦截器执行出错 (${eventType}):`, e)
+        }
+      }
+    }
+
+    // 3. 中间件链（三期新增）
+    if (this._middlewares.length > 0) {
+      // 构建信封：始终以数组形式存储参数，确保多参数事件正确分发
+      // 中间件可修改 data.payload 数组中的元素（如 data.payload[0] = newValue）
+      const data = { payload: args }
+      let chainIndex = 0
+      let chainCompleted = false
+      let chainResult = true
+
+      const chainNext = () => {
+        if (chainIndex < this._middlewares.length) {
+          const mw = this._middlewares[chainIndex++]
+          try {
+            mw(eventType, data, chainNext)
+          } catch (e) {
+            // 中间件异常：广播 error 事件，标记链终止（异常终止，非主动阻止）
+            this._emitError({ error: e, source: 'middleware' })
+            chainCompleted = true
+            chainResult = false
+            return
+          }
+        } else {
+          // 中间件链执行完毕，分发到监听器（展开 payload 数组保持与无中间件路径一致）
+          chainCompleted = true
+          chainResult = this._dispatchToListeners(eventType, ...data.payload)
+        }
+      }
+      chainNext()
+
+      // 如果中间件链未完成（某中间件未调 next），返回 false 表示事件被阻止
+      if (!chainCompleted) {
+        this._stats.recordBlock()
+        chainResult = false
+      }
+
+      // 更新性能统计
+      const elapsed = performance.now() - startTime
+      this._stats.recordEmit(elapsed)
+
+      return chainResult
+    }
+
+    // 4-5. 无中间件时直接分发（保持原有性能）
+    const result = this._dispatchToListeners(eventType, ...args)
+
+    // 更新性能统计
+    const elapsed = performance.now() - startTime
+    this._stats.recordEmit(elapsed)
+
+    return result
+  }
+
+  /**
+   * 异步触发事件（等待所有异步监听器完成）
+   * 与 emit() 不同的是：拦截器和中间件中的异步操作会被 await，
+   * 且所有异步监听器的 Promise 会被等待完成
+   * @param {string} eventType - 事件类型
+   * @param {...*} args - 参数
+   * @returns {Promise<boolean>} true 表示未被拦截器/中间件阻止
+   */
+  async emitAsync(eventType, ...args) {
+    if (this._destroyed) return false
+
+    const startTime = performance.now()
+
+    // 1. 检查全局拦截器（异步等待）
+    for (const interceptor of this._globalInterceptors) {
+      try {
+        const result = await interceptor(eventType, ...args)
+        if (result === false) {
+          this._stats.recordBlock()
+          return false
+        }
+      } catch (e) {
+        console.error(`[EventBus] 全局拦截器执行出错:`, e)
+      }
+    }
+
+    // 2. 检查事件类型拦截器（异步等待）
+    const typeInterceptors = this._interceptors.get(eventType)
+    if (typeInterceptors) {
+      for (const interceptor of typeInterceptors) {
+        try {
+          const result = await interceptor(...args)
+          if (result === false) {
+            this._stats.recordBlock()
+            return false
+          }
+        } catch (e) {
+          console.error(`[EventBus] 拦截器执行出错 (${eventType}):`, e)
+        }
+      }
+    }
+
+    // 3. 中间件链（与 emit() 一致，确保中间件在异步路径也生效）
+    if (this._middlewares.length > 0) {
+      /** @type {{ payload: any[] }} 信封对象，payload 始终为参数数组 */
+      const data = { payload: args }
+      let chainIndex = 0
+      let chainCompleted = false
+      let chainResult = true
+
+      const chainNext = () => {
+        if (chainIndex < this._middlewares.length) {
+          const mw = this._middlewares[chainIndex++]
+          try {
+            mw(eventType, data, chainNext)
+          } catch (e) {
+            this._emitError({ error: e, source: 'middleware' })
+            chainCompleted = true
+            chainResult = false
+            return
+          }
+        } else {
+          chainCompleted = true
+          // 中间件链完成，分发到监听器
+          chainResult = this._dispatchToListenersAsync(eventType, data.payload)
+        }
+      }
+      chainNext()
+
+      // 中间件链未完成（某中间件未调 next()）
+      if (!chainCompleted) {
+        this._stats.recordBlock()
+        const elapsed = performance.now() - startTime
+        this._stats.recordEmit(elapsed)
+        return false
+      }
+
+      // 等待所有异步监听器完成
+      if (chainResult && chainResult._promises) {
+        await Promise.all(chainResult._promises)
+      }
+
+      const elapsed = performance.now() - startTime
+      this._stats.recordEmit(elapsed)
+      return chainResult !== false
+    }
+
+    // 4-5. 无中间件时直接异步分发
+    const result = this._dispatchToListenersAsync(eventType, args)
+
+    // 等待所有异步监听器完成
+    if (result && result._promises) {
+      await Promise.all(result._promises)
+    }
+
+    const elapsed = performance.now() - startTime
+    this._stats.recordEmit(elapsed)
+    return true
+  }
+
+  // --------------------------------------------------------------------------
+  // 拦截器
+  // --------------------------------------------------------------------------
+
+  /**
+   * 注册事件类型拦截器
+   * @param {string} eventType - 事件类型
+   * @param {Function} interceptor - 拦截器 (...args) => boolean（false 阻止传播）
+   * @returns {Function} 取消注册函数
+   */
+  useInterceptor(eventType, interceptor) {
+    if (this._destroyed) return () => {}
+
+    if (!this._interceptors.has(eventType)) {
+      this._interceptors.set(eventType, [])
+    }
+    this._interceptors.get(eventType).push(interceptor)
+    this._stats.setInterceptorsCount(this._countAllInterceptors())
+
+    return () => {
+      const list = this._interceptors.get(eventType)
+      if (list) {
+        const idx = list.indexOf(interceptor)
+        if (idx !== -1) list.splice(idx, 1)
+        if (list.length === 0) this._interceptors.delete(eventType)
+        this._stats.setInterceptorsCount(this._countAllInterceptors())
+      }
+    }
+  }
+
+  /**
+   * 注册全局拦截器（对所有事件生效）
+   * @param {Function} interceptor - 拦截器 (eventType, ...args) => boolean
+   * @returns {Function} 取消注册函数
+   */
+  useGlobalInterceptor(interceptor) {
+    if (this._destroyed) return () => {}
+
+    this._globalInterceptors.push(interceptor)
+    this._stats.setInterceptorsCount(this._countAllInterceptors())
+
+    return () => {
+      const idx = this._globalInterceptors.indexOf(interceptor)
+      if (idx !== -1) this._globalInterceptors.splice(idx, 1)
+      this._stats.setInterceptorsCount(this._countAllInterceptors())
+    }
+  }
+
+  // --------------------------------------------------------------------------
+  // 中间件（三期新增）
+  // --------------------------------------------------------------------------
+
+  /**
+   * 注册中间件
+   * 中间件在拦截器之后、监听器分发之前执行。
+   * Express 风格签名：(eventType, data, next) => void
+   *   - eventType: 事件类型（字符串）
+   *   - data: 数据信封 { payload: any[] }，payload 始终为参数数组，
+   *     中间件可修改数组元素（如 data.payload[0] = newValue）
+   *   - next: 下一步回调 () => void，不调 next() 阻止事件传播
+   *
+   * @param {Function} middleware - 中间件函数 (eventType: string, data: { payload: any[] }, next: () => void) => void
+   * @returns {Function} 取消注册函数
+   */
+  use(middleware) {
+    if (this._destroyed) return () => {}
+
+    if (typeof middleware !== 'function') {
+      console.warn('[EventBus] use() 中间件必须是函数')
+      return () => {}
+    }
+
+    this._middlewares.push(middleware)
+
+    return () => this.disuse(middleware)
+  }
+
+  /**
+   * 移除中间件
+   * @param {Function} middleware - 中间件函数
+   * @returns {boolean} 是否移除成功
+   */
+  disuse(middleware) {
+    const index = this._middlewares.indexOf(middleware)
+    if (index >= 0) {
+      this._middlewares.splice(index, 1)
+      return true
+    }
+    return false
+  }
+
+  // --------------------------------------------------------------------------
+  // 性能统计
+  // --------------------------------------------------------------------------
+
+  /**
+   * 获取性能统计
+   * @returns {Object} 统计数据快照
+   */
+  getStats() {
+    return this._stats.getStats()
+  }
+
+  /**
+   * 重置性能统计
+   */
+  resetStats() {
+    this._stats.reset()
+  }
+
+  // --------------------------------------------------------------------------
+  // 生命周期方法（基础设施，不继承 Subsystem）
+  // --------------------------------------------------------------------------
+
+  /**
+   * 初始化（空实现，基础设施无特殊初始化）
+   * @returns {Promise<void>}
+   */
+  async initialize() {
+    this._isInitialized = true
+  }
+
+  /**
+   * 销毁事件总线，清理所有监听器、拦截器、性能统计
+   * @returns {Promise<void>}
+   */
+  async destroy() {
+    if (this._destroyed) return
+
+    // 先 emit destroyed 事件（super.destroy() 后监听器被清理，emit 无效）
+    this.emit('destroyed')
+
+    this._exactListeners.clear()
+    this._wildcardListeners = []
+    this._interceptors.clear()
+    this._globalInterceptors = []
+    this._middlewares = []
+    this._stats.reset()
+
+    // 调用 EventEmitter 基类的 destroy（清理监听器 + 设置 _destroyed = true）
+    super.destroy()
+  }
+
+  // --------------------------------------------------------------------------
+  // 内部方法
+  // --------------------------------------------------------------------------
+
+  /**
+   * 安全分发 error 事件（内部方法）
+   * 直接分发给 _exactListeners 和 _wildcardListeners，不走中间件和拦截器，
+   * 避免中间件再次抛错导致无限递归。
+   * 使用 _isEmittingError 递归保护标志，防止 error 监听器自身抛错导致无限递归。
+   *
+   * @param {Object} payload - 错误数据 { error: Error, source: string }
+   * @private
+   */
+  _emitError(payload) {
+    // 递归保护：正在分发 error 时忽略后续 error，避免无限递归
+    if (this._isEmittingError) return
+    this._isEmittingError = true
+
+    try {
+      // 1. 分发给精确匹配的 'error' 监听器
+      const errorList = this._exactListeners.get('error')
+      if (errorList) {
+        for (const entry of errorList) {
+          try {
+            entry.fn(payload)
+          } catch {
+            // error 监听器自身异常忽略，避免递归
+          }
+        }
+      }
+
+      // 2. 分发给通配符监听器
+      for (const entry of this._wildcardListeners) {
+        if (this._matchWildcard(entry.pattern, 'error')) {
+          try {
+            entry.fn('error', payload)
+          } catch {
+            // error 监听器自身异常忽略，避免递归
+          }
+        }
+      }
+    } finally {
+      this._isEmittingError = false
+    }
+  }
+
+  /**
+   * 分发到监听器（内部方法）
+   * 按顺序调用精确匹配监听器和通配符监听器
+   * @param {string} eventType - 事件类型
+   * @param {...*} args - 参数
+   * @returns {boolean} true 表示正常分发完成
+   * @private
+   */
+  _dispatchToListeners(eventType, ...args) {
+    // 1. 调用精确匹配监听器（按优先级降序，已排序）
+    const exactList = this._exactListeners.get(eventType)
+    const onceToRemove = []
+
+    if (exactList) {
+      // 快照防止迭代中修改
+      const snapshot = exactList.slice()
+      for (const entry of snapshot) {
+        try {
+          entry.fn(...args)
+        } catch (e) {
+          // 自动广播全局 error 事件
+          this._emitError({ error: e, source: eventType })
+        }
+        if (entry.once) {
+          onceToRemove.push(entry)
+        }
+      }
+
+      // 移除 once 监听器
+      for (const entry of onceToRemove) {
+        const idx = exactList.indexOf(entry)
+        if (idx !== -1) exactList.splice(idx, 1)
+      }
+      if (exactList.length === 0) {
+        this._exactListeners.delete(eventType)
+      }
+    }
+
+    // 2. 调用通配符监听器
+    const wildcardOnceToRemove = []
+    for (const entry of this._wildcardListeners) {
+      if (this._matchWildcard(entry.pattern, eventType)) {
+        try {
+          // 通配符监听器第一个参数为事件类型
+          entry.fn(eventType, ...args)
+        } catch (e) {
+          this._emitError({ error: e, source: eventType })
+        }
+        if (entry.once) {
+          wildcardOnceToRemove.push(entry)
+        }
+      }
+    }
+
+    // 移除通配符 once 监听器
+    for (const entry of wildcardOnceToRemove) {
+      const idx = this._wildcardListeners.indexOf(entry)
+      if (idx !== -1) this._wildcardListeners.splice(idx, 1)
+    }
+
+    return true
+  }
+
+  /**
+   * 异步分发到监听器（内部方法，供 emitAsync 使用）
+   * 与 _dispatchToListeners 类似，但收集异步监听器的 Promise
+   * 返回结果对象包含 _promises 数组，由 emitAsync 等待
+   *
+   * @param {string} eventType - 事件类型
+   * @param {any[]} args - 参数数组
+   * @returns {{ _promises: Promise[] }} 包含异步 Promise 列表的结果对象
+   * @private
+   */
+  _dispatchToListenersAsync(eventType, args) {
+    /** @type {Promise[]} 异步监听器的 Promise 列表 */
+    const promises = []
+
+    // 1. 调用精确匹配监听器
+    const exactList = this._exactListeners.get(eventType)
+    const onceToRemove = []
+
+    if (exactList) {
+      const snapshot = exactList.slice()
+      for (const entry of snapshot) {
+        try {
+          const result = entry.fn(...args)
+          if (result instanceof Promise) {
+            promises.push(result.catch((e) => {
+              this._emitError({ error: e, source: eventType })
+            }))
+          }
+        } catch (e) {
+          this._emitError({ error: e, source: eventType })
+        }
+        if (entry.once) onceToRemove.push(entry)
+      }
+
+      // 移除 once 监听器
+      for (const entry of onceToRemove) {
+        const idx = exactList.indexOf(entry)
+        if (idx !== -1) exactList.splice(idx, 1)
+      }
+      if (exactList.length === 0) {
+        this._exactListeners.delete(eventType)
+      }
+    }
+
+    // 2. 调用通配符监听器
+    const wildcardOnceToRemove = []
+    for (const entry of this._wildcardListeners) {
+      if (this._matchWildcard(entry.pattern, eventType)) {
+        try {
+          const result = entry.fn(eventType, ...args)
+          if (result instanceof Promise) {
+            promises.push(result.catch((e) => {
+              this._emitError({ error: e, source: eventType })
+            }))
+          }
+        } catch (e) {
+          this._emitError({ error: e, source: eventType })
+        }
+        if (entry.once) wildcardOnceToRemove.push(entry)
+      }
+    }
+
+    // 移除通配符 once 监听器
+    for (const entry of wildcardOnceToRemove) {
+      const idx = this._wildcardListeners.indexOf(entry)
+      if (idx !== -1) this._wildcardListeners.splice(idx, 1)
+    }
+
+    return { _promises: promises }
+  }
+
+  /**
+   * 按优先级降序排序监听器列表
+   * @param {Array} list - 监听器列表
+   * @private
+   */
+  _sortListeners(list) {
+    list.sort((a, b) => b.priority - a.priority)
+  }
+
+  /**
+   * 按优先级降序排序通配符监听器
+   * @private
+   */
+  _sortWildcardListeners() {
+    this._wildcardListeners.sort((a, b) => b.priority - a.priority)
+  }
+
+  /**
+   * 匹配通配符模式
+   * 支持场景：
+   *   '*' → 匹配所有事件
+   *   'scene:*' → 匹配 'scene:' 前缀的所有事件
+   *   'scene:**' → 匹配 'scene.' 前缀的所有事件
+   * @param {string} pattern - 通配符模式
+   * @param {string} eventType - 事件类型
+   * @returns {boolean} 是否匹配
+   * @private
+   */
+  _matchWildcard(pattern, eventType) {
+    if (pattern === '*') return true
+
+    const colonIdx = pattern.indexOf(':')
+    if (colonIdx !== -1) {
+      // 'scene:*' 格式：匹配 'scene:' 前缀
+      const prefix = pattern.substring(0, colonIdx + 1)
+      return eventType.startsWith(prefix)
+    }
+
+    const dotIdx = pattern.indexOf('.**')
+    if (dotIdx !== -1) {
+      // 'modules.**' 格式：匹配 'modules.' 前缀
+      const prefix = pattern.substring(0, dotIdx + 1)
+      return eventType.startsWith(prefix)
+    }
+
+    // 其他情况不匹配
+    return false
+  }
+
+  /**
+   * 移除通配符监听器
+   * @param {Object} entry - 监听器条目
+   * @private
+   */
+  _removeWildcardListener(entry) {
+    const idx = this._wildcardListeners.indexOf(entry)
+    if (idx !== -1) {
+      this._wildcardListeners.splice(idx, 1)
+      this._stats.setListenersCount(this._countAllListeners())
+    }
+  }
+
+  /**
+   * 计算所有监听器总数
+   * @returns {number}
+   * @private
+   */
+  _countAllListeners() {
+    let count = this._wildcardListeners.length
+    for (const list of this._exactListeners.values()) {
+      count += list.length
+    }
+    return count
+  }
+
+  /**
+   * 计算所有拦截器总数
+   * @returns {number}
+   * @private
+   */
+  _countAllInterceptors() {
+    let count = this._globalInterceptors.length
+    for (const list of this._interceptors.values()) {
+      count += list.length
+    }
+    return count
+  }
+}
+
+export { EventBus }