@yumerijs/core 1.3.3 → 2.0.0

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;

package/dist/server.js

@@ -43,8 +43,6 @@ const http_1 = __importDefault(require("http"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const url_1 = require("url");
-const ws_1 = __importDefault(require("ws"));
-const formidable = __importStar(require("formidable"));
 const mime = __importStar(require("mime-types"));
 const logger = new logger_1.Logger('server');
 class Server {
@@ -53,19 +51,16 @@ class Server {
     host;
     enableCors;
     staticDir;
-    enableWs;
     httpServer = null;
-    wsServer = null;
     constructor(core, config = {}) {
         this.core = core;
         this.port = config.port ?? 14510;
         this.host = config.host ?? '0.0.0.0';
         this.enableCors = config.enableCors ?? true;
         this.staticDir = config.staticDir ?? 'static';
-        this.enableWs = config.enableWs ?? true;
     }
-    createSession(ip, cookies, res, req, extra = {}) {
-        const session = new session_1.Session(ip, cookies, this, req, res);
+    createSession(ip, cookies, res, req, pathname, extra = {}) {
+        const session = new session_1.Session(ip, cookies, this, req, res, pathname);
         Object.assign(session.properties, extra);
         session.protocol = extra.protocol ?? 'http';
         return session;
@@ -85,46 +80,6 @@ class Server {
         const xff = req.headers['x-forwarded-for'];
         return xff ? xff.split(',')[0].trim() : req.socket.remoteAddress || '127.0.0.1';
     }
-    async parseRequestBody(req) {
-        return new Promise((resolve, reject) => {
-            const contentType = (req.headers['content-type'] || '').toLowerCase();
-            if (contentType.includes('application/json') || contentType.includes('application/x-www-form-urlencoded')) {
-                let body = '';
-                req.on('data', chunk => body += chunk.toString());
-                req.on('end', () => {
-                    try {
-                        if (contentType.includes('application/json'))
-                            resolve(JSON.parse(body));
-                        else {
-                            const params = new URLSearchParams(body);
-                            const parsed = {};
-                            params.forEach((v, k) => parsed[k] = v);
-                            resolve(parsed);
-                        }
-                    }
-                    catch (e) {
-                        reject(e);
-                    }
-                });
-            }
-            else if (contentType.includes('multipart/form-data')) {
-                const form = formidable.formidable({});
-                form.parse(req, (err, fields) => {
-                    if (err)
-                        return reject(err);
-                    const parsed = {};
-                    Object.keys(fields).forEach(k => {
-                        const val = fields[k];
-                        parsed[k] = Array.isArray(val) && val.length === 1 ? val[0] : val;
-                    });
-                    resolve(parsed);
-                });
-            }
-            else
-                resolve({});
-            req.on('error', reject);
-        });
-    }
     serveStaticFile(pathname, res) {
         const fullPath = path.join(process.cwd(), this.staticDir, pathname);
         fs.readFile(fullPath, (err, data) => {
@@ -154,25 +109,9 @@ class Server {
             const queryParams = url.searchParams;
             const ip = this.getClientIP(req);
             const cookies = this.parseCookies(req);
-            const session = this.createSession(ip, cookies, res, req, { protocol: 'http', header: req.headers });
-            if (req.method?.toLowerCase() === 'post') {
-                try {
-                    const body = await this.parseRequestBody(req);
-                    Object.entries(body).forEach(([k, v]) => {
-                        if (typeof v === 'string')
-                            queryParams.set(k, v);
-                        else if (Array.isArray(v))
-                            v.forEach(val => queryParams.append(k, val));
-                    });
-                }
-                catch (err) {
-                    res.writeHead(400, { 'Content-Type': 'text/plain' });
-                    res.end('Invalid request body');
-                    logger.error('Request body parse error:', err);
-                    return;
-                }
-            }
+            const session = this.createSession(ip, cookies, res, req, pathname, { protocol: 'http', header: req.headers });
             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);
                 if (!matched) {
@@ -188,42 +127,59 @@ class Server {
                     res.end(session.body);
                 }
             }
+            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 {
+                    let head = session.head;
+                    head['Set-Cookie'] = Object.entries(session.newCookie).map(([k, v]) => `${k}=${v}`);
+                    if (this.enableCors) {
+                        head['Access-Control-Allow-Origin'] = '*';
+                    }
+                    res.writeHead(session.status ?? 200, head);
+                    res.end(session.body);
+                }
+            }
             else {
                 this.serveStaticFile(pathname, res);
             }
         });
-        if (this.enableWs) {
-            this.wsServer = new ws_1.default.Server({ server: this.httpServer });
-            this.wsServer.on('connection', (ws, req) => {
-                const url = new url_1.URL(req.url || '/', `http://${req.headers.host}`);
-                const pathname = url.pathname;
-                const queryParams = url.searchParams;
-                const ip = this.getClientIP(req);
-                const cookies = this.parseCookies(req);
-                const session = this.createSession(ip, cookies, undefined, req, { ws, protocol: 'ws' });
-                ws.on('message', async (msg) => {
-                    try {
-                        const data = JSON.parse(msg.toString());
-                        Object.entries(data).forEach(([k, v]) => queryParams.set(k, v));
-                    }
-                    catch {
-                        queryParams.set('message', msg.toString());
-                    }
-                    await this.core.executeRoute(pathname, session, queryParams);
-                });
-                this.core.executeRoute(pathname, session, queryParams).catch(err => {
-                    logger.error(`WS initial route error for ${pathname}:`, err);
-                    ws.close(1011, 'Internal error');
-                });
-            });
-        }
+        this.httpServer.on('upgrade', async (req, socket, head) => {
+            const url = new url_1.URL(req.url || '/', `http://${req.headers.host}`);
+            const pathname = url.pathname;
+            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);
+            if (route && route.ws != null) {
+                const matched = await this.core.executeRoute(pathname, session, queryParams);
+                if (!matched) {
+                    socket.write('HTTP/1.1 400 Bad Request\r\n' +
+                        'Content-Type: text/plain\r\n' +
+                        'Connection: close\r\n');
+                    socket.destroy();
+                }
+                else {
+                    route.ws.handleUpgrade(req, socket, head, (ws) => {
+                        route.ws.emit('connection', ws, req, session);
+                    });
+                }
+            }
+            else {
+                socket.write('HTTP/1.1 400 Bad Request\r\n' +
+                    'Content-Type: text/plain\r\n' +
+                    'Connection: close\r\n');
+                socket.destroy();
+            }
+        });
         this.httpServer.listen(this.port, this.host, () => {
             logger.info(`Server listening on ${this.host}:${this.port}`);
         });
     }
     stop() {
-        if (this.wsServer)
-            this.wsServer.close();
         if (this.httpServer)
             this.httpServer.close(() => logger.info('Server stopped'));
     }

package/dist/session.d.ts

@@ -5,6 +5,12 @@
  **/
 import { Server } from './server';
 import { IncomingMessage, ServerResponse } from 'http';
+type ParsedParams = Record<string, string | string[] | undefined>;
+export interface Client {
+    req: IncomingMessage;
+    res: ServerResponse;
+    headers?: Record<string, string>;
+}
 export declare class Session {
     ip: string;
     cookie: Record<string, string>;
@@ -16,12 +22,42 @@ export declare class Session {
     status: number;
     body: any;
     properties?: Record<string, any>;
-    res: any;
-    req: any;
+    client: Client;
     server: Server;
     protocol: string;
-    constructor(ip: string, cookie: Record<string, string>, server: Server, req?: IncomingMessage, res?: ServerResponse, query?: Record<string, string>);
+    pathname: string;
+    languages: string[];
+    /**
+     * @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>);
+    /**
+     * 解析 Accept-Language 字符串为排序后的语言数组
+     * @param header Accept-Language 头，比如 "zh-CN,zh-TW;q=0.8,en-US;q=0.6"
+     * @returns 按优先级排序的语言数组，自动补上父语言
+     */
+    parseAcceptLanguages(header: string): any[];
+    /**
+     * 生成 sessionid
+     * @param ip 用户IP
+     * @param option 选项
+     */
     private generateId;
+    /**
+     * 解析请求体
+     * @param client 客户端
+     * @returns Promise<ParsedParams>
+     */
+    parseRequestBody(client?: Client): Promise<ParsedParams>;
+    /**
+     * 获取请求体
+     * @param req 请求对象
+     * @returns Promise<string>
+     */
+    getReqBody(req: IncomingMessage): Promise<string>;
     private md5;
     setData(key: string, value: any): void;
     deleteData(key: string): void;
@@ -30,4 +66,10 @@ export declare class Session {
     setMime(mimeType: 'png' | 'jpg' | 'jpeg' | 'pdf' | 'plain' | 'html' | 'json' | 'xml' | string): void;
     send(data: any): any;
     endsession(message: any): any;
+    /**
+     * 获取I18n文本
+     * @param name 文本点名称
+     */
+    text(name: string): any;
 }
+export {};