@yumerijs/loader 2.0.0 → 2.0.1

package/dist/index.d.ts

@@ -1,27 +1,45 @@
-import { Core, Config, Logger, Context } from '@yumerijs/core';
+import { Core, Config, Logger, Context, PluginStatus } from '@yumerijs/core';
+import 'esbuild-register';
 interface Plugin {
     apply: (ctx: Context, config: Config) => Promise<void>;
     disable: (ctx: Context) => Promise<void>;
     depend: Array<string>;
     provide: Array<string>;
 }
-interface PluginLoader {
-    load(pluginName: string): Promise<Plugin>;
-    unloadPlugin(pluginName: string): Promise<void>;
-    checkPluginDependencies(pluginPath: string): Promise<boolean>;
-    installPluginDependencies(pluginName: string): Promise<void>;
-    logger: Logger;
-}
-declare class PluginLoader {
-    private pluginCache;
-    private core;
-    private config;
-    private isDev;
+export declare class PluginLoader {
     private pluginsDir;
+    core: Core;
+    config: any;
     logger: Logger;
-    constructor(core?: Core, config?: Config, pluginsDir?: string);
-    setCoreAndConfig(core: Core, config: Config): void;
-    private loadPluginFromPath;
+    plugins: {
+        [name: string]: Plugin & {
+            depend?: string[];
+            provide?: string[];
+        };
+    };
+    pluginStatus: Record<string, PluginStatus>;
+    private pluginWatchers;
+    private pluginModules;
+    private configPath;
+    private pluginContexts;
+    private isDev;
+    constructor(core?: Core, pluginsDir?: string);
+    getCore(): Core;
+    getContext(pluginName: string): Context;
+    unregall(pluginName: string): void;
+    loadConfig(configPath: string): Promise<void>;
+    private watchConfig;
+    getPluginConfig(pluginName: string): Promise<Config>;
+    loadPlugins(): Promise<void>;
+    loadSinglePlugin(pluginName: string, triggerPendingCheck?: boolean, onlypending?: boolean): Promise<boolean>;
+    private _loadPendingPlugins;
+    unloadPlugin(pluginNameToUnload: string, ispending?: boolean): Promise<void>;
+    private _unloadSinglePlugin;
+    reloadPlugin(pluginName: string): Promise<void>;
+    private watchPlugin;
+    loadModule(pluginName: string): Promise<Plugin>;
     private clearRequireCache;
+    checkPluginDependencies(pluginPath: string): Promise<boolean>;
+    installPluginDependencies(pluginName: string): Promise<void>;
 }
 export default PluginLoader;

package/dist/index.js

@@ -33,147 +33,327 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginLoader = void 0;
 const path = __importStar(require("path"));
 const core_1 = require("@yumerijs/core");
 const fs = __importStar(require("fs"));
 const util_1 = require("util");
 const child_process_1 = require("child_process");
-const url_1 = require("url");
+const yaml = __importStar(require("js-yaml"));
+const chokidar = __importStar(require("chokidar"));
+require("esbuild-register");
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
 class PluginLoader {
-    pluginCache = {};
-    core = null;
+    pluginsDir;
+    core;
     config = null;
-    isDev = false;
-    pluginsDir = 'plugins'; // Default plugins directory
     logger = new core_1.Logger('loader');
-    constructor(core, config, pluginsDir = 'plugins') {
-        this.pluginCache = {};
-        this.core = core || null;
-        this.config = config || null;
-        this.isDev = process.env.NODE_ENV === 'development';
+    plugins = {};
+    pluginStatus = {};
+    pluginWatchers = {};
+    pluginModules = {};
+    configPath = '';
+    pluginContexts = {};
+    isDev = false;
+    constructor(core, pluginsDir = 'plugins') {
         this.pluginsDir = pluginsDir;
+        this.core = core || new core_1.Core(undefined, false);
+        this.isDev = process.env.NODE_ENV === 'development';
+        core_1.Logger.setCore(this.core); // Set the core instance for the logger
     }
-    setCoreAndConfig(core, config) {
-        this.core = core;
-        this.config = config;
+    getCore() {
+        return this.core;
     }
-    async load(pluginName) {
-        if (this.pluginCache[pluginName] && !this.isDev) {
-            return this.pluginCache[pluginName];
+    getContext(pluginName) {
+        if (!this.pluginContexts[pluginName]) {
+            this.pluginContexts[pluginName] = new core_1.Context(this.core, pluginName);
         }
-        let pluginPath;
-        let isLocalPlugin = false;
-        const localPluginPath = path.resolve(process.cwd(), this.pluginsDir, pluginName);
-        const localPluginPathAlt = path.resolve(process.cwd(), pluginName);
-        if (fs.existsSync(localPluginPath)) {
-            pluginPath = localPluginPath;
-            isLocalPlugin = true;
+        return this.pluginContexts[pluginName];
+    }
+    unregall(pluginName) {
+        const ctx = this.pluginContexts[pluginName];
+        if (ctx) {
+            ctx.dispose();
+            delete this.pluginContexts[pluginName];
         }
-        else if (fs.existsSync(localPluginPathAlt)) {
-            pluginPath = localPluginPathAlt;
-            isLocalPlugin = true;
+    }
+    async loadConfig(configPath) {
+        try {
+            this.configPath = configPath;
+            const doc = yaml.load(fs.readFileSync(configPath, 'utf8'));
+            this.config = doc;
+            this.logger.info('Config loaded.');
+            if (this.isDev) {
+                this.watchConfig(configPath);
+            }
+            this.core.coreConfig = this.config.core || {};
+            this.core.i18n = new (require('@yumerijs/core').I18n)(this.core.coreConfig.lang || ['zh', 'en']);
         }
-        else if (path.isAbsolute(pluginName) || pluginName.startsWith('.')) {
-            pluginPath = path.resolve(pluginName);
-            isLocalPlugin = true;
+        catch (e) {
+            this.logger.error('Failed to load config:', e);
+            throw e;
         }
-        else {
+    }
+    watchConfig(configPath) {
+        const watcher = chokidar.watch(configPath, {
+            persistent: true,
+            ignoreInitial: true,
+            awaitWriteFinish: {
+                stabilityThreshold: 300,
+                pollInterval: 100,
+            },
+        });
+        watcher.on('change', async () => {
             try {
-                pluginPath = require.resolve(pluginName);
+                const doc = yaml.load(fs.readFileSync(configPath, 'utf8'));
+                if (doc && doc.plugins) {
+                    this.config.plugins = doc.plugins;
+                }
+                await this.core.emit('config-changed', this.config);
             }
-            catch (e) {
-                if (e.code === 'MODULE_NOT_FOUND') {
-                    throw new Error(`Plugin ${pluginName} not found. Please install it first.`);
+            catch (error) {
+                this.logger.error('Failed to reload config:', error);
+            }
+        });
+        this.logger.info(`Watching for config changes at ${configPath}`);
+    }
+    async getPluginConfig(pluginName) {
+        const actualPluginName = pluginName.startsWith('~') ? pluginName.substring(1) : pluginName;
+        if (this.configPath && this.isDev) {
+            try {
+                const doc = yaml.load(fs.readFileSync(this.configPath, 'utf8'));
+                if (doc && doc.plugins) {
+                    this.config.plugins = doc.plugins;
                 }
-                throw e;
+            }
+            catch (error) {
+                this.logger.warn('Failed to refresh config for hot reload:', error);
             }
         }
-        try {
-            if (isLocalPlugin) {
-                const plugin = await this.loadPluginFromPath(pluginPath, isLocalPlugin);
-                this.pluginCache[pluginName] = plugin;
-                return plugin;
+        if (!this.config.plugins[actualPluginName]) {
+            return new core_1.Config(actualPluginName);
+        }
+        return new core_1.Config(actualPluginName, this.config.plugins[actualPluginName]);
+    }
+    async loadPlugins() {
+        if (!this.config || typeof this.config.plugins !== 'object' || this.config.plugins === null) {
+            this.logger.info('No plugins configuration found. No plugins to load.');
+            return;
+        }
+        const allPluginNames = Object.keys(this.config.plugins);
+        this.pluginStatus = {}; // Reset status
+        for (const name of allPluginNames) {
+            if (name.startsWith('~')) {
+                const actualName = name.substring(1);
+                this.pluginStatus[actualName] = "disabled" /* PluginStatus.DISABLED */;
             }
             else {
-                const plugin = await Promise.resolve(`${pluginName}`).then(s => __importStar(require(s)));
-                return plugin.default || plugin;
+                this.pluginStatus[name] = "pending" /* PluginStatus.PENDING */;
             }
         }
-        catch (e) {
-            this.logger.error(`Failed to load plugin from ${pluginPath}:`, e);
-            throw e;
+        const enabledPlugins = allPluginNames.filter(name => !name.startsWith('~'));
+        const currentlyLoaded = Object.keys(this.plugins);
+        for (const loadedName of currentlyLoaded) {
+            if (!enabledPlugins.includes(loadedName)) {
+                await this.unloadPlugin(loadedName);
+            }
+        }
+        if (enabledPlugins.length === 0) {
+            this.logger.info('No enabled plugins found in configuration.');
+            return;
+        }
+        let loadedInLastPass = true;
+        while (loadedInLastPass) {
+            loadedInLastPass = false;
+            for (const pluginName of enabledPlugins) {
+                if (this.pluginStatus[pluginName] === "enabled" /* PluginStatus.ENABLED */) {
+                    continue;
+                }
+                const success = await this.loadSinglePlugin(pluginName, false);
+                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);
         }
     }
-    async loadPluginFromPath(pluginPath, isLocalPlugin) {
+    async loadSinglePlugin(pluginName, triggerPendingCheck = true, onlypending = false) {
+        if (!this.pluginStatus[pluginName]) {
+            this.pluginStatus[pluginName] = "pending" /* PluginStatus.PENDING */;
+        }
+        if (this.pluginStatus[pluginName] !== "pending" /* PluginStatus.PENDING */ && onlypending) {
+            return false;
+        }
         try {
-            let targetPath = pluginPath;
-            if (isLocalPlugin && this.isDev) {
-                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);
+            const pluginInstance = await this.loadModule(pluginName);
+            if (!pluginInstance) {
+                throw new Error('Plugin loader returned no instance.');
+            }
+            const deps = pluginInstance.depend || [];
+            const unmetDependencies = deps.filter(dep => !this.core.components[dep]);
+            if (unmetDependencies.length > 0) {
+                return false;
+            }
+            this.plugins[pluginName] = pluginInstance;
+            const pluginConfig = await this.getPluginConfig(pluginName);
+            const context = this.getContext(pluginName);
+            // The new API
+            await this.core.plugin(pluginInstance, context, pluginConfig);
+            this.pluginStatus[pluginName] = "enabled" /* PluginStatus.ENABLED */;
+            if (triggerPendingCheck) {
+                await this._loadPendingPlugins();
+            }
+            if (this.isDev) {
+                let pluginPathToWatch = null;
+                try {
+                    const pkgJsonPath = require.resolve(`${pluginName}/package.json`);
+                    pluginPathToWatch = path.dirname(pkgJsonPath);
+                }
+                catch (e) {
+                    const localPluginPath = path.resolve(process.cwd(), pluginName);
+                    const localPluginPathInPlugins = path.resolve(process.cwd(), 'plugins', pluginName);
+                    if (fs.existsSync(localPluginPath)) {
+                        pluginPathToWatch = localPluginPath;
                     }
-                    else if (pkg.main) {
-                        targetPath = path.join(pluginPath, pkg.main);
+                    else if (fs.existsSync(localPluginPathInPlugins)) {
+                        pluginPathToWatch = localPluginPathInPlugins;
                     }
                 }
+                if (pluginPathToWatch) {
+                    this.watchPlugin(pluginName, pluginPathToWatch);
+                }
+                else {
+                    this.logger.warn(`Could not resolve path for plugin ${pluginName} to watch for changes.`);
+                }
             }
-            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());
+            return true;
+        }
+        catch (err) {
+            this.logger.error(`Failed to load plugin "${pluginName}":`, err);
+            return false;
+        }
+    }
+    async _loadPendingPlugins() {
+        const pendingPlugins = Object.keys(this.pluginStatus).filter(p => this.pluginStatus[p] === "pending" /* PluginStatus.PENDING */);
+        if (pendingPlugins.length === 0)
+            return;
+        for (const pluginName of pendingPlugins) {
+            await this.loadSinglePlugin(pluginName, false);
+        }
+    }
+    async unloadPlugin(pluginNameToUnload, ispending = false) {
+        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);
+                    }
                 }
-                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;
+        }
+        for (const dependentName of dependents) {
+            await this.unloadPlugin(dependentName, true);
+        }
+        await this._unloadSinglePlugin(pluginNameToUnload, ispending);
+    }
+    async _unloadSinglePlugin(pluginName, ispending = false) {
+        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(this.getContext(pluginName));
+            this.unregall(pluginName);
+            delete this.plugins[pluginName];
+            delete this.pluginModules[pluginName];
+            this.pluginStatus[pluginName] = ispending ? "pending" /* PluginStatus.PENDING */ : "disabled" /* PluginStatus.DISABLED */;
+            if (this.pluginWatchers[pluginName]) {
+                this.pluginWatchers[pluginName].close();
+                delete this.pluginWatchers[pluginName];
             }
+            this.core.emit('plugin-unloaded', pluginName);
         }
-        catch (e) {
-            this.logger.error(`Error loading plugin from path ${pluginPath}:`, e);
-            throw e;
+        catch (error) {
+            this.logger.error(`Failed to unload plugin "${pluginName}":`, error);
+        }
+    }
+    async reloadPlugin(pluginName) {
+        await this.unloadPlugin(pluginName);
+        const success = await this.loadSinglePlugin(pluginName);
+        if (success) {
+            this.core.emit('plugin-reloaded', pluginName);
+        }
+        else {
+            this.logger.error(`Failed to reload plugin "${pluginName}". It may have unmet dependencies.`);
         }
     }
+    watchPlugin(pluginName, pluginPath) {
+        if (this.pluginWatchers[pluginName]) {
+            return;
+        }
+        const logger = new core_1.Logger('hmr');
+        const watcher = chokidar.watch(pluginPath, {
+            ignored: /(^|[\/])\../,
+            persistent: true,
+            ignoreInitial: true,
+            awaitWriteFinish: {
+                stabilityThreshold: 200,
+                pollInterval: 100,
+            },
+        });
+        watcher.on('change', async (changePath) => {
+            logger.info(`Plugin file changed: ${changePath}`);
+            await this.reloadPlugin(pluginName);
+        });
+        watcher.on('add', async (changePath) => {
+            logger.info(`New file added to plugin ${pluginName}: ${changePath}`);
+            await this.reloadPlugin(pluginName);
+        });
+        watcher.on('unlink', async (changePath) => {
+            logger.info(`File removed from plugin ${pluginName}: ${changePath}`);
+            await this.reloadPlugin(pluginName);
+        });
+        this.pluginWatchers[pluginName] = watcher;
+    }
+    async loadModule(pluginName) {
+        if (this.isDev) {
+            this.clearRequireCache(pluginName, new Set());
+        }
+        const plugin = await require(pluginName);
+        return plugin.default || plugin;
+    }
     clearRequireCache(moduleId, visited) {
         if (visited.has(moduleId)) {
-            return; // Cycle detected
+            return;
         }
         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];
-        // 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}`);
-    }
     async checkPluginDependencies(pluginPath) {
-        // TODO: Implement dependency checking from package.json
         return true;
     }
     async installPluginDependencies(pluginName) {
@@ -192,4 +372,5 @@ class PluginLoader {
         }
     }
 }
+exports.PluginLoader = PluginLoader;
 exports.default = PluginLoader;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yumerijs/loader",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "Module loader for yumeri",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -25,12 +25,16 @@
   },
   "homepage": "https://github.com/yumerijs/yumeri#readme",
   "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
     "@types/node": "^22.13.10",
     "esbuild": "^0.25.9",
     "esbuild-register": "^3.6.0",
     "typescript": "^5.8.2"
   },
   "dependencies": {
-    "@yumerijs/core": "^2.0.0"
+    "@types/js-yaml": "^4.0.9",
+    "@yumerijs/core": "^2.0.1",
+    "chokidar": "^4.0.3",
+    "js-yaml": "^4.1.0"
   }
 }