@aura-stack/router 0.3.0 → 0.5.0

package/dist/router.cjs

@@ -74,6 +74,47 @@ var RouterError = class extends AuraStackRouterError {
     this.name = name ?? "RouterError";
   }
 };
+var InvalidZodSchemaError = class {
+  constructor(type, errors) {
+    this.status = statusCode[type];
+    this.statusText = statusText[type];
+    this.errors = errors;
+  }
+};
+
+// src/headers.ts
+var import_cookie = require("cookie");
+var HeadersBuilder = class {
+  constructor(initialHeaders) {
+    this.headers = new Headers(initialHeaders);
+  }
+  setHeader(name, value) {
+    this.headers.set(name, value);
+    return this;
+  }
+  setCookie(name, value, options) {
+    this.headers.append("Set-Cookie", (0, import_cookie.serialize)(name, value, options));
+    return this;
+  }
+  getHeader(name) {
+    return this.headers.get(name);
+  }
+  getCookie(name) {
+    const cookies = (0, import_cookie.parse)(this.headers.get("cookie") ?? "");
+    return cookies[name];
+  }
+  getSetCookie(name) {
+    const cookies = this.headers.getSetCookie();
+    const cookie = cookies.find((cookie2) => cookie2.startsWith(name + "="));
+    return cookie ? (0, import_cookie.parseSetCookie)(cookie).value : void 0;
+  }
+  toHeaders() {
+    return new Headers(this.headers);
+  }
+  toCookies() {
+    return (0, import_cookie.parse)(this.headers.get("cookie") ?? "");
+  }
+};
 
 // src/assert.ts
 var supportedMethods = /* @__PURE__ */ new Set(["GET", "POST", "DELETE", "PUT", "PATCH", "OPTIONS", "HEAD", "TRACE", "CONNECT"]);
