@yumerijs/loader 2.0.5 → 2.1.1

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;
@@ -59,6 +60,7 @@ class PluginLoader {
         this.core = core || new core_1.Core(this, undefined, false);
         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.
@@ -67,11 +69,22 @@ class PluginLoader {
     async reloadConfigFile() {
         this.logger.info('Reloading config file...');
         try {
-            const doc = yaml.load(fs.readFileSync(this.configPath, 'utf8'));
+            const ext = path.extname(this.configPath).toLowerCase();
+            const fileContent = fs.readFileSync(this.configPath, 'utf8');
+            let doc;
+            if (ext === '.yaml' || ext === '.yml') {
+                doc = yaml.load(fileContent);
+            }
+            else if (ext === '.json') {
+                doc = JSON.parse(fileContent);
+            }
+            else {
+                throw new Error(`Unsupported config file extension: ${ext}`);
+            }
             this.config = doc;
             this.core.coreConfig = this.config.core || {};
             this.core.emit('config-reloaded', this.config);
-            this.logger.info('Config file reloaded.');
+            this.logger.info('Config file reloaded successfully.');
         }
         catch (e) {
             this.logger.error('Failed to reload config file:', e);
@@ -80,9 +93,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];
     }
@@ -96,7 +109,14 @@ class PluginLoader {
     async loadConfig(configPath) {
         try {
             this.configPath = configPath;
-            const doc = yaml.load(fs.readFileSync(configPath, 'utf8'));
+            const fileContents = fs.readFileSync(configPath, 'utf8');
+            let doc;
+            if (path.extname(configPath) === '.json') {
+                doc = JSON.parse(fileContents);
+            }
+            else {
+                doc = yaml.load(fileContents);
+            }
             this.config = doc;
             this.logger.info('Config loaded.');
             this.core.coreConfig = this.config.core || {};
@@ -172,14 +192,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) {

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.5",
+  "version": "2.1.1",
   "description": "Module loader for yumeri",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -29,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": {