@yumerijs/core 3.0.0-alpha.1 → 3.0.0-alpha.2

package/dist/context.d.ts

@@ -1,14 +1,8 @@
-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;
 }
@@ -123,4 +117,3 @@ export declare class Context {
      */
     dispose(): Promise<void>;
 }
-export {};

package/dist/core.d.ts

@@ -9,12 +9,25 @@ 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;
@@ -50,7 +63,7 @@ export declare class Core {
     getRendererForPlugin(pluginName: string): string | undefined;
     runCore(): Promise<void>;
     getShortPluginName(pluginName: string): string;
-    plugin(module: 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

@@ -6,6 +6,48 @@ 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'),
@@ -82,10 +124,11 @@ export class Core {
         return pluginName;
     }
     async plugin(module, context, config) {
+        const plugin = resolvePluginModule(module, context, config);
         const shortName = this.getShortPluginName(context.pluginname);
-        context.module = module;
+        context.module = plugin;
         // 自动依赖注入
-        const depend = module.depend || [];
+        const depend = plugin.depend || [];
         for (const name of depend) {
             const component = this.getComponent(name);
             if (component) {
@@ -93,8 +136,8 @@ export class Core {
             }
         }
         this.logger.info(`apply plugin ${shortName}`);
-        if (module.apply) {
-            await module.apply(context, config);
+        if (plugin.apply) {
+            await plugin.apply(context, config);
         }
     }
     registerComponent(name, component) {

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,22 +23,195 @@ 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 : '',
-            };
-        }
+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).
@@ -113,102 +287,26 @@ export class Route {
         if (this.routehost && this.routehost.length > 0) {
             if (!host)
                 return null; // 如果设置了 host 限制但没有传入 host，直接失败
-            const actualHost = host.toLowerCase().split(':')[0]; // 移除端口并转小写
-            const hostParts = actualHost.split('.');
+            const actual = parseAuthority(host);
             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
+                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 = {};
-                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 就行
+                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;

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@yumerijs/core",
-  "version": "3.0.0-alpha.1",
+  "version": "3.0.0-alpha.2",
   "description": "Core module for yumeri",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "type": "module",
   "files": [
     "dist"
   ],