vafast 0.1.13 → 0.2.1

package/dist/middleware/component-renderer.js

@@ -6,13 +6,11 @@
 const renderVueSSR = async (componentImport, req, preloadedDeps) => {
     try {
         // 使用预加载的依赖或动态导入
-        const { createSSRApp, renderToString } = preloadedDeps || await Promise.all([
-            import("vue"),
-            import("@vue/server-renderer")
-        ]).then(([vue, renderer]) => ({
-            createSSRApp: vue.createSSRApp,
-            renderToString: renderer.renderToString
-        }));
+        const { createSSRApp, renderToString } = preloadedDeps ||
+            (await Promise.all([import("vue"), import("@vue/server-renderer")]).then(([vue, renderer]) => ({
+                createSSRApp: vue.createSSRApp,
+                renderToString: renderer.renderToString,
+            })));
         const componentModule = await componentImport();
         const component = componentModule.default || componentModule;
         const app = createSSRApp(component);
@@ -64,13 +62,11 @@ const renderVueSSR = async (componentImport, req, preloadedDeps) => {
 const renderReactSSR = async (componentImport, req, preloadedDeps) => {
     try {
         // 使用预加载的依赖或动态导入
-        const { createElement, renderToString } = preloadedDeps || await Promise.all([
-            import("react"),
-            import("react-dom/server")
-        ]).then(([react, renderer]) => ({
-            createElement: react.createElement,
-            renderToString: renderer.renderToString
-        }));
+        const { createElement, renderToString } = preloadedDeps ||
+            (await Promise.all([import("react"), import("react-dom/server")]).then(([react, renderer]) => ({
+                createElement: react.createElement,
+                renderToString: renderer.renderToString,
+            })));
         const componentModule = await componentImport();
         const Component = componentModule.default || componentModule;
         const content = createElement(Component, {

package/dist/middleware/component-router.js

@@ -5,7 +5,10 @@ export function flattenComponentRoutes(routes) {
     const flattened = [];
     function processRoute(route, parentPath = "", parentMiddleware = []) {
         const currentPath = parentPath + route.path;
-        const currentMiddleware = [...parentMiddleware, ...(route.middleware || [])];
+        const currentMiddleware = [
+            ...parentMiddleware,
+            ...(route.middleware || []),
+        ];
         if ("component" in route) {
             // 这是一个组件路由
             flattened.push({

package/dist/middleware.d.ts

@@ -15,4 +15,4 @@ export declare class VafastError extends Error {
 /**
  * 组合类型: 自动注入错误处理器进行中间件组合
  */
-export declare function composeMiddleware(middleware: Middleware[], finalHandler: Handler): Handler;
+export declare function composeMiddleware(middleware: Middleware[], finalHandler: Handler): (req: Request) => Promise<Response>;

package/dist/middleware.js

@@ -1,5 +1,5 @@
 // src/middleware.ts
-import { json } from "./utils/response";
+import { json, mapResponse } from "./utils/response";
 /** 中间件类型：使用 next() 传递给下一个处理 */
 /** Vafast 自定义错误类型 */
 export class VafastError extends Error {
@@ -27,8 +27,13 @@ export function composeMiddleware(middleware, finalHandler) {
             if (index <= i)
                 return Promise.reject(new Error("next() called multiple times"));
             i = index;
-            const fn = index < all.length ? all[index] : finalHandler;
-            return Promise.resolve(fn(req, (() => dispatch(index + 1))));
+            // 中间件阶段
+            if (index < all.length) {
+                const mw = all[index];
+                return Promise.resolve(mw(req, () => dispatch(index + 1)));
+            }
+            // 最终 handler - 使用 mapResponse 转换返回值
+            return Promise.resolve(finalHandler(req)).then(mapResponse);
         };
         return dispatch(0);
     };

package/dist/monitoring/types.d.ts

@@ -107,7 +107,7 @@ export interface MonitoringConfig {
     };
 }
 export interface MonitoringEvent {
-    type: 'request_start' | 'request_end' | 'validation_start' | 'validation_end' | 'error';
+    type: "request_start" | "request_end" | "validation_start" | "validation_end" | "error";
     timestamp: number;
     requestId: string;
     data: any;

package/dist/router/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 路由模块导出
+ */
+export { RadixRouter } from "./radix-tree";
+export { flattenNestedRoutes, normalizePath } from "../router";

package/dist/router/index.js

@@ -0,0 +1,7 @@
+/**
+ * 路由模块导出
+ */
+// Radix Tree 路由器
+export { RadixRouter } from "./radix-tree";
+// 路由工具函数
+export { flattenNestedRoutes, normalizePath } from "../router";

package/dist/router/radix-tree.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Radix Tree 路由匹配器
+ *
+ * 高性能路由匹配实现，时间复杂度 O(k)，k 为路径段数
+ *
+ * 支持的路由模式:
+ * - 静态路径: /users, /api/v1/health
+ * - 动态参数: /users/:id, /posts/:postId/comments/:commentId
+ * - 通配符: /files/*, /static/*filepath
+ */
+import type { Handler, Middleware, Method } from "../types";
+/** 路由匹配结果 */
+export interface MatchResult {
+    handler: Handler;
+    middleware: Middleware[];
+    params: Record<string, string>;
+}
+/**
+ * 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 declare class RadixRouter {
+    private root;
+    constructor();
+    private createNode;
+    /** 分割路径 */
+    private splitPath;
+    /** 注册路由 */
+    register(method: Method, pattern: string, handler: Handler, middleware?: Middleware[]): void;
+    /** 匹配路由 */
+    match(method: Method, path: string): MatchResult | null;
+    /** 递归匹配节点 (优先级: 静态 > 动态参数 > 通配符) */
+    private matchNode;
+    /** 获取路径允许的 HTTP 方法 */
+    getAllowedMethods(path: string): Method[];
+    /** 查找节点（不提取参数） */
+    private findNode;
+    /** 获取所有已注册的路由 */
+    getRoutes(): Array<{
+        method: Method;
+        path: string;
+    }>;
+    private collectRoutes;
+}

package/dist/router/radix-tree.js

@@ -0,0 +1,186 @@
+/**
+ * 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);
+    }
+    /** 注册路由 */
+    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];
+            }
+        }
+        node.handlers[method] = { handler, middleware };
+    }
+    /** 匹配路由 */
+    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,
+        };
+    }
+    /** 递归匹配节点 (优先级: 静态 > 动态参数 > 通配符) */
+    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;
+        }
+        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);
+        }
+    }
+}

package/dist/router.d.ts

@@ -1,17 +1,45 @@
+/**
+ * 路由工具函数
+ *
+ * 提供路由处理的基础工具
+ */
 import type { Route, NestedRoute, FlattenedRoute } from "./types";
-export interface MatchResult {
-    matched: boolean;
-    params: Record<string, string>;
-}
 /**
- * 扁平化嵌套路由，计算完整路径和中间件链
+ * 扁平化嵌套路由
+ *
+ * 将嵌套路由结构转换为扁平数组，计算完整路径和中间件链
+ *
+ * @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 declare function flattenNestedRoutes(routes: (Route | NestedRoute)[]): FlattenedRoute[];
 /**
- * 标准化路径：去重斜杠、解码URL、处理结尾斜杠
+ * 标准化路径
+ *
+ * - 解码 URL 编码字符
+ * - 去除重复斜杠
+ * - 处理结尾斜杠
+ *
+ * @example
+ * ```typescript
+ * normalizePath("//api//users/")  // "/api/users"
+ * normalizePath("/api/%20test")   // "/api/ test"
+ * ```
  */
 export declare function normalizePath(path: string): string;
-/**
- * 匹配函数：支持动态路由和路径标准化
- */
-export declare function matchPath(pattern: string, path: string): MatchResult;

package/dist/router.js

@@ -1,21 +1,52 @@
 /**
- * 扁平化嵌套路由，计算完整路径和中间件链
+ * 路由工具函数
+ *
+ * 提供路由处理的基础工具
+ */
+/**
+ * 扁平化嵌套路由
+ *
+ * 将嵌套路由结构转换为扁平数组，计算完整路径和中间件链
+ *
+ * @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 = parentPath + route.path;
-        const currentMiddleware = [...parentMiddleware, ...(route.middleware || [])];
-        if ('method' in route && 'handler' in route) {
-            // 这是一个叶子路由（有处理函数）
+        // 计算当前完整路径
+        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
+                middlewareChain: currentMiddleware,
             });
         }
-        else if ('children' in route && route.children) {
-            // 这是一个分组路由，处理子路由
+        else if ("children" in route && route.children) {
+            // 分组路由，递归处理子路由
             for (const child of route.children) {
                 processRoute(child, currentPath, currentMiddleware);
             }
@@ -27,48 +58,29 @@ export function flattenNestedRoutes(routes) {
     return flattened;
 }
 /**
- * 标准化路径：去重斜杠、解码URL、处理结尾斜杠
+ * 标准化路径
+ *
+ * - 解码 URL 编码字符
+ * - 去除重复斜杠
+ * - 处理结尾斜杠
+ *
+ * @example
+ * ```typescript
+ * normalizePath("//api//users/")  // "/api/users"
+ * normalizePath("/api/%20test")   // "/api/ test"
+ * ```
  */
 export function normalizePath(path) {
-    // 解码 URL 编码的字符
+    // 解码 URL 编码
     let normalized = decodeURIComponent(path);
-    // 去重连续的斜杠
+    // 去除重复斜杠
     normalized = normalized.replace(/\/+/g, "/");
-    // 处理根路径
+    // 空路径转为根路径
     if (normalized === "")
-        normalized = "/";
-    // 去掉结尾斜杠（除非是根路径）
+        return "/";
+    // 去除结尾斜杠（根路径除外）
     if (normalized !== "/" && normalized.endsWith("/")) {
         normalized = normalized.slice(0, -1);
     }
     return normalized;
 }
-/**
- * 匹配函数：支持动态路由和路径标准化
- */
-export function matchPath(pattern, path) {
-    // 标准化输入路径
-    const normalizedPath = normalizePath(path);
-    const patternParts = pattern.split("/").filter(Boolean);
-    const pathParts = normalizedPath.split("/").filter(Boolean);
-    const params = {};
-    for (let i = 0; i < patternParts.length; i++) {
-        const pat = patternParts[i];
-        const part = pathParts[i];
-        if (pat === "*") {
-            params["*"] = pathParts.slice(i).join("/");
-            return { matched: true, params };
-        }
-        if (pat.startsWith(":")) {
-            if (!part)
-                return { matched: false, params: {} };
-            params[pat.slice(1)] = part;
-            continue;
-        }
-        if (pat !== part)
-            return { matched: false, params: {} };
-    }
-    if (patternParts.length !== pathParts.length)
-        return { matched: false, params: {} };
-    return { matched: true, params };
-}

package/dist/server/base-server.d.ts

@@ -31,8 +31,4 @@ export declare abstract class BaseServer {
      * 提取路径参数
      */
     protected extractParams(pattern: string, path: string): Record<string, string>;
-    /**
-     * 处理 OPTIONS 请求
-     */
-    protected handleOptions(pathname: string, routes: any[]): Response;
 }

package/dist/server/base-server.js

@@ -120,7 +120,8 @@ export class BaseServer {
             return false;
         }
         for (let i = 0; i < patternParts.length; i++) {
-            if (patternParts[i] !== pathParts[i] && !patternParts[i].startsWith(":")) {
+            if (patternParts[i] !== pathParts[i] &&
+                !patternParts[i].startsWith(":")) {
                 return false;
             }
         }
@@ -141,27 +142,4 @@ export class BaseServer {
         }
         return params;
     }
-    /**
-     * 处理 OPTIONS 请求
-     */
-    handleOptions(pathname, routes) {
-        const availableMethods = [];
-        for (const route of routes) {
-            const path = route.fullPath || route.path;
-            const method = route.method || "GET";
-            if (this.matchPath(path, pathname)) {
-                availableMethods.push(method);
-            }
-        }
-        // 去重并排序
-        const uniqueMethods = [...new Set(availableMethods)].sort();
-        return new Response(null, {
-            status: 204,
-            headers: {
-                Allow: uniqueMethods.join(", "),
-                "Access-Control-Allow-Methods": uniqueMethods.join(", "),
-                "Access-Control-Allow-Headers": "Content-Type, Authorization",
-            },
-        });
-    }
 }

