mm_machine 2.2.6 → 2.2.8

package/drive.js

@@ -0,0 +1,598 @@
+const {
+  Mod
+} = require('./mod');
+require('mm_tpl');
+let {
+  conf
+} = require('mm_config');
+
+/**
+ * 驱动基础类
+ * @class
+ */
+class Drive extends Mod {
+  // 模块基础目录，用于放置脚本模板文件和配置模板文件
+  static base_dir = '';
+
+  // 配置项
+  static config = {
+    // 名称, 由中英文和下"_"组成, 用于卸载接口 例如: demo
+    name: '',
+    // 标题, 介绍作用
+    title: '',
+    // 描述, 用于描述该有什么用的
+    description: '',
+    // 文件路径, 当调用函数不存在时，会先从文件中加载
+    main: './index.js',
+    // 回调函数名 用于决定调用脚本的哪个函数
+    func_name: 'main',
+    // 作用域（同时作为检索的后缀名）
+    scope: ($.val && $.val.scope) ? $.val.scope : 'server',
+    // 排序
+    sort: 10,
+    // 状态, 0表示未启用, 1表示启用
+    state: 1,
+    // 显示, 0表示不显示, 1表示显示
+    show: 0,
+    // 是否结束，可选，默认false
+    end: false
+  };
+
+  /**
+   * 构造函数
+   * @param {object} config 配置项
+   * @param {object} parent 父项
+   * @class
+   */
+  constructor(config, parent) {
+    super(config, parent);
+    // 当前配置文件路径
+    this.config_file = '';
+
+    // 当前脚本文件路径
+    this.script_file = '';
+
+    // 模式: 1.生产模式 2.热更新模式 3.热重载模式 4.热更新+重载模式 5.重载模式
+    this.mode = 1;
+  }
+}
+
+/**
+ * 配置驱动
+ */
+Drive.prototype._preset = function () {
+  let file = this.config.main;
+  if (file) {
+    this.script_file = file.fullname(this._getDir());
+  }
+};
+
+/**
+ * 获取配置
+ * @param {string} file 配置文件路径
+ * @returns {object} 配置项
+ */
+Drive.prototype.loadConfig = function (file) {
+  if (file) {
+    this.config_file = file;
+  };
+  // 加载配置
+  let config = $.loadJson(this.config_file, (cg) => {
+    this.setConfig(cg);
+    return cg;
+  });
+  if (!config) {
+    this.newConfig(this.config_file);
+    config = $.loadJson(this.config_file, (cg) => {
+      this.setConfig(cg);
+      return cg;
+    });
+  }
+  this.setConfig(config);
+  return config;
+};
+
+/**
+ * 设置配置
+ * @param {object} config 配置对象
+ */
+Drive.prototype.setConfig = function (config) {
+  if (config) {
+    // 如果main改变，重置加载状态
+    if (config.main !== this.config.main) {
+      this.is_loaded = false;
+    }
+
+    if (this.config_file) {
+      // 合并配置并应用配置处理
+      this.config = conf({
+        ...this.config,
+        ...config
+      }, this.config_file);
+    }
+    else {
+      Object.assign(this.config, config);
+    }
+  }
+  this._preset();
+  return this.config;
+};
+
+/**
+ * 获取配置
+ * @returns {object} 配置项
+ */
+Drive.prototype.getConfig = function () {
+  return this.config;
+};
+
+/**
+ * 获取当前文件
+ * @returns {object} 当前文件对象
+ */
+Drive.prototype._getDir = function () {
+  let dir = this._dir;
+  if (!dir) {
+    if (this.script_file) {
+      dir = this.script_file.dirname();
+      this._dir = dir;
+    }
+    else if (this.config_file) {
+      dir = this.config_file.dirname();
+      this._dir = dir;
+    }
+  }
+  return dir;
+};
+
+/**
+ * 获取模块目录
+ * @returns {string} 模块目录
+ */
+Drive.prototype._getBaseDir = function () {
+  return this.getParent().getBaseDir();
+};
+
+/**
+ * 创建脚本
+ * @param {string} file 文件路径
+ * @param {object} model 模板数据
+ * @param {string} tpl_dir 模板文件路径
+ * @returns {boolean} 创建是否成功
+ */
+Drive.prototype._createScriptFile = function (file, model = {}, tpl_dir = '') {
+  var tpl = this.getScriptTpl(tpl_dir);
+  var content = $.tpl.render(tpl, model);
+  file.saveText(content);
+  return file;
+};
+
+/**
+ * 获取脚本模板
+ * @param {string} tpl_dir 模板文件路径
+ * @returns {string} 脚本模板内容
+ */
+Drive.prototype.getScriptTpl = function (tpl_dir = '') {
+  var f = './script.tpl.js'.fullname(tpl_dir || this._getBaseDir());
+  if (f.hasFile()) {
+    return f.loadText();
+  } else {
+    return `module.exports = {
+  /**
+   * 初始化
+   */
+  async _init() {
+    this.log('debug', \`初始化！\`);
+  },
+  /**
+   * 销毁
+   */
+  async _destroy(...args) {
+    this.log('debug', \`销毁！\`);
+  },
+  /**
+   * 主要逻辑
+   */
+  async main(...args) {
+    // 主要代码写在这
+  }
+}`;
+  }
+};
+
+/**
+ * 移除脚本
+ */
+Drive.prototype._remove = function () {
+  let file = this._getScriptFile();
+  if (!file) return;
+
+  try {
+    if (this.mode === 3 || this.mode === 4) {
+      // 移除模块和监听
+      $.mod.unload(file);
+    } else {
+      // 移除模块缓存
+      let filename = require.resolve(file);
+      if (require.cache[filename]) {
+        require.cache[filename] = null;
+        delete require.cache[filename];
+      }
+    }
+  } catch (err) {
+    this.log('error', `移除脚本失败: `, err);
+  }
+};
+
+/**
+ * 卸载脚本
+ */
+Drive.prototype.unloadScript = function () {
+  this._remove();
+  this.is_loaded = false;
+};
+
+/**
+ * 重新加载脚本
+ * @returns {object | null} 返回加载的模块对象
+ */
+Drive.prototype.reloadScript = function () {
+  this.unloadScript();
+  return this.loadScript();
+};
+
+/**
+ * 卸载之后处理
+ * @param {boolean} remove 是否删除文件
+ */
+Drive.prototype.unloadCore = async function (remove) {
+  // 删除脚本
+  this.unloadScript();
+  if (remove) {
+    this.delFile();
+  }
+};
+
+/**
+ * 获取脚本文件路径
+ * @param {string} file 文件路径
+ * @returns {string | null} 完整文件路径
+ */
+Drive.prototype._getScriptFile = function () {
+  let main = this.config.main || '';
+  if (!main) return null;
+
+  let filename = main.fullname(this._getDir());
+  if (!filename.hasFile()) {
+    this.newScript(filename);
+  }
+
+  return filename;
+};
+
+/**
+ * 加载脚本文件，支持热重载模式
+ * 在开发模式(mode=3或4)下使用 $.require 进行热重载
+ * 在生产模式下使用标准的 require 加载
+ * @returns {object | null} 加载的模块对象
+ */
+Drive.prototype.loadScript = function () {
+  let file = this._getScriptFile();
+  if (!file) return null;
+  if (this.mode === 3 || this.mode === 4) {
+    // 开发模式：使用 $.require 进行热重载，绑定热更新回调
+    var cs = $.require(file, (mod) => {
+      this._setMainMethod(mod);
+    });
+    this._setMainMethod(cs);
+    return cs;
+  } else {
+    var cs = require(file);
+    this._setMainMethod(cs);
+    return cs;
+  }
+};
+
+/**
+ * 设置主方法
+ * @param {object} mod 模块对象
+ */
+Drive.prototype._setMainMethod = function (mod) {
+  if (!mod) return;
+  let name = this.config.func_name || 'main';
+  if (name && mod[name]) {
+    this.main = mod[name];
+  }
+  if ($.push) {
+    $.push(this._methods, mod, true);
+  }
+  else {
+    Object.assign(this._methods, mod);
+  }
+  this.is_loaded = true;
+};
+
+/**
+ * 获取配置文件作用域
+ * @param {object} file 文件对象
+ * @returns {string} 配置文件作用域
+ */
+Drive.prototype._getScope = function (file) {
+  return file.replace(/\\/g, '/').between('app/', '/');
+};
+
+/**
+ * 新建配置文件
+ * @param {string} file 目标文件路径
+ */
+Drive.prototype.newConfig = function (file) {
+  if (!this.config.name) {
+    this.config.name = this._getName(file);
+    this.config.scope = this._getScope(file);
+  }
+  this._createConfigFile(file);
+};
+
+/**
+ * 创建配置文件
+ * @param {string} file 目标文件路径
+ * @returns {string} 配置文件内容
+ */
+Drive.prototype._createConfigFile = function (file) {
+  var tpl = this.getConfigTpl();
+  var content = $.tpl.render(tpl, this.config);
+  file.saveText(content);
+  return file;
+};
+
+/**
+ * 获取配置模板
+ * @param {string} tpl_dir 模板文件路径
+ * @returns {string} 配置模板内容
+ */
+Drive.prototype.getConfigTpl = function (tpl_dir = '') {
+  var f = './config.tpl.json'.fullname(tpl_dir || this._getBaseDir());
+  if (f.hasFile()) {
+    return f.loadText();
+  } else {
+    return `{
+  // 模块名称，必填
+  "name": "\${name}",
+  // 模块标题，可选，默认"示例标题"
+  "title": "\${title || "示例标题"}",
+  // 模块描述，可选，默认"示例描述"
+  "description": "\${description || "示例描述"}",
+  // 主脚本文件路径，可选，默认"./index.js"
+  "main": "\${main || "./index.js"}",
+  // 模块作用域，可选，默认"server"
+  "scope": "\${scope || "server"}",
+  // 模块状态，可选，默认1
+  "state": \${state || 1},
+  // 模块排序，可选，默认100
+  "sort": \${sort || 100},
+	// 是否结束，可选，默认false
+	"end": \${end || false}
+}`;
+  }
+};
+
+/**
+ * 加载配置文件
+ * @param {string} file 文件路径
+ * @param {string} name 配置项名称
+ * @returns {object | null} 配置对象
+ */
+Drive.prototype.loadFile = function (file, name) {
+  try {
+    let filename = file.fullname(this._getDir());
+    let text = filename.loadText();
+
+    // 如果文件不存在，创建新的配置文件
+    if (!text) {
+      this.newConfig(filename);
+      text = filename.loadText();
+    }
+
+    if (!text) return null;
+
+    let config = this._loadHotReload(filename);
+    let final_config = this._findConfigByName(config, name);
+    return final_config;
+  } catch (err) {
+    this.log('error', `加载配置文件失败: `, err);
+    return null;
+  }
+};
+
+/**
+ * 根据模式加载配置（支持热更新）
+ * @param {string} file 完整文件路径
+ * @returns {object | Array | null} 配置对象
+ */
+Drive.prototype._loadHotReload = function (file) {
+  if (this.mode === 2 || this.mode === 3 || this.mode === 4) {
+    return $.loadJson(file, this._handleHotReload.bind(this));
+  }
+  return file.loadJson();
+};
+
+/**
+ * 根据名称在配置数组中查找配置项
+ * @param {object | Array} config 配置对象或数组
+ * @param {string} name 配置项名称
+ * @returns {object | null} 匹配的配置项
+ */
+Drive.prototype._findConfigByName = function (config, name) {
+  if (!name || !Array.isArray(config)) return config;
+  return config.find((Drive) => Drive.name === name) || null;
+};
+
+/**
+ * 根据模式决定是否重新加载脚本
+ */
+Drive.prototype._reloadIfNeeded = function () {
+  if (this.mode === 3 || this.mode === 4) {
+    this.reloadScript();
+  }
+};
+
+/**
+ * 删除目录
+ */
+Drive.prototype.delDir = function () {
+  let main = this.config.main;
+  if (main && $.dir && $.dir.del) {
+    $.dir.del(this.dir);
+  }
+};
+
+/**
+ * 删除配置和脚本文件
+ * @returns {string | null} 错误消息，如果没有错误则返回null
+ */
+Drive.prototype.delFile = function () {
+  let name = this.config.name;
+  let file = this.script_file;
+
+  let error_message = null;
+  try {
+    if (!file || !file.hasFile) return null;
+
+    if (!file.hasFile()) {
+      return '配置文件不存在';
+    }
+
+    error_message = this._delConfigFile(file, name);
+  } catch (err) {
+    this.log('error', `删除文件失败: `, err);
+    error_message = `删除失败: ${err.message}`;
+  }
+  return error_message;
+};
+
+/**
+ * 删除配置文件
+ * @param {object} file 文件对象
+ * @param {string} name 配置名称
+ * @returns {string | null} 错误消息
+ */
+Drive.prototype._delConfigFile = function (file, name) {
+  let text = file.loadText();
+  if (!text) {
+    this.delDir();
+    return null;
+  }
+
+  let config = text.toJson();
+  if (Array.isArray(config)) {
+    return this._delArray(file, config, name);
+  }
+
+  this.delDir();
+  return null;
+};
+
+/**
+ * 从数组配置中删除指定项
+ * @param {object} file 文件对象
+ * @param {Array} config 配置数组
+ * @param {string} name 配置名称
+ * @returns {string | null} 错误消息
+ */
+Drive.prototype._delArray = function (file, config, name) {
+  let index = config.findIndex((Drive) => Drive.name === name);
+  if (index === -1) return null;
+
+  this.delDir();
+  config.splice(index, 1);
+
+  if (config.length > 0) {
+    file.saveText(JSON.stringify(config, null, 4));
+  } else if (file.delFile) {
+    file.delFile();
+  }
+
+  return null;
+};
+
+/**
+ * 获取配置文件名称
+ * @param {object} file 文件对象
+ * @returns {string} 配置文件名称
+ */
+Drive.prototype._getName = function (file) {
+  return file.dirname().basename();
+};
+
+/**
+ * 加载前处理
+ */
+Drive.prototype.loadBefore = async function () {
+  try {
+    let module = this.loadScript();
+    if (module) {
+      this.is_loaded = true;
+    }
+  } catch (err) {
+    this.log('error', `加载前处理失败: `, err);
+    this.is_loaded = false;
+  }
+};
+
+/**
+ * 加载处理
+ */
+Drive.prototype._loadCore = async function () {
+  this.loadConfig();
+  this.loadScript();
+};
+
+/**
+ * 保存配置
+ */
+Drive.prototype.save = function () {
+  try {
+    if (!this.script_file) return;
+
+    let file = this.script_file.fullname(this._getDir());
+    let text = file.loadText();
+
+    if (text && text.trim().startsWith('[')) {
+      // 数组格式配置
+      let config = text.toJson();
+      if (Array.isArray(config)) {
+        // 查找并更新现有配置项
+        let index = config.findIndex((Drive) => Drive.name === this.config.name);
+        if (index !== -1) {
+          config[index] = this.config;
+        } else {
+          // 如果不存在，添加新配置项
+          config.push(this.config);
+        }
+        file.saveText(JSON.stringify(config, null, 4));
+        return;
+      }
+    }
+
+    // 单对象格式配置，直接保存
+    file.saveText(JSON.stringify(this.config, null, 4));
+  } catch (err) {
+    this.log('error', `保存配置失败: `, err);
+  }
+};
+
+/**
+ * 触发事件
+ * @param {string} event 事件名
+ * @param {...any} args 事件参数
+ */
+Drive.prototype.emitEvent = function (event, ...args) {
+  this._eventer?.emit(event, ...args);
+};
+
+/**
+ * @module 导出Drive类
+ */
+module.exports = {
+  Drive
+};

