@yumerijs/core 2.0.13 → 2.1.0

package/dist/context.d.ts

@@ -9,6 +9,8 @@ interface Plugin {
     depend: Array<string>;
     provide: Array<string>;
 }
+export interface Components {
+}
 /**
  * 插件上下文对象
  * 每个插件一个 Context，用于管理插件注册的命令、路由、事件、组件和中间件
@@ -23,6 +25,8 @@ export declare class Context {
     private childContexts;
     private childPlugins;
     private i18ns;
+    component: Components;
+    instance: any;
     /** 插件名称 */
     pluginname: string;
     /**
@@ -30,7 +34,13 @@ export declare class Context {
      * @param core Core 实例
      * @param pluginname 插件名称
      */
-    constructor(core: Core, pluginname: string);
+    constructor(core: Core, pluginname: string, instance?: any, injections?: Record<string, any>);
+    /**
+     * 注入依赖
+     * @param name 依赖名称
+     * @param value 依赖值
+     */
+    inject(name: string, value: any): void;
     /**
      * 注册路由
      * @param path 路由路径
@@ -72,6 +82,7 @@ export declare class Context {
     emit(event: string, ...args: any[]): Promise<void>;
     /**
      * 获取组件实例
+     * @deprecated
      * @param name 组件名称
      */
     getComponent(name: string): any;

package/dist/context.js

