@yumerijs/core 1.3.3 → 2.0.1

package/dist/i18n.js

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * @time: 2025/10/28 22:13
+ * @author: FireGuo
+ * WindyPear-Team All right reserved
+ **/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.I18n = void 0;
+class I18n {
+    data = {};
+    fallback;
+    constructor(fallback = ['en']) {
+        this.fallback = fallback;
+    }
+    register(key, lang) {
+        if (typeof key === 'string' && lang) {
+            if (!this.data[key])
+                this.data[key] = {};
+            Object.assign(this.data[key], lang);
+        }
+        else if (typeof key === 'object') {
+            this.flattenAndRegister(key);
+        }
+    }
+    setFallback(fallback) {
+        this.fallback = fallback;
+    }
+    flattenAndRegister(obj, prefix = '') {
+        for (const [k, v] of Object.entries(obj)) {
+            const fullKey = prefix ? `${prefix}.${k}` : k;
+            if (typeof v === 'object' && !('zh' in v || 'en' in v)) {
+                this.flattenAndRegister(v, fullKey);
+            }
+            else if (typeof v === 'object') {
+                if (!this.data[fullKey])
+                    this.data[fullKey] = {};
+                Object.assign(this.data[fullKey], v);
+            }
+        }
+    }
+    isRegistered(key) {
+        return !!this.data[key];
+    }
+    delete(key) {
+        delete this.data[key];
+    }
+    /**
+     * 获取指定key的翻译
+     * @param key 文本点
+     * @param langs 用户的语言优先级数组
+     */
+    get(key, langs) {
+        const entry = this.data[key];
+        if (!entry)
+            return key;
+        if (langs && langs.length) {
+            for (const l of langs) {
+                if (entry[l])
+                    return entry[l];
+            }
+        }
+        for (const fb of this.fallback) {
+            if (entry[fb])
+                return entry[fb];
+        }
+        return key;
+    }
+    /**
+     * 替换模板字符串中的文本点
+     * e.g. "Hello {{app.title}}" -> "Hello 世界"
+     */
+    replaceAll(input, langs) {
+        return input.replace(/\{\{(.*?)\}\}/g, (_, key) => this.get(key.trim(), langs));
+    }
+    all() {
+        return this.data;
+    }
+}
+exports.I18n = I18n;

package/dist/index.d.ts

@@ -11,3 +11,4 @@ export * from './logger';
 export * from './context';
 export * from './hook';
 export * from './middleware';
+export * from './i18n';

package/dist/index.js

@@ -27,3 +27,4 @@ __exportStar(require("./logger"), exports);
 __exportStar(require("./context"), exports);
 __exportStar(require("./hook"), exports);
 __exportStar(require("./middleware"), exports);
+__exportStar(require("./i18n"), exports);

package/dist/logger.d.ts