package/index.js

@@ -67,7 +67,7 @@ Manager.prototype.newInfo = function (name, sort, state) {
  * @returns {string} 基础目录
  */
 Manager.prototype.getBaseDir = function () {
-  return this.config.base_dir;
+  return this.config.base_dir || __dirname;
 };
 
 /**
@@ -94,8 +94,8 @@ Manager.prototype.updateInfo = function () {
 Manager.prototype.sort = function () {
   var sort_key = this.config.sort_key || 'sort';
   this.infos.sort((o1, o2) => {
-    let p1 = o1[sort_key] || 0;
-    let p2 = o2[sort_key] || 0;
+    let p1 = o1[sort_key] || 100;
+    let p2 = o2[sort_key] || 100;
     return p1 - p2;
   });
 };
@@ -188,7 +188,7 @@ Manager.prototype.register = function (config_file, config = {}, script = {}) {
 Manager.prototype.load = async function (name) {
   let mod = this.getMod(name);
   if (mod) {
-    return await mod.exec('load');
+    return await mod.do('load');
   }
   return null;
 };
@@ -201,7 +201,7 @@ Manager.prototype.load = async function (name) {
 Manager.prototype.unload = async function (name) {
   let mod = this.getMod(name);
   if (mod) {
-    return await mod.exec('unload');
+    return await mod.do('unload');
   }
   return null;
 };
@@ -214,7 +214,7 @@ Manager.prototype.unload = async function (name) {
 Manager.prototype.reload = async function (name) {
   let mod = this.getMod(name);
   if (mod) {
-    return await mod.exec('reload');
+    return await mod.do('reload');
   }
   return null;
 };
@@ -251,7 +251,7 @@ Manager.prototype.loads = async function () {
   var promises = [];
   for (let name in this.mods) {
     let mod = this.mods[name];
-    promises.push(mod.exec('load'));
+    promises.push(mod.do('load'));
   }
   await Promise.all(promises);
 };
@@ -284,7 +284,7 @@ Manager.prototype.loadScripts = async function () {
   var promises = [];
   for (let name in this.mods) {
     let mod = this.mods[name];
-    promises.push(mod.exec('loadScript'));
+    promises.push(mod.call('loadScript'));
   }
   await Promise.all(promises);
 };
@@ -431,11 +431,11 @@ Manager.prototype._runSub = async function (mod, method, ...params) {
   try {
     // 确保模块已加载
     if (!mod.isLoaded()) {
-      await mod.do('loadScript');
+      await mod.call('loadScript');
     }
 
     // 执行方法
-    let ret = await mod.exec(method, ...params);
+    let ret = await mod.call(method, ...params);
     // 根据模式决定是否重载
     if (this.mode >= 4) {
       mod.do('reload');

package/mod.js

@@ -0,0 +1,480 @@
+const { Base } = require('mm_expand');
+require('mm_hot_reload');
+
+/**
+ * 增强require函数，专门用于脚本文件(.js)热重载
+ * 当脚本文件内容发生变化时，自动重新加载并触发回调
+ * @param {string} file 脚本文件路径(.js)
+ * @param {Function} func 热更新回调函数，文件变化时触发
+ * @returns {object} 加载的模块对象
+ * @throws {TypeError} 文件路径不是字符串或回调不是函数时抛出
+ */
+$.require = function (file, func) {
+  // 参数校验
+  if (typeof file !== 'string') {
+    throw new TypeError('文件路径必须是字符串');
+  }
+
+  if (func && typeof func !== 'function') {
+    throw new TypeError('回调函数必须是函数');
+  }
+
+  // 确保文件是.js文件
+  if (!file.endsWith('.js')) {
+    throw new TypeError('$.require 只能用于.js脚本文件');
+  }
+
+  return $.mod.load(file, func);
+};
+
+/**
+ * 增强JSON加载函数，专门用于配置文件(.json)热重载
+ * 当配置文件内容发生变化时，自动重新加载并触发回调
+ * @param {string} file 配置文件路径(.json)
+ * @param {Function} func 热更新回调函数，文件变化时触发
+ * @returns {object} 解析的JSON对象
+ * @throws {TypeError} 文件路径不是字符串或回调不是函数时抛出
+ */
+$.loadJson = function (file, func) {
+  // 参数校验
+  if (typeof file !== 'string') {
+    throw new TypeError('文件路径必须是字符串');
+  }
+
+  if (func && typeof func !== 'function') {
+    throw new TypeError('回调函数必须是函数');
+  }
+
+  // 确保文件是.json文件
+  if (!file.endsWith('.json')) {
+    throw new TypeError('$.loadJson 只能用于.json配置文件');
+  }
+  return $.mod.load(file, func);
+};
+
+/**
+ * 模块类
+ */
+class Mod extends Base {
+  /**
+   * 配置项
+   */
+  static config = {
+    // 模块名称
+    name: '',
+    // 模块描述
+    description: '',
+    // 状态, 可选值: 1-启用, 0-禁用
+    state: 1
+  };
+
+  /**
+   * 构造函数
+   * @param {object} config 配置项
+   * @param {object|null} parent 父对象
+   */
+  constructor(config, parent = null) {
+    super(config);
+    // 是否已加载
+    this.is_loaded = false;
+    // 追加查询到上级的方法
+    if (parent) {
+      this.getParent = function () {
+        return parent;
+      };
+    }
+  }
+}
+
+/**
+ * 检查模块是否已加载
+ * @returns {boolean} 是否已加载
+ */
+Mod.prototype.isLoaded = function () {
+  return this.is_loaded;
+};
+
+/**
+ * 日志输出
+ * @param {string} level 日志级别
+ * @param {string} message 日志消息
+ * @param  {...any} params 日志参数
+ */
+Mod.prototype.log = function (level, message, ...params) {
+  this.getLogger()[level](`[${this.constructor.name}] [${this.config.name}] ${message}`, ...params);
+};
+
+/**
+ * 监听事件
+ */
+Mod.prototype._listen = function () {
+  this._onLoad();
+  this._onInit();
+  this._onStart();
+  this._onStop();
+  this._onUnload();
+  this._onDestroy();
+};
+
+/**
+ * 监听销毁事件
+ */
+Mod.prototype._onDestroy = function () {
+  let status_last = 'stopped';
+  // 销毁
+  this.on('destroy:before', async (ctx) => {
+    status_last = this.getState();
+    this.setState('destroying');
+  });
+  this.on('destroy:after', async (ctx) => {
+    await this._destroyCore(...ctx.params);
+  });
+  this.on('destroy:success', (ctx) => {
+    this.setState('destroyed');
+  });
+  this.on('destroy:error', (ctx) => {
+    this.setState(status_last);
+  });
+};
+
+/**
+ * 监听加载事件
+ * @param {object} ctx 上下文对象
+ */
+Mod.prototype._onLoad = async function (ctx) {
+  let status_last = 'created';
+  // 1. 加载
+  this.on('load:before', async (ctx) => {
+    status_last = this.getState();
+    this.setState('loading');
+    await this._loadCore(...ctx.params);
+  });
+  this.on('load:after', (ctx) => {
+    this.setState('loaded');
+    this.is_loaded = true;
+  });
+};
+
+/**
+ * 监听启动事件
+ * @param {object} ctx 上下文对象
+ */
+Mod.prototype._onStart = async function (ctx) {
+  let status_last = 'inited';
+  // 3. 启动
+  this.on('start:before', async (ctx) => {
+    status_last = this.getState();
+    this.setState('starting');
+    await this._startCore(...ctx.params);
+  });
+  this.on('start:success', (ctx) => {
+    this.setState('running');
+  });
+  this.on('start:error', (ctx) => {
+    this.setState(status_last);
+  });
+};
+
+/**
+ * 监听停止事件
+ * @param {object} ctx 上下文对象
+ */
+Mod.prototype._onStop = async function (ctx) {
+  let status_last = 'running';
+  // 4. 停止
+  this.on('stop:before', async (ctx) => {
+    status_last = this.getState();
+    this.setState('stopping');
+  });
+  this.on('stop:after', async (ctx) => {
+    await this._stopCore(...ctx.params);
+  });
+  this.on('stop:success', async (ctx) => {
+    this.setState('stopped');
+  });
+  this.on('stop:error', (ctx) => {
+    this.setState(status_last);
+  });
+};
+
+/**
+ * 监听卸载事件
+ * @param {object} ctx 上下文对象
+ */
+Mod.prototype._onUnload = async function (ctx) {
+  let status_last = 'stopped';
+  // 5. 卸载
+  this.on('unload:before', (ctx) => {
+    status_last = this.getState();
+    this.setState('unloading');
+  });
+  this.on('unload:check', (ctx) => {
+    if (status_last !== 'stopped') {
+      status_last = this.getState();
+      ctx.error = new Error('卸载前必须先停止');
+    }
+  });
+  this.on('unload:after', async (ctx) => {
+    this.setState('unloaded');
+    this.is_loaded = false;
+    await this._unloadCore(...ctx.params);
+  });
+};
+
+/**
+ * 初始化监听
+ */
+Mod.prototype._onDestroy = async function (ctx) {
+  let status_last = 'unloaded';
+  this.on('destroy:check', (ctx) => {
+    if (status_last !== 'unloaded') {
+      status_last = this.getState();
+      ctx.error = new Error('销毁前必须先卸载');
+    }
+  });
+};
+
+/**
+ * 加载
+ */
+Mod.prototype.load = async function () {
+
+};
+
+/**
+ * 加载核心
+ */
+Mod.prototype._loadCore = async function () {
+
+};
+
+/**
+ * 启动
+ */
+Mod.prototype.start = async function () {
+
+};
+
+/**
+ * 启动核心
+ */
+Mod.prototype._startCore = async function () {
+
+};
+
+/**
+ * 停止
+ */
+Mod.prototype.stop = async function () {
+
+};
+
+/**
+ * 停止核心
+ */
+Mod.prototype._stopCore = async function () {
+
+};
+
+/**
+ * 卸载
+ */
+Mod.prototype.unload = async function () {
+
+};
+
+/**
+ * 卸载核心
+ */
+Mod.prototype._unloadCore = async function () {
+  if (this.methods) {
+    this.methods = {};
+  }
+};
+
+/**
+ * 重载
+ */
+Mod.prototype.reload = async function () {
+  await this.do('unload');
+  await this.do('load');
+};
+
+/**
+ * 重启
+ */
+Mod.prototype.restart = async function () {
+  await this.do('stop');
+  await this.do('start');
+};
+
+/**
+ * 是否运行中
+ * @returns {boolean} 是否运行中
+ */
+Mod.prototype.isRunning = function () {
+  return this.getState() === 'running';
+};
+
+/**
+ * 结束
+ */
+Mod.prototype.end = async function () {
+  await this.do('stop');
+  await this.do('unload');
+  await this.do('destroy');
+};
+
+/**
+ * 触发事件
+ * @param {string} event 事件名
+ * @param {...any} args 事件参数
+ */
+Mod.prototype.emitEvent = function (event, ...args) {
+  this._eventer?.emit(event, ...args);
+};
+
+/**
+ * 运行方法
+ * @param {string} method 方法名
+ * @param {...any} args 方法参数
+ * @returns {Promise<any>} 方法执行结果
+ */
+Mod.prototype.run = async function (method, ...args) {
+  return this.main(method, ...args);
+};
+
+/**
+ * 主方法
+ * @param {string} method 方法名
+ * @param {...any} args 方法参数
+ * @returns {Promise<any>} 方法执行结果
+ */
+Mod.prototype.main = async function (method, ...args) {
+  if (!this.methods?.[method]) {
+    throw new Error(`方法${method}不存在`);
+  }
+  return await this.methods[method](...args);
+};
+
+/**
+ * 设置脚本方法
+ * @param {object} methods 脚本方法对象
+ */
+Mod.prototype.setMethods = function (methods) {
+  if (!methods) return;
+  if (!this._methods) {
+    this._methods = {};
+  }
+  Object.assign(this._methods, methods);
+};
+
+/**
+ * 设置脚本方法
+ * @param {object} methods 脚本方法对象
+ */
+Mod.prototype.setMethod = function (method, func) {
+  if (!func) throw new Error(`函数(func)不能为空`);
+  if (!this._methods) {
+    this._methods = {};
+  }
+  this._methods[method] = func;
+};
+
+/**
+ * 获取方法函数
+ * @param {string} method 方法名
+ * @returns {Function|null} 方法函数
+ */
+Mod.prototype.getMethod = function (method) {
+  let func = this._methods && this._methods[method];
+  if (!func) {
+    func = this[method];
+  }
+  return func;
+};
+
+/**
+ * 调用函数（核心执行方法）
+ * @param {string} method 函数名
+ * @param {*} params 参数集合
+ * @returns {Promise<any>} 执行结果
+ */
+Mod.prototype.call = async function (method, ...params) {
+  let method_func = this.getMethod(method);
+  if (!method_func) return null;
+
+  let result;
+
+  try {
+    result = await this._callBefore(method, params);
+    if (result) return result;
+    result = await this._callMain(method_func, params, result);
+    result = await this._callAfter(method, params, result);
+  } catch (err) {
+    this.log('error', `执行方法 ${method} 失败: `, err);
+    return null;
+  }
+
+  return result;
+};
+
+/**
+ * 执行前置钩子
+ * @param {string} method 方法名
+ * @param {Array} params 参数
+ * @returns {Promise<any>} 前置钩子结果
+ */
+Mod.prototype._callBefore = async function (method, params) {
+  let before_method = `${method}Before`;
+  let before_func = this.getMethod(before_method);
+
+  if (!before_func) return undefined;
+
+  try {
+    let result = await before_func.call(this._mod || this, ...params);
+    return result;
+  } catch (err) {
+    this.log('error', `执行前置钩子 ${before_method} 失败: `, err);
+    return undefined;
+  }
+};
+
+/**
+ * 执行主方法
+ * @param {Function} method_func 方法函数
+ * @param {Array} params 参数
+ * @param {any} result 前置钩子结果
+ * @returns {Promise<any>} 主方法结果
+ */
+Mod.prototype._callMain = async function (method_func, params, result) {
+  let method_result = await method_func.call(this._mod || this, ...params);
+  // 修复：如果主方法返回undefined，则使用前置钩子的结果
+  return method_result !== undefined ? method_result : result;
+};
+
+/**
+ * 执行后置钩子
+ * @param {string} method 方法名
+ * @param {Array} params 参数
+ * @param {any} result 主方法结果
+ * @returns {Promise<any>} 后置钩子结果
+ */
+Mod.prototype._callAfter = async function (method, params, result) {
+  let after_method = `${method}After`;
+  let after_func = this.getMethod(after_method);
+
+  if (!after_func) return result;
+
+  try {
+    let after = await after_func.call(this._mod || this, result, ...params);
+    return after !== undefined ? after : result;
+  } catch (err) {
+    this.log('error', `执行后置钩子 ${after_method} 失败: `, err);
+    return result;
+  }
+};
+
+module.exports = {
+  Mod
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mm_machine",
-  "version": "2.2.6",
+  "version": "2.2.8",
   "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": {
@@ -27,9 +27,9 @@
     "node": ">=12.0.0"
   },
   "files": [
-    "base.js",
+    "mod.js",
     "index.js",
-    "item.js",
+    "drive.js",
     "README.md"
   ],
   "dependencies": {