vafast 0.1.17 → 0.2.1

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

package/dist/router.js

@@ -0,0 +1,86 @@
+/**
+ * 路由工具函数
+ *
+ * 提供路由处理的基础工具
+ */
+/**
+ * 扁平化嵌套路由
+ *
+ * 将嵌套路由结构转换为扁平数组，计算完整路径和中间件链
+ *
+ * @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);
+            }
+        }
+    }
+    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;
+}

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

@@ -0,0 +1,34 @@
+import type { Middleware } from "../types";
+/**
+ * 服务器基类
+ * 包含所有服务器类型的公共逻辑
+ */
+export declare abstract class BaseServer {
+    protected globalMiddleware: Middleware[];
+    use(mw: Middleware): void;
+    /**
+     * 打印扁平化后的路由信息，用于调试
+     */
+    protected logFlattenedRoutes(routes: any[], type?: string): void;
+    /**
+     * 检测路由冲突
+     * 检查是否有路径相同但方法不同的路由，以及潜在的路径冲突
+     */
+    protected detectRouteConflicts(routes: any[]): void;
+    /**
+     * 检测动态路由的潜在冲突
+     */
+    private detectDynamicRouteConflicts;
+    /**
+     * 判断两个路径是否可能冲突
+     */
+    private pathsMayConflict;
+    /**
+     * 路径匹配
+     */
+    protected matchPath(pattern: string, path: string): boolean;
+    /**
+     * 提取路径参数
+     */
+    protected extractParams(pattern: string, path: string): Record<string, string>;
+}

package/dist/server/base-server.js