@@ -8,10 +8,14 @@ export declare class Logger {
     private title;
     private titleColor;
     static coreInstance: Core | null;
-    static logs: string[];
+    static logs: {
+        level: string;
+        message: string;
+        timestamp: string;
+    }[];
     static setCore(core: Core): void;
     constructor(title: string);
-    private getRandomColor;
+    private getColorByName;
     private getTimestamp;
     private log;
     info(...args: any[]): void;

package/dist/logger.js

@@ -17,22 +17,28 @@ class Logger {
     static logs = [];
     static setCore(core) {
         if (Logger.coreInstance !== null) {
-            const logger = new Logger('Logger');
-            logger.warn("Logger.coreInstance is already set. Overwriting would cause confusion.");
+            return;
         }
         Logger.coreInstance = core;
     }
     constructor(title) {
         this.title = title;
-        this.titleColor = this.getRandomColor();
+        this.titleColor = this.getColorByName(this.title);
     }
-    getRandomColor() {
+    getColorByName(name) {
         const availableColors = [
             picocolors_1.default.red, picocolors_1.default.green, picocolors_1.default.yellow, picocolors_1.default.blue,
-            picocolors_1.default.magenta, picocolors_1.default.cyan, picocolors_1.default.white, picocolors_1.default.gray
+            picocolors_1.default.magenta, picocolors_1.default.cyan, picocolors_1.default.white,
+            picocolors_1.default.redBright, picocolors_1.default.greenBright, picocolors_1.default.yellowBright,
+            picocolors_1.default.blueBright, picocolors_1.default.magentaBright, picocolors_1.default.cyanBright
         ];
-        const randomIndex = Math.floor(Math.random() * availableColors.length);
-        return availableColors[randomIndex];
+        // Simple hash function to ensure consistent color for the same title
+        let hash = 0;
+        for (let i = 0; i < name.length; i++) {
+            hash = name.charCodeAt(i) + ((hash << 5) - hash);
+        }
+        const index = Math.abs(hash % availableColors.length);
+        return availableColors[index];
     }
     getTimestamp() {
         const now = new Date();
@@ -43,7 +49,8 @@ class Logger {
         const levelColor = level === 'E' ? picocolors_1.default.red : level === 'W' ? picocolors_1.default.yellow : picocolors_1.default.cyan;
         const timestamp = this.getTimestamp();
         console.log(`${picocolors_1.default.gray(timestamp)} [${levelColor(level)}] ${this.titleColor(this.title)}`, ...args);
-        Logger.coreInstance?.emit('log', { level, message: args.join(' ') });
+        Logger.coreInstance?.emit('log', { level, message: args.join(' '), timestamp });
+        Logger.logs.push({ level, message: args.join(' '), timestamp });
     }
     info(...args) { this.log('I', ...args); }
     warn(...args) { this.log('W', ...args); }

package/dist/route.d.ts

@@ -5,6 +5,7 @@
  **/
 import { Session } from './session';
 import { Middleware } from './middleware';
+import { WebSocketServer } from 'ws';
 export type RouteHandler = (session: Session, queryParams: URLSearchParams, ...pathParams: string[]) => Promise<void> | void;
 /**
  * Route class using segment-based matching (no fragile capture-group-index mapping).
@@ -21,6 +22,7 @@ export declare class Route {
     private handler;
     middlewares: Middleware[];
     allowedMethods: string[];
+    ws: WebSocketServer;
     /**
      * 创建路由
      * @param path 路由路径
@@ -60,4 +62,9 @@ export declare class Route {
      * @returns this
      */
     methods(...methods: string[]): Route;
+    /**
+      * 注册Ws处理器
+      * @param handler 处理器
+      */
+    wsOn(event: string, handler: (...args: any[]) => void): this;
 }

package/dist/route.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Route = void 0;
+const ws_1 = require("ws");
 function parsePatternToSegments(pattern) {
     // Normalize: remove leading/trailing slashes for consistent splitting
     const norm = pattern.replace(/^\/+|\/+$/g, '');
@@ -39,6 +40,7 @@ class Route {
     handler = null;
     middlewares = [];
     allowedMethods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD'];
+    ws = null;
     /**
      * 创建路由
      * @param path 路由路径
@@ -73,129 +75,135 @@ class Route {
      * @returns 匹配结果
      */
     match(pathname) {
-        // normalize pathname: remove leading/trailing slashes
-        const normPath = pathname.replace(/^\/+|\/+$/g, '');
-        const parts = normPath === '' ? [] : normPath.split('/');
-        const params = {};
-        const pathParams = [];
-        let i = 0; // index into segments (pattern)
-        let j = 0; // index into parts (path)
-        while (i < this.segments.length) {
-            const seg = this.segments[i];
-            // static must match exactly
-            if (seg.type === 'static') {
-                if (j >= parts.length)
-                    return null;
-                if (parts[j] !== seg.value)
-                    return null;
-                i++;
-                j++;
-                continue;
-            }
-            // seg.type === 'param'
-            const nextSegIsStatic = (() => {
-                const next = this.segments[i + 1];
-                return !!next && next.type === 'static';
-            })();
-            switch (seg.modifier) {
-                case '': { // required single segment
+        if (pathname.startsWith('/')) {
+            // normalize pathname: remove leading/trailing slashes
+            const normPath = pathname.replace(/^\/+|\/+$/g, '');
+            const parts = normPath === '' ? [] : normPath.split('/');
+            const params = {};
+            const pathParams = [];
+            let i = 0; // index into segments (pattern)
+            let j = 0; // index into parts (path)
+            while (i < this.segments.length) {
+                const seg = this.segments[i];
+                // static must match exactly
+                if (seg.type === 'static') {
                     if (j >= parts.length)
                         return null;
-                    params[seg.name] = parts[j];
-                    pathParams.push(parts[j]);
+                    if (parts[j] !== seg.value)
+                        return null;
                     i++;
                     j++;
-                    break;
+                    continue;
                 }
-                case '?': { // optional single segment
-                    // If next segment is static, we should not consume the part when it equals that static
-                    if (j < parts.length) {
-                        if (nextSegIsStatic) {
-                            // peek: if current part equals next static, then this optional param is absent
-                            const nextStatic = this.segments[i + 1].value;
-                            if (parts[j] === nextStatic) {
-                                params[seg.name] = undefined;
-                                pathParams.push('');
-                                i++;
-                                break;
-                            }
-                        }
-                        // otherwise consume one segment as the optional param
+                // seg.type === 'param'
+                const nextSegIsStatic = (() => {
+                    const next = this.segments[i + 1];
+                    return !!next && next.type === 'static';
+                })();
+                switch (seg.modifier) {
+                    case '': { // required single segment
+                        if (j >= parts.length)
+                            return null;
                         params[seg.name] = parts[j];
                         pathParams.push(parts[j]);
+                        i++;
                         j++;
+                        break;
                     }
-                    else {
-                        params[seg.name] = undefined;
-                        pathParams.push('');
-                    }
-                    i++;
-                    break;
-                }
-                case '+': { // required multi (one or more segments)
-                    if (j >= parts.length)
-                        return null; // must have at least one
-                    // find boundary where next static occurs (if any)
-                    let end = parts.length;
-                    if (nextSegIsStatic) {
-                        const nextStatic = this.segments[i + 1].value;
-                        let found = -1;
-                        for (let k = j; k < parts.length; k++) {
-                            if (parts[k] === nextStatic) {
-                                found = k;
-                                break;
+                    case '?': { // optional single segment
+                        // If next segment is static, we should not consume the part when it equals that static
+                        if (j < parts.length) {
+                            if (nextSegIsStatic) {
+                                // peek: if current part equals next static, then this optional param is absent
+                                const nextStatic = this.segments[i + 1].value;
+                                if (parts[j] === nextStatic) {
+                                    params[seg.name] = undefined;
+                                    pathParams.push('');
+                                    i++;
+                                    break;
+                                }
                             }
+                            // otherwise consume one segment as the optional param
+                            params[seg.name] = parts[j];
+                            pathParams.push(parts[j]);
+                            j++;
+                        }
+                        else {
+                            params[seg.name] = undefined;
+                            pathParams.push('');
                         }
-                        if (found === -1)
-                            return null; // next static not found -> cannot satisfy pattern
-                        end = found;
-                        if (end === j)
-                            return null; // need at least one segment
+                        i++;
+                        break;
                     }
-                    // consume parts[j..end-1]
-                    const value = parts.slice(j, end).join('/');
-                    params[seg.name] = value;
-                    pathParams.push(value);
-                    j = end;
-                    i++;
-                    break;
-                }
-                case '*': { // optional multi (zero or more)
-                    // If next static exists, consume until that static; else consume all remainder (may be zero)
-                    let end = parts.length;
-                    if (nextSegIsStatic) {
-                        const nextStatic = this.segments[i + 1].value;
-                        let found = -1;
-                        for (let k = j; k < parts.length; k++) {
-                            if (parts[k] === nextStatic) {
-                                found = k;
-                                break;
+                    case '+': { // required multi (one or more segments)
+                        if (j >= parts.length)
+                            return null; // must have at least one
+                        // find boundary where next static occurs (if any)
+                        let end = parts.length;
+                        if (nextSegIsStatic) {
+                            const nextStatic = this.segments[i + 1].value;
+                            let found = -1;
+                            for (let k = j; k < parts.length; k++) {
+                                if (parts[k] === nextStatic) {
+                                    found = k;
+                                    break;
+                                }
                             }
-                        }
-                        if (found === -1) {
-                            // next static not found => we cannot match the remainder to the next pattern,
-                            // but '*' can consume all remainder (and then next static will fail later)
-                            end = parts.length;
-                        }
-                        else {
+                            if (found === -1)
+                                return null; // next static not found -> cannot satisfy pattern
                             end = found;
+                            if (end === j)
+                                return null; // need at least one segment
                         }
+                        // consume parts[j..end-1]
+                        const value = parts.slice(j, end).join('/');
+                        params[seg.name] = value;
+                        pathParams.push(value);
+                        j = end;
+                        i++;
+                        break;
                     }
-                    const value = parts.slice(j, end).join('/');
-                    params[seg.name] = value === '' ? undefined : value;
-                    pathParams.push(value === '' ? '' : value);
-                    j = end;
-                    i++;
-                    break;
+                    case '*': { // optional multi (zero or more)
+                        // If next static exists, consume until that static; else consume all remainder (may be zero)
+                        let end = parts.length;
+                        if (nextSegIsStatic) {
+                            const nextStatic = this.segments[i + 1].value;
+                            let found = -1;
+                            for (let k = j; k < parts.length; k++) {
+                                if (parts[k] === nextStatic) {
+                                    found = k;
+                                    break;
+                                }
+                            }
+                            if (found === -1) {
+                                // next static not found => we cannot match the remainder to the next pattern,
+                                // but '*' can consume all remainder (and then next static will fail later)
+                                end = parts.length;
+                            }
+                            else {
+                                end = found;
+                            }
+                        }
+                        const value = parts.slice(j, end).join('/');
+                        params[seg.name] = value === '' ? undefined : value;
+                        pathParams.push(value === '' ? '' : value);
+                        j = end;
+                        i++;
+                        break;
+                    }
+                    default:
+                        return null;
                 }
-                default:
-                    return null;
             }
+            // after finishing pattern, path must be fully consumed (no extra segments)
+            if (j !== parts.length)
+                return null;
+            return { params, pathParams };
         }
-        // after finishing pattern, path must be fully consumed (no extra segments)
-        if (j !== parts.length)
-            return null;
-        return { params, pathParams };
+        else if (pathname.startsWith('root') && this.path == pathname) {
+            return { params: { pathname }, pathParams: [pathname] };
+        }
+        return null;
     }
     /**
      * 执行路由处理器
@@ -217,5 +225,15 @@ class Route {
         this.allowedMethods = methods;
         return this;
     }
+    /**
+      * 注册Ws处理器
+      * @param handler 处理器
+      */
+    wsOn(event, handler) {
+        if (!this.ws)
+            this.ws = new ws_1.WebSocketServer({ noServer: true });
+        this.ws.on(event, handler);
+        return this;
+    }
 }
 exports.Route = Route;

package/dist/server.d.ts

@@ -7,19 +7,16 @@ export interface ServerConfig {
     enableWs: boolean;
 }
 export declare class Server {
-    private core;
+    core: Core;
     private port;
     private host;
     private enableCors;
     private staticDir;
-    private enableWs;
     private httpServer;
-    private wsServer;
     constructor(core: Core, config?: Partial<ServerConfig>);
     private createSession;
     private parseCookies;
     private getClientIP;
-    private parseRequestBody;
     private serveStaticFile;
     start(): Promise<void>;
     stop(): void;