mm_machine 2.4.3 → 2.4.5

package/drive.js

@@ -3,6 +3,7 @@ require('mm_tpl');
 let {
   conf
 } = require('mm_config');
+// const { Word } = require('./ulits/word.js');
 const {
   Mod
 } = require('./mod');
@@ -617,7 +618,12 @@ Drive.prototype._delArray = function (file, config, name) {
  * @returns {string} 配置文件名称
  */
 Drive.prototype._getName = function (file) {
-  return file.dirname().basename();
+  let name = file.dirname().basename();
+  return name;
+  // // 提取文件名作为模块名
+  // var word = new Word();
+  // // 将文件名改为驼峰命名法
+  // return word.toCamelCase(name);
 };
 
 /**
@@ -639,8 +645,8 @@ Drive.prototype.loadBefore = function () {
  * 加载处理
  */
 Drive.prototype._loadCore = function () {
-  this.loadConfig();
-  this.loadScript();
+  // this.loadConfig();
+  // this.loadScript();
 };
 
 /**

package/index.js

@@ -86,8 +86,10 @@ class Manager extends Mod {
    * 构造函数
    * @param {object} config 配置项
    * @param {object} parent 父项对象
+   * @param {object} mods 模块对象列表
+   * @param {object} Drive 驱动对象
    */
-  constructor(config, parent) {
+  constructor(config, parent, mods = {}, Drive) {
     super({
       ...Manager.config,
       ...config
@@ -96,7 +98,10 @@ class Manager extends Mod {
     // 模块信息列表 { name: '', sort: 0, available: true, enabled: true }
     this.infos = [];
     // 模块
-    this.mods = {};
+    this.mods = mods;
+    if (Drive) {
+      this.Drive = Drive;
+    }
   }
 }
 
@@ -496,7 +501,7 @@ Manager.prototype.main = async function (name, method, ...params) {
   if (name) {
     let mod = this.getMod(name);
     if (mod && mod.config?.state === 1) {
-      result = await this._runSub(mod, method, ...params);
+      result = await this._run(mod, method, ...params);
     }
   } else if (name === null) {
     result = await this._runAllEnabled(method, ...params);
@@ -517,7 +522,7 @@ Manager.prototype._runAllEnabled = async function (method, ...params) {
     let config = this.infos[i];
     let mod = this.getMod(config.name);
     if (mod && mod.config?.state === 1) {
-      var ret = await this._runSub(mod, method, ...params);
+      var ret = await this._run(mod, method, ...params);
       if (ret !== null && ret !== undefined) {
         result = ret;
         // 如果结果不为空且有结束标志，则停止迭代
@@ -530,49 +535,6 @@ Manager.prototype._runAllEnabled = async function (method, ...params) {
   return result;
 };
 
-/**
- * 执行方法
- * @param {string} name 模块名称
- * @param {string} method 方法名称
- * @param {...any} params 方法参数集合
- * @returns {Promise<any>} 执行结果
- */
-Manager.prototype.runAsync = async function (name, method, ...params) {
-  // 使用mods的顺序（按配置顺序调用）
-  var result = null;
-  if (name) {
-    let mod = await this.getMod(name);
-    if (mod) {
-      result = await this._runSub(mod, method, ...params);
-    }
-  } else if (name === null) {
-    result = await this._runAll(method, ...params);
-  }
-  return result;
-};
-
-/**
- * 私有方法：执行所有模块方法
- * @param {string} method 方法名称
- * @param {...any} params 方法参数集合
- * @returns {Promise<any>} 执行结果
- * @private
- */
-Manager.prototype._runAll = async function (method, ...params) {
-  var result = null;
-  for (let i = 0; i < this.infos.length; i++) {
-    let config = this.infos[i];
-    let mod = this.getMod(config.name);
-    if (mod) {
-      var ret = await this._runSub(mod, method, ...params);
-      if (ret !== null && ret !== undefined) {
-        result = ret;
-      }
-    }
-  }
-  return result;
-};
-
 /**
  * 私有方法：执行模块方法
  * @param {object} mod 模块对象
@@ -581,7 +543,7 @@ Manager.prototype._runAll = async function (method, ...params) {
  * @returns {Promise<any>} 执行结果
  * @private
  */
-Manager.prototype._runSub = async function (mod, method, ...params) {
+Manager.prototype._run = async function (mod, method, ...params) {
   if (!mod || !method) return null;
 
   try {
@@ -614,25 +576,270 @@ Manager.prototype._initManager = function () {
 /**
  * 加载资源
  */
-Manager.prototype._loadSources = function () {
+Manager.prototype._loadSources = async function () {
+  // 通过更新函数加载资源信息
+  await this.call('update');
 };
 
 /**
  * 初始化资源
  */
-Manager.prototype._initSources = function () {
+Manager.prototype._initSources = async function () {
+  // 通过
 };
 
 /**
  * 初始化公共属性
  */
-Manager.prototype._initCore = function () {
+Manager.prototype._initCore = async function () {
   // 初始化管理器
   this._initManager();
   // 加载资源
-  this._loadSources();
+  await this._loadSources();
   // 初始化AI客户端
-  this._initSources();
+  await this._initSources();
+};
+
+/**
+ * 执行方法
+ * @param {string} method 方法名称
+ * @param {...object} params 参数列表
+ * @returns {object} 返回执行结果
+ */
+Manager.prototype._exec = async function (mod, method, ...params) {
+  if (mod[method]) {
+    return await mod[method](...params);
+  }
+  else {
+    throw new Error(`方法${method}不存在`);
+  }
+};
+
+/**
+ * 执行方法
+ * @param {string} method 方法名称
+ * @param  {...any} params 参数列表
+ * @returns {object} 返回执行结果
+ */
+Manager.prototype.exec = async function (name, method, ...params) {
+  let ret;
+  try {
+    let mod = this.getMod(name);
+    ret = await this._exec(mod, method, ...params);
+  }
+  catch (error) {
+    this.log('error', `${method}方法执行失败！`, error);
+  }
+  return ret;
+};
+
+/**
+ * 确保所有模块都已加载
+ * @returns {Promise} 加载完成
+ */
+Manager.prototype._ensureAllModulesLoaded = async function () {
+  let infos = this.getInfos();
+  
+  for (let i = 0; i < infos.length; i++) {
+    let info = infos[i];
+    let mod = this.getMod(info.name);
+    
+    if (!mod.isLoaded()) {
+      try {
+        await mod.call('loadScript');
+      } catch (error) {
+        this.log('error', `模块${info.name}加载失败`, error);
+        continue; // 跳过加载失败的模块
+      }
+    }
+  }
+};
+
+/**
+ * 异步触发事件，按顺序执行等待完成
+ * @param {string} method 方法名称
+ * @param  {...any} params 事件参数
+ * @returns {Promise} 事件触发结果
+ */
+Manager.prototype.runWait = async function (method, ...params) {
+  // 参数校验
+  if (typeof method !== 'string') {
+    throw new TypeError('方法名称必须是字符串');
+  }
+
+  let result;
+  let infos = this.getInfos();
+
+  for (let i = 0; i < infos.length; i++) {
+    let info = infos[i];
+    let mod = this.getMod(info.name);
+
+    // 确保模块已加载
+    if (!mod.isLoaded()) {
+      try {
+        await mod.call('loadScript');
+      } catch (error) {
+        this.log('error', `模块${info.name}加载失败`, error);
+        continue; // 跳过加载失败的模块
+      }
+    }
+
+    // 执行方法
+    try {
+      let ret = await mod.call(method, ...params);
+      if (ret !== null && ret !== undefined) {
+        result = ret;
+      }
+    } catch (error) {
+      this.log('error', `模块${info.name}执行${method}方法失败`, error);
+    }
+  }
+
+  return result;
+};
+
+/**
+ * 异步触发事件，并发执行不等待
+ * @param {string} method 方法名称
+ * @param  {...any} params 事件参数
+ * @returns {boolean} 是否成功触发事件
+ */
+Manager.prototype.runAsync = async function (method, ...params) {
+  // 参数校验
+  if (typeof method !== 'string') {
+    throw new TypeError('方法名称必须是字符串');
+  }
+  
+  // 确保所有模块都已加载
+  await this._ensureAllModulesLoaded();
+  
+  let infos = this.getInfos();
+  
+  // 并发执行所有方法，不等待结果
+  for (let i = 0; i < infos.length; i++) {
+    let info = infos[i];
+    let mod = this.getMod(info.name);
+    try {
+      mod.call(method, ...params);
+    } catch (error) {
+      this.log('error', `模块${info.name}执行${method}方法失败`, error);
+    }
+  }
+  
+  return true;
+};
+
+/**
+ * 异步触发事件，并发执行等待完成
+ * @param {string} method 方法名称
+ * @param  {...any} params 事件参数
+ * @returns {Promise} 事件触发结果
+ */
+Manager.prototype.runAll = async function (method, ...params) {
+  // 参数校验
+  if (typeof method !== 'string') {
+    throw new TypeError('方法名称必须是字符串');
+  }
+
+  // 确保所有模块都已加载
+  await this._ensureAllModulesLoaded();
+
+  const promises = [];
+  let infos = this.getInfos();
+
+  // 并发执行所有方法
+  for (let i = 0; i < infos.length; i++) {
+    let info = infos[i];
+    let mod = this.getMod(info.name);
+    if (mod.isLoaded()) {
+      promises.push(
+        mod.call(method, ...params).catch(error => {
+          this.log('error', `模块${info.name}执行${method}方法失败`, error);
+          return null; // 失败时返回null
+        })
+      );
+    }
+  }
+
+  return await Promise.all(promises);
+};
+
+/**
+ * 异步触发事件，竞争执行
+ * @param {string} method 方法名称
+ * @param  {...any} params 事件参数
+ * @returns {Promise} 第一个完成的结果
+ */
+Manager.prototype.runRace = async function (method, ...params) {
+  // 参数校验
+  if (typeof method !== 'string') {
+    throw new TypeError('方法名称必须是字符串');
+  }
+  
+  // 确保所有模块都已加载
+  await this._ensureAllModulesLoaded();
+  
+  const promises = [];
+  let infos = this.getInfos();
+  
+  // 竞争执行所有方法
+  for (let i = 0; i < infos.length; i++) {
+    let info = infos[i];
+    let mod = this.getMod(info.name);
+    if (mod.isLoaded()) {
+      promises.push(
+        mod.call(method, ...params).catch(error => {
+          this.log('error', `模块${info.name}执行${method}方法失败`, error);
+          throw error; // 竞争执行中，失败应该抛出错误
+        })
+      );
+    }
+  }
+  
+  return await Promise.race(promises);
+};
+
+/**
+ * 异步触发事件，瀑布流执行
+ * @param {string} method 方法名称
+ * @param {*} result 初始值
+ * @param  {...any} params 事件参数
+ * @returns {Promise} 最后一个事件监听者的结果
+ */
+Manager.prototype.runWaterfall = async function (method, result, ...params) {
+  // 参数校验
+  if (typeof method !== 'string') {
+    throw new TypeError('方法名称必须是字符串');
+  }
+
+  let infos = this.getInfos();
+
+  for (let i = 0; i < infos.length; i++) {
+    let info = infos[i];
+    let mod = this.getMod(info.name);
+
+    // 确保模块已加载
+    if (!mod.isLoaded()) {
+      try {
+        await mod.call('loadScript');
+      } catch (error) {
+        this.log('error', `模块${info.name}加载失败`, error);
+        continue; // 跳过加载失败的模块
+      }
+    }
+
+    // 执行方法，将前一个结果作为参数传递给下一个
+    try {
+      let ret = await mod.call(method, result, ...params);
+      if (ret !== null && ret !== undefined) {
+        result = ret;
+      }
+    } catch (error) {
+      this.log('error', `模块${info.name}执行${method}方法失败`, error);
+    }
+  }
+
+  return result;
 };
 
 module.exports = {

package/mod.js

@@ -238,11 +238,19 @@ Mod.prototype._onDestroy = async function (ctx) {
   });
 };
 
+/**
+ * 加载 - 内部方法
+ * @private
+ */
+Mod.prototype._load = async function () {
+  return this;
+};
+
 /**
  * 加载
  */
 Mod.prototype.load = async function () {
-
+  return await this._load();
 };
 
 /**
@@ -253,38 +261,65 @@ Mod.prototype._loadCore = async function () {
 };
 
 /**
- * 启动
+ * 启动 - 内部方法
+ * @private
+ * @param {...any} args 初始化参数
  */
-Mod.prototype.start = async function () {
+Mod.prototype._start = async function (...args) {
+  return this;
+};
 
+/**
+ * 启动
+ */
+Mod.prototype.start = async function (...args) {
+  return await this._start(...args);
 };
 
 /**
  * 启动核心
+ * @private
  */
 Mod.prototype._startCore = async function () {
 
 };
 
+/**
+ * 停止 - 内部方法
+ * @private
+ */
+Mod.prototype._stop = async function () {
+  return this;
+};
+
 /**
  * 停止
  */
 Mod.prototype.stop = async function () {
-
+  return await this._stop();
 };
 
 /**
  * 停止核心
+ * @private
  */
 Mod.prototype._stopCore = async function () {
 
 };
 
+/**
+ * 卸载 - 内部方法
+ * @private
+ */
+Mod.prototype._unload = async function () {
+  return this;
+};
+
 /**
  * 卸载
  */
 Mod.prototype.unload = async function () {
-
+  return await this._unload();
 };
 
 /**
@@ -330,21 +365,28 @@ Mod.prototype.end = async function () {
 };
 
 /**
- * 触发事件
- * @param {string} event 事件名
- * @param {...any} args 事件参数
+ * 获取事件管理器
+ * @returns {Eventer|null} 事件管理器
  */
-Mod.prototype.emitEvent = function (event, ...args) {
-  this._eventer?.emit(event, ...args);
+Mod.prototype.getEventer = function () {
+  return this._eventer || $.eventer;
 };
 
 /**
- * 运行方法
- * @param {...any} args 方法参数
- * @returns {Promise<any>} 方法执行结果
+ * 设置事件管理器
+ * @param {Eventer} eventer 事件管理器
  */
-Mod.prototype.run = async function (...args) {
-  return this.main(...args);
+Mod.prototype.setEventer = function (eventer) {
+  this._eventer = eventer;
+};
+
+/**
+ * 触发事件
+ * @param {string} event 事件名
+ * @param {...any} args 事件参数
+ */
+Mod.prototype.emitEvent = function (event, ...args) {
+  this.getEventer()?.emit(event, ...args);
 };
 
 /**
@@ -453,7 +495,7 @@ Mod.prototype._callBefore = async function (method, params) {
  * @returns {Promise<any>} 主方法结果
  */
 Mod.prototype._callMain = async function (method_func, params, result) {
-  let ret = await method_func.call(this._mod || this, ...params);
+  let ret = await method_func.call(this, ...params);
   // 修复：如果主方法返回undefined，则使用前置钩子的结果
   return ret !== undefined ? ret : result;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mm_machine",
-  "version": "2.4.3",
+  "version": "2.4.5",
   "description": "A flexible Node.js plugin mechanism system for dynamic loading, management and execution of modules. Supports hot reload, lifecycle management, and modern JavaScript features.",
   "main": "index.js",
   "scripts": {