@@ -0,0 +1,145 @@
+/**
+ * 服务器基类
+ * 包含所有服务器类型的公共逻辑
+ */
+export class BaseServer {
+    globalMiddleware = [];
+    use(mw) {
+        this.globalMiddleware.push(mw);
+    }
+    /**
+     * 打印扁平化后的路由信息，用于调试
+     */
+    logFlattenedRoutes(routes, type = "路由") {
+        console.log(`🚀 扁平化后的${type}:`);
+        for (const route of routes) {
+            const method = route.method || "GET";
+            const path = route.fullPath || route.path;
+            console.log(`  ${method} ${path}`);
+            if (route.middlewareChain && route.middlewareChain.length > 0) {
+                console.log(`    中间件链: ${route.middlewareChain.length} 个`);
+            }
+        }
+        console.log("");
+    }
+    /**
+     * 检测路由冲突
+     * 检查是否有路径相同但方法不同的路由，以及潜在的路径冲突
+     */
+    detectRouteConflicts(routes) {
+        const pathGroups = new Map();
+        // 按路径分组
+        for (const route of routes) {
+            const path = route.fullPath || route.path;
+            const method = route.method || "GET";
+            if (!pathGroups.has(path)) {
+                pathGroups.set(path, []);
+            }
+            pathGroups.get(path).push({ ...route, method });
+        }
+        // 检查冲突
+        for (const [path, routeList] of pathGroups) {
+            if (routeList.length > 1) {
+                const methods = routeList.map((r) => r.method);
+                const uniqueMethods = [...new Set(methods)];
+                if (uniqueMethods.length === 1) {
+                    // 相同路径、相同方法 - 这是冲突！
+                    console.warn(`⚠️  路由冲突: ${uniqueMethods[0]} ${path} 定义了 ${routeList.length} 次`);
+                    routeList.forEach((route, index) => {
+                        console.warn(`   ${index + 1}. ${route.method} ${path}`);
+                    });
+                }
+                else {
+                    // 相同路径、不同方法 - 这是正常的
+                    console.log(`ℹ️  路径 ${path} 支持方法: ${uniqueMethods.join(", ")}`);
+                }
+            }
+        }
+        // 检查潜在的路径冲突（动态路由可能冲突）
+        this.detectDynamicRouteConflicts(routes);
+    }
+    /**
+     * 检测动态路由的潜在冲突
+     */
+    detectDynamicRouteConflicts(routes) {
+        const dynamicRoutes = routes.filter((r) => {
+            const path = r.fullPath || r.path;
+            return path.includes(":") || path.includes("*");
+        });
+        for (let i = 0; i < dynamicRoutes.length; i++) {
+            for (let j = i + 1; j < dynamicRoutes.length; j++) {
+                const route1 = dynamicRoutes[i];
+                const route2 = dynamicRoutes[j];
+                const method1 = route1.method || "GET";
+                const method2 = route2.method || "GET";
+                if (method1 === method2) {
+                    const path1 = route1.fullPath || route1.path;
+                    const path2 = route2.fullPath || route2.path;
+                    // 检查路径是否可能冲突
+                    if (this.pathsMayConflict(path1, path2)) {
+                        console.warn(`⚠️  潜在路由冲突: ${method1} ${path1} 可能与 ${path2} 冲突`);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * 判断两个路径是否可能冲突
+     */
+    pathsMayConflict(path1, path2) {
+        const parts1 = path1.split("/").filter(Boolean);
+        const parts2 = path2.split("/").filter(Boolean);
+        if (parts1.length !== parts2.length)
+            return false;
+        for (let i = 0; i < parts1.length; i++) {
+            const p1 = parts1[i];
+            const p2 = parts2[i];
+            // 如果两个部分都是静态的且不同，则不会冲突
+            if (!p1.startsWith(":") &&
+                !p1.startsWith("*") &&
+                !p2.startsWith(":") &&
+                !p2.startsWith("*") &&
+                p1 !== p2) {
+                return false;
+            }
+            // 如果一个是通配符，另一个是动态参数，可能冲突
+            if ((p1 === "*" && p2.startsWith(":")) ||
+                (p2 === "*" && p1.startsWith(":"))) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * 路径匹配
+     */
+    matchPath(pattern, path) {
+        const patternParts = pattern.split("/").filter(Boolean);
+        const pathParts = path.split("/").filter(Boolean);
+        if (patternParts.length !== pathParts.length) {
+            return false;
+        }
+        for (let i = 0; i < patternParts.length; i++) {
+            if (patternParts[i] !== pathParts[i] &&
+                !patternParts[i].startsWith(":")) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * 提取路径参数
+     */
+    extractParams(pattern, path) {
+        const params = {};
+        const patternParts = pattern.split("/").filter(Boolean);
+        const pathParts = path.split("/").filter(Boolean);
+        for (let i = 0; i < patternParts.length; i++) {
+            if (patternParts[i].startsWith(":")) {
+                const paramName = patternParts[i].slice(1);
+                params[paramName] = pathParts[i];
+            }
+        }
+        return params;
+    }
+}

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

@@ -0,0 +1,32 @@
+import type { ComponentRoute, NestedComponentRoute } from "../types/component-route";
+import { BaseServer } from "./base-server";
+import { DependencyManager } from "../utils/dependency-manager";
+/**
+ * 组件路由服务器
+ * 专门处理声明式组件路由
+ */
+export declare class ComponentServer extends BaseServer {
+    private routes;
+    private dependencyManager;
+    constructor(routes: (ComponentRoute | NestedComponentRoute)[]);
+    /**
+     * 处理请求
+     */
+    fetch(req: Request): Promise<Response>;
+    /**
+     * 执行中间件链
+     */
+    private executeMiddlewareChain;
+    /**
+     * 渲染 Vue 组件
+     */
+    private renderVueComponent;
+    /**
+     * 渲染 React 组件
+     */
+    private renderReactComponent;
+    /**
+     * 获取依赖管理器（用于外部访问）
+     */
+    getDependencyManager(): DependencyManager;
+}

package/dist/server/component-server.js

@@ -0,0 +1,146 @@
+import { flattenComponentRoutes } from "../middleware/component-router";
+import { BaseServer } from "./base-server";
+import { PathMatcher } from "../utils/path-matcher";
+import { HtmlRenderer } from "../utils/html-renderer";
+import { DependencyManager } from "../utils/dependency-manager";
+/**
+ * 组件路由服务器
+ * 专门处理声明式组件路由
+ */
+export class ComponentServer extends BaseServer {
+    routes;
+    dependencyManager;
+    constructor(routes) {
+        super();
+        this.routes = flattenComponentRoutes(routes);
+        this.dependencyManager = new DependencyManager();
+        // 检测路由冲突
+        this.detectRouteConflicts(this.routes);
+        this.logFlattenedRoutes(this.routes, "组件路由");
+        console.log("🚀 依赖按需加载，服务器启动完成");
+    }
+    /**
+     * 处理请求
+     */
+    async fetch(req) {
+        const url = new URL(req.url);
+        const pathname = url.pathname;
+        const method = req.method;
+        // 只支持 GET 请求
+        if (method !== "GET") {
+            return new Response("Method Not Allowed", { status: 405 });
+        }
+        // 查找匹配的路由
+        let matchedRoute = null;
+        for (const route of this.routes) {
+            if (PathMatcher.matchPath(route.fullPath, pathname)) {
+                matchedRoute = route;
+                break;
+            }
+        }
+        if (!matchedRoute) {
+            return new Response("Not Found", { status: 404 });
+        }
+        try {
+            // 创建中间件上下文
+            const context = {
+                req,
+                params: PathMatcher.extractParams(matchedRoute.fullPath, pathname),
+                query: Object.fromEntries(url.searchParams),
+                pathname,
+            };
+            // 执行中间件链，中间件会处理组件渲染
+            return await this.executeMiddlewareChain(matchedRoute.middlewareChain, context, matchedRoute.component);
+        }
+        catch (error) {
+            console.error("组件渲染失败:", error);
+            return new Response("Internal Server Error", { status: 500 });
+        }
+    }
+    /**
+     * 执行中间件链
+     */
+    async executeMiddlewareChain(middlewareChain, context, componentImport) {
+        // 创建最终的渲染函数
+        const renderComponent = async () => {
+            const componentModule = await componentImport();
+            const component = componentModule.default || componentModule;
+            // 自动检测组件类型
+            const componentType = this.dependencyManager.detectComponentType(component);
+            // 按需加载依赖
+            const deps = await this.dependencyManager.getFrameworkDeps(componentType);
+            // 根据组件类型渲染
+            if (componentType === "vue") {
+                return await this.renderVueComponent(component, context, deps);
+            }
+            else if (componentType === "react") {
+                return await this.renderReactComponent(component, context, deps);
+            }
+            else {
+                throw new Error(`不支持的组件类型: ${componentType}`);
+            }
+        };
+        // 执行中间件链
+        let index = 0;
+        const next = async () => {
+            if (index >= middlewareChain.length) {
+                return await renderComponent();
+            }
+            const middleware = middlewareChain[index++];
+            return await middleware(context.req, next);
+        };
+        return await next();
+    }
+    /**
+     * 渲染 Vue 组件
+     */
+    async renderVueComponent(component, context, deps) {
+        try {
+            const [vue, renderer] = deps;
+            const app = vue.createSSRApp(component);
+            // 提供路由信息
+            app.provide("routeInfo", {
+                params: context.params || {},
+                query: context.query || {},
+                pathname: context.pathname,
+            });
+            const html = await renderer.renderToString(app);
+            const fullHtml = HtmlRenderer.generateVueHtml(html, context);
+            return new Response(fullHtml, {
+                headers: { "Content-Type": "text/html; charset=utf-8" },
+            });
+        }
+        catch (error) {
+            console.error("Vue 组件渲染失败:", error);
+            return new Response("Vue Component Render Error", { status: 500 });
+        }
+    }
+    /**
+     * 渲染 React 组件
+     */
+    async renderReactComponent(component, context, deps) {
+        try {
+            const [react, renderer] = deps;
+            const content = react.createElement(component, {
+                req: context.req,
+                params: context.params || {},
+                query: context.query || {},
+            });
+            const html = renderer.renderToString(content);
+            const fullHtml = HtmlRenderer.generateReactHtml(html, context);
+            return new Response(fullHtml, {
+                headers: { "Content-Type": "text/html; charset=utf-8" },
+            });
+        }
+        catch (error) {
+            console.error("React 组件渲染失败:", error);
+            return new Response("React Component Render Error", { status: 500 });
+        }
+    }
+    /**
+     * 获取依赖管理器（用于外部访问）
+     */
+    getDependencyManager() {
+        return this.dependencyManager;
+    }
+}

package/dist/server/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 服务器模块导出
+ */
+export { Server } from "./server";
+export { ComponentServer } from "./component-server";
+export { ServerFactory } from "./server-factory";
+export { BaseServer } from "./base-server";