@aura-stack/router 0.1.0

package/dist/context.cjs

@@ -0,0 +1,151 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/context.ts
+var context_exports = {};
+__export(context_exports, {
+  getBody: () => getBody,
+  getHeaders: () => getHeaders,
+  getRouteParams: () => getRouteParams,
+  getSearchParams: () => getSearchParams
+});
+module.exports = __toCommonJS(context_exports);
+
+// src/assert.ts
+var supportedBodyMethods = ["POST", "PUT", "PATCH"];
+var isSupportedBodyMethod = (method) => {
+  return supportedBodyMethods.includes(method);
+};
+
+// src/error.ts
+var statusCode = {
+  OK: 200,
+  CREATED: 201,
+  ACCEPTED: 202,
+  NO_CONTENT: 204,
+  MULTIPLE_CHOICES: 300,
+  MOVED_PERMANENTLY: 301,
+  FOUND: 302,
+  SEE_OTHER: 303,
+  NOT_MODIFIED: 304,
+  TEMPORARY_REDIRECT: 307,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  PAYMENT_REQUIRED: 402,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  NOT_ACCEPTABLE: 406,
+  PROXY_AUTHENTICATION_REQUIRED: 407,
+  UNPROCESSABLE_ENTITY: 422,
+  INTERNAL_SERVER_ERROR: 500,
+  NOT_IMPLEMENTED: 501,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  HTTP_VERSION_NOT_SUPPORTED: 505
+};
+var statusText = Object.entries(statusCode).reduce(
+  (previous, [status, code]) => {
+    return { ...previous, [code]: status };
+  },
+  {}
+);
+var AuraStackRouterError = class extends Error {
+  constructor(type, message, name) {
+    super(message);
+    this.name = name ?? "AuraStackRouterError";
+    this.status = statusCode[type];
+    this.statusText = statusText[this.status];
+  }
+};
+
+// src/endpoint.ts
+var createRoutePattern = (route) => {
+  const pattern = route.replace(/:[^/]+/g, "([^/]+)").replace(/\//g, "\\/");
+  return new RegExp(`^${pattern}$`);
+};
+
+// src/context.ts
+var getRouteParams = (route, path) => {
+  const routeRegex = createRoutePattern(route);
+  if (!routeRegex.test(path)) {
+    throw new AuraStackRouterError("BAD_REQUEST", `Missing required route params for route: ${route}`);
+  }
+  const params = routeRegex.exec(route)?.slice(1).map((seg) => seg.replace(":", ""));
+  if (!params) return {};
+  const values = routeRegex.exec(path)?.slice(1);
+  return params.reduce(
+    (previous, now, idx) => ({
+      ...previous,
+      [now]: decodeURIComponent(values?.[idx] ?? "")
+    }),
+    {}
+  );
+};
+var getSearchParams = (url, config) => {
+  const route = new URL(url);
+  if (config.schemas?.searchParams) {
+    const parsed = config.schemas.searchParams.safeParse(Object.fromEntries(route.searchParams.entries()));
+    if (!parsed.success) {
+      throw new AuraStackRouterError("UNPROCESSABLE_ENTITY", "Invalid search parameters");
+    }
+    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 void 0;
+  }
+  const contentType = request.headers.get("Content-Type") ?? "";
+  if (contentType.includes("application/json")) {
+    const json = await request.json();
+    if (config.schemas?.body) {
+      const parsed = config.schemas.body.safeParse(json);
+      if (!parsed.success) {
+        throw new AuraStackRouterError("UNPROCESSABLE_ENTITY", "Invalid request body");
+      }
+      return parsed.data;
+    }
+    return json;
+  }
+  if (contentType.includes("application/x-www-form-urlencoded") || contentType.includes("multipart/form-data")) {
+    return await request.formData();
+  }
+  if (contentType.includes("text/")) {
+    return await request.text();
+  }
+  if (contentType.includes("application/octet-stream")) {
+    return await request.arrayBuffer();
+  }
+  if (contentType.includes("image/") || contentType.includes("video/") || contentType.includes("audio/")) {
+    return await request.blob();
+  }
+  return null;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getBody,
+  getHeaders,
+  getRouteParams,
+  getSearchParams
+});

package/dist/context.d.cts

