@rangojs/router 0.0.0-experimental.0b82333f

package/src/href-client.ts

@@ -0,0 +1,222 @@
+/**
+ * Client-safe type-safe href function
+ *
+ * This is a compile-time only href that validates paths against registered routes.
+ * No runtime route map lookup - just an identity function with TypeScript validation.
+ *
+ * @example
+ * ```typescript
+ * import { href } from "rsc-router/client";
+ *
+ * href("/blog/my-post");           // ✓ matches /blog/:slug
+ * href("/shop/product/widget");    // ✓ matches /shop/product/:slug
+ * href("/invalid");                // ✗ TypeScript error
+ * ```
+ */
+
+import type { GetRegisteredRoutes } from "./types.js";
+import type { ResponseEnvelope } from "./urls.js";
+
+/**
+ * Parse constraint values into a union type for paths
+ * "a|b|c" → "a" | "b" | "c"
+ */
+type ParseConstraintPath<T extends string> =
+  T extends `${infer First}|${infer Rest}`
+    ? First | ParseConstraintPath<Rest>
+    : T;
+
+/**
+ * Convert a route pattern to a template literal type
+ *
+ * Supports:
+ * - Static: /about → "/about"
+ * - Dynamic: /blog/:slug → `/blog/${string}`
+ * - Optional: /:locale?/blog → "/blog" | `/${string}/blog`
+ * - Constrained: /:locale(en|gb)/blog → "/en/blog" | "/gb/blog"
+ * - Optional + Constrained: /:locale(en|gb)?/blog → "/blog" | "/en/blog" | "/gb/blog"
+ *
+ * @example
+ * PatternToPath<"/blog/:slug"> = `/blog/${string}`
+ * PatternToPath<"/:locale?/blog"> = "/blog" | `/${string}/blog`
+ * PatternToPath<"/:locale(en|gb)/blog"> = "/en/blog" | "/gb/blog"
+ * PatternToPath<"/:locale(en|gb)?/blog"> = "/blog" | "/en/blog" | "/gb/blog"
+ */
+export type PatternToPath<T extends string> =
+  // Optional + constrained param in middle: /:param(a|b)?/rest
+  T extends `${infer Before}:${infer _Name}(${infer Constraint})?/${infer After}`
+    ?
+        | PatternToPath<`${Before}${After}`>
+        | `${Before}${ParseConstraintPath<Constraint>}/${PatternToPath<After>}`
+    : // Optional + constrained param at end: /path/:param(a|b)?
+      T extends `${infer Before}:${infer _Name}(${infer Constraint})?`
+      ? Before | `${Before}${ParseConstraintPath<Constraint>}`
+      : // Constrained param in middle: /:param(a|b)/rest
+        T extends `${infer Before}:${infer _Name}(${infer Constraint})/${infer After}`
+        ? `${Before}${ParseConstraintPath<Constraint>}/${PatternToPath<After>}`
+        : // Constrained param at end: /path/:param(a|b)
+          T extends `${infer Before}:${infer _Name}(${infer Constraint})`
+          ? `${Before}${ParseConstraintPath<Constraint>}`
+          : // Optional param in middle: /:param?/rest
+            T extends `${infer Before}:${infer _Param}?/${infer After}`
+            ?
+                | PatternToPath<`${Before}${After}`>
+                | `${Before}${string}/${PatternToPath<After>}`
+            : // Optional param at end: /path/:param?
+              T extends `${infer Before}:${infer _Param}?`
+              ? Before | `${Before}${string}`
+              : // Required param in middle: /:param/rest
+                T extends `${infer Before}:${infer _Param}/${infer After}`
+                ? `${Before}${string}/${PatternToPath<After>}`
+                : // Required param at end: /path/:param
+                  T extends `${infer Before}:${infer _Param}`
+                  ? `${Before}${string}`
+                  : // Static path
+                    T;
+
+/**
+ * Allow optional query string (?...) and/or hash fragment (#...) suffix
+ *
+ * @example
+ * WithSuffix<"/about"> = "/about" | "/about?..." | "/about#..." | "/about?...#..."
+ */
+type WithSuffix<T extends string> =
+  | T
+  | `${T}?${string}`
+  | `${T}#${string}`
+  | `${T}?${string}#${string}`;
+
+/**
+ * Helper type to get pattern from routes, handling string values and { path, response } objects
+ */
+type RoutePattern<TRoutes, K extends keyof TRoutes> = TRoutes[K] extends string
+  ? TRoutes[K]
+  : TRoutes[K] extends { readonly path: infer P extends string }
+    ? P
+    : string;
+
+/**
+ * Reverse lookup: find route name where the pattern matches TPattern
+ */
+type NameForPattern<TPattern extends string, TRoutes = GetRegisteredRoutes> = {
+  [K in keyof TRoutes]: RoutePattern<TRoutes, K> extends TPattern ? K : never;
+}[keyof TRoutes];
+
+/**
+ * Look up the response data type for a route pattern from RegisteredRoutes.
+ *
+ * Works by reverse-looking up the route name for the given pattern,
+ * then extracting the response type from the route entry.
+ *
+ * For static routes (no params), pattern === path:
+ *   PathResponse<"/api/health"> → { status: string; timestamp: number }
+ *
+ * For dynamic routes, use the pattern:
+ *   PathResponse<"/api/products/:id"> → Product
+ */
+export type PathResponse<
+  TPattern extends string,
+  TRoutes = GetRegisteredRoutes,
+> = ResponseEnvelope<
+  {
+    [K in keyof TRoutes]: RoutePattern<TRoutes, K> extends TPattern
+      ? TRoutes[K] extends { readonly response: infer R }
+        ? Exclude<R, Response>
+        : never
+      : never;
+  }[keyof TRoutes]
+>;
+
+/**
+ * Strip trailing slash from a path (e.g., "/blog/" -> "/blog" | "/blog/")
+ * Allows navigation to include() prefixes without requiring trailing slash
+ */
+type OptionalTrailingSlash<T extends string> = T extends `${infer Base}/`
+  ? Base extends ""
+    ? T
+    : Base | T
+  : T;
+
+/**
+ * Union of all valid paths from registered routes
+ *
+ * Generated from RSCRouter.RegisteredRoutes via module augmentation.
+ * Allows optional query strings and hash fragments.
+ */
+export type ValidPaths<TRoutes = GetRegisteredRoutes> =
+  keyof TRoutes extends never
+    ? `/${string}` // Fallback when no routes are registered
+    : WithSuffix<
+        {
+          [K in keyof TRoutes]: OptionalTrailingSlash<
+            PatternToPath<RoutePattern<TRoutes, K>>
+          >;
+        }[keyof TRoutes]
+      >;
+
+/**
+ * Type-safe href function for client-side use
+ *
+ * Without mount: identity function, validates absolute paths at compile time.
+ * With mount: prepends mount path, for use with useMount() inside include() scopes.
+ *
+ * @param path - A valid path matching one of the registered route patterns
+ * @param mount - Optional mount prefix from useMount() for include-scoped paths
+ * @returns The resolved path
+ *
+ * @example
+ * ```typescript
+ * // Absolute paths (type-safe)
+ * href("/blog/hello");           // "/blog/hello"
+ * href("/shop/product/widget");  // "/shop/product/widget"
+ *
+ * // With mount (inside an include)
+ * const mount = useMount();      // "/articles"
+ * href("/", mount);              // "/articles/"
+ * href("/my-post", mount);       // "/articles/my-post"
+ *
+ * // Query strings and hashes pass through
+ * href("/blog/hello?page=1");
+ * href("/about#contact");
+ * ```
+ */
+export function href<T extends ValidPaths>(path: T, mount?: string): string {
+  if (mount && mount !== "/") {
+    // Strip trailing slash from mount to avoid double-slash when joining
+    const normalizedMount = mount.endsWith("/") ? mount.slice(0, -1) : mount;
+    return normalizedMount + path;
+  }
+  return path;
+}
+
+/**
+ * Props shape returned by href.json() etc. for spreading on <Link>.
+ * Sets data-external to trigger hard navigation (skips RSC fetch).
+ */
+export interface ResponseHrefProps {
+  to: string;
+  "data-external": "";
+}
+
+type ResponseHrefFn = <T extends ValidPaths>(
+  path: T,
+  mount?: string,
+) => ResponseHrefProps;
+
+function createResponseHrefTag(): ResponseHrefFn {
+  return (path, mount) => ({
+    to: href(path, mount),
+    "data-external": "" as const,
+  });
+}
+
+export namespace href {
+  export const json: ResponseHrefFn = createResponseHrefTag();
+  export const text: ResponseHrefFn = createResponseHrefTag();
+  export const html: ResponseHrefFn = createResponseHrefTag();
+  export const xml: ResponseHrefFn = createResponseHrefTag();
+  export const md: ResponseHrefFn = createResponseHrefTag();
+  export const image: ResponseHrefFn = createResponseHrefTag();
+  export const stream: ResponseHrefFn = createResponseHrefTag();
+  export const any: ResponseHrefFn = createResponseHrefTag();
+}

