vafast 0.3.1 → 0.3.4

package/dist/server/server-factory.js

@@ -1,70 +1,982 @@
-import { Server } from "../server";
-import { ComponentServer } from "./component-server";
-/**
- * 服务器工厂类
- * 用于创建和管理不同类型的服务器
- */
-export class ServerFactory {
-    servers = new Map();
-    /**
-     * 创建标准REST API服务器
-     */
-    createRestServer(routes) {
-        const server = new Server(routes);
-        this.servers.set("rest", server);
-        return server;
-    }
-    /**
-     * 创建组件服务器
-     */
-    createComponentServer(routes) {
-        const server = new ComponentServer(routes);
-        this.servers.set("component", server);
-        return server;
-    }
-    /**
-     * 获取指定类型的服务器
-     */
-    getServer(type) {
-        return this.servers.get(type);
-    }
-    /**
-     * 获取所有服务器
-     */
-    getAllServers() {
-        return this.servers;
-    }
-    /**
-     * 移除指定类型的服务器
-     */
-    removeServer(type) {
-        return this.servers.delete(type);
-    }
-    /**
-     * 清除所有服务器
-     */
-    clearServers() {
-        this.servers.clear();
-    }
-    /**
-     * 获取服务器状态信息
-     */
-    getServerStatus() {
-        const status = {};
-        for (const [name, server] of this.servers) {
-            if (server instanceof Server) {
-                status[name] = {
-                    type: "REST API",
-                    routes: server.routes?.length || 0,
-                };
-            }
-            else if (server instanceof ComponentServer) {
-                status[name] = {
-                    type: "Component",
-                    routes: server.routes?.length || 0,
-                };
-            }
+// 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;
+}
+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;
+}
+
+// src/utils/response.ts
+function json(data, status = 200, headers = {}) {
+  const body = JSON.stringify(data);
+  if (Object.keys(headers).length === 0) {
+    return new Response(body, {
+      status,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  const h = new Headers({
+    "Content-Type": "application/json",
+    ...headers
+  });
+  return new Response(body, {
+    status,
+    headers: h
+  });
+}
+var JSON_HEADERS = { "Content-Type": "application/json" };
+var TEXT_HEADERS = { "Content-Type": "text/plain" };
+function mapResponse(response) {
+  if (response instanceof Response) return response;
+  switch (response?.constructor?.name) {
+    case "String":
+      return new Response(response, { headers: TEXT_HEADERS });
+    case "Object":
+    case "Array":
+      return new Response(JSON.stringify(response), { headers: JSON_HEADERS });
+    case "Number":
+    case "Boolean":
+      return new Response(String(response), { headers: TEXT_HEADERS });
+    case void 0:
+      return new Response(null, { status: 204 });
+    case "ReadableStream":
+      return new Response(response);
+    case "Blob":
+      return new Response(response);
+    case "ArrayBuffer":
+      return new Response(response);
+    case "Uint8Array":
+      return new Response(response);
+    default:
+      if (response instanceof Promise) {
+        return response.then(mapResponse);
+      }
+      return new Response(JSON.stringify(response), { headers: JSON_HEADERS });
+  }
+}
+
+// src/middleware.ts
+var VafastError = class extends Error {
+  status;
+  type;
+  expose;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "VafastError";
+    this.status = options.status ?? 500;
+    this.type = options.type ?? "internal_error";
+    this.expose = options.expose ?? false;
+    if (options.cause) this.cause = options.cause;
+  }
+};
+function composeMiddleware(middleware, finalHandler) {
+  const all = [errorHandler, ...middleware];
+  return function composedHandler(req) {
+    let i = -1;
+    const dispatch = (index) => {
+      if (index <= i)
+        return Promise.reject(new Error("next() called multiple times"));
+      i = index;
+      if (index < all.length) {
+        const mw = all[index];
+        return Promise.resolve(mw(req, () => dispatch(index + 1)));
+      }
+      return Promise.resolve(finalHandler(req)).then(mapResponse);
+    };
+    return dispatch(0);
+  };
+}
+var errorHandler = async (req, next) => {
+  try {
+    return await next();
+  } catch (err) {
+    console.error("\u672A\u5904\u7406\u7684\u9519\u8BEF:", err);
+    if (err instanceof VafastError) {
+      return json(
+        {
+          error: err.type,
+          message: err.expose ? err.message : "\u53D1\u751F\u4E86\u4E00\u4E2A\u9519\u8BEF"
+        },
+        err.status
+      );
+    }
+    return json({ error: "internal_error", message: "\u51FA\u73B0\u4E86\u4E00\u4E9B\u95EE\u9898" }, 500);
+  }
+};
+
+// src/server/base-server.ts
+var BaseServer = class {
+  globalMiddleware = [];
+  use(mw) {
+    this.globalMiddleware.push(mw);
+  }
+  /**
+   * 打印扁平化后的路由信息，用于调试
+   */
+  logFlattenedRoutes(routes, type = "\u8DEF\u7531") {
+    console.log(`\u{1F680} \u6241\u5E73\u5316\u540E\u7684${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(`    \u4E2D\u95F4\u4EF6\u94FE: ${route.middlewareChain.length} \u4E2A`);
+      }
+    }
+    console.log("");
+  }
+  /**
+   * 检测路由冲突
+   * 检查是否有路径相同但方法不同的路由，以及潜在的路径冲突
+   */
+  detectRouteConflicts(routes) {
+    const pathGroups = /* @__PURE__ */ 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(
+            `\u26A0\uFE0F  \u8DEF\u7531\u51B2\u7A81: ${uniqueMethods[0]} ${path} \u5B9A\u4E49\u4E86 ${routeList.length} \u6B21`
+          );
+          routeList.forEach((route, index) => {
+            console.warn(`   ${index + 1}. ${route.method} ${path}`);
+          });
+        } else {
+          console.log(`\u2139\uFE0F  \u8DEF\u5F84 ${path} \u652F\u6301\u65B9\u6CD5: ${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(
+              `\u26A0\uFE0F  \u6F5C\u5728\u8DEF\u7531\u51B2\u7A81: ${method1} ${path1} \u53EF\u80FD\u4E0E ${path2} \u51B2\u7A81`
+            );
+          }
         }
-        return status;
+      }
+    }
+  }
+  /**
+   * 判断两个路径是否可能冲突
+   */
+  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;
+  }
+};
+
+// 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];
+      }
+    }
+    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;
+      }
+    }
+    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);
+    }
+  }
+};
+
+// src/server/server.ts
+var Server = class extends BaseServer {
+  router;
+  routes;
+  /** 是否已预编译 */
+  isCompiled = false;
+  /** 预编译时的全局中间件数量 */
+  compiledWithMiddlewareCount = 0;
+  constructor(routes = []) {
+    super();
+    this.router = new RadixRouter();
+    this.routes = [];
+    this.router.setCompiler(
+      (middleware, handler) => composeMiddleware(middleware, handler)
+    );
+    if (routes.length > 0) {
+      this.registerRoutes(routes);
+    }
+  }
+  /**
+   * 预编译所有路由处理链
+   * 在添加所有路由和全局中间件后调用，可提升运行时性能
+   */
+  compile() {
+    this.router.precompileAll(this.globalMiddleware);
+    this.isCompiled = true;
+    this.compiledWithMiddlewareCount = this.globalMiddleware.length;
+    return this;
+  }
+  registerRoutes(routes) {
+    const flattened = flattenNestedRoutes(routes);
+    this.routes.push(...flattened);
+    for (const route of flattened) {
+      this.router.register(
+        route.method,
+        route.fullPath,
+        route.handler,
+        route.middlewareChain || []
+      );
+    }
+    this.detectRouteConflicts(flattened);
+    this.logFlattenedRoutes(flattened);
+    if (this.globalMiddleware.length === 0 && !this.isCompiled) {
+      this.compile();
+    }
+  }
+  /** 快速提取 pathname */
+  extractPathname(url) {
+    let start = url.indexOf("://");
+    start = start === -1 ? 0 : start + 3;
+    const pathStart = url.indexOf("/", start);
+    if (pathStart === -1) return "/";
+    let end = url.indexOf("?", pathStart);
+    if (end === -1) end = url.indexOf("#", pathStart);
+    if (end === -1) end = url.length;
+    return url.substring(pathStart, end) || "/";
+  }
+  /** 处理请求 */
+  fetch = async (req) => {
+    const pathname = this.extractPathname(req.url);
+    const method = req.method;
+    const match = this.router.match(method, pathname);
+    if (match) {
+      req.params = match.params;
+      if (match.compiled && this.globalMiddleware.length === this.compiledWithMiddlewareCount) {
+        return match.compiled(req);
+      }
+      const allMiddleware = [...this.globalMiddleware, ...match.middleware];
+      const handler = composeMiddleware(allMiddleware, match.handler);
+      return handler(req);
+    }
+    const allowedMethods = this.router.getAllowedMethods(pathname);
+    if (allowedMethods.length > 0) {
+      return json(
+        {
+          success: false,
+          error: "Method Not Allowed",
+          message: `Method ${method} not allowed for this endpoint`,
+          allowedMethods
+        },
+        405,
+        { Allow: allowedMethods.join(", ") }
+      );
+    }
+    return json({ success: false, error: "Not Found" }, 404);
+  };
+  addRoute(route) {
+    const flattenedRoute = {
+      ...route,
+      fullPath: route.path,
+      middlewareChain: route.middleware || []
+    };
+    this.routes.push(flattenedRoute);
+    this.router.register(
+      route.method,
+      route.path,
+      route.handler,
+      route.middleware || []
+    );
+  }
+  addRoutes(routes) {
+    this.registerRoutes(routes);
+  }
+  getRoutes() {
+    return this.router.getRoutes();
+  }
+};
+
+// src/middleware/component-router.ts
+function flattenComponentRoutes(routes) {
+  const flattened = [];
+  function processRoute(route, parentPath = "", parentMiddleware = []) {
+    const currentPath = parentPath + route.path;
+    const currentMiddleware = [
+      ...parentMiddleware,
+      ...route.middleware || []
+    ];
+    if ("component" 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;
 }
+
+// src/utils/path-matcher.ts
+var PathMatcher = class {
+  /**
+   * 路径匹配
+   */
+  static 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;
+  }
+  /**
+   * 提取路径参数
+   */
+  static 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;
+  }
+  /**
+   * 计算路径特异性分数
+   * 用于路由排序：静态 > 动态(:param) > 通配符(*)
+   */
+  static calculatePathScore(path) {
+    const parts = path.split("/").filter(Boolean);
+    let score = 0;
+    for (const p of parts) {
+      if (p === "*")
+        score += 1;
+      else if (p.startsWith(":"))
+        score += 2;
+      else score += 3;
+    }
+    return score * 10 + parts.length;
+  }
+  /**
+   * 判断两个路径是否可能冲突
+   */
+  static 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;
+  }
+};
+
+// src/utils/html-renderer.ts
+var HtmlRenderer = class {
+  /**
+   * 生成基础HTML模板
+   */
+  static generateBaseHtml(content, context, clientScriptPath = "/client.js") {
+    return `
+      <!doctype html>
+      <html>
+        <head>
+          <meta charset="utf-8">
+          <title>Vafast SSR App</title>
+          <meta name="viewport" content="width=device-width, initial-scale=1">
+        </head>
+        <body>
+          <div id="app">${content}</div>
+          <script>
+            window.__ROUTE_INFO__ = {
+              params: ${JSON.stringify(context.params || {})},
+              query: ${JSON.stringify(context.query || {})},
+              pathname: '${context.pathname}'
+            };
+          </script>
+          <script type="module" src="${clientScriptPath}"></script>
+        </body>
+      </html>
+    `;
+  }
+  /**
+   * 生成Vue组件HTML
+   */
+  static generateVueHtml(content, context, clientScriptPath = "/client.js") {
+    return this.generateBaseHtml(content, context, clientScriptPath);
+  }
+  /**
+   * 生成React组件HTML
+   */
+  static generateReactHtml(content, context, clientScriptPath = "/client.js") {
+    return `
+      <!doctype html>
+      <html>
+        <head>
+          <meta charset="utf-8">
+          <title>Vafast SSR App</title>
+          <meta name="viewport" content="width=device-width, initial-scale=1">
+        </head>
+        <body>
+          <div id="root">${content}</div>
+          <script>
+            window.__ROUTE_INFO__ = {
+              params: ${JSON.stringify(context.params || {})},
+              query: ${JSON.stringify(context.query || {})},
+              pathname: '${context.pathname}'
+            };
+          </script>
+          <script type="module" src="${clientScriptPath}"></script>
+        </body>
+      </html>
+    `;
+  }
+};
+
+// src/utils/dependency-manager.ts
+var DependencyManager = class {
+  dependencyCache = /* @__PURE__ */ new Map();
+  /**
+   * 按需获取框架依赖
+   */
+  async getFrameworkDeps(framework) {
+    if (this.dependencyCache.has(framework)) {
+      return this.dependencyCache.get(framework);
+    }
+    console.log(`\u{1F4E6} \u6309\u9700\u52A0\u8F7D ${framework} \u4F9D\u8D56...`);
+    try {
+      let deps;
+      switch (framework) {
+        case "vue":
+          deps = await Promise.all([
+            import("vue"),
+            import("@vue/server-renderer")
+          ]);
+          break;
+        case "react":
+          deps = await Promise.all([
+            import("react"),
+            import("react-dom/server")
+          ]);
+          break;
+        default:
+          throw new Error(`\u4E0D\u652F\u6301\u7684\u6846\u67B6: ${framework}`);
+      }
+      this.dependencyCache.set(framework, deps);
+      console.log(`\u2705 ${framework} \u4F9D\u8D56\u52A0\u8F7D\u5B8C\u6210`);
+      return deps;
+    } catch (error) {
+      console.error(`\u274C ${framework} \u4F9D\u8D56\u52A0\u8F7D\u5931\u8D25:`, error);
+      throw error;
+    }
+  }
+  /**
+   * 检测组件类型
+   */
+  detectComponentType(component) {
+    if (component.render && typeof component.render === "function") {
+      return "vue";
+    }
+    if (component.$$typeof) {
+      return "react";
+    }
+    return "vue";
+  }
+  /**
+   * 清除缓存
+   */
+  clearCache() {
+    this.dependencyCache.clear();
+    console.log("\u{1F9F9} \u4F9D\u8D56\u7F13\u5B58\u5DF2\u6E05\u9664");
+  }
+  /**
+   * 获取缓存状态
+   */
+  getCacheStatus() {
+    const status = {};
+    for (const [framework] of this.dependencyCache) {
+      status[framework] = true;
+    }
+    return status;
+  }
+};
+
+// src/server/component-server.ts
+var ComponentServer = class extends BaseServer {
+  routes;
+  dependencyManager;
+  constructor(routes) {
+    super();
+    this.routes = flattenComponentRoutes(routes);
+    this.dependencyManager = new DependencyManager();
+    this.detectRouteConflicts(this.routes);
+    this.logFlattenedRoutes(this.routes, "\u7EC4\u4EF6\u8DEF\u7531");
+    console.log("\u{1F680} \u4F9D\u8D56\u6309\u9700\u52A0\u8F7D\uFF0C\u670D\u52A1\u5668\u542F\u52A8\u5B8C\u6210");
+  }
+  /**
+   * 处理请求
+   */
+  async fetch(req) {
+    const url = new URL(req.url);
+    const pathname = url.pathname;
+    const method = req.method;
+    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("\u7EC4\u4EF6\u6E32\u67D3\u5931\u8D25:", 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(`\u4E0D\u652F\u6301\u7684\u7EC4\u4EF6\u7C7B\u578B: ${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 \u7EC4\u4EF6\u6E32\u67D3\u5931\u8D25:", 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 \u7EC4\u4EF6\u6E32\u67D3\u5931\u8D25:", error);
+      return new Response("React Component Render Error", { status: 500 });
+    }
+  }
+  /**
+   * 获取依赖管理器（用于外部访问）
+   */
+  getDependencyManager() {
+    return this.dependencyManager;
+  }
+};
+
+// src/server/server-factory.ts
+var ServerFactory = class {
+  servers = /* @__PURE__ */ new Map();
+  /**
+   * 创建标准REST API服务器
+   */
+  createRestServer(routes) {
+    const server = new Server(routes);
+    this.servers.set("rest", server);
+    return server;
+  }
+  /**
+   * 创建组件服务器
+   */
+  createComponentServer(routes) {
+    const server = new ComponentServer(routes);
+    this.servers.set("component", server);
+    return server;
+  }
+  /**
+   * 获取指定类型的服务器
+   */
+  getServer(type) {
+    return this.servers.get(type);
+  }
+  /**
+   * 获取所有服务器
+   */
+  getAllServers() {
+    return this.servers;
+  }
+  /**
+   * 移除指定类型的服务器
+   */
+  removeServer(type) {
+    return this.servers.delete(type);
+  }
+  /**
+   * 清除所有服务器
+   */
+  clearServers() {
+    this.servers.clear();
+  }
+  /**
+   * 获取服务器状态信息
+   */
+  getServerStatus() {
+    const status = {};
+    for (const [name, server] of this.servers) {
+      if (server instanceof Server) {
+        status[name] = {
+          type: "REST API",
+          routes: server.routes?.length || 0
+        };
+      } else if (server instanceof ComponentServer) {
+        status[name] = {
+          type: "Component",
+          routes: server.routes?.length || 0
+        };
+      }
+    }
+    return status;
+  }
+};
+export {
+  ServerFactory
+};
+//# sourceMappingURL=server-factory.js.map