@@ -0,0 +1,84 @@
+import { RoutePattern, Params, EndpointConfig, ContextSearchParams } from './types.cjs';
+import 'zod';
+
+/**
+ * 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: <Route extends RoutePattern>(route: Route, path: string) => Params<Route>;
+/**
+ * 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/context.d.ts

@@ -0,0 +1,84 @@
+import { RoutePattern, Params, EndpointConfig, ContextSearchParams } from './types.js';
+import 'zod';
+
+/**
+ * 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: <Route extends RoutePattern>(route: Route, path: string) => Params<Route>;
+/**
+ * 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/context.js

@@ -0,0 +1,15 @@
+import {
+  getBody,
+  getHeaders,
+  getRouteParams,
+  getSearchParams
+} from "./chunk-NNCUFWPI.js";
+import "./chunk-6UBPSXKR.js";
+import "./chunk-ENOBC3XN.js";
+import "./chunk-RFYOPPMW.js";
+export {
+  getBody,
+  getHeaders,
+  getRouteParams,
+  getSearchParams
+};

package/dist/endpoint.cjs

@@ -0,0 +1,110 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/endpoint.ts
+var endpoint_exports = {};
+__export(endpoint_exports, {
+  createEndpoint: () => createEndpoint,
+  createEndpointConfig: () => createEndpointConfig,
+  createRoutePattern: () => createRoutePattern
+});
+module.exports = __toCommonJS(endpoint_exports);
+
+// src/assert.ts
+var supportedMethods = ["GET", "POST", "DELETE", "PUT", "PATCH"];
+var isSupportedMethod = (method) => {
+  return supportedMethods.includes(method);
+};
+var isValidRoute = (route) => {
+  const routePattern = /^\/[a-zA-Z0-9/_:-]*$/;
+  return routePattern.test(route);
+};
+var isValidHandler = (handler) => {
+  return typeof handler === "function";
+};
+
+// src/error.ts
+var statusCode = {
+  OK: 200,
+  CREATED: 201,
+  ACCEPTED: 202,
+  NO_CONTENT: 204,
+  MULTIPLE_CHOICES: 300,
+  MOVED_PERMANENTLY: 301,
+  FOUND: 302,
+  SEE_OTHER: 303,
+  NOT_MODIFIED: 304,
+  TEMPORARY_REDIRECT: 307,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  PAYMENT_REQUIRED: 402,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  NOT_ACCEPTABLE: 406,
+  PROXY_AUTHENTICATION_REQUIRED: 407,
+  UNPROCESSABLE_ENTITY: 422,
+  INTERNAL_SERVER_ERROR: 500,
+  NOT_IMPLEMENTED: 501,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  HTTP_VERSION_NOT_SUPPORTED: 505
+};
+var statusText = Object.entries(statusCode).reduce(
+  (previous, [status, code]) => {
+    return { ...previous, [code]: status };
+  },
+  {}
+);
+var AuraStackRouterError = class extends Error {
+  constructor(type, message, name) {
+    super(message);
+    this.name = name ?? "AuraStackRouterError";
+    this.status = statusCode[type];
+    this.statusText = statusText[this.status];
+  }
+};
+
+// src/endpoint.ts
+var createRoutePattern = (route) => {
+  const pattern = route.replace(/:[^/]+/g, "([^/]+)").replace(/\//g, "\\/");
+  return new RegExp(`^${pattern}$`);
+};
+var createEndpoint = (method, route, handler, config = {}) => {
+  if (!isSupportedMethod(method)) {
+    throw new AuraStackRouterError("METHOD_NOT_ALLOWED", `Unsupported HTTP method: ${method}`);
+  }
+  if (!isValidRoute(route)) {
+    throw new AuraStackRouterError("BAD_REQUEST", `Invalid route format: ${route}`);
+  }
+  if (!isValidHandler(handler)) {
+    throw new AuraStackRouterError("BAD_REQUEST", "Handler must be a function");
+  }
+  return { method, route, handler, config };
+};
+function createEndpointConfig(...args) {
+  if (typeof args[0] === "string") return args[1];
+  return args[0];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createEndpoint,
+  createEndpointConfig,
+  createRoutePattern
+});

package/dist/endpoint.d.cts

@@ -0,0 +1,59 @@
+import { RoutePattern, HTTPMethod, EndpointSchemas, RouteHandler, EndpointConfig, RouteEndpoint } from './types.cjs';
+import 'zod';
+
+/**
+ * Create a RegExp pattern from a route string. This function allows segment the
+ * dynamic params in the route. For example, the route `/users/:id` will be
+ * converted to a regex pattern that captures the `id` parameter.
+ *
+ * @param route - The route pattern string
+ * @returns A RegExp object that matches the route pattern
+ * @example
+ * // Expected: /^\/users\/([^/]+)$/
+ * const pattern = createRoutePattern("/users/:id");
+ */
+declare const createRoutePattern: (route: RoutePattern) => RegExp;
+/**
+ * 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 Lowercase<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.
+ *
+ * @experimental
+ * @param config - The endpoint configuration object
+ * @returns The same configuration object, typed as EndpointConfig
+ * @example
+ * 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);
+ */
+declare function createEndpointConfig<Schemas extends EndpointSchemas>(config: EndpointConfig<RoutePattern, Schemas>): EndpointConfig<RoutePattern, Schemas>;
+declare function createEndpointConfig<Route extends RoutePattern, S extends EndpointSchemas>(route: Route, config: EndpointConfig<Route, S>): EndpointConfig<Route, S>;
+
+export { createEndpoint, createEndpointConfig, createRoutePattern };

