@bunary/http 0.0.2 → 0.0.5

package/dist/index.js

@@ -1,26 +1,5 @@
 // @bun
-// src/app.ts
-function compilePath(path) {
-  const paramNames = [];
-  const regexString = path.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, (_match, paramName) => {
-    paramNames.push(paramName);
-    return "([^/]+)";
-  });
-  return {
-    pattern: new RegExp(`^${regexString}$`),
-    paramNames
-  };
-}
-function extractParams(path, route) {
-  const match = path.match(route.pattern);
-  if (!match)
-    return {};
-  const params = {};
-  for (let i = 0;i < route.paramNames.length; i++) {
-    params[route.paramNames[i]] = match[i + 1];
-  }
-  return params;
-}
+// src/response.ts
 function toResponse(result) {
   if (result instanceof Response) {
     return result;
@@ -45,34 +24,296 @@ function toResponse(result) {
     headers: { "Content-Type": "application/json" }
   });
 }
+
+// src/router.ts
+function compilePath(path) {
+  const paramNames = [];
+  const optionalParams = [];
+  let regexString = path.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  regexString = regexString.replace(/\/:([a-zA-Z_][a-zA-Z0-9_]*)(\\\?)?/g, (_match, paramName, isOptional) => {
+    if (paramNames.includes(paramName)) {
+      throw new Error(`Duplicate parameter name ":${paramName}" in route pattern "${path}". Each parameter name must be unique within a route.`);
+    }
+    paramNames.push(paramName);
+    if (isOptional) {
+      optionalParams.push(paramName);
+      return "(?:/([^/]+))?";
+    }
+    return "/([^/]+)";
+  });
+  regexString += "/?";
+  return {
+    pattern: new RegExp(`^${regexString}$`),
+    paramNames,
+    optionalParams
+  };
+}
+function extractParams(path, route) {
+  const match = path.match(route.pattern);
+  if (!match)
+    return {};
+  const params = {};
+  for (let i = 0;i < route.paramNames.length; i++) {
+    const value = match[i + 1];
+    if (value !== undefined && value !== "") {
+      params[route.paramNames[i]] = value;
+    }
+  }
+  return params;
+}
+function checkConstraints(params, constraints) {
+  if (!constraints)
+    return true;
+  for (const [param, pattern] of Object.entries(constraints)) {
+    const value = params[param];
+    if (value === undefined)
+      continue;
+    if (!pattern.test(value))
+      return false;
+  }
+  return true;
+}
+
+// src/routes/builder.ts
+function compilePattern(pattern, param) {
+  try {
+    return new RegExp(pattern);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Invalid pattern";
+    throw new Error(`Invalid regex pattern for parameter "${param}": ${message}`);
+  }
+}
+function createRouteBuilder(route, namedRoutes, app) {
+  function addConstraint(param, pattern) {
+    if (!route.constraints) {
+      route.constraints = {};
+    }
+    route.constraints[param] = pattern;
+  }
+  const builder = {
+    get get() {
+      return app.get;
+    },
+    get post() {
+      return app.post;
+    },
+    get put() {
+      return app.put;
+    },
+    get delete() {
+      return app.delete;
+    },
+    get patch() {
+      return app.patch;
+    },
+    get use() {
+      return app.use;
+    },
+    get group() {
+      return app.group;
+    },
+    get route() {
+      return app.route;
+    },
+    get hasRoute() {
+      return app.hasRoute;
+    },
+    get getRoutes() {
+      return app.getRoutes;
+    },
+    get listen() {
+      return app.listen;
+    },
+    get fetch() {
+      return app.fetch;
+    },
+    name: (name) => {
+      if (namedRoutes.has(name)) {
+        throw new Error(`Route name "${name}" is already defined`);
+      }
+      route.name = name;
+      namedRoutes.set(name, route);
+      return builder;
+    },
+    where: (paramOrConstraints, pattern) => {
+      if (typeof paramOrConstraints === "string") {
+        if (!pattern) {
+          throw new Error(`Pattern is required for constraint on "${paramOrConstraints}"`);
+        }
+        const regex = typeof pattern === "string" ? compilePattern(pattern, paramOrConstraints) : pattern;
+        addConstraint(paramOrConstraints, regex);
+      } else {
+        for (const [param, pat] of Object.entries(paramOrConstraints)) {
+          const regex = typeof pat === "string" ? compilePattern(pat, param) : pat;
+          addConstraint(param, regex);
+        }
+      }
+      return builder;
+    },
+    whereNumber: (param) => {
+      addConstraint(param, /^\d+$/);
+      return builder;
+    },
+    whereAlpha: (param) => {
+      addConstraint(param, /^[a-zA-Z]+$/);
+      return builder;
+    },
+    whereAlphaNumeric: (param) => {
+      addConstraint(param, /^[a-zA-Z0-9]+$/);
+      return builder;
+    },
+    whereUuid: (param) => {
+      addConstraint(param, /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i);
+      return builder;
+    },
+    whereUlid: (param) => {
+      addConstraint(param, /^[0-9A-HJKMNP-TV-Z]{26}$/);
+      return builder;
+    },
+    whereIn: (param, values) => {
+      if (values.length === 0) {
+        throw new Error(`whereIn requires at least one value for parameter "${param}"`);
+      }
+      const escaped = values.map((v) => v.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+      addConstraint(param, new RegExp(`^(${escaped.join("|")})$`));
+      return builder;
+    }
+  };
+  return builder;
+}
+function wrapBuilderWithNamePrefix(builder, namePrefix) {
+  if (!namePrefix)
+    return builder;
+  return new Proxy(builder, {
+    get(target, prop) {
+      if (prop === "name") {
+        return (name) => {
+          return target.name(namePrefix + name);
+        };
+      }
+      return target[prop];
+    }
+  });
+}
+// src/routes/find.ts
+function findRoute(routes, method, path) {
+  for (const route of routes) {
+    if (route.pattern.test(path)) {
+      if (route.method === method) {
+        const params = extractParams(path, route);
+        if (!checkConstraints(params, route.constraints)) {
+          continue;
+        }
+        return { route, params };
+      }
+    }
+  }
+  return null;
+}
+function hasMatchingPath(routes, path) {
+  return routes.some((route) => {
+    if (!route.pattern.test(path))
+      return false;
+    const params = extractParams(path, route);
+    return checkConstraints(params, route.constraints);
+  });
+}
+// src/pathUtils.ts
+function normalizePrefix(prefix) {
+  let normalized = prefix;
+  if (!normalized.startsWith("/")) {
+    normalized = `/${normalized}`;
+  }
+  if (normalized.endsWith("/") && normalized.length > 1) {
+    normalized = normalized.slice(0, -1);
+  }
+  return normalized;
+}
+function joinPaths(prefix, path) {
+  const normalizedPrefix = normalizePrefix(prefix);
+  let normalizedPath = path;
+  if (!normalizedPath.startsWith("/") && normalizedPath !== "") {
+    normalizedPath = `/${normalizedPath}`;
+  }
+  if (normalizedPath === "/") {
+    return normalizedPrefix;
+  }
+  return normalizedPrefix + normalizedPath;
+}
+
+// src/routes/group.ts
+function createGroupRouter(prefix, groupMiddleware, namePrefix, addRoute) {
+  const router = {
+    get: (path, handler) => {
+      const fullPath = joinPaths(prefix, path);
+      const builder = addRoute("GET", fullPath, handler, groupMiddleware);
+      return wrapBuilderWithNamePrefix(builder, namePrefix);
+    },
+    post: (path, handler) => {
+      const fullPath = joinPaths(prefix, path);
+      return wrapBuilderWithNamePrefix(addRoute("POST", fullPath, handler, groupMiddleware), namePrefix);
+    },
+    put: (path, handler) => {
+      const fullPath = joinPaths(prefix, path);
+      return wrapBuilderWithNamePrefix(addRoute("PUT", fullPath, handler, groupMiddleware), namePrefix);
+    },
+    delete: (path, handler) => {
+      const fullPath = joinPaths(prefix, path);
+      return wrapBuilderWithNamePrefix(addRoute("DELETE", fullPath, handler, groupMiddleware), namePrefix);
+    },
+    patch: (path, handler) => {
+      const fullPath = joinPaths(prefix, path);
+      return wrapBuilderWithNamePrefix(addRoute("PATCH", fullPath, handler, groupMiddleware), namePrefix);
+    },
+    group: (prefixOrOptions, callback) => {
+      const opts = typeof prefixOrOptions === "string" ? { prefix: prefixOrOptions } : prefixOrOptions;
+      const nestedPrefix = joinPaths(prefix, opts.prefix);
+      const nestedMiddleware = [...groupMiddleware, ...opts.middleware ?? []];
+      const nestedNamePrefix = namePrefix + (opts.name ?? "");
+      const nestedRouter = createGroupRouter(nestedPrefix, nestedMiddleware, nestedNamePrefix, addRoute);
+      callback(nestedRouter);
+      return router;
+    }
+  };
+  return router;
+}
+// src/app.ts
 function createApp() {
   const routes = [];
   const middlewares = [];
-  function addRoute(method, path, handler) {
-    const { pattern, paramNames } = compilePath(path);
-    routes.push({ method, path, pattern, paramNames, handler });
-    return app;
-  }
-  function findRoute(method, path) {
-    for (const route of routes) {
-      if (route.pattern.test(path)) {
-        if (route.method === method) {
-          return { route, params: extractParams(path, route) };
-        }
-      }
+  const namedRoutes = new Map;
+  let globalMiddlewareVersion = 0;
+  const middlewareCache = new WeakMap;
+  function getMiddlewareChain(route) {
+    const cached = middlewareCache.get(route);
+    if (cached && cached.version === globalMiddlewareVersion) {
+      return cached.chain;
     }
-    return null;
+    const chain = route.middleware ? [...middlewares, ...route.middleware] : middlewares.length > 0 ? [...middlewares] : [];
+    middlewareCache.set(route, { version: globalMiddlewareVersion, chain });
+    return chain;
   }
-  function hasMatchingPath(path) {
-    return routes.some((route) => route.pattern.test(path));
+  function addRoute(method, path, handler, groupMiddleware = []) {
+    const { pattern, paramNames, optionalParams } = compilePath(path);
+    const route = {
+      method,
+      path,
+      pattern,
+      paramNames,
+      handler,
+      optionalParams: optionalParams.length > 0 ? optionalParams : undefined,
+      middleware: groupMiddleware.length > 0 ? [...groupMiddleware] : undefined
+    };
+    routes.push(route);
+    return createRouteBuilder(route, namedRoutes, app);
   }
   async function handleRequest(request) {
     const url = new URL(request.url);
     const path = url.pathname;
     const method = request.method;
-    const match = findRoute(method, path);
+    const match = findRoute(routes, method, path);
     if (!match) {
-      if (hasMatchingPath(path)) {
+      if (hasMatchingPath(routes, path)) {
         return new Response(JSON.stringify({ error: "Method not allowed" }), {
           status: 405,
           headers: { "Content-Type": "application/json" }
@@ -86,13 +327,15 @@ function createApp() {
     const ctx = {
       request,
       params: match.params,
-      query: url.searchParams
+      query: url.searchParams,
+      locals: {}
     };
     try {
+      const allMiddleware = getMiddlewareChain(match.route);
       let index = 0;
       const next = async () => {
-        if (index < middlewares.length) {
-          const middleware = middlewares[index++];
+        if (index < allMiddleware.length) {
+          const middleware = allMiddleware[index++];
           return await middleware(ctx, next);
         }
         return await match.route.handler(ctx);
@@ -115,8 +358,67 @@ function createApp() {
     patch: (path, handler) => addRoute("PATCH", path, handler),
     use: (middleware) => {
       middlewares.push(middleware);
+      globalMiddlewareVersion++;
+      return app;
+    },
+    group: (prefixOrOptions, callback) => {
+      const opts = typeof prefixOrOptions === "string" ? { prefix: prefixOrOptions } : prefixOrOptions;
+      const groupRouter = createGroupRouter(opts.prefix, opts.middleware ?? [], opts.name ?? "", addRoute);
+      callback(groupRouter);
       return app;
     },
+    route: (name, params) => {
+      const route = namedRoutes.get(name);
+      if (!route) {
+        throw new Error(`Route "${name}" not found`);
+      }
+      if (params) {
+        for (const [key, value] of Object.entries(params)) {
+          const strValue = String(value);
+          if (strValue.includes("\r") || strValue.includes(`
+`) || strValue.includes("\x00")) {
+            throw new Error(`Invalid character in parameter "${key}": control characters are not allowed`);
+          }
+        }
+      }
+      let url = route.path;
+      const queryParams = {};
+      const usedParams = new Set;
+      for (const paramName of route.paramNames) {
+        const isOptional = route.optionalParams?.includes(paramName);
+        const value = params?.[paramName];
+        if (value !== undefined) {
+          url = url.replace(new RegExp(`:${paramName}\\??`), encodeURIComponent(String(value)));
+          usedParams.add(paramName);
+        } else if (isOptional) {
+          url = url.replace(new RegExp(`/:${paramName}\\?`), "");
+        } else {
+          throw new Error(`Missing required param "${paramName}" for route "${name}"`);
+        }
+      }
+      if (params) {
+        for (const [key, value] of Object.entries(params)) {
+          if (!usedParams.has(key)) {
+            queryParams[key] = String(value);
+          }
+        }
+      }
+      if (Object.keys(queryParams).length > 0) {
+        const qs = new URLSearchParams(queryParams).toString();
+        url += `?${qs}`;
+      }
+      return url;
+    },
+    hasRoute: (name) => {
+      return namedRoutes.has(name);
+    },
+    getRoutes: () => {
+      return routes.map((route) => ({
+        name: route.name ?? null,
+        method: route.method,
+        path: route.path
+      }));
+    },
     listen: (port = 3000, hostname = "localhost") => {
       const server = Bun.serve({
         port,

package/dist/pathUtils.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Path manipulation utilities for route handling.
+ */
+/**
+ * Normalize a path prefix (ensure leading slash, no trailing slash).
+ *
+ * @param prefix - Path prefix to normalize
+ * @returns Normalized prefix with leading slash and no trailing slash
+ *
+ * @example
+ * ```ts
+ * normalizePrefix("api")     // "/api"
+ * normalizePrefix("/api/")   // "/api"
+ * normalizePrefix("/")       // "/"
+ * ```
+ */
+export declare function normalizePrefix(prefix: string): string;
+/**
+ * Join path segments, handling slashes correctly.
+ *
+ * @param prefix - Path prefix
+ * @param path - Path to append
+ * @returns Combined path
+ *
+ * @example
+ * ```ts
+ * joinPaths("/api", "/users")  // "/api/users"
+ * joinPaths("/api", "users")   // "/api/users"
+ * joinPaths("/api/", "/users") // "/api/users"
+ * joinPaths("/", "/")          // "/"
+ * ```
+ */
+export declare function joinPaths(prefix: string, path: string): string;
+//# sourceMappingURL=pathUtils.d.ts.map

package/dist/pathUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathUtils.d.ts","sourceRoot":"","sources":["../src/pathUtils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAStD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAc9D"}

package/dist/response.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Response conversion utilities for route handlers.
+ */
+import type { HandlerResponse } from "./types/index.js";
+/**
+ * Convert a handler response to a proper Response object.
+ *
+ * Handles the following response types:
+ * - Response: passed through unchanged
+ * - null/undefined: 204 No Content
+ * - string: text/plain response
+ * - number: text/plain response
+ * - object/array: JSON response
+ *
+ * @param result - The handler return value
+ * @returns A proper Response object
+ *
+ * @example
+ * ```ts
+ * toResponse({ message: "Hello" });  // JSON response
+ * toResponse("Hello");               // text/plain response
+ * toResponse(null);                  // 204 No Content
+ * ```
+ */
+export declare function toResponse(result: HandlerResponse): Response;
+//# sourceMappingURL=response.d.ts.map

package/dist/response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response.d.ts","sourceRoot":"","sources":["../src/response.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAExD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,eAAe,GAAG,QAAQ,CAgC5D"}

package/dist/router.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Route matching utilities for compiling paths and extracting parameters.
+ */
+import type { Route } from "./types/index.js";
+/**
+ * Result of compiling a path pattern.
+ */
+export interface CompiledPath {
+    /** Regex pattern for matching */
+    pattern: RegExp;
+    /** Parameter names in order */
+    paramNames: string[];
+    /** Names of optional parameters */
+    optionalParams: string[];
+}
+/**
+ * Compile a path pattern into a regex and extract parameter names.
+ * Supports optional parameters with :param? syntax.
+ *
+ * @param path - Route path pattern (e.g., "/users/:id" or "/users/:id?")
+ * @returns Object with regex pattern, parameter names, and optional param names
+ *
+ * @example
+ * ```ts
+ * const { pattern, paramNames, optionalParams } = compilePath("/users/:id?");
+ * // pattern matches "/users" and "/users/123"
+ * // paramNames = ["id"]
+ * // optionalParams = ["id"]
+ * ```
+ */
+export declare function compilePath(path: string): CompiledPath;
+/**
+ * Extract path parameters from a matched route.
+ * Handles optional parameters by only including them if they have values.
+ *
+ * @param path - The request path
+ * @param route - The matched route
+ * @returns Record of parameter names to values (undefined for missing optional params)
+ */
+export declare function extractParams(path: string, route: Route): Record<string, string | undefined>;
+/**
+ * Check if route constraints are satisfied.
+ *
+ * @param params - Extracted route parameters
+ * @param constraints - Parameter constraints (regex patterns)
+ * @returns True if all constraints pass
+ */
+export declare function checkConstraints(params: Record<string, string | undefined>, constraints?: Record<string, RegExp>): boolean;
+//# sourceMappingURL=router.d.ts.map

package/dist/router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../src/router.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAE9C;;GAEG;AACH,MAAM,WAAW,YAAY;IAC5B,iCAAiC;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,+BAA+B;IAC/B,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,mCAAmC;IACnC,cAAc,EAAE,MAAM,EAAE,CAAC;CACzB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,CAmCtD;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAa5F;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC/B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,EAC1C,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAClC,OAAO,CAUT"}

package/dist/routes/builder.d.ts

@@ -0,0 +1,17 @@
+import type { BunaryApp, Route, RouteBuilder } from "../types/index.js";
+/**
+ * Safely compile a string pattern to RegExp with error handling.
+ * Provides better error messages for invalid regex patterns.
+ */
+export declare function compilePattern(pattern: string, param: string): RegExp;
+/**
+ * Create a RouteBuilder for a specific route.
+ * Each builder captures its own route reference to avoid shared mutable state issues.
+ */
+export declare function createRouteBuilder(route: Route, namedRoutes: Map<string, Route>, app: BunaryApp): RouteBuilder;
+/**
+ * Wrap a route builder to auto-apply name prefix.
+ * Uses a Proxy to maintain dynamic getter behavior from the original builder.
+ */
+export declare function wrapBuilderWithNamePrefix(builder: RouteBuilder, namePrefix: string): RouteBuilder;
+//# sourceMappingURL=builder.d.ts.map

package/dist/routes/builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../src/routes/builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAExE;;;GAGG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAOrE;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CACjC,KAAK,EAAE,KAAK,EACZ,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,EAC/B,GAAG,EAAE,SAAS,GACZ,YAAY,CAmHd;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,GAAG,YAAY,CAajG"}

package/dist/routes/find.d.ts

@@ -0,0 +1,27 @@
+import type { Route } from "../types/index.js";
+export interface RouteMatch {
+    route: Route;
+    params: Record<string, string | undefined>;
+}
+/**
+ * Find a matching route for the given method and path.
+ *
+ * **Complexity**: O(n) where n is the number of registered routes.
+ * Routes are tested sequentially until a match is found.
+ *
+ * This linear search is suitable for most applications (up to ~100 routes).
+ * For applications with hundreds of routes, consider:
+ * - Grouping routes by common prefixes (reduces regex tests per request)
+ * - Using method-based route maps (the 405 "Method Not Allowed" check already
+ *   iterates separately, so grouping by method could help)
+ * - Implementing a radix/prefix tree for static path segments
+ *
+ * The current design prioritizes simplicity and correctness. Route order matters:
+ * the first matching route wins, allowing intentional route shadowing.
+ */
+export declare function findRoute(routes: Route[], method: string, path: string): RouteMatch | null;
+/**
+ * Check if any route matches the path (regardless of method).
+ */
+export declare function hasMatchingPath(routes: Route[], path: string): boolean;
+//# sourceMappingURL=find.d.ts.map

package/dist/routes/find.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find.d.ts","sourceRoot":"","sources":["../../src/routes/find.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAE/C,MAAM,WAAW,UAAU;IAC1B,KAAK,EAAE,KAAK,CAAC;IACb,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;CAC3C;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAc1F;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAMtE"}

package/dist/routes/group.d.ts

@@ -0,0 +1,7 @@
+import type { GroupRouter, Middleware, RouteBuilder, RouteHandler } from "../types/index.js";
+export type AddRouteFn = (method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH", path: string, handler: RouteHandler, groupMiddleware?: Middleware[]) => RouteBuilder;
+/**
+ * Create a group router for defining routes within a group.
+ */
+export declare function createGroupRouter(prefix: string, groupMiddleware: Middleware[], namePrefix: string, addRoute: AddRouteFn): GroupRouter;
+//# sourceMappingURL=group.d.ts.map

package/dist/routes/group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"group.d.ts","sourceRoot":"","sources":["../../src/routes/group.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAGX,WAAW,EACX,UAAU,EACV,YAAY,EACZ,YAAY,EACZ,MAAM,mBAAmB,CAAC;AAG3B,MAAM,MAAM,UAAU,GAAG,CACxB,MAAM,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,QAAQ,GAAG,OAAO,EACnD,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,YAAY,EACrB,eAAe,CAAC,EAAE,UAAU,EAAE,KAC1B,YAAY,CAAC;AAElB;;GAEG;AACH,wBAAgB,iBAAiB,CAChC,MAAM,EAAE,MAAM,EACd,eAAe,EAAE,UAAU,EAAE,EAC7B,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,UAAU,GAClB,WAAW,CAoDb"}

package/dist/routes/index.d.ts

@@ -0,0 +1,4 @@
+export { createRouteBuilder, compilePattern, wrapBuilderWithNamePrefix } from "./builder.js";
+export { findRoute, hasMatchingPath, type RouteMatch } from "./find.js";
+export { createGroupRouter, type AddRouteFn } from "./group.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/routes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/routes/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,cAAc,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAC;AAC7F,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,KAAK,UAAU,EAAE,MAAM,WAAW,CAAC;AACxE,OAAO,EAAE,iBAAiB,EAAE,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC"}

package/dist/types/appOptions.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Configuration options for creating a Bunary app.
+ */
+export interface AppOptions {
+    /** Base path prefix for all routes (default: "") */
+    basePath?: string;
+}
+//# sourceMappingURL=appOptions.d.ts.map

package/dist/types/appOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"appOptions.d.ts","sourceRoot":"","sources":["../../src/types/appOptions.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,UAAU;IAC1B,oDAAoD;IACpD,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB"}