package/src/index.rsc.ts

@@ -0,0 +1,233 @@
+/**
+ * @rangojs/router (react-server environment)
+ *
+ * This file is used when importing "@rangojs/router" from RSC (server components).
+ * It re-exports everything from the universal index.ts plus adds server-side
+ * implementations that replace the client-side error stubs.
+ *
+ * The bundler uses the "react-server" export condition to select this file
+ * in RSC context, while the regular index.ts is used in client components.
+ */
+
+// Re-export all universal exports from index.ts
+export {
+  // Error classes
+  RouteNotFoundError,
+  DataNotFoundError,
+  notFound,
+  MiddlewareError,
+  HandlerError,
+  BuildError,
+  InvalidHandlerError,
+  RouterError,
+  Skip,
+  isSkip,
+} from "./index.js";
+
+// Re-export all types from types.ts (user-facing types only)
+export type {
+  // Configuration types
+  DocumentProps,
+  DefaultEnv,
+  RouteDefinition,
+  RouteConfig,
+  RouteDefinitionOptions,
+  TrailingSlashMode,
+  // Handler types
+  Handler,
+  HandlerContext,
+  ExtractParams,
+  GenericParams,
+  // Middleware types
+  Middleware,
+  // Revalidation types
+  RevalidateParams,
+  Revalidate,
+  RouteKeys,
+  // Loader types
+  LoaderDefinition,
+  LoaderFn,
+  LoaderContext,
+  FetchableLoaderOptions,
+  LoadOptions,
+  // Error boundary types
+  ErrorInfo,
+  ErrorBoundaryFallbackProps,
+  ErrorBoundaryHandler,
+  ClientErrorBoundaryFallbackProps,
+  // NotFound boundary types
+  NotFoundInfo,
+  NotFoundBoundaryFallbackProps,
+  NotFoundBoundaryHandler,
+  // Error handling callback types
+  ErrorPhase,
+  OnErrorContext,
+  OnErrorCallback,
+} from "./types.js";
+
+// Router options type (server-only, so import directly)
+export type {
+  RSCRouterOptions,
+  SSRStreamMode,
+  SSROptions,
+  ResolveStreamingContext,
+} from "./router.js";
+
+// Server-side createLoader and redirect
+export {
+  createLoader,
+  redirect,
+  type RouteHelpers,
+  type RouteHandlers,
+  // Globally importable route helpers for composition
+  layout,
+  cache,
+  middleware,
+  revalidate,
+  loader,
+  loading,
+  parallel,
+  intercept,
+  when,
+  errorBoundary,
+  notFoundBoundary,
+  transition,
+} from "./route-definition.js";
+
+// Composition types for reusable callback factories
+export type {
+  RouteUseItem,
+  LayoutUseItem,
+  AllUseItems,
+  UseItems,
+} from "./route-types.js";
+
+// Handle API
+export { createHandle, isHandle, type Handle } from "./handle.js";
+
+// Context variable API (typed ctx.set/ctx.get tokens)
+export { createVar, type ContextVar } from "./context-var.js";
+
+// CSP nonce token (use with ctx.get(nonce) in middleware/handlers)
+export { nonce } from "./rsc/nonce.js";
+
+// Pre-render handler API
+export {
+  Prerender,
+  type PrerenderHandlerDefinition,
+  type PrerenderPassthroughContext,
+  type PrerenderOptions,
+  type BuildContext,
+  type StaticBuildContext,
+  type GetParamsContext,
+} from "./prerender.js";
+
+// Static handler API
+export { Static, type StaticHandlerDefinition } from "./static-handler.js";
+
+// Django-style URL patterns (RSC/server context)
+export {
+  urls,
+  type PathHelpers,
+  type PathOptions,
+  type UrlPatterns,
+  type IncludeOptions,
+  type IncludeItem,
+  type RouteResponse,
+  type ResponseError,
+  type ResponseEnvelope,
+  type ResponseHandler,
+  type ResponseHandlerContext,
+  type JsonResponseHandler,
+  type TextResponseHandler,
+  type JsonValue,
+  type ResponsePathFn,
+  type JsonResponsePathFn,
+  type TextResponsePathFn,
+} from "./urls.js";
+
+// Core router (server-side)
+export {
+  createRouter,
+  type RSCRouter,
+  type RootLayoutProps,
+  type RouterRequestInput,
+} from "./router.js";
+
+// RSC handler types (server-side)
+export type { HandlerCacheConfig } from "./rsc/types.js";
+
+// Built-in handles (server-side)
+export { Meta } from "./handles/meta.js";
+export { Breadcrumbs, type BreadcrumbItem } from "./handles/breadcrumbs.js";
+
+// Request context (for accessing request data in server actions/components).
+// Re-exported with a narrowed return type so that public consumers only see
+// public members. Internal code imports from "./server/request-context.js"
+// directly and gets the full type.
+import { getRequestContext as _getRequestContextInternal } from "./server/request-context.js";
+export type { PublicRequestContext as RequestContext } from "./server/request-context.js";
+import type { PublicRequestContext } from "./server/request-context.js";
+import type { DefaultEnv } from "./types/global-namespace.js";
+
+export const getRequestContext: <
+  TEnv = DefaultEnv,
+>() => PublicRequestContext<TEnv> = _getRequestContextInternal;
+
+// Request-scoped shorthands
+export {
+  cookies,
+  headers,
+  type CookieStore,
+  type Cookie,
+  type ReadonlyHeaders,
+} from "./server/cookie-store.js";
+
+// Meta types
+export type { MetaDescriptor, MetaDescriptorBase } from "./router/types.js";
+
+// Middleware context types
+export type { MiddlewareContext, CookieOptions } from "./router/middleware.js";
+
+// Reverse type utilities for type-safe URL generation (Django-style URL reversal)
+export type {
+  ScopedReverseFunction,
+  ReverseFunction,
+  ExtractLocalRoutes,
+  ParamsFor,
+} from "./reverse.js";
+export { scopedReverse, createReverse } from "./reverse.js";
+
+// Search params schema types
+export type {
+  SearchSchema,
+  SearchSchemaValue,
+  ResolveSearchSchema,
+  RouteSearchParams,
+  RouteParams,
+} from "./search-params.js";
+
+// Location state (universal)
+export {
+  createLocationState,
+  type LocationStateDefinition,
+  type LocationStateEntry,
+  type LocationStateOptions,
+} from "./browser/react/location-state-shared.js";
+
+// Path-based response type lookup from RegisteredRoutes
+export type { PathResponse } from "./href-client.js";
+
+// Telemetry sink
+export { createConsoleSink } from "./router/telemetry.js";
+export { createOTelSink } from "./router/telemetry-otel.js";
+export type { OTelTracer, OTelSpan } from "./router/telemetry-otel.js";
+export type { TelemetrySink, TelemetryEvent } from "./router/telemetry.js";
+
+// Timeout types and error class
+export { RouterTimeoutError } from "./router/timeout.js";
+export type {
+  RouterTimeouts,
+  TimeoutPhase,
+  TimeoutContext,
+} from "./router/timeout.js";