package/dist/server/index.d.ts

@@ -1,7 +1,7 @@
+/**
+ * 服务器模块导出
+ */
 export { Server } from "./server";
 export { ComponentServer } from "./component-server";
-export { BaseServer } from "./base-server";
 export { ServerFactory } from "./server-factory";
-export { PathMatcher } from "../utils/path-matcher";
-export { HtmlRenderer } from "../utils/html-renderer";
-export { DependencyManager } from "../utils/dependency-manager";
+export { BaseServer } from "./base-server";

package/dist/server/index.js

@@ -1,9 +1,11 @@
-// 导出所有服务器相关的类和工具
+/**
+ * 服务器模块导出
+ */
+// 主服务器类
 export { Server } from "./server";
+// 组件服务器 (SSR)
 export { ComponentServer } from "./component-server";
-export { BaseServer } from "./base-server";
+// 服务器工厂
 export { ServerFactory } from "./server-factory";
-// 导出工具类
-export { PathMatcher } from "../utils/path-matcher";
-export { HtmlRenderer } from "../utils/html-renderer";
-export { DependencyManager } from "../utils/dependency-manager";
+// 基类 (仅用于扩展)
+export { BaseServer } from "./base-server";

package/dist/server/server.d.ts

@@ -1,7 +1,35 @@
-import type { Route, NestedRoute } from "../types";
+/**
+ * Vafast 核心服务器
+ *
+ * 基于 Radix Tree 的高性能路由匹配
+ * 时间复杂度: O(k)，k 为路径段数
+ */
+import type { Route, NestedRoute, Method } from "../types";
 import { BaseServer } from "./base-server";
+/**
+ * Vafast 服务器
+ *
+ * @example
+ * ```typescript
+ * const server = new Server([
+ *   { method: "GET", path: "/", handler: () => new Response("Hello") },
+ * ]);
+ * export default { fetch: server.fetch };
+ * ```
+ */
 export declare class Server extends BaseServer {
+    private router;
     private routes;
-    constructor(routes: (Route | NestedRoute)[]);
+    constructor(routes?: (Route | NestedRoute)[]);
+    private registerRoutes;
+    /** 快速提取 pathname */
+    private extractPathname;
+    /** 处理请求 */
     fetch: (req: Request) => Promise<Response>;
+    addRoute(route: Route): void;
+    addRoutes(routes: (Route | NestedRoute)[]): void;
+    getRoutes(): Array<{
+        method: Method;
+        path: string;
+    }>;
 }