@@ -16,6 +16,8 @@ class Context {
     childContexts = [];
     childPlugins = new Map();
     i18ns = [];
+    component;
+    instance;
     /** 插件名称 */
     pluginname;
     /**
@@ -23,10 +25,20 @@ class Context {
      * @param core Core 实例
      * @param pluginname 插件名称
      */
-    constructor(core, pluginname) {
+    constructor(core, pluginname, instance, injections = {}) {
         this.core = core;
+        this.instance = instance;
         this.pluginname = pluginname;
         this.childPlugins = new Map();
+        this.component = injections;
+    }
+    /**
+     * 注入依赖
+     * @param name 依赖名称
+     * @param value 依赖值
+     */
+    inject(name, value) {
+        this.component[name] = value;
     }
     /**
      * 注册路由
@@ -36,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);
     }
     /**
      * 注册事件
@@ -99,6 +111,7 @@ class Context {
     }
     /**
      * 获取组件实例
+     * @deprecated
      * @param name 组件名称
      */
     getComponent(name) {
@@ -184,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,7 +44,11 @@ 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";
+}
 class Server {
     core;
     port;
@@ -59,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;
@@ -109,84 +116,75 @@ 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');
-            if (route && route.allowedMethods.includes(req.method ?? 'GET')) {
-                const matched = await this.core.executeRoute(pathname, session, queryParams);
+            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) {
                     this.serveStaticFile(pathname, res);
+                    return;
                 }
-                else {
-                    if (!session.responseHandled) {
-                        let head = session.head;
-                        head['Set-Cookie'] = Object.entries(session.newCookie).map(([name, cookie]) => {
-                            let cookieString = `${name}=${cookie.value}`;
-                            if (cookie.options.expires) {
-                                cookieString += `; Expires=${cookie.options.expires.toUTCString()}`;
-                            }
-                            if (cookie.options.path) {
-                                cookieString += `; Path=${cookie.options.path}`;
-                            }
-                            if (cookie.options.domain) {
-                                cookieString += `; Domain=${cookie.options.domain}`;
-                            }
-                            if (cookie.options.secure) {
-                                cookieString += `; Secure`;
-                            }
-                            if (cookie.options.httpOnly) {
-                                cookieString += `; HttpOnly`;
-                            }
-                            if (cookie.options.sameSite) {
-                                cookieString += `; SameSite=${cookie.options.sameSite}`;
-                            }
-                            return cookieString;
-                        });
-                        if (this.enableCors) {
-                            head['Access-Control-Allow-Origin'] = '*';
-                        }
-                        res.writeHead(session.status ?? 200, head);
+                if (session.responseHandled)
+                    return;
+                const head = { ...session.head };
+                head['Set-Cookie'] = Object.entries(session.newCookie).map(([name, cookie]) => {
+                    let cookieString = `${name}=${cookie.value}`;
+                    if (cookie.options.expires)
+                        cookieString += `; Expires=${cookie.options.expires.toUTCString()}`;
+                    if (cookie.options.path)
+                        cookieString += `; Path=${cookie.options.path}`;
+                    if (cookie.options.domain)
+                        cookieString += `; Domain=${cookie.options.domain}`;
+                    if (cookie.options.secure)
+                        cookieString += `; Secure`;
+                    if (cookie.options.httpOnly)
+                        cookieString += `; HttpOnly`;
+                    if (cookie.options.sameSite)
+                        cookieString += `; SameSite=${cookie.options.sameSite}`;
+                    return cookieString;
+                });
+                if (this.enableCors) {
+                    head['Access-Control-Allow-Origin'] = '*';
+                }
+                res.writeHead(session.status ?? 200, head);
+                switch (session.restype) {
+                    case 'plain':
                         res.end(session.body);
-                    }
+                        break;
+                    case 'buffer':
+                        res.end(session.body);
+                        break;
+                    case 'json':
+                        res.end(JSON.stringify(session.body));
+                        break;
+                    case 'stream':
+                        if (isStream(session.body)) {
+                            const stream = session.body;
+                            stream.pipe(res);
+                        }
+                        break;
+                    default:
+                        res.end(session.body); // fallback
                 }
+            };
+            if (route && route.allowedMethods.includes(req.method ?? 'GET')) {
+                await handleRoute(pathname);
             }
             else if (rootroute && rootroute.allowedMethods.includes(req.method ?? 'GET')) {
-                const matched = await this.core.executeRoute('root', session, queryParams);
-                if (!matched) {
-                    this.serveStaticFile(pathname, res);
-                }
-                else {
-                    if (!session.responseHandled) {
-                        let head = session.head;
-                        head['Set-Cookie'] = Object.entries(session.newCookie).map(([name, cookie]) => {
-                            let cookieString = `${name}=${cookie.value}`;
-                            if (cookie.options.expires) {
-                                cookieString += `; Expires=${cookie.options.expires.toUTCString()}`;
-                            }
-                            if (cookie.options.path) {
-                                cookieString += `; Path=${cookie.options.path}`;
-                            }
-                            if (cookie.options.domain) {
-                                cookieString += `; Domain=${cookie.options.domain}`;
-                            }
-                            if (cookie.options.secure) {
-                                cookieString += `; Secure`;
-                            }
-                            if (cookie.options.httpOnly) {
-                                cookieString += `; HttpOnly`;
-                            }
-                            if (cookie.options.sameSite) {
-                                cookieString += `; SameSite=${cookie.options.sameSite}`;
-                            }
-                            return cookieString;
-                        });
-                        if (this.enableCors) {
-                            head['Access-Control-Allow-Origin'] = '*';
-                        }
-                        res.writeHead(session.status ?? 200, head);
-                        res.end(session.body);
-                    }
-                }
+                await handleRoute('root');
             }
             else {
                 this.serveStaticFile(pathname, res);
@@ -198,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

@@ -5,7 +5,10 @@
  **/
 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;
@@ -34,6 +37,13 @@ export interface StaticCacheOptions {
     smaxAge?: number;
     etagType?: 'md5' | 'sha1' | 'sha256' | 'sha512';
 }
+type ResType = "plain" | "json" | "stream" | "buffer";
+interface BodyMap {
+    plain: string;
+    json: Record<string, any>;
+    stream: Stream;
+    buffer: Buffer;
+}
 export declare class Session {
     ip: string;
     cookie: Record<string, string>;
@@ -46,7 +56,8 @@ export declare class Session {
     }>;
     head: Record<string, any>;
     status: number;
-    body: any;
+    private _restype;
+    private _body;
     properties?: Record<string, any>;
     client: Client;
     server: Server;
@@ -54,13 +65,18 @@ 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;
+    set body(value: string);
     setCookie(name: string, value: string, options?: CookieOptions): void;
     /**
      * 解析 Accept-Language 字符串为排序后的语言数组
@@ -104,7 +120,38 @@ export declare class Session {
      * @param option 选项
      */
     setCache(option: CacheOptions): void;
+    /**
+     * 设置静态文件
+     * @param content 文件内容
+     * @param option 选项
+     */
     static(content: string, option: CacheOptions): void;
+    /**
+     * 发送静态文件
+     * @param path 文件路径
+     * @param option 缓存选项
+     * @returns void
+     */
     file(path: string, option: StaticCacheOptions): void;
+    /**
+     * 发送普通文件
+     * @param path 文件路径
+     * @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

@@ -54,7 +54,8 @@ class Session {
     newCookie = {};
     head = {};
     status = 200;
-    body;
+    _restype = "plain";
+    _body;
     properties = {};
     client = null;
     server;
@@ -62,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];
@@ -108,6 +111,20 @@ class Session {
             this.setCookie('lang', this.languages.join(','));
         }
     }
+    response(body, type = 'text') {
+        this._restype = type;
+        this._body = body;
+    }
+    get restype() {
+        return this._restype;
+    }
+    get body() {
+        return this._body;
+    }
+    set body(value) {
+        this._body = value;
+        this._restype = "plain"; // 自动把 restype 设成 plain
+    }
     setCookie(name, value, options = {}) {
         if (options.path === undefined) {
             options.path = '/';
@@ -310,6 +327,11 @@ class Session {
         if (option.expires)
             this.head['Expires'] = option.expires.toUTCString();
     }
+    /**
+     * 设置静态文件
+     * @param content 文件内容
+     * @param option 选项
+     */
     static(content, option) {
         // 先查看用户是否在询问文件修改情况
         if (this.client.headers['If-Modified-Since']) {
@@ -326,8 +348,14 @@ class Session {
             }
         }
         this.setCache(option);
-        this.body = content;
+        this.response(content);
     }
+    /**
+     * 发送静态文件
+     * @param path 文件路径
+     * @param option 缓存选项
+     * @returns void
+     */
     file(path, option) {
         if (this.client.headers['If-Modified-Since']) {
             const modified = new Date(this.client.headers['If-Modified-Since']);
@@ -353,7 +381,80 @@ class Session {
             smaxAge: option.smaxAge,
             cacheControl: 'public'
         });
-        this.body = fs_1.default.readFileSync(path, 'utf-8');
+        this.response(fs_1.default.createReadStream(path), 'stream');
+    }
+    /**
+     * 发送普通文件
+     * @param path 文件路径
+     * @param isStream 是否流式传输
+     */
+    sendFile(path, isStream = false) {
+        if (isStream) {
+            this.setMime('application/octet-stream');
+            this.response(fs_1.default.createReadStream(path), 'stream');
+        }
+        else {
+            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.13",
+  "version": "2.1.0",
   "description": "Core module for yumeri",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",