@yumerijs/core 2.2.2 → 3.0.0-alpha.2

package/dist/context.d.ts

@@ -1,15 +1,10 @@
-import { Core } from './core.js';
+import { Core, Plugin } from './core.js';
 import { Route } from './route.js';
 import { HookHandler } from './hook.js';
 import { Middleware } from './middleware.js';
 import { IRenderer } from '@yumerijs/types';
-interface Plugin {
-    apply: (ctx: Context, config: any) => any;
-    disable: (ctx: Context) => Promise<void>;
-    depend: Array<string>;
-    provide: Array<string>;
-}
 export interface Components {
+    [key: string]: any;
 }
 /**
  * 插件上下文对象
@@ -27,7 +22,7 @@ export declare class Context {
     private i18ns;
     component: Components;
     renderer?: IRenderer;
-    instance: any;
+    module: any;
     childpath: string;
     /** 插件名称 */
     pluginname: string;
@@ -36,7 +31,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 +96,16 @@ export declare class Context {
     fork(name?: string, path?: string): Context;
     /**
      * 注册子插件
-     * @param plugin 插件实例
+     * @param module 插件模块
+     * @param config 插件配置
+     */
+    apply(module: Plugin, config: any): Promise<void>;
+    /**
+     * 快速注册子插件（自动 fork）
+     * @param module 插件模块
      * @param config 插件配置
      */
-    apply(plugin: Plugin, config: any): Promise<void>;
+    plugin(module: Plugin, config?: any): Promise<Context>;
     /**
      * 注册 i18n
      * @param content 内容（可以是嵌套对象或单个key）
@@ -116,4 +117,3 @@ export declare class Context {
      */
     dispose(): Promise<void>;
 }
-export {};

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

@@ -9,19 +9,32 @@ import { HookHandler, Hook } from './hook.js';
 import { Server as CoreServer } from './server.js';
 import { I18n } from './i18n.js';
 import { IRenderer } from '@yumerijs/types';
-interface Plugin {
-    apply: (ctx: Context, config: Config) => Promise<void>;
-    disable: (ctx: Context) => Promise<void>;
-    depend: Array<string>;
-    provide: Array<string>;
+export interface Plugin {
+    apply?: (ctx: Context, config: Config) => Promise<void> | void;
+    disable?: (ctx: Context) => Promise<void> | void;
+    depend?: Array<string>;
+    provide?: Array<string>;
+    render?: string;
+    config?: Schema<any>;
 }
+type PluginConstructor = new (ctx: Context, config: Config) => Plugin;
+type PluginModuleLike = Plugin | PluginConstructor | ((ctx: Context, config: Config) => Promise<void> | void) | {
+    default?: Plugin | PluginConstructor | ((ctx: Context, config: Config) => Promise<void> | void);
+    apply?: ((ctx: Context, config: Config) => Promise<void> | void);
+    disable?: (ctx: Context) => Promise<void> | void;
+    depend?: Array<string>;
+    provide?: Array<string>;
+    render?: string;
+    config?: Schema<any>;
+};
+export declare function resolvePluginModule(module: PluginModuleLike, context: Context, config: Config): Plugin;
 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 +57,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: PluginModuleLike, 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,60 @@
 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;
+function isClassPlugin(value) {
+    if (typeof value !== 'function')
+        return false;
+    const source = Function.prototype.toString.call(value);
+    return source.startsWith('class ');
+}
+function mergePluginMeta(target, source) {
+    if (!source || typeof source !== 'object')
+        return target;
+    if (target.depend == null && Array.isArray(source.depend))
+        target.depend = source.depend;
+    if (target.provide == null && Array.isArray(source.provide))
+        target.provide = source.provide;
+    if (target.render == null && typeof source.render === 'string')
+        target.render = source.render;
+    if (target.config == null && source.config)
+        target.config = source.config;
+    if (target.disable == null && typeof source.disable === 'function')
+        target.disable = source.disable.bind(source);
+    return target;
+}
+export function resolvePluginModule(module, context, config) {
+    const candidate = module?.default ?? module?.apply ?? module;
+    let plugin;
+    if (isClassPlugin(candidate)) {
+        plugin = new candidate(context, config);
+    }
+    else if (typeof candidate === 'function') {
+        plugin = { apply: candidate };
+    }
+    else if (candidate && typeof candidate === 'object') {
+        plugin = candidate;
+    }
+    else {
+        throw new TypeError('Invalid plugin module. Expected class, function, or plugin object.');
+    }
+    mergePluginMeta(plugin, module);
+    if (candidate !== module) {
+        mergePluginMeta(plugin, candidate);
+    }
+    return plugin;
+}
 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 +69,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 +110,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 +123,21 @@ export class Core {
         }
         return pluginName;
     }
