@yumerijs/core 2.0.14 → 2.1.0

package/dist/context.d.ts

@@ -26,6 +26,7 @@ export declare class Context {
     private childPlugins;
     private i18ns;
     component: Components;
+    instance: any;
     /** 插件名称 */
     pluginname: string;
     /**
@@ -33,7 +34,7 @@ export declare class Context {
      * @param core Core 实例
      * @param pluginname 插件名称
      */
-    constructor(core: Core, pluginname: string, injections?: Record<string, any>);
+    constructor(core: Core, pluginname: string, instance?: any, injections?: Record<string, any>);
     /**
      * 注入依赖
      * @param name 依赖名称

package/dist/context.js

@@ -17,6 +17,7 @@ class Context {
     childPlugins = new Map();
     i18ns = [];
     component;
+    instance;
     /** 插件名称 */
     pluginname;
     /**
@@ -24,8 +25,9 @@ class Context {
      * @param core Core 实例
      * @param pluginname 插件名称
      */
-    constructor(core, pluginname, injections = {}) {
+    constructor(core, pluginname, instance, injections = {}) {
         this.core = core;
+        this.instance = instance;
         this.pluginname = pluginname;
         this.childPlugins = new Map();
         this.component = injections;
@@ -46,10 +48,10 @@ class Context {
     route(path) {
         if (this.core.routes[path]) {
             this.core.logger.warn(`Plugin "${this.pluginname}" attempt to register route "${path}", but it has already been registered.`);
-            return new route_1.Route(path);
+            return new route_1.Route(path, this);
         }
         this.routes.push(path);
-        return this.core.route(path);
+        return this.core.route(path, this);
     }
     /**
      * 注册事件
@@ -195,10 +197,7 @@ class Context {
         this.middlewares.forEach((middleware) => delete this.core.globalMiddlewares[middleware]);
         // 删除事件监听器
         this.eventlisteners.forEach(({ name, listener }) => {
-            const listeners = this.core.eventListeners?.[name];
-            if (listeners) {
-                this.core.eventListeners[name] = listeners.filter(l => l !== listener);
-            }
+            this.core.off(name, listener);
         });
         // 删除钩子
         for (const hook in this.hooks) {

package/dist/core.d.ts

@@ -1,3 +1,4 @@
+import { EventEmitter } from 'events';
 import { Config } from './config';
 import { Logger } from './logger';
 import { Session } from './session';
@@ -7,6 +8,7 @@ import { Context } from './context';
 import { HookHandler, Hook } from './hook';
 import { Server as CoreServer } from './server';
 import { I18n } from './i18n';
+import { IRenderer } from '@yumerijs/types';
 interface Plugin {
     apply: (ctx: Context, config: Config) => Promise<void>;
     disable: (ctx: Context) => Promise<void>;
@@ -27,9 +29,7 @@ export declare const enum PluginStatus {
     PENDING = "pending"
 }
 export declare class Core {
-    eventListeners: {
-        [event: string]: ((...args: any[]) => Promise<void>)[];
-    };
+    emitter: EventEmitter<[never]>;
     components: {
         [name: string]: any;
     };
@@ -41,7 +41,11 @@ export declare class Core {
     server: CoreServer;
     i18n: I18n;
     loader: any;
+    renderers: Map<string, IRenderer>;
+    pluginRenderers: Map<string, string>;
     constructor(loader?: any, coreConfig?: CoreOptions, setCore?: boolean);
+    addRenderer(renderer: IRenderer): void;
+    getRendererForPlugin(pluginName: string): string | undefined;
     runCore(): Promise<void>;
     getShortPluginName(pluginName: string): string;
     plugin(pluginInstance: Plugin, context: Context, config: Config): Promise<void>;
@@ -49,9 +53,10 @@ export declare class Core {
     getComponent(name: string): any;
     unregisterComponent(name: string): void;
     on(event: string, listener: (...args: any[]) => Promise<void>): void;
-    emit(event: string, ...args: any[]): Promise<void>;
+    emit(event: string, ...payload: any): void;
+    off(event: string, listener: (...args: any[]) => Promise<void>): void;
     use(name: string, middleware: Middleware): Core;
-    route(path: string): Route;
+    route(path: string, context: Context): Route;
     hook(name: string, hookname: string, callback: HookHandler): any;
     unhook(name: string, hookname: string): any;
     hookExecute(name: string, ...args: any[]): Promise<any[]>;

package/dist/core.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Core = void 0;
+const events_1 = require("events");
 const logger_1 = require("./logger");
 const route_1 = require("./route");
 const hook_1 = require("./hook");
 const server_1 = require("./server");
 class Core {
-    eventListeners = {};
+    emitter = new events_1.EventEmitter();
     components = {};
     routes = {};
     logger = new logger_1.Logger('core');
@@ -16,12 +17,23 @@ class Core {
     server;
     i18n;
     loader;
+    renderers = new Map();
+    pluginRenderers = new Map(); // Stores which plugin uses which renderer
     constructor(loader, coreConfig, setCore = true) {
         this.coreConfig = coreConfig || {};
         this.loader = loader;
         if (setCore)
             logger_1.Logger.setCore(this);
     }
+    addRenderer(renderer) {
+        if (this.renderers.has(renderer.name)) {
+            this.logger.warn(`Renderer "${renderer.name}" is already registered and will be overwritten.`);
+        }
+        this.renderers.set(renderer.name, renderer);
+    }
+    getRendererForPlugin(pluginName) {
+        return this.pluginRenderers.get(pluginName);
+    }
     async runCore() {
         this.server = new server_1.Server(this, {
             port: this.coreConfig.port || 14510,
@@ -44,6 +56,7 @@ class Core {
     }
     async plugin(pluginInstance, context, config) {
         const shortName = this.getShortPluginName(context.pluginname);
+        context.instance = pluginInstance;
         this.logger.info(`apply plugin ${shortName}`);
         if (pluginInstance.apply) {
             await pluginInstance.apply(context, config);
@@ -59,29 +72,28 @@ class Core {
         delete this.components[name];
     }
     on(event, listener) {
-        if (!this.eventListeners[event]) {
-            this.eventListeners[event] = [];
-        }
-        this.eventListeners[event].push(listener);
+        this.emitter.on(event, (...args) => {
+            // 包一层保证 async 可以被捕获
+            Promise.resolve(listener(...args)).catch((err) => {
+                console.error(`Error in event listener for "${event}":`, err);
+            });
+        });
     }
-    async emit(event, ...args) {
-        if (this.eventListeners[event]) {
-            for (const listener of this.eventListeners[event]) {
-                try {
-                    await listener(...args);
-                }
-                catch (err) {
-                    this.logger.error(`Error in event listener for "${event}":`, err);
-                }
-            }
-        }
+    emit(event, ...payload) {
+        this.emitter.emit(event, ...payload);
+    }
+    // 删除监听器
+    off(event, listener) {
+        // 原生 EventEmitter 必须删“同一个函数引用”
+        // 所以必须包装一致，这里我们直接用 listener 本体删
+        this.emitter.off(event, listener);
     }
     use(name, middleware) {
         this.globalMiddlewares[name] = middleware;
         return this;
     }
-    route(path) {
-        const route = new route_1.Route(path);
+    route(path, context) {
+        const route = new route_1.Route(path, context);
         this.routes[path] = route;
         return route;
     }
@@ -108,18 +120,62 @@ class Core {
             const result = route.match(pathname);
             if (result) {
                 try {
+                    this.emit('request:start', {
+                        path: pathname,
+                        route: routePath,
+                        method: session?.client?.req?.method,
+                        plugin: route.context?.pluginname,
+                        start: Date.now(),
+                        sessionId: session?.sessionid,
+                    });
                     const middlewares = [...Object.values(this.globalMiddlewares), ...(route.middlewares || [])];
                     let index = 0;
                     const runner = async () => {
-                        if (index < middlewares.length)
+                        if (index < middlewares.length) {
+                            const name = Object.keys(this.globalMiddlewares)[index] || `mw-${index}`;
+                            const start = Date.now();
                             await middlewares[index++](session, runner);
-                        else
+                            this.emit('middleware:end', {
+                                name,
+                                path: pathname,
+                                plugin: route.context?.pluginname,
+                                duration: Date.now() - start,
+                                sessionId: session?.sessionid,
+                            });
+                        }
+                        else {
+                            const start = Date.now();
                             await route.executeHandler(session, queryParams, result.pathParams);
+                            this.emit('route:end', {
+                                path: pathname,
+                                route: routePath,
+                                plugin: route.context?.pluginname,
+                                duration: Date.now() - start,
+                                sessionId: session?.sessionid,
+                                status: session?.status,
+                            });
+                        }
                     };
                     await runner();
+                    this.emit('request:end', {
+                        path: pathname,
+                        route: routePath,
+                        method: session?.client?.req?.method,
+                        plugin: route.context?.pluginname,
+                        duration: Date.now() - session._startAt || undefined,
+                        status: session?.status,
+                        sessionId: session?.sessionid,
+                    });
                 }
                 catch (error) {
                     this.logger.error(`Unhandled error in route execution for path "${pathname}":`, error);
+                    this.emit('request:error', {
+                        path: pathname,
+                        route: routePath,
+                        plugin: route.context?.pluginname,
+                        error: String(error),
+                        sessionId: session?.sessionid,
+                    });
                     if (session && session.client.res && !session.client.res.writableEnded) {
                         session.client.res.statusCode = 500;
                         session.client.res.end('Internal Server Error');

package/dist/i18n.d.ts

@@ -23,7 +23,7 @@ export declare class I18n {
      * 替换模板字符串中的文本点
      * e.g. "Hello {{app.title}}" -> "Hello 世界"
      */
-    replaceAll(input: string, langs?: string[]): string;
+    replaceAll(input: string, langs?: string[], customRegex?: RegExp): string;
     all(): I18nData;
 }
 export {};

package/dist/i18n.js

@@ -69,8 +69,9 @@ class I18n {
      * 替换模板字符串中的文本点
      * e.g. "Hello {{app.title}}" -> "Hello 世界"
      */
-    replaceAll(input, langs) {
-        return input.replace(/\{\{(.*?)\}\}/g, (_, key) => this.get(key.trim(), langs));
+    replaceAll(input, langs, customRegex) {
+        const regex = customRegex || /\{\{\s*([\w.]+)\s*\}\}/g;
+        return input.replace(regex, (_, key) => this.get(key.trim(), langs));
     }
     all() {
         return this.data;

package/dist/route.d.ts

@@ -6,6 +6,7 @@
 import { Session } from './session';
 import { Middleware } from './middleware';
 import { WebSocketServer } from 'ws';
+import { Context } from './context';
 export type RouteHandler = (session: Session, queryParams: URLSearchParams, ...pathParams: string[]) => Promise<void> | void;
 /**
  * Route class using segment-based matching (no fragile capture-group-index mapping).
@@ -23,11 +24,13 @@ export declare class Route {
     middlewares: Middleware[];
     allowedMethods: string[];
     ws: WebSocketServer;
+    context: Context;
     /**
      * 创建路由
      * @param path 路由路径
+     * @param context 插件上下文
      */
-    constructor(path: string);
+    constructor(path: string, context: Context);
     /**
      * 设置路由处理器
      * @param handler 路由处理器

package/dist/route.js

@@ -41,12 +41,15 @@ class Route {
     middlewares = [];
     allowedMethods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD'];
     ws = null;
+    context;
     /**
      * 创建路由
      * @param path 路由路径
+     * @param context 插件上下文
      */
-    constructor(path) {
+    constructor(path, context) {
         this.path = path;
+        this.context = context;
         const { segments, params } = parsePatternToSegments(path);
         this.segments = segments;
         this.paramsInfo = params;

package/dist/server.d.ts

@@ -14,6 +14,7 @@ export declare class Server {
     private staticDir;
     private httpServer;
     constructor(core: Core, config?: Partial<ServerConfig>);
+    getStaticDir(): string;
     private createSession;
     private parseCookies;
     private getClientIP;

package/dist/server.js

@@ -44,6 +44,7 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const url_1 = require("url");
 const mime = __importStar(require("mime-types"));
+const types_1 = require("@yumerijs/types");
 const logger = new logger_1.Logger('server');
 function isStream(value) {
     return value && typeof value.pipe === "function";
@@ -62,8 +63,11 @@ class Server {
         this.enableCors = config.enableCors ?? true;
         this.staticDir = config.staticDir ?? 'static';
     }
-    createSession(ip, cookies, res, req, pathname, extra = {}) {
-        const session = new session_1.Session(ip, cookies, this, req, res, pathname);
+    getStaticDir() {
+        return this.staticDir;
+    }
+    createSession(ip, cookies, res, req, pathname, pluginContext, extra = {}) {
+        const session = new session_1.Session(ip, cookies, this, req, res, pathname, undefined, pluginContext);
         Object.assign(session.properties, extra);
         session.protocol = extra.protocol ?? 'http';
         return session;
@@ -112,9 +116,21 @@ class Server {
             const queryParams = url.searchParams;
             const ip = this.getClientIP(req);
             const cookies = this.parseCookies(req);
-            const session = this.createSession(ip, cookies, res, req, pathname, { protocol: 'http', header: req.headers });
+            if (req.method === 'GET' || req.method === 'HEAD') {
+                const virtualAsset = await (0, types_1.resolveVirtualAsset)(pathname);
+                if (virtualAsset) {
+                    const headers = virtualAsset.headers || {};
+                    headers['Content-Type'] = headers['Content-Type'] || virtualAsset.contentType || 'application/octet-stream';
+                    res.writeHead(200, headers);
+                    res.end(virtualAsset.body);
+                    return;
+                }
+            }
             const route = this.core.getRoute(pathname);
             const rootroute = this.core.getRoute('root');
+            const pluginContext = route ? route.context : (rootroute ? rootroute.context : undefined);
+            const session = this.createSession(ip, cookies, res, req, pathname, pluginContext, { protocol: 'http', header: req.headers });
+            session._startAt = Date.now();
             const handleRoute = async (routePath) => {
                 const matched = await this.core.executeRoute(routePath, session, queryParams);
                 if (!matched) {
@@ -180,8 +196,9 @@ class Server {
             const queryParams = url.searchParams;
             const ip = this.getClientIP(req);
             const cookies = this.parseCookies(req);
-            const session = this.createSession(ip, cookies, null, req, pathname, { protocol: 'http', header: req.headers });
             const route = this.core.getRoute(pathname);
+            const pluginContext = route ? route.context : undefined;
+            const session = this.createSession(ip, cookies, null, req, pathname, pluginContext, { protocol: 'http', header: req.headers });
             if (route && route.ws != null) {
                 const matched = await this.core.executeRoute(pathname, session, queryParams);
                 if (!matched) {

package/dist/session.d.ts

@@ -6,7 +6,9 @@
 import { Server } from './server';
 import { IncomingMessage, ServerResponse } from 'http';
 import { Stream } from "stream";
+import { Context } from './context';
 type ParsedParams = Record<string, string | string[] | undefined>;
+type MissingMode = 'keep-template' | 'keep-key' | 'remove';
 export interface Client {
     req: IncomingMessage;
     res: ServerResponse;
@@ -63,13 +65,14 @@ export declare class Session {
     pathname: string;
     languages: string[];
     responseHandled: boolean;
+    pluginContext: Context | undefined;
     /**
      * @constructor
      * @param ip 用户IP
      * @param cookie 会话cookie
      * @param query 请求字符串
      */
-    constructor(ip: string, cookie: Record<string, string>, server: Server, req?: IncomingMessage, res?: ServerResponse, pathname?: string, query?: Record<string, string>);
+    constructor(ip: string, cookie: Record<string, string>, server: Server, req?: IncomingMessage, res?: ServerResponse, pathname?: string, query?: Record<string, string>, pluginContext?: Context);
     response<T extends ResType>(body: BodyMap[T], type?: T): void;
     get restype(): ResType;
     get body(): string;
@@ -136,5 +139,19 @@ export declare class Session {
      * @param isStream 是否流式传输
      */
     sendFile(path: string, isStream?: boolean): void;
+    /**
+     * 渲染模板
+     * @template 模板字符串
+     * @data 数据
+     * @missing 缺失值处理方式，keep-template: 保留模板，keep-key: 保留键，remove: 移除
+     * @regex 模板匹配正则，默认为{{ xxx.xxx }}
+     */
+    render(template: string, data: Record<string, any>, missing?: MissingMode, regex?: RegExp): string;
+    /**
+     * Renders a UI component using the plugin's declared renderer.
+     * @param component The component object to render.
+     * @param data The data/props to pass to the component.
+     */
+    renderView(component: any, data?: Record<string, any>): Promise<void>;
 }
 export {};

package/dist/session.js

@@ -63,18 +63,20 @@ class Session {
     pathname;
     languages;
     responseHandled = false;
+    pluginContext;
     /**
      * @constructor
      * @param ip 用户IP
      * @param cookie 会话cookie
      * @param query 请求字符串
      */
-    constructor(ip, cookie, server, req, res, pathname, query) {
+    constructor(ip, cookie, server, req, res, pathname, query, pluginContext) {
         this.ip = ip;
         this.cookie = cookie;
         this.query = query;
         this.server = server;
         this.pathname = pathname;
+        this.pluginContext = pluginContext;
         let header = {};
         for (let key in req.headers) {
             const value = req.headers[key];
@@ -395,5 +397,64 @@ class Session {
             this.response(fs_1.default.readFileSync(path), 'buffer');
         }
     }
+    /**
+     * 渲染模板
+     * @template 模板字符串
+     * @data 数据
+     * @missing 缺失值处理方式，keep-template: 保留模板，keep-key: 保留键，remove: 移除
+     * @regex 模板匹配正则，默认为{{ xxx.xxx }}
+     */
+    render(template, data, missing = 'keep-template', regex = /\{\{\s*([\w.]+)\s*\}\}/g) {
+        const getValue = (obj, path) => {
+            return path.split('.').reduce((acc, key) => acc?.[key], obj);
+        };
+        return template.replace(regex, (_, key) => {
+            const value = getValue(data, key);
+            if (value !== undefined)
+                return String(value);
+            switch (missing) {
+                case 'keep-key':
+                    return key;
+                case 'remove':
+                    return '';
+                case 'keep-template':
+                default:
+                    return _;
+            }
+        });
+    }
+    /**
+     * Renders a UI component using the plugin's declared renderer.
+     * @param component The component object to render.
+     * @param data The data/props to pass to the component.
+     */
+    async renderView(component, data = {}) {
+        if (!this.pluginContext) {
+            throw new Error(`Cannot call 'renderView' because the session is not associated with a plugin context.`);
+        }
+        const rendererName = this.pluginContext.instance.render;
+        const pluginName = this.pluginContext.pluginname;
+        if (!rendererName) {
+            this.server.core.logger.error(`Plugin "${pluginName}" uses 'renderView' but did not declare a renderer. Please add 'export const render = "your-renderer-name";' to your plugin's entry file.`);
+            // throw new Error(`Plugin "${pluginName}" did not declare a renderer.`);
+        }
+        const renderer = this.server.core.renderers.get(rendererName);
+        if (!renderer) {
+            this.server.core.logger.error(`Renderer "${rendererName}" declared by plugin "${pluginName}" is not registered. Have you installed the renderer package (e.g., '@yumerijs/vue-renderer')?`);
+            // throw new Error(`Renderer "${rendererName}" is not registered.`);
+        }
+        const renderOptions = {
+            pluginName,
+        };
+        try {
+            const html = await renderer.render(component, data, renderOptions);
+            this.setMime('text/html');
+            this.response(html, 'plain');
+        }
+        catch (error) {
+            this.server.core.logger.error(`Error while rendering view for plugin "${pluginName}":`, error);
+            throw error;
+        }
+    }
 }
 exports.Session = Session;

package/package.json

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