@rangojs/router 0.0.0-experimental.2 → 0.0.0-experimental.20dbba0c

package/src/handles/MetaTags.tsx

@@ -25,11 +25,12 @@
  */
 
 import { use } from "react";
-import { useHandle } from "../browser/react/use-handle.ts";
-import { Meta } from "./meta.ts";
-import type { MetaDescriptor, MetaDescriptorBase } from "../router/types.ts";
-import { getSSRThemeConfig } from "../theme/theme-context.js";
+import { useHandle } from "../browser/react/use-handle.js";
+import { Meta } from "./meta.js";
+import type { MetaDescriptor, MetaDescriptorBase } from "../router/types.js";
+import { useThemeContext } from "../theme/theme-context.js";
 import { generateThemeScript } from "../theme/theme-script.js";
+import { useNonce } from "../browser/react/nonce-context.js";
 
 // Type guards for MetaDescriptorBase variants
 function hasCharSet(d: MetaDescriptorBase): d is { charSet: "utf-8" } {
@@ -40,30 +41,53 @@ function hasTitle(d: MetaDescriptorBase): d is { title: string } {
   return "title" in d && typeof (d as { title?: unknown }).title === "string";
 }
 
-function hasNameContent(d: MetaDescriptorBase): d is { name: string; content: string } {
-  return "name" in d && "content" in d &&
+function hasNameContent(
+  d: MetaDescriptorBase,
+): d is { name: string; content: string } {
+  return (
+    "name" in d &&
+    "content" in d &&
     typeof (d as { name?: unknown }).name === "string" &&
-    typeof (d as { content?: unknown }).content === "string";
+    typeof (d as { content?: unknown }).content === "string"
+  );
 }
 
-function hasPropertyContent(d: MetaDescriptorBase): d is { property: string; content: string } {
-  return "property" in d && "content" in d &&
+function hasPropertyContent(
+  d: MetaDescriptorBase,
+): d is { property: string; content: string } {
+  return (
+    "property" in d &&
+    "content" in d &&
     typeof (d as { property?: unknown }).property === "string" &&
-    typeof (d as { content?: unknown }).content === "string";
+    typeof (d as { content?: unknown }).content === "string"
+  );
 }
 
-function hasHttpEquivContent(d: MetaDescriptorBase): d is { httpEquiv: string; content: string } {
-  return "httpEquiv" in d && "content" in d &&
+function hasHttpEquivContent(
+  d: MetaDescriptorBase,
+): d is { httpEquiv: string; content: string } {
+  return (
+    "httpEquiv" in d &&
+    "content" in d &&
     typeof (d as { httpEquiv?: unknown }).httpEquiv === "string" &&
-    typeof (d as { content?: unknown }).content === "string";
+    typeof (d as { content?: unknown }).content === "string"
+  );
 }
 
-function hasScriptLdJson(d: MetaDescriptorBase): d is { "script:ld+json": object } {
+function hasScriptLdJson(
+  d: MetaDescriptorBase,
+): d is { "script:ld+json": object } {
   return "script:ld+json" in d;
 }
 
-function hasTagName(d: MetaDescriptorBase): d is { tagName: "meta" | "link"; [name: string]: string } {
-  return "tagName" in d && ((d as { tagName?: unknown }).tagName === "meta" || (d as { tagName?: unknown }).tagName === "link");
+function hasTagName(
+  d: MetaDescriptorBase,
+): d is { tagName: "meta" | "link"; [name: string]: string } {
+  return (
+    "tagName" in d &&
+    ((d as { tagName?: unknown }).tagName === "meta" ||
+      (d as { tagName?: unknown }).tagName === "link")
+  );
 }
 
 /**
@@ -78,7 +102,7 @@ function isPromise(value: unknown): value is Promise<unknown> {
  */
 function renderMetaDescriptor(
   descriptor: MetaDescriptorBase,
-  index: number
+  index: number,
 ): React.ReactNode {
   // charset
   if (hasCharSet(descriptor)) {
@@ -139,21 +163,42 @@ function renderMetaDescriptor(
   if (hasTagName(descriptor)) {
     const { tagName, ...rest } = descriptor;
     if (tagName === "link") {
-      return <link key={`link-${index}`} {...(rest as React.LinkHTMLAttributes<HTMLLinkElement>)} />;
+      return (
+        <link
+          key={`link-${index}`}
+          {...(rest as React.LinkHTMLAttributes<HTMLLinkElement>)}
+        />
+      );
     }
     if (tagName === "meta") {
-      return <meta key={`meta-${index}`} {...(rest as React.MetaHTMLAttributes<HTMLMetaElement>)} />;
+      return (
+        <meta
+          key={`meta-${index}`}
+          {...(rest as React.MetaHTMLAttributes<HTMLMetaElement>)}
+        />
+      );
     }
   }
 
   // Fallback: treat as meta attributes
-  return <meta key={`meta-fallback-${index}`} {...(descriptor as React.MetaHTMLAttributes<HTMLMetaElement>)} />;
+  return (
+    <meta
+      key={`meta-fallback-${index}`}
+      {...(descriptor as React.MetaHTMLAttributes<HTMLMetaElement>)}
+    />
+  );
 }
 
 /**
  * Wrapper component to resolve a Promise<MetaDescriptorBase> using use().
  */
-function AsyncMetaTag({ promise, index }: { promise: Promise<MetaDescriptorBase>; index: number }): React.ReactNode {
+function AsyncMetaTag({
+  promise,
+  index,
+}: {
+  promise: Promise<MetaDescriptorBase>;
+  index: number;
+}): React.ReactNode {
   const resolved = use(promise);
   return renderMetaDescriptor(resolved, index);
 }
@@ -172,19 +217,27 @@ function AsyncMetaTag({ promise, index }: { promise: Promise<MetaDescriptorBase>
  */
 export function MetaTags(): React.ReactNode {
   const descriptors = useHandle(Meta) as MetaDescriptor[];
-  const themeConfig = getSSRThemeConfig();
+  const themeConfig = useThemeContext()?.config ?? null;
+  const nonce = useNonce();
 
   return (
     <>
       {/* Theme script must be first to prevent FOUC */}
       {themeConfig && (
         <script
+          nonce={nonce}
           dangerouslySetInnerHTML={{ __html: generateThemeScript(themeConfig) }}
         />
       )}
       {descriptors.map((descriptor, index) => {
         if (isPromise(descriptor)) {
-          return <AsyncMetaTag key={`async-${index}`} promise={descriptor} index={index} />;
+          return (
+            <AsyncMetaTag
+              key={`async-${index}`}
+              promise={descriptor}
+              index={index}
+            />
+          );
         }
         return renderMetaDescriptor(descriptor, index);
       })}

package/src/handles/breadcrumbs.ts

@@ -0,0 +1,66 @@
+/**
+ * Built-in Breadcrumbs handle for accumulating breadcrumb items across route segments.
+ *
+ * Each layout/route pushes breadcrumb items via `ctx.use(Breadcrumbs)`.
+ * Items are collected in parent-to-child order with automatic deduplication
+ * by `href` (last item for each href wins).
+ *
+ * @example
+ * ```tsx
+ * // In route handler
+ * route("/blog/:slug", (ctx) => {
+ *   const breadcrumb = ctx.use(Breadcrumbs);
+ *   breadcrumb({ label: "Blog", href: "/blog" });
+ *   breadcrumb({ label: post.title, href: `/blog/${ctx.params.slug}` });
+ * });
+ *
+ * // In client component (consume with useHandle)
+ * const crumbs = useHandle(Breadcrumbs);
+ * crumbs.map((c) => <a href={c.href}>{c.label}</a>);
+ * ```
+ */
+
+import type { ReactNode } from "react";
+import { createHandle, type Handle } from "../handle.js";
+
+/**
+ * A single breadcrumb item.
+ *
+ * @property label - Display text for the breadcrumb
+ * @property href - URL the breadcrumb links to
+ * @property content - Optional extra content (sync or async) rendered alongside the label
+ */
+export interface BreadcrumbItem {
+  label: string;
+  href: string;
+  content?: ReactNode | Promise<ReactNode>;
+}
+
+/**
+ * Collect function for Breadcrumbs handle.
+ * Flattens segments in parent-to-child order with deduplication by href
+ * (last item for each href wins).
+ */
+function collectBreadcrumbs(segments: BreadcrumbItem[][]): BreadcrumbItem[] {
+  const all = segments.flat();
+  const seen = new Map<string, number>();
+
+  for (let i = 0; i < all.length; i++) {
+    seen.set(all[i].href, i);
+  }
+
+  // Return items in order, keeping only the last occurrence per href
+  return all.filter((item, index) => seen.get(item.href) === index);
+}
+
+/**
+ * Built-in handle for accumulating breadcrumb navigation items.
+ *
+ * Use `ctx.use(Breadcrumbs)` in route handlers to push breadcrumb items.
+ * Use `useHandle(Breadcrumbs)` in client components to consume them.
+ */
+export const Breadcrumbs: Handle<BreadcrumbItem, BreadcrumbItem[]> =
+  createHandle<BreadcrumbItem, BreadcrumbItem[]>(
+    collectBreadcrumbs,
+    "__rsc_router_breadcrumbs__",
+  );

package/src/handles/index.ts

@@ -4,3 +4,4 @@
 
 export { Meta } from "./meta.ts";
 export { MetaTags } from "./MetaTags.tsx";
+export { Breadcrumbs, type BreadcrumbItem } from "./breadcrumbs.ts";

package/src/handles/meta.ts

@@ -28,18 +28,18 @@
  * ```
  */
 
-import { createHandle, type Handle } from "../handle.ts";
+import { createHandle, type Handle } from "../handle.js";
 import type {
   MetaDescriptor,
   TitleDescriptor,
   UnsetDescriptor,
-} from "../router/types.ts";
+} from "../router/types.js";
 
 /**
  * Type guard for unset descriptor
  */
 function isUnsetDescriptor(
-  descriptor: MetaDescriptor
+  descriptor: MetaDescriptor,
 ): descriptor is UnsetDescriptor {
   return (
     typeof descriptor === "object" &&
@@ -53,7 +53,7 @@ function isUnsetDescriptor(
  * Type guard for title descriptor (any form)
  */
 function isTitleDescriptor(
-  descriptor: MetaDescriptor
+  descriptor: MetaDescriptor,
 ): descriptor is { title: TitleDescriptor } {
   return (
     typeof descriptor === "object" &&
@@ -66,7 +66,7 @@ function isTitleDescriptor(
  * Type guard for title template descriptor
  */
 function isTitleTemplate(
-  title: TitleDescriptor
+  title: TitleDescriptor,
 ): title is { template: string; default: string } {
   return (
     typeof title === "object" &&
@@ -79,7 +79,9 @@ function isTitleTemplate(
 /**
  * Type guard for absolute title descriptor
  */
-function isAbsoluteTitle(title: TitleDescriptor): title is { absolute: string } {
+function isAbsoluteTitle(
+  title: TitleDescriptor,
+): title is { absolute: string } {
   return typeof title === "object" && title !== null && "absolute" in title;
 }
 
@@ -141,7 +143,7 @@ function addOrReplace(
   result: MetaDescriptor[],
   keyToIndex: Map<string, number>,
   descriptor: MetaDescriptor,
-  key: string | undefined
+  key: string | undefined,
 ): void {
   if (key !== undefined && keyToIndex.has(key)) {
     result[keyToIndex.get(key)!] = descriptor;
@@ -158,7 +160,7 @@ function addOrReplace(
  */
 function updateIndicesAfterRemoval(
   keyToIndex: Map<string, number>,
-  removedIndex: number
+  removedIndex: number,
 ): void {
   for (const [key, index] of keyToIndex) {
     if (index > removedIndex) {
@@ -208,13 +210,23 @@ function collectMeta(segments: MetaDescriptor[][]): MetaDescriptor[] {
           // Store template for subsequent title descriptors in child segments
           titleTemplate = titleValue.template;
           // Set the default title
-          addOrReplace(result, keyToIndex, { title: titleValue.default }, "title");
+          addOrReplace(
+            result,
+            keyToIndex,
+            { title: titleValue.default },
+            "title",
+          );
           continue;
         }
 
         if (isAbsoluteTitle(titleValue)) {
           // Absolute title bypasses any template
-          addOrReplace(result, keyToIndex, { title: titleValue.absolute }, "title");
+          addOrReplace(
+            result,
+            keyToIndex,
+            { title: titleValue.absolute },
+            "title",
+          );
           continue;
         }
 
@@ -222,7 +234,12 @@ function collectMeta(segments: MetaDescriptor[][]): MetaDescriptor[] {
         const finalTitle = titleTemplate
           ? titleTemplate.replace("%s", titleValue as string)
           : titleValue;
-        addOrReplace(result, keyToIndex, { title: finalTitle as string }, "title");
+        addOrReplace(
+          result,
+          keyToIndex,
+          { title: finalTitle as string },
+          "title",
+        );
         continue;
       }
 
@@ -241,7 +258,7 @@ function collectMeta(segments: MetaDescriptor[][]): MetaDescriptor[] {
  * Use `ctx.use(Meta)` in route handlers to push meta descriptors.
  * Use `<MetaTags />` component to render them in the document head.
  */
-export const Meta: Handle<MetaDescriptor, MetaDescriptor[]> = createHandle<MetaDescriptor, MetaDescriptor[]>(
-  collectMeta,
-  "__rsc_router_meta__"
-);
+export const Meta: Handle<MetaDescriptor, MetaDescriptor[]> = createHandle<
+  MetaDescriptor,
+  MetaDescriptor[]
+>(collectMeta, "__rsc_router_meta__");

package/src/host/cookie-handler.ts

@@ -0,0 +1,165 @@
+/**
+ * Cookie Override Handler
+ *
+ * Manages cookie-based host override for development environments.
+ */
+
+import type { HostOverrideConfig } from "./types.js";
+import type { RouterRequestInput } from "../router/router-interfaces.js";
+import { matchPattern, parseRequest } from "./pattern-matcher.js";
+import {
+  HostOverrideNotAllowedError,
+  InvalidHostnameError,
+  HostValidationError,
+} from "./errors.js";
+
+/**
+ * Parse cookies from request
+ */
+export function parseCookies(request: Request): Record<string, string> {
+  const cookieHeader = request.headers.get("cookie");
+  if (!cookieHeader) {
+    return {};
+  }
+
+  const cookies: Record<string, string> = {};
+  const pairs = cookieHeader.split(";");
+
+  for (const pair of pairs) {
+    const [name, ...rest] = pair.trim().split("=");
+    if (name && rest.length > 0) {
+      const value = rest.join("=");
+      try {
+        cookies[name] = decodeURIComponent(value);
+      } catch {
+        cookies[name] = value;
+      }
+    }
+  }
+
+  return cookies;
+}
+
+/**
+ * Get cookie value from request
+ */
+export function getCookie(request: Request, name: string): string | undefined {
+  const cookies = parseCookies(request);
+  return cookies[name];
+}
+
+/**
+ * Create Set-Cookie header to delete a cookie
+ */
+export function createDeleteCookieHeader(name: string): string {
+  return `${name}=; Max-Age=0; Path=/; Secure; HttpOnly`;
+}
+
+/**
+ * Create error response with cookie deletion
+ */
+export function createCookieErrorResponse(
+  cookieName: string,
+  message: string,
+): Response {
+  return new Response(
+    JSON.stringify({
+      error: message,
+      message: `The ${cookieName} cookie has been cleared`,
+    }),
+    {
+      status: 400,
+      headers: {
+        "Content-Type": "application/json",
+        "Set-Cookie": createDeleteCookieHeader(cookieName),
+      },
+    },
+  );
+}
+
+/**
+ * Check if current host is allowed to use override
+ */
+export function isHostAllowed(
+  request: Request,
+  allowedHosts: string[],
+): boolean {
+  const { hostname, pathname, parts } = parseRequest(request);
+
+  for (const pattern of allowedHosts) {
+    if (matchPattern(pattern, hostname, pathname, parts)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Handle cookie override logic
+ *
+ * Returns overridden hostname if valid, original hostname if no override.
+ * Throws errors for invalid overrides.
+ */
+export function handleCookieOverride(
+  request: Request,
+  config: HostOverrideConfig | undefined,
+  input: RouterRequestInput<any>,
+): string {
+  if (!config) {
+    const { hostname } = parseRequest(request);
+    return hostname;
+  }
+
+  const { cookieName, allowedHosts, validate } = config;
+  const cookieValue = getCookie(request, cookieName);
+  const { hostname: originalHostname } = parseRequest(request);
+
+  // No cookie - return original hostname
+  if (!cookieValue) {
+    return originalHostname;
+  }
+
+  // Check if current host is allowed
+  const allowed = isHostAllowed(request, allowedHosts);
+
+  // If not allowed, throw error
+  if (!allowed) {
+    throw new HostOverrideNotAllowedError(originalHostname, cookieName, {
+      cause: { cookieValue, currentHost: originalHostname },
+    });
+  }
+
+  // If allowed and has custom validation, run it
+  if (validate) {
+    try {
+      const validatedHostname = validate(request, cookieValue, input);
+      return validatedHostname;
+    } catch (error) {
+      // Wrap in HostValidationError
+      const message = error instanceof Error ? error.message : String(error);
+      throw new HostValidationError(message, error);
+    }
+  }
+
+  // Default validation - verify it's a valid hostname using URL constructor
+  try {
+    // Try to construct a URL with the hostname to validate it
+    const testUrl = new URL(`https://${cookieValue}`);
+
+    // Ensure the hostname matches what we provided (URL constructor normalizes it)
+    if (testUrl.hostname !== cookieValue) {
+      throw new InvalidHostnameError(cookieValue, {
+        cause: { original: cookieValue, normalized: testUrl.hostname },
+      });
+    }
+  } catch (error) {
+    // If URL constructor failed, throw InvalidHostnameError with cause
+    if (error instanceof InvalidHostnameError) {
+      throw error;
+    }
+    throw new InvalidHostnameError(cookieValue, { cause: error });
+  }
+
+  return cookieValue;
+}

package/src/host/errors.ts

@@ -0,0 +1,97 @@
+/**
+ * Custom Error Classes for Host Router
+ *
+ * All host router errors extend HostRouterError for easy instance checking.
+ */
+
+/**
+ * Error options with cause
+ */
+interface ErrorOptions {
+  cause?: unknown;
+}
+
+/**
+ * Base error class for all host router errors
+ */
+export class HostRouterError extends Error {
+  cause?: unknown;
+
+  constructor(message: string, options?: ErrorOptions) {
+    super(message);
+    if (options?.cause) {
+      this.cause = options.cause;
+    }
+    this.name = "HostRouterError";
+    Object.setPrototypeOf(this, HostRouterError.prototype);
+  }
+}
+
+/**
+ * Error thrown when pattern validation fails
+ */
+export class InvalidPatternError extends HostRouterError {
+  constructor(pattern: string, reason: string, options?: ErrorOptions) {
+    super(`Invalid pattern "${pattern}": ${reason}`, options);
+    this.name = "InvalidPatternError";
+    Object.setPrototypeOf(this, InvalidPatternError.prototype);
+  }
+}
+
+/**
+ * Error thrown when cookie override is not allowed
+ */
+export class HostOverrideNotAllowedError extends HostRouterError {
+  constructor(currentHost: string, cookieName: string, options?: ErrorOptions) {
+    super(
+      `Host override not allowed on "${currentHost}" (cookie: ${cookieName})`,
+      options,
+    );
+    this.name = "HostOverrideNotAllowedError";
+    Object.setPrototypeOf(this, HostOverrideNotAllowedError.prototype);
+  }
+}
+
+/**
+ * Error thrown when cookie hostname is invalid
+ */
+export class InvalidHostnameError extends HostRouterError {
+  constructor(hostname: string, options?: ErrorOptions) {
+    super(`Invalid hostname format: "${hostname}"`, options);
+    this.name = "InvalidHostnameError";
+    Object.setPrototypeOf(this, InvalidHostnameError.prototype);
+  }
+}
+
+/**
+ * Error thrown when custom validation fails
+ */
+export class HostValidationError extends HostRouterError {
+  constructor(message: string, cause?: unknown) {
+    super(message, { cause });
+    this.name = "HostValidationError";
+    Object.setPrototypeOf(this, HostValidationError.prototype);
+  }
+}
+
+/**
+ * Error thrown when no route matches
+ */
+export class NoRouteMatchError extends HostRouterError {
+  constructor(hostname: string, pathname: string, options?: ErrorOptions) {
+    super(`No route matched for ${hostname}${pathname}`, options);
+    this.name = "NoRouteMatchError";
+    Object.setPrototypeOf(this, NoRouteMatchError.prototype);
+  }
+}
+
+/**
+ * Error thrown when handler type is invalid
+ */
+export class InvalidHandlerError extends HostRouterError {
+  constructor(handler: unknown, options?: ErrorOptions) {
+    super(`Invalid handler type: ${typeof handler}`, options);
+    this.name = "InvalidHandlerError";
+    Object.setPrototypeOf(this, InvalidHandlerError.prototype);
+  }
+}

package/src/host/index.ts

@@ -0,0 +1,53 @@
+/**
+ * Host Router
+ *
+ * A routing system for managing multi-application hosting based on
+ * domain/subdomain patterns with support for cookie-based host override
+ * for development environments.
+ *
+ * @example
+ * ```ts
+ * import { createHostRouter } from '@rangojs/router/host';
+ *
+ * const router = createHostRouter();
+ *
+ * router.host(['.']).map(() => import('./apps/main'));
+ * router.host(['admin.*']).map(() => import('./apps/admin'));
+ *
+ * export default {
+ *   fetch(request) {
+ *     return router.match(request);
+ *   }
+ * };
+ * ```
+ */
+
+// Core router
+export { createHostRouter } from "./router.js";
+
+// Utilities
+export { defineHosts } from "./utils.js";
+
+// Errors
+export {
+  HostRouterError,
+  InvalidPatternError,
+  HostOverrideNotAllowedError,
+  InvalidHostnameError,
+  HostValidationError,
+  NoRouteMatchError,
+  InvalidHandlerError,
+} from "./errors.js";
+
+// Types
+export type {
+  HostRouter,
+  HostRouteBuilder,
+  HostRouterOptions,
+  Handler,
+  LazyHandler,
+  Middleware,
+  HostPattern,
+  HostMatchResult,
+  HostOverrideConfig,
+} from "./types.js";