@yumerijs/core 1.1.0 → 1.1.2

package/dist/core.d.ts

@@ -18,6 +18,14 @@ interface PluginLoader {
     installPluginDependencies(pluginName: string): Promise<void>;
     logger: Logger;
 }
+/**
+ * 定义插件状态枚举
+ */
+export declare const enum PluginStatus {
+    ENABLED = "enabled",// 正常启用
+    DISABLED = "disabled",// 已禁用
+    PENDING = "pending"
+}
 export declare class Core {
     plugins: {
         [name: string]: Plugin & {
@@ -45,116 +53,125 @@ export declare class Core {
     evttoplu: Record<string, Record<string, ((...args: any[]) => Promise<void>)[]>>;
     mdwtoplu: Record<string, string>;
     plftoplu: Record<string, string>;
-    /**
-     * 创建Core实例
-     * @param pluginLoader 插件加载器
-     */
+    pluginStatus: Record<string, PluginStatus>;
     constructor(pluginLoader: PluginLoader);
     /**
      * 加载配置文件
-     * @param configPath 配置文件路径
+     * @param configPath 配置文件的路径
      */
     loadConfig(configPath: string): Promise<void>;
     /**
-     * 监听配置文件变化
-     * @param configPath 配置文件路径
+     * 监听配置文件变化，实现热重载
+     * @param configPath 配置文件的路径
      */
     private watchConfig;
     /**
-     * 获取插件配置
+     * 获取指定插件的配置
      * @param pluginName 插件名称
-     * @returns 配置
+     * @returns 插件的配置对象
      */
     getPluginConfig(pluginName: string): Promise<Config>;
     /**
-     * 加载插件
-     * @returns Promise<void>
+     * 加载所有在配置文件中启用的插件
      */
     loadPlugins(): Promise<void>;
     /**
-     * 监听插件目录，实现热重载
-     * @param core Core实例
-     * @param pluginsDir 插件目录
+     * 导出的函数：加载单个插件
+     * @param pluginName 要加载的插件名
+     * @param triggerPendingCheck 是否在加载后触发对其他待定插件的检查，默认为 true
+     * @returns Promise<boolean> 是否加载成功
      */
-    watchPlugins(core: Core, pluginsDir?: string): void;
+    loadSinglePlugin(pluginName: string, triggerPendingCheck?: boolean): Promise<boolean>;
+    /**
+     * 内部函数：尝试加载所有处于 PENDING 状态的插件
+     */
+    private _loadPendingPlugins;
+    /**
+     * 卸载插件，并递归卸载依赖于它的其他插件
+     * @param pluginNameToUnload 要卸载的插件名
+     */
+    unloadPlugin(pluginNameToUnload: string): Promise<void>;
+    /**
+     * 内部函数：执行单个插件的卸载逻辑
+     * @param pluginName 插件名
+     */
+    private _unloadSinglePlugin;
     /**
      * 重新加载插件
      * @param pluginName 插件名称
-     * @param core Core实例
      */
-    reloadPlugin(pluginName: string, core: Core): Promise<void>;
+    reloadPlugin(pluginName: string): Promise<void>;
     /**
-     * 卸载插件并触发事件
-     * @param pluginName 插件名称
-     * @param core Core实例
+     * 监听插件文件变化，实现热更新
+     * @param core Core 实例
+     * @param pluginsDir 插件目录，默认为 'plugins'
      */
-    unloadPluginAndEmit(pluginName: string, core: Core): Promise<void>;
+    watchPlugins(core: Core, pluginsDir?: string): void;
     /**
      * 注册组件
      * @param name 组件名称
-     * @param component 组件
-     * @returns void
+     * @param component 组件实例
      */
     registerComponent(name: string, component: any): void;
     /**
      * 获取组件
      * @param name 组件名称
-     * @returns 组件
+     * @returns 组件实例
      */
     getComponent(name: string): any;
     /**
-     * 取消注册组件
+     * 注销组件
      * @param name 组件名称
      */
     unregisterComponent(name: string): void;
     /**
-     * 监听事件
+     * 注册事件监听器
      * @param event 事件名称
-     * @param listener 回调函数
+     * @param listener 事件回调函数
      */
     on(event: string, listener: (...args: any[]) => Promise<void>): void;
     /**
      * 触发事件
      * @param event 事件名称
-     * @param args 参数
+     * @param args 传递给事件监听器的参数
      */
     emit(event: string, ...args: any[]): Promise<void>;
     /**
      * 注册全局中间件
      * @param name 中间件名称
-     * @param middleware 中间件
-     * @returns Core对象
+     * @param middleware 中间件函数
+     * @returns Core 实例
      */
     use(name: string, middleware: Middleware): Core;
     /**
-     * 定义指令
-     * @param name 指令名称
-     * @returns 指令对象
+     * 注册命令
+     * @param name 命令名称
+     * @returns Command 实例
      */
     command(name: string): Command;
     /**
-     * 执行指令
-     * @param name 指令名称
-     * @param session 会话
-     * @param args 参数
-     * @returns 回话/null
+     * 执行命令
+     * @param name 命令名称
+     * @param session 会话对象
+     * @param args 传递给命令处理函数的参数
+     * @returns 会话对象或 null
      */
     executeCommand(name: string, session: any, ...args: any[]): Promise<Session | null>;
     /**
      * 注册平台
-     * @param platform 平台名称
-     * @returns 启动结果
+     * @param platform 平台实例
+     * @returns 平台启动结果
      */
     registerPlatform(platform: Platform): any;
     /**
-     * 取消注册插件
+     * 清理指定插件注册的所有内容
      * @param pluginname 插件名称
      */
     unregall(pluginname: string): void;
     /**
-     * 获取指令对象
-     * @param name 指令名称
-     * @returns null/指令对象
+     * 获取命令
+     * @param name 命令名称
+     * @returns Command 实例或 null
      */
     getCommand(name: string): Command | null;
 }

package/dist/core.js

@@ -38,8 +38,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Core = void 0;
 /**
- * @time: 2025/04/20 11:45
- * @author: FireGuo
+ * @time: 2025/07/12 18:14
+ * @author: FireGuo & Manus
  * WindyPear-Team All right reserved
  **/
 const yaml = __importStar(require("js-yaml"));
@@ -61,43 +61,39 @@ class Core {
     logger = new logger_1.Logger('core');
     providedComponents = {};
     pluginModules = {};
-    configPath = ''; // 存储配置文件路径
-    globalMiddlewares = {}; // 全局中间件数组
-    cmdtoplu = {}; // 存储命令与插件名的映射关系
-    comtoplu = {}; // 存储组件与插件名的映射关系
-    evttoplu = {}; // 存储事件与插件名的映射关系
-    mdwtoplu = {}; // 存储中间件与插件名的映射关系
-    plftoplu = {}; // 存储平台与插件名的映射关系
-    /**
-     * 创建Core实例
-     * @param pluginLoader 插件加载器
-     */
+    configPath = '';
+    globalMiddlewares = {};
+    cmdtoplu = {};
+    comtoplu = {};
+    evttoplu = {};
+    mdwtoplu = {};
+    plftoplu = {};
+    pluginStatus = {};
     constructor(pluginLoader) {
         this.pluginLoader = pluginLoader;
     }
     /**
      * 加载配置文件
-     * @param configPath 配置文件路径
+     * @param configPath 配置文件的路径
      */
     async loadConfig(configPath) {
         try {
-            this.configPath = configPath; // 保存配置文件路径
+            this.configPath = configPath;
             const doc = yaml.load(fs.readFileSync(configPath, 'utf8'));
             this.config = doc;
             this.logger.info('Config loaded.');
-            // 开发环境下监听配置文件变化
             if (process.env.NODE_ENV === 'development') {
                 this.watchConfig(configPath);
             }
         }
         catch (e) {
             this.logger.error('Failed to load config:', e);
-            throw e; // 抛出异常，让上层处理
+            throw e;
         }
     }
     /**
-     * 监听配置文件变化
-     * @param configPath 配置文件路径
+     * 监听配置文件变化，实现热重载
+     * @param configPath 配置文件的路径
      */
     watchConfig(configPath) {
         const watcher = chokidar_1.default.watch(configPath, {
@@ -109,30 +105,26 @@ class Core {
             },
         });
         watcher.on('change', async () => {
-            //this.logger.info('Config file changed, reloading...');
             try {
-                // 重新加载配置文件
                 const doc = yaml.load(fs.readFileSync(configPath, 'utf8'));
-                this.config = doc;
-                // this.logger.info('Config reloaded successfully.');
-                // 触发配置变更事件
+                if (doc && doc.plugins) {
+                    this.config.plugins = doc.plugins;
+                }
                 await this.emit('config-changed', this.config);
             }
             catch (error) {
-                // this.logger.error('Failed to reload config:', error);
+                this.logger.error('Failed to reload config:', error);
             }
         });
         this.logger.info(`Watching for config changes at ${configPath}`);
     }
     /**
-     * 获取插件配置
+     * 获取指定插件的配置
      * @param pluginName 插件名称
-     * @returns 配置
+     * @returns 插件的配置对象
      */
     async getPluginConfig(pluginName) {
-        // 如果插件名以~开头，则去掉~前缀获取配置
         const actualPluginName = pluginName.startsWith('~') ? pluginName.substring(1) : pluginName;
-        // 如果配置文件路径存在且处于开发模式，每次都重新读取配置文件
         if (this.configPath && process.env.NODE_ENV === 'development') {
             try {
                 const doc = yaml.load(fs.readFileSync(this.configPath, 'utf8'));
@@ -147,129 +139,221 @@ class Core {
         if (!this.config.plugins[actualPluginName]) {
             return new config_1.Config(actualPluginName);
         }
-        const config = new config_1.Config(actualPluginName, this.config.plugins[actualPluginName]);
-        return config;
+        return new config_1.Config(actualPluginName, this.config.plugins[actualPluginName]);
     }
     /**
-     * 加载插件
-     * @returns Promise<void>
+     * 加载所有在配置文件中启用的插件
      */
     async loadPlugins() {
-        // 检查 plugins 配置是否存在且是对象类型
         if (!this.config || typeof this.config.plugins !== 'object' || this.config.plugins === null) {
-            this.logger.info('No plugins configuration found or it is not an object. No plugins to load.');
+            this.logger.info('No plugins configuration found. No plugins to load.');
             return;
         }
-        // 获取所有需要加载的插件名，过滤掉以~开头的插件（禁用的插件）
-        const pluginNamesToLoad = Object.keys(this.config.plugins).filter(name => !name.startsWith('~'));
-        if (pluginNamesToLoad.length === 0) {
-            this.logger.info('No enabled plugins found in configuration. All plugins might be disabled or configuration is empty.');
-            return;
+        const allPluginNames = Object.keys(this.config.plugins);
+        this.pluginStatus = {}; // 重置状态
+        // 初始化所有插件的状态
+        for (const name of allPluginNames) {
+            if (name.startsWith('~')) {
+                const actualName = name.substring(1);
+                this.pluginStatus[actualName] = "disabled" /* PluginStatus.DISABLED */;
+            }
+            else {
+                this.pluginStatus[name] = "pending" /* PluginStatus.PENDING */; // 默认为等待加载
+            }
         }
-        // 记录被禁用的插件
-        const disabledPlugins = Object.keys(this.config.plugins).filter(name => name.startsWith('~'));
-        if (disabledPlugins.length > 0) {
-            this.logger.info(`Skipping disabled plugins: ${disabledPlugins.join(', ')}`);
+        const enabledPlugins = allPluginNames.filter(name => !name.startsWith('~'));
+        if (enabledPlugins.length === 0) {
+            this.logger.info('No enabled plugins found in configuration.');
+            return;
         }
-        const loadedPluginNames = [];
-        // 使用对象来跟踪尝试加载的插件名
-        let loadAttempted = {};
-        // 使用插件名数组来管理剩余待加载的插件
-        let remainingPluginNames = [...pluginNamesToLoad];
-        // 不加载名称以~开头的插件
-        remainingPluginNames = remainingPluginNames.filter(name => !name.startsWith('~'));
-        // 多次尝试加载插件，直到所有插件加载完毕或检测到循环依赖
-        while (remainingPluginNames.length > 0) {
-            let loadedInThisPass = false;
-            // 用于存储下一轮尝试加载的插件名
-            const nextRemainingPluginNames = [];
-            // 遍历当前剩余待加载的插件名
-            for (const pluginName of remainingPluginNames) {
-                // 如果插件已经加载或已尝试加载，则跳过
-                if (loadedPluginNames.includes(pluginName) || loadAttempted[`${pluginName}`]) {
+        // this.logger.info(`Disabled plugins: ${Object.keys(this.pluginStatus).filter(p => this.pluginStatus[p] === PluginStatus.DISABLED).join(', ') || 'None'}`);
+        // 循环加载，直到没有插件可以被加载
+        let loadedInLastPass = true;
+        while (loadedInLastPass) {
+            loadedInLastPass = false;
+            for (const pluginName of enabledPlugins) {
+                // 如果插件已经是启用状态，则跳过
+                if (this.pluginStatus[pluginName] === "enabled" /* PluginStatus.ENABLED */) {
                     continue;
                 }
-                // 标记该插件已尝试加载
-                loadAttempted[`${pluginName}`] = true;
-                try {
-                    this.logger.info(`Attempting to load plugin: ${pluginName}`);
-                    // 使用插件名加载插件实例和模块
-                    const pluginInstance = await this.pluginLoader.load(pluginName);
-                    //const pluginModule = await this.importPluginModule(pluginName);
-                    if (pluginInstance) {
-                        const depend = pluginInstance.depend;
-                        const provide = pluginInstance.provide;
-                        // 检查依赖是否满足 (此处仍然检查 this.components，请确保 this.components 在此阶段已包含必要的基准组件)
-                        const unmetDependencies = depend?.filter(dep => !this.components.hasOwnProperty(dep)) || [];
-                        if (unmetDependencies.length === 0) {
-                            // 将加载成功并满足依赖的插件存储起来
-                            this.plugins[`${pluginName}`] = Object.assign(pluginInstance, { depend, provide });
-                            //this.pluginModules[`${pluginName}`] = pluginModule;
-                            //this.logger.info(`Plugin ${pluginName} loaded.`);
-                            loadedPluginNames.push(pluginName);
-                            loadedInThisPass = true; // 标记本轮有插件加载成功
-                            if (loadedInThisPass && pluginInstance && pluginInstance.apply) {
-                                await pluginInstance.apply(new context_1.Context(this, pluginName), await this.getPluginConfig(pluginName));
-                                // 使用 pluginName
-                                this.pluginLoader.logger.info(`apply plugin ${pluginName}`);
-                            }
-                            // 记录该插件提供了哪些组件
-                            if (provide) {
-                                for (const componentName of provide) {
-                                    if (this.providedComponents.hasOwnProperty(componentName)) {
-                                        this.logger.error(`Multiple plugins provide the component "${componentName}". Provided by "${this.providedComponents[`${componentName}`]}" and "${pluginName}". Only the first loaded will be active.`);
-                                    }
-                                    else {
-                                        this.providedComponents[`${componentName}`] = pluginName;
-                                    }
-                                }
-                            }
-                        }
-                        else {
-                            // 如果存在未满足的依赖，将插件名放回下一轮尝试加载列表
-                            nextRemainingPluginNames.push(pluginName);
-                            /*this.logger.warn(
-                              `Plugin ${pluginName} has unmet dependencies: ${unmetDependencies.join(', ')}. Will try again later.`
-                            );*/
-                        }
+                // 尝试加载单个插件
+                const success = await this.loadSinglePlugin(pluginName, false); // 内部加载，不触发后续的pending检查
+                if (success) {
+                    loadedInLastPass = true;
+                }
+            }
+        }
+        // 加载完所有能加载的插件后，统一检查并加载待定插件
+        await this._loadPendingPlugins();
+        const pendingPlugins = Object.keys(this.pluginStatus).filter(p => this.pluginStatus[p] === "pending" /* PluginStatus.PENDING */);
+        if (pendingPlugins.length > 0) {
+            // this.logger.warn('Some plugins could not be loaded due to unresolved dependencies:', pendingPlugins);
+        }
+        if (process.env.NODE_ENV === 'development') {
+            this.watchPlugins(this);
+        }
+    }
+    /**
+     * 导出的函数：加载单个插件
+     * @param pluginName 要加载的插件名
+     * @param triggerPendingCheck 是否在加载后触发对其他待定插件的检查，默认为 true
+     * @returns Promise<boolean> 是否加载成功
+     */
+    async loadSinglePlugin(pluginName, triggerPendingCheck = true) {
+        // 如果插件不存在于状态记录中（例如，动态添加），则设为 PENDING
+        if (!this.pluginStatus[pluginName]) {
+            this.pluginStatus[pluginName] = "pending" /* PluginStatus.PENDING */;
+        }
+        // 只有 PENDING 状态的插件才能被加载
+        if (this.pluginStatus[pluginName] !== "pending" /* PluginStatus.PENDING */) {
+            // this.logger.info(`Plugin "${pluginName}" is not in a pending state (current: ${this.pluginStatus[pluginName]}). Skipping load.`);
+            return false;
+        }
+        try {
+            const pluginInstance = await this.pluginLoader.load(pluginName);
+            if (!pluginInstance) {
+                throw new Error('Plugin loader returned no instance.');
+            }
+            const deps = pluginInstance.depend || [];
+            const unmetDependencies = deps.filter(dep => !this.providedComponents[dep]);
+            if (unmetDependencies.length > 0) {
+                // this.logger.info(`Plugin "${pluginName}" has unmet dependencies: [${unmetDependencies.join(', ')}]. Will retry later.`);
+                return false;
+            }
+            // 依赖满足，开始加载
+            this.plugins[pluginName] = pluginInstance;
+            if (pluginInstance.apply) {
+                await pluginInstance.apply(new context_1.Context(this, pluginName), await this.getPluginConfig(pluginName));
+                this.pluginLoader.logger.info(`Applied plugin "${pluginName}"`);
+            }
+            // 注册提供的组件
+            if (pluginInstance.provide) {
+                for (const componentName of pluginInstance.provide) {
+                    if (this.providedComponents[componentName]) {
+                        this.logger.error(`Component "${componentName}" is provided by multiple plugins: "${this.providedComponents[componentName]}" and "${pluginName}".`);
                     }
                     else {
-                        //this.logger.warn(`Plugin "${pluginName}" could not be loaded or its module could not be imported.`);
+                        this.providedComponents[componentName] = pluginName;
                     }
                 }
-                catch (err) {
-                    this.pluginLoader.logger.error(`Failed to load or process plugin ${pluginName}:`, err);
-                    // 如果加载或处理失败，不将其加入下一轮尝试列表，但也不标记为已加载成功
+            }
+            this.pluginStatus[pluginName] = "enabled" /* PluginStatus.ENABLED */; // 更新状态为已启用
+            // this.logger.info(`Plugin "${pluginName}" loaded successfully.`);
+            // 加载成功后，检查是否可以加载其他等待中的插件
+            if (triggerPendingCheck) {
+                await this._loadPendingPlugins();
+            }
+            return true;
+        }
+        catch (err) {
+            this.pluginLoader.logger.error(`Failed to load plugin "${pluginName}":`, err);
+            // 加载失败的插件保持 PENDING 状态，以便后续重试
+            return false;
+        }
+    }
+    /**
+     * 内部函数：尝试加载所有处于 PENDING 状态的插件
+     */
+    async _loadPendingPlugins() {
+        const pendingPlugins = Object.keys(this.pluginStatus).filter(p => this.pluginStatus[p] === "pending" /* PluginStatus.PENDING */);
+        if (pendingPlugins.length === 0)
+            return;
+        // this.logger.info('Checking pending plugins...');
+        for (const pluginName of pendingPlugins) {
+            await this.loadSinglePlugin(pluginName, false); // 递归调用，但不触发顶层的pending检查
+        }
+    }
+    /**
+     * 卸载插件，并递归卸载依赖于它的其他插件
+     * @param pluginNameToUnload 要卸载的插件名
+     */
+    async unloadPlugin(pluginNameToUnload) {
+        // 1. 找出所有直接或间接依赖于此插件的插件
+        const dependents = [];
+        const pluginsToCheck = [pluginNameToUnload];
+        while (pluginsToCheck.length > 0) {
+            const currentPluginName = pluginsToCheck.shift();
+            const provided = this.plugins[currentPluginName]?.provide || [];
+            if (provided.length === 0)
+                continue;
+            for (const pluginName in this.plugins) {
+                if (dependents.includes(pluginName) || pluginName === pluginNameToUnload)
+                    continue;
+                const deps = this.plugins[pluginName].depend || [];
+                if (provided.some(p => deps.includes(p))) {
+                    if (!dependents.includes(pluginName)) {
+                        dependents.push(pluginName);
+                        pluginsToCheck.push(pluginName); // 递归查找
+                        // this.logger.info(`Plugin "${pluginName}" depends on "${currentPluginName}" and will be unloaded.`);
+                    }
                 }
             }
-            // 如果本轮没有插件加载成功，并且剩余插件列表没有变化，则检测到循环或无法解决的依赖
-            if (!loadedInThisPass && nextRemainingPluginNames.length === remainingPluginNames.length && remainingPluginNames.length > 0) {
-                this.logger.error('Detected circular or unresolvable plugin dependencies. Remaining plugins:', nextRemainingPluginNames.map(name => name) // 映射回插件名
-                );
-                break; // 防止无限循环
+        }
+        // 2. 卸载所有依赖者
+        for (const dependentName of dependents) {
+            await this._unloadSinglePlugin(dependentName);
+        }
+        // 3. 最后卸载目标插件
+        await this._unloadSinglePlugin(pluginNameToUnload);
+        // 4. 卸载完成后，尝试重新加载处于 PENDING 状态的插件
+        // await this._loadPendingPlugins();
+    }
+    /**
+     * 内部函数：执行单个插件的卸载逻辑
+     * @param pluginName 插件名
+     */
+    async _unloadSinglePlugin(pluginName) {
+        if (this.pluginStatus[pluginName] !== "enabled" /* PluginStatus.ENABLED */) {
+            return; // 只卸载已启用的插件
+        }
+        this.logger.info(`Unloading plugin "${pluginName}"...`);
+        try {
+            const plugin = this.plugins[pluginName];
+            if (plugin && plugin.disable) {
+                await plugin.disable(new context_1.Context(this, pluginName));
             }
-            // 更新剩余待加载插件列表为下一轮的列表
-            remainingPluginNames = nextRemainingPluginNames;
+            await this.pluginLoader.unloadPlugin(pluginName);
+            this.unregall(pluginName); // 清理该插件注册的所有内容
+            delete this.plugins[pluginName];
+            delete this.pluginModules[pluginName];
+            // 更新状态为 PENDING，因为它的配置仍然是启用的
+            // 如果它被其他插件依赖，当那个插件被卸载时，它也会被重新评估
+            this.pluginStatus[pluginName] = "pending" /* PluginStatus.PENDING */;
+            this.emit('plugin-unloaded', pluginName);
+            // this.logger.info(`Plugin "${pluginName}" unloaded.`);
         }
-        // 警告未加载成功的插件
-        if (remainingPluginNames.length > 0) {
-            this.logger.warn('Some plugins could not be fully loaded due to unresolved dependencies or errors:', remainingPluginNames.map(name => name) // 映射回插件名
-            );
+        catch (error) {
+            this.logger.error(`Failed to unload plugin "${pluginName}":`, error);
         }
-        // 开发环境下监听插件变化
-        if (process.env.NODE_ENV === 'development') {
-            this.watchPlugins(this);
+    }
+    /**
+     * 重新加载插件
+     * @param pluginName 插件名称
+     */
+    async reloadPlugin(pluginName) {
+        // this.logger.info(`Reloading plugin "${pluginName}"...`);
+        // 1. 递归卸载插件及其依赖者
+        await this.unloadPlugin(pluginName);
+        // 2. 重新加载该插件
+        // unloadPlugin 已经将状态设置为 PENDING，所以 loadSinglePlugin 可以直接工作
+        const success = await this.loadSinglePlugin(pluginName);
+        if (success) {
+            // this.logger.info(`Plugin "${pluginName}" reloaded successfully.`);
+            this.emit('plugin-reloaded', pluginName);
+        }
+        else {
+            this.logger.error(`Failed to reload plugin "${pluginName}". It may have unmet dependencies.`);
         }
     }
     /**
-     * 监听插件目录，实现热重载
-     * @param core Core实例
-     * @param pluginsDir 插件目录
+     * 监听插件文件变化，实现热更新
+     * @param core Core 实例
+     * @param pluginsDir 插件目录，默认为 'plugins'
      */
     watchPlugins(core, pluginsDir = 'plugins') {
         const logger = new logger_1.Logger('hmr');
         const watcher = chokidar_1.default.watch(pluginsDir, {
-            ignored: /(^|[/\\])\../, // 忽略点文件
+            ignored: /(^|[/\\])\../,
             persistent: true,
             ignoreInitial: true,
             awaitWriteFinish: {
@@ -277,167 +361,84 @@ class Core {
                 pollInterval: 100,
             },
         });
-        watcher.on('change', async (changePath) => {
+        const getPluginNameFromPath = (changePath) => {
             if (!changePath.endsWith('.ts') && !changePath.endsWith('.js'))
-                return;
+                return null;
             const parts = changePath.split(path.sep);
-            if (parts.length < 2)
-                return;
-            const pluginName = parts[1];
-            this.logger.info(`Plugin file changed: ${changePath}`);
-            this.reloadPlugin(pluginName, core);
+            return parts.length > 1 ? parts[1] : null;
+        };
+        watcher.on('change', async (changePath) => {
+            const pluginName = getPluginNameFromPath(changePath);
+            if (pluginName) {
+                logger.info(`Plugin file changed: ${changePath}`);
+                await core.reloadPlugin(pluginName);
+            }
         });
         watcher.on('add', async (changePath) => {
-            if (!changePath.endsWith('.ts') && !changePath.endsWith('.js'))
-                return;
-            const parts = changePath.split(path.sep);
-            if (parts.length < 2)
-                return;
-            const pluginName = parts[1];
-            this.logger.info(`New plugin file added: ${changePath}`);
-            this.reloadPlugin(pluginName, core);
+            const pluginName = getPluginNameFromPath(changePath);
+            if (pluginName) {
+                logger.info(`New plugin file added: ${changePath}`);
+                await core.reloadPlugin(pluginName);
+            }
         });
         watcher.on('unlink', async (changePath) => {
-            if (!changePath.endsWith('.ts') && !changePath.endsWith('.js'))
-                return;
-            const parts = changePath.split(path.sep);
-            if (parts.length < 2)
-                return;
-            const pluginName = parts[1];
-            this.logger.info(`Plugin file removed: ${changePath}`);
-            await this.unloadPluginAndEmit(pluginName, core);
+            const pluginName = getPluginNameFromPath(changePath);
+            if (pluginName) {
+                logger.info(`Plugin file removed: ${changePath}`);
+                await core.unloadPlugin(pluginName);
+            }
         });
         logger.info(`Watching for plugin changes in ${pluginsDir}`);
     }
-    /**
-     * 重新加载插件
-     * @param pluginName 插件名称
-     * @param core Core实例
-     */
-    async reloadPlugin(pluginName, core) {
-        try {
-            // 强制重新读取配置文件，确保获取最新配置
-            if (this.configPath && process.env.NODE_ENV === 'development') {
-                try {
-                    const doc = yaml.load(fs.readFileSync(this.configPath, 'utf8'));
-                    if (doc && doc.plugins) {
-                        this.config.plugins = doc.plugins;
-                    }
-                }
-                catch (error) {
-                    this.logger.warn('Failed to refresh config for plugin reload:', error);
-                }
-            }
-            // 获取最新的插件配置
-            const config = await core.getPluginConfig(pluginName);
-            // 加载插件实例
-            const plugin = await core.pluginLoader.load(pluginName);
-            // 如果插件存在，先禁用旧实例
-            if (plugin && plugin.disable) {
-                await plugin.disable(new context_1.Context(this, pluginName));
-            }
-            // 清理插件提供的组件
-            // if (plugin.provide) {
-            //   for (let providedmodules of plugin.provide) {
-            //     if (this.components[`${providedmodules}`]) {
-            //       this.unregisterComponent(providedmodules);
-            //     }
-            //   }
-            // }
-            // 卸载插件
-            await core.unloadPluginAndEmit(pluginName, core);
-            // 应用新的插件实例
-            if (plugin && plugin.apply) {
-                await plugin.apply(new context_1.Context(this, pluginName), config);
-            }
-            this.pluginLoader.logger.info(`apply plugin ${pluginName}`);
-            // 触发插件重载事件
-            core.emit('plugin-reloaded', pluginName);
-        }
-        catch (error) {
-            this.logger.error(`Failed to reload plugin ${pluginName}:`, error);
-        }
-    }
-    /**
-     * 卸载插件并触发事件
-     * @param pluginName 插件名称
-     * @param core Core实例
-     */
-    async unloadPluginAndEmit(pluginName, core) {
-        try {
-            const plugin = core.plugins[`${pluginName}`];
-            if (plugin && plugin.disable) {
-                await plugin.disable(new context_1.Context(this, pluginName));
-            }
-            await core.pluginLoader.unloadPlugin(pluginName);
-            delete core.plugins[`${pluginName}`];
-            delete this.pluginModules[`${pluginName}`];
-            // Remove provided components from this plugin
-            // for (const componentName in this.providedComponents) {
-            //   if (this.providedComponents[`${componentName}`] === pluginName) {
-            //     delete this.components[`${componentName}`];
-            //     delete this.providedComponents[`${componentName}`];
-            //   }
-            // }
-            this.unregall(pluginName);
-            core.emit('plugin-unloaded', pluginName);
-        }
-        catch (error) {
-            this.logger.error(`Failed to unload plugin ${pluginName}:`, error);
-        }
-    }
     /**
      * 注册组件
      * @param name 组件名称
-     * @param component 组件
-     * @returns void
+     * @param component 组件实例
      */
     registerComponent(name, component) {
         if (this.components.hasOwnProperty(name)) {
-            this.logger.warn(`Component "${name}" already registered by plugin "${this.providedComponents[`${name}`]}".`);
+            this.logger.warn(`Component "${name}" already registered by plugin "${this.providedComponents[name]}".`);
             return;
         }
-        this.components[`${name}`] = component;
-        this.logger.info(`Component "${name}" registered.`);
+        this.components[name] = component;
+        // this.logger.info(`Component "${name}" registered.`);
     }
     /**
      * 获取组件
      * @param name 组件名称
-     * @returns 组件
+     * @returns 组件实例
      */
     getComponent(name) {
-        return this.components[`${name}`];
+        return this.components[name];
     }
     /**
-     * 取消注册组件
+     * 注销组件
      * @param name 组件名称
      */
     unregisterComponent(name) {
-        delete this.components[`${name}`];
-        delete this.providedComponents[`${name}`];
-        delete this.comtoplu[`${name}`];
+        delete this.components[name];
+        delete this.providedComponents[name];
+        delete this.comtoplu[name];
     }
     /**
-     * 监听事件
+     * 注册事件监听器
      * @param event 事件名称
-     * @param listener 回调函数
+     * @param listener 事件回调函数
      */
     on(event, listener) {
-        if (!this.eventListeners[`${event}`]) {
-            this.eventListeners[`${event}`] = [];
+        if (!this.eventListeners[event]) {
+            this.eventListeners[event] = [];
         }
-        this.eventListeners[`${event}`].push(listener);
-        //this.logger.info(`Listener added for event "${event}".`);
+        this.eventListeners[event].push(listener);
     }
     /**
      * 触发事件
      * @param event 事件名称
-     * @param args 参数
+     * @param args 传递给事件监听器的参数
      */
     async emit(event, ...args) {
-        if (this.eventListeners[`${event}`]) {
-            // this.logger.info(`Emitting event "${event}" with args:`, args);
-            for (const listener of this.eventListeners[`${event}`]) {
+        if (this.eventListeners[event]) {
+            for (const listener of this.eventListeners[event]) {
                 try {
                     await listener(...args);
                 }
@@ -446,136 +447,109 @@ class Core {
                 }
             }
         }
-        else {
-            //this.logger.info(`No listeners for event "${event}".`);
-        }
     }
     /**
      * 注册全局中间件
      * @param name 中间件名称
-     * @param middleware 中间件
-     * @returns Core对象
+     * @param middleware 中间件函数
+     * @returns Core 实例
      */
     use(name, middleware) {
         this.globalMiddlewares[name] = middleware;
         return this;
     }
     /**
-     * 定义指令
-     * @param name 指令名称
-     * @returns 指令对象
+     * 注册命令
+     * @param name 命令名称
+     * @returns Command 实例
      */
     command(name) {
-        const command = new command_1.Command(this, name); // 传递 Core 实例
-        this.commands[`${name}`] = command;
+        const command = new command_1.Command(this, name);
+        this.commands[name] = command;
         return command;
     }
     /**
-     * 执行指令
-     * @param name 指令名称
-     * @param session 会话
-     * @param args 参数
-     * @returns 回话/null
+     * 执行命令
+     * @param name 命令名称
+     * @param session 会话对象
+     * @param args 传递给命令处理函数的参数
+     * @returns 会话对象或 null
      */
     async executeCommand(name, session, ...args) {
-        const command = this.commands[`${name}`];
+        const command = this.commands[name];
         if (command) {
-            // 将 globalMiddlewares 从对象转为数组
             const globalMiddlewareList = Object.values(this.globalMiddlewares || {});
             const commandMiddlewareList = command.middlewares || [];
-            // 如果有中间件，执行中间件链
-            if (globalMiddlewareList.length > 0 || commandMiddlewareList.length > 0) {
-                const middlewares = [...globalMiddlewareList, ...commandMiddlewareList];
-                let index = 0;
-                const runner = async () => {
-                    if (index >= middlewares.length) {
-                        await command.executeHandler(session, ...args);
-                        return;
-                    }
+            const middlewares = [...globalMiddlewareList, ...commandMiddlewareList];
+            let index = 0;
+            const runner = async () => {
+                if (index < middlewares.length) {
                     const middleware = middlewares[index++];
                     await middleware(session, runner);
-                };
-                await runner();
-                return session;
-            }
-            else {
-                return await command.execute(session, ...args);
-            }
+                }
+                else {
+                    await command.executeHandler(session, ...args);
+                }
+            };
+            await runner();
+            return session;
         }
         return null;
     }
     /**
      * 注册平台
-     * @param platform 平台名称
-     * @returns 启动结果
+     * @param platform 平台实例
+     * @returns 平台启动结果
      */
     registerPlatform(platform) {
         this.platforms.push(platform);
         return platform.startPlatform(this);
     }
     /**
-     * 取消注册插件
+     * 清理指定插件注册的所有内容
      * @param pluginname 插件名称
      */
     unregall(pluginname) {
-        let cmdtodel = [];
-        for (const cmd in this.cmdtoplu) {
-            if (this.cmdtoplu[cmd] === pluginname) {
-                cmdtodel.push(cmd);
-            }
-        }
-        for (const cmd of cmdtodel) {
+        // 清理 commands
+        Object.keys(this.cmdtoplu)
+            .filter(cmd => this.cmdtoplu[cmd] === pluginname)
+            .forEach(cmd => {
             delete this.cmdtoplu[cmd];
             delete this.commands[cmd];
-        }
-        let comptodel = [];
-        for (const comp in this.comtoplu) {
-            if (this.comtoplu[comp] === pluginname) {
-                comptodel.push(comp);
-            }
-        }
-        for (const comp of comptodel) {
+        });
+        // 清理 components 和 providedComponents
+        Object.keys(this.comtoplu)
+            .filter(comp => this.comtoplu[comp] === pluginname)
+            .forEach(comp => {
             delete this.comtoplu[comp];
             delete this.components[comp];
             delete this.providedComponents[comp];
-        }
-        let evttodel = [];
+        });
+        // 清理 event listeners
         for (const evt in this.evttoplu) {
             if (this.evttoplu[evt][pluginname]) {
-                // 清除插件在 evttoplu 中的记录
-                delete this.evttoplu[evt][pluginname];
-                // 如果该事件的插件已经全部清除了，也可以选择删掉整个事件
-                if (Object.keys(this.evttoplu[evt]).length === 0) {
-                    evttodel.push(evt);
-                }
-                // 同时在 this.eventListeners 中删掉对应 listener
                 const pluginListeners = this.evttoplu[evt][pluginname] || [];
-                this.eventListeners[evt] = this.eventListeners[evt]?.filter(l => !pluginListeners.includes(l)) || [];
-            }
-        }
-        let mdwtodel = [];
-        for (const mdw in this.mdwtoplu) {
-            if (this.mdwtoplu[mdw] === pluginname) {
-                mdwtodel.push(mdw);
+                if (this.eventListeners[evt]) {
+                    this.eventListeners[evt] = this.eventListeners[evt].filter(l => !pluginListeners.includes(l));
+                }
+                delete this.evttoplu[evt][pluginname];
             }
         }
-        for (const mdw of mdwtodel) {
+        // 清理 middlewares
+        Object.keys(this.mdwtoplu)
+            .filter(mdw => this.mdwtoplu[mdw] === pluginname)
+            .forEach(mdw => {
             delete this.mdwtoplu[mdw];
             delete this.globalMiddlewares[mdw];
-        }
+        });
     }
     /**
-     * 获取指令对象
-     * @param name 指令名称
-     * @returns null/指令对象
+     * 获取命令
+     * @param name 命令名称
+     * @returns Command 实例或 null
      */
     getCommand(name) {
-        if (Object.hasOwn(this.commands, name)) {
-            return this.commands[name];
-        }
-        else {
-            return null;
-        }
+        return this.commands[name] || null;
     }
 }
 exports.Core = Core;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yumerijs/core",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "Core module for yumeri",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",