-    async plugin(pluginInstance, context, config) {
+    async plugin(module, context, config) {
+        const plugin = resolvePluginModule(module, context, config);
         const shortName = this.getShortPluginName(context.pluginname);
-        context.instance = pluginInstance;
+        context.module = plugin;
+        // 自动依赖注入
+        const depend = plugin.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 (plugin.apply) {
+            await plugin.apply(context, config);
         }
     }
     registerComponent(name, component) {
@@ -123,7 +195,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 +223,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

@@ -1,4 +1,5 @@
 import { WebSocketServer } from 'ws';
+import { isIP } from 'node:net';
 function parsePatternToSegments(pattern) {
     // Normalize: remove leading/trailing slashes for consistent splitting
     const norm = pattern.replace(/^\/+|\/+$/g, '');
@@ -22,6 +23,196 @@ function parsePatternToSegments(pattern) {
     }
     return { segments, params };
 }
+function parseSegmentToken(part) {
+    if (!part.startsWith(':')) {
+        return { type: 'static', value: part };
+    }
+    let name = part.slice(1);
+    let modifier = '';
+    const lastChar = name[name.length - 1];
+    if (lastChar === '?' || lastChar === '*' || lastChar === '+') {
+        modifier = lastChar;
+        name = name.slice(0, -1);
+    }
+    return { type: 'param', name, modifier };
+}
+function splitHostAndPortPattern(pattern) {
+    const normalized = pattern.trim().toLowerCase();
+    if (normalized.startsWith('[')) {
+        const end = normalized.indexOf(']');
+        if (end === -1)
+            return { hostPart: normalized };
+        const hostPart = normalized.slice(1, end);
+        const rest = normalized.slice(end + 1);
+        if (rest.startsWith(':')) {
+            return { hostPart, portPart: rest.slice(1) };
+        }
+        return { hostPart };
+    }
+    const colonCount = (normalized.match(/:/g) || []).length;
+    const lastColon = normalized.lastIndexOf(':');
+    const hasDots = normalized.includes('.');
+    if (lastColon === -1) {
+        return { hostPart: normalized };
+    }
+    const suffix = normalized.slice(lastColon + 1);
+    const prefix = normalized.slice(0, lastColon);
+    const isPortToken = /^\d+$/.test(suffix) || /^:[a-z_][a-z0-9_]*[?*+]?$/.test(`:${suffix}`);
+    if (!isPortToken) {
+        return { hostPart: normalized };
+    }
+    if (normalized.startsWith(':') && !hasDots) {
+        const paramBody = prefix.slice(1);
+        if (/^[a-z_][a-z0-9_]*$/.test(paramBody)) {
+            return { hostPart: prefix, portPart: suffix };
+        }
+    }
+    if (colonCount === 1 && !normalized.startsWith(':')) {
+        return { hostPart: prefix, portPart: suffix };
+    }
+    if (hasDots) {
+        return { hostPart: prefix, portPart: suffix };
+    }
+    return { hostPart: normalized };
+}
+function parseHostPattern(hostPattern) {
+    const { hostPart, portPart } = splitHostAndPortPattern(hostPattern);
+    const matchWholeHost = !hostPart.includes('.') || hostPart.includes(':');
+    const rawParts = matchWholeHost ? [hostPart] : hostPart.split('.');
+    return {
+        hostSegments: rawParts.map(parseSegmentToken),
+        portSegment: portPart ? parseSegmentToken(portPart) : undefined,
+        matchWholeHost,
+    };
+}
+function parseAuthority(host) {
+    const normalized = host.trim().toLowerCase();
+    if (normalized.startsWith('[')) {
+        const end = normalized.indexOf(']');
+        if (end !== -1) {
+            const hostname = normalized.slice(1, end);
+            const rest = normalized.slice(end + 1);
+            const port = rest.startsWith(':') ? rest.slice(1) : undefined;
+            return { hostname, port, kind: 'ipv6' };
+        }
+    }
+    if (isIP(normalized) === 6) {
+        return { hostname: normalized, kind: 'ipv6' };
+    }
+    const lastColon = normalized.lastIndexOf(':');
+    if (lastColon !== -1 && normalized.indexOf(':') === lastColon) {
+        const maybePort = normalized.slice(lastColon + 1);
+        if (/^\d+$/.test(maybePort)) {
+            const hostname = normalized.slice(0, lastColon);
+            if (isIP(hostname) === 4) {
+                return { hostname, port: maybePort, kind: 'ipv4' };
+            }
+            return { hostname, port: maybePort, kind: 'domain' };
+        }
+    }
+    if (isIP(normalized) === 4) {
+        return { hostname: normalized, kind: 'ipv4' };
+    }
+    return { hostname: normalized, kind: 'domain' };
+}
+function matchSingleSegment(seg, value, params) {
+    if (seg.type === 'static') {
+        return value === seg.value;
+    }
+    switch (seg.modifier) {
+        case '':
+        case '+':
+        case '*':
+            if (value == null || value === '') {
+                if (seg.modifier === '*') {
+                    params[seg.name] = undefined;
+                    return true;
+                }
+                return false;
+            }
+            params[seg.name] = value;
+            return true;
+        case '?':
+            params[seg.name] = value || undefined;
+            return true;
+        default:
+            return false;
+    }
+}
+function matchHostSegments(segments, parts, joiner, params) {
+    let hi = 0;
+    let hj = 0;
+    while (hi < segments.length) {
+        const seg = segments[hi];
+        const nextSegIsStatic = !!segments[hi + 1] && segments[hi + 1].type === 'static';
+        if (seg.type === 'static') {
+            if (hj >= parts.length || parts[hj] !== seg.value)
+                return false;
+            hi++;
+            hj++;
+            continue;
+        }
+        switch (seg.modifier) {
+            case '':
+                if (hj >= parts.length)
+                    return false;
+                params[seg.name] = parts[hj];
+                hi++;
+                hj++;
+                break;
+            case '?':
+                if (hj < parts.length) {
+                    if (nextSegIsStatic && parts[hj] === segments[hi + 1].value) {
+                        params[seg.name] = undefined;
+                        hi++;
+                    }
+                    else {
+                        params[seg.name] = parts[hj];
+                        hi++;
+                        hj++;
+                    }
+                }
+                else {
+                    params[seg.name] = undefined;
+                    hi++;
+                }
+                break;
+            case '+': {
+                if (hj >= parts.length)
+                    return false;
+                let end = parts.length;
+                if (nextSegIsStatic) {
+                    const nextStatic = segments[hi + 1].value;
+                    const found = parts.indexOf(nextStatic, hj);
+                    if (found === -1 || found === hj)
+                        return false;
+                    end = found;
+                }
+                params[seg.name] = parts.slice(hj, end).join(joiner);
+                hj = end;
+                hi++;
+                break;
+            }
+            case '*': {
+                let end = parts.length;
+                if (nextSegIsStatic) {
+                    const nextStatic = segments[hi + 1].value;
+                    const found = parts.indexOf(nextStatic, hj);
+                    if (found !== -1)
+                        end = found;
+                }
+                const value = parts.slice(hj, end).join(joiner);
+                params[seg.name] = value || undefined;
+                hj = end;
+                hi++;
+                break;
+            }
+            default:
+                return false;
+        }
+    }
+    return hj === parts.length;
+}
 /**
  * Route class using segment-based matching (no fragile capture-group-index mapping).
  * Behavior matches the SimpleRouter in the webpage:
@@ -39,6 +230,7 @@ export class Route {
     allowedMethods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD'];
     ws = null;
     context;
+    routehost = null;
     /**
      * 创建路由
      * @param path 路由路径
@@ -60,6 +252,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 +278,41 @@ 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 actual = parseAuthority(host);
+            let hostMatched = false;
+            for (const pattern of this.routehost) {
+                const parsedPattern = parseHostPattern(pattern);
+                const hostParts = parsedPattern.matchWholeHost || actual.kind === 'ipv6'
+                    ? [actual.hostname]
+                    : actual.hostname.split('.');
+                const joiner = parsedPattern.matchWholeHost || actual.kind === 'ipv6' ? ':' : '.';
+                let tempParams = {};
+                const hostOk = matchHostSegments(parsedPattern.hostSegments, hostParts, joiner, tempParams);
+                if (!hostOk)
+                    continue;
+                if (parsedPattern.portSegment) {
+                    const portOk = matchSingleSegment(parsedPattern.portSegment, actual.port, tempParams);
+                    if (!portOk)
+                        continue;
+                }
+                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 +436,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 +451,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));
         }
     }
     /**