mm_expand 1.8.9 → 1.9.0

package/lib/eventer.js

@@ -1,84 +1,184 @@
 /**
- * 事件类
+ * 事件类 - 增强版EventBus实现
  */
 class Eventer {
 	/**
-	 * 构造函数
-	 * @param {Object} config 配置参数
-	 */
-	constructor(config) {
-		this.config = Object.assign({
-			max_listeners: 10 // 最大监听器数量
-		}, config || {});
-		// 是否为插件
-		this.is_plugin = false;
-		// 事件字典
-		this.dict = {};
-	}
+ * 构造函数
+ * @param {Object} config 配置参数
+ */
+constructor(config) {
+	this.config = Object.assign({
+		max_listeners: 10, // 最大监听器数量
+		default_namespace: 'default', // 默认命名空间
+		chain_enabled: true // 是否启用链式触发
+	}, config || {});
+	// 是否为插件
+	this.is_plugin = false;
+	// 事件字典 - 支持命名空间
+	this.dict = {};
+	// 事件中间件
+	this.middlewares = [];
+	// 命名空间映射
+	this.namespaces = {};
+	// 事件链映射 { 'event1': ['event2', 'event3'], 'namespace:event1': ['event4'] }
+	this.eventChains = {};
+	// 初始化默认命名空间
+	this.namespaces[this.config.default_namespace] = true;
+}
 }
 
 /**
- * 监听事件
- * @param {String} key 事件关键字
+ * 监听事件（支持命名空间和优先级）
+ * @param {String} key 事件关键字，支持namespace:key格式
  * @param {Object} func 触发函数
  * @param {String} name 增加名称，方便删除，当出现相同名称时会被覆盖
  * @param {Number} times 执行次数 -1为无限次执行
- * @returns {Number} 返回事件索引位置
+ * @param {Number} priority 优先级，数字越小优先级越高，默认为0
+ * @param {Object} options 其他选项，如throttle、debounce等
+ * @param {String} namespace 可选的显式命名空间，优先级高于key中的命名空间
+ * @returns {Object} 返回事件信息对象 {namespace, index, name}
  */
