@kevisual/router 0.0.26 → 0.0.27

package/dist/router-simple-lib.d.ts

@@ -0,0 +1,3 @@
+declare const parseXml: (req: any) => Promise<any>;
+
+export { parseXml };

package/dist/router-simple-lib.js

@@ -0,0 +1,35 @@
+import xml2js from 'xml2js';
+
+const parseXml = async (req) => {
+    return await new Promise((resolve) => {
+        // 读取请求数据
+        let data = '';
+        req.setEncoding('utf8');
+        // 监听data事件，接收数据片段
+        req.on('data', (chunk) => {
+            data += chunk;
+        });
+        // 当请求结束时处理数据
+        req.on('end', () => {
+            try {
+                // 使用xml2js解析XML
+                xml2js.parseString(data, function (err, result) {
+                    if (err) {
+                        console.error('XML解析错误:', err);
+                        resolve(null);
+                    }
+                    else {
+                        const jsonString = JSON.stringify(result);
+                        resolve(jsonString);
+                    }
+                });
+            }
+            catch (error) {
+                console.error('处理请求时出错:', error);
+                resolve(null);
+            }
+        });
+    });
+};
+
+export { parseXml };

package/dist/router-simple.js

@@ -8,7 +8,7 @@ function requireDist () {
 	if (hasRequiredDist) return dist;
 	hasRequiredDist = 1;
 	Object.defineProperty(dist, "__esModule", { value: true });
-	dist.TokenData = void 0;
+	dist.PathError = dist.TokenData = void 0;
 	dist.parse = parse;
 	dist.compile = compile;
 	dist.match = match;
@@ -18,7 +18,6 @@ function requireDist () {
 	const NOOP_VALUE = (value) => value;
 	const ID_START = /^[$_\p{ID_Start}]$/u;
 	const ID_CONTINUE = /^[$\u200c\u200d\p{ID_Continue}]$/u;
-	const DEBUG_URL = "https://git.new/pathToRegexpError";
 	const SIMPLE_TOKENS = {
 	    // Groups.
 	    "{": "{",
@@ -36,7 +35,7 @@ function requireDist () {
 	 * Escape text for stringify to path.
 	 */
 	function escapeText(str) {
-	    return str.replace(/[{}()\[\]+?!:*]/g, "\\$&");
+	    return str.replace(/[{}()\[\]+?!:*\\]/g, "\\$&");
 	}
 	/**
 	 * Escape a regular expression string.
@@ -45,161 +44,135 @@ function requireDist () {
 	    return str.replace(/[.+*?^${}()[\]|/\\]/g, "\\$&");
 	}
 	/**
-	 * Tokenize input string.
+	 * Tokenized path instance.
+	 */
+	class TokenData {
+	    constructor(tokens, originalPath) {
+	        this.tokens = tokens;
+	        this.originalPath = originalPath;
+	    }
+	}
+	dist.TokenData = TokenData;
+	/**
+	 * ParseError is thrown when there is an error processing the path.
 	 */
-	function* lexer(str) {
+	class PathError extends TypeError {
+	    constructor(message, originalPath) {
+	        let text = message;
+	        if (originalPath)
+	            text += `: ${originalPath}`;
+	        text += `; visit https://git.new/pathToRegexpError for info`;
+	        super(text);
+	        this.originalPath = originalPath;
+	    }
+	}
+	dist.PathError = PathError;
+	/**
+	 * Parse a string for the raw tokens.
+	 */
+	function parse(str, options = {}) {
+	    const { encodePath = NOOP_VALUE } = options;
 	    const chars = [...str];
-	    let i = 0;
+	    const tokens = [];
+	    let index = 0;
+	    let pos = 0;
 	    function name() {
 	        let value = "";
-	        if (ID_START.test(chars[++i])) {
-	            value += chars[i];
-	            while (ID_CONTINUE.test(chars[++i])) {
-	                value += chars[i];
-	            }
+	        if (ID_START.test(chars[index])) {
+	            do {
+	                value += chars[index++];
+	            } while (ID_CONTINUE.test(chars[index]));
 	        }
-	        else if (chars[i] === '"') {
-	            let pos = i;
-	            while (i < chars.length) {
-	                if (chars[++i] === '"') {
-	                    i++;
-	                    pos = 0;
+	        else if (chars[index] === '"') {
+	            let quoteStart = index;
+	            while (index++ < chars.length) {
+	                if (chars[index] === '"') {
+	                    index++;
+	                    quoteStart = 0;
 	                    break;
 	                }
-	                if (chars[i] === "\\") {
-	                    value += chars[++i];
-	                }
-	                else {
-	                    value += chars[i];
-	                }
+	                // Increment over escape characters.
+	                if (chars[index] === "\\")
+	                    index++;
+	                value += chars[index];
 	            }
-	            if (pos) {
-	                throw new TypeError(`Unterminated quote at ${pos}: ${DEBUG_URL}`);
+	            if (quoteStart) {
+	                throw new PathError(`Unterminated quote at index ${quoteStart}`, str);
 	            }
 	        }
 	        if (!value) {
-	            throw new TypeError(`Missing parameter name at ${i}: ${DEBUG_URL}`);
+	            throw new PathError(`Missing parameter name at index ${index}`, str);
 	        }
 	        return value;
 	    }
-	    while (i < chars.length) {
-	        const value = chars[i];
+	    while (index < chars.length) {
+	        const value = chars[index];
 	        const type = SIMPLE_TOKENS[value];
 	        if (type) {
-	            yield { type, index: i++, value };
+	            tokens.push({ type, index: index++, value });
 	        }
 	        else if (value === "\\") {
-	            yield { type: "ESCAPED", index: i++, value: chars[i++] };
+	            tokens.push({ type: "escape", index: index++, value: chars[index++] });
 	        }
 	        else if (value === ":") {
-	            const value = name();
-	            yield { type: "PARAM", index: i, value };
+	            tokens.push({ type: "param", index: index++, value: name() });
 	        }
 	        else if (value === "*") {
-	            const value = name();
-	            yield { type: "WILDCARD", index: i, value };
+	            tokens.push({ type: "wildcard", index: index++, value: name() });
 	        }
 	        else {
-	            yield { type: "CHAR", index: i, value: chars[i++] };
+	            tokens.push({ type: "char", index: index++, value });
 	        }
 	    }
-	    return { type: "END", index: i, value: "" };
-	}
-	class Iter {
-	    constructor(tokens) {
-	        this.tokens = tokens;
-	    }
-	    peek() {
-	        if (!this._peek) {
-	            const next = this.tokens.next();
-	            this._peek = next.value;
-	        }
-	        return this._peek;
-	    }
-	    tryConsume(type) {
-	        const token = this.peek();
-	        if (token.type !== type)
-	            return;
-	        this._peek = undefined; // Reset after consumed.
-	        return token.value;
-	    }
-	    consume(type) {
-	        const value = this.tryConsume(type);
-	        if (value !== undefined)
-	            return value;
-	        const { type: nextType, index } = this.peek();
-	        throw new TypeError(`Unexpected ${nextType} at ${index}, expected ${type}: ${DEBUG_URL}`);
-	    }
-	    text() {
-	        let result = "";
-	        let value;
-	        while ((value = this.tryConsume("CHAR") || this.tryConsume("ESCAPED"))) {
-	            result += value;
-	        }
-	        return result;
-	    }
-	}
-	/**
-	 * Tokenized path instance.
-	 */
-	class TokenData {
-	    constructor(tokens) {
-	        this.tokens = tokens;
-	    }
-	}
-	dist.TokenData = TokenData;
-	/**
-	 * Parse a string for the raw tokens.
-	 */
-	function parse(str, options = {}) {
-	    const { encodePath = NOOP_VALUE } = options;
-	    const it = new Iter(lexer(str));
-	    function consume(endType) {
-	        const tokens = [];
+	    tokens.push({ type: "end", index, value: "" });
+	    function consumeUntil(endType) {
+	        const output = [];
 	        while (true) {
-	            const path = it.text();
-	            if (path)
-	                tokens.push({ type: "text", value: encodePath(path) });
-	            const param = it.tryConsume("PARAM");
-	            if (param) {
-	                tokens.push({
-	                    type: "param",
-	                    name: param,
+	            const token = tokens[pos++];
+	            if (token.type === endType)
+	                break;
+	            if (token.type === "char" || token.type === "escape") {
+	                let path = token.value;
+	                let cur = tokens[pos];
+	                while (cur.type === "char" || cur.type === "escape") {
+	                    path += cur.value;
+	                    cur = tokens[++pos];
+	                }
+	                output.push({
+	                    type: "text",
+	                    value: encodePath(path),
 	                });
 	                continue;
 	            }
-	            const wildcard = it.tryConsume("WILDCARD");
-	            if (wildcard) {
-	                tokens.push({
-	                    type: "wildcard",
-	                    name: wildcard,
+	            if (token.type === "param" || token.type === "wildcard") {
+	                output.push({
+	                    type: token.type,
+	                    name: token.value,
 	                });
 	                continue;
 	            }
-	            const open = it.tryConsume("{");
-	            if (open) {
-	                tokens.push({
+	            if (token.type === "{") {
+	                output.push({
 	                    type: "group",
-	                    tokens: consume("}"),
+	                    tokens: consumeUntil("}"),
 	                });
 	                continue;
 	            }
-	            it.consume(endType);
-	            return tokens;
+	            throw new PathError(`Unexpected ${token.type} at index ${token.index}, expected ${endType}`, str);
 	        }
+	        return output;
 	    }
-	    const tokens = consume("END");
-	    return new TokenData(tokens);
+	    return new TokenData(consumeUntil("end"), str);
 	}
 	/**
 	 * Compile a string to a template function for the path.
 	 */
 	function compile(path, options = {}) {
 	    const { encode = encodeURIComponent, delimiter = DEFAULT_DELIMITER } = options;
-	    const data = path instanceof TokenData ? path : parse(path, options);
+	    const data = typeof path === "object" ? path : parse(path, options);
 	    const fn = tokensToFunction(data.tokens, delimiter, encode);
-	    return function path(data = {}) {
-	        const [path, ...missing] = fn(data);
+	    return function path(params = {}) {
+	        const [path, ...missing] = fn(params);
 	        if (missing.length) {
 	            throw new TypeError(`Missing parameters: ${missing.join(", ")}`);
 	        }
@@ -296,14 +269,12 @@ function requireDist () {
 	function pathToRegexp(path, options = {}) {
 	    const { delimiter = DEFAULT_DELIMITER, end = true, sensitive = false, trailing = true, } = options;
 	    const keys = [];
-	    const sources = [];
 	    const flags = sensitive ? "" : "i";
-	    const paths = Array.isArray(path) ? path : [path];
-	    const items = paths.map((path) => path instanceof TokenData ? path : parse(path, options));
-	    for (const { tokens } of items) {
-	        for (const seq of flatten(tokens, 0, [])) {
-	            const regexp = sequenceToRegExp(seq, delimiter, keys);
-	            sources.push(regexp);
+	    const sources = [];
+	    for (const input of pathsToArray(path, [])) {
+	        const data = typeof input === "object" ? input : parse(input, options);
+	        for (const tokens of flatten(data.tokens, 0, [])) {
+	            sources.push(toRegExpSource(tokens, delimiter, keys, data.originalPath));
 	        }
 	    }
 	    let pattern = `^(?:${sources.join("|")})`;
@@ -313,6 +284,19 @@ function requireDist () {
 	    const regexp = new RegExp(pattern, flags);
 	    return { regexp, keys };
 	}
+	/**
+	 * Convert a path or array of paths into a flat array.
+	 */
+	function pathsToArray(paths, init) {
+	    if (Array.isArray(paths)) {
+	        for (const p of paths)
+	            pathsToArray(p, init);
+	    }
+	    else {
+	        init.push(paths);
+	    }
+	    return init;
+	}
 	/**
 	 * Generate a flat list of sequence tokens from the given tokens.
 	 */
@@ -322,8 +306,7 @@ function requireDist () {
 	    }
 	    const token = tokens[index];
 	    if (token.type === "group") {
-	        const fork = init.slice();
-	        for (const seq of flatten(token.tokens, 0, fork)) {
+	        for (const seq of flatten(token.tokens, 0, init.slice())) {
 	            yield* flatten(tokens, index + 1, seq);
 	        }
 	    }
@@ -335,12 +318,11 @@ function requireDist () {
 	/**
 	 * Transform a flat sequence of tokens into a regular expression.
 	 */
-	function sequenceToRegExp(tokens, delimiter, keys) {
+	function toRegExpSource(tokens, delimiter, keys, originalPath) {
 	    let result = "";
 	    let backtrack = "";
 	    let isSafeSegmentParam = true;
-	    for (let i = 0; i < tokens.length; i++) {
-	        const token = tokens[i];
+	    for (const token of tokens) {
 	        if (token.type === "text") {
 	            result += escape(token.value);
 	            backtrack += token.value;
@@ -349,7 +331,7 @@ function requireDist () {
 	        }
 	        if (token.type === "param" || token.type === "wildcard") {
 	            if (!isSafeSegmentParam && !backtrack) {
-	                throw new TypeError(`Missing text after "${token.name}": ${DEBUG_URL}`);
+	                throw new PathError(`Missing text before "${token.name}" ${token.type}`, originalPath);
 	            }
 	            if (token.type === "param") {
 	                result += `(${negate(delimiter, isSafeSegmentParam ? "" : backtrack)}+)`;
@@ -365,6 +347,9 @@ function requireDist () {
 	    }
 	    return result;
 	}
+	/**
+	 * Block backtracking on previous text and ignore delimiter string.
+	 */
 	function negate(delimiter, backtrack) {
 	    if (backtrack.length < 2) {
 	        if (delimiter.length < 2)
@@ -377,36 +362,57 @@ function requireDist () {
 	    return `(?:(?!${escape(backtrack)}|${escape(delimiter)})[\\s\\S])`;
 	}
 	/**
-	 * Stringify token data into a path string.
+	 * Stringify an array of tokens into a path string.
 	 */
-	function stringify(data) {
-	    return data.tokens
-	        .map(function stringifyToken(token, index, tokens) {
-	        if (token.type === "text")
-	            return escapeText(token.value);
+	function stringifyTokens(tokens) {
+	    let value = "";
+	    let i = 0;
+	    function name(value) {
+	        const isSafe = isNameSafe(value) && isNextNameSafe(tokens[i]);
+	        return isSafe ? value : JSON.stringify(value);
+	    }
+	    while (i < tokens.length) {
+	        const token = tokens[i++];
+	        if (token.type === "text") {
+	            value += escapeText(token.value);
+	            continue;
+	        }
 	        if (token.type === "group") {
-	            return `{${token.tokens.map(stringifyToken).join("")}}`;
+	            value += `{${stringifyTokens(token.tokens)}}`;
+	            continue;
 	        }
-	        const isSafe = isNameSafe(token.name) && isNextNameSafe(tokens[index + 1]);
-	        const key = isSafe ? token.name : JSON.stringify(token.name);
-	        if (token.type === "param")
-	            return `:${key}`;
-	        if (token.type === "wildcard")
-	            return `*${key}`;
-	        throw new TypeError(`Unexpected token: ${token}`);
-	    })
-	        .join("");
+	        if (token.type === "param") {
+	            value += `:${name(token.name)}`;
+	            continue;
+	        }
+	        if (token.type === "wildcard") {
+	            value += `*${name(token.name)}`;
+	            continue;
+	        }
+	        throw new TypeError(`Unknown token type: ${token.type}`);
+	    }
+	    return value;
 	}
+	/**
+	 * Stringify token data into a path string.
+	 */
+	function stringify(data) {
+	    return stringifyTokens(data.tokens);
+	}
+	/**
+	 * Validate the parameter name contains valid ID characters.
+	 */
 	function isNameSafe(name) {
 	    const [first, ...rest] = name;
-	    if (!ID_START.test(first))
-	        return false;
-	    return rest.every((char) => ID_CONTINUE.test(char));
+	    return ID_START.test(first) && rest.every((char) => ID_CONTINUE.test(char));
 	}
+	/**
+	 * Validate the next token does not interfere with the current param name.
+	 */
 	function isNextNameSafe(token) {
-	    if ((token === null || token === void 0 ? void 0 : token.type) !== "text")
-	        return true;
-	    return !ID_CONTINUE.test(token.value[0]);
+	    if (token && token.type === "text")
+	        return !ID_CONTINUE.test(token.value[0]);
+	    return true;
 	}
 	
 	return dist;

package/dist/router.d.ts

@@ -1,10 +1,11 @@
-import { z } from 'zod';
+import { Schema } from 'zod';
 export { Schema } from 'zod';
 import http, { IncomingMessage, ServerResponse } from 'node:http';
 import https from 'node:https';
 import http2 from 'node:http2';
 import * as cookie from 'cookie';
 import { WebSocketServer, WebSocket } from 'ws';
+import { IncomingMessage as IncomingMessage$1, ServerResponse as ServerResponse$1 } from 'http';
 import { RouteOpts as RouteOpts$1, QueryRouterServer as QueryRouterServer$1, RouteMiddleware as RouteMiddleware$1, Run as Run$1 } from '@kevisual/router';
 import { Query, DataOpts, Result } from '@kevisual/query/query';
 
@@ -41,7 +42,7 @@ type RuleAny = {
     type: 'any';
 } & BaseRule;
 type Rule = RuleString | RuleNumber | RuleBoolean | RuleArray | RuleObject | RuleAny;
-declare const createSchema: (rule: Rule) => z.ZodType<any, any, any>;
+declare const createSchema: (rule: Rule) => Schema;
 
 type RouterContextT = {
     code?: number;
@@ -143,7 +144,7 @@ type RouteOpts = {
         [key: string]: Rule;
     };
     schema?: {
-        [key: string]: any;
+        [key: string]: Schema<any>;
     };
     isVerify?: boolean;
     verify?: (ctx?: RouteContext, dev?: boolean) => boolean;
@@ -184,7 +185,7 @@ declare class Route<U = {
     type?: string;
     private _validator?;
     schema?: {
-        [key: string]: any;
+        [key: string]: Schema<any>;
     };
     data?: any;
     /**
@@ -406,6 +407,36 @@ declare class QueryRouterServer extends QueryRouter {
     }): Promise<any>;
 }
 
+declare class Connect {
+    path: string;
+    key?: string;
+    _fn?: (ctx?: RouteContext) => Promise<RouteContext>;
+    description?: string;
+    connects: {
+        path: string;
+        key?: string;
+    }[];
+    share: boolean;
+    constructor(path: string);
+    use(path: string): void;
+    useList(paths: string[]): void;
+    useConnect(connect: Connect): void;
+    useConnectList(connects: Connect[]): void;
+    getPathList(): string[];
+    set fn(fn: (ctx?: RouteContext) => Promise<RouteContext>);
+    get fn(): (ctx?: RouteContext) => Promise<RouteContext>;
+}
+declare class QueryConnect {
+    connects: Connect[];
+    constructor();
+    add(connect: Connect): void;
+    remove(connect: Connect): void;
+    getList(): {
+        path: string;
+        key: string;
+    }[];
+}
+
 type Listener = (...args: any[]) => void;
 type CookieFn = (name: string, value: string, options?: cookie.SerializeOptions, end?: boolean) => void;
 type HandleCtx = {
@@ -689,12 +720,12 @@ declare class App<T = {}, U = AppReqRes> {
     importRoutes(routes: any[]): void;
     importApp(app: App): void;
     throw(code?: number | string, message?: string, tips?: string): void;
-    static handleRequest(req: IncomingMessage, res: ServerResponse): Promise<{
+    static handleRequest(req: IncomingMessage$1, res: ServerResponse$1): Promise<{
         cookies: Record<string, string>;
         token: string;
     }>;
-    onServerRequest(fn: (req: IncomingMessage, res: ServerResponse) => void): void;
+    onServerRequest(fn: (req: IncomingMessage$1, res: ServerResponse$1) => void): void;
 }
 
-export { App, CustomError, QueryRouter, QueryRouterServer, QueryUtil, Route, Server, createSchema, define, handleServer, util };
+export { App, Connect, CustomError, QueryConnect, QueryRouter, QueryRouterServer, QueryUtil, Route, Server, createSchema, define, handleServer, util };
 export type { RouteArray, RouteContext, RouteMiddleware, RouteObject, RouteOpts, Rule, Run };