package/dist/endpoint.d.ts

@@ -0,0 +1,59 @@
+import { RoutePattern, HTTPMethod, EndpointSchemas, RouteHandler, EndpointConfig, RouteEndpoint } from './types.js';
+import 'zod';
+
+/**
+ * Create a RegExp pattern from a route string. This function allows segment the
+ * dynamic params in the route. For example, the route `/users/:id` will be
+ * converted to a regex pattern that captures the `id` parameter.
+ *
+ * @param route - The route pattern string
+ * @returns A RegExp object that matches the route pattern
+ * @example
+ * // Expected: /^\/users\/([^/]+)$/
+ * const pattern = createRoutePattern("/users/:id");
+ */
+declare const createRoutePattern: (route: RoutePattern) => RegExp;
+/**
+ * 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 Lowercase<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.
+ *
+ * @experimental
+ * @param config - The endpoint configuration object
+ * @returns The same configuration object, typed as EndpointConfig
+ * @example
+ * 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);
+ */
+declare function createEndpointConfig<Schemas extends EndpointSchemas>(config: EndpointConfig<RoutePattern, Schemas>): EndpointConfig<RoutePattern, Schemas>;
+declare function createEndpointConfig<Route extends RoutePattern, S extends EndpointSchemas>(route: Route, config: EndpointConfig<Route, S>): EndpointConfig<Route, S>;
+
+export { createEndpoint, createEndpointConfig, createRoutePattern };

package/dist/endpoint.js

@@ -0,0 +1,12 @@
+import {
+  createEndpoint,
+  createEndpointConfig,
+  createRoutePattern
+} from "./chunk-6UBPSXKR.js";
+import "./chunk-ENOBC3XN.js";
+import "./chunk-RFYOPPMW.js";
+export {
+  createEndpoint,
+  createEndpointConfig,
+  createRoutePattern
+};

package/dist/error.cjs

@@ -0,0 +1,69 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/error.ts
+var error_exports = {};
+__export(error_exports, {
+  AuraStackRouterError: () => AuraStackRouterError
+});
+module.exports = __toCommonJS(error_exports);
+var statusCode = {
+  OK: 200,
+  CREATED: 201,
+  ACCEPTED: 202,
+  NO_CONTENT: 204,
+  MULTIPLE_CHOICES: 300,
+  MOVED_PERMANENTLY: 301,
+  FOUND: 302,
+  SEE_OTHER: 303,
+  NOT_MODIFIED: 304,
+  TEMPORARY_REDIRECT: 307,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  PAYMENT_REQUIRED: 402,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  NOT_ACCEPTABLE: 406,
+  PROXY_AUTHENTICATION_REQUIRED: 407,
+  UNPROCESSABLE_ENTITY: 422,
+  INTERNAL_SERVER_ERROR: 500,
+  NOT_IMPLEMENTED: 501,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  HTTP_VERSION_NOT_SUPPORTED: 505
+};
+var statusText = Object.entries(statusCode).reduce(
+  (previous, [status, code]) => {
+    return { ...previous, [code]: status };
+  },
+  {}
+);
+var AuraStackRouterError = class extends Error {
+  constructor(type, message, name) {
+    super(message);
+    this.name = name ?? "AuraStackRouterError";
+    this.status = statusCode[type];
+    this.statusText = statusText[this.status];
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuraStackRouterError
+});

package/dist/error.d.cts

@@ -0,0 +1,40 @@
+/**
+ * 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;
+};
+/**
+ * Defines the errors used in AuraStack Router. Includes HTTP status code and
+ * status text.
+ */
+declare class AuraStackRouterError extends Error {
+    readonly status: number;
+    readonly statusText: keyof typeof statusCode;
+    constructor(type: keyof typeof statusCode, message: string, name?: string);
+}
+
+export { AuraStackRouterError };