vafast 0.3.2 → 0.3.4

package/dist/router/radix-tree.js

@@ -1,222 +1,190 @@
-/**
- * Radix Tree 路由匹配器
- *
- * 高性能路由匹配实现，时间复杂度 O(k)，k 为路径段数
- *
- * 支持的路由模式:
- * - 静态路径: /users, /api/v1/health
- * - 动态参数: /users/:id, /posts/:postId/comments/:commentId
- * - 通配符: /files/*, /static/*filepath
- */
-/**
- * Radix Tree 路由器
- *
- * @example
- * ```typescript
- * const router = new RadixRouter();
- * router.register("GET", "/users/:id", handler);
- * const result = router.match("GET", "/users/123");
- * // result.params = { id: "123" }
- * ```
- */
-export class RadixRouter {
-    root;
-    constructor() {
-        this.root = this.createNode("");
-    }
-    createNode(path) {
-        return {
-            path,
-            children: Object.create(null),
-            handlers: Object.create(null),
-        };
-    }
-    /** 分割路径 */
-    splitPath(path) {
-        return path.split("/").filter(Boolean);
-    }
-    /** 编译器函数 - 用于预编译中间件链 */
-    compiler;
-    /** 设置中间件编译器 */
-    setCompiler(compiler) {
-        this.compiler = compiler;
-    }
-    /** 注册路由 */
-    register(method, pattern, handler, middleware = []) {
-        const segments = this.splitPath(pattern);
-        let node = this.root;
-        for (const segment of segments) {
-            const firstChar = segment[0];
-            if (firstChar === ":") {
-                // 动态参数节点
-                if (!node.paramChild) {
-                    node.paramChild = this.createNode(segment);
-                    node.paramChild.paramName = segment.substring(1);
-                }
-                node = node.paramChild;
-            }
-            else if (firstChar === "*") {
-                // 通配符节点
-                if (!node.wildcardChild) {
-                    node.wildcardChild = this.createNode(segment);
-                    node.wildcardChild.paramName =
-                        segment.length > 1 ? segment.substring(1) : "*";
-                }
-                node = node.wildcardChild;
-                break;
-            }
-            else {
-                // 静态路径节点
-                if (!node.children[segment]) {
-                    node.children[segment] = this.createNode(segment);
-                }
-                node = node.children[segment];
-            }
-        }
-        const routeHandler = { handler, middleware };
-        // 如果没有全局中间件且设置了编译器，预编译处理链
-        if (this.compiler && middleware.length === 0) {
-            routeHandler.compiled = this.compiler([], handler);
-        }
-        node.handlers[method] = routeHandler;
-    }
-    /** 预编译所有路由（在添加全局中间件后调用） */
-    precompileAll(globalMiddleware) {
-        if (!this.compiler)
-            return;
-        this.precompileNode(this.root, globalMiddleware);
-    }
-    precompileNode(node, globalMiddleware) {
-        for (const method in node.handlers) {
-            const routeHandler = node.handlers[method];
-            if (routeHandler) {
-                const allMiddleware = [...globalMiddleware, ...routeHandler.middleware];
-                routeHandler.compiled = this.compiler(allMiddleware, routeHandler.handler);
-            }
-        }
-        for (const key in node.children) {
-            this.precompileNode(node.children[key], globalMiddleware);
-        }
-        if (node.paramChild) {
-            this.precompileNode(node.paramChild, globalMiddleware);
-        }
-        if (node.wildcardChild) {
-            this.precompileNode(node.wildcardChild, globalMiddleware);
-        }
+// src/router/radix-tree.ts
+var RadixRouter = class {
+  root;
+  constructor() {
+    this.root = this.createNode("");
+  }
+  createNode(path) {
+    return {
+      path,
+      children: /* @__PURE__ */ Object.create(null),
+      handlers: /* @__PURE__ */ Object.create(null)
+    };
+  }
+  /** 分割路径 */
+  splitPath(path) {
+    return path.split("/").filter(Boolean);
+  }
+  /** 编译器函数 - 用于预编译中间件链 */
+  compiler;
+  /** 设置中间件编译器 */
+  setCompiler(compiler) {
+    this.compiler = compiler;
+  }
+  /** 注册路由 */
+  register(method, pattern, handler, middleware = []) {
+    const segments = this.splitPath(pattern);
+    let node = this.root;
+    for (const segment of segments) {
+      const firstChar = segment[0];
+      if (firstChar === ":") {
+        if (!node.paramChild) {
+          node.paramChild = this.createNode(segment);
+          node.paramChild.paramName = segment.substring(1);
+        }
+        node = node.paramChild;
+      } else if (firstChar === "*") {
+        if (!node.wildcardChild) {
+          node.wildcardChild = this.createNode(segment);
+          node.wildcardChild.paramName = segment.length > 1 ? segment.substring(1) : "*";
+        }
+        node = node.wildcardChild;
+        break;
+      } else {
+        if (!node.children[segment]) {
+          node.children[segment] = this.createNode(segment);
+        }
+        node = node.children[segment];
+      }
     }
-    /** 匹配路由 */
-    match(method, path) {
-        const segments = this.splitPath(path);
-        const params = Object.create(null);
-        const node = this.matchNode(this.root, segments, 0, params);
-        if (!node)
-            return null;
-        const routeHandler = node.handlers[method];
-        if (!routeHandler)
-            return null;
-        return {
-            handler: routeHandler.handler,
-            middleware: routeHandler.middleware,
-            params,
-            compiled: routeHandler.compiled,
-        };
-    }
-    /** 递归匹配节点 (优先级: 静态 > 动态参数 > 通配符) */
-    matchNode(node, segments, index, params) {
-        if (index === segments.length) {
-            for (const method in node.handlers) {
-                if (node.handlers[method])
-                    return node;
-            }
-            return null;
-        }
-        const segment = segments[index];
-        // 1. 静态路径
-        const staticChild = node.children[segment];
-        if (staticChild) {
-            const result = this.matchNode(staticChild, segments, index + 1, params);
-            if (result)
-                return result;
-        }
-        // 2. 动态参数
-        if (node.paramChild) {
-            const paramName = node.paramChild.paramName;
-            const oldValue = params[paramName];
-            params[paramName] = segment;
-            const result = this.matchNode(node.paramChild, segments, index + 1, params);
-            if (result)
-                return result;
-            // 回溯
-            if (oldValue === undefined) {
-                delete params[paramName];
-            }
-            else {
-                params[paramName] = oldValue;
-            }
-        }
-        // 3. 通配符
-        if (node.wildcardChild) {
-            params[node.wildcardChild.paramName || "*"] = segments
-                .slice(index)
-                .join("/");
-            return node.wildcardChild;
-        }
+    const routeHandler = { handler, middleware };
+    if (this.compiler && middleware.length === 0) {
+      routeHandler.compiled = this.compiler([], handler);
+    }
+    node.handlers[method] = routeHandler;
+  }
+  /** 预编译所有路由（在添加全局中间件后调用） */
+  precompileAll(globalMiddleware) {
+    if (!this.compiler) return;
+    this.precompileNode(this.root, globalMiddleware);
+  }
+  precompileNode(node, globalMiddleware) {
+    for (const method in node.handlers) {
+      const routeHandler = node.handlers[method];
+      if (routeHandler) {
+        const allMiddleware = [...globalMiddleware, ...routeHandler.middleware];
+        routeHandler.compiled = this.compiler(
+          allMiddleware,
+          routeHandler.handler
+        );
+      }
+    }
+    for (const key in node.children) {
+      this.precompileNode(node.children[key], globalMiddleware);
+    }
+    if (node.paramChild) {
+      this.precompileNode(node.paramChild, globalMiddleware);
+    }
+    if (node.wildcardChild) {
+      this.precompileNode(node.wildcardChild, globalMiddleware);
+    }
+  }
+  /** 匹配路由 */
+  match(method, path) {
+    const segments = this.splitPath(path);
+    const params = /* @__PURE__ */ Object.create(null);
+    const node = this.matchNode(this.root, segments, 0, params);
+    if (!node) return null;
+    const routeHandler = node.handlers[method];
+    if (!routeHandler) return null;
+    return {
+      handler: routeHandler.handler,
+      middleware: routeHandler.middleware,
+      params,
+      compiled: routeHandler.compiled
+    };
+  }
+  /** 递归匹配节点 (优先级: 静态 > 动态参数 > 通配符) */
+  matchNode(node, segments, index, params) {
+    if (index === segments.length) {
+      for (const method in node.handlers) {
+        if (node.handlers[method]) return node;
+      }
+      return null;
+    }
+    const segment = segments[index];
+    const staticChild = node.children[segment];
+    if (staticChild) {
+      const result = this.matchNode(staticChild, segments, index + 1, params);
+      if (result) return result;
+    }
+    if (node.paramChild) {
+      const paramName = node.paramChild.paramName;
+      const oldValue = params[paramName];
+      params[paramName] = segment;
+      const result = this.matchNode(
+        node.paramChild,
+        segments,
+        index + 1,
+        params
+      );
+      if (result) return result;
+      if (oldValue === void 0) {
+        delete params[paramName];
+      } else {
+        params[paramName] = oldValue;
+      }
+    }
+    if (node.wildcardChild) {
+      params[node.wildcardChild.paramName || "*"] = segments.slice(index).join("/");
+      return node.wildcardChild;
+    }
+    return null;
+  }
+  /** 获取路径允许的 HTTP 方法 */
+  getAllowedMethods(path) {
+    const segments = this.splitPath(path);
+    const node = this.findNode(segments);
+    if (!node) return [];
+    const methods = [];
+    for (const method in node.handlers) {
+      if (node.handlers[method]) {
+        methods.push(method);
+      }
+    }
+    return methods;
+  }
+  /** 查找节点（不提取参数） */
+  findNode(segments) {
+    let node = this.root;
+    for (const segment of segments) {
+      if (node.children[segment]) {
+        node = node.children[segment];
+      } else if (node.paramChild) {
+        node = node.paramChild;
+      } else if (node.wildcardChild) {
+        return node.wildcardChild;
+      } else {
         return null;
+      }
     }
-    /** 获取路径允许的 HTTP 方法 */
-    getAllowedMethods(path) {
-        const segments = this.splitPath(path);
-        const node = this.findNode(segments);
-        if (!node)
-            return [];
-        const methods = [];
-        for (const method in node.handlers) {
-            if (node.handlers[method]) {
-                methods.push(method);
-            }
-        }
-        return methods;
-    }
-    /** 查找节点（不提取参数） */
-    findNode(segments) {
-        let node = this.root;
-        for (const segment of segments) {
-            if (node.children[segment]) {
-                node = node.children[segment];
-            }
-            else if (node.paramChild) {
-                node = node.paramChild;
-            }
-            else if (node.wildcardChild) {
-                return node.wildcardChild;
-            }
-            else {
-                return null;
-            }
-        }
-        return node;
-    }
-    /** 获取所有已注册的路由 */
-    getRoutes() {
-        const routes = [];
-        this.collectRoutes(this.root, "", routes);
-        return routes;
-    }
-    collectRoutes(node, prefix, routes) {
-        const currentPath = prefix + (node.path ? "/" + node.path : "");
-        for (const method in node.handlers) {
-            if (node.handlers[method]) {
-                routes.push({ method: method, path: currentPath || "/" });
-            }
-        }
-        for (const key in node.children) {
-            this.collectRoutes(node.children[key], currentPath, routes);
-        }
-        if (node.paramChild) {
-            this.collectRoutes(node.paramChild, currentPath, routes);
-        }
-        if (node.wildcardChild) {
-            this.collectRoutes(node.wildcardChild, currentPath, routes);
-        }
+    return node;
+  }
+  /** 获取所有已注册的路由 */
+  getRoutes() {
+    const routes = [];
+    this.collectRoutes(this.root, "", routes);
+    return routes;
+  }
+  collectRoutes(node, prefix, routes) {
+    const currentPath = prefix + (node.path ? "/" + node.path : "");
+    for (const method in node.handlers) {
+      if (node.handlers[method]) {
+        routes.push({ method, path: currentPath || "/" });
+      }
+    }
+    for (const key in node.children) {
+      this.collectRoutes(node.children[key], currentPath, routes);
+    }
+    if (node.paramChild) {
+      this.collectRoutes(node.paramChild, currentPath, routes);
+    }
+    if (node.wildcardChild) {
+      this.collectRoutes(node.wildcardChild, currentPath, routes);
     }
-}
+  }
+};
+export {
+  RadixRouter
+};
+//# sourceMappingURL=radix-tree.js.map

package/dist/router/radix-tree.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/router/radix-tree.ts"],"sourcesContent":["/**\n * Radix Tree 路由匹配器\n *\n * 高性能路由匹配实现，时间复杂度 O(k)，k 为路径段数\n *\n * 支持的路由模式:\n * - 静态路径: /users, /api/v1/health\n * - 动态参数: /users/:id, /posts/:postId/comments/:commentId\n * - 通配符: /files/*, /static/*filepath\n */\n\nimport type { Handler, Middleware, Method } from \"../types\";\n\n/** 预编译的处理器类型 */\ntype CompiledHandler = (req: Request) => Promise<Response>;\n\n/** 路由处理信息 */\ninterface RouteHandler {\n  handler: Handler;\n  middleware: Middleware[];\n  /** 预编译后的完整处理链（包含中间件） */\n  compiled?: CompiledHandler;\n}\n\n/** Radix Tree 节点 */\ninterface RadixNode {\n  path: string;\n  children: Record<string, RadixNode>;\n  paramChild?: RadixNode;\n  wildcardChild?: RadixNode;\n  paramName?: string;\n  handlers: Record<Method, RouteHandler | undefined>;\n}\n\n/** 路由匹配结果 */\nexport interface MatchResult {\n  handler: Handler;\n  middleware: Middleware[];\n  params: Record<string, string>;\n  /** 预编译后的完整处理链 */\n  compiled?: CompiledHandler;\n}\n\n/**\n * Radix Tree 路由器\n *\n * @example\n * ```typescript\n * const router = new RadixRouter();\n * router.register(\"GET\", \"/users/:id\", handler);\n * const result = router.match(\"GET\", \"/users/123\");\n * // result.params = { id: \"123\" }\n * ```\n */\nexport class RadixRouter {\n  private root: RadixNode;\n\n  constructor() {\n    this.root = this.createNode(\"\");\n  }\n\n  private createNode(path: string): RadixNode {\n    return {\n      path,\n      children: Object.create(null),\n      handlers: Object.create(null),\n    };\n  }\n\n  /** 分割路径 */\n  private splitPath(path: string): string[] {\n    return path.split(\"/\").filter(Boolean);\n  }\n\n  /** 编译器函数 - 用于预编译中间件链 */\n  private compiler?: (\n    middleware: Middleware[],\n    handler: Handler,\n  ) => CompiledHandler;\n\n  /** 设置中间件编译器 */\n  setCompiler(\n    compiler: (middleware: Middleware[], handler: Handler) => CompiledHandler,\n  ): void {\n    this.compiler = compiler;\n  }\n\n  /** 注册路由 */\n  register(\n    method: Method,\n    pattern: string,\n    handler: Handler,\n    middleware: Middleware[] = [],\n  ): void {\n    const segments = this.splitPath(pattern);\n    let node = this.root;\n\n    for (const segment of segments) {\n      const firstChar = segment[0];\n\n      if (firstChar === \":\") {\n        // 动态参数节点\n        if (!node.paramChild) {\n          node.paramChild = this.createNode(segment);\n          node.paramChild.paramName = segment.substring(1);\n        }\n        node = node.paramChild;\n      } else if (firstChar === \"*\") {\n        // 通配符节点\n        if (!node.wildcardChild) {\n          node.wildcardChild = this.createNode(segment);\n          node.wildcardChild.paramName =\n            segment.length > 1 ? segment.substring(1) : \"*\";\n        }\n        node = node.wildcardChild;\n        break;\n      } else {\n        // 静态路径节点\n        if (!node.children[segment]) {\n          node.children[segment] = this.createNode(segment);\n        }\n        node = node.children[segment];\n      }\n    }\n\n    const routeHandler: RouteHandler = { handler, middleware };\n\n    // 如果没有全局中间件且设置了编译器，预编译处理链\n    if (this.compiler && middleware.length === 0) {\n      routeHandler.compiled = this.compiler([], handler);\n    }\n\n    node.handlers[method] = routeHandler;\n  }\n\n  /** 预编译所有路由（在添加全局中间件后调用） */\n  precompileAll(globalMiddleware: Middleware[]): void {\n    if (!this.compiler) return;\n    this.precompileNode(this.root, globalMiddleware);\n  }\n\n  private precompileNode(\n    node: RadixNode,\n    globalMiddleware: Middleware[],\n  ): void {\n    for (const method in node.handlers) {\n      const routeHandler = node.handlers[method as Method];\n      if (routeHandler) {\n        const allMiddleware = [...globalMiddleware, ...routeHandler.middleware];\n        routeHandler.compiled = this.compiler!(\n          allMiddleware,\n          routeHandler.handler,\n        );\n      }\n    }\n\n    for (const key in node.children) {\n      this.precompileNode(node.children[key], globalMiddleware);\n    }\n\n    if (node.paramChild) {\n      this.precompileNode(node.paramChild, globalMiddleware);\n    }\n\n    if (node.wildcardChild) {\n      this.precompileNode(node.wildcardChild, globalMiddleware);\n    }\n  }\n\n  /** 匹配路由 */\n  match(method: Method, path: string): MatchResult | null {\n    const segments = this.splitPath(path);\n    const params: Record<string, string> = Object.create(null);\n\n    const node = this.matchNode(this.root, segments, 0, params);\n    if (!node) return null;\n\n    const routeHandler = node.handlers[method];\n    if (!routeHandler) return null;\n\n    return {\n      handler: routeHandler.handler,\n      middleware: routeHandler.middleware,\n      params,\n      compiled: routeHandler.compiled,\n    };\n  }\n\n  /** 递归匹配节点 (优先级: 静态 > 动态参数 > 通配符) */\n  private matchNode(\n    node: RadixNode,\n    segments: string[],\n    index: number,\n    params: Record<string, string>,\n  ): RadixNode | null {\n    if (index === segments.length) {\n      for (const method in node.handlers) {\n        if (node.handlers[method as Method]) return node;\n      }\n      return null;\n    }\n\n    const segment = segments[index];\n\n    // 1. 静态路径\n    const staticChild = node.children[segment];\n    if (staticChild) {\n      const result = this.matchNode(staticChild, segments, index + 1, params);\n      if (result) return result;\n    }\n\n    // 2. 动态参数\n    if (node.paramChild) {\n      const paramName = node.paramChild.paramName!;\n      const oldValue = params[paramName];\n\n      params[paramName] = segment;\n      const result = this.matchNode(\n        node.paramChild,\n        segments,\n        index + 1,\n        params,\n      );\n\n      if (result) return result;\n\n      // 回溯\n      if (oldValue === undefined) {\n        delete params[paramName];\n      } else {\n        params[paramName] = oldValue;\n      }\n    }\n\n    // 3. 通配符\n    if (node.wildcardChild) {\n      params[node.wildcardChild.paramName || \"*\"] = segments\n        .slice(index)\n        .join(\"/\");\n      return node.wildcardChild;\n    }\n\n    return null;\n  }\n\n  /** 获取路径允许的 HTTP 方法 */\n  getAllowedMethods(path: string): Method[] {\n    const segments = this.splitPath(path);\n    const node = this.findNode(segments);\n    if (!node) return [];\n\n    const methods: Method[] = [];\n    for (const method in node.handlers) {\n      if (node.handlers[method as Method]) {\n        methods.push(method as Method);\n      }\n    }\n    return methods;\n  }\n\n  /** 查找节点（不提取参数） */\n  private findNode(segments: string[]): RadixNode | null {\n    let node = this.root;\n\n    for (const segment of segments) {\n      if (node.children[segment]) {\n        node = node.children[segment];\n      } else if (node.paramChild) {\n        node = node.paramChild;\n      } else if (node.wildcardChild) {\n        return node.wildcardChild;\n      } else {\n        return null;\n      }\n    }\n\n    return node;\n  }\n\n  /** 获取所有已注册的路由 */\n  getRoutes(): Array<{ method: Method; path: string }> {\n    const routes: Array<{ method: Method; path: string }> = [];\n    this.collectRoutes(this.root, \"\", routes);\n    return routes;\n  }\n\n  private collectRoutes(\n    node: RadixNode,\n    prefix: string,\n    routes: Array<{ method: Method; path: string }>,\n  ): void {\n    const currentPath = prefix + (node.path ? \"/\" + node.path : \"\");\n\n    for (const method in node.handlers) {\n      if (node.handlers[method as Method]) {\n        routes.push({ method: method as Method, path: currentPath || \"/\" });\n      }\n    }\n\n    for (const key in node.children) {\n      this.collectRoutes(node.children[key], currentPath, routes);\n    }\n\n    if (node.paramChild) {\n      this.collectRoutes(node.paramChild, currentPath, routes);\n    }\n\n    if (node.wildcardChild) {\n      this.collectRoutes(node.wildcardChild, currentPath, routes);\n    }\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/router.d.ts

@@ -1,9 +1,11 @@
+import { Route, NestedRoute, FlattenedRoute } from './types/types.js';
+
 /**
  * 路由工具函数
  *
  * 提供路由处理的基础工具
  */
-import type { Route, NestedRoute, FlattenedRoute } from "./types";
+
 /**
  * 扁平化嵌套路由
  *
@@ -28,7 +30,7 @@ import type { Route, NestedRoute, FlattenedRoute } from "./types";
  * // ]
  * ```
  */
-export declare function flattenNestedRoutes(routes: (Route | NestedRoute)[]): FlattenedRoute[];
+declare function flattenNestedRoutes(routes: (Route | NestedRoute)[]): FlattenedRoute[];
 /**
  * 标准化路径
  *
@@ -42,4 +44,6 @@ export declare function flattenNestedRoutes(routes: (Route | NestedRoute)[]): Fl
  * normalizePath("/api/%20test")   // "/api/ test"
  * ```
  */
-export declare function normalizePath(path: string): string;
+declare function normalizePath(path: string): string;
+
+export { flattenNestedRoutes, normalizePath };

package/dist/router.js

@@ -1,86 +1,40 @@
-/**
- * 路由工具函数
- *
- * 提供路由处理的基础工具
- */
-/**
- * 扁平化嵌套路由
- *
- * 将嵌套路由结构转换为扁平数组，计算完整路径和中间件链
- *
- * @example
- * ```typescript
- * const routes = flattenNestedRoutes([
- *   {
- *     path: "/api",
- *     middleware: [authMiddleware],
- *     children: [
- *       { path: "/users", method: "GET", handler: getUsers },
- *       { path: "/users/:id", method: "GET", handler: getUser },
- *     ],
- *   },
- * ]);
- * // 结果:
- * // [
- * //   { fullPath: "/api/users", method: "GET", ... },
- * //   { fullPath: "/api/users/:id", method: "GET", ... },
- * // ]
- * ```
- */
-export function flattenNestedRoutes(routes) {
-    const flattened = [];
-    function processRoute(route, parentPath = "", parentMiddleware = []) {
-        // 计算当前完整路径
-        const currentPath = normalizePath(parentPath + route.path);
-        // 合并中间件链
-        const currentMiddleware = [
-            ...parentMiddleware,
-            ...(route.middleware || []),
-        ];
-        if ("method" in route && "handler" in route) {
-            // 叶子路由（有处理函数）
-            flattened.push({
-                ...route,
-                fullPath: currentPath,
-                middlewareChain: currentMiddleware,
-            });
-        }
-        else if ("children" in route && route.children) {
-            // 分组路由，递归处理子路由
-            for (const child of route.children) {
-                processRoute(child, currentPath, currentMiddleware);
-            }
-        }
+// src/router.ts
+function flattenNestedRoutes(routes) {
+  const flattened = [];
+  function processRoute(route, parentPath = "", parentMiddleware = []) {
+    const currentPath = normalizePath(parentPath + route.path);
+    const currentMiddleware = [
+      ...parentMiddleware,
+      ...route.middleware || []
+    ];
+    if ("method" in route && "handler" in route) {
+      flattened.push({
+        ...route,
+        fullPath: currentPath,
+        middlewareChain: currentMiddleware
+      });
+    } else if ("children" in route && route.children) {
+      for (const child of route.children) {
+        processRoute(child, currentPath, currentMiddleware);
+      }
     }
-    for (const route of routes) {
-        processRoute(route);
-    }
-    return flattened;
+  }
+  for (const route of routes) {
+    processRoute(route);
+  }
+  return flattened;
 }
-/**
- * 标准化路径
- *
- * - 解码 URL 编码字符
- * - 去除重复斜杠
- * - 处理结尾斜杠
- *
- * @example
- * ```typescript
- * normalizePath("//api//users/")  // "/api/users"
- * normalizePath("/api/%20test")   // "/api/ test"
- * ```
- */
-export function normalizePath(path) {
-    // 解码 URL 编码
-    let normalized = decodeURIComponent(path);
-    // 去除重复斜杠
-    normalized = normalized.replace(/\/+/g, "/");
-    // 空路径转为根路径
-    if (normalized === "")
-        return "/";
-    // 去除结尾斜杠（根路径除外）
-    if (normalized !== "/" && normalized.endsWith("/")) {
-        normalized = normalized.slice(0, -1);
-    }
-    return normalized;
+function normalizePath(path) {
+  let normalized = decodeURIComponent(path);
+  normalized = normalized.replace(/\/+/g, "/");
+  if (normalized === "") return "/";
+  if (normalized !== "/" && normalized.endsWith("/")) {
+    normalized = normalized.slice(0, -1);
+  }
+  return normalized;
 }
+export {
+  flattenNestedRoutes,
+  normalizePath
+};
+//# sourceMappingURL=router.js.map

package/dist/router.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/router.ts"],"sourcesContent":["/**\n * 路由工具函数\n *\n * 提供路由处理的基础工具\n */\n\nimport type { Route, NestedRoute, FlattenedRoute, Middleware } from \"./types\";\n\n/**\n * 扁平化嵌套路由\n *\n * 将嵌套路由结构转换为扁平数组，计算完整路径和中间件链\n *\n * @example\n * ```typescript\n * const routes = flattenNestedRoutes([\n *   {\n *     path: \"/api\",\n *     middleware: [authMiddleware],\n *     children: [\n *       { path: \"/users\", method: \"GET\", handler: getUsers },\n *       { path: \"/users/:id\", method: \"GET\", handler: getUser },\n *     ],\n *   },\n * ]);\n * // 结果:\n * // [\n * //   { fullPath: \"/api/users\", method: \"GET\", ... },\n * //   { fullPath: \"/api/users/:id\", method: \"GET\", ... },\n * // ]\n * ```\n */\nexport function flattenNestedRoutes(\n  routes: (Route | NestedRoute)[],\n): FlattenedRoute[] {\n  const flattened: FlattenedRoute[] = [];\n\n  function processRoute(\n    route: Route | NestedRoute,\n    parentPath = \"\",\n    parentMiddleware: Middleware[] = [],\n  ): void {\n    // 计算当前完整路径\n    const currentPath = normalizePath(parentPath + route.path);\n    // 合并中间件链\n    const currentMiddleware = [\n      ...parentMiddleware,\n      ...(route.middleware || []),\n    ];\n\n    if (\"method\" in route && \"handler\" in route) {\n      // 叶子路由（有处理函数）\n      flattened.push({\n        ...route,\n        fullPath: currentPath,\n        middlewareChain: currentMiddleware,\n      });\n    } else if (\"children\" in route && route.children) {\n      // 分组路由，递归处理子路由\n      for (const child of route.children) {\n        processRoute(child, currentPath, currentMiddleware);\n      }\n    }\n  }\n\n  for (const route of routes) {\n    processRoute(route);\n  }\n\n  return flattened;\n}\n\n/**\n * 标准化路径\n *\n * - 解码 URL 编码字符\n * - 去除重复斜杠\n * - 处理结尾斜杠\n *\n * @example\n * ```typescript\n * normalizePath(\"//api//users/\")  // \"/api/users\"\n * normalizePath(\"/api/%20test\")   // \"/api/ test\"\n * ```\n */\nexport function normalizePath(path: string): string {\n  // 解码 URL 编码\n  let normalized = decodeURIComponent(path);\n\n  // 去除重复斜杠\n  normalized = normalized.replace(/\\/+/g, \"/\");\n\n  // 空路径转为根路径\n  if (normalized === \"\") return \"/\";\n\n  // 去除结尾斜杠（根路径除外）\n  if (normalized !== \"/\" && normalized.endsWith(\"/\")) {\n    normalized = normalized.slice(0, -1);\n  }\n\n  return normalized;\n}\n"],"mappings":";AAgCO,SAAS,oBACd,QACkB;AAClB,QAAM,YAA8B,CAAC;AAErC,WAAS,aACP,OACA,aAAa,IACb,mBAAiC,CAAC,GAC5B;AAEN,UAAM,cAAc,cAAc,aAAa,MAAM,IAAI;AAEzD,UAAM,oBAAoB;AAAA,MACxB,GAAG;AAAA,MACH,GAAI,MAAM,cAAc,CAAC;AAAA,IAC3B;AAEA,QAAI,YAAY,SAAS,aAAa,OAAO;AAE3C,gBAAU,KAAK;AAAA,QACb,GAAG;AAAA,QACH,UAAU;AAAA,QACV,iBAAiB;AAAA,MACnB,CAAC;AAAA,IACH,WAAW,cAAc,SAAS,MAAM,UAAU;AAEhD,iBAAW,SAAS,MAAM,UAAU;AAClC,qBAAa,OAAO,aAAa,iBAAiB;AAAA,MACpD;AAAA,IACF;AAAA,EACF;AAEA,aAAW,SAAS,QAAQ;AAC1B,iBAAa,KAAK;AAAA,EACpB;AAEA,SAAO;AACT;AAeO,SAAS,cAAc,MAAsB;AAElD,MAAI,aAAa,mBAAmB,IAAI;AAGxC,eAAa,WAAW,QAAQ,QAAQ,GAAG;AAG3C,MAAI,eAAe,GAAI,QAAO;AAG9B,MAAI,eAAe,OAAO,WAAW,SAAS,GAAG,GAAG;AAClD,iBAAa,WAAW,MAAM,GAAG,EAAE;AAAA,EACrC;AAEA,SAAO;AACT;","names":[]}

package/dist/serve.d.ts

@@ -1,12 +1,2 @@
-/**
- * 统一的 serve 函数
- * 使用 Node.js 原生 http 模块，兼容 Bun 和 Node.js
- *
- * 基准测试结果（Bun 环境）：
- * - Bun.serve: 35,422 req/s
- * - node:http: 38,075 req/s
- *
- * node:http 在 Bun 下性能甚至更好，无需使用 Bun API
- */
-export { serve, createAdaptorServer } from "./node-server/serve";
-export type { ServeOptions, ServeResult, FetchHandler, } from "./node-server/serve";
+export { FetchHandler, ServeOptions, ServeResult, createAdaptorServer, serve } from './node-server/serve.js';
+import 'node:http';