-Eventer.prototype.on = function (key, func, name, times = -1) {
-	var events = this.dict;
-	if (!events[key]) {
-		events[key] = [];
+Eventer.prototype.on = function (key, func, name, times = -1, priority = 0, options = {}, explicitNamespace = null) {
+	// 解析命名空间
+	var parsed = this._parseKey(key);
+	var namespace = explicitNamespace || parsed.namespace;
+	var eventKey = parsed.eventKey;
+	
+	// 初始化命名空间和事件数组
+	if (!this.dict[namespace]) {
+		this.dict[namespace] = {};
+		this.namespaces[namespace] = true;
+	}
+	if (!this.dict[namespace][eventKey]) {
+		this.dict[namespace][eventKey] = [];
+	}
+	
+	// 确保func是函数
+	if (typeof func !== 'function') {
+		throw new Error('事件处理函数必须是一个函数');
 	}
+	
+	// 设置默认名称
 	if (!name) {
-		name = func.name || 'default';
+		name = func.name || `handler_${Date.now()}_${Math.floor(Math.random() * 1000)}`;
 	}
+	
+	// 应用节流或防抖
+	var wrappedFunc = func;
+	if (options.throttle) {
+		wrappedFunc = this._throttle(func, options.throttle);
+	} else if (options.debounce) {
+		wrappedFunc = this._debounce(func, options.debounce);
+	}
+	
+	// 创建事件对象
 	var obj = {
 		name,
-		func,
-		times
+		func: wrappedFunc,
+		original_func: func,
+		times,
+		priority,
+		options,
+		created_at: Date.now()
 	};
-	var o = null;
-	for (var i = 0; i < events[key].length; i++) {
-		if (events[key][i].name === name) {
-			o = events[key][i];
+	
+	// 检查是否已存在同名事件
+	var eventList = this.dict[namespace][eventKey];
+	var existingIndex = -1;
+	for (var i = 0; i < eventList.length; i++) {
+		if (eventList[i].name === name) {
+			existingIndex = i;
 			break;
 		}
 	}
-	if (o) {
-		Object.assign(o, obj);
+	
+	if (existingIndex >= 0) {
+		// 覆盖已存在的同名监听器
+		Object.assign(eventList[existingIndex], obj);
+		// 重新排序
+		this._sortEventsByPriority(eventList);
+		return { namespace, index: existingIndex, name };
 	} else {
-		events[key].push(obj);
+		// 检查监听器数量是否超过限制
+		var max_listeners = this.config.max_listeners;
+		if (max_listeners > 0 && eventList.length >= max_listeners) {
+			$.log.warn(`警告: '${namespace}:${eventKey}' 事件的监听器数量已达到 ${max_listeners}，可能导致内存泄漏。使用 setMaxListeners() 方法可以增加限制。`);
+		}
+		
+		// 添加新事件
+		eventList.push(obj);
+		// 按优先级排序
+		this._sortEventsByPriority(eventList);
+		return { namespace, index: eventList.length - 1, name };
 	}
-	return events[key].length - 1;
 }
 
 /**
  * 监听事件(仅执行一次)
- * @param {String} key 事件关键
+ * @param {String} key 事件关键，支持namespace:key格式
  * @param {Object} func 触发函数
  * @param {String} name 增加名称，方便删除，当出现相同名称时会被覆盖
- * @returns {Number} 返回事件索引位置
+ * @param {Number} priority 优先级，数字越小优先级越高，默认为0
+ * @param {Object} options 其他选项
+ * @param {String} namespace 可选的显式命名空间
+ * @returns {Object} 返回事件信息对象 {namespace, index, name}
  */
-Eventer.prototype.once = function (key, func, name) {
-	return this.on(key, func, name, 1);
+Eventer.prototype.once = function (key, func, name, priority = 0, options = {}, namespace = null) {
+	return this.on(key, func, name, 1, priority, options, namespace);
 }
 
 /**
- * 执行事件
- * @param {String} key 事件关键字
+ * 执行事件（支持中间件和命名空间）
+ * @param {String} key 事件关键字，支持namespace:key格式
  * @param {Object} params 传递参数
+ * @param {Object} options 执行选项
+ * @returns {Promise<Array>} 返回所有事件处理的结果数组
  */
 Eventer.prototype.run = async function (key, ...params) {
-	var events = this.dict;
-	var list = events[key];
-	if (list) {
-		var arr = [];
-		for (var i = 0; i < list.length; i++) {
+	// 解析命名空间
+	var { namespace, eventKey } = this._parseKey(key);
+	var fullEventKey = key; // 完整的事件键，包含命名空间
+	
+	// 获取事件列表
+	var eventList = this.dict[namespace] && this.dict[namespace][eventKey];
+	
+	// 创建上下文对象
+	var startTime = Date.now();
+	var context = {
+		namespace,
+		event: eventKey,
+		full_event: fullEventKey,
+		params,
+		results: [],
+		start_time: startTime,
+		executed: 0,
+		error_count: 0
+	};
+	
+	var arr = []; // 存储需要移除的事件
+	var results = []; // 存储执行结果
+	
+	// 如果有事件处理函数，执行它们
+	if (eventList && eventList.length > 0) {
+		// 执行前置中间件
+		try {
+			await this._runMiddlewares('before', context);
+		} catch (middlewareError) {
+			$.log.error(`事件中间件执行失败 [${namespace}:${eventKey}]`, middlewareError);
+		}
+		
+		// 执行事件处理函数
+		for (var i = 0; i < eventList.length; i++) {
 			try {
-				var o = list[i];
-				// 简化Promise处理逻辑，避免可能的重复执行
-				await o.func(...params);
+				var o = eventList[i];
+				context.executed++;
+				
+				// 执行事件处理函数
+				var result = await o.func.apply(o, params);
+				results.push(result);
+				context.results.push(result);
+				
+				// 处理执行次数限制
 				if (o.times >= 0) {
 					o.times--;
 					if (o.times <= 0) {
@@ -86,97 +186,235 @@ Eventer.prototype.run = async function (key, ...params) {
 					}
 				}
 			} catch (e) {
-				$.log.error("执行事件失败！", e);
-				//TODO handle the exception
+				context.error_count++;
+				$.log.error(`事件执行失败 [${namespace}:${eventKey}] - ${o.name}`, e);
+				results.push({
+					_error: true,
+					error: e,
+					handler: o.name
+				});
+				context.results.push(results[results.length - 1]);
 			}
 		}
+		
+		// 移除已执行完的事件
 		for (var i = 0; i < arr.length; i++) {
-			for (var j = list.length - 1; j >= 0; j--) {
-				if (list[j].name === arr[i]) {
-					list.splice(j, 1);
-				}
-			}
+			this.del(`${namespace}:${eventKey}`, arr[i]);
+		}
+		
+		// 执行后置中间件
+		try {
+			context.end_time = Date.now();
+			context.duration = context.end_time - startTime;
+			await this._runMiddlewares('after', context);
+		} catch (middlewareError) {
+			$.log.error(`事件后置中间件执行失败 [${namespace}:${eventKey}]`, middlewareError);
+		}
+	}
+	
+	// 执行事件链（只触发下一级事件，不重复执行当前事件）
+	if (this.config.chain_enabled && this.eventChains[fullEventKey]) {
+		try {
+			// 直接触发下一级事件，避免重复执行当前事件
+			await this._triggerNextChainEvents(fullEventKey, params);
+		} catch (chainError) {
+			$.log.error(`事件链执行失败 [${fullEventKey}]`, chainError);
 		}
 	}
+	
+	return results;
 }
 
 /**
  * 触发事件
- * @param {String} key 事件关键
+ * @param {String} key 事件关键，支持namespace:key格式
  * @param {Object} params 传递参数
+ * @returns {Promise<Array>} 返回所有事件处理的结果数组
  */
 Eventer.prototype.emit = function (key, ...params) {
-	this.run(key, ...params);
+	return this.run(key, ...params);
+}
+
+/**
+ * 触发所有命名空间的特定事件
+ * @param {String} eventKey 事件关键字（不含命名空间）
+ * @param {Object} params 传递参数
+ * @returns {Promise<Object>} 返回各命名空间的执行结果 {namespace1: results1, namespace2: results2}
+ */
+Eventer.prototype.emitAll = async function (eventKey, ...params) {
+	var results = {};
+	// 确保遍历所有命名空间，包括动态创建的
+	for (var namespace in this.dict) {
+		// 确保命名空间在namespaces映射中
+		if (!this.namespaces[namespace]) {
+			this.namespaces[namespace] = true;
+		}
+		
+		// 检查该命名空间下是否存在该事件
+		if (this.dict[namespace] && this.dict[namespace][eventKey]) {
+			// 直接使用命名空间和事件键执行
+			var context = {
+				namespace,
+				event: eventKey,
+				params
+			};
+			
+			var eventList = this.dict[namespace][eventKey];
+			var namespaceResults = [];
+			var arr = []; // 存储需要移除的事件
+			
+			// 执行事件处理函数
+			for (var i = 0; i < eventList.length; i++) {
+				try {
+					var o = eventList[i];
+					
+					// 执行事件处理函数
+					var result = await o.func.apply(o, params);
+					namespaceResults.push(result);
+					
+					// 处理执行次数限制
+					if (o.times >= 0) {
+						o.times--;
+						if (o.times <= 0) {
+							arr.push(o.name);
+						}
+					}
+				} catch (e) {
+					// 记录错误但不中断执行
+					$.log.error(`事件执行失败 [${namespace}:${eventKey}] - ${eventList[i].name}`, e);
+					namespaceResults.push({
+						_error: true,
+						error: e,
+						handler: eventList[i].name
+					});
+				}
+			}
+			
+			// 移除已执行完的事件
+			for (var i = 0; i < arr.length; i++) {
+				this.del(`${namespace}:${eventKey}`, arr[i]);
+			}
+			
+			results[namespace] = namespaceResults;
+		}
+	}
+	return results;
 }
 
 /**
  * 删除事件
- * @param {String} key 事件关键字
+ * @param {String} key 事件关键字，支持namespace:key格式
  * @param {Number|String} indexOrName 事件集索引或名称
  * @returns {Boolean} 删除成功返回true，否则返回false
  */
-Eventer.prototype.del = function (key, indexOrName) {
-	var events = this.dict;
-	if (!events[key]) {
+Eventer.prototype.off = function (key, indexOrName) {
+	// 解析命名空间
+	var { namespace, eventKey } = this._parseKey(key);
+	
+	// 检查事件是否存在
+	if (!this.dict[namespace] || !this.dict[namespace][eventKey]) {
 		return false;
 	}
 
+	var events = this.dict[namespace][eventKey];
+	
 	if (indexOrName) {
-		var list = events[key];
 		if (typeof (indexOrName) === "number") {
-			if (indexOrName >= 0 && indexOrName < list.length) {
-				list.splice(indexOrName, 1);
+			// 按索引删除
+			if (indexOrName >= 0 && indexOrName < events.length) {
+				events.splice(indexOrName, 1);
 				return true;
 			}
 		} else {
 			// 根据名称删除事件
-			for (var j = list.length - 1; j >= 0; j--) {
-				if (list[j].name === indexOrName) {
-					list.splice(j, 1);
+			for (var j = events.length - 1; j >= 0; j--) {
+				if (events[j].name === indexOrName) {
+					events.splice(j, 1);
 					return true;
 				}
 			}
 		}
 	} else {
 		// 删除整个事件
-		delete events[key];
+		delete this.dict[namespace][eventKey];
 		return true;
 	}
 	return false;
 };
 
+Eventer.prototype.add = Eventer.prototype.on;
+Eventer.prototype.del = Eventer.prototype.off;
+
+/**
+ * 删除命名空间中的所有事件
+ * @param {String} namespace 命名空间
+ * @returns {Boolean} 删除成功返回true，否则返回false
+ */
+Eventer.prototype.clearNamespace = function (namespace) {
+	if (!namespace || !this.dict[namespace]) {
+		return false;
+	}
+	delete this.dict[namespace];
+	delete this.namespaces[namespace];
+	return true;
+}
+
 /**
  * 获取事件列表
- * @param {String} key 事件关键字，如果为空则获取所有事件
+ * @param {String} key 事件关键字，如果为空则获取所有事件，支持namespace:key格式
  * @returns {Array|Object} 返回事件列表或所有事件对象
  */
 Eventer.prototype.getEvents = function (key) {
 	if (key) {
-		return this.dict[key] || [];
+		// 解析命名空间
+		var { namespace, eventKey } = this._parseKey(key);
+		return this.dict[namespace] && this.dict[namespace][eventKey] ? [...this.dict[namespace][eventKey]] : [];
+	}
+	// 返回深拷贝的所有事件
+	var result = {};
+	for (var namespace in this.dict) {
+		result[namespace] = {};
+		for (var eventKey in this.dict[namespace]) {
+			result[namespace][eventKey] = [...this.dict[namespace][eventKey]];
+		}
 	}
-	return this.dict;
+	return result;
 };
 
+/**
+ * 获取所有命名空间
+ * @returns {Array} 返回所有命名空间数组
+ */
+Eventer.prototype.getNamespaces = function () {
+	return Object.keys(this.namespaces);
+}
+
 /**
  * 清空所有事件
  */
 Eventer.prototype.clear = function () {
 	this.dict = {};
+	this.namespaces = {};
+	// 保留默认命名空间
+	this.namespaces[this.config.default_namespace] = true;
 };
 
 /**
  * 检查事件是否存在
- * @param {String} key 事件关键字
+ * @param {String} key 事件关键字，支持namespace:key格式
  * @param {String} name 事件名称（可选）
  * @returns {Boolean} 事件存在返回true，否则返回false
  */
 Eventer.prototype.has = function (key, name) {
-	if (!this.dict[key]) {
+	// 解析命名空间
+	var { namespace, eventKey } = this._parseKey(key);
+	
+	if (!this.dict[namespace] || !this.dict[namespace][eventKey]) {
 		return false;
 	}
 
 	if (name) {
-		var list = this.dict[key];
+		var list = this.dict[namespace][eventKey];
 		for (var i = 0; i < list.length; i++) {
 			if (list[i].name === name) {
 				return true;
@@ -190,21 +428,335 @@ Eventer.prototype.has = function (key, name) {
 
 /**
  * 获取事件数量
- * @param {String} key 事件关键字，如果为空则获取所有事件数量
+ * @param {String} key 事件关键字，如果为空则获取所有事件数量，支持namespace:key格式或namespace:*格式
  * @returns {Number} 返回事件数量
  */
 Eventer.prototype.count = function (key) {
 	if (key) {
-		return this.dict[key] ? this.dict[key].length : 0;
+		// 解析可能的命名空间模式
+		if (key.endsWith(':*')) {
+			// 统计命名空间下所有事件
+			var namespace = key.split(':')[0];
+			if (this.dict[namespace]) {
+				var total = 0;
+				for (var eventKey in this.dict[namespace]) {
+					total += this.dict[namespace][eventKey].length;
+				}
+				return total;
+			}
+			return 0;
+		}
+		
+		// 解析具体事件
+		var { namespace, eventKey } = this._parseKey(key);
+		return this.dict[namespace] && this.dict[namespace][eventKey] ? this.dict[namespace][eventKey].length : 0;
 	}
 
+	// 统计所有事件
 	var total = 0;
-	for (var k in this.dict) {
-		total += this.dict[k].length;
+	for (var namespace in this.dict) {
+		for (var eventKey in this.dict[namespace]) {
+			total += this.dict[namespace][eventKey].length;
+		}
 	}
 	return total;
 };
 
+/**
+ * 添加事件中间件
+ * @param {String} type 中间件类型，'before' 或 'after'
+ * @param {Function} middleware 中间件函数，接收context参数
+ * @returns {Eventer} 返回当前实例，支持链式调用
+ */
+Eventer.prototype.use = function (type, middleware) {
+	if (type !== 'before' && type !== 'after') {
+		throw new Error('中间件类型必须是 "before" 或 "after"');
+	}
+	if (typeof middleware !== 'function') {
+		throw new Error('中间件必须是一个函数');
+	}
+	
+	if (!this.middlewares[type]) {
+		this.middlewares[type] = [];
+	}
+	
+	this.middlewares[type].push(middleware);
+	return this;
+};
+
+/**
+ * 添加事件链式触发关系
+ * @param {String} fromEvent 触发源事件，支持namespace:key格式
+ * @param {String|Array} toEvents 目标事件，可以是单个事件字符串或事件数组
+ * @returns {Eventer} 返回当前实例，支持链式调用
+ */
+Eventer.prototype.chain = function (fromEvent, toEvents) {
+	if (!fromEvent || typeof fromEvent !== 'string') {
+		throw new Error('触发源事件必须是一个非空字符串');
+	}
+	
+	if (!toEvents) {
+		throw new Error('目标事件不能为空');
+	}
+	
+	// 标准化为数组
+	var targets = Array.isArray(toEvents) ? toEvents : [toEvents];
+	for (var i = 0; i < targets.length; i++) {
+		if (typeof targets[i] !== 'string') {
+			throw new Error('目标事件必须是字符串类型');
+		}
+	}
+	
+	// 初始化事件链
+	if (!this.eventChains[fromEvent]) {
+		this.eventChains[fromEvent] = [];
+	}
+	
+	// 添加到事件链中，避免重复
+	for (var i = 0; i < targets.length; i++) {
+		if (this.eventChains[fromEvent].indexOf(targets[i]) === -1) {
+			this.eventChains[fromEvent].push(targets[i]);
+		}
+	}
+	
+	return this;
+};
+
+/**
+ * 移除事件链式触发关系
+ * @param {String} fromEvent 触发源事件
+ * @param {String|Array} toEvents 目标事件，不传则移除所有关联
+ * @returns {Eventer} 返回当前实例，支持链式调用
+ */
+Eventer.prototype.unchain = function (fromEvent, toEvents) {
+	if (!fromEvent || !this.eventChains[fromEvent]) {
+		return this;
+	}
+	
+	if (!toEvents) {
+		// 移除所有关联
+		delete this.eventChains[fromEvent];
+	} else {
+		// 移除指定关联
+		var targets = Array.isArray(toEvents) ? toEvents : [toEvents];
+		this.eventChains[fromEvent] = this.eventChains[fromEvent].filter(event => {
+			return targets.indexOf(event) === -1;
+		});
+		
+		// 如果没有关联了，清理数组
+		if (this.eventChains[fromEvent].length === 0) {
+			delete this.eventChains[fromEvent];
+		}
+	}
+	
+	return this;
+};
+
+/**
+ * 获取事件链关系
+ * @param {String} event 事件名称，不传则获取所有
+ * @returns {Object|Array} 事件链关系
+ */
+Eventer.prototype.getChains = function (event) {
+	if (event) {
+		return this.eventChains[event] || [];
+	}
+	return { ...this.eventChains };
+};
+
+/**
+ * 触发下一级事件链事件
+ * @private
+ * @param {String} currentEvent 当前触发的事件
+ * @param {Array} params 传递的参数
+ * @returns {Promise<void>}
+ */
+Eventer.prototype._triggerNextChainEvents = async function (currentEvent, params) {
+	if (!this.config.chain_enabled || !this.eventChains[currentEvent]) {
+		return;
+	}
+	
+	// 循环触发下一级事件
+	for (var nextEvent of this.eventChains[currentEvent]) {
+		await this._executeEventChainItem(nextEvent, params);
+	}
+};
+
+/**
+ * 执行单个链上事件（包含中间件）
+ * @private
+ * @param {String} eventKey 要执行的事件
+ * @param {Array} params 参数
+ * @returns {Promise<Array>} 执行结果
+ */
+Eventer.prototype._executeEventChainItem = async function (eventKey, params) {
+	// 解析命名空间
+	var { namespace, eventKey: innerEventKey } = this._parseKey(eventKey);
+	var eventList = this.dict[namespace] && this.dict[namespace][innerEventKey];
+	var results = [];
+	
+	// 创建上下文对象
+	var startTime = Date.now();
+	var context = {
+		namespace,
+		event: innerEventKey,
+		full_event: eventKey,
+		params,
+		results: [],
+		start_time: startTime,
+		executed: 0,
+		error_count: 0
+	};
+	
+	// 如果有事件处理函数，执行它们
+	if (eventList && eventList.length > 0) {
+		// 执行前置中间件
+		try {
+			await this._runMiddlewares('before', context);
+		} catch (middlewareError) {
+			$.log.error(`事件链中间件执行失败 [${namespace}:${innerEventKey}]`, middlewareError);
+		}
+		
+		// 执行事件处理函数
+		for (var i = 0; i < eventList.length; i++) {
+			try {
+				var o = eventList[i];
+				context.executed++;
+				
+				// 执行事件处理函数
+				var result = await o.func.apply(o, params);
+				results.push(result);
+				context.results.push(result);
+				
+				// 处理执行次数限制
+				if (o.times >= 0) {
+					o.times--;
+					if (o.times <= 0) {
+						this.del(`${namespace}:${innerEventKey}`, o.name);
+					}
+				}
+			} catch (e) {
+				context.error_count++;
+				$.log.error(`事件链执行失败 [${namespace}:${innerEventKey}] - ${o.name}`, e);
+				results.push({
+					_error: true,
+					error: e,
+					handler: o.name
+				});
+				context.results.push(results[results.length - 1]);
+			}
+		}
+		
+		// 执行后置中间件
+		try {
+			context.end_time = Date.now();
+			context.duration = context.end_time - startTime;
+			await this._runMiddlewares('after', context);
+		} catch (middlewareError) {
+			$.log.error(`事件链后置中间件执行失败 [${namespace}:${innerEventKey}]`, middlewareError);
+		}
+	}
+	
+	// 递归触发下一级事件
+	if (this.eventChains[eventKey]) {
+		await this._triggerNextChainEvents(eventKey, params);
+	}
+	
+	return results;
+};
+
+/**
+ * 并行执行事件（提高性能）
+ * @param {String} key 事件关键字，支持namespace:key格式
+ * @param {Object} params 传递参数
+ * @returns {Promise<Array>} 返回所有事件处理的结果数组
+ */
+Eventer.prototype.runParallel = async function (key, ...params) {
+	// 解析命名空间
+	var { namespace, eventKey } = this._parseKey(key);
+	
+	// 获取事件列表
+	var eventList = this.dict[namespace] && this.dict[namespace][eventKey];
+	if (!eventList || eventList.length === 0) {
+		return [];
+	}
+	
+	// 创建上下文对象
+	var startTime = Date.now();
+	var context = {
+		namespace,
+		event: eventKey,
+		params,
+		start_time: startTime
+	};
+	
+	// 执行前置中间件
+	try {
+		await this._runMiddlewares('before', context);
+	} catch (middlewareError) {
+		$.log.error(`事件中间件执行失败 [${namespace}:${eventKey}]`, middlewareError);
+	}
+	
+	// 并行执行所有事件
+	var tasks = eventList.map(o => this._executeTask(o, params));
+	var results = await Promise.allSettled(tasks);
+	
+	// 处理结果和清理
+	var arr = [];
+	var processedResults = [];
+	
+	for (var i = 0; i < results.length; i++) {
+		var result = results[i];
+		var event = eventList[i];
+		
+		if (result.status === 'fulfilled') {
+			processedResults.push(result.value);
+		} else {
+			$.log.error(`事件执行失败 [${namespace}:${eventKey}] - ${event.name}`, result.reason);
+			processedResults.push({
+				_error: true,
+				error: result.reason,
+				handler: event.name
+			});
+		}
+		
+		// 处理执行次数限制
+		if (event.times >= 0) {
+			event.times--;
+			if (event.times <= 0) {
+				arr.push(event.name);
+			}
+		}
+	}
+	
+	// 移除已执行完的事件
+	for (var i = 0; i < arr.length; i++) {
+		this.del(`${namespace}:${eventKey}`, arr[i]);
+	}
+	
+	// 执行后置中间件
+	try {
+		context.end_time = Date.now();
+		context.duration = context.end_time - startTime;
+		context.results = processedResults;
+		await this._runMiddlewares('after', context);
+	} catch (middlewareError) {
+		$.log.error(`事件后置中间件执行失败 [${namespace}:${eventKey}]`, middlewareError);
+	}
+	
+	return processedResults;
+};
+
+/**
+ * 异步触发事件（并行执行）
+ * @param {String} key 事件关键字，支持namespace:key格式
+ * @param {Object} params 传递参数
+ * @returns {Promise<Array>} 返回所有事件处理的结果数组
+ */
+Eventer.prototype.emitParallel = function (key, ...params) {
+	return this.runParallel(key, ...params);
+};
+
 /**
  * 防止内存泄漏警告
  * @param {Number} n 最大监听器数量
@@ -219,7 +771,7 @@ Eventer.prototype.setMaxListeners = function (n) {
 
 /**
  * 批量添加事件
- * @param {Object} eventsMap 事件映射对象 { key: [func1, func2...] }
+ * @param {Object} eventsMap 事件映射对象 { key: [func1, func2...] 或 key: {func, options} }
  * @returns {Eventer} 返回当前实例，支持链式调用
  */
 Eventer.prototype.onMany = function (eventsMap) {
@@ -230,14 +782,129 @@ Eventer.prototype.onMany = function (eventsMap) {
 	for (var key in eventsMap) {
 		var handlers = eventsMap[key];
 		if (Array.isArray(handlers)) {
-			handlers.forEach(func => {
-				if (typeof func === 'function') {
-					this.on(key, func);
+			handlers.forEach((handler, index) => {
+				if (typeof handler === 'function') {
+					this.on(key, handler, `handler_${index}`);
+				} else if (typeof handler === 'object' && handler.func) {
+					var { func, name, priority, options } = handler;
+					this.on(key, func, name || `handler_${index}`, -1, priority, options);
 				}
 			});
+		} else if (typeof handlers === 'object' && handlers.func) {
+			var { func, name, priority, options } = handlers;
+			this.on(key, func, name, -1, priority, options);
 		}
 	}
 	return this;
 };
 
-exports.Eventer = Eventer;
+// 私有方法
+
+/**
+ * 解析事件键，提取命名空间和事件名
+ * @private
+ * @param {String} key 事件键
+ * @returns {Object} {namespace, eventKey}
+ */
+Eventer.prototype._parseKey = function (key) {
+	var parts = key.split(':');
+	var namespace = this.config.default_namespace;
+	var eventKey = key;
+	
+	if (parts.length > 1) {
+		namespace = parts[0];
+		eventKey = parts.slice(1).join(':');
+	}
+	
+	return { namespace, eventKey };
+};
+
+/**
+ * 按优先级排序事件
+ * @private
+ * @param {Array} events 事件列表
+ */
+Eventer.prototype._sortEventsByPriority = function (events) {
+	events.sort((a, b) => {
+		// 先按优先级排序
+		if (a.priority !== b.priority) {
+			return a.priority - b.priority;
+		}
+		// 优先级相同时按创建时间排序
+		return a.created_at - b.created_at;
+	});
+};
+
+/**
+ * 执行事件中间件
+ * @private
+ * @param {String} type 中间件类型
+ * @param {Object} context 上下文对象
+ */
+Eventer.prototype._runMiddlewares = async function(type, context) {
+	if (!this.middlewares[type]) {
+		return;
+	}
+	
+	for (let middleware of this.middlewares[type]) {
+		try {
+			await middleware(context);
+		} catch (err) {
+			$.log.error(`中间件执行失败 [${type}] - ${err.message}`);
+		}
+	}
+};
+
+/**
+ * 执行单个事件任务
+ * @private
+ * @param {Object} event 事件对象
+ * @param {Array} params 参数数组
+ * @returns {Promise<any>} 执行结果
+ */
+Eventer.prototype._executeTask = async function (event, params) {
+	return event.func.apply(event, params);
+};
+
+/**
+ * 函数节流
+ * @private
+ * @param {Function} func 要节流的函数
+ * @param {Number} limit 时间限制（毫秒）
+ * @returns {Function} 节流后的函数
+ */
+Eventer.prototype._throttle = function (func, limit) {
+	var inThrottle;
+	return function() {
+		var args = arguments;
+		var context = this;
+		if (!inThrottle) {
+			func.apply(context, args);
+			inThrottle = true;
+			setTimeout(() => inThrottle = false, limit);
+		}
+	};
+};
+
+/**
+ * 函数防抖
+ * @private
+ * @param {Function} func 要防抖的函数
+ * @param {Number} wait 等待时间（毫秒）
+ * @returns {Function} 防抖后的函数
+ */
+Eventer.prototype._debounce = function (func, wait) {
+	var timeout;
+	return function() {
+		var args = arguments;
+		var context = this;
+		clearTimeout(timeout);
+		timeout = setTimeout(() => func.apply(context, args), wait);
+	};
+};
+
+/**
+ * 导出单例实例
+ */
+exports.Eventer = Eventer;
+exports.eventer = new Eventer();