@@ -87,13 +128,31 @@ var isSupportedBodyMethod = (method) => {
 var isRouterError = (error) => {
   return error instanceof RouterError;
 };
+var isInvalidZodSchemaError = (error) => {
+  return error instanceof InvalidZodSchemaError;
+};
 
 // src/context.ts
+var formatZodError = (error) => {
+  if (!error.issues || error.issues.length === 0) {
+    return {};
+  }
+  return error.issues.reduce((previous, issue) => {
+    const key = issue.path.join(".");
+    return {
+      ...previous,
+      [key]: {
+        code: issue.code,
+        message: issue.message
+      }
+    };
+  }, {});
+};
 var getRouteParams = (params, config) => {
   if (config.schemas?.params) {
     const parsed = config.schemas.params.safeParse(params);
     if (!parsed.success) {
-      throw new RouterError("UNPROCESSABLE_ENTITY", "Invalid route parameters");
+      throw new InvalidZodSchemaError("UNPROCESSABLE_ENTITY", formatZodError(parsed.error));
     }
     return parsed.data;
   }
@@ -104,15 +163,12 @@ var getSearchParams = (url, config) => {
   if (config.schemas?.searchParams) {
     const parsed = config.schemas.searchParams.safeParse(Object.fromEntries(route.searchParams.entries()));
     if (!parsed.success) {
-      throw new RouterError("UNPROCESSABLE_ENTITY", "Invalid search parameters");
+      throw new InvalidZodSchemaError("UNPROCESSABLE_ENTITY", formatZodError(parsed.error));
     }
     return parsed.data;
   }
   return new URLSearchParams(route.searchParams.toString());
 };
-var getHeaders = (request) => {
-  return new Headers(request.headers);
-};
 var getBody = async (request, config) => {
   if (!isSupportedBodyMethod(request.method)) {
     return null;
@@ -124,7 +180,7 @@ var getBody = async (request, config) => {
     if (config.schemas?.body) {
       const parsed = config.schemas.body.safeParse(json);
       if (!parsed.success) {
-        throw new RouterError("UNPROCESSABLE_ENTITY", "Invalid request body");
+        throw new InvalidZodSchemaError("UNPROCESSABLE_ENTITY", formatZodError(parsed.error));
       }
       return parsed.data;
     }
@@ -154,31 +210,31 @@ var createContentTypeRegex = (contentTypes, contenType) => {
 };
 
 // src/middlewares.ts
-var executeGlobalMiddlewares = async (request, middlewares) => {
-  if (!middlewares) return request;
+var executeGlobalMiddlewares = async (context, middlewares) => {
+  if (!middlewares) return context;
   for (const middleware of middlewares) {
     if (typeof middleware !== "function") {
       throw new RouterError("BAD_REQUEST", "Global middlewares must be functions");
     }
-    const executed = await middleware(request);
+    const executed = await middleware(context);
     if (executed instanceof Response) {
       return executed;
     }
-    request = executed;
+    context = executed;
   }
-  if (!request || !(request instanceof Request)) {
+  if (!context || !(context.request instanceof Request)) {
     throw new RouterError("BAD_REQUEST", "Global middleware must return a Request or Response object");
   }
-  return request;
+  return context;
 };
-var executeMiddlewares = async (request, context, middlewares = []) => {
+var executeMiddlewares = async (context, middlewares = []) => {
   try {
     let ctx = context;
     for (const middleware of middlewares) {
       if (typeof middleware !== "function") {
         throw new RouterError("BAD_REQUEST", "Middleware must be a function");
       }
-      ctx = await middleware(request, ctx);
+      ctx = await middleware(ctx);
     }
     return ctx;
   } catch {
@@ -250,6 +306,17 @@ var handleError = async (error, request, config) => {
       );
     }
   }
+  if (isInvalidZodSchemaError(error)) {
+    const { errors, status, statusText: statusText2 } = error;
+    return Response.json(
+      {
+        message: "Invalid request data",
+        error: "validation_error",
+        details: errors
+      },
+      { status, statusText: statusText2 }
+    );
+  }
   if (isRouterError(error)) {
     const { message, status, statusText: statusText2 } = error;
     return Response.json({ message }, { status, statusText: statusText2 });
@@ -261,29 +328,35 @@ var handleRequest = async (method, request, config, root) => {
     if (!isSupportedMethod(request.method)) {
       throw new RouterError("METHOD_NOT_ALLOWED", `The HTTP method '${request.method}' is not supported`);
     }
-    const globalRequest = await executeGlobalMiddlewares(request, config.middlewares);
-    if (globalRequest instanceof Response) return globalRequest;
-    const url = new URL(globalRequest.url);
+    const globalContext = { request, context: config.context ?? {} };
+    const globalRequestContext = await executeGlobalMiddlewares(globalContext, config.middlewares);
+    if (globalRequestContext instanceof Response) return globalRequestContext;
+    const url = new URL(globalRequestContext.request.url);
     const pathnameWithBase = url.pathname;
-    if (globalRequest.method !== method) {
-      throw new RouterError("METHOD_NOT_ALLOWED", `The HTTP method '${globalRequest.method}' is not allowed`);
+    if (globalRequestContext.request.method !== method) {
+      throw new RouterError("METHOD_NOT_ALLOWED", `The HTTP method '${globalRequestContext.request.method}' is not allowed`);
     }
     const { endpoint, params } = search(method, root, pathnameWithBase);
-    if (endpoint.method !== globalRequest.method) {
-      throw new RouterError("METHOD_NOT_ALLOWED", `The HTTP method '${globalRequest.method}' is not allowed`);
+    if (endpoint.method !== globalRequestContext.request.method) {
+      throw new RouterError("METHOD_NOT_ALLOWED", `The HTTP method '${globalRequestContext.request.method}' is not allowed`);
     }
     const dynamicParams = getRouteParams(params, endpoint.config);
-    const body = await getBody(globalRequest, endpoint.config);
-    const searchParams = getSearchParams(globalRequest.url, endpoint.config);
-    const headers = getHeaders(globalRequest);
-    const context = {
+    const body = await getBody(globalRequestContext.request, endpoint.config);
+    const searchParams = getSearchParams(globalRequestContext.request.url, endpoint.config);
+    const headers = new HeadersBuilder(globalRequestContext.request.headers);
+    let context = {
       params: dynamicParams,
       searchParams,
       headers,
-      body
+      body,
+      request: globalRequestContext.request,
+      url,
+      method: globalRequestContext.request.method,
+      route: endpoint.route,
+      context: config.context ?? {}
     };
-    await executeMiddlewares(globalRequest, context, endpoint.config.middlewares);
-    const response = await endpoint.handler(globalRequest, context);
+    context = await executeMiddlewares(context, endpoint.config.middlewares);
+    const response = await endpoint.handler(context);
     return response;
   } catch (error) {
     return handleError(error, request, config);

package/dist/router.d.ts

@@ -1,6 +1,8 @@
 import { RouteEndpoint, RouterConfig, GetHttpHandlers, HTTPMethod, RoutePattern, EndpointSchemas, MiddlewareFunction } from './types.js';
 import 'zod';
 import './error.js';
+import './headers.js';
+import 'cookie';
 
 interface TrieNode {
     statics: Map<string, TrieNode>;

package/dist/router.js

@@ -3,11 +3,12 @@ import {
   createRouter,
   insert,
   search
-} from "./chunk-JIA6NLL6.js";
-import "./chunk-PT4GU6PH.js";
-import "./chunk-JNMXLKDG.js";
-import "./chunk-FWDOXDWG.js";
-import "./chunk-GJC3ODME.js";
+} from "./chunk-TEDN6QMU.js";
+import "./chunk-XB5P5CQZ.js";
+import "./chunk-FU35BPU7.js";
+import "./chunk-Z6JJAIWN.js";
+import "./chunk-BWIKAYZV.js";
+import "./chunk-B6PMGVSL.js";
 export {
   createNode,
   createRouter,

package/dist/types.d.ts

@@ -1,5 +1,7 @@
 import { ZodObject, z } from 'zod';
 import { RouterError } from './error.js';
+import { HeadersBuilder } from './headers.js';
+import 'cookie';
 
 /**
  * Route pattern must start with a slash and can contain parameters prefixed with a colon.
@@ -50,6 +52,13 @@ interface EndpointSchemas {
     searchParams?: ZodObject<any>;
     params?: ZodObject<any>;
 }
+/**
+ * Global context type that can be extended when creating the router. It allows passing
+ * additional data to all route handlers and middlewares. For a type-inference use module
+ * augmentation to extend the GlobalContext interface.
+ */
+interface GlobalContext {
+}
 /**
  * Configuration for an endpoint, including optional schemas for request validation and middlewares.
  */
@@ -95,25 +104,34 @@ type ContextParams<Schemas extends EndpointConfig["schemas"], Default = Record<s
  */
 interface RequestContext<RouteParams = Record<string, string>, Config extends EndpointConfig = EndpointConfig> {
     params: ContextParams<Config["schemas"], RouteParams>["params"];
-    headers: Headers;
+    headers: HeadersBuilder;
     body: ContextBody<Config["schemas"]>["body"];
     searchParams: ContextSearchParams<Config["schemas"]>["searchParams"];
+    request: Request;
+    url: URL;
+    method: HTTPMethod;
+    route: RoutePattern;
+    context: GlobalContext;
+}
+interface GlobalMiddlewareContext {
+    request: Request;
+    context: GlobalContext;
 }
 /**
  * Global middleware function type that represent a function that runs before the route matching.
  */
-type GlobalMiddleware = (request: Request) => Promise<Request | Response>;
+type GlobalMiddleware = (ctx: GlobalMiddlewareContext) => Response | GlobalMiddlewareContext | Promise<Response | GlobalMiddlewareContext>;
 /**
  * Middleware function type that represent a function that runs before the route handler
  * defined in the `createEndpoint/createEndpointConfig` function or globally in the `createRouter` function.
  */
-type MiddlewareFunction<RouteParams = Record<string, string>, Config extends EndpointConfig = EndpointConfig> = (request: Request, ctx: Prettify<RequestContext<RouteParams, Config>>) => Promise<RequestContext<RouteParams, Config>>;
+type MiddlewareFunction<RouteParams = Record<string, string>, Config extends EndpointConfig = EndpointConfig> = (ctx: Prettify<RequestContext<RouteParams, Config>>) => Response | RequestContext<RouteParams, Config> | Promise<Response | RequestContext<RouteParams, Config>>;
 /**
  * Defines a route handler function that processes an incoming request and returns a response.
  * The handler receives the request object and a context containing route parameters, headers,
  * and optionally validated body and search parameters based on the endpoint configuration.
  */
-type RouteHandler<Route extends RoutePattern, Config extends EndpointConfig> = (request: Request, ctx: Prettify<RequestContext<GetRouteParams<Route>, Config>>) => Response | Promise<Response>;
+type RouteHandler<Route extends RoutePattern, Config extends EndpointConfig> = (ctx: Prettify<RequestContext<GetRouteParams<Route>, Config>>) => Response | Promise<Response>;
 /**
  * Represents a route endpoint definition, specifying the HTTP method, route pattern,
  * handler function with inferred context types, and associated configuration.
@@ -135,10 +153,15 @@ type InferMethod<Endpoints extends RouteEndpoint[]> = Endpoints extends unknown[
 type GetHttpHandlers<Endpoints extends RouteEndpoint[]> = {
     [Method in InferMethod<Endpoints>]: (req: Request) => Response | Promise<Response>;
 };
+type GlobalCtx = keyof GlobalContext extends never ? {
+    context?: GlobalContext;
+} : {
+    context: GlobalContext;
+};
 /**
  * Configuration options for `createRouter` function.
  */
-interface RouterConfig {
+interface RouterConfig extends GlobalCtx {
     /**
      * Prefix path for all routes/endpoints defined in the router.
      *
@@ -188,4 +211,4 @@ interface RouterConfig {
     onError?: (error: Error | RouterError, request: Request) => Response | Promise<Response>;
 }
 
-export type { ContentType, ContextBody, ContextParams, ContextSearchParams, EndpointConfig, EndpointSchemas, GetHttpHandlers, GetRouteParams, GlobalMiddleware, HTTPMethod, InferMethod, MiddlewareFunction, Prettify, RequestContext, RouteEndpoint, RouteHandler, RoutePattern, RouterConfig };
+export type { ContentType, ContextBody, ContextParams, ContextSearchParams, EndpointConfig, EndpointSchemas, GetHttpHandlers, GetRouteParams, GlobalContext, GlobalCtx, GlobalMiddleware, GlobalMiddlewareContext, HTTPMethod, InferMethod, MiddlewareFunction, Prettify, RequestContext, RouteEndpoint, RouteHandler, RoutePattern, RouterConfig };

package/package.json

@@ -1,8 +1,31 @@
 {
   "name": "@aura-stack/router",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "type": "module",
   "description": "A lightweight TypeScript library for building, managing, and validating API routes and endpoints in Node.js applications.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aura-stack-ts/router"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/@aura-stack/router"
+  },
+  "keywords": [
+    "router",
+    "endpoints",
+    "api",
+    "aura",
+    "aura stack",
+    "typescript",
+    "nodejs"
+  ],
+  "author": "Aura Stack <auraauthoss@gmail.com> | Hernan Alvarado <hernanvid123@gmail.com>",
+  "homepage": "https://github.com/aura-stack-ts/router",
+  "bugs": {
+    "url": "https://github.com/aura-stack-ts/router/issues"
+  },
+  "license": "MIT",
   "files": [
     "dist"
   ],
@@ -27,19 +50,18 @@
       "import": "./dist/error.js",
       "require": "./dist/error.cjs"
     },
+    "./headers": {
+      "types": "./dist/headers.d.ts",
+      "import": "./dist/headers.js",
+      "require": "./dist/headers.cjs"
+    },
+    "./cookie": {
+      "types": "./dist/cookie.d.ts",
+      "import": "./dist/cookie.js",
+      "require": "./dist/cookie.cjs"
+    },
     "./types": "./dist/types.d.ts"
   },
-  "keywords": [
-    "router",
-    "endpoints",
-    "api",
-    "aura",
-    "aura stack",
-    "typescript",
-    "nodejs"
-  ],
-  "author": "Aura Stack <auraauthoss@gmail.com> | Hernan Alvarado <hernanvid123@gmail.com>",
-  "license": "MIT",
   "devDependencies": {
     "prettier": "^3.6.2",
     "tsup": "^8.5.0",
@@ -47,6 +69,9 @@
     "vitest": "^3.2.4",
     "zod": "^4.1.11"
   },
+  "dependencies": {
+    "cookie": "^1.1.1"
+  },
   "scripts": {
     "dev": "tsup --watch",
     "dev:docs": "pnpm --filter docs dev",
@@ -58,6 +83,7 @@
     "test:bench": "vitest --run bench",
     "type-check": "tsc --noEmit",
     "clean": "rm -rf dist",
-    "clean:cts": "rm -rf dist/*.cts"
+    "clean:cts": "rm -rf dist/*.cts",
+    "prepublish": "pnpm clean:cts"
   }
 }

package/dist/assert.d.cts

@@ -1,52 +0,0 @@
-import { RouterError } from './error.cjs';
-import { HTTPMethod, RoutePattern, RouteHandler } from './types.cjs';
-import 'zod';
-
-declare const supportedProtocols: Set<string>;
-/**
- * Checks if the provided method is a supported HTTP method.
- *
- * @param method - The HTTP method to check.
- * @returns True if the method is supported, false otherwise.
- */
-declare const isSupportedMethod: (method: string) => method is HTTPMethod;
-/**
- * Check if the provided method can includes a body as per HTTP specification.
- * @param method - The HTTP method to check.
- * @returns True if the method can include a body, false otherwise.
- */
-declare const isSupportedBodyMethod: (method: string) => method is HTTPMethod;
-/**
- * Checks if the provided route is a valid route pattern.
- *
- * @param route - The route pattern to check.
- * @returns True if the route is valid, false otherwise.
- */
-declare const isValidRoute: (route: string) => route is RoutePattern;
-/**
- * Checks if the provided handler is a valid route handler function.
- *
- * @param handler - The handler to check.
- * @returns True if the handler is valid, false otherwise.
- */
-declare const isValidHandler: (handler: unknown) => handler is RouteHandler<any, any>;
-/**
- * Asserts that the error is an instance of RouterError. It is useful if you want
- * to check if the error thrown by the router is an RouterError or by other sources.
- *
- * @param error - The error to check
- * @returns True if the error is an instance of RouterError, false otherwise.
- * @example
- * import { isRouterError } from "aura-stack/router";
- *
- * try {
- *   // Some router operation that may throw an error
- * } catch (error) {
- *  if (isRouterError(error)) {
- *    // Handle RouterError
- *  }
- * }
- */
-declare const isRouterError: (error: unknown) => error is RouterError;
-
-export { isRouterError, isSupportedBodyMethod, isSupportedMethod, isValidHandler, isValidRoute, supportedProtocols };

package/dist/context.d.cts

@@ -1,85 +0,0 @@
-import { EndpointConfig, ContextSearchParams } from './types.cjs';
-import 'zod';
-import './error.cjs';
-
-/**
- * Extracts route parameters from a given path using the specified route pattern.
- *
- * This function matches the provided path against the route pattern
- * (e.g., "/users/:userId/posts/:postId") and returns an object mapping parameter
- * names to their decoded values.
- *
- * @param route - The route pattern, typically defined in the endpoint configuration.
- * @param path - The actual request path to extract parameters from.
- * @returns An object containing the extracted route parameters as key-value pairs.
- *
- * @example
- * const route = "/users/:userId/posts/:postId";
- * const path = "/users/123/posts/456";
- *
- * // Expected: { userId: "123", postId: "456" }
- * const params = getRouteParams(route, path);
- */
-declare const getRouteParams: (params: Record<string, string>, config: EndpointConfig) => Record<string, unknown>;
-/**
- * Extracts and validates search parameters from a given URL from the request.
- *
- * If a schema is provided in the endpoint configuration, the search parameters
- * are validated against it using Zod and returned the parsed data. If validation
- * fails, an error is thrown. Otherwise, a URLSearchParams object is returned.
- *
- * @param url - The actual request URL to extract search parameters from.
- * @param config - Configuration object that may include a schema for validation.
- * @returns Either a URLSearchParams object or a parsed object based on the provided schema.
- * @example
- * // With schema
- * const url = "https://example.com/api?search=test&page=2";
- * const config: EndpointConfig = {
- *   schemas: {
- *     searchParams: z.object({
- *       search: z.string(),
- *       page: z.number().optional(),
- *     }),
- *   },
- * }
- *
- * // Expected: { search: "test", page: 2 }
- * const searchParams = getSearchParams(url, config);
- *
- * // Without schema
- * const url2 = "https://example.com/api?query=example";
- *
- * // Expected: URLSearchParams { 'query' => 'example' }
- * const searchParams2 = getSearchParams(url2, {} as EndpointConfig);
- */
-declare const getSearchParams: <Config extends EndpointConfig>(url: string, config: Config) => ContextSearchParams<Config["schemas"]>["searchParams"];
-/**
- * Extracts headers from the given Request object and returns them as a Headers instance.
- *
- * @param request - The Request object from which to extract headers.
- * @returns A Headers instance containing all headers from the request.
- * @example
- * const request = new Request("https://example.com/api", {
- *   headers: {
- *     "Content-Type": "application/json",
- *     "Authorization": "Bearer token",
- *   },
- * });
- * const headers = getHeaders(request);
- */
-declare const getHeaders: (request: Request) => Headers;
-/**
- * Extracts and parses the body of a Request object based on its Content-Type header.
- *
- * If a schema is provided in the endpoint configuration, the body is validated against
- * it using Zod and returned the parsed data. If validation fails, an error is thrown.
- *
- * In some cases, the browser includes text/plain;charset=UTF-8 as the default Content-Type
- *
- * @param request - The Request object from which to extract the body.
- * @param config - Configuration object that may include a schema for validation.
- * @returns The parsed body of the request or an error if validation fails.
- */
-declare const getBody: <Config extends EndpointConfig>(request: Request, config: Config) => Promise<any>;
-
-export { getBody, getHeaders, getRouteParams, getSearchParams };

package/dist/endpoint.d.cts

@@ -1,60 +0,0 @@
-import { HTTPMethod, RoutePattern, EndpointSchemas, RouteHandler, EndpointConfig, RouteEndpoint } from './types.cjs';
-import 'zod';
-import './error.cjs';
-
-/**
- * Defines an API endpoint for the router by specifying the HTTP method, route pattern,
- * handler function, and optional configuration such as validation schemas or middlewares.
- * Validates all parameters for correctness. The resulting endpoint should be passed
- * to the `createRouter` function.
- *
- * @param method - The HTTP method (e.g., GET, POST, PUT, DELETE, PATCH)
- * @param route - The route pattern to associate with the endpoint (supports dynamic params)
- * @param handler - The function to handle requests matching the method and route
- * @param config - Optional configuration including validation schemas, middlewares, etc.
- * @returns An object representing the configured endpoint
- * @example
- * const signIn = createEndpoint("POST", "/auth/signin", async (req, ctx) => {
- *   return new Response("Signed in");
- * });
- */
-declare const createEndpoint: <const Method extends Uppercase<HTTPMethod>, const Route extends RoutePattern, const Schemas extends EndpointSchemas>(method: Method, route: Route, handler: RouteHandler<Route, {
-    schemas: Schemas;
-}>, config?: EndpointConfig<Route, Schemas>) => RouteEndpoint<Method, Route, {}>;
-/**
- * Create an endpoint configuration to be passed to the `createEndpoint` function.
- * This function is primarily for type inference and does not perform any runtime checks.
- *
- * This overload is recommended when the route pattern does not need to be specified explicitly,
- * otherwise use the overload that accepts the route pattern as the first argument.
- *
- * @param config - The endpoint configuration object
- * @returns The same configuration object, typed as EndpointConfig
- * @example
- * // Without route pattern
- * const config = createEndpointConfig({
- *   middlewares: [myMiddleware],
- *   schemas: {
- *     searchParams: z.object({
- *       q: z.string().min(3),
- *     })
- *   }
- * })
- *
- * const search = createEndpoint("GET", "/search", async (request, ctx) => {
- *   return new Response("Search results");
- * }, config);
- *
- * // Overload with route pattern
- * const config = createEndpointConfig("/users/:userId", {
- *   middlewares: [myMiddleware],
- * })
- *
- * const getUser = createEndpoint("GET", "/users/:userId", async (request, ctx) => {
- *   return new Response("User details");
- * }, config);
- */
-declare function createEndpointConfig<Schemas extends EndpointSchemas>(config: EndpointConfig<RoutePattern, Schemas>): EndpointConfig<RoutePattern, Schemas>;
-declare function createEndpointConfig<Route extends RoutePattern, Schemas extends EndpointSchemas>(route: Route, config: EndpointConfig<Route, Schemas>): EndpointConfig<Route, Schemas>;
-
-export { createEndpoint, createEndpointConfig };

package/dist/error.d.cts

@@ -1,65 +0,0 @@
-/**
- * The HTTP status codes used in AuraStack Router.
- */
-declare const statusCode: {
-    OK: number;
-    CREATED: number;
-    ACCEPTED: number;
-    NO_CONTENT: number;
-    MULTIPLE_CHOICES: number;
-    MOVED_PERMANENTLY: number;
-    FOUND: number;
-    SEE_OTHER: number;
-    NOT_MODIFIED: number;
-    TEMPORARY_REDIRECT: number;
-    BAD_REQUEST: number;
-    UNAUTHORIZED: number;
-    PAYMENT_REQUIRED: number;
-    FORBIDDEN: number;
-    NOT_FOUND: number;
-    METHOD_NOT_ALLOWED: number;
-    NOT_ACCEPTABLE: number;
-    PROXY_AUTHENTICATION_REQUIRED: number;
-    UNPROCESSABLE_ENTITY: number;
-    INTERNAL_SERVER_ERROR: number;
-    NOT_IMPLEMENTED: number;
-    BAD_GATEWAY: number;
-    SERVICE_UNAVAILABLE: number;
-    HTTP_VERSION_NOT_SUPPORTED: number;
-};
-type StatusCode = keyof typeof statusCode;
-/**
- * Reverse mapping of status codes to their corresponding status text.
- */
-declare const statusText: Record<"OK" | "CREATED" | "ACCEPTED" | "NO_CONTENT" | "MULTIPLE_CHOICES" | "MOVED_PERMANENTLY" | "FOUND" | "SEE_OTHER" | "NOT_MODIFIED" | "TEMPORARY_REDIRECT" | "BAD_REQUEST" | "UNAUTHORIZED" | "PAYMENT_REQUIRED" | "FORBIDDEN" | "NOT_FOUND" | "METHOD_NOT_ALLOWED" | "NOT_ACCEPTABLE" | "PROXY_AUTHENTICATION_REQUIRED" | "UNPROCESSABLE_ENTITY" | "INTERNAL_SERVER_ERROR" | "NOT_IMPLEMENTED" | "BAD_GATEWAY" | "SERVICE_UNAVAILABLE" | "HTTP_VERSION_NOT_SUPPORTED", "OK" | "CREATED" | "ACCEPTED" | "NO_CONTENT" | "MULTIPLE_CHOICES" | "MOVED_PERMANENTLY" | "FOUND" | "SEE_OTHER" | "NOT_MODIFIED" | "TEMPORARY_REDIRECT" | "BAD_REQUEST" | "UNAUTHORIZED" | "PAYMENT_REQUIRED" | "FORBIDDEN" | "NOT_FOUND" | "METHOD_NOT_ALLOWED" | "NOT_ACCEPTABLE" | "PROXY_AUTHENTICATION_REQUIRED" | "UNPROCESSABLE_ENTITY" | "INTERNAL_SERVER_ERROR" | "NOT_IMPLEMENTED" | "BAD_GATEWAY" | "SERVICE_UNAVAILABLE" | "HTTP_VERSION_NOT_SUPPORTED">;
-/**
- * Defines the errors used in AuraStack Router. Includes HTTP status code and
- * status text.
- * @deprecated Use RouterError instead
- */
-declare class AuraStackRouterError extends Error {
-    /**
-     * The HTTP status code associated with the error.
-     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Status
-     * @example
-     * NOT_FOUND: 404
-     * METHOD_NOT_ALLOWED: 405
-     * INTERNAL_SERVER_ERROR: 500
-     */
-    readonly status: number;
-    /**
-     * The HTTP status text associated with the status code of the error.
-     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Status
-     * @example
-     * NOT_FOUND: NOT_FOUND
-     * METHOD_NOT_ALLOWED: METHOD_NOT_ALLOWED
-     * INTERNAL_SERVER_ERROR: INTERNAL_SERVER_ERROR
-     */
-    readonly statusText: StatusCode;
-    constructor(type: StatusCode, message: string, name?: string);
-}
-declare class RouterError extends AuraStackRouterError {
-    constructor(type: StatusCode, message: string, name?: string);
-}
-
-export { AuraStackRouterError, RouterError, statusCode, statusText };