@yumerijs/core 1.1.0 → 1.1.1

package/dist/core.js

@@ -155,108 +155,76 @@ class Core {
      * @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.');
             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 disabledPlugins = Object.keys(this.config.plugins).filter(name => name.startsWith('~'));
         if (disabledPlugins.length > 0) {
             this.logger.info(`Skipping disabled plugins: ${disabledPlugins.join(', ')}`);
         }
         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}`]) {
+                if (loadedPluginNames.includes(pluginName)) {
                     continue;
                 }
-                // 标记该插件已尝试加载
-                loadAttempted[`${pluginName}`] = true;
                 try {
-                    this.logger.info(`Attempting to load plugin: ${pluginName}`);
-                    // 使用插件名加载插件实例和模块
+                    // 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)) || [];
+                        // 用 providedComponents 作为依赖判断来源（比 components 更准确）
+                        const unmetDependencies = depend?.filter(dep => !this.providedComponents.hasOwnProperty(dep)) || [];
                         if (unmetDependencies.length === 0) {
-                            // 将加载成功并满足依赖的插件存储起来
-                            this.plugins[`${pluginName}`] = Object.assign(pluginInstance, { depend, provide });
-                            //this.pluginModules[`${pluginName}`] = pluginModule;
-                            //this.logger.info(`Plugin ${pluginName} loaded.`);
+                            this.plugins[pluginName] = Object.assign(pluginInstance, { depend, provide });
                             loadedPluginNames.push(pluginName);
-                            loadedInThisPass = true; // 标记本轮有插件加载成功
-                            if (loadedInThisPass && pluginInstance && pluginInstance.apply) {
+                            loadedInThisPass = true;
+                            if (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.`);
+                                        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;
+                                        this.providedComponents[componentName] = pluginName;
                                     }
                                 }
                             }
                         }
                         else {
-                            // 如果存在未满足的依赖，将插件名放回下一轮尝试加载列表
                             nextRemainingPluginNames.push(pluginName);
-                            /*this.logger.warn(
-                              `Plugin ${pluginName} has unmet dependencies: ${unmetDependencies.join(', ')}. Will try again later.`
-                            );*/
+                            // 不加入 loadAttempted，让下一轮重试
                         }
                     }
-                    else {
-                        //this.logger.warn(`Plugin "${pluginName}" could not be loaded or its module could not be imported.`);
-                    }
                 }
                 catch (err) {
                     this.pluginLoader.logger.error(`Failed to load or process plugin ${pluginName}:`, err);
-                    // 如果加载或处理失败，不将其加入下一轮尝试列表，但也不标记为已加载成功
+                    loadAttempted[pluginName] = true; // 真正失败才标记
                 }
             }
-            // 如果本轮没有插件加载成功，并且剩余插件列表没有变化，则检测到循环或无法解决的依赖
             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; // 防止无限循环
+                this.logger.error('Detected circular or unresolvable plugin dependencies. Remaining plugins:', nextRemainingPluginNames);
+                break;
             }
-            // 更新剩余待加载插件列表为下一轮的列表
             remainingPluginNames = nextRemainingPluginNames;
         }
-        // 警告未加载成功的插件
         if (remainingPluginNames.length > 0) {
-            this.logger.warn('Some plugins could not be fully loaded due to unresolved dependencies or errors:', remainingPluginNames.map(name => name) // 映射回插件名
-            );
+            this.logger.warn('Some plugins could not be fully loaded due to unresolved dependencies or errors:', remainingPluginNames);
         }
-        // 开发环境下监听插件变化
         if (process.env.NODE_ENV === 'development') {
             this.watchPlugins(this);
         }

package/package.json

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