@yumerijs/core 2.0.14 → 2.1.1

package/dist/config.d.ts

@@ -1,122 +1,31 @@
-/**
- * @time: 2025/05/24 12:18
- * @author: FireGuo
- * WindyPear-Team All right reserved
- **/
-/**
- * 插件配置模式定义类
- * 用于描述插件配置项的类型、默认值、描述等信息
- */
-export declare class ConfigSchema {
-    /**
-     * 配置项类型
-     */
-    type: 'string' | 'number' | 'boolean' | 'object' | 'array';
-    /**
-     * 默认值
-     */
-    default?: any;
-    /**
-     * 配置项描述
-     */
+export declare function fallback<T>(schema: Schema<T>, config: T): T;
+export declare class Schema<T = any> {
+    _type?: T;
+    type: string;
+    isRequired?: boolean;
     description?: string;
-    /**
-     * 是否必需
-     */
-    required?: boolean;
-    /**
-     * 枚举值列表（可选项）
-     */
-    enum?: any[];
-    /**
-     * 数组项类型定义（当type为array时使用）
-     */
-    items?: ConfigSchema;
-    /**
-     * 对象属性定义（当type为object时使用）
-     */
-    properties?: Record<string, ConfigSchema>;
-    /**
-     * 创建配置模式对象
-     * @param type 配置项类型
-     * @param options 配置项选项
-     */
-    constructor(type: 'string' | 'number' | 'boolean' | 'object' | 'array', options?: {
-        default?: any;
-        description?: string;
-        required?: boolean;
-        enum?: any[];
-        items?: ConfigSchema;
-        properties?: Record<string, ConfigSchema>;
+    defaultValue?: any;
+    properties?: Record<string, Schema<any>>;
+    items?: Schema<any>;
+    enum?: T[];
+    constructor(definition: Omit<Schema<T>, '_type' | 'required' | 'default'> & {
+        enum?: T[];
     });
-    /**
-     * 创建字符串类型配置模式
-     * @param options 配置项选项
-     * @returns 配置模式对象
-     */
-    static string(options?: Omit<ConfigSchema, 'type' | 'items' | 'properties'>): ConfigSchema;
-    /**
-     * 创建数字类型配置模式
-     * @param options 配置项选项
-     * @returns 配置模式对象
-     */
-    static number(options?: Omit<ConfigSchema, 'type' | 'items' | 'properties'>): ConfigSchema;
-    /**
-     * 创建布尔类型配置模式
-     * @param options 配置项选项
-     * @returns 配置模式对象
-     */
-    static boolean(options?: Omit<ConfigSchema, 'type' | 'items' | 'properties'>): ConfigSchema;
-    /**
-     * 创建对象类型配置模式
-     * @param properties 对象属性定义
-     * @param options 配置项选项
-     * @returns 配置模式对象
-     */
-    static object(properties: Record<string, ConfigSchema>, options?: Omit<ConfigSchema, 'type' | 'items' | 'properties'>): ConfigSchema;
-    /**
-     * 创建数组类型配置模式
-     * @param items 数组项类型定义
-     * @param options 配置项选项
-     * @returns 配置模式对象
-     */
-    static array(items: ConfigSchema, options?: Omit<ConfigSchema, 'type' | 'items' | 'properties'>): ConfigSchema;
+    static string(description?: string): Schema<string>;
+    static number(description?: string): Schema<number>;
+    static boolean(description?: string): Schema<boolean>;
+    static array<T>(inner: Schema<T>, description?: string): Schema<T[]>;
+    static object<T extends {}>(properties: {
+        [K in keyof T]: Schema<T[K]>;
+    }, description?: string): Schema<T>;
+    static extend<T extends {}, U extends {}>(base: Schema<T>, extension: {
+        [K in keyof U]: Schema<U[K]>;
+    }, description?: string): Schema<T & U>;
+    static enum<L extends string | number>(values: L[], description?: string): Schema<L>;
+    required(this: this): this;
+    default(this: this, value: T): this;
 }
-export declare class Config {
-    /**
-     * 配置名称
-     */
-    name: string;
-    /**
-     * 配置内容
-     */
-    content: {
-        [name: string]: any;
-    };
-    /**
-     * 配置模式
-     */
-    schema?: Record<string, ConfigSchema>;
-    /**
-     * 创建配置对象
-     * @param name 配置名称
-     * @param content 配置内容
-     * @param schema 配置模式
-     */
-    constructor(name: string, content?: {
-        [name: string]: any;
-    }, schema?: Record<string, ConfigSchema>);
-    /**
-     * 获取配置项值
-     * @param key 配置项键名
-     * @param defaultValue 默认值
-     * @returns 配置项值
-     */
-    get<T>(key: string, defaultValue?: T): T;
-    /**
-     * 设置配置项值
-     * @param key 配置项键名
-     * @param value 配置项值
-     */
-    set(key: string, value: any): void;
+export { Schema as ConfigSchema };
+export interface Config {
+    [key: string]: any;
 }

package/dist/config.js

@@ -1,151 +1,83 @@
 "use strict";
-/**
- * @time: 2025/05/24 12:18
- * @author: FireGuo
- * WindyPear-Team All right reserved
- **/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Config = exports.ConfigSchema = void 0;
-/**
- * 插件配置模式定义类
- * 用于描述插件配置项的类型、默认值、描述等信息
- */
-class ConfigSchema {
-    /**
-     * 配置项类型
-     */
+exports.ConfigSchema = exports.Schema = void 0;
+exports.fallback = fallback;
+function isNullable(value) {
+    return value === null || value === undefined;
+}
+function fallback(schema, config) {
+    if (!schema)
+        return config;
+    let result = config;
+    if (isNullable(result)) {
+        result = schema.defaultValue;
+    }
+    if (schema.type === 'object') {
+        if (typeof result !== 'object' || result === null) {
+            result = {};
+        }
+        for (const key in schema.properties) {
+            const innerSchema = schema.properties[key];
+            result[key] = fallback(innerSchema, result[key]);
+        }
+    }
+    else if (schema.type === 'array' && schema.items) {
+        if (!Array.isArray(result)) {
+            result = [];
+        }
+        result = result.map((item) => fallback(schema.items, item));
+    }
+    return result;
+}
+class Schema {
+    _type; // Phantom type
     type;
-    /**
-     * 默认值
-     */
-    default;
-    /**
-     * 配置项描述
-     */
+    isRequired;
     description;
-    /**
-     * 是否必需
-     */
-    required;
-    /**
-     * 枚举值列表（可选项）
-     */
-    enum;
-    /**
-     * 数组项类型定义（当type为array时使用）
-     */
-    items;
-    /**
-     * 对象属性定义（当type为object时使用）
-     */
+    defaultValue;
     properties;
-    /**
-     * 创建配置模式对象
-     * @param type 配置项类型
-     * @param options 配置项选项
-     */
-    constructor(type, options) {
-        this.type = type;
-        if (options) {
-            this.default = options.default;
-            this.description = options.description;
-            this.required = options.required;
-            this.enum = options.enum;
-            this.items = options.items;
-            this.properties = options.properties;
-        }
+    items;
+    enum;
+    constructor(definition) {
+        this.type = definition.type;
+        this.isRequired = definition.isRequired;
+        this.description = definition.description;
+        this.defaultValue = definition.defaultValue;
+        this.properties = definition.properties;
+        this.items = definition.items;
+        this.enum = definition.enum;
     }
-    /**
-     * 创建字符串类型配置模式
-     * @param options 配置项选项
-     * @returns 配置模式对象
-     */
-    static string(options) {
-        return new ConfigSchema('string', options);
+    static string(description) {
+        return new Schema({ type: 'string', description });
     }
-    /**
-     * 创建数字类型配置模式
-     * @param options 配置项选项
-     * @returns 配置模式对象
-     */
-    static number(options) {
-        return new ConfigSchema('number', options);
+    static number(description) {
+        return new Schema({ type: 'number', description });
     }
-    /**
-     * 创建布尔类型配置模式
-     * @param options 配置项选项
-     * @returns 配置模式对象
-     */
-    static boolean(options) {
-        return new ConfigSchema('boolean', options);
+    static boolean(description) {
+        return new Schema({ type: 'boolean', description });
     }
-    /**
-     * 创建对象类型配置模式
-     * @param properties 对象属性定义
-     * @param options 配置项选项
-     * @returns 配置模式对象
-     */
-    static object(properties, options) {
-        return new ConfigSchema('object', { ...options, properties });
+    static array(inner, description) {
+        return new Schema({ type: 'array', items: inner, description });
     }
-    /**
-     * 创建数组类型配置模式
-     * @param items 数组项类型定义
-     * @param options 配置项选项
-     * @returns 配置模式对象
-     */
-    static array(items, options) {
-        return new ConfigSchema('array', { ...options, items });
+    static object(properties, description) {
+        return new Schema({ type: 'object', properties, description });
     }
-}
-exports.ConfigSchema = ConfigSchema;
-class Config {
-    /**
-     * 配置名称
-     */
-    name = '';
-    /**
-     * 配置内容
-     */
-    content = {};
-    /**
-     * 配置模式
-     */
-    schema;
-    /**
-     * 创建配置对象
-     * @param name 配置名称
-     * @param content 配置内容
-     * @param schema 配置模式
-     */
-    constructor(name, content, schema) {
-        this.name = name;
-        this.content = content || {}; // 如果 content 是 undefined，则赋值为空对象
-        this.schema = schema;
+    static extend(base, extension, description) {
+        const combinedProperties = { ...base.properties, ...extension };
+        return new Schema({ type: 'object', properties: combinedProperties, description: description || base.description });
     }
-    /**
-     * 获取配置项值
-     * @param key 配置项键名
-     * @param defaultValue 默认值
-     * @returns 配置项值
-     */
-    get(key, defaultValue) {
-        if (this.content[key] !== undefined) {
-            return this.content[key];
-        }
-        // 如果有schema，尝试从schema中获取默认值
-        if (this.schema && this.schema[key] && this.schema[key].default !== undefined) {
-            return this.schema[key].default;
-        }
-        return defaultValue;
+    static enum(values, description) {
+        const type = typeof values[0] === 'string' ? 'string' : typeof values[0] === 'number' ? 'number' : 'string'; // Infer type based on first value
+        return new Schema({ type, enum: values, description });
+    }
+    required() {
+        this.isRequired = true;
+        return this;
     }
-    /**
-     * 设置配置项值
-     * @param key 配置项键名
-     * @param value 配置项值
-     */
-    set(key, value) {
-        this.content[key] = value;
+    default(value) {
+        this.defaultValue = value;
+        return this;
     }
 }
-exports.Config = Config;
+exports.Schema = Schema;
+exports.ConfigSchema = Schema;

package/dist/context.d.ts

@@ -2,9 +2,8 @@ import { Core } from './core';
 import { Route } from './route';
 import { HookHandler } from './hook';
 import { Middleware } from './middleware';
-import { Config } from './config';
 interface Plugin {
-    apply: (ctx: Context, config: Config) => Promise<void>;
+    apply: (ctx: Context, config: any) => any;
     disable: (ctx: Context) => Promise<void>;
     depend: Array<string>;
     provide: Array<string>;
@@ -26,6 +25,7 @@ export declare class Context {
     private childPlugins;
     private i18ns;
     component: Components;
+    instance: any;
     /** 插件名称 */
     pluginname: string;
     /**
@@ -33,7 +33,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 依赖名称
@@ -101,7 +101,7 @@ export declare class Context {
      * @param plugin 插件实例
      * @param config 插件配置
      */
-    apply(plugin: Plugin, config: Config): Promise<void>;
+    apply(plugin: Plugin, config: any): Promise<void>;
     /**
      * 注册 i18n
      * @param content 内容（可以是嵌套对象或单个key）

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.1",
   "description": "Core module for yumeri",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",