@ereo/router 0.1.6

package/dist/index.js

@@ -0,0 +1,1507 @@
+// @bun
+var __require = import.meta.require;
+
+// src/file-router.ts
+import { readdir, stat } from "fs/promises";
+import { join, extname } from "path";
+
+// src/types.ts
+var ROUTE_SCORE = {
+  STATIC: 100,
+  INDEX: 90,
+  DYNAMIC: 50,
+  OPTIONAL: 30,
+  CATCH_ALL: 10
+};
+var SPECIAL_FILES = {
+  LAYOUT: "_layout",
+  ERROR: "_error",
+  LOADING: "_loading",
+  NOT_FOUND: "_404"
+};
+var ROUTE_GROUP_PATTERN = /^\((.+)\)$/;
+var DYNAMIC_SEGMENT_PATTERN = /^\[([^\]]+)\]$/;
+var CATCH_ALL_PATTERN = /^\[\.\.\.([^\]]+)\]$/;
+var OPTIONAL_PATTERN = /^\[\[([^\]]+)\]\]$/;
+
+// src/matcher.ts
+function parsePathSegments(path) {
+  const segments = [];
+  const parts = path.split("/").filter(Boolean);
+  for (const part of parts) {
+    const catchAllMatch = part.match(CATCH_ALL_PATTERN);
+    if (catchAllMatch) {
+      segments.push({
+        raw: part,
+        type: "catchAll",
+        paramName: catchAllMatch[1]
+      });
+      continue;
+    }
+    const optionalMatch = part.match(OPTIONAL_PATTERN);
+    if (optionalMatch) {
+      segments.push({
+        raw: part,
+        type: "optional",
+        paramName: optionalMatch[1]
+      });
+      continue;
+    }
+    const dynamicMatch = part.match(DYNAMIC_SEGMENT_PATTERN);
+    if (dynamicMatch) {
+      segments.push({
+        raw: part,
+        type: "dynamic",
+        paramName: dynamicMatch[1]
+      });
+      continue;
+    }
+    segments.push({
+      raw: part,
+      type: "static"
+    });
+  }
+  return segments;
+}
+function calculateRouteScore(segments) {
+  let score = 0;
+  for (let i = 0;i < segments.length; i++) {
+    const segment = segments[i];
+    const positionMultiplier = 1000 / (i + 1);
+    switch (segment.type) {
+      case "static":
+        score += ROUTE_SCORE.STATIC * positionMultiplier;
+        break;
+      case "dynamic":
+        score += ROUTE_SCORE.DYNAMIC * positionMultiplier;
+        break;
+      case "optional":
+        score += ROUTE_SCORE.OPTIONAL * positionMultiplier;
+        break;
+      case "catchAll":
+        score += ROUTE_SCORE.CATCH_ALL * positionMultiplier;
+        break;
+    }
+  }
+  return score;
+}
+function patternToRegex(segments) {
+  if (segments.length === 0) {
+    return /^\/$/;
+  }
+  let pattern = "^";
+  for (let i = 0;i < segments.length; i++) {
+    const segment = segments[i];
+    switch (segment.type) {
+      case "static":
+        pattern += `\\/${escapeRegex(segment.raw)}`;
+        break;
+      case "dynamic":
+        pattern += "\\/([^/]+)";
+        break;
+      case "optional":
+        pattern += "(?:\\/([^/]+))?";
+        break;
+      case "catchAll":
+        pattern += "(?:\\/(.+))?";
+        break;
+    }
+  }
+  pattern += "\\/?$";
+  return new RegExp(pattern);
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function matchRoute(pathname, route, segments) {
+  const regex = patternToRegex(segments);
+  const match = pathname.match(regex);
+  if (!match) {
+    return null;
+  }
+  const params = {};
+  let paramIndex = 1;
+  for (const segment of segments) {
+    if (segment.paramName) {
+      const value = match[paramIndex];
+      if (segment.type === "catchAll" && value) {
+        params[segment.paramName] = value.split("/");
+      } else if (value !== undefined) {
+        params[segment.paramName] = value;
+      }
+      paramIndex++;
+    }
+  }
+  return {
+    route,
+    params,
+    pathname
+  };
+}
+
+class RouteMatcher {
+  routes = [];
+  constructor(routes) {
+    this.compileRoutes(routes);
+  }
+  compileRoutes(routes) {
+    const flatRoutes = this.flattenRoutes(routes);
+    this.routes = flatRoutes.map((route) => {
+      const segments = parsePathSegments(route.path);
+      return {
+        route,
+        segments,
+        regex: patternToRegex(segments),
+        score: calculateRouteScore(segments)
+      };
+    }).sort((a, b) => b.score - a.score);
+  }
+  flattenRoutes(routes, parent) {
+    const result = [];
+    for (const route of routes) {
+      if (!route.layout || route.index) {
+        result.push(route);
+      }
+      if (route.children) {
+        result.push(...this.flattenRoutes(route.children, route));
+      }
+    }
+    return result;
+  }
+  match(pathname) {
+    const normalizedPath = pathname === "" ? "/" : pathname;
+    for (const { route, segments, regex } of this.routes) {
+      const match = normalizedPath.match(regex);
+      if (match) {
+        const params = {};
+        let paramIndex = 1;
+        for (const segment of segments) {
+          if (segment.paramName) {
+            const value = match[paramIndex];
+            if (segment.type === "catchAll" && value) {
+              params[segment.paramName] = value.split("/");
+            } else if (value !== undefined) {
+              params[segment.paramName] = value;
+            }
+            paramIndex++;
+          }
+        }
+        return {
+          route,
+          params,
+          pathname: normalizedPath
+        };
+      }
+    }
+    return null;
+  }
+  getRoutes() {
+    return this.routes.map((r) => r.route);
+  }
+  addRoute(route) {
+    const segments = parsePathSegments(route.path);
+    const entry = {
+      route,
+      segments,
+      regex: patternToRegex(segments),
+      score: calculateRouteScore(segments)
+    };
+    const insertIndex = this.routes.findIndex((r) => r.score < entry.score);
+    if (insertIndex === -1) {
+      this.routes.push(entry);
+    } else {
+      this.routes.splice(insertIndex, 0, entry);
+    }
+  }
+  removeRoute(routeId) {
+    const index = this.routes.findIndex((r) => r.route.id === routeId);
+    if (index !== -1) {
+      this.routes.splice(index, 1);
+      return true;
+    }
+    return false;
+  }
+}
+function createMatcher(routes) {
+  return new RouteMatcher(routes);
+}
+function matchWithLayouts(pathname, routes) {
+  const matcher = new RouteMatcher(routes);
+  const match = matcher.match(pathname);
+  if (!match) {
+    return null;
+  }
+  const layouts = [];
+  const collectLayouts = (routeList, currentPath) => {
+    for (const route of routeList) {
+      if (route.layout) {
+        const layoutPath = route.path === "/" ? "" : route.path;
+        const matchPath = match.pathname === "/" ? "" : match.pathname;
+        if (matchPath === layoutPath || matchPath.startsWith(layoutPath + "/") || layoutPath === "") {
+          layouts.push(route);
+        }
+      }
+      if (route.children) {
+        collectLayouts(route.children, currentPath + route.path);
+      }
+    }
+  };
+  collectLayouts(routes, "");
+  layouts.sort((a, b) => a.path.length - b.path.length);
+  return {
+    ...match,
+    layouts
+  };
+}
+
+// src/route-tree.ts
+class RouteTree {
+  root;
+  constructor() {
+    this.root = this.createNode("/", "/", "", false, false);
+  }
+  createNode(id, path, file, index, layout) {
+    const segments = parsePathSegments(path);
+    return {
+      id,
+      path,
+      segments,
+      file,
+      index,
+      layout,
+      children: [],
+      score: calculateRouteScore(segments)
+    };
+  }
+  addRoute(id, path, file, options = {}) {
+    const { index = false, layout = false } = options;
+    const node = this.createNode(id, path, file, index, layout);
+    const parent = this.findParent(path);
+    node.parent = parent;
+    parent.children.push(node);
+    parent.children.sort((a, b) => b.score - a.score);
+    return node;
+  }
+  findParent(path) {
+    if (path === "/") {
+      return this.root;
+    }
+    const segments = path.split("/").filter(Boolean);
+    segments.pop();
+    if (segments.length === 0) {
+      return this.root;
+    }
+    let current = this.root;
+    let currentPath = "";
+    for (const segment of segments) {
+      currentPath += "/" + segment;
+      const child = current.children.find((c) => c.path === currentPath || c.layout);
+      if (child) {
+        current = child;
+      }
+    }
+    return current;
+  }
+  getRoot() {
+    return this.root;
+  }
+  toRoutes() {
+    return this.nodeToRoute(this.root).children || [];
+  }
+  nodeToRoute(node) {
+    const route = {
+      id: node.id,
+      path: node.path,
+      file: node.file,
+      index: node.index,
+      layout: node.layout
+    };
+    if (node.children.length > 0) {
+      route.children = node.children.map((child) => this.nodeToRoute(child));
+    }
+    if (node.module) {
+      route.module = node.module;
+    }
+    return route;
+  }
+  findByPath(path) {
+    const search = (node) => {
+      if (node.path === path) {
+        return node;
+      }
+      for (const child of node.children) {
+        const found = search(child);
+        if (found)
+          return found;
+      }
+      return null;
+    };
+    return search(this.root);
+  }
+  findById(id) {
+    const search = (node) => {
+      if (node.id === id) {
+        return node;
+      }
+      for (const child of node.children) {
+        const found = search(child);
+        if (found)
+          return found;
+      }
+      return null;
+    };
+    return search(this.root);
+  }
+  removeById(id) {
+    const remove = (parent) => {
+      const index = parent.children.findIndex((c) => c.id === id);
+      if (index !== -1) {
+        parent.children.splice(index, 1);
+        return true;
+      }
+      for (const child of parent.children) {
+        if (remove(child))
+          return true;
+      }
+      return false;
+    };
+    return remove(this.root);
+  }
+  flatten() {
+    const result = [];
+    const collect = (node) => {
+      if (node !== this.root) {
+        result.push(node);
+      }
+      for (const child of node.children) {
+        collect(child);
+      }
+    };
+    collect(this.root);
+    return result;
+  }
+  getLayouts() {
+    return this.flatten().filter((n) => n.layout);
+  }
+  getLayoutChain(routeId) {
+    const node = this.findById(routeId);
+    if (!node)
+      return [];
+    const layouts = [];
+    let current = node.parent;
+    while (current) {
+      if (current.layout) {
+        layouts.unshift(current);
+      }
+      current = current.parent;
+    }
+    return layouts;
+  }
+}
+function filePathToUrlPath(filePath, routesDir) {
+  let path = filePath.replace(routesDir, "").replace(/\.(tsx?|jsx?)$/, "");
+  const fileName = path.split("/").pop() || "";
+  const isLayout = fileName === SPECIAL_FILES.LAYOUT;
+  const isIndex = fileName === "index";
+  if (isLayout || isIndex) {
+    path = path.replace(/\/?(index|_layout)$/, "");
+  }
+  path = path.replace(/\/\([^)]+\)/g, "");
+  if (!path.startsWith("/")) {
+    path = "/" + path;
+  }
+  if (path !== "/" && path.endsWith("/")) {
+    path = path.slice(0, -1);
+  }
+  return {
+    path: path || "/",
+    index: isIndex,
+    layout: isLayout
+  };
+}
+function buildRouteTree(files, routesDir) {
+  const tree = new RouteTree;
+  const sortedFiles = [...files].sort((a, b) => {
+    const aIsLayout = a.relativePath.includes(SPECIAL_FILES.LAYOUT);
+    const bIsLayout = b.relativePath.includes(SPECIAL_FILES.LAYOUT);
+    if (aIsLayout && !bIsLayout)
+      return -1;
+    if (!aIsLayout && bIsLayout)
+      return 1;
+    return a.relativePath.localeCompare(b.relativePath);
+  });
+  for (const file of sortedFiles) {
+    const { path, index, layout } = filePathToUrlPath(file.relativePath, routesDir);
+    const id = file.relativePath.replace(/\.(tsx?|jsx?)$/, "");
+    tree.addRoute(id, path, file.absolutePath, { index, layout });
+  }
+  return tree;
+}
+function createRouteTree() {
+  return new RouteTree;
+}
+
+// src/route-config.ts
+var defaultRenderConfig = {
+  mode: "ssr",
+  streaming: { enabled: true }
+};
+var defaultIslandsConfig = {
+  defaultStrategy: "load",
+  disabled: false
+};
+var defaultProgressiveConfig = {
+  forms: { fallback: "server", redirect: "follow" },
+  prefetch: { trigger: "hover", data: true, ttl: 60000 }
+};
+function parseMiddleware(middleware) {
+  if (!middleware)
+    return;
+  if (!Array.isArray(middleware)) {
+    throw new Error("Middleware must be an array");
+  }
+  return middleware.map((item) => {
+    if (typeof item === "string")
+      return item;
+    if (typeof item === "function")
+      return item;
+    throw new Error(`Invalid middleware item: ${item}`);
+  });
+}
+function parseRenderConfig(config) {
+  if (!config || typeof config !== "object") {
+    return defaultRenderConfig;
+  }
+  const c = config;
+  const mode = c.mode || "ssr";
+  if (!["ssg", "ssr", "csr", "json", "xml"].includes(mode)) {
+    throw new Error(`Invalid render mode: ${mode}`);
+  }
+  return {
+    mode,
+    prerender: parsePrerenderConfig(c.prerender),
+    streaming: parseStreamingConfig(c.streaming),
+    csr: parseCSRConfig(c.csr)
+  };
+}
+function parsePrerenderConfig(config) {
+  if (!config || typeof config !== "object")
+    return;
+  const c = config;
+  return {
+    enabled: Boolean(c.enabled),
+    paths: parsePaths(c.paths),
+    revalidate: typeof c.revalidate === "number" ? c.revalidate : undefined,
+    tags: parseTags(c.tags),
+    fallback: c.fallback || "blocking"
+  };
+}
+function parsePaths(paths) {
+  if (!paths)
+    return;
+  if (Array.isArray(paths))
+    return paths;
+  if (typeof paths === "function")
+    return paths;
+  throw new Error("Invalid prerender paths");
+}
+function parseTags(tags) {
+  if (!tags)
+    return;
+  if (Array.isArray(tags))
+    return tags;
+  if (typeof tags === "function")
+    return tags;
+  throw new Error("Invalid cache tags");
+}
+function parseStreamingConfig(config) {
+  if (!config || typeof config !== "object")
+    return;
+  const c = config;
+  return {
+    enabled: Boolean(c.enabled),
+    suspenseBoundaries: Array.isArray(c.suspenseBoundaries) ? c.suspenseBoundaries : undefined
+  };
+}
+function parseCSRConfig(config) {
+  if (!config || typeof config !== "object")
+    return;
+  const c = config;
+  return {
+    enabled: Boolean(c.enabled),
+    clientLoader: typeof c.clientLoader === "function" ? c.clientLoader : undefined
+  };
+}
+function parseIslandsConfig(config) {
+  if (!config || typeof config !== "object") {
+    return defaultIslandsConfig;
+  }
+  const c = config;
+  const strategies = ["load", "idle", "visible", "media", "none"];
+  const defaultStrategy = c.defaultStrategy || "load";
+  if (!strategies.includes(defaultStrategy)) {
+    throw new Error(`Invalid hydration strategy: ${defaultStrategy}`);
+  }
+  return {
+    defaultStrategy,
+    components: Array.isArray(c.components) ? c.components : undefined,
+    disabled: Boolean(c.disabled)
+  };
+}
+function parseCacheConfig(config) {
+  if (!config || typeof config !== "object")
+    return;
+  const c = config;
+  return {
+    edge: parseEdgeCache(c.edge),
+    browser: parseBrowserCache(c.browser),
+    data: parseDataCache(c.data)
+  };
+}
+function parseEdgeCache(config) {
+  if (!config || typeof config !== "object")
+    return;
+  const c = config;
+  return {
+    maxAge: typeof c.maxAge === "number" ? c.maxAge : 0,
+    staleWhileRevalidate: typeof c.staleWhileRevalidate === "number" ? c.staleWhileRevalidate : undefined,
+    vary: Array.isArray(c.vary) ? c.vary : undefined,
+    keyGenerator: typeof c.keyGenerator === "function" ? c.keyGenerator : undefined
+  };
+}
+function parseBrowserCache(config) {
+  if (!config || typeof config !== "object")
+    return;
+  const c = config;
+  return {
+    maxAge: typeof c.maxAge === "number" ? c.maxAge : 0,
+    private: Boolean(c.private)
+  };
+}
+function parseDataCache(config) {
+  if (!config || typeof config !== "object")
+    return;
+  const c = config;
+  return {
+    key: typeof c.key === "string" ? c.key : typeof c.key === "function" ? c.key : undefined,
+    tags: parseTags(c.tags)
+  };
+}
+function parseProgressiveConfig(config) {
+  if (!config || typeof config !== "object") {
+    return defaultProgressiveConfig;
+  }
+  const c = config;
+  return {
+    forms: parseFormsConfig(c.forms),
+    prefetch: parsePrefetchConfig(c.prefetch)
+  };
+}
+function parseFormsConfig(config) {
+  if (!config || typeof config !== "object") {
+    return defaultProgressiveConfig.forms;
+  }
+  const c = config;
+  const fallback = c.fallback || "server";
+  if (!["server", "spa"].includes(fallback)) {
+    throw new Error(`Invalid form fallback: ${fallback}`);
+  }
+  return {
+    fallback,
+    redirect: c.redirect || "follow"
+  };
+}
+function parsePrefetchConfig(config) {
+  if (!config || typeof config !== "object") {
+    return defaultProgressiveConfig.prefetch;
+  }
+  const c = config;
+  const trigger = c.trigger || "hover";
+  if (!["hover", "visible", "intent", "never"].includes(trigger)) {
+    throw new Error(`Invalid prefetch trigger: ${trigger}`);
+  }
+  return {
+    trigger,
+    data: Boolean(c.data),
+    ttl: typeof c.ttl === "number" ? c.ttl : 60000
+  };
+}
+function parseAuthConfig(config) {
+  if (!config || typeof config !== "object")
+    return;
+  const c = config;
+  return {
+    required: Boolean(c.required),
+    roles: Array.isArray(c.roles) ? c.roles : undefined,
+    permissions: Array.isArray(c.permissions) ? c.permissions : undefined,
+    check: typeof c.check === "function" ? c.check : undefined,
+    redirect: typeof c.redirect === "string" ? c.redirect : undefined,
+    unauthorized: typeof c.unauthorized === "object" ? c.unauthorized : undefined
+  };
+}
+function parseDevConfig(config) {
+  if (!config || typeof config !== "object")
+    return;
+  const c = config;
+  return {
+    mock: parseMockConfig(c.mock),
+    latency: typeof c.latency === "number" ? c.latency : undefined,
+    errorRate: typeof c.errorRate === "number" ? c.errorRate : undefined
+  };
+}
+function parseMockConfig(config) {
+  if (!config || typeof config !== "object")
+    return;
+  const c = config;
+  return {
+    enabled: Boolean(c.enabled),
+    data: typeof c.data === "object" ? c.data : undefined
+  };
+}
+function parseVariants(config) {
+  if (config === undefined)
+    return;
+  if (!Array.isArray(config)) {
+    throw new Error("Variants must be an array");
+  }
+  return config.map((variant, index) => {
+    if (!variant || typeof variant !== "object") {
+      throw new Error(`Invalid variant at index ${index}`);
+    }
+    const v = variant;
+    if (!v.path || typeof v.path !== "string") {
+      throw new Error(`Variant at index ${index} missing path`);
+    }
+    return {
+      path: v.path,
+      params: typeof v.params === "object" ? v.params : undefined,
+      config: v.config ? parseRouteConfig(v.config) : undefined
+    };
+  });
+}
+function parseRouteConfig(config) {
+  if (!config || typeof config !== "object") {
+    return {};
+  }
+  const c = config;
+  return {
+    middleware: parseMiddleware(c.middleware),
+    render: parseRenderConfig(c.render),
+    islands: parseIslandsConfig(c.islands),
+    cache: parseCacheConfig(c.cache),
+    progressive: parseProgressiveConfig(c.progressive),
+    auth: parseAuthConfig(c.auth),
+    dev: parseDevConfig(c.dev),
+    variants: parseVariants(c.variants)
+  };
+}
+function mergeRouteConfigs(parent, child) {
+  if (!parent)
+    return child || {};
+  if (!child)
+    return parent;
+  return {
+    middleware: [...parent.middleware || [], ...child.middleware || []],
+    render: child.render || parent.render,
+    islands: child.islands || parent.islands,
+    cache: child.cache || parent.cache,
+    progressive: child.progressive || parent.progressive,
+    route: child.route || parent.route,
+    auth: child.auth || parent.auth,
+    dev: child.dev || parent.dev,
+    variants: child.variants || parent.variants
+  };
+}
+
+// src/file-router.ts
+var defaultOptions = {
+  routesDir: "app/routes",
+  basePath: "",
+  extensions: [".tsx", ".ts", ".jsx", ".js"],
+  watch: false
+};
+
+class FileRouter {
+  options;
+  routesDir;
+  routes = [];
+  tree = null;
+  matcher = null;
+  watcher = null;
+  eventHandlers = {};
+  constructor(options = {}) {
+    this.options = { ...defaultOptions, ...options };
+    const routesDir = this.options.routesDir;
+    this.routesDir = routesDir.startsWith("/") ? routesDir : join(process.cwd(), routesDir);
+  }
+  async init() {
+    await this.discoverRoutes();
+    if (this.options.watch) {
+      this.startWatching();
+    }
+  }
+  async discoverRoutes() {
+    const files = await this.scanDirectory(this.routesDir);
+    this.tree = buildRouteTree(files.map((f) => ({
+      relativePath: f.relativePath,
+      absolutePath: f.absolutePath
+    })), "");
+    this.routes = this.tree.toRoutes();
+    this.matcher = createMatcher(this.routes);
+    this.emit("reload", this.routes);
+    return this.routes;
+  }
+  async scanDirectory(dir, base = "") {
+    const files = [];
+    try {
+      const entries = await readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        const relativePath = join(base, entry.name);
+        if (entry.isDirectory()) {
+          const subFiles = await this.scanDirectory(fullPath, relativePath);
+          files.push(...subFiles);
+        } else if (entry.isFile()) {
+          const ext = extname(entry.name);
+          if (this.options.extensions.includes(ext)) {
+            files.push({
+              relativePath: "/" + relativePath,
+              absolutePath: fullPath,
+              extension: ext
+            });
+          }
+        }
+      }
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+    return files;
+  }
+  startWatching() {
+    this.watchWithNode();
+  }
+  watchWithNode() {
+    const { watch } = __require("fs");
+    try {
+      this.watcher = watch(this.routesDir, { recursive: true }, (event, filename) => {
+        if (!filename)
+          return;
+        const ext = extname(filename);
+        if (!this.options.extensions.includes(ext))
+          return;
+        this.handleFileChange(filename, event);
+      });
+    } catch (error) {
+      console.warn("File watching not available:", error);
+    }
+  }
+  debounceTimer = null;
+  handleFileChange(filename, event) {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+    this.debounceTimer = setTimeout(async () => {
+      const fullPath = join(this.routesDir, filename);
+      try {
+        const stats = await stat(fullPath);
+        if (stats.isFile()) {
+          if (event === "rename") {
+            await this.discoverRoutes();
+          } else {
+            const routeId = "/" + filename.replace(/\.(tsx?|jsx?)$/, "");
+            const node = this.tree?.findById(routeId);
+            if (node) {
+              delete node.module;
+              this.emit("change", this.nodeToRoute(node));
+            }
+          }
+        }
+      } catch (error) {
+        if (error.code === "ENOENT") {
+          const routeId = "/" + filename.replace(/\.(tsx?|jsx?)$/, "");
+          this.tree?.removeById(routeId);
+          this.routes = this.tree?.toRoutes() || [];
+          this.matcher = createMatcher(this.routes);
+          this.emit("remove", routeId);
+        }
+      }
+    }, 50);
+  }
+  nodeToRoute(node) {
+    return {
+      id: node.id,
+      path: node.path,
+      file: node.file,
+      index: node.index,
+      layout: node.layout,
+      module: node.module,
+      children: node.children?.map((c) => this.nodeToRoute(c))
+    };
+  }
+  stopWatching() {
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+  }
+  getRoutes() {
+    return this.routes;
+  }
+  getTree() {
+    return this.tree;
+  }
+  getMatcher() {
+    return this.matcher;
+  }
+  match(pathname) {
+    return this.matcher?.match(pathname) ?? null;
+  }
+  on(event, handler) {
+    this.eventHandlers[event] = handler;
+  }
+  emit(event, ...args) {
+    const handler = this.eventHandlers[event];
+    if (handler) {
+      handler(...args);
+    }
+  }
+  async loadModule(route) {
+    if (route.module)
+      return;
+    try {
+      const mod = await import(route.file);
+      route.module = mod;
+      if (mod.config) {
+        route.config = parseRouteConfig(mod.config);
+      }
+      const parent = this.findParentRoute(route);
+      if (parent?.config) {
+        route.config = mergeRouteConfigs(parent.config, route.config);
+      }
+    } catch (error) {
+      console.error(`Failed to load route module: ${route.file}`, error);
+      throw error;
+    }
+  }
+  findParentRoute(route) {
+    const parentId = route.id.split("/").slice(0, -1).join("/") || "/";
+    return this.routes.find((r) => r.id === parentId);
+  }
+  async getRouteConfig(route) {
+    if (!route.config && !route.module) {
+      await this.loadModule(route);
+    }
+    return route.config;
+  }
+  async getRoutesWithConfig() {
+    const loadPromises = this.routes.map(async (route) => {
+      if (!route.config && !route.module) {
+        await this.loadModule(route);
+      }
+    });
+    await Promise.all(loadPromises);
+    return this.routes;
+  }
+  async findRoutesByRenderMode(mode) {
+    const routes = await this.getRoutesWithConfig();
+    return routes.filter((r) => r.config?.render?.mode === mode);
+  }
+  async findProtectedRoutes() {
+    const routes = await this.getRoutesWithConfig();
+    return routes.filter((r) => r.config?.auth?.required);
+  }
+  async getPrerenderPaths() {
+    const routes = await this.findRoutesByRenderMode("ssg");
+    const paths = [];
+    for (const route of routes) {
+      const prerender = route.config?.render?.prerender;
+      if (prerender?.enabled && prerender.paths) {
+        if (Array.isArray(prerender.paths)) {
+          paths.push(...prerender.paths);
+        } else if (typeof prerender.paths === "function") {
+          const result = await prerender.paths();
+          paths.push(...Array.isArray(result) ? result : []);
+        }
+      }
+    }
+    return paths;
+  }
+  async loadAllModules() {
+    const loadRecursive = async (routes) => {
+      for (const route of routes) {
+        await this.loadModule(route);
+        if (route.children) {
+          await loadRecursive(route.children);
+        }
+      }
+    };
+    await loadRecursive(this.routes);
+  }
+}
+function createFileRouter(options) {
+  return new FileRouter(options);
+}
+async function initFileRouter(options) {
+  const router = createFileRouter(options);
+  await router.init();
+  return router;
+}
+// src/middleware-chain.ts
+function createMiddleware(config) {
+  return {
+    ...config,
+    register() {
+      registerMiddleware(config.name, config.handler);
+    }
+  };
+}
+function chainMiddleware(...middlewares) {
+  const combinedProvides = middlewares.flatMap((m) => m.provides || []);
+  const combinedRequires = middlewares.flatMap((m) => m.requires || []);
+  return {
+    name: middlewares.map((m) => m.name).join("+"),
+    provides: combinedProvides,
+    requires: combinedRequires,
+    handler: composeMiddleware(...middlewares.map((m) => m.handler))
+  };
+}
+var namedMiddlewareRegistry = new Map;
+var typedMiddlewareRegistry = new Map;
+function registerMiddleware(name, handler) {
+  namedMiddlewareRegistry.set(name, handler);
+}
+function registerTypedMiddleware(middleware) {
+  typedMiddlewareRegistry.set(middleware.name, middleware);
+  namedMiddlewareRegistry.set(middleware.name, middleware.handler);
+}
+function getTypedMiddleware(name) {
+  return typedMiddlewareRegistry.get(name);
+}
+function validateMiddlewareChain(names) {
+  const errors = [];
+  const providedKeys = new Set;
+  for (const name of names) {
+    const middleware = typedMiddlewareRegistry.get(name);
+    if (!middleware)
+      continue;
+    const requires = middleware.requires || [];
+    for (const key of requires) {
+      if (!providedKeys.has(key)) {
+        errors.push(`Middleware '${name}' requires '${String(key)}' but it's not provided by preceding middleware`);
+      }
+    }
+    const provides = middleware.provides || [];
+    for (const key of provides) {
+      providedKeys.add(key);
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function getMiddleware(name) {
+  return namedMiddlewareRegistry.get(name);
+}
+function hasMiddleware(name) {
+  return namedMiddlewareRegistry.has(name);
+}
+function unregisterMiddleware(name) {
+  return namedMiddlewareRegistry.delete(name);
+}
+function clearMiddlewareRegistry() {
+  namedMiddlewareRegistry.clear();
+}
+function resolveMiddleware(reference) {
+  if (typeof reference === "function") {
+    return reference;
+  }
+  return namedMiddlewareRegistry.get(reference);
+}
+async function executeMiddlewareChain(middleware, options) {
+  const { request, context, finalHandler, onError } = options;
+  const handlers = [];
+  for (const ref of middleware) {
+    const handler = resolveMiddleware(ref);
+    if (!handler) {
+      if (typeof ref === "string") {
+        throw new Error(`Named middleware not found: ${ref}`);
+      }
+      throw new Error("Invalid middleware reference");
+    }
+    handlers.push(handler);
+  }
+  let index = 0;
+  const next = async () => {
+    if (index >= handlers.length) {
+      return finalHandler();
+    }
+    const handler = handlers[index++];
+    try {
+      return await handler(request, context, next);
+    } catch (error) {
+      if (onError) {
+        return onError(error instanceof Error ? error : new Error(String(error)));
+      }
+      throw error;
+    }
+  };
+  return next();
+}
+function createMiddlewareExecutor(config) {
+  const middleware = config.middleware || [];
+  return async (options) => {
+    return executeMiddlewareChain(middleware, options);
+  };
+}
+function composeMiddleware(...handlers) {
+  return async (request, context, next) => {
+    let index = 0;
+    const composedNext = async () => {
+      if (index >= handlers.length) {
+        return next();
+      }
+      const handler = handlers[index++];
+      return handler(request, context, composedNext);
+    };
+    return composedNext();
+  };
+}
+function when(predicate, middleware) {
+  return async (request, context, next) => {
+    const shouldRun = await predicate(request, context);
+    if (shouldRun) {
+      return middleware(request, context, next);
+    }
+    return next();
+  };
+}
+function method(methods, middleware) {
+  const methodSet = new Set(Array.isArray(methods) ? methods : [methods]);
+  return when((request) => methodSet.has(request.method), middleware);
+}
+function globToRegex(glob) {
+  const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(/\{\{GLOBSTAR\}\}/g, ".*");
+  return new RegExp(`^${escaped}$`);
+}
+function path(patterns, middleware) {
+  const patternList = Array.isArray(patterns) ? patterns : [patterns];
+  return when((request) => {
+    const url = new URL(request.url);
+    return patternList.some((pattern) => {
+      if (typeof pattern === "string") {
+        if (url.pathname === pattern)
+          return true;
+        if (pattern.endsWith("/*")) {
+          const prefix = pattern.slice(0, -1);
+          return url.pathname.startsWith(prefix);
+        }
+        return url.pathname.startsWith(pattern);
+      }
+      return pattern.test(url.pathname);
+    });
+  }, middleware);
+}
+function createLoggerMiddleware(options = {}) {
+  return async (request, context, next) => {
+    const startTime = Date.now();
+    const url = new URL(request.url);
+    const logData = {
+      method: request.method,
+      pathname: url.pathname,
+      timestamp: new Date().toISOString()
+    };
+    if (options.includeHeaders) {
+      logData.headers = Object.fromEntries(options.includeHeaders.map((h) => [h, request.headers.get(h)]));
+    }
+    try {
+      const response = await next();
+      const duration = Date.now() - startTime;
+      console.log({
+        ...logData,
+        status: response.status,
+        duration: `${duration}ms`
+      });
+      return response;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      console.error({
+        ...logData,
+        error: error instanceof Error ? error.message : String(error),
+        duration: `${duration}ms`
+      });
+      throw error;
+    }
+  };
+}
+function createCorsMiddleware(options = {}) {
+  const {
+    origin = "*",
+    methods = ["GET", "HEAD", "PUT", "PATCH", "POST", "DELETE"],
+    headers = [],
+    credentials = false,
+    maxAge = 86400
+  } = options;
+  return async (request, context, next) => {
+    const response = await next();
+    const corsHeaders = new Headers(response.headers);
+    if (typeof origin === "string") {
+      corsHeaders.set("Access-Control-Allow-Origin", origin);
+    } else if (Array.isArray(origin)) {
+      const requestOrigin = request.headers.get("Origin");
+      if (requestOrigin && origin.includes(requestOrigin)) {
+        corsHeaders.set("Access-Control-Allow-Origin", requestOrigin);
+      }
+    } else if (typeof origin === "function") {
+      const requestOrigin = request.headers.get("Origin") || "";
+      if (origin(requestOrigin)) {
+        corsHeaders.set("Access-Control-Allow-Origin", requestOrigin);
+      }
+    }
+    corsHeaders.set("Access-Control-Allow-Methods", methods.join(", "));
+    if (headers.length > 0) {
+      corsHeaders.set("Access-Control-Allow-Headers", headers.join(", "));
+    }
+    if (credentials) {
+      corsHeaders.set("Access-Control-Allow-Credentials", "true");
+    }
+    corsHeaders.set("Access-Control-Max-Age", String(maxAge));
+    if (request.method === "OPTIONS") {
+      return new Response(null, {
+        status: 204,
+        headers: corsHeaders
+      });
+    }
+    return new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: corsHeaders
+    });
+  };
+}
+function createRateLimitMiddleware(options = {}) {
+  const {
+    windowMs = 60000,
+    maxRequests = 100,
+    keyGenerator = (req) => req.headers.get("X-Forwarded-For") || "unknown",
+    skipSuccessfulRequests = false
+  } = options;
+  const store = new Map;
+  return async (request, context, next) => {
+    const key = keyGenerator(request);
+    const now = Date.now();
+    let record = store.get(key);
+    if (!record || now > record.resetTime) {
+      record = { count: 0, resetTime: now + windowMs };
+    }
+    record.count++;
+    store.set(key, record);
+    if (record.count > maxRequests) {
+      return new Response("Rate limit exceeded", {
+        status: 429,
+        headers: {
+          "Retry-After": String(Math.ceil((record.resetTime - now) / 1000))
+        }
+      });
+    }
+    const response = await next();
+    const newResponse = new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+    newResponse.headers.set("X-RateLimit-Limit", String(maxRequests));
+    newResponse.headers.set("X-RateLimit-Remaining", String(Math.max(0, maxRequests - record.count)));
+    newResponse.headers.set("X-RateLimit-Reset", String(Math.ceil(record.resetTime / 1000)));
+    if (skipSuccessfulRequests && response.status < 400) {
+      store.delete(key);
+    }
+    return newResponse;
+  };
+}
+// src/validation.ts
+class ParamValidationError extends Error {
+  field;
+  value;
+  constructor(message, field, value) {
+    super(message);
+    this.field = field;
+    this.value = value;
+    this.name = "ParamValidationError";
+  }
+}
+var validators = {
+  string: (options = {}) => ({
+    parse: (value) => {
+      if (value === undefined) {
+        throw new ParamValidationError("Value is required", "value", value);
+      }
+      const str = Array.isArray(value) ? value[0] : value;
+      if (typeof str !== "string") {
+        throw new ParamValidationError("Value must be a string", "value", value);
+      }
+      if (options.min !== undefined && str.length < options.min) {
+        throw new ParamValidationError(`String too short (min ${options.min})`, "value", str);
+      }
+      if (options.max !== undefined && str.length > options.max) {
+        throw new ParamValidationError(`String too long (max ${options.max})`, "value", str);
+      }
+      if (options.regex && !options.regex.test(str)) {
+        throw new ParamValidationError("String does not match pattern", "value", str);
+      }
+      return str;
+    }
+  }),
+  number: (options = {}) => ({
+    parse: (value) => {
+      if (value === undefined) {
+        throw new ParamValidationError("Value is required", "value", value);
+      }
+      const str = Array.isArray(value) ? value[0] : value;
+      const num = Number(str);
+      if (isNaN(num)) {
+        throw new ParamValidationError("Value must be a number", "value", value);
+      }
+      if (options.integer && !Number.isInteger(num)) {
+        throw new ParamValidationError("Value must be an integer", "value", num);
+      }
+      if (options.min !== undefined && num < options.min) {
+        throw new ParamValidationError(`Number too small (min ${options.min})`, "value", num);
+      }
+      if (options.max !== undefined && num > options.max) {
+        throw new ParamValidationError(`Number too large (max ${options.max})`, "value", num);
+      }
+      return num;
+    }
+  }),
+  int: (options = {}) => validators.number({ ...options, integer: true }),
+  boolean: () => ({
+    parse: (value) => {
+      if (value === undefined) {
+        throw new ParamValidationError("Value is required", "value", value);
+      }
+      const str = Array.isArray(value) ? value[0] : value;
+      const lower = str.toLowerCase();
+      if (lower === "true" || lower === "1" || lower === "yes")
+        return true;
+      if (lower === "false" || lower === "0" || lower === "no")
+        return false;
+      throw new ParamValidationError("Value must be a boolean", "value", value);
+    }
+  }),
+  enum: (values) => ({
+    parse: (value) => {
+      if (value === undefined) {
+        throw new ParamValidationError("Value is required", "value", value);
+      }
+      const str = Array.isArray(value) ? value[0] : value;
+      if (!values.includes(str)) {
+        throw new ParamValidationError(`Value must be one of: ${values.join(", ")}`, "value", str);
+      }
+      return str;
+    }
+  }),
+  array: (itemValidator) => ({
+    parse: (value) => {
+      if (value === undefined) {
+        return [];
+      }
+      const arr = Array.isArray(value) ? value : [value];
+      return arr.map((item) => itemValidator.parse(item));
+    }
+  }),
+  optional: (validator) => ({
+    parse: (value) => {
+      if (value === undefined)
+        return;
+      return validator.parse(value);
+    }
+  }),
+  default: (validator, defaultValue) => ({
+    parse: (value) => {
+      if (value === undefined)
+        return defaultValue;
+      return validator.parse(value);
+    }
+  })
+};
+function validateParams(params, schema) {
+  const result = {};
+  const errors = [];
+  for (const [key, validator] of Object.entries(schema)) {
+    try {
+      result[key] = validator.parse(params[key]);
+    } catch (error) {
+      if (error instanceof ParamValidationError) {
+        errors.push(new ParamValidationError(error.message, key, params[key]));
+      } else {
+        errors.push(new ParamValidationError(String(error), key, params[key]));
+      }
+    }
+  }
+  if (errors.length > 0) {
+    const firstError = errors[0];
+    throw new ParamValidationError(`Parameter validation failed: ${firstError.message}`, firstError.field, firstError.value);
+  }
+  return result;
+}
+function safeValidateParams(params, schema) {
+  try {
+    const data = validateParams(params, schema);
+    return { valid: true, data };
+  } catch (error) {
+    if (error instanceof ParamValidationError) {
+      return { valid: false, errors: [error] };
+    }
+    return {
+      valid: false,
+      errors: [new ParamValidationError(String(error), "unknown", params)]
+    };
+  }
+}
+function validateSearchParams(searchParams, schema) {
+  let params;
+  if (typeof searchParams === "string") {
+    const url = new URL(`http://localhost:3000?${searchParams}`);
+    params = Object.fromEntries(url.searchParams.entries());
+  } else if (searchParams instanceof URLSearchParams) {
+    params = Object.fromEntries(searchParams.entries());
+  } else {
+    params = searchParams;
+  }
+  const result = {};
+  for (const [key, validatorDef] of Object.entries(schema)) {
+    const value = params[key];
+    if (typeof validatorDef === "function" || "parse" in validatorDef) {
+      const validator = validatorDef;
+      result[key] = validator.parse(value);
+    } else if ("default" in validatorDef) {
+      const def = validatorDef;
+      if (value === undefined) {
+        result[key] = def.default;
+      } else if (def.validator) {
+        result[key] = def.validator.parse(value);
+      } else {
+        result[key] = value;
+      }
+    }
+  }
+  return result;
+}
+function createRouteValidator(options) {
+  const validate = (routeParams, searchParams) => {
+    const validatedParams = options.params ? validateParams(routeParams, options.params) : {};
+    const validatedSearch = options.searchParams ? validateSearchParams(searchParams, options.searchParams) : {};
+    return {
+      params: validatedParams,
+      searchParams: validatedSearch
+    };
+  };
+  return {
+    validate,
+    safeValidate: (routeParams, searchParams) => {
+      try {
+        return {
+          valid: true,
+          data: validate(routeParams, searchParams)
+        };
+      } catch (error) {
+        return {
+          valid: false,
+          error: error instanceof ParamValidationError ? error : new ParamValidationError(String(error), "unknown", null)
+        };
+      }
+    }
+  };
+}
+function matchParamPattern(pattern, value) {
+  if (pattern.startsWith("[...")) {
+    return true;
+  }
+  if (pattern.startsWith("[[") && pattern.endsWith("]]")) {
+    return value === "" || /^[^/]+$/.test(value);
+  }
+  if (pattern.startsWith("[") && pattern.endsWith("]")) {
+    return /^[^/]+$/.test(value);
+  }
+  return pattern === value;
+}
+function extractParamNames(path2) {
+  const names = [];
+  const segments = path2.split("/");
+  for (const segment of segments) {
+    if (segment.startsWith("[...") && segment.endsWith("]")) {
+      names.push(segment.slice(4, -1));
+    } else if (segment.startsWith("[[[") && segment.endsWith("]]")) {
+      names.push(segment.slice(3, -2));
+    } else if (segment.startsWith("[[") && segment.endsWith("]]")) {
+      names.push(segment.slice(2, -2));
+    } else if (segment.startsWith("[") && segment.endsWith("]")) {
+      names.push(segment.slice(1, -1));
+    }
+  }
+  return names;
+}
+export {
+  when,
+  validators,
+  validateSearchParams,
+  validateParams,
+  validateMiddlewareChain,
+  unregisterMiddleware,
+  safeValidateParams,
+  resolveMiddleware,
+  registerTypedMiddleware,
+  registerMiddleware,
+  patternToRegex,
+  path,
+  parseVariants,
+  parseRouteConfig,
+  parseRenderConfig,
+  parseProgressiveConfig,
+  parsePathSegments,
+  parseMiddleware,
+  parseIslandsConfig,
+  parseDevConfig,
+  parseCacheConfig,
+  parseAuthConfig,
+  method,
+  mergeRouteConfigs,
+  matchWithLayouts,
+  matchRoute,
+  matchParamPattern,
+  initFileRouter,
+  hasMiddleware,
+  globToRegex,
+  getTypedMiddleware,
+  getMiddleware,
+  filePathToUrlPath,
+  extractParamNames,
+  executeMiddlewareChain,
+  createRouteValidator,
+  createRouteTree,
+  createRateLimitMiddleware,
+  createMiddlewareExecutor,
+  createMiddleware,
+  createMatcher,
+  createLoggerMiddleware,
+  createFileRouter,
+  createCorsMiddleware,
+  composeMiddleware,
+  clearMiddlewareRegistry,
+  chainMiddleware,
+  calculateRouteScore,
+  buildRouteTree,
+  SPECIAL_FILES,
+  RouteTree,
+  RouteMatcher,
+  ROUTE_SCORE,
+  ROUTE_GROUP_PATTERN,
+  ParamValidationError,
+  OPTIONAL_PATTERN,
+  FileRouter,
+  DYNAMIC_SEGMENT_PATTERN,
+  CATCH_ALL_PATTERN
+};