@yumerijs/loader 1.1.0 → 1.2.0

package/dist/index.d.ts

@@ -21,13 +21,7 @@ declare class PluginLoader {
     logger: Logger;
     constructor(core?: Core, config?: Config, pluginsDir?: string);
     setCoreAndConfig(core: Core, config: Config): void;
-    /**
-     * 从指定路径加载插件.
-     * @param pluginPath 插件路径.
-     * @param isLocalPlugin 是否是本地插件
-     * @returns 加载的插件对象.
-     * @throws 如果插件加载失败.
-     */
     private loadPluginFromPath;
+    private clearRequireCache;
 }
 export default PluginLoader;

package/dist/index.js

@@ -38,7 +38,7 @@ const core_1 = require("@yumerijs/core");
 const fs = __importStar(require("fs"));
 const util_1 = require("util");
 const child_process_1 = require("child_process");
-const tsNode = __importStar(require("ts-node"));
+const url_1 = require("url");
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
 class PluginLoader {
     pluginCache = {};
@@ -53,59 +53,40 @@ class PluginLoader {
         this.config = config || null;
         this.isDev = process.env.NODE_ENV === 'development';
         this.pluginsDir = pluginsDir;
-        tsNode.register({
-            transpileOnly: true, // Use transpileOnly for faster compilation
-            compilerOptions: {
-                module: 'CommonJS' // Ensure CommonJS for compatibility with require
-            }
-        });
     }
     setCoreAndConfig(core, config) {
         this.core = core;
         this.config = config;
     }
-    /**
-     * 从本地目录或 npm 包加载插件.
-     * @param pluginName 插件名称或路径.
-     * @returns 加载的插件对象.
-     * @throws 如果插件加载失败.
-     */
     async load(pluginName) {
-        if (this.pluginCache[pluginName]) {
-            this.logger.info(`Returning cached plugin: ${pluginName}`);
+        if (this.pluginCache[pluginName] && !this.isDev) {
             return this.pluginCache[pluginName];
         }
         let pluginPath;
         let isLocalPlugin = false;
-        // 1. 检查是否是本地插件目录下的插件
-        const localPluginPath = path.resolve(this.pluginsDir, pluginName);
-        const localPluginPath1 = path.resolve(pluginName);
+        const localPluginPath = path.resolve(process.cwd(), this.pluginsDir, pluginName);
+        const localPluginPathAlt = path.resolve(process.cwd(), pluginName);
         if (fs.existsSync(localPluginPath)) {
             pluginPath = localPluginPath;
             isLocalPlugin = true;
         }
-        else if (fs.existsSync(localPluginPath1)) {
-            pluginPath = localPluginPath1;
+        else if (fs.existsSync(localPluginPathAlt)) {
+            pluginPath = localPluginPathAlt;
             isLocalPlugin = true;
         }
-        // 2. 检查是否是绝对路径或相对路径
         else if (path.isAbsolute(pluginName) || pluginName.startsWith('.')) {
             pluginPath = path.resolve(pluginName);
             isLocalPlugin = true;
         }
-        // 3. 尝试作为 npm 包加载
         else {
             try {
-                // 尝试 require，如果成功，则认为是一个已安装的 npm 包
-                require.resolve(pluginName); // 检查包是否已安装
-                pluginPath = pluginName;
+                pluginPath = require.resolve(pluginName);
             }
             catch (e) {
-                // 如果 require.resolve 失败，则抛出错误
                 if (e.code === 'MODULE_NOT_FOUND') {
                     throw new Error(`Plugin ${pluginName} not found. Please install it first.`);
                 }
-                throw e; // 其他类型的错误，直接抛出
+                throw e;
             }
         }
         try {
@@ -118,99 +99,77 @@ class PluginLoader {
             throw e;
         }
     }
-    /**
-     * 从指定路径加载插件.
-     * @param pluginPath 插件路径.
-     * @param isLocalPlugin 是否是本地插件
-     * @returns 加载的插件对象.
-     * @throws 如果插件加载失败.
-     */
     async loadPluginFromPath(pluginPath, isLocalPlugin) {
         try {
-            let jsonPath;
             let targetPath = pluginPath;
             if (isLocalPlugin && this.isDev) {
-                // 开发模式下，加载 src 目录下的 ts 文件
-                jsonPath = path.join(pluginPath, 'package.json');
-                let jsoncontent = fs.readFileSync(jsonPath, 'utf-8');
-                targetPath = path.join(pluginPath, JSON.parse(jsoncontent).dev);
-                if (!fs.existsSync(targetPath)) {
-                    throw new Error(`devfile not found in ${pluginPath}`);
-                }
-                // 检查目标文件是否是 TypeScript 文件
-                if (targetPath.endsWith('.ts')) {
-                    // 清除该文件的缓存，确保获取最新版本
-                    const resolvedPath = require.resolve(targetPath);
-                    if (require.cache[resolvedPath]) {
-                        delete require.cache[resolvedPath];
+                const jsonPath = path.join(pluginPath, 'package.json');
+                if (fs.existsSync(jsonPath)) {
+                    const jsonContent = fs.readFileSync(jsonPath, 'utf-8');
+                    const pkg = JSON.parse(jsonContent);
+                    if (pkg.dev) {
+                        targetPath = path.join(pluginPath, pkg.dev);
                     }
-                    // 使用 ts-node 重新编译并加载 TypeScript 模块
-                    const module = require(targetPath);
-                    return module;
-                }
-                else {
-                    // 清除该文件的缓存，确保获取最新版本
-                    const resolvedPath = require.resolve(targetPath);
-                    if (require.cache[resolvedPath]) {
-                        delete require.cache[resolvedPath];
+                    else if (pkg.main) {
+                        targetPath = path.join(pluginPath, pkg.main);
                     }
-                    // 使用 require 加载 js 模块
-                    const module = require(targetPath);
-                    return module;
                 }
             }
-            else {
-                targetPath = require.resolve(pluginPath);
-                // 清除该文件的缓存，确保获取最新版本
-                if (require.cache[targetPath]) {
-                    delete require.cache[targetPath];
+            if (this.isDev) {
+                // In development, use require() to leverage esbuild-register
+                // and clear cache for HMR.
+                const resolvedPath = require.resolve(targetPath);
+                // Clean up the cache for the main module and its children
+                if (require.cache[resolvedPath]) {
+                    this.clearRequireCache(resolvedPath, new Set());
                 }
+                const module = require(resolvedPath);
+                return module.default || module;
+            }
+            else {
+                // In production, use dynamic import.
+                const url = (0, url_1.pathToFileURL)(targetPath).href;
+                const module = await Promise.resolve(`${url}`).then(s => __importStar(require(s)));
+                return module.default || module;
             }
-            // 使用require加载
-            const pluginModule = require(targetPath);
-            return pluginModule;
         }
         catch (e) {
             this.logger.error(`Error loading plugin from path ${pluginPath}:`, e);
             throw e;
         }
     }
-    /**
-     * 卸载插件
-     * @param pluginName 插件名称
-     */
+    clearRequireCache(moduleId, visited) {
+        if (visited.has(moduleId)) {
+            return; // Cycle detected
+        }
+        visited.add(moduleId);
+        const module = require.cache[moduleId];
+        if (!module)
+            return;
+        // Recursively clear children's cache
+        if (module.children) {
+            for (const child of module.children) {
+                this.clearRequireCache(child.id, visited);
+            }
+        }
+        // Delete the module from cache
+        delete require.cache[moduleId];
+    }
     async unloadPlugin(pluginName) {
         if (!this.pluginCache[pluginName]) {
             return; // Plugin not loaded
         }
         delete this.pluginCache[pluginName];
-        try {
-            // 清除插件相关的所有模块缓存
-            Object.keys(require.cache).forEach(key => {
-                if (key.includes(pluginName)) {
-                    delete require.cache[key];
-                }
-            });
-            // this.logger.info(`Plugin unloaded: ${pluginName}`);
-            this.core?.unregall(pluginName);
-        }
-        catch (error) {
-            this.logger.error(`Error unloading plugin ${pluginName}:`, error);
-        }
+        // With dynamic import, there's no direct equivalent of require.cache to clear.
+        // The timestamp query in dev mode handles fresh loading.
+        // For production, modules are cached intentionally.
+        this.core?.unregall(pluginName);
+        // this.logger.info(`Plugin unloaded: ${pluginName}`);
     }
-    /**
-     * 检查插件的依赖是否满足.
-     * @param pluginPath 插件路径.
-     * @returns 如果依赖满足，则返回 true，否则返回 false.
-     */
     async checkPluginDependencies(pluginPath) {
-        // TODO: 读取插件package.json，检查依赖是否满足
+        // TODO: Implement dependency checking from package.json
         return true;
     }
-    /**
-     * 安装插件的依赖.
-     * @param pluginPath 插件路径.
-     */
     async installPluginDependencies(pluginName) {
         try {
             this.logger.info(`Installing dependencies for plugin: ${pluginName}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yumerijs/loader",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Module loader for yumeri",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -8,8 +8,7 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsc",
-    "prepublishOnly": "yarn build"
+    "build": "tsc"
   },
   "repository": {
     "type": "git",
@@ -28,12 +27,13 @@
   "devDependencies": {
     "@types/node": "^22.13.10",
     "@types/semver": "^7.5.8",
+    "esbuild": "^0.25.9",
+    "esbuild-register": "^3.6.0",
     "typescript": "^5.8.2"
   },
   "dependencies": {
-    "@yumerijs/core": "1.1.0",
+    "@yumerijs/core": "^1.2.0",
     "chokidar": "^4.0.3",
-    "semver": "^7.7.1",
-    "ts-node": "^10.9.2"
+    "semver": "^7.7.1"
   }
 }