mm_expand 2.3.3 → 2.3.5

package/lib/eventer.js

@@ -1,3 +1,4 @@
+/* eslint-disable mm_eslint/function-name */
 require('./global.js');
 
 /**
@@ -5,11 +6,11 @@ require('./global.js');
  */
 class Eventer {
   static config = {
-    max_listeners: 10, // 最大监听器数量
-    default_namespace: 'default', // 默认命名空间
+    max_list: 10, // 最大监听器数量
+    default_name: 'default', // 默认命名空间
     chain_enabled: true, // 是否启用链式触发
     auto_clean: true, // 是否自动清理空的事件列表
-    error_handler: null, // 全局错误处理函数
+    error: null, // 全局错误处理函数
     pause_enabled: true, // 是否启用暂停功能
   };
   
@@ -42,7 +43,7 @@ class Eventer {
     this._paused_namespace = new Set(); // 暂停的命名空间
     this._paused_global = false; // 全局暂停状态
     // 初始化默认命名空间
-    this._namespace[this.config.default_namespace] = true;
+    this._namespace[this.config.default_name] = true;
   }
 
   /**
@@ -113,10 +114,10 @@ Eventer.prototype._validateOnParams = function (key, func) {
 };
 
 Eventer.prototype._parseEventKey = function (key, ns) {
-  const parsed = this._parseKey(key);
-  const namespace = ns || parsed.namespace;
-  const event_key = parsed.key;
-  const full_key = `${namespace}:${event_key}`;
+  let parsed = this._parseKey(key);
+  let namespace = ns || parsed.namespace;
+  let event_key = parsed.key;
+  let full_key = `${namespace}:${event_key}`;
   return { namespace, event_key, full_key };
 };
 
@@ -144,12 +145,12 @@ Eventer.prototype._wrapFunction = function (func, params) {
   }
 
   if (params.timeout && typeof params.timeout === 'number' && params.timeout > 0) {
-    const original_func = wrapped_func;
+    let original_func = wrapped_func;
     wrapped_func = async function (...args) {
-      const timeout_promise = new Promise((resolve, reject) => {
+      const timeoutPromise = new Promise((resolve, reject) => {
         setTimeout(() => reject(new Error(`事件执行超时 (${params.timeout}ms)`)), params.timeout);
       });
-      return Promise.race([original_func.apply(this, args), timeout_promise]);
+      return Promise.race([original_func.apply(this, args), timeoutPromise]);
     };
   }
 
@@ -179,10 +180,9 @@ Eventer.prototype._findHandlerIndex = function (list, name) {
 };
 
 Eventer.prototype._checkListenerLimit = function (namespace, event_key, list) {
-  const max_listeners = this.config.max_listeners;
-  if (max_listeners > 0 && list.length >= max_listeners) {
-    this.log('warn', `警告: '${namespace}:${event_key}' 事件的监听器数量已达到 ${max_listeners}，可能导致内存泄漏。使用 
-  set_max_listeners() 方法可以增加限制。`);
+  let max_list = this.config.max_list;
+  if (max_list > 0 && list.length >= max_list) {
+    this.log('warn', `警告: '${namespace}:${event_key}' 事件的监听器数量已达到 ${max_list}，可能导致内存泄漏。使用 set_max_listeners() 方法可以增加限制。`);
   }
 };
 
@@ -208,7 +208,7 @@ Eventer.prototype._createHandlerResult = function (namespace, index, name, full_
  */
 Eventer.prototype.on = function (key, func, name, options) {
   // 处理参数
-  const params = this._processOnParams(key, func, name, options);
+  let params = this._processOnParams(key, func, name, options);
 
   // 验证参数
   this._validateOnParams(params.key, params.func);
@@ -224,7 +224,7 @@ Eventer.prototype._processOnParams = function (key, func, name, options) {
     return this._extractOnParams(key);
   } else {
     // 便捷方式
-    const opts = options || {};
+    let opts = options || {};
     return {
       key: key,
       func: func,
@@ -247,13 +247,13 @@ Eventer.prototype._addEventHandler = function (params) {
   this._initNamespace(namespace, event_key);
 
   // 设置默认名称
-  const final_name = eventName || this._generateDefaultName(eventFunc);
+  let final_name = eventName || this._generateDefaultName(eventFunc);
 
   // 应用节流或防抖
-  const wrapped_func = this._wrapFunction(eventFunc, params);
+  let wrapped_func = this._wrapFunction(eventFunc, params);
 
   // 创建事件对象
-  const obj = this._createHandlerObj({
+  let obj = this._createHandlerObj({
     name: final_name,
     wrapped_func: wrapped_func,
     func: eventFunc,
@@ -280,12 +280,12 @@ Eventer.prototype._processOnceParams = function (key, func, name, options) {
   // 支持两种调用方式：便捷方式和配置对象方式
   if (typeof key === 'object' && key !== null) {
     // 配置对象方式
-    const params = this._extractOnParams(key);
+    let params = this._extractOnParams(key);
     params.times = 1; // 强制设置为仅执行一次
     return params;
   } else {
     // 便捷方式
-    const opts = options || {};
+    let opts = options || {};
     return {
       key: key,
       func: func,
@@ -299,8 +299,8 @@ Eventer.prototype._processOnceParams = function (key, func, name, options) {
 
 Eventer.prototype._handleEventAddition = function (config) {
   const { namespace, event_key, full_key, final_name, obj } = config;
-  const list = this._dict[namespace][event_key];
-  const idx = this._findHandlerIndex(list, final_name);
+  let list = this._dict[namespace][event_key];
+  let idx = this._findHandlerIndex(list, final_name);
 
   if (idx >= 0) {
     // 覆盖已存在的同名监听器
@@ -330,7 +330,7 @@ Eventer.prototype._handleEventAddition = function (config) {
  */
 Eventer.prototype.once = function (key, func, name, options) {
   // 处理参数
-  const params = this._processOnceParams(key, func, name, options);
+  let params = this._processOnceParams(key, func, name, options);
 
   // 验证参数
   this._validateOnParams(params.key, params.func);
@@ -354,11 +354,11 @@ Eventer.prototype._validateExec = function (key) {
 };
 
 Eventer.prototype._createCtx = function (key, params) {
-  const parsed = this._parseKey(key);
-  const namespace = parsed.namespace;
-  const event_key = parsed.key;
-  const full_key = `${namespace}:${event_key}`;
-  const start_time = Date.now();
+  let parsed = this._parseKey(key);
+  let namespace = parsed.namespace;
+  let event_key = parsed.key;
+  let full_key = `${namespace}:${event_key}`;
+  let start_time = Date.now();
 
   const ctx = {
     namespace,
@@ -385,7 +385,7 @@ Eventer.prototype._createCtx = function (key, params) {
 Eventer.prototype._cancelTasks = function (full_key) {
   try {
     if (this._tasks.has(full_key)) {
-      const tasks = this._tasks.get(full_key);
+      let tasks = this._tasks.get(full_key);
       tasks.forEach(task => {
         if (task && typeof task.cancel === 'function') {
           try {
@@ -516,8 +516,8 @@ Eventer.prototype._buildSafeResult = function (ctx) {
       results: ctx.results || [],
       cancelled: ctx.cancelled || false,
       cancel: ctx.cancel || (() => { }),
-      race_result: ctx.race_result,
-      waterfall_result: ctx.results && ctx.results.length > 0 ? ctx.results[ctx.results.length - 1]
+      race: ctx.race_result,
+      waterfall: ctx.results && ctx.results.length > 0 ? ctx.results[ctx.results.length - 1]
         : undefined
     };
   } catch (return_error) {
@@ -543,7 +543,7 @@ Eventer.prototype._execute = async function (key, options = {}, ...params) {
     return this._createPausedResult();
   }
 
-  const list = this._dict[namespace] && this._dict[namespace][event_key];
+  let list = this._dict[namespace] && this._dict[namespace][event_key];
   const arr = [];
 
   if (list && list.length > 0) {
@@ -592,7 +592,7 @@ Eventer.prototype._executeEventList = async function (config) {
 
   this._initTaskList(full_key);
 
-  const cancelled = await this._runBeforeMiddleware(ctx, full_key);
+  let cancelled = await this._runBeforeMiddleware(ctx, full_key);
   if (cancelled) {
     return {
       results: [],
@@ -618,7 +618,7 @@ Eventer.prototype._executeSequential = async function (config) {
   const { list, params, ctx, full_key, arr } = config;
 
   for (let i = 0; i < list.length && !ctx.cancelled; i++) {
-    const o = list[i];
+    let o = list[i];
     ctx.executed++;
     o.last_executed = Date.now();
 
@@ -631,11 +631,11 @@ Eventer.prototype._execSingleTask = async function (o, params, ctx, options) {
   const { full_key, arr } = options;
 
   // 创建任务
-  const task = this._createTask(o, full_key);
+  let task = this._createTask(o, full_key);
 
   try {
     // 执行事件处理函数
-    const result = await o.func.apply(o, params);
+    let result = await o.func.apply(o, params);
 
     // 处理成功结果
     this._handleSuccessResult({ result, o, ctx, arr, task });
@@ -646,7 +646,7 @@ Eventer.prototype._execSingleTask = async function (o, params, ctx, options) {
 };
 
 Eventer.prototype._createTask = function (o, full_key) {
-  const task_id = `${o.name}_${Date.now()}`;
+  let task_id = `${o.name}_${Date.now()}`;
   let cancelled = false;
   const task = {
     id: task_id,
@@ -657,7 +657,7 @@ Eventer.prototype._createTask = function (o, full_key) {
   };
 
   // 添加到进行中的任务列表
-  const tasks = this._tasks.get(full_key);
+  let tasks = this._tasks.get(full_key);
   tasks.push(task);
 
   return { task, tasks, cancelled };
@@ -712,18 +712,19 @@ Eventer.prototype._handleTaskError = function (e, o, ctx, task) {
  */
 Eventer.prototype._executeParallel = async function (config) {
   const { list, params, ctx, full_key, arr } = config;
-  const concurrency = this._getConcurrency(params);
-  const processed_results = new Array(list.length);
+  let concurrency = this._getConcurrency(params);
+  // eslint-disable-next-line mm_eslint/class-instance-name
+  const proc_results = new Array(list.length);
 
   if (concurrency < Infinity) {
     await this._executeBatches({
-      list, params, ctx, full_key, arr, concurrency, processed_results
+      list, params, ctx, full_key, arr, concurrency, proc_results
     });
   } else {
-    await this._executeAllParallel({ list, params, ctx, full_key, arr, processed_results });
+    await this._executeAllParallel({ list, params, ctx, full_key, arr, proc_results });
   }
 
-  this._setResults(ctx, processed_results);
+  this._setResults(ctx, proc_results);
 };
 
 Eventer.prototype._getConcurrency = function (params) {
@@ -732,14 +733,14 @@ Eventer.prototype._getConcurrency = function (params) {
 };
 
 Eventer.prototype._executeBatches = async function (config) {
-  const { list, params, ctx, full_key, arr, concurrency, processed_results } = config;
+  const { list, params, ctx, full_key, arr, concurrency, proc_results } = config;
 
   for (let i = 0; i < list.length && !ctx.cancelled; i += concurrency) {
-    const batch = list.slice(i, i + concurrency);
-    const batch_promises = batch.map((obj, batch_idx) => {
-      const global_idx = i + batch_idx;
+    let batch = list.slice(i, i + concurrency);
+    let batch_promises = batch.map((obj, batch_idx) => {
+      let global = i + batch_idx; // eslint-disable-line mm_eslint/variable-name
       return this._executeSingleTask({
-        obj, params, ctx, full_key, arr, idx: global_idx, processed_results
+        obj, params, ctx, full_key, arr, idx: global, proc_results
       });
     });
 
@@ -748,17 +749,17 @@ Eventer.prototype._executeBatches = async function (config) {
 };
 
 Eventer.prototype._executeAllParallel = async function (config) {
-  const { list, params, ctx, full_key, arr, processed_results } = config;
+  const { list, params, ctx, full_key, arr, proc_results } = config;
 
-  const promises = list.map((obj, idx) => {
-    return this._executeSingleTask({ obj, params, ctx, full_key, arr, idx, processed_results });
+  let promises = list.map((obj, idx) => {
+    return this._executeSingleTask({ obj, params, ctx, full_key, arr, idx, proc_results });
   });
 
   await Promise.allSettled(promises);
 };
 
-Eventer.prototype._setResults = function (ctx, processed_results) {
-  ctx.results = processed_results.filter(result => result !== undefined);
+Eventer.prototype._setResults = function (ctx, proc_results) {
+  ctx.results = proc_results.filter(result => result !== undefined);
 };
 
 /**
@@ -768,16 +769,16 @@ Eventer.prototype._setResults = function (ctx, processed_results) {
  */
 Eventer.prototype._executeWaterfall = async function (config) {
   const { list, params, ctx, full_key, arr, initial_value } = config;
-  let waterfall_value = this._getInitialValue(params, initial_value);
+  let wate_value = this._getInitialValue(params, initial_value);
 
   for (let i = 0; i < list.length && !ctx.cancelled; i++) {
-    const obj = list[i];
+    let obj = list[i];
     ctx.executed++;
     obj.last_executed = Date.now();
 
-    const task = this._createWaterfallTask(obj, full_key);
-    waterfall_value = await this._execWaterfallStep({
-      obj, params, ctx, arr, task, waterfall_value
+    let task = this._createWaterfallTask(obj, full_key);
+    wate_value = await this._execWaterfallStep({
+      obj, params, ctx, arr, task, wate_value
     });
   }
 };
@@ -787,7 +788,7 @@ Eventer.prototype._getInitialValue = function (params, initial_value) {
 };
 
 Eventer.prototype._createWaterfallTask = function (obj, full_key) {
-  const task_id = `${obj.name}_${Date.now()}`;
+  let task_id = `${obj.name}_${Date.now()}`;
   let cancelled = false;
   const task = {
     id: task_id,
@@ -797,21 +798,21 @@ Eventer.prototype._createWaterfallTask = function (obj, full_key) {
     cancel: () => { cancelled = true; }
   };
 
-  const tasks = this._tasks.get(full_key);
+  let tasks = this._tasks.get(full_key);
   tasks.push(task);
 
   return { task, tasks, cancelled };
 };
 
 Eventer.prototype._execWaterfallStep = async function (config) {
-  const { obj, params, ctx, arr, task, waterfall_value } = config;
+  const { obj, params, ctx, arr, task, wate_value } = config;
   try {
-    const result = await obj.func.apply(obj, [waterfall_value, ...params.slice(1)]);
+    let result = await obj.func.apply(obj, [wate_value, ...params.slice(1)]);
     this._handleWfSuccess({ result, obj, ctx, arr, task });
     return result;
   } catch (e) {
     this._handleWfError({ e, obj, ctx, task });
-    return waterfall_value;
+    return wate_value;
   }
 };
 
@@ -867,7 +868,7 @@ Eventer.prototype._callErrorHandler = function (e, obj, ctx) {
  */
 Eventer.prototype._executeRace = async function (config) {
   const { list, params, ctx, full_key, arr } = config;
-  const promises = this._createRacePromises({ list, params, ctx, full_key, arr });
+  let promises = this._createRacePromises({ list, params, ctx, full_key, arr });
 
   return await this._runRace(promises);
 };
@@ -877,11 +878,11 @@ Eventer.prototype._createRacePromises = function (config) {
   const promises = [];
 
   for (let i = 0; i < list.length && !ctx.cancelled; i++) {
-    const obj = list[i];
+    let obj = list[i];
     ctx.executed++;
     obj.last_executed = Date.now();
 
-    const promise = this._createRacePromise({ obj, params, ctx, full_key, arr });
+    let promise = this._createRacePromise({ obj, params, ctx, full_key, arr });
     promises.push(promise);
   }
 
@@ -890,11 +891,11 @@ Eventer.prototype._createRacePromises = function (config) {
 
 Eventer.prototype._createRacePromise = function (config) {
   const { obj, params, ctx, full_key, arr } = config;
-  const task = this._createRaceTask(obj, full_key);
+  let task = this._createRaceTask(obj, full_key);
 
   return (async () => {
     try {
-      const result = await obj.func.apply(obj, params);
+      let result = await obj.func.apply(obj, params);
       return this._handleRaceSuccess({ result, obj, ctx, arr, task });
     } catch (e) {
       return this._handleRaceError(e, obj, ctx, task);
@@ -905,7 +906,7 @@ Eventer.prototype._createRacePromise = function (config) {
 };
 
 Eventer.prototype._createRaceTask = function (obj, full_key) {
-  const task_id = `${obj.name}_${Date.now()}`;
+  let task_id = `${obj.name}_${Date.now()}`;
   let cancelled = false;
   const task = {
     id: task_id,
@@ -915,7 +916,7 @@ Eventer.prototype._createRaceTask = function (obj, full_key) {
     cancel: () => { cancelled = true; }
   };
 
-  const tasks = this._tasks.get(full_key);
+  let tasks = this._tasks.get(full_key);
   tasks.push(task);
 
   return { task, tasks, cancelled };
@@ -951,8 +952,8 @@ Eventer.prototype._handleRaceError = function (e, obj, ctx, task) {
 
 Eventer.prototype._runRace = async function (promises) {
   if (promises.length > 0) {
-    const race_result = await Promise.race(promises);
-    return race_result;
+    let race = await Promise.race(promises);
+    return race;
   }
   return null;
 };
@@ -963,22 +964,22 @@ Eventer.prototype._runRace = async function (promises) {
  * @private
  */
 Eventer.prototype._executeSingleTask = async function (config) {
-  const { obj, params, ctx, full_key, arr, idx, processed_results } = config;
+  const { obj, params, ctx, full_key, arr, idx, proc_results } = config;
   obj.last_executed = Date.now();
 
   // 创建任务
-  const task_info = this._createParallelTask(obj, full_key);
+  let task_info = this._createParallelTask(obj, full_key);
 
   try {
-    const result = await obj.func.apply(obj, params);
-    this._handleTaskSuccess({ result, obj, ctx, arr, idx, processed_results, task_info });
+    let result = await obj.func.apply(obj, params);
+    this._handleTaskSuccess({ result, obj, ctx, arr, idx, proc_results, task_info });
   } catch (err) {
-    this._handleTaskError({ err, obj, ctx, idx, processed_results, task_info });
+    this._handleTaskError({ err, obj, ctx, idx, proc_results, task_info });
   }
 };
 
 Eventer.prototype._createParallelTask = function (obj, full_key) {
-  const task_id = `${obj.name}_${Date.now()}`;
+  let task_id = `${obj.name}_${Date.now()}`;
   let cancelled = false;
   const task = {
     id: task_id,
@@ -989,20 +990,20 @@ Eventer.prototype._createParallelTask = function (obj, full_key) {
   };
 
   // 添加到进行中的任务列表
-  const tasks = this._tasks.get(full_key);
+  let tasks = this._tasks.get(full_key);
   tasks.push(task);
 
   return { task, tasks, cancelled };
 };
 
 Eventer.prototype._handleTaskSuccess = function (config) {
-  const { result, obj, ctx, arr, idx, processed_results, task_info } = config;
+  const { result, obj, ctx, arr, idx, proc_results, task_info } = config;
 
   // 从进行中的任务列表中移除
   task_info.tasks.splice(task_info.tasks.indexOf(task_info.task), 1);
 
   if (!task_info.cancelled && !ctx.cancelled) {
-    processed_results[idx] = result;
+    proc_results[idx] = result;
 
     // 处理执行次数限制
     if (obj.times >= 0) {
@@ -1015,7 +1016,7 @@ Eventer.prototype._handleTaskSuccess = function (config) {
 };
 
 Eventer.prototype._handleTaskError = function (config) {
-  const { err, obj, ctx, idx, processed_results, task_info } = config;
+  const { err, obj, ctx, idx, proc_results, task_info } = config;
 
   // 从进行中的任务列表中移除
   task_info.tasks.splice(task_info.tasks.indexOf(task_info.task), 1);
@@ -1027,7 +1028,7 @@ Eventer.prototype._handleTaskError = function (config) {
       handler: obj.name,
       timestamp: Date.now()
     };
-    processed_results[idx] = error_result;
+    proc_results[idx] = error_result;
 
     // 全局错误处理器
     if (this.config.error_handler && typeof this.config.error_handler === 'function') {
@@ -1055,7 +1056,7 @@ Eventer.prototype.run = async function (key, ...params) {
 Eventer.prototype.emit = function (key, ...params) {
   // 内部调用 _execute 方法，但不等待结果
   try {
-    const result = this._execute(key, { exec_mode: 'sequential' }, ...params);
+    let result = this._execute(key, { exec_mode: 'sequential' }, ...params);
     result.catch(e => this.log('error', '事件异步执行失败:', e));
     return {
       ...result,
@@ -1094,7 +1095,7 @@ Eventer.prototype.emit = function (key, ...params) {
  */
 Eventer.prototype.emitWait = async function (key, ...args) {
   try {
-    const result = await this._execute(key, { exec_mode: 'sequential' }, ...args);
+    let result = await this._execute(key, { exec_mode: 'sequential' }, ...args);
     return result.results || [];
   } catch (error) {
     this.log('error', `等待事件触发失败 [${key}]`, error);
@@ -1119,13 +1120,13 @@ Eventer.prototype.emitAsync = async function (key, ...args) {
 
 Eventer.prototype._execAsync = function (key, args) {
   // 解析命名空间
-  const parsed = this._parseKey(key);
-  const namespace = parsed.namespace;
-  const event_key = parsed.key;
-  const full_key = `${namespace}:${event_key}`;
+  let parsed = this._parseKey(key);
+  let namespace = parsed.namespace;
+  let event_key = parsed.key;
+  let full_key = `${namespace}:${event_key}`;
 
   // 获取事件列表
-  const list = this._dict[namespace] && this._dict[namespace][event_key];
+  let list = this._dict[namespace] && this._dict[namespace][event_key];
 
   if (!list || list.length === 0) {
     return false;
@@ -1179,7 +1180,7 @@ Eventer.prototype._handleSyncError = function (sync_error, full_key, args) {
  */
 Eventer.prototype.emitAll = async function (key, ...args) {
   try {
-    const result = await this._execute(key, { exec_mode: 'parallel' }, ...args);
+    let result = await this._execute(key, { exec_mode: 'parallel' }, ...args);
     return result.results || [];
   } catch (error) {
     this.log('error', `并发事件触发失败 [${key}]`, error);
@@ -1195,14 +1196,61 @@ Eventer.prototype.emitAll = async function (key, ...args) {
  */
 Eventer.prototype.emitRace = async function (key, ...args) {
   try {
-    const result = await this._execute(key, { exec_mode: 'race' }, ...args);
-    return result.race_result || null;
+    let result = await this._execute(key, { exec_mode: 'race' }, ...args);
+    return result.race || null;
   } catch (error) {
     this.log('error', `竞争事件触发失败 [${key}]`, error);
     return null;
   }
 };
 
+/**
+ * 异步触发事件，返回第一个有返回值的结果（不阻塞其他监听器）
+ * @param {string} key 事件关键字，支持namespace:key格式
+ * @param  {...any} args 事件参数
+ * @returns {Promise} - 第一个有返回值（非 undefined）的监听器结果
+ * 所有监听器并行执行，返回第一个有返回值（非 undefined）的结果，
+ *               返回 undefined 的监听器被跳过，其他监听器继续在后台执行不受影响
+ */
+Eventer.prototype.emitFirst = async function (key, ...args) {
+  try {
+    let parsed = this._parseKey(key);
+    let namespace = parsed.namespace;
+    let event_key = parsed.key;
+
+    let list = this._dict[namespace] && this._dict[namespace][event_key];
+    if (!list || list.length === 0) {
+      return undefined;
+    }
+
+    return await new Promise(resolve => {
+      let settled = false;
+      let pending = list.length;
+
+      for (let handler of list) {
+        Promise.resolve(handler.func(...args)).then(result => {
+          if (!settled && result !== undefined) {
+            settled = true;
+            resolve(result);
+          }
+          pending--;
+          if (pending === 0 && !settled) {
+            resolve(undefined);
+          }
+        }).catch(() => {
+          pending--;
+          if (pending === 0 && !settled) {
+            resolve(undefined);
+          }
+        });
+      }
+    });
+  } catch (error) {
+    this.log('error', `首个结果事件触发失败 [${key}]`, error);
+    return undefined;
+  }
+};
+
 /**
  * 异步触发事件，瀑布流执行
  * @param {string} key 事件关键字，支持namespace:key格式
@@ -1212,11 +1260,11 @@ Eventer.prototype.emitRace = async function (key, ...args) {
  */
 Eventer.prototype.emitWaterfall = async function (key, value, ...args) {
   try {
-    const result = await this._execute(key, {
+    let result = await this._execute(key, {
       exec_mode: 'waterfall',
       initial_value: value
     }, ...args);
-    return result.waterfall_result || value;
+    return result.waterfall || value;
   } catch (error) {
     this.log('error', `瀑布流事件触发失败 [${key}]`, error);
     return value;
@@ -1249,16 +1297,16 @@ Eventer.prototype._ensureNs = function (name) {
  * @returns {object} 包含结果和需要移除的事件名称的对象
  */
 Eventer.prototype._execNsEvents = async function (name, key, params) {
-  const list = this._dict[name][key];
+  let list = this._dict[name][key];
   const namespace_results = [];
   const arr = []; // 存储需要移除的事件
 
   // 执行事件处理函数
   for (let i = 0; i < list.length; i++) {
     try {
-      const obj = list[i];
+      let obj = list[i];
       // 执行事件处理函数
-      const result = await obj.func.apply(obj, params);
+      let result = await obj.func.apply(obj, params);
       namespace_results.push(result);
 
       // 处理执行次数限制
@@ -1279,7 +1327,7 @@ Eventer.prototype._execNsEvents = async function (name, key, params) {
     }
   }
 
-  return { namespace_results, arr };
+  return { name_results, arr };
 };
 
 /**
@@ -1298,29 +1346,23 @@ Eventer.prototype._removeEvents = function (name, key, arr) {
 Eventer.prototype.emitAllNamespaces = async function (key, ...params) {
   const results = {};
   // 确保遍历所有命名空间，包括动态创建的
-  for (const name in this._dict) {
+  for (let name in this._dict) {
     // 确保命名空间在namespace映射中
     this._ensureNs(name);
 
     // 检查该命名空间下是否存在该事件
     if (this._dict[name] && this._dict[name][key]) {
-      const { namespace_results, arr } = await this._execNsEvents(name, key, params);
+      const { name_results, arr } = await this._execNsEvents(name, key, params);
 
       // 移除已执行完的事件
       this._removeEvents(name, key, arr);
 
-      results[name] = namespace_results;
+      results[name] = name_results;
     }
   }
   return results;
 };
 
-/**
- * 删除事件
- * @param {string} key 事件关键字，支持namespace:key格式
- * @param {number | string} index_or_name 事件集索引或名称
- * @returns {boolean} 删除成功返回true，否则返回false
- */
 /**
  * 删除单个事件监听器
  * @private
@@ -1352,7 +1394,7 @@ Eventer.prototype._removeSingleEvent = function (events, index_or_name) {
  * @private
  * @param {string} namespace 命名空间
  * @param {string} key 事件关键字
- * @param event_key
+ * @param {string} event_key 事件键
  * @param {string} full_key 完整事件关键字
  * @returns {boolean} 删除成功返回true
  */
@@ -1367,7 +1409,7 @@ Eventer.prototype._removeEntireEvent = function (namespace, event_key, full_key)
 
   // 清理相关的事件链
   if (this._chain) {
-    for (const chain_key in this._chain) {
+    for (let chain_key in this._chain) {
       if (chain_key === full_key) {
         delete this._chain[chain_key];
       } else if (this._chain[chain_key] && Array.is_array(this._chain[chain_key]) &&
@@ -1413,6 +1455,12 @@ Eventer.prototype._autoCleanEvents = function (namespace, key, events, index_or_
   }
 };
 
+/**
+ * 删除事件
+ * @param {string} key 事件关键字，支持namespace:key格式
+ * @param {number | string} index_or_name 事件集索引或名称
+ * @returns {boolean} 删除成功返回true，否则返回false
+ */
 Eventer.prototype.off = function (key, index_or_name) {
   // 入参校验
   if (!key || typeof key !== 'string') {
@@ -1420,17 +1468,17 @@ Eventer.prototype.off = function (key, index_or_name) {
   }
 
   // 解析命名空间
-  const parsed = this._parseKey(key);
-  const namespace = parsed.namespace;
-  const event_key = parsed.key;
-  const full_key = `${namespace}:${event_key}`;
+  let parsed = this._parseKey(key);
+  let namespace = parsed.namespace;
+  let event_key = parsed.key;
+  let full_key = `${namespace}:${event_key}`;
 
   // 检查事件是否存在
   if (!this._dict[namespace] || !this._dict[namespace][event_key]) {
     return false;
   }
 
-  const events = this._dict[namespace][event_key];
+  let events = this._dict[namespace][event_key];
   let removed = false;
 
   if (index_or_name) {
@@ -1481,9 +1529,9 @@ Eventer.prototype.getEvents = function (key) {
   }
   // 返回深拷贝的所有事件
   const result = {};
-  for (const name in this._dict) {
+  for (let name in this._dict) {
     result[name] = {};
-    for (const key in this._dict[name]) {
+    for (let key in this._dict[name]) {
       result[name][key] = [...this._dict[name][key]];
     }
   }
@@ -1535,7 +1583,7 @@ Eventer.prototype.clear = function (keepnamespace = false) {
   if (!keepnamespace) {
     this._namespace = {};
     // 重新初始化默认命名空间
-    this._namespace[this.config.default_namespace] = true;
+    this._namespace[this.config.default_name] = true;
   }
 
   return this;
@@ -1549,16 +1597,16 @@ Eventer.prototype.clear = function (keepnamespace = false) {
  */
 Eventer.prototype.has = function (key, name) {
   // 解析命名空间
-  const parsed = this._parseKey(key);
-  const namespace = parsed.namespace;
-  const event_key = parsed.key;
+  let parsed = this._parseKey(key);
+  let namespace = parsed.namespace;
+  let event_key = parsed.key;
 
   if (!this._dict[namespace] || !this._dict[namespace][event_key]) {
     return false;
   }
 
   if (name) {
-    const list = this._dict[namespace][event_key];
+    let list = this._dict[namespace][event_key];
     for (let i = 0; i < list.length; i++) {
       if (list[i].name === name) {
         return true;
@@ -1580,10 +1628,10 @@ Eventer.prototype.count = function (key) {
     // 解析可能的命名空间模式
     if (key.ends_with(':*')) {
       // 统计命名空间下所有事件
-      const namespace = key.split(':')[0];
+      let namespace = key.split(':')[0];
       if (this._dict[namespace]) {
         let total = 0;
-        for (const key in this._dict[namespace]) {
+        for (let key in this._dict[namespace]) {
           total += this._dict[namespace][key].length;
         }
         return total;
@@ -1600,8 +1648,8 @@ Eventer.prototype.count = function (key) {
 
   // 统计所有事件
   let total = 0;
-  for (const name in this._dict) {
-    for (const key in this._dict[name]) {
+  for (let name in this._dict) {
+    for (let key in this._dict[name]) {
       total += this._dict[name][key].length;
     }
   }
@@ -1640,7 +1688,7 @@ Eventer.prototype.chain = function (from_event, to_events) {
   this._validateChainInput(from_event, to_events);
 
   // 解析源事件
-  const full_from_event = this._getFullEventKey(from_event);
+  let full_from_event = this._getFullEventKey(from_event);
 
   // 初始化事件链
   this._initEventChain(full_from_event);
@@ -1670,7 +1718,7 @@ Eventer.prototype._initEventChain = function (full_from_event) {
 
 Eventer.prototype._addTargetEvents = function (full_from_event, to_events) {
   // 确保目标事件是数组
-  const target_events = Array.is_array(to_events) ? to_events : [to_events];
+  let target_events = Array.is_array(to_events) ? to_events : [to_events];
 
   for (let i = 0; i < target_events.length; i++) {
     this._addSingleTargetEvent(full_from_event, target_events[i]);
@@ -1683,7 +1731,7 @@ Eventer.prototype._addTargetEvent = function (full_from_event, to_event) {
   }
 
   // 解析目标事件
-  const full_to_event = this._getFullEventKey(to_event);
+  let full_to_event = this._getFullEventKey(to_event);
 
   // 避免重复添加
   if (!this._chain[full_from_event].includes(full_to_event)) {
@@ -1705,7 +1753,7 @@ Eventer.prototype.unchain = function (from_event, to_events) {
 
   // 解析源事件
   const { namespace: from_namespace, key: fromkey } = this._parseKey(from_event);
-  const full_from_event = `${from_namespace}:${fromkey}`;
+  let full_from_event = `${from_namespace}:${fromkey}`;
 
   // 如果源事件不存在事件链，直接返回
   if (!this._chain[full_from_event]) {
@@ -1723,7 +1771,7 @@ Eventer.prototype.unchain = function (from_event, to_events) {
 };
 
 Eventer.prototype._removeTargetEvents = function (full_from_event, to_events) {
-  const target_events = Array.is_array(to_events) ? to_events : [to_events];
+  let target_events = Array.is_array(to_events) ? to_events : [to_events];
 
   for (let i = 0; i < target_events.length; i++) {
     this._removeTargetEvent(full_from_event, target_events[i]);
@@ -1742,7 +1790,7 @@ Eventer.prototype._removeTargetEvent = function (full_from_event, to_event) {
 
   // 解析目标事件
   const { namespace: to_namespace, key: tokey } = this._parseKey(to_event);
-  const full_to_event = `${to_namespace}:${tokey}`;
+  let full_to_event = `${to_namespace}:${tokey}`;
 
   // 检查事件链是否存在
   if (!this._chain[full_from_event]) {
@@ -1751,7 +1799,7 @@ Eventer.prototype._removeTargetEvent = function (full_from_event, to_event) {
   }
 
   // 查找并删除事件链
-  const index = this._chain[full_from_event].indexOf(full_to_event);
+  let index = this._chain[full_from_event].indexOf(full_to_event);
   if (index === -1) {
     this.log('warn', `事件链不存在: ${full_from_event} -> ${full_to_event}`);
     return;
@@ -1772,7 +1820,7 @@ Eventer.prototype.getChains = function (event) {
 
   // 解析事件
   const { namespace, key } = this._parseKey(event);
-  const full_event = `${namespace}:${key}`;
+  let full_event = `${namespace}:${key}`;
 
   return this._chain[full_event] ? [...this._chain[full_event]] : [];
 };
@@ -1790,7 +1838,7 @@ Eventer.prototype._triggerChain = async function (current_event, params) {
   }
 
   // 循环触发下一级事件
-  for (const next_event of this._chain[current_event]) {
+  for (let next_event of this._chain[current_event]) {
     await this._execChainItem(next_event, params);
   }
 };
@@ -1805,11 +1853,11 @@ Eventer.prototype._triggerChain = async function (current_event, params) {
 Eventer.prototype._execChainItem = async function (key, params) {
   // 解析命名空间
   const { namespace, key: innerkey } = this._parseKey(key);
-  const list = this._dict[namespace] && this._dict[namespace][innerkey];
+  let list = this._dict[namespace] && this._dict[namespace][innerkey];
   const results = [];
 
   // 创建上下文对象
-  const ctx = this._createChainContext(namespace, innerkey, key, params);
+  let ctx = this._createChainContext(namespace, innerkey, key, params);
 
   // 如果有事件处理函数，执行它们
   if (list && list.length > 0) {
@@ -1825,7 +1873,7 @@ Eventer.prototype._execChainItem = async function (key, params) {
 };
 
 Eventer.prototype._createChainContext = function (namespace, innerkey, key, params) {
-  const start_time = Date.now();
+  let start_time = Date.now();
   return {
     namespace,
     event: innerkey,
@@ -1872,7 +1920,7 @@ Eventer.prototype._execChainHandler = async function (obj, ctx, results) {
     ctx.executed++;
 
     // 执行事件处理函数
-    const result = await obj.func.apply(obj, ctx.params);
+    let result = await obj.func.apply(obj, ctx.params);
     results.push(result);
     ctx.results.push(result);
 
@@ -1914,7 +1962,7 @@ Eventer.prototype._handleChainError = function (e, obj, ctx, results) {
  * @returns {Promise<object>} 返回包含results和cancel方法的对象
  */
 Eventer.prototype.runParallel = async function (key, ...params) {
-  const result = await this._execute(key, {
+  let result = await this._execute(key, {
     exec_mode: 'parallel',
     options: params.options
   }, ...params);
@@ -1934,7 +1982,7 @@ Eventer.prototype.runParallel = async function (key, ...params) {
  */
 Eventer.prototype.emitParallel = function (key, ...params) {
   // 内部调用 _execute 方法，但不等待结果
-  const result = this._execute(key, {
+  let result = this._execute(key, {
     exec_mode: 'parallel',
     options: params.options
   }, ...params);
@@ -1953,7 +2001,7 @@ Eventer.prototype.emitParallel = function (key, ...params) {
  * @param {number} max_listeners 最大监听器数量
  * @returns {Eventer} 返回当前实例，支持链式调用
  */
-Eventer.prototype.setMaxListeners = function (max_listeners) {
+Eventer.prototype.setMaxListeners = function (max_list) {
   if (typeof max_listeners !== 'number' || max_listeners < 0) {
     throw new Error('最大监听器数量必须是一个非负数');
   }
@@ -1971,7 +2019,7 @@ Eventer.prototype.onMany = function (events_map) {
     throw new Error('事件对象必须是一个非空对象');
   }
 
-  for (const event_name in events_map) {
+  for (let event_name in events_map) {
     if (events_map.has_own_property(event_name)) {
       this.on(event_name, events_map[event_name]);
     }
@@ -1988,11 +2036,11 @@ Eventer.prototype.onMany = function (events_map) {
  * @private
  */
 Eventer.prototype._parseKey = function (key) {
-  const parts = key.split(':');
+  let parts = key.split(':');
   if (parts.length === 1) {
     // 没有命名空间，使用默认命名空间
     return {
-      namespace: this.config.default_namespace,
+      namespace: this.config.default_name,
       key: key
     };
   } else if (parts.length === 2) {
@@ -2155,14 +2203,14 @@ Eventer.prototype._throttle = function (func, limit) {
   let last_func;
   let last_time = 0;
   return function () {
-    const ctx = this;
-    const args = arguments;
+    let ctx = this;
+    let args = arguments;
     if (!last_time) {
       func.apply(ctx, args);
       last_time = Date.now();
     } else {
       clearTimeout(last_func);
-      last_func = setTimeout(function () {
+      last_func = setTimeout(() => {
         if ((Date.now() - last_time) >= limit) {
           func.apply(ctx, args);
           last_time = Date.now();
@@ -2182,10 +2230,10 @@ Eventer.prototype._throttle = function (func, limit) {
 Eventer.prototype._debounce = function (func, wait) {
   let timeout;
   return function () {
-    const ctx = this;
-    const args = arguments;
+    let ctx = this;
+    let args = arguments;
     clearTimeout(timeout);
-    timeout = setTimeout(function () {
+    timeout = setTimeout(() => {
       func.apply(ctx, args);
     }, wait);
   };
@@ -2208,10 +2256,10 @@ Eventer.prototype.pause = function (key = '') {
   }
 
   // 解析关键字
-  const parsed = this._parseKey(key);
-  const namespace = parsed.namespace;
-  const event_key = parsed.key;
-  const full_key = `${namespace}:${event_key}`;
+  let parsed = this._parseKey(key);
+  let namespace = parsed.namespace;
+  let event_key = parsed.key;
+  let full_key = `${namespace}:${event_key}`;
 
   if (key) {
     return this._pauseEvent(full_key);
@@ -2266,10 +2314,10 @@ Eventer.prototype.resume = function (key = '') {
   }
 
   // 解析关键字
-  const parsed = this._parseKey(key);
-  const namespace = parsed.namespace;
-  const event_key = parsed.key;
-  const full_key = `${namespace}:${event_key}`;
+  let parsed = this._parseKey(key);
+  let namespace = parsed.namespace;
+  let event_key = parsed.key;
+  let full_key = `${namespace}:${event_key}`;
 
   if (key) {
     return this._resumeEvent(full_key);
@@ -2324,10 +2372,10 @@ Eventer.prototype.isPaused = function (key) {
   }
 
   // 解析关键字
-  const parsed = this._parseKey(key);
-  const namespace = parsed.namespace;
-  const event_key = parsed.key;
-  const full_key = `${namespace}:${event_key}`;
+  let parsed = this._parseKey(key);
+  let namespace = parsed.namespace;
+  let event_key = parsed.key;
+  let full_key = `${namespace}:${event_key}`;
 
   // 命名空间暂停检查
   if (this._paused_namespace.has(namespace)) {
@@ -2350,7 +2398,7 @@ Eventer.prototype.getPausedStatus = function () {
   return {
     global_paused: this._paused_global,
     paused_events: Array.from(this._paused),
-    paused_namespaces: Array.from(this._paused_namespace)
+    paused_namespaces: Array.from(this._paused_namespace), // eslint-disable-line mm_eslint/variable-name
   };
 };