mm_expand 2.0.1 → 2.0.3

package/lib/event.js

@@ -1,159 +1,568 @@
-const emitter = require('events');
-require('./global.js');
-
-/**
- * 事件类
- */
-class Event extends emitter {
-  /**
-   *
-   */
-  constructor() {
-    super();
-    // 日志对象
-    this._logger = $.log || console;
-  }
-}
-
-/**
- * 日志输出
- * @param {string} level 日志级别
- * @param {string} message 日志消息
- * @param  {...any} args 日志参数
- */
-Event.prototype.log = function (level, message, ...args) {
-  this._logger[level](`[${this.constructor.name}] ${message}`, ...args);
-};
-
-/**
- * 异步触发事件，按顺序执行等待完成
- * @param {string} event 事件名称
- * @param  {...any} args 事件参数
- * @returns {Promise} - 事件触发结果
- */
-Event.prototype.emitWait = async function (event, ...args) {
-  const listeners = this.listeners(event);
-  if (listeners.length === 0) {
-    return;
-  } else {
-    for (const listener of listeners) {
-      try {
-        await listener(...args);
-      } catch (err) {
-        this.log('error', 'Error in async event listener:', err);
-      }
-    }
-  }
-};
-
-/**
- * 异步触发事件，并发执行不等待
- * @param {string} event 事件名称
- * @param  {...any} args 事件参数
- * @returns {boolean} 是否成功触发事件
- */
-Event.prototype.emitAsync = async function (event, ...args) {
-  const listeners = this.listeners(event);
-
-  if (listeners.length === 0) {
-    return false;
-  }
-
-  // 立即启动所有监听器，但不等待
-  listeners.forEach(listener => {
-    try {
-      // 使用 Promise.resolve 确保异步执行
-      Promise.resolve(listener(...args))
-        .catch(error => {
-          // 错误处理 - 记录但不抛出
-          this.log('error', `Async listener error for event ${event}:`, error);
-          this.emit('async:error', error, event, args);
-        });
-    } catch (syncError) {
-      // 同步错误处理
-      this.log('error', `Sync listener error for event ${event}:`, syncError);
-      this.emit('sync:error', syncError, event, args);
-    }
-  });
-
-  return true;
-};
-
-/**
- * 异步触发事件，并发执行等待完成
- * @param {string} event 事件名称
- * @param  {...any} args 事件参数
- * @returns {Promise} - 事件触发结果
- */
-Event.prototype.emitAll = async function (event, ...args) {
-  const listeners = this.listeners(event);
-
-  if (listeners.length === 0) {
-    return [];
-  }
-
-  const promises = listeners.map(listener => {
-    try {
-      return Promise.resolve(listener(...args));
-    } catch (error) {
-      return Promise.reject(error);
-    }
-  });
-
-  return await Promise.all(promises);
-};
-
-/**
- * 异步触发事件，竞争执行
- * @param {string} event 事件名称
- * @param  {...any} args 事件参数
- * @returns {Promise} - 第一个完成的结果
- */
-Event.prototype.emitRace = async function (event, ...args) {
-  const listeners = this.listeners(event);
-
-  if (listeners.length === 0) {
-    return null;
-  }
-
-  const promises = listeners.map((listener, index) =>
-    Promise.resolve(listener(...args))
-      .then(result => ({ index, result, status: 'fulfilled' }))
-      .catch(error => ({ index, error, status: 'rejected' }))
-  );
-
-  // 使用 Promise.race 获取第一个完成的结果
-  return await Promise.race(promises);
-};
-
-/**
- * 异步触发事件，瀑布流执行
- * @param {string} event 事件名称
- * @param {*} value 初始值
- * @param  {...any} args 事件参数
- * @returns {Promise} - 最后一个事件监听者的结果
- */
-Event.prototype.emitWaterfall = async function (event, value, ...args) {
-  const listeners = this.listeners(event);
-
-  if (listeners.length === 0) {
-    return value;
-  }
-
-  let val = value;
-
-  for (const listener of listeners) {
-    try {
-      val = await listener(val, ...args);
-    } catch (error) {
-      this.log('error', 'Waterfall execution failed:', error);
-      throw error;
-    }
-  }
-
-  return val;
-};
-
-module.exports = {
-  Event
-};
+require('./global.js');
+
+/**
+ * 高性能事件发射器
+ * 优化特殊事件存储，提高查找效率
+ */
+class Event {
+  static config = {
+    max_listeners: 100,
+    auto_clean: true,
+    error_handler: null
+  };
+
+  /**
+   * 构造函数
+   * @param {object} config 配置参数
+   */
+  constructor(config) {
+    this.config = {
+      ...Event.config,
+      ...config || {}
+    };
+
+    // 事件存储结构优化
+    this._events = {
+      // 主事件（没有冒号的事件）
+      main: new Map(),
+      // 特殊事件分类存储
+      special: {
+        before: new Map(),
+        check: new Map(),
+        after: new Map(),
+        error: new Map(),
+        render: new Map(),
+        success: new Map(),
+        other: new Map()
+      }
+    };
+
+    // 事件计数器
+    this._counters = {
+      main: 0,
+      special: 0
+    };
+
+    // 日志对象
+    this._logger = $.log || console;
+  }
+
+  /**
+   * 判断事件类型
+   * @param {string} event_name 事件名称
+   * @returns {string} 事件类型
+   * @private
+   */
+  _getEventType(event_name) {
+    if (typeof event_name !== 'string') return 'main';
+    
+    const parts = event_name.split(':');
+    if (parts.length < 2) return 'main';
+    
+    const suffix = parts[parts.length - 1];
+    const special_types = ['before', 'check', 'after', 'error', 'render', 'success'];
+    
+    if (special_types.includes(suffix)) {
+      return suffix;
+    }
+    
+    return 'other';
+  }
+
+  /**
+   * 获取事件存储位置
+   * @param {string} event_name 事件名称
+   * @returns {object} 存储位置信息
+   * @private
+   */
+  _getEventStore(event_name) {
+    const event_type = this._getEventType(event_name);
+    
+    if (event_type === 'main') {
+      return {
+        map: this._events.main,
+        type: 'main'
+      };
+    }
+    
+    return {
+      map: this._events.special[event_type],
+      type: 'special',
+      special_type: event_type
+    };
+  }
+
+  /**
+   * 添加事件监听器
+   * @param {string} event_name 事件名称
+   * @param {function} listener 监听器函数
+   * @returns {Event} 返回this，支持链式调用
+   */
+  on(event_name, listener) {
+    if (typeof listener !== 'function') {
+      throw new TypeError('监听器必须是函数');
+    }
+
+    const store = this._getEventStore(event_name);
+    
+    if (!store.map.has(event_name)) {
+      store.map.set(event_name, []);
+    }
+
+    const listeners = store.map.get(event_name);
+    
+    // 检查监听器数量限制
+    if (listeners.length >= this.config.max_listeners) {
+      this._logger.warn(`事件 ${event_name} 的监听器数量已达到上限 ${this.config.max_listeners}`);
+      return this;
+    }
+
+    listeners.push(listener);
+    
+    // 更新计数器
+    if (store.type === 'special') {
+      this._counters.special++;
+    } else {
+      this._counters.main++;
+    }
+
+    return this;
+  }
+
+  /**
+   * 添加一次性事件监听器
+   * @param {string} event_name 事件名称
+   * @param {function} listener 监听器函数
+   * @returns {Event} 返回this，支持链式调用
+   */
+  once(event_name, listener) {
+    const once_wrapper = (...args) => {
+      this.off(event_name, once_wrapper);
+      return listener(...args);
+    };
+
+    once_wrapper._original = listener;
+    return this.on(event_name, once_wrapper);
+  }
+
+  /**
+   * 移除事件监听器（removeListener 别名）
+   * @param {string} event_name 事件名称
+   * @param {function} listener 监听器函数
+   * @returns {Event} 返回this，支持链式调用
+   */
+  removeListener(event_name, listener) {
+    return this.off(event_name, listener);
+  }
+
+  /**
+   * 移除事件监听器
+   * @param {string} event_name 事件名称
+   * @param {function} listener 监听器函数
+   * @returns {Event} 返回this，支持链式调用
+   */
+  off(event_name, listener) {
+    const store = this._getEventStore(event_name);
+    
+    if (!store.map.has(event_name)) {
+      return this;
+    }
+
+    const listeners = store.map.get(event_name);
+    
+    if (listener) {
+      // 移除特定监听器
+      const index = listeners.findIndex(fn => fn === listener || fn._original === listener);
+      if (index !== -1) {
+        listeners.splice(index, 1);
+        
+        // 更新计数器
+        if (store.type === 'special') {
+          this._counters.special--;
+        } else {
+          this._counters.main--;
+        }
+      }
+    } else {
+      // 移除所有监听器
+      const count = listeners.length;
+      store.map.delete(event_name);
+      
+      // 更新计数器
+      if (store.type === 'special') {
+        this._counters.special -= count;
+      } else {
+        this._counters.main -= count;
+      }
+    }
+
+    // 自动清理空的事件列表
+    if (this.config.auto_clean && listeners && listeners.length === 0) {
+      store.map.delete(event_name);
+    }
+
+    return this;
+  }
+
+  /**
+   * 触发事件
+   * @param {string} event_name 事件名称
+   * @param  {...any} args 事件参数
+   * @returns {boolean} 是否成功触发事件
+   */
+  emit(event_name, ...args) {
+    const store = this._getEventStore(event_name);
+    
+    if (!store.map.has(event_name)) {
+      return false;
+    }
+
+    const listeners = store.map.get(event_name).slice();
+    
+    for (const listener of listeners) {
+      try {
+        listener(...args);
+      } catch (error) {
+        this._handleError(error, event_name, args);
+      }
+    }
+
+    return true;
+  }
+
+  /**
+   * 异步触发事件，按顺序执行等待完成
+   * @param {string} event_name 事件名称
+   * @param  {...any} args 事件参数
+   * @returns {Promise} 事件触发结果
+   */
+  async emitWait(event_name, ...args) {
+    const store = this._getEventStore(event_name);
+    
+    if (!store.map.has(event_name)) {
+      return;
+    }
+
+    const listeners = store.map.get(event_name).slice();
+    
+    for (const listener of listeners) {
+      try {
+        await listener(...args);
+      } catch (error) {
+        this._handleError(error, event_name, args);
+      }
+    }
+  }
+
+  /**
+   * 异步触发事件，并发执行不等待
+   * @param {string} event_name 事件名称
+   * @param  {...any} args 事件参数
+   * @returns {boolean} 是否成功触发事件
+   */
+  emitAsync(event_name, ...args) {
+    const store = this._getEventStore(event_name);
+    
+    if (!store.map.has(event_name)) {
+      return false;
+    }
+
+    const listeners = store.map.get(event_name).slice();
+    
+    listeners.forEach(listener => {
+      try {
+        Promise.resolve(listener(...args))
+          .catch(error => {
+            this._handleError(error, event_name, args);
+          });
+      } catch (sync_error) {
+        this._handleError(sync_error, event_name, args);
+      }
+    });
+
+    return true;
+  }
+
+  /**
+   * 异步触发事件，并发执行等待完成
+   * @param {string} event_name 事件名称
+   * @param  {...any} args 事件参数
+   * @returns {Promise} 事件触发结果
+   */
+  async emitAll(event_name, ...args) {
+    const store = this._getEventStore(event_name);
+    
+    if (!store.map.has(event_name)) {
+      return [];
+    }
+
+    const listeners = store.map.get(event_name).slice();
+    const promises = listeners.map(listener => {
+      try {
+        return Promise.resolve(listener(...args));
+      } catch (error) {
+        return Promise.reject(error);
+      }
+    });
+
+    return await Promise.all(promises);
+  }
+
+  /**
+   * 异步触发事件，竞争执行
+   * @param {string} event_name 事件名称
+   * @param  {...any} args 事件参数
+   * @returns {Promise} 第一个完成的结果
+   */
+  async emitRace(event_name, ...args) {
+    const store = this._getEventStore(event_name);
+    
+    if (!store.map.has(event_name)) {
+      return null;
+    }
+
+    const listeners = store.map.get(event_name).slice();
+    const promises = listeners.map((listener, index) =>
+      Promise.resolve(listener(...args))
+        .then(result => ({ index, result, status: 'fulfilled' }))
+        .catch(error => ({ index, error, status: 'rejected' }))
+    );
+
+    return await Promise.race(promises);
+  }
+
+  /**
+   * 异步触发事件，瀑布流执行
+   * @param {string} event_name 事件名称
+   * @param {*} value 初始值
+   * @param  {...any} args 事件参数
+   * @returns {Promise} 最后一个事件监听者的结果
+   */
+  async emitWaterfall(event_name, value, ...args) {
+    const store = this._getEventStore(event_name);
+    
+    if (!store.map.has(event_name)) {
+      return value;
+    }
+
+    const listeners = store.map.get(event_name).slice();
+    let val = value;
+
+    for (const listener of listeners) {
+      try {
+        val = await listener(val, ...args);
+      } catch (error) {
+        this._handleError(error, event_name, args);
+        throw error;
+      }
+    }
+
+    return val;
+  }
+
+  /**
+   * 获取事件监听器数量
+   * @param {string} event_name 事件名称
+   * @returns {number} 监听器数量
+   */
+  listenerCount(event_name) {
+    const store = this._getEventStore(event_name);
+    
+    if (!store.map.has(event_name)) {
+      return 0;
+    }
+
+    return store.map.get(event_name).length;
+  }
+
+  /**
+   * 获取所有事件监听器
+   * @param {string} event_name 事件名称
+   * @returns {array} 监听器数组
+   */
+  listeners(event_name) {
+    const store = this._getEventStore(event_name);
+    
+    if (!store.map.has(event_name)) {
+      return [];
+    }
+
+    return store.map.get(event_name).slice();
+  }
+
+  /**
+   * 移除所有事件监听器
+   * @param {string} event_name 事件名称，不传则移除所有事件
+   * @returns {Event} 返回this，支持链式调用
+   */
+  removeAllListeners(event_name) {
+    if (event_name) {
+      const store = this._getEventStore(event_name);
+      
+      if (store.map.has(event_name)) {
+        const count = store.map.get(event_name).length;
+        store.map.delete(event_name);
+        
+        // 更新计数器
+        if (store.type === 'special') {
+          this._counters.special -= count;
+        } else {
+          this._counters.main -= count;
+        }
+      }
+    } else {
+      // 移除所有事件
+      this._events.main.clear();
+      Object.values(this._events.special).forEach(map => map.clear());
+      this._counters.main = 0;
+      this._counters.special = 0;
+    }
+
+    return this;
+  }
+
+  /**
+   * 获取所有事件名称
+   * @returns {array} 事件名称数组
+   */
+  eventNames() {
+    const event_names = [];
+    
+    // 添加 main 类型事件
+    for (const event_name of this._events.main.keys()) {
+      event_names.push(event_name);
+    }
+    
+    // 添加特殊类型事件
+    for (const [type, map] of Object.entries(this._events.special)) {
+      for (const event_name of map.keys()) {
+        event_names.push(event_name);
+      }
+    }
+    
+    return event_names;
+  }
+
+  /**
+   * 前置添加事件监听器
+   * @param {string} event_name 事件名称
+   * @param {function} listener 监听器函数
+   * @returns {Event} 返回this，支持链式调用
+   */
+  prependListener(event_name, listener) {
+    if (typeof listener !== 'function') {
+      throw new TypeError('监听器必须是函数');
+    }
+
+    const store = this._getEventStore(event_name);
+    
+    if (!store.map.has(event_name)) {
+      store.map.set(event_name, []);
+    }
+
+    const listeners = store.map.get(event_name);
+    
+    // 检查监听器数量限制
+    if (listeners.length >= this.config.max_listeners) {
+      this._logger.warn(`事件 ${event_name} 的监听器数量已达到上限 ${this.config.max_listeners}`);
+      return this;
+    }
+
+    // 前置添加监听器
+    listeners.unshift(listener);
+    
+    // 更新计数器
+    if (store.type === 'special') {
+      this._counters.special++;
+    } else {
+      this._counters.main++;
+    }
+
+    return this;
+  }
+
+  /**
+   * 前置添加一次性事件监听器
+   * @param {string} event_name 事件名称
+   * @param {function} listener 监听器函数
+   * @returns {Event} 返回this，支持链式调用
+   */
+  prependOnceListener(event_name, listener) {
+    const once_wrapper = (...args) => {
+      this.off(event_name, once_wrapper);
+      return listener(...args);
+    };
+
+    once_wrapper._original = listener;
+    return this.prependListener(event_name, once_wrapper);
+  }
+
+  /**
+   * 获取原始监听器数组
+   * @param {string} event_name 事件名称
+   * @returns {array} 原始监听器数组
+   */
+  rawListeners(event_name) {
+    const store = this._getEventStore(event_name);
+    
+    if (!store.map.has(event_name)) {
+      return [];
+    }
+
+    return store.map.get(event_name).slice();
+  }
+
+  /**
+   * 获取事件统计信息
+   * @returns {object} 统计信息
+   */
+  getStats() {
+    return {
+      total: this._counters.main + this._counters.special,
+      main: this._counters.main,
+      special: this._counters.special,
+      special_types: {
+        before: this._events.special.before.size,
+        check: this._events.special.check.size,
+        after: this._events.special.after.size,
+        error: this._events.special.error.size,
+        render: this._events.special.render.size,
+        success: this._events.special.success.size,
+        other: this._events.special.other.size
+      }
+    };
+  }
+
+  /**
+   * 错误处理
+   * @param {Error} error 错误对象
+   * @param {string} event_name 事件名称
+   * @param {array} args 事件参数
+   * @private
+   */
+  _handleError(error, event_name, args) {
+    if (this.config.error_handler) {
+      try {
+        this.config.error_handler(error, event_name, args);
+      } catch (handler_error) {
+        this._logger.error('错误处理函数执行失败:', handler_error);
+      }
+    } else {
+      this._logger.error(`事件 ${event_name} 执行失败:`, error);
+    }
+  }
+
+  /**
+   * 日志输出
+   * @param {string} level 日志级别
+   * @param {string} message 日志消息
+   * @param  {...any} args 日志参数
+   */
+  log(level, message, ...args) {
+    this._logger[level](`[${this.constructor.name}] ${message}`, ...args);
+  }
+}
+
+module.exports = {
+  Event
+};