@yumerijs/loader 2.0.4 → 2.1.0

package/dist/index.d.ts

@@ -4,6 +4,7 @@ interface Plugin {
     disable: (ctx: Context) => Promise<void>;
     depend: Array<string>;
     provide: Array<string>;
+    render?: string;
 }
 export declare class PluginLoader {
     private pluginsDir;
@@ -29,7 +30,7 @@ export declare class PluginLoader {
      */
     reloadConfigFile(): Promise<void>;
     getCore(): Core;
-    getContext(pluginName: string): Context;
+    getContext(pluginName: string, injections?: Record<string, any>): Context;
     unregall(pluginName: string): void;
     loadConfig(configPath: string): Promise<void>;
     getPluginConfig(pluginName: string): Promise<Config>;

package/dist/index.js

@@ -41,6 +41,7 @@ const util_1 = require("util");
 const child_process_1 = require("child_process");
 const yaml = __importStar(require("js-yaml"));
 const chokidar = __importStar(require("chokidar"));
+const vueLoader_1 = require("./runtime/vueLoader");
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
 class PluginLoader {
     pluginsDir;
@@ -57,10 +58,9 @@ class PluginLoader {
     constructor(core, pluginsDir = 'plugins') {
         this.pluginsDir = pluginsDir;
         this.core = core || new core_1.Core(this, undefined, false);
-        this.core.uuid = Math.random().toString(36).substring(2);
-        this.logger.info(`[DIAG] Loader created/received Core instance with UUID: ${this.core.uuid}`);
         this.isDev = process.env.NODE_ENV === 'development';
         core_1.Logger.setCore(this.core);
+        (0, vueLoader_1.registerVueRuntimeLoader)();
     }
     /**
      * Reloads the config file from disk into memory and emits a 'config-reloaded' event.
@@ -82,9 +82,9 @@ class PluginLoader {
     getCore() {
         return this.core;
     }
-    getContext(pluginName) {
+    getContext(pluginName, injections = {}) {
         if (!this.pluginContexts[pluginName]) {
-            this.pluginContexts[pluginName] = new core_1.Context(this.core, pluginName);
+            this.pluginContexts[pluginName] = new core_1.Context(this.core, pluginName, null, injections);
         }
         return this.pluginContexts[pluginName];
     }
@@ -174,14 +174,46 @@ class PluginLoader {
             if (!pluginInstance) {
                 throw new Error('Plugin loader returned no instance.');
             }
+            // Auto-load and register renderer if declared
+            if (pluginInstance.render && typeof pluginInstance.render === 'string') {
+                const rendererName = pluginInstance.render;
+                this.logger.info(`Plugin "${pluginName}" requires renderer "${rendererName}".`);
+                this.core.pluginRenderers.set(pluginName, rendererName);
+                if (!this.core.renderers.has(rendererName)) {
+                    this.logger.info(`Renderer "${rendererName}" is not registered. Attempting to auto-load...`);
+                    try {
+                        const rendererPackageMap = {
+                            'vue': '@yumerijs/vue-renderer',
+                            'react': '@yumerijs/react-renderer'
+                        };
+                        const rendererPackageName = rendererPackageMap[rendererName] || rendererName;
+                        this.logger.info(`Loading renderer package: "${rendererPackageName}"...`);
+                        const RendererClass = require(rendererPackageName);
+                        // Handle both ES modules (default export) and CommonJS modules
+                        const ActualRendererClass = RendererClass.default || RendererClass;
+                        const rendererInstance = new ActualRendererClass();
+                        this.core.addRenderer(rendererInstance);
+                        this.logger.info(`Successfully loaded and registered renderer "${rendererName}".`);
+                    }
+                    catch (err) {
+                        this.logger.error(`Failed to auto-load renderer package for "${rendererName}". Please make sure the renderer package is installed.`);
+                        this.logger.error(err);
+                    }
+                }
+            }
             const deps = pluginInstance.depend || [];
             const unmetDependencies = deps.filter(dep => !this.core.components[dep]);
             if (unmetDependencies.length > 0) {
                 return false;
             }
             this.plugins[pluginName] = pluginInstance;
+            const depend = pluginInstance.depend || [];
+            let injections = {};
+            for (const injection of depend) {
+                injections[injection] = this.core.getComponent(injection);
+            }
             const pluginConfig = await this.getPluginConfig(pluginName);
-            const context = this.getContext(pluginName);
+            const context = this.getContext(pluginName, injections);
             await this.core.plugin(pluginInstance, context, pluginConfig);
             this.pluginStatus[pluginName] = "enabled" /* PluginStatus.ENABLED */;
             if (triggerPendingCheck) {
@@ -278,15 +310,28 @@ class PluginLoader {
      * @param pluginName The name of the plugin to reload.
      */
     async reloadPlugin(pluginName) {
-        this.logger.info(`Reloading plugin code for "${pluginName}"...`);
-        this.clearRequireCache(pluginName, new Set());
-        await this.unloadPlugin(pluginName);
+        this.logger.info(`Reloading plugin: "${pluginName}"...`);
+        // Clear the module cache for the plugin. This is critical for hot-reloading.
+        try {
+            const resolvedPath = require.resolve(pluginName);
+            this.clearRequireCache(resolvedPath, new Set());
+            this.logger.info(`Cache cleared for plugin "${pluginName}".`);
+        }
+        catch (e) {
+            this.logger.error(`Could not resolve path for plugin ${pluginName} to clear cache.`, e);
+        }
+        // Reload the configuration from disk to catch any changes.
+        await this.reloadConfigFile();
+        // Unload the plugin and its dependents.
+        await this.unloadPlugin(pluginName, true);
+        // Load the plugin again. This will also trigger a check for other pending plugins.
         const success = await this.loadSinglePlugin(pluginName);
         if (success) {
+            this.logger.info(`Plugin "${pluginName}" reloaded successfully.`);
             this.core.emit('plugin-reloaded', pluginName);
         }
         else {
-            this.logger.error(`Failed to reload plugin "${pluginName}". It may have unmet dependencies.`);
+            this.logger.error(`Failed to reload plugin "${pluginName}". It may have unmet dependencies or other errors.`);
         }
     }
     watchPlugin(pluginName, pluginPath) {

package/dist/runtime/vueLoader.d.ts

@@ -0,0 +1 @@
+export declare function registerVueRuntimeLoader(): void;

package/dist/runtime/vueLoader.js

@@ -0,0 +1,95 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerVueRuntimeLoader = registerVueRuntimeLoader;
+const fs_1 = __importDefault(require("fs"));
+const crypto_1 = __importDefault(require("crypto"));
+const compiler_sfc_1 = require("@vue/compiler-sfc");
+const esbuild_1 = require("esbuild");
+let vueLoaderRegistered = false;
+const SUPPORTED_ESBUILD_LOADERS = new Set(['js', 'ts', 'tsx', 'jsx']);
+function getScopeId(filename) {
+    return crypto_1.default.createHash('md5').update(filename).digest('hex').slice(0, 8);
+}
+function inferLoader(lang) {
+    if (!lang)
+        return 'js';
+    return SUPPORTED_ESBUILD_LOADERS.has(lang) ? lang : 'js';
+}
+function registerVueRuntimeLoader() {
+    if (vueLoaderRegistered) {
+        return;
+    }
+    vueLoaderRegistered = true;
+    require.extensions['.vue'] = function registerVueSFC(module, filename) {
+        const nodeModule = module;
+        try {
+            const source = fs_1.default.readFileSync(filename, 'utf8');
+            const { descriptor } = (0, compiler_sfc_1.parse)(source, { filename });
+            if (!descriptor.script && !descriptor.scriptSetup && !descriptor.template) {
+                nodeModule._compile('module.exports = {};\n', filename);
+                return;
+            }
+            const id = getScopeId(filename);
+            let code = '';
+            const lang = descriptor.scriptSetup?.lang || descriptor.script?.lang;
+            if (!descriptor.script && !descriptor.scriptSetup && descriptor.template) {
+                const templateResult = (0, compiler_sfc_1.compileTemplate)({
+                    id,
+                    filename,
+                    source: descriptor.template.content,
+                    ssr: true
+                });
+                code = `
+import { defineComponent } from 'vue';
+${templateResult.code}
+
+const __component__ = defineComponent({});
+__component__.ssrRender = ssrRender;
+
+export default __component__;
+`;
+            }
+            else {
+                const compiled = (0, compiler_sfc_1.compileScript)(descriptor, {
+                    id,
+                    inlineTemplate: Boolean(descriptor.template),
+                    templateOptions: {
+                        ssr: true
+                    }
+                });
+                code = compiled.content;
+            }
+            const transformed = (0, esbuild_1.transformSync)(code, {
+                loader: inferLoader(lang),
+                format: 'cjs',
+                target: 'node18',
+                sourcemap: 'inline',
+                sourcefile: filename
+            });
+            const metadataCode = `
+const __yumeri_raw__ = module.exports && module.exports.__esModule ? module.exports.default : module.exports;
+const __yumeri_target__ = typeof __yumeri_raw__ === 'function' || (typeof __yumeri_raw__ === 'object' && __yumeri_raw__ !== null)
+  ? __yumeri_raw__
+  : null;
+if (__yumeri_target__) {
+  Object.defineProperty(__yumeri_target__, '__file', {
+    value: ${JSON.stringify(filename)},
+    enumerable: false,
+    configurable: true,
+    writable: true,
+  });
+}
+`;
+            nodeModule._compile(`${transformed.code}\n${metadataCode}`, filename);
+        }
+        catch (error) {
+            const friendlyMessage = new Error(`[yumeri] Failed to compile Vue SFC "${filename}". ` +
+                `Make sure @vue/compiler-sfc can parse the file. Original error: ${error.message}`);
+            friendlyMessage.stack = error.stack;
+            throw friendlyMessage;
+        }
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yumerijs/loader",
-  "version": "2.0.4",
+  "version": "2.1.0",
   "description": "Module loader for yumeri",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -8,7 +8,8 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsc"
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
   },
   "repository": {
     "type": "git",
@@ -28,13 +29,14 @@
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^22.13.10",
     "@yumerijs/core": "^2.0.1",
-    "esbuild": "^0.25.9",
     "esbuild-register": "^3.6.0",
     "typescript": "^5.8.2"
   },
   "dependencies": {
     "@types/js-yaml": "^4.0.9",
+    "@vue/compiler-sfc": "^3.5.25",
     "chokidar": "^4.0.3",
+    "esbuild": "^0.25.9",
     "js-yaml": "^4.1.0"
   },
   "peerDependencies": {