mm_expand 2.3.6 → 2.3.8

package/lib/array.js

@@ -155,7 +155,7 @@ function createDescCnSort(field) {
 /**
  * 列表转树形列表
  * @param {string | object} idOrConfig 主键字段名或配置对象
- * @param id_or_config
+ * @param {string} id_or_config 主键字段名
  * @param {number} value 根节点值
  * @param {string} father_id 父节点字段名
  * @param {string} sub 子节点字段名

package/lib/date.js

@@ -18,14 +18,14 @@ Date.prototype.toStr = function (fm) {
     'q+': Math.floor((t.getMonth() + 3) / 3),
     'S': t.getMilliseconds()
   };
-  if (/(y+)/.test(format)) {
-    var x = RegExp.$1;
-    format = format.replace(x, (t.getFullYear() + '').substring(4 - x.length));
+  var yearMatch = format.match(/(y+)/);
+  if (yearMatch) {
+    format = format.replace(yearMatch[1], (t.getFullYear() + '').substring(4 - yearMatch[1].length));
   }
   for (var k in obj) {
-    if (new RegExp('(' + k + ')').test(format)) {
-      var x = RegExp.$1;
-      format = format.replace(x, x.length == 1 ? obj[k] : ('00' + obj[k]).substring(('' +
+    var match = format.match(new RegExp('(' + k + ')'));
+    if (match) {
+      format = format.replace(match[1], match[1].length == 1 ? obj[k] : ('00' + obj[k]).substring(('' +
   obj[k]).length));
     }
   }

package/lib/eventer.js

@@ -33,17 +33,17 @@ class Eventer {
     // 事件中间件
     this._middleware = [];
     // 命名空间映射
-    this._namespace = {};
-    // 事件链映射 { 'event1': ['event2', 'event3'], 'namespace:event1': ['event4'] }
+    this._space = {};
+    // 事件链映射 { 'event1': ['event2', 'event3'], 'space:event1': ['event4'] }
     this._chain = {};
     // 进行中的任务映射，用于取消操作
     this._tasks = new Map();
     // 暂停状态管理
     this._paused = new Set(); // 暂停的单个事件
-    this._paused_namespace = new Set(); // 暂停的命名空间
+    this._paused_space = new Set(); // 暂停的命名空间
     this._paused_global = false; // 全局暂停状态
     // 初始化默认命名空间
-    this._namespace[this.config.default_name] = true;
+    this._space[this.config.default_name] = true;
   }
 
   /**
@@ -95,14 +95,14 @@ Eventer.prototype.init = async function (...args) {
 
 /**
  * 监听事件（支持命名空间和优先级）
- * @param {string} key 事件关键字，支持namespace:key格式
+ * @param {string} key 事件关键字，支持space:key格式
  * @param {object} func 触发函数
  * @param {string} name 增加名称，方便删除，当出现相同名称时会被覆盖
  * @param {number} times 执行次数 -1为无限次执行
  * @param {number} priority 优先级，数字越小优先级越高，默认为0
  * @param {object} options 其他选项，如throttle、debounce、timeout等
  * @param {string} ns 可选的显式命名空间，优先级高于key中的命名空间
- * @returns {object} 返回事件信息对象 {namespace, index, name, remove}，remove为移除该事件的函数
+ * @returns {object} 返回事件信息对象 {space, index, name, remove}，remove为移除该事件的函数
  */
 Eventer.prototype._validateOnParams = function (key, func) {
   if (!key || typeof key !== 'string') {
@@ -115,19 +115,19 @@ Eventer.prototype._validateOnParams = function (key, func) {
 
 Eventer.prototype._parseEventKey = function (key, ns) {
   let parsed = this._parseKey(key);
-  let namespace = ns || parsed.namespace;
+  let space = ns || parsed.space;
   let event_key = parsed.key;
-  let full_key = `${namespace}:${event_key}`;
-  return { namespace, event_key, full_key };
+  let full_key = `${space}:${event_key}`;
+  return { space, event_key, full_key };
 };
 
-Eventer.prototype._initNamespace = function (namespace, event_key) {
-  if (!this._dict[namespace]) {
-    this._dict[namespace] = {};
-    this._namespace[namespace] = true;
+Eventer.prototype._initNamespace = function (space, event_key) {
+  if (!this._dict[space]) {
+    this._dict[space] = {};
+    this._space[space] = true;
   }
-  if (!this._dict[namespace][event_key]) {
-    this._dict[namespace][event_key] = [];
+  if (!this._dict[space][event_key]) {
+    this._dict[space][event_key] = [];
   }
 };
 
@@ -179,16 +179,16 @@ Eventer.prototype._findHandlerIndex = function (list, name) {
   return -1;
 };
 
-Eventer.prototype._checkListenerLimit = function (namespace, event_key, list) {
+Eventer.prototype._checkListenerLimit = function (space, event_key, list) {
   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() 方法可以增加限制。`);
+    this.log('warn', `警告: '${space}:${event_key}' 事件的监听器数量已达到 ${max_list}，可能导致内存泄漏。使用 set_max_listeners() 方法可以增加限制。`);
   }
 };
 
-Eventer.prototype._createHandlerResult = function (namespace, index, name, full_key) {
+Eventer.prototype._createHandlerResult = function (space, index, name, full_key) {
   return {
-    namespace,
+    space,
     index,
     name,
     /**
@@ -200,11 +200,11 @@ Eventer.prototype._createHandlerResult = function (namespace, index, name, full_
 
 /**
  * 监听事件（支持命名空间和优先级）
- * @param {string} key 事件关键字，支持namespace:key格式
+ * @param {string} key 事件关键字，支持space:key格式
  * @param {object} func 触发函数
  * @param {string} name 增加名称，方便删除，当出现相同名称时会被覆盖
  * @param {object} options 其他选项，如throttle、debounce、timeout等
- * @returns {object} 返回事件信息对象 {namespace, index, name, remove}，remove为移除该事件的函数
+ * @returns {object} 返回事件信息对象 {space, index, name, remove}，remove为移除该事件的函数
  */
 Eventer.prototype.on = function (key, func, name, options) {
   // 处理参数
@@ -241,10 +241,10 @@ Eventer.prototype._addEventHandler = function (params) {
     times: eventTimes, priority: eventPriority, ns } = params;
 
   // 解析命名空间
-  const { namespace, event_key, full_key } = this._parseEventKey(eventKey, ns);
+  const { space, event_key, full_key } = this._parseEventKey(eventKey, ns);
 
   // 初始化命名空间和事件数组
-  this._initNamespace(namespace, event_key);
+  this._initNamespace(space, event_key);
 
   // 设置默认名称
   let final_name = eventName || this._generateDefaultName(eventFunc);
@@ -262,7 +262,7 @@ Eventer.prototype._addEventHandler = function (params) {
   });
 
   // 处理事件添加逻辑
-  return this._handleEventAddition({ namespace, event_key, full_key, final_name, obj });
+  return this._handleEventAddition({ space, event_key, full_key, final_name, obj });
 };
 
 Eventer.prototype._extractOnParams = function (config) {
@@ -298,8 +298,8 @@ Eventer.prototype._processOnceParams = function (key, func, name, options) {
 };
 
 Eventer.prototype._handleEventAddition = function (config) {
-  const { namespace, event_key, full_key, final_name, obj } = config;
-  let list = this._dict[namespace][event_key];
+  const { space, event_key, full_key, final_name, obj } = config;
+  let list = this._dict[space][event_key];
   let idx = this._findHandlerIndex(list, final_name);
 
   if (idx >= 0) {
@@ -307,26 +307,26 @@ Eventer.prototype._handleEventAddition = function (config) {
     Object.assign(list[idx], obj);
     // 重新排序
     this._sort(list);
-    return this._createHandlerResult(namespace, idx, final_name, full_key);
+    return this._createHandlerResult(space, idx, final_name, full_key);
   } else {
     // 检查监听器数量是否超过限制
-    this._checkListenerLimit(namespace, event_key, list);
+    this._checkListenerLimit(space, event_key, list);
 
     // 添加新事件
     list.push(obj);
     // 按优先级排序
     this._sort(list);
-    return this._createHandlerResult(namespace, list.length - 1, final_name, full_key);
+    return this._createHandlerResult(space, list.length - 1, final_name, full_key);
   }
 };
 
 /**
  * 监听事件(仅执行一次)
- * @param {string | object} key 事件关键，支持namespace:key格式，或配置对象
+ * @param {string | object} key 事件关键，支持space:key格式，或配置对象
  * @param {object} func 触发函数
  * @param {string} name 增加名称，方便删除，当出现相同名称时会被覆盖
  * @param {object} options 其他选项
- * @returns {object} 返回事件信息对象 {namespace, idx, name}
+ * @returns {object} 返回事件信息对象 {space, idx, name}
  */
 Eventer.prototype.once = function (key, func, name, options) {
   // 处理参数
@@ -341,7 +341,7 @@ Eventer.prototype.once = function (key, func, name, options) {
 
 /**
  * 统一的事件执行引擎
- * @param {string} key 事件关键字，支持namespace:key格式
+ * @param {string} key 事件关键字，支持space:key格式
  * @param {object} options 执行选项
  * @param  {...any} params 传递参数
  * @returns {Promise<object>} 返回包含results和cancel方法的对象
@@ -355,13 +355,13 @@ Eventer.prototype._validateExec = function (key) {
 
 Eventer.prototype._createCtx = function (key, params) {
   let parsed = this._parseKey(key);
-  let namespace = parsed.namespace;
+  let space = parsed.space;
   let event_key = parsed.key;
-  let full_key = `${namespace}:${event_key}`;
+  let full_key = `${space}:${event_key}`;
   let start_time = Date.now();
 
   const ctx = {
-    namespace,
+    space,
     event: event_key,
     full_event: full_key,
     params,
@@ -379,7 +379,7 @@ Eventer.prototype._createCtx = function (key, params) {
     }
   };
 
-  return { ctx, namespace, event_key, full_key, start_time };
+  return { ctx, space, event_key, full_key, start_time };
 };
 
 Eventer.prototype._cancelTasks = function (full_key) {
@@ -419,7 +419,7 @@ Eventer.prototype._runBeforeMiddleware = async function (ctx, full_key) {
     }
     return false;
   } catch (error) {
-    this.log('error', `事件中间件执行失败 [${ctx.namespace}:${ctx.event}]`, error);
+    this.log('error', `事件中间件执行失败 [${ctx.space}:${ctx.event}]`, error);
     if (this.config.error_handler && typeof this.config.error_handler === 'function') {
       this.config.error_handler(error, { type: 'middleware', stage: 'before', ctx });
     }
@@ -459,28 +459,28 @@ Eventer.prototype._executeStrategy = async function (config) {
   }
 };
 
-Eventer.prototype._removeEvents = function (namespace, key, arr) {
+Eventer.prototype._removeEvents = function (space, key, arr) {
   try {
     for (let i = 0; i < arr.length; i++) {
-      this.del(`${namespace}:${key}`, arr[i]);
+      this.del(`${space}:${key}`, arr[i]);
     }
   } catch (remove_error) {
-    this.log('error', `事件移除失败 [${namespace}:${key}]`, remove_error);
+    this.log('error', `事件移除失败 [${space}:${key}]`, remove_error);
   }
 };
 
-Eventer.prototype._autoCleanup = function (namespace, key) {
+Eventer.prototype._autoCleanup = function (space, key) {
   try {
-    if (this.config.auto_clean && this._dict[namespace] && this._dict[namespace][key] &&
-      this._dict[namespace][key].length === 0) {
-      delete this._dict[namespace][key];
-      if (this._dict[namespace] && Object.keys(this._dict[namespace]).length === 0) {
-        delete this._dict[namespace];
-        delete this._namespace[namespace];
+    if (this.config.auto_clean && this._dict[space] && this._dict[space][key] &&
+      this._dict[space][key].length === 0) {
+      delete this._dict[space][key];
+      if (this._dict[space] && Object.keys(this._dict[space]).length === 0) {
+        delete this._dict[space];
+        delete this._space[space];
       }
     }
   } catch (cleanup_error) {
-    this.log('error', `自动清理失败 [${namespace}:${key}]`, cleanup_error);
+    this.log('error', `自动清理失败 [${space}:${key}]`, cleanup_error);
   }
 };
 
@@ -490,7 +490,7 @@ Eventer.prototype._runAfterMiddleware = async function (ctx, start_time) {
     ctx.duration = ctx.end_time - start_time;
     await this._runMiddleware('after', ctx);
   } catch (error) {
-    this.log('error', `事件后置中间件执行失败 [${ctx.namespace}:${ctx.event}]`, error);
+    this.log('error', `事件后置中间件执行失败 [${ctx.space}:${ctx.event}]`, error);
     if (this.config.error_handler && typeof this.config.error_handler === 'function') {
       this.config.error_handler(error, { type: 'middleware', stage: 'after', ctx });
     }
@@ -537,18 +537,18 @@ Eventer.prototype._buildSafeResult = function (ctx) {
 Eventer.prototype._execute = async function (key, options = {}, ...params) {
   this._validateExec(key);
 
-  const { ctx, namespace, event_key, full_key, start_time } = this._createCtx(key, params);
+  const { ctx, space, event_key, full_key, start_time } = this._createCtx(key, params);
 
   if (this.isPaused(full_key)) {
     return this._createPausedResult();
   }
 
-  let list = this._dict[namespace] && this._dict[namespace][event_key];
+  let list = this._dict[space] && this._dict[space][event_key];
   const arr = [];
 
   if (list && list.length > 0) {
     await this._executeEventList({
-      list, params, ctx, full_key, arr, options, namespace, event_key, start_time
+      list, params, ctx, full_key, arr, options, space, event_key, start_time
     });
   }
 
@@ -582,13 +582,13 @@ Eventer.prototype._createPausedResult = function () {
  * @param {string} config.full_key 完整键名
  * @param {Array} config.arr 数组
  * @param {object} config.options 选项
- * @param {string} config.namespace 命名空间
+ * @param {string} config.space 命名空间
  * @param {string} config.event_key 事件键
  * @param {number} config.start_time 开始时间
  * @private
  */
 Eventer.prototype._executeEventList = async function (config) {
-  const { list, params, ctx, full_key, arr, options, namespace, event_key, start_time } = config;
+  const { list, params, ctx, full_key, arr, options, space, event_key, start_time } = config;
 
   this._initTaskList(full_key);
 
@@ -604,8 +604,8 @@ Eventer.prototype._executeEventList = async function (config) {
   await this._executeStrategy({ list, params, ctx, full_key, arr, options });
 
   this._cleanupTasks(full_key);
-  this._removeEvents(namespace, event_key, arr);
-  this._autoCleanup(namespace, event_key);
+  this._removeEvents(space, event_key, arr);
+  this._autoCleanup(space, event_key);
   await this._runAfterMiddleware(ctx, start_time);
 };
 
@@ -685,7 +685,7 @@ Eventer.prototype._handleSuccessResult = function (config) {
 
 Eventer.prototype._handleTaskError = function (e, o, ctx, task) {
   ctx.error_count++;
-  this.log('error', `事件执行失败 [${ctx.namespace}:${ctx.event}] - ${o.name}`, e);
+  this.log('error', `事件执行失败 [${ctx.space}:${ctx.event}] - ${o.name}`, e);
 
   const error_result = {
     _error: true,
@@ -828,7 +828,7 @@ Eventer.prototype._handleWfSuccess = function (config) {
 Eventer.prototype._handleWfError = function (config) {
   const { e, obj, ctx, task } = config;
   ctx.error_count++;
-  this.log('error', `事件执行失败 [${ctx.namespace}:${ctx.event}] - ${obj.name}`, e);
+  this.log('error', `事件执行失败 [${ctx.space}:${ctx.event}] - ${obj.name}`, e);
 
   const error_result = {
     _error: true,
@@ -935,7 +935,7 @@ Eventer.prototype._handleRaceSuccess = function (config) {
 
 Eventer.prototype._handleRaceError = function (e, obj, ctx, task) {
   ctx.error_count++;
-  this.log('error', `事件执行失败 [${ctx.namespace}:${ctx.event}] - ${obj.name}`, e);
+  this.log('error', `事件执行失败 [${ctx.space}:${ctx.event}] - ${obj.name}`, e);
 
   const error_result = {
     _error: true,
@@ -1039,7 +1039,7 @@ Eventer.prototype._handleTaskError = function (config) {
 
 /**
  * 执行事件（支持中间件和命名空间）
- * @param {string} key 事件关键字，支持namespace:key格式
+ * @param {string} key 事件关键字，支持space:key格式
  * @param {object} params 传递参数
  * @returns {Promise<object>} 返回包含results和cancel方法的对象
  */
@@ -1049,7 +1049,7 @@ Eventer.prototype.run = async function (key, ...params) {
 
 /**
  * 触发事件
- * @param {string} key 事件关键，支持namespace:key格式
+ * @param {string} key 事件关键，支持space:key格式
  * @param {object} params 传递参数
  * @returns {Promise<object>} 返回包含results和cancel方法的对象
  */
@@ -1089,7 +1089,7 @@ Eventer.prototype.emit = function (key, ...params) {
 
 /**
  * 异步触发事件，按顺序执行等待完成
- * @param {string} key 事件关键字，支持namespace:key格式
+ * @param {string} key 事件关键字，支持space:key格式
  * @param  {...any} args 事件参数
  * @returns {Promise} - 事件触发结果
  */
@@ -1105,7 +1105,7 @@ Eventer.prototype.emitWait = async function (key, ...args) {
 
 /**
  * 异步触发事件，并发执行不等待
- * @param {string} key 事件关键字，支持namespace:key格式
+ * @param {string} key 事件关键字，支持space:key格式
  * @param  {...any} args 事件参数
  * @returns {boolean} - 是否有监听者
  */
@@ -1121,12 +1121,12 @@ Eventer.prototype.emitAsync = async function (key, ...args) {
 Eventer.prototype._execAsync = function (key, args) {
   // 解析命名空间
   let parsed = this._parseKey(key);
-  let namespace = parsed.namespace;
+  let space = parsed.space;
   let event_key = parsed.key;
-  let full_key = `${namespace}:${event_key}`;
+  let full_key = `${space}:${event_key}`;
 
   // 获取事件列表
-  let list = this._dict[namespace] && this._dict[namespace][event_key];
+  let list = this._dict[space] && this._dict[space][event_key];
 
   if (!list || list.length === 0) {
     return false;
@@ -1174,7 +1174,7 @@ Eventer.prototype._handleSyncError = function (sync_error, full_key, args) {
 
 /**
  * 异步触发事件，并发执行等待完成
- * @param {string} key 事件关键字，支持namespace:key格式
+ * @param {string} key 事件关键字，支持space:key格式
  * @param  {...any} args 事件参数
  * @returns {Promise<Array>} - 所有监听器的执行结果
  */
@@ -1190,7 +1190,7 @@ Eventer.prototype.emitAll = async function (key, ...args) {
 
 /**
  * 异步触发事件，竞争执行
- * @param {string} key 事件关键字，支持namespace:key格式
+ * @param {string} key 事件关键字，支持space:key格式
  * @param  {...any} args 事件参数
  * @returns {Promise} - 第一个完成的结果
  */
@@ -1206,19 +1206,18 @@ Eventer.prototype.emitRace = async function (key, ...args) {
 
 /**
  * 异步触发事件，返回第一个有返回值的结果（不阻塞其他监听器）
- * @param {string} key 事件关键字，支持namespace:key格式
+ * @param {string} key 事件关键字，支持space:key格式
  * @param  {...any} args 事件参数
  * @returns {Promise} - 第一个有返回值（非 undefined）的监听器结果
- * 所有监听器并行执行，返回第一个有返回值（非 undefined）的结果，
- *               返回 undefined 的监听器被跳过，其他监听器继续在后台执行不受影响
+ * 所有监听器并行执行，返回第一个有返回值（非 undefined）的结果，返回 undefined 的监听器被跳过，其他监听器继续在后台执行不受影响
  */
 Eventer.prototype.emitFirst = async function (key, ...args) {
   try {
     let parsed = this._parseKey(key);
-    let namespace = parsed.namespace;
+    let space = parsed.space;
     let event_key = parsed.key;
 
-    let list = this._dict[namespace] && this._dict[namespace][event_key];
+    let list = this._dict[space] && this._dict[space][event_key];
     if (!list || list.length === 0) {
       return undefined;
     }
@@ -1253,7 +1252,7 @@ Eventer.prototype.emitFirst = async function (key, ...args) {
 
 /**
  * 异步触发事件，瀑布流执行
- * @param {string} key 事件关键字，支持namespace:key格式
+ * @param {string} key 事件关键字，支持space:key格式
  * @param {*} value 初始值
  * @param  {...any} args 事件参数
  * @returns {Promise} - 最后一个事件监听者的结果
@@ -1271,20 +1270,14 @@ Eventer.prototype.emitWaterfall = async function (key, value, ...args) {
   }
 };
 
-/**
- * 触发所有命名空间的特定事件
- * @param {string} key 事件关键字（不含命名空间）
- * @param {object} params 传递参数
- * @returns {Promise<object>} 返回各命名空间的执行结果 {namespace1: results1, namespace2: results2}
- */
 /**
  * 确保命名空间在映射中
  * @private
  * @param {string} name 命名空间名称
  */
 Eventer.prototype._ensureNs = function (name) {
-  if (!this._namespace[name]) {
-    this._namespace[name] = true;
+  if (!this._space[name]) {
+    this._space[name] = true;
   }
 };
 
@@ -1298,7 +1291,7 @@ Eventer.prototype._ensureNs = function (name) {
  */
 Eventer.prototype._execNsEvents = async function (name, key, params) {
   let list = this._dict[name][key];
-  const namespace_results = [];
+  const space_results = [];
   const arr = []; // 存储需要移除的事件
 
   // 执行事件处理函数
@@ -1307,7 +1300,7 @@ Eventer.prototype._execNsEvents = async function (name, key, params) {
       let obj = list[i];
       // 执行事件处理函数
       let result = await obj.func.apply(obj, params);
-      namespace_results.push(result);
+      space_results.push(result);
 
       // 处理执行次数限制
       if (obj.times >= 0) {
@@ -1319,7 +1312,7 @@ Eventer.prototype._execNsEvents = async function (name, key, params) {
     } catch (e) {
       // 记录错误但不中断执行
       this.log('error', `事件执行失败 [${name}:${key}] - ${list[i].name}`, e);
-      namespace_results.push({
+      space_results.push({
         _error: true,
         error: e,
         handler: list[i].name
@@ -1347,7 +1340,7 @@ Eventer.prototype.emitAllNamespaces = async function (key, ...params) {
   const results = {};
   // 确保遍历所有命名空间，包括动态创建的
   for (let name in this._dict) {
-    // 确保命名空间在namespace映射中
+    // 确保命名空间在space映射中
     this._ensureNs(name);
 
     // 检查该命名空间下是否存在该事件
@@ -1392,20 +1385,20 @@ Eventer.prototype._removeSingleEvent = function (events, index_or_name) {
 /**
  * 删除整个事件
  * @private
- * @param {string} namespace 命名空间
+ * @param {string} space 命名空间
  * @param {string} key 事件关键字
  * @param {string} event_key 事件键
  * @param {string} full_key 完整事件关键字
  * @returns {boolean} 删除成功返回true
  */
-Eventer.prototype._removeEntireEvent = function (namespace, event_key, full_key) {
+Eventer.prototype._removeEntireEvent = function (space, event_key, full_key) {
   // 安全检查：确保命名空间和事件存在
-  if (!this._dict[namespace] || !this._dict[namespace][event_key]) {
+  if (!this._dict[space] || !this._dict[space][event_key]) {
     return false;
   }
 
   // 删除整个事件
-  delete this._dict[namespace][event_key];
+  delete this._dict[space][event_key];
 
   // 清理相关的事件链
   if (this._chain) {
@@ -1425,39 +1418,39 @@ Eventer.prototype._removeEntireEvent = function (namespace, event_key, full_key)
 /**
  * 自动清理空的事件列表和命名空间
  * @private
- * @param {string} namespace 命名空间
+ * @param {string} space 命名空间
  * @param {string} key 事件关键字
  * @param {Array} events 事件列表
  * @param {string | number} index_or_name 事件索引或名称
  */
-Eventer.prototype._autoCleanEvents = function (namespace, key, events, index_or_name) {
+Eventer.prototype._autoCleanEvents = function (space, key, events, index_or_name) {
   if (!this.config.auto_clean) return;
 
   // 安全检查：确保命名空间存在
-  if (!this._dict[namespace]) {
+  if (!this._dict[space]) {
     return;
   }
 
   // 清理空的事件列表
   if (index_or_name && events && events.length === 0) {
     // 安全检查：确保事件键存在
-    if (this._dict[namespace][key]) {
-      delete this._dict[namespace][key];
+    if (this._dict[space][key]) {
+      delete this._dict[space][key];
     }
   }
 
   // 如果命名空间为空，则删除命名空间
-  if (this._dict[namespace] && Object.keys(this._dict[namespace]).length === 0) {
-    delete this._dict[namespace];
-    if (this._namespace && this._namespace[namespace]) {
-      delete this._namespace[namespace];
+  if (this._dict[space] && Object.keys(this._dict[space]).length === 0) {
+    delete this._dict[space];
+    if (this._space && this._space[space]) {
+      delete this._space[space];
     }
   }
 };
 
 /**
  * 删除事件
- * @param {string} key 事件关键字，支持namespace:key格式
+ * @param {string} key 事件关键字，支持space:key格式
  * @param {number | string} index_or_name 事件集索引或名称
  * @returns {boolean} 删除成功返回true，否则返回false
  */
@@ -1469,16 +1462,16 @@ Eventer.prototype.off = function (key, index_or_name) {
 
   // 解析命名空间
   let parsed = this._parseKey(key);
-  let namespace = parsed.namespace;
+  let space = parsed.space;
   let event_key = parsed.key;
-  let full_key = `${namespace}:${event_key}`;
+  let full_key = `${space}:${event_key}`;
 
   // 检查事件是否存在
-  if (!this._dict[namespace] || !this._dict[namespace][event_key]) {
+  if (!this._dict[space] || !this._dict[space][event_key]) {
     return false;
   }
 
-  let events = this._dict[namespace][event_key];
+  let events = this._dict[space][event_key];
   let removed = false;
 
   if (index_or_name) {
@@ -1486,12 +1479,12 @@ Eventer.prototype.off = function (key, index_or_name) {
     removed = this._removeSingleEvent(events, index_or_name);
   } else {
     // 删除整个事件
-    removed = this._removeEntireEvent(namespace, event_key, full_key);
+    removed = this._removeEntireEvent(space, event_key, full_key);
   }
 
   // 自动清理
   if (removed) {
-    this._autoCleanEvents(namespace, event_key, events, index_or_name);
+    this._autoCleanEvents(space, event_key, events, index_or_name);
   }
 
   return removed;
@@ -1510,22 +1503,22 @@ Eventer.prototype.clearNamespace = function (name) {
     return false;
   }
   delete this._dict[name];
-  delete this._namespace[name];
+  delete this._space[name];
   return true;
 };
 
 /**
  * 获取事件列表
- * @param {string} key 事件关键字，如果为空则获取所有事件，支持namespace:key格式
+ * @param {string} key 事件关键字，如果为空则获取所有事件，支持space:key格式
  * @returns {Array | object} 返回事件列表或所有事件对象
  */
 Eventer.prototype.getEvents = function (key) {
   if (key) {
     // 解析命名空间
-    const { namespace, key: event_key } = this._parseKey(key);
-    return this._dict[namespace] &&
+    const { space, key: event_key } = this._parseKey(key);
+    return this._dict[space] &&
 
-      this._dict[namespace][event_key] ? [...this._dict[namespace][event_key]] : [];
+      this._dict[space][event_key] ? [...this._dict[space][event_key]] : [];
   }
   // 返回深拷贝的所有事件
   const result = {};
@@ -1543,15 +1536,15 @@ Eventer.prototype.getEvents = function (key) {
  * @returns {Array} 返回所有命名空间数组
  */
 Eventer.prototype.getNamespace = function () {
-  return Object.keys(this._namespace);
+  return Object.keys(this._space);
 };
 
 /**
  * 清空所有事件和资源
- * @param {boolean} keepnamespace 是否保留命名空间定义，默认false
+ * @param {boolean} keep_space 是否保留命名空间定义，默认false
  * @returns {Eventer} 返回当前实例，支持链式调用
  */
-Eventer.prototype.clear = function (keepnamespace = false) {
+Eventer.prototype.clear = function (keep_space = false) {
   // 取消所有进行中的任务
   if (this._tasks) {
     this._tasks.forEach((tasks, key) => {
@@ -1574,16 +1567,16 @@ Eventer.prototype.clear = function (keepnamespace = false) {
   if (this._paused) {
     this._paused.clear();
   }
-  if (this._paused_namespace) {
-    this._paused_namespace.clear();
+  if (this._paused_space) {
+    this._paused_space.clear();
   }
   this._paused_global = false;
 
   // 保留命名空间定义
-  if (!keepnamespace) {
-    this._namespace = {};
+  if (!keep_space) {
+    this._space = {};
     // 重新初始化默认命名空间
-    this._namespace[this.config.default_name] = true;
+    this._space[this.config.default_name] = true;
   }
 
   return this;
@@ -1591,22 +1584,22 @@ Eventer.prototype.clear = function (keepnamespace = false) {
 
 /**
  * 检查事件是否存在
- * @param {string} key 事件关键字，支持namespace:key格式
+ * @param {string} key 事件关键字，支持space:key格式
  * @param {string} name 事件名称（可选）
  * @returns {boolean} 事件存在返回true，否则返回false
  */
 Eventer.prototype.has = function (key, name) {
   // 解析命名空间
   let parsed = this._parseKey(key);
-  let namespace = parsed.namespace;
+  let space = parsed.space;
   let event_key = parsed.key;
 
-  if (!this._dict[namespace] || !this._dict[namespace][event_key]) {
+  if (!this._dict[space] || !this._dict[space][event_key]) {
     return false;
   }
 
   if (name) {
-    let list = this._dict[namespace][event_key];
+    let list = this._dict[space][event_key];
     for (let i = 0; i < list.length; i++) {
       if (list[i].name === name) {
         return true;
@@ -1620,7 +1613,7 @@ Eventer.prototype.has = function (key, name) {
 
 /**
  * 获取事件数量
- * @param {string} key 事件关键字，如果为空则获取所有事件数量，支持namespace:key格式或namespace:*格式
+ * @param {string} key 事件关键字，如果为空则获取所有事件数量，支持space:key格式或space:*格式
  * @returns {number} 返回事件数量
  */
 Eventer.prototype.count = function (key) {
@@ -1628,11 +1621,11 @@ Eventer.prototype.count = function (key) {
     // 解析可能的命名空间模式
     if (key.ends_with(':*')) {
       // 统计命名空间下所有事件
-      let namespace = key.split(':')[0];
-      if (this._dict[namespace]) {
+      let space = key.split(':')[0];
+      if (this._dict[space]) {
         let total = 0;
-        for (let key in this._dict[namespace]) {
-          total += this._dict[namespace][key].length;
+        for (let key in this._dict[space]) {
+          total += this._dict[space][key].length;
         }
         return total;
       }
@@ -1640,10 +1633,10 @@ Eventer.prototype.count = function (key) {
     }
 
     // 解析具体事件
-    const { namespace, key: event_key } = this._parseKey(key);
-    return this._dict[namespace] &&
+    const { space, key: event_key } = this._parseKey(key);
+    return this._dict[space] &&
 
-      this._dict[namespace][event_key] ? this._dict[namespace][event_key].length : 0;
+      this._dict[space][event_key] ? this._dict[space][event_key].length : 0;
   }
 
   // 统计所有事件
@@ -1679,7 +1672,7 @@ Eventer.prototype.use = function (type, middleware) {
 
 /**
  * 添加事件链式触发关系
- * @param {string} from_event 源事件，支持namespace:key格式
+ * @param {string} from_event 源事件，支持space:key格式
  * @param {string | Array} to_events 目标事件，可以是单个事件或事件数组
  * @returns {Eventer} 返回当前实例，支持链式调用
  */
@@ -1706,8 +1699,8 @@ Eventer.prototype._validateChainInput = function (from_event, to_events) {
 };
 
 Eventer.prototype._getFullEventKey = function (event) {
-  const { namespace, key } = this._parseKey(event);
-  return `${namespace}:${key}`;
+  const { space, key } = this._parseKey(event);
+  return `${space}:${key}`;
 };
 
 Eventer.prototype._initEventChain = function (full_from_event) {
@@ -1741,7 +1734,7 @@ Eventer.prototype._addTargetEvent = function (full_from_event, to_event) {
 
 /**
  * 移除事件链式触发关系
- * @param {string} from_event 源事件，支持namespace:key格式
+ * @param {string} from_event 源事件，支持space:key格式
  * @param {string | Array} to_events 目标事件，可以是单个事件或事件数组（可选，不提供则移除所有关联）
  * @returns {Eventer} 返回当前实例，支持链式调用
  */
@@ -1752,8 +1745,8 @@ Eventer.prototype.unchain = function (from_event, to_events) {
   }
 
   // 解析源事件
-  const { namespace: from_namespace, key: fromkey } = this._parseKey(from_event);
-  let full_from_event = `${from_namespace}:${fromkey}`;
+  const { space: from_space, key: fromkey } = this._parseKey(from_event);
+  let full_from_event = `${from_space}:${fromkey}`;
 
   // 如果源事件不存在事件链，直接返回
   if (!this._chain[full_from_event]) {
@@ -1789,8 +1782,8 @@ Eventer.prototype._removeTargetEvent = function (full_from_event, to_event) {
   }
 
   // 解析目标事件
-  const { namespace: to_namespace, key: tokey } = this._parseKey(to_event);
-  let full_to_event = `${to_namespace}:${tokey}`;
+  const { space: to_space, key: tokey } = this._parseKey(to_event);
+  let full_to_event = `${to_space}:${tokey}`;
 
   // 检查事件链是否存在
   if (!this._chain[full_from_event]) {
@@ -1810,7 +1803,7 @@ Eventer.prototype._removeTargetEvent = function (full_from_event, to_event) {
 
 /**
  * 获取事件链
- * @param {string} event 事件关键字，支持namespace:key格式
+ * @param {string} event 事件关键字，支持space:key格式
  * @returns {Array} 返回事件链数组
  */
 Eventer.prototype.getChains = function (event) {
@@ -1819,8 +1812,8 @@ Eventer.prototype.getChains = function (event) {
   }
 
   // 解析事件
-  const { namespace, key } = this._parseKey(event);
-  let full_event = `${namespace}:${key}`;
+  const { space, key } = this._parseKey(event);
+  let full_event = `${space}:${key}`;
 
   return this._chain[full_event] ? [...this._chain[full_event]] : [];
 };
@@ -1852,12 +1845,12 @@ Eventer.prototype._triggerChain = async function (current_event, params) {
  */
 Eventer.prototype._execChainItem = async function (key, params) {
   // 解析命名空间
-  const { namespace, key: innerkey } = this._parseKey(key);
-  let list = this._dict[namespace] && this._dict[namespace][innerkey];
+  const { space, key: innerkey } = this._parseKey(key);
+  let list = this._dict[space] && this._dict[space][innerkey];
   const results = [];
 
   // 创建上下文对象
-  let ctx = this._createChainContext(namespace, innerkey, key, params);
+  let ctx = this._createChainContext(space, innerkey, key, params);
 
   // 如果有事件处理函数，执行它们
   if (list && list.length > 0) {
@@ -1872,10 +1865,10 @@ Eventer.prototype._execChainItem = async function (key, params) {
   return results;
 };
 
-Eventer.prototype._createChainContext = function (namespace, innerkey, key, params) {
+Eventer.prototype._createChainContext = function (space, innerkey, key, params) {
   let start_time = Date.now();
   return {
-    namespace,
+    space,
     event: innerkey,
     full_event: key,
     params,
@@ -1905,7 +1898,7 @@ Eventer.prototype._runChainMiddleware = async function (type, ctx) {
     }
     await this._runMiddleware(type, ctx);
   } catch (error) {
-    this.log('error', `事件链${type}中间件执行失败 [${ctx.namespace}:${ctx.event}]`, error);
+    this.log('error', `事件链${type}中间件执行失败 [${ctx.space}:${ctx.event}]`, error);
   }
 };
 
@@ -1935,14 +1928,14 @@ Eventer.prototype._handleChainTimes = function (obj, ctx) {
   if (obj.times >= 0) {
     obj.times--;
     if (obj.times <= 0) {
-      this.del(`${ctx.namespace}:${ctx.event}`, obj.name);
+      this.del(`${ctx.space}:${ctx.event}`, obj.name);
     }
   }
 };
 
 Eventer.prototype._handleChainError = function (e, obj, ctx, results) {
   ctx.error_count++;
-  this.log('error', `事件链执行失败 [${ctx.namespace}:${ctx.event}] - ${obj.name}`, e);
+  this.log('error', `事件链执行失败 [${ctx.space}:${ctx.event}] - ${obj.name}`, e);
 
   const error_result = {
     _error: true,
@@ -1956,7 +1949,7 @@ Eventer.prototype._handleChainError = function (e, obj, ctx, results) {
 
 /**
  * 并行执行事件（提高性能）
- * @param {string} key 事件关键字，支持namespace:key格式
+ * @param {string} key 事件关键字，支持space:key格式
  * @param {object} params 传递参数
  * @param {object} options 执行选项，如concurrency（并发数限制）
  * @returns {Promise<object>} 返回包含results和cancel方法的对象
@@ -1975,7 +1968,7 @@ Eventer.prototype.runParallel = async function (key, ...params) {
 
 /**
  * 并行触发事件
- * @param {string} key 事件关键字，支持namespace:key格式
+ * @param {string} key 事件关键字，支持space:key格式
  * @param {object} params 传递参数
  * @param {object} options 执行选项，如concurrency（并发数限制）
  * @returns {Promise<object>} 返回包含results和cancel方法的对象
@@ -2032,7 +2025,7 @@ Eventer.prototype.onMany = function (events_map) {
 /**
  * 解析事件键，提取命名空间和事件键
  * @param {string} key 事件关键字
- * @returns {object} 包含namespace和key的对象
+ * @returns {object} 包含space和key的对象
  * @private
  */
 Eventer.prototype._parseKey = function (key) {
@@ -2040,19 +2033,19 @@ Eventer.prototype._parseKey = function (key) {
   if (parts.length === 1) {
     // 没有命名空间，使用默认命名空间
     return {
-      namespace: this.config.default_name,
+      space: this.config.default_name,
       key: key
     };
   } else if (parts.length === 2) {
     // 有命名空间
     return {
-      namespace: parts[0],
+      space: parts[0],
       key: parts[1]
     };
   } else {
     // 多个冒号，将第一个作为命名空间，其余作为事件键
     return {
-      namespace: parts[0],
+      space: parts[0],
       key: parts.slice(1).join(':')
     };
   }
@@ -2152,11 +2145,11 @@ Eventer.prototype._triggerChainEvent = async function (key, current_event, param
 };
 
 Eventer.prototype._createChainCtx = function (key, current_event, params) {
-  var { namespace, key: innerkey } = this._parseKey(key);
-  var fullkey = `${namespace}:${innerkey}`;
+  var { space, key: innerkey } = this._parseKey(key);
+  var fullkey = `${space}:${innerkey}`;
 
   return {
-    namespace,
+    space,
     event: innerkey,
     full_event: fullkey,
     params,
@@ -2242,7 +2235,7 @@ Eventer.prototype._debounce = function (func, wait) {
 
 /**
  * 暂停事件执行
- * @param {string} key 事件关键字或命名空间，支持namespace:key格式，为空表示全局暂停
+ * @param {string} key 事件关键字或命名空间，支持space:key格式，为空表示全局暂停
  * @returns {boolean} 是否成功暂停
  */
 Eventer.prototype.pause = function (key = '') {
@@ -2257,14 +2250,14 @@ Eventer.prototype.pause = function (key = '') {
 
   // 解析关键字
   let parsed = this._parseKey(key);
-  let namespace = parsed.namespace;
+  let space = parsed.space;
   let event_key = parsed.key;
-  let full_key = `${namespace}:${event_key}`;
+  let full_key = `${space}:${event_key}`;
 
   if (key) {
     return this._pauseEvent(full_key);
   } else {
-    return this._pauseNamespace(namespace);
+    return this._pauseNamespace(space);
   }
 };
 
@@ -2288,19 +2281,19 @@ Eventer.prototype._pauseEvent = function (full_key) {
   return true;
 };
 
-Eventer.prototype._pauseNamespace = function (namespace) {
-  if (this._paused_namespace.has(namespace)) {
-    this.log('warn', `命名空间 '${namespace}' 已处于暂停状态`);
+Eventer.prototype._pauseNamespace = function (space) {
+  if (this._paused_space.has(space)) {
+    this.log('warn', `命名空间 '${space}' 已处于暂停状态`);
     return false;
   }
-  this._paused_namespace.add(namespace);
-  this.log('info', `命名空间 '${namespace}' 已暂停`);
+  this._paused_space.add(space);
+  this.log('info', `命名空间 '${space}' 已暂停`);
   return true;
 };
 
 /**
  * 恢复事件执行
- * @param {string} key 事件关键字或命名空间，支持namespace:key格式，为空表示恢复全局暂停
+ * @param {string} key 事件关键字或命名空间，支持space:key格式，为空表示恢复全局暂停
  * @returns {boolean} 是否成功恢复
  */
 Eventer.prototype.resume = function (key = '') {
@@ -2315,14 +2308,14 @@ Eventer.prototype.resume = function (key = '') {
 
   // 解析关键字
   let parsed = this._parseKey(key);
-  let namespace = parsed.namespace;
+  let space = parsed.space;
   let event_key = parsed.key;
-  let full_key = `${namespace}:${event_key}`;
+  let full_key = `${space}:${event_key}`;
 
   if (key) {
     return this._resumeEvent(full_key);
   } else {
-    return this._resumeNamespace(namespace);
+    return this._resumeNamespace(space);
   }
 };
 
@@ -2346,19 +2339,19 @@ Eventer.prototype._resumeEvent = function (full_key) {
   return true;
 };
 
-Eventer.prototype._resumeNamespace = function (namespace) {
-  if (!this._paused_namespace.has(namespace)) {
-    this.log('warn', `命名空间 '${namespace}' 未处于暂停状态`);
+Eventer.prototype._resumeNamespace = function (space) {
+  if (!this._paused_space.has(space)) {
+    this.log('warn', `命名空间 '${space}' 未处于暂停状态`);
     return false;
   }
-  this._paused_namespace.delete(namespace);
-  this.log('info', `命名空间 '${namespace}' 已恢复`);
+  this._paused_space.delete(space);
+  this.log('info', `命名空间 '${space}' 已恢复`);
   return true;
 };
 
 /**
  * 检查事件是否被暂停
- * @param {string} key 事件关键字，支持namespace:key格式
+ * @param {string} key 事件关键字，支持space:key格式
  * @returns {boolean} 是否被暂停
  */
 Eventer.prototype.isPaused = function (key) {
@@ -2373,12 +2366,12 @@ Eventer.prototype.isPaused = function (key) {
 
   // 解析关键字
   let parsed = this._parseKey(key);
-  let namespace = parsed.namespace;
+  let space = parsed.space;
   let event_key = parsed.key;
-  let full_key = `${namespace}:${event_key}`;
+  let full_key = `${space}:${event_key}`;
 
   // 命名空间暂停检查
-  if (this._paused_namespace.has(namespace)) {
+  if (this._paused_space.has(space)) {
     return true;
   }
 
@@ -2398,7 +2391,7 @@ Eventer.prototype.getPausedStatus = function () {
   return {
     global_paused: this._paused_global,
     paused_events: Array.from(this._paused),
-    paused_namespaces: Array.from(this._paused_namespace), // eslint-disable-line mm_eslint/variable-name
+    paused_spaces: Array.from(this._paused_space), // eslint-disable-line mm_eslint/variable-name
   };
 };
 
@@ -2424,8 +2417,8 @@ Eventer.prototype.clearPaused = function () {
     cleared = true;
   }
 
-  if (this._paused_namespace.size > 0) {
-    this._paused_namespace.clear();
+  if (this._paused_space.size > 0) {
+    this._paused_space.clear();
     cleared = true;
   }
 

package/lib/number.js

@@ -8,6 +8,7 @@ Number.prototype.toFloor = function (len) {
   var n = Math.pow(10, len);
   return Math.floor(this * n) / n;
 };
+
 /**
  * 进一法
  * @param {number} len 保留长度
@@ -17,6 +18,7 @@ Number.prototype.toCeil = function (len) {
   var n = Math.pow(10, len);
   return Math.ceil(this * n) / n;
 };
+
 /**
  * 四舍五入法
  * @param {number} len 保留长度

package/lib/object.js

@@ -60,6 +60,7 @@ function _convertValueByType(value, target_type) {
       return value;
   }
 }
+
 /**
  * 查询对象属性明细
  * @param {object} obj 目标对象
@@ -131,6 +132,7 @@ function _getPropertyInfo(obj, prop_path) {
   // 使用util.inspect显示详细的属性信息
   return inspect(current, { depth: 1, colors: false });
 }
+
 /**
  * 判断对象是否相似
  * @param {object} source 被判断对象
@@ -160,6 +162,7 @@ function as(source, target, exact, depth = 0) {
   }
   return processObject(source, target, exact, depth);
 }
+
 /**
  * 处理数组相似性比较
  * @param {Array} source_arr 源数组
@@ -180,6 +183,7 @@ function processArray(source_arr, target_arr, exact, depth) {
   }
   return true;
 }
+
 /**
  * 处理对象相似性比较
  * @param {object} source_obj 源对象
@@ -200,6 +204,7 @@ function processObject(source_obj, target_obj, exact, depth) {
   }
   return true;
 }
+
 /**
  * 添加对象属性
  * @param {object} target 被添加的对象
@@ -388,6 +393,7 @@ function toXml(source, format, attributes, cdata = false) {
   const builder = new Xml(options);
   return builder.build(source_xml || source);
 };
+
 /**
  * 转url字符串
  * @param {object} source 被转换的对象
@@ -435,6 +441,7 @@ function saveJson(source, target, format = true) {
   }
   return json_str;
 };
+
 /**
  * 将对象保存为XML文件
  * @param {object} source 源对象
@@ -1030,6 +1037,7 @@ function objToArr(source, key = 'key') {
   }
   return result;
 }
+
 /**
  * 数值增减操作
  * @param {object} source 源对象
@@ -1057,6 +1065,7 @@ function gain(source, key, value) {
   }
   return source;
 }
+
 // Object原型方法 - 设置为不可枚举，避免影响for...in循环
 Object.defineProperty(Object.prototype, 'as', {
   value: function (target, exact, depth = 0) {

package/lib/string.js

@@ -251,19 +251,16 @@ String.prototype.right = function (delimiter, retain) {
 };
 /**
  * 取文本之间
- * @param {string} leftDelimiter 索引的左边字符
- * @param {string} rightDelimiter 索引的右边字符
- * @param left_delimiter
- * @param left_deli
- * @param right_delimiter
- * @param right_deli
+ * @param {string} left_str 索引的左边字符
+ * @param {string} right_str 索引的右边字符
  * @param {boolean} retain 当索引字符不存在时是否保留右边
  * @returns {string} 截取后的字符串
  */
-String.prototype.between = function (left_deli, right_deli, retain) {
-  let str = this.right(left_delimiter, retain);
-  return str.left(right_delimiter, retain);
+String.prototype.between = function (left_str, right_str, retain) {
+  let str = this.right(left_str, retain);
+  return str.left(right_str, retain);
 };
+
 /**
  * 替换所有字符串
  * @param {string} search 被替换的字符串

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mm_expand",
-	"version": "2.3.6",
+	"version": "2.3.8",
 	"description": "超级美眉原型函数扩展模块 - 增强的字符串、数组、对象、日期操作，具备错误预防功能并简化业务逻辑",
 	"main": "index.js",
 	"scripts": {