@yumerijs/core 2.2.2 → 3.0.0-alpha.1

package/dist/context.d.ts

@@ -10,6 +10,7 @@ interface Plugin {
     provide: Array<string>;
 }
 export interface Components {
+    [key: string]: any;
 }
 /**
  * 插件上下文对象
@@ -27,7 +28,7 @@ export declare class Context {
     private i18ns;
     component: Components;
     renderer?: IRenderer;
-    instance: any;
+    module: any;
     childpath: string;
     /** 插件名称 */
     pluginname: string;
@@ -36,7 +37,7 @@ export declare class Context {
      * @param core Core 实例
      * @param pluginname 插件名称
      */
-    constructor(core: Core, pluginname: string, instance?: any, injections?: Record<string, any>);
+    constructor(core: Core, pluginname: string, module?: any, injections?: Record<string, any>);
     /**
      * 注入依赖
      * @param name 依赖名称
@@ -101,10 +102,16 @@ export declare class Context {
     fork(name?: string, path?: string): Context;
     /**
      * 注册子插件
-     * @param plugin 插件实例
+     * @param module 插件模块
      * @param config 插件配置
      */
-    apply(plugin: Plugin, config: any): Promise<void>;
+    apply(module: Plugin, config: any): Promise<void>;
+    /**
+     * 快速注册子插件（自动 fork）
+     * @param module 插件模块
+     * @param config 插件配置
+     */
+    plugin(module: Plugin, config?: any): Promise<Context>;
     /**
      * 注册 i18n
      * @param content 内容（可以是嵌套对象或单个key）

package/dist/context.js

@@ -16,7 +16,7 @@ export class Context {
     i18ns = [];
     component;
     renderer;
-    instance;
+    module;
     childpath = '/';
     /** 插件名称 */
     pluginname;
@@ -25,9 +25,9 @@ export class Context {
      * @param core Core 实例
      * @param pluginname 插件名称
      */
-    constructor(core, pluginname, instance, injections = {}) {
+    constructor(core, pluginname, module, injections = {}) {
         this.core = core;
-        this.instance = instance;
+        this.module = module;
         this.pluginname = pluginname;
         this.childPlugins = new Map();
         this.component = injections;
@@ -145,15 +145,28 @@ export class Context {
     }
     /**
      * 注册子插件
-     * @param plugin 插件实例
+     * @param module 插件模块
      * @param config 插件配置
      */
-    async apply(plugin, config) {
-        if (!plugin || !plugin.apply)
+    async apply(module, config) {
+        if (!module)
             return;
         const ctx = this.fork();
-        await plugin.apply(ctx, config);
-        this.childPlugins.set(ctx, plugin);
+        await this.core.plugin(module, ctx, config);
+        this.childPlugins.set(ctx, module);
+    }
+    /**
+     * 快速注册子插件（自动 fork）
+     * @param module 插件模块
+     * @param config 插件配置
+     */
+    async plugin(module, config = {}) {
+        if (!module)
+            return;
+        const ctx = this.fork();
+        await this.core.plugin(module, ctx, config);
+        this.childPlugins.set(ctx, module);
+        return ctx;
     }
     /**
      * 注册 i18n

package/dist/core.d.ts

@@ -16,12 +16,12 @@ interface Plugin {
     provide: Array<string>;
 }
 export interface CoreOptions {
-    port: number;
-    host: string;
-    staticDir: string;
-    enableCors: boolean;
-    enableWs: boolean;
-    lang: string[];
+    port?: number;
+    host?: string;
+    enableCors?: boolean;
+    enableWs?: boolean;
+    lang?: string[];
+    skipcheckUpdates?: boolean;
 }
 export declare const coreConfigSchema: Schema<CoreOptions>;
 export declare const enum PluginStatus {
@@ -44,12 +44,13 @@ export declare class Core {
     loader: any;
     renderers: Map<string, IRenderer>;
     pluginRenderers: Map<string, string>;
-    constructor(loader?: any, coreConfig?: CoreOptions, setCore?: boolean);
+    constructor(loader?: any, coreConfig?: CoreOptions, loggersetCore?: boolean, splash?: boolean);
+    checkUpdate(): Promise<void>;
     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>;
+    plugin(module: Plugin, context: Context, config: Config): Promise<void>;
     registerComponent(name: string, component: any): void;
     getComponent(name: string): any;
     unregisterComponent(name: string): void;

package/dist/core.js

@@ -1,16 +1,18 @@
 import { EventEmitter } from 'events';
-import { Schema } from './config.js';
+import { Schema, fallback } from './config.js';
 import { Logger } from './logger.js';
 import { Route } from './route.js';
 import { Hook } from './hook.js';
 import { Server as CoreServer } from './server.js';
+import * as fs from 'fs';
+const version = JSON.parse(await fs.promises.readFile(new URL('../package.json', import.meta.url), 'utf-8')).version;
 export const coreConfigSchema = Schema.object({
     port: Schema.number('监听端口').default(14510),
     host: Schema.string('监听地址').default('0.0.0.0'),
-    staticDir: Schema.string('静态目录').default('public'),
     enableCors: Schema.boolean('启用跨域').default(false),
     enableWs: Schema.boolean('启用 WebSocket').default(false),
     lang: Schema.array(Schema.string(), '语言列表').default(['zh', 'en']),
+    skipcheckUpdates: Schema.boolean('启动时检查更新').default(false)
 });
 export class Core {
     emitter = new EventEmitter();
@@ -25,12 +27,32 @@ export class Core {
     loader;
     renderers = new Map();
     pluginRenderers = new Map(); // Stores which plugin uses which renderer
-    constructor(loader, coreConfig, setCore = true) {
-        this.coreConfig = coreConfig || {};
+    constructor(loader, coreConfig = {}, loggersetCore = true, splash = true) {
+        this.coreConfig = fallback(coreConfigSchema, coreConfig);
         this.loader = loader;
-        if (setCore)
+        if (splash)
+            this.logger.info('Welcome to use Yumeri ver.' + version);
+        if (!this.coreConfig.skipcheckUpdates)
+            this.checkUpdate();
+        if (loggersetCore)
             Logger.setCore(this);
     }
+    async checkUpdate() {
+        try {
+            const response = await fetch('https://registry.npmjs.org/yumeri/latest');
+            if (!response.ok)
+                return;
+            const { version: latest } = await response.json();
+            if (latest !== version) {
+                this.logger.info(`There is new version for Yumeri: ${version} -> ${latest}`);
+            }
+            else {
+            }
+        }
+        catch (error) {
+            this.logger.error('Error while checking updates: ', error.message);
+        }
+    }
     addRenderer(renderer) {
         if (this.renderers.has(renderer.name)) {
             this.logger.warn(`Renderer "${renderer.name}" is already registered and will be overwritten.`);
@@ -46,7 +68,6 @@ export class Core {
             host: this.coreConfig.host || '0.0.0.0',
             enableCors: this.coreConfig.enableCors || false,
             enableWs: this.coreConfig.enableWs || false,
-            staticDir: this.coreConfig.staticDir || 'public',
         });
         await this.server.start();
     }
@@ -60,12 +81,20 @@ export class Core {
         }
         return pluginName;
     }
-    async plugin(pluginInstance, context, config) {
+    async plugin(module, context, config) {
         const shortName = this.getShortPluginName(context.pluginname);
-        context.instance = pluginInstance;
+        context.module = module;
+        // 自动依赖注入
+        const depend = module.depend || [];
+        for (const name of depend) {
+            const component = this.getComponent(name);
+            if (component) {
+                context.inject(name, component);
+            }
+        }
         this.logger.info(`apply plugin ${shortName}`);
-        if (pluginInstance.apply) {
-            await pluginInstance.apply(context, config);
+        if (module.apply) {
+            await module.apply(context, config);
         }
     }
     registerComponent(name, component) {
@@ -123,7 +152,7 @@ export class Core {
     async executeRoute(pathname, session, queryParams) {
         for (const routePath in this.routes) {
             const route = this.routes[routePath];
-            const result = route.match(pathname);
+            const result = route.match(pathname, session.client?.headers?.host);
             if (result) {
                 try {
                     this.emit('request:start', {
@@ -151,7 +180,7 @@ export class Core {
                         }
                         else {
                             const start = Date.now();
-                            await route.executeHandler(session, queryParams, result.pathParams);
+                            await route.executeHandler(session, queryParams, result.pathParams, result.hostParams);
                             this.emit('route:end', {
                                 path: pathname,
                                 route: routePath,

package/dist/route.d.ts

@@ -25,6 +25,7 @@ export declare class Route {
     allowedMethods: string[];
     ws: WebSocketServer;
     context: Context;
+    private routehost;
     /**
      * 创建路由
      * @param path 路由路径
@@ -37,6 +38,12 @@ export declare class Route {
      * @returns this
      */
     action(handler: RouteHandler): this;
+    /**
+     * 设置允许的host
+     * @param host host列表
+     * @returns this
+     */
+    host(host: string[] | string): this;
     /**
      * 挂载中间件
      * @param middleware 中间件
@@ -46,11 +53,13 @@ export declare class Route {
     /**
      * 匹配路由
      * @param pathname 请求路径
+     * @param host 请求host
      * @returns 匹配结果
      */
-    match(pathname: string): {
+    match(pathname: string, host?: string): {
         params: Record<string, string | undefined>;
         pathParams: string[];
+        hostParams: Record<string, string>;
     } | null;
     /**
      * 执行路由处理器
@@ -58,7 +67,7 @@ export declare class Route {
      * @param params 查询参数
      * @param pathParams 路由参数
      */
-    executeHandler(session: Session, params: URLSearchParams, pathParams: string[]): Promise<void>;
+    executeHandler(session: Session, params: URLSearchParams, pathParams: string[], hostParams: Record<string, string>): Promise<void>;
     /**
      * 设置可用方法
      * @param methods 可用方法

package/dist/route.js

@@ -22,6 +22,23 @@ function parsePatternToSegments(pattern) {
     }
     return { segments, params };
 }
+function parseHostToSegments(hostPattern) {
+    // 移除可能的空格，按 . 分割
+    const parts = hostPattern.split('.');
+    return parts.map(part => {
+        // 简单的参数解析逻辑
+        if (part.startsWith(':')) {
+            const lastChar = part[part.length - 1];
+            const hasModifier = ['?', '+', '*'].includes(lastChar);
+            return {
+                type: 'param',
+                name: hasModifier ? part.slice(1, -1) : part.slice(1),
+                modifier: hasModifier ? lastChar : '',
+            };
+        }
+        return { type: 'static', value: part };
+    });
+}
 /**
  * Route class using segment-based matching (no fragile capture-group-index mapping).
  * Behavior matches the SimpleRouter in the webpage:
@@ -39,6 +56,7 @@ export class Route {
     allowedMethods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD'];
     ws = null;
     context;
+    routehost = null;
     /**
      * 创建路由
      * @param path 路由路径
@@ -60,6 +78,20 @@ export class Route {
         this.handler = handler;
         return this;
     }
+    /**
+     * 设置允许的host
+     * @param host host列表
+     * @returns this
+     */
+    host(host) {
+        if (typeof host === 'string') {
+            this.routehost = [host];
+        }
+        else {
+            this.routehost = host;
+        }
+        return this;
+    }
     /**
      * 挂载中间件
      * @param middleware 中间件
@@ -72,9 +104,117 @@ export class Route {
     /**
      * 匹配路由
      * @param pathname 请求路径
+     * @param host 请求host
      * @returns 匹配结果
      */
-    match(pathname) {
+    match(pathname, host) {
+        let hostParams = {};
+        // Host 匹配逻辑开始
+        if (this.routehost && this.routehost.length > 0) {
+            if (!host)
+                return null; // 如果设置了 host 限制但没有传入 host，直接失败
+            const actualHost = host.toLowerCase().split(':')[0]; // 移除端口并转小写
+            const hostParts = actualHost.split('.');
+            let hostMatched = false;
+            for (const pattern of this.routehost) {
+                const hSegments = parseHostToSegments(pattern); // 这里的 parsePattern 应该和你 path 解析逻辑一致
+                let hi = 0; // pattern segment index
+                let hj = 0; // actual host parts index
+                let tempParams = {};
+                let possible = true;
+                while (hi < hSegments.length) {
+                    const seg = hSegments[hi];
+                    const nextSegIsStatic = !!hSegments[hi + 1] && hSegments[hi + 1].type === 'static';
+                    if (seg.type === 'static') {
+                        if (hj >= hostParts.length || hostParts[hj] !== seg.value.toLowerCase()) {
+                            possible = false;
+                            break;
+                        }
+                        hi++;
+                        hj++;
+                    }
+                    else {
+                        // 参数匹配逻辑 (:, ?, +, *)
+                        switch (seg.modifier) {
+                            case '': // required single
+                                if (hj >= hostParts.length) {
+                                    possible = false;
+                                    break;
+                                }
+                                tempParams[seg.name] = hostParts[hj];
+                                hi++;
+                                hj++;
+                                break;
+                            case '?': // optional single
+                                if (hj < hostParts.length) {
+                                    if (nextSegIsStatic && hostParts[hj] === hSegments[hi + 1].value.toLowerCase()) {
+                                        tempParams[seg.name] = undefined;
+                                        hi++;
+                                    }
+                                    else {
+                                        tempParams[seg.name] = hostParts[hj];
+                                        hj++;
+                                        hi++;
+                                    }
+                                }
+                                else {
+                                    tempParams[seg.name] = undefined;
+                                    hi++;
+                                }
+                                break;
+                            case '+': // required multi
+                                if (hj >= hostParts.length) {
+                                    possible = false;
+                                    break;
+                                }
+                                let endP = hostParts.length;
+                                if (nextSegIsStatic) {
+                                    let found = hostParts.indexOf(hSegments[hi + 1].value.toLowerCase(), hj);
+                                    if (found === -1) {
+                                        possible = false;
+                                        break;
+                                    }
+                                    endP = found;
+                                }
+                                if (endP === hj) {
+                                    possible = false;
+                                    break;
+                                }
+                                tempParams[seg.name] = hostParts.slice(hj, endP).join('.');
+                                hj = endP;
+                                hi++;
+                                break;
+                            case '*': // optional multi
+                                let endS = hostParts.length;
+                                if (nextSegIsStatic) {
+                                    let found = hostParts.indexOf(hSegments[hi + 1].value.toLowerCase(), hj);
+                                    if (found !== -1)
+                                        endS = found;
+                                }
+                                const val = hostParts.slice(hj, endS).join('.');
+                                tempParams[seg.name] = val === '' ? undefined : val;
+                                hj = endS;
+                                hi++;
+                                break;
+                            default:
+                                possible = false;
+                                break;
+                        }
+                        if (!possible)
+                            break;
+                    }
+                }
+                if (possible && hj === hostParts.length) {
+                    hostMatched = true;
+                    hostParams = tempParams;
+                    break; // 只要匹配到一个 host pattern 就行
+                }
+            }
+            if (!hostMatched)
+                return null;
+        }
+        // Host 匹配逻辑结束
+        // 路由匹配逻辑开始
         if (pathname.startsWith('/')) {
             // normalize pathname: remove leading/trailing slashes
             const normPath = pathname.replace(/^\/+|\/+$/g, '');
@@ -198,10 +338,12 @@ export class Route {
             // after finishing pattern, path must be fully consumed (no extra segments)
             if (j !== parts.length)
                 return null;
-            return { params, pathParams };
+            const result = { params, pathParams, hostParams };
+            return result;
         }
         else if (pathname.startsWith('root') && this.path == pathname) {
-            return { params: { pathname }, pathParams: [pathname] };
+            const result = { params: { pathname }, pathParams: [pathname], hostParams };
+            return result;
         }
         return null;
     }
@@ -211,9 +353,9 @@ export class Route {
      * @param params 查询参数
      * @param pathParams 路由参数
      */
-    async executeHandler(session, params, pathParams) {
+    async executeHandler(session, params, pathParams, hostParams) {
         if (this.handler) {
-            await this.handler(session, params, ...pathParams);
+            await this.handler(session, params, ...pathParams, ...Object.values(hostParams));
         }
     }
     /**

package/dist/server.d.ts

@@ -1,24 +1,42 @@
 import { Core } from './core.js';
+/** 服务器配置接口 */
 export interface ServerConfig {
+    /** 监听端口 */
     port: number;
+    /** 监听主机 */
     host: string;
+    /** 是否启用跨域 */
     enableCors: boolean;
-    staticDir: string;
+    /** 是否启用 WebSocket */
     enableWs: boolean;
 }
+/**
+ * 核心服务器类
+ * 负责底层 HTTP 请求的监听、分发和响应
+ */
 export declare class Server {
     core: Core;
     private port;
     private host;
     private enableCors;
-    private staticDir;
     private httpServer;
     constructor(core: Core, config?: Partial<ServerConfig>);
-    getStaticDir(): string;
+    /**
+     * 创建一个新的会话对象
+     */
     private createSession;
+    /**
+     * 解析请求中的 Cookie
+     */
     private parseCookies;
+    /**
+     * 获取客户端真实 IP
+     */
     private getClientIP;
-    private serveStaticFile;
+    /**
+     * 启动服务器
+     */
     start(): Promise<void>;
+    /** 停止服务器 */
     stop(): void;
 }