@rangojs/router 0.0.0-experimental.2 → 0.0.0-experimental.21

package/dist/route-content-wrapper.js

@@ -0,0 +1,77 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Suspense, use, useId } from "react";
+import { invariant } from "./errors";
+import { OutletProvider } from "./client.js";
+import { isLoaderDataResult } from "./types.js";
+/**
+ * Stable async wrapper component for route content
+ * Using a module-level component ensures React sees the same component reference
+ * across renders, preventing unnecessary remounts during actions.
+ *
+ * When content is a pending promise, React suspends and shows the nearest
+ * Suspense fallback. When content is already resolved, it renders immediately
+ * without suspension.
+ *
+ * @param segmentId - Stable ID from segment, used for consistent keys across renders
+ */
+export function RouteContentWrapper({ content, fallback, segmentId, }) {
+    if (!content) {
+        // Already resolved
+        return content;
+    }
+    return (_jsx(Suspense, { fallback: fallback ?? null, children: _jsx(Suspender, { content: content }, segmentId) }, segmentId ? "route-content-suspense-" + segmentId : undefined));
+}
+export function RouteContentWrapperCallback({ resolve, fallback, children, }) {
+    const id = useId();
+    invariant(children, "RouteContentWrapperCallback requires children");
+    invariant(typeof children === "function", "RouteContentWrapperCallback requires children to be a function");
+    invariant(resolve !== undefined, "RouteContentWrapperCallback requires resolve");
+    return (_jsx(Suspense, { fallback: fallback ?? null, children: _jsx(SuspenderCallback, { resolve: resolve, children: children }, id) }, "route-content-suspense-callback-" + id));
+}
+const Suspender = ({ content, }) => {
+    invariant(content instanceof Promise, "Suspender expects a Promise content");
+    return use(content);
+};
+const SuspenderCallback = ({ resolve, children, }) => {
+    return resolve instanceof Promise
+        ? children(use(resolve))
+        : children(resolve);
+};
+export function LoaderBoundary({ loaderDataPromise, loaderIds, fallback, outletKey, outletContent, segment, parallel, children, }) {
+    return (_jsx(Suspense, { fallback: fallback ?? null, children: _jsx(LoaderResolver, { loaderDataPromise: loaderDataPromise, loaderIds: loaderIds, outletKey: outletKey, outletContent: outletContent, segment: segment, parallel: parallel, children: children }) }, `loader-boundary-${outletKey}`));
+}
+/**
+ * Internal component that resolves loader promises and renders OutletProvider
+ */
+function LoaderResolver({ loaderDataPromise, loaderIds, outletKey, outletContent, segment, parallel, children, }) {
+    // Resolve loader promises using React's use()
+    const resolvedData = loaderDataPromise instanceof Promise
+        ? use(loaderDataPromise)
+        : loaderDataPromise;
+    // Build loaderData record from resolved values
+    const loaderData = {};
+    let loaderErrorFallback = null;
+    loaderIds.forEach((id, i) => {
+        const result = resolvedData[i];
+        if (isLoaderDataResult(result)) {
+            if (result.ok) {
+                loaderData[id] = result.data;
+            }
+            else {
+                if (result.fallback) {
+                    loaderErrorFallback = result.fallback;
+                }
+                else {
+                    throw new Error(result.error.message);
+                }
+            }
+        }
+        else {
+            // Legacy format - direct data
+            loaderData[id] = result;
+        }
+    });
+    return (_jsx(OutletProvider, { content: outletContent, segment: segment, parallel: parallel, loaderData: Object.keys(loaderData).length > 0 ? loaderData : undefined, children: loaderErrorFallback ?? children }, outletKey));
+}
+//# sourceMappingURL=route-content-wrapper.js.map

package/dist/route-content-wrapper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-content-wrapper.js","sourceRoot":"","sources":["../src/route-content-wrapper.tsx"],"names":[],"mappings":"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"}

package/dist/route-definition.d.ts

@@ -0,0 +1,421 @@
+import type { ReactNode } from "react";
+import type { PartialCacheOptions, DefaultEnv, ErrorBoundaryHandler, ExtractRouteParams, Handler, LoaderDefinition, MiddlewareFn, NotFoundBoundaryHandler, ResolvedRouteMap, RouteDefinition, RouteDefinitionOptions, ShouldRevalidateFn, TrailingSlashMode } from "./types.js";
+import { type InterceptWhenFn } from "./server/context";
+import type { AllUseItems, LayoutItem, RouteItem, ParallelItem, InterceptItem, MiddlewareItem, RevalidateItem, LoaderItem, LoadingItem, ErrorBoundaryItem, NotFoundBoundaryItem, LayoutUseItem, RouteUseItem, ParallelUseItem, InterceptUseItem, LoaderUseItem, WhenItem, CacheItem } from "./route-types.js";
+/**
+ * Result of route() function with paths and trailing slash config
+ */
+export interface RouteDefinitionResult<T extends RouteDefinition> {
+    routes: ResolvedRouteMap<T>;
+    trailingSlash: Record<string, TrailingSlashMode>;
+}
+/**
+ * Define routes with optional trailing slash configuration
+ *
+ * @example
+ * ```typescript
+ * // Simple string paths
+ * const routes = route({
+ *   blog: "/blog",
+ *   post: "/blog/:id",
+ * });
+ *
+ * // With trailing slash config
+ * const routes = route({
+ *   blog: "/blog",
+ *   api: { path: "/api", trailingSlash: "ignore" },
+ * }, { trailingSlash: "never" }); // global default
+ * ```
+ */
+export declare function route<const T extends RouteDefinition>(input: T, options?: RouteDefinitionOptions): ResolvedRouteMap<T> & {
+    __trailingSlash?: Record<string, TrailingSlashMode>;
+};
+export type { AllUseItems, LayoutItem, RouteItem, ParallelItem, InterceptItem, MiddlewareItem, RevalidateItem, LoaderItem, ErrorBoundaryItem, NotFoundBoundaryItem, LayoutUseItem, RouteUseItem, ParallelUseItem, InterceptUseItem, WhenItem, CacheItem, } from "./route-types.js";
+export type { InterceptSelectorContext, InterceptSegmentsState, InterceptWhenFn, } from "./server/context";
+/**
+ * Route helpers provided by map()
+ * These are the only typed helpers users interact with
+ */
+export type RouteHelpers<T extends RouteDefinition, TEnv> = {
+    /**
+     * Define a route handler for a specific route pattern
+     * ```typescript
+     * route("products.detail", async (ctx) => {
+     *   const product = await getProduct(ctx.params.slug);
+     *   return <ProductPage product={product} />;
+     * })
+     *
+     * // With nested use() for middleware, loaders, etc.
+     * route("products.detail", ProductHandler, () => [
+     *   loader(ProductLoader),
+     *   loading(<ProductSkeleton />),
+     * ])
+     * ```
+     * @param name - Route name matching a key from route definitions
+     * @param handler - Async function that returns JSX for the route
+     * @param use - Optional callback returning middleware, loaders, loading, etc.
+     */
+    route: <K extends keyof ResolvedRouteMap<T> & string>(name: K, handler: Handler<ExtractRouteParams<T, K & string>, {}, TEnv>, use?: () => RouteUseItem[]) => RouteItem;
+    /**
+     * Define a layout that wraps child routes
+     * ```typescript
+     * layout(<RootLayout />, () => [
+     *   route("home", HomePage),
+     *   route("about", AboutPage),
+     * ])
+     *
+     * // With dynamic layout handler
+     * layout(async (ctx) => {
+     *   const user = ctx.get("user");
+     *   return <DashboardShell user={user} />;
+     * }, () => [
+     *   middleware(authMiddleware),
+     *   route("dashboard", DashboardPage),
+     * ])
+     * ```
+     * @param component - Static JSX or async handler for the layout
+     * @param use - Callback returning child routes, middleware, loaders, etc.
+     */
+    layout: (component: ReactNode | Handler<any, any, TEnv>, use?: () => LayoutUseItem[]) => LayoutItem;
+    /**
+     * Define parallel routes that render simultaneously in named slots
+     * ```typescript
+     * parallel({
+     *   "@sidebar": <Sidebar />,
+     *   "@main": async (ctx) => <MainContent data={ctx.use(DataLoader)} />,
+     * })
+     *
+     * // With loaders and loading states
+     * parallel({
+     *   "@analytics": AnalyticsPanel,
+     *   "@metrics": MetricsPanel,
+     * }, () => [
+     *   loader(DashboardLoader),
+     *   loading(<DashboardSkeleton />),
+     * ])
+     * ```
+     * @param slots - Object with slot names (prefixed with @) mapped to handlers
+     * @param use - Optional callback for loaders, loading, revalidate, etc.
+     */
+    parallel: <TSlots extends Record<`@${string}`, Handler<any, any, TEnv> | ReactNode>>(slots: TSlots, use?: () => ParallelUseItem[]) => ParallelItem;
+    /**
+     * Define an intercepting route for soft navigation
+     *
+     * When soft-navigating to the target route from within the current layout,
+     * the intercept handler renders in the named slot instead of the route's
+     * default handler. Direct navigation uses the route's handler.
+     *
+     * ```typescript
+     * // In a layout - intercept "card" route as modal
+     * layout(<KanbanLayout />, () => [
+     *   intercept("@modal", "card", () => <CardModal />),
+     * ])
+     *
+     * // With loaders and revalidation
+     * intercept("@modal", "card", () => <CardModal />, () => [
+     *   loader(CardModalLoader),
+     *   revalidate(() => false),
+     * ])
+     * ```
+     * @param slotName - Named slot (prefixed with @) where intercept renders
+     * @param routeName - Route name to intercept
+     * @param handler - Component or handler for intercepted render
+     * @param use - Optional callback for loaders, middleware, revalidate, etc.
+     */
+    intercept: <K extends keyof ResolvedRouteMap<T> & string>(slotName: `@${string}`, routeName: K, handler: ReactNode | Handler<ExtractRouteParams<T, K>, {}, TEnv>, use?: () => InterceptUseItem[]) => InterceptItem;
+    /**
+     * Attach middleware to the current route/layout
+     * ```typescript
+     * middleware(async (ctx, next) => {
+     *   const session = await getSession(ctx.request);
+     *   if (!session) return redirect("/login");
+     *   ctx.set("user", session.user);
+     *   next();
+     * })
+     *
+     * // Chain multiple middleware
+     * middleware(authMiddleware, loggingMiddleware, rateLimitMiddleware)
+     * ```
+     * @param fns - One or more middleware functions to execute in order
+     */
+    middleware: (...fns: MiddlewareFn<TEnv>[]) => MiddlewareItem;
+    /**
+     * Control when a segment should revalidate during navigation
+     * ```typescript
+     * // Revalidate when params change
+     * revalidate(({ currentParams, nextParams }) =>
+     *   currentParams.slug !== nextParams.slug
+     * )
+     *
+     * // Revalidate after specific actions (actionId format: "path/to/file.ts#exportName")
+     * revalidate(({ actionId }) =>
+     *   actionId?.includes("Cart") ?? false
+     * )
+     *
+     * // Soft decision (suggest but allow override)
+     * revalidate(({ defaultShouldRevalidate }) =>
+     *   ({ defaultShouldRevalidate: true })
+     * )
+     * ```
+     * @param fn - Function that returns boolean (hard) or { defaultShouldRevalidate } (soft)
+     */
+    revalidate: (fn: ShouldRevalidateFn<any, TEnv>) => RevalidateItem;
+    /**
+     * Attach a data loader to the current route/layout
+     * ```typescript
+     * loader(ProductLoader)
+     *
+     * // With loader-specific revalidation (match by file or export name)
+     * loader(CartLoader, () => [
+     *   revalidate(({ actionId }) => actionId?.includes("Cart") ?? false),
+     * ])
+     *
+     * // Access loader data in handlers via ctx.use()
+     * route("products.detail", async (ctx) => {
+     *   const product = await ctx.use(ProductLoader);
+     *   return <ProductPage product={product} />;
+     * })
+     * ```
+     * @param loaderDef - Loader created with createLoader()
+     * @param use - Optional callback for loader-specific revalidation rules
+     */
+    loader: <TData>(loaderDef: LoaderDefinition<TData>, use?: () => LoaderUseItem[]) => LoaderItem;
+    /**
+     * Attach a loading component to the current route/layout
+     * ```typescript
+     * // Show loading on all requests (including SSR)
+     * loading(<Skeleton />)
+     *
+     * // Skip loading on SSR, only show on client navigation
+     * loading(<Skeleton />, { ssr: false })
+     * ```
+     * @param component - The loading UI to show during navigation
+     * @param options - Configuration options
+     * @param options.ssr - If false, skip showing loading on document requests (SSR)
+     */
+    loading: (component: ReactNode, options?: {
+        ssr?: boolean;
+    }) => LoadingItem;
+    /**
+     * Attach an error boundary to catch errors in this segment and children
+     * ```typescript
+     * errorBoundary(<ErrorFallback />)
+     *
+     * // With dynamic error handler
+     * errorBoundary(({ error, reset }) => (
+     *   <div>
+     *     <h2>Something went wrong</h2>
+     *     <p>{error.message}</p>
+     *     <button onClick={reset}>Try again</button>
+     *   </div>
+     * ))
+     * ```
+     * @param fallback - Static JSX or handler receiving error info and reset function
+     */
+    errorBoundary: (fallback: ReactNode | ErrorBoundaryHandler) => ErrorBoundaryItem;
+    /**
+     * Attach a not-found boundary to handle notFound() calls in this segment
+     * ```typescript
+     * notFoundBoundary(<ProductNotFound />)
+     *
+     * // With dynamic handler
+     * notFoundBoundary(({ notFound }) => (
+     *   <div>
+     *     <h2>{notFound.message}</h2>
+     *     <a href="/products">Browse all products</a>
+     *   </div>
+     * ))
+     * ```
+     * @param fallback - Static JSX or handler receiving not-found info
+     */
+    notFoundBoundary: (fallback: ReactNode | NotFoundBoundaryHandler) => NotFoundBoundaryItem;
+    /**
+     * Define a condition for when an intercept should activate
+     *
+     * Only valid inside intercept() use() callback. When multiple when() calls
+     * are present, ALL must return true for the intercept to activate.
+     * If no when() is defined, the intercept always activates on soft navigation.
+     *
+     * Context properties:
+     * - `from` - Source URL (where user is navigating from)
+     * - `to` - Destination URL (where user is navigating to)
+     * - `params` - Matched route params
+     * - `segments` - Client's current segments with `path` and `ids`
+     *
+     * ```typescript
+     * // Only intercept when coming from the board page
+     * intercept("@modal", "card", <CardModal />, () => [
+     *   when(({ from }) => from.pathname.startsWith("/board")),
+     *   loader(CardDetailLoader),
+     * ])
+     *
+     * // Use segments to check current route context
+     * intercept("@modal", "card", <CardModal />, () => [
+     *   when(({ segments }) => segments.path[0] === "kanban"),
+     * ])
+     *
+     * // Multiple conditions (AND logic)
+     * intercept("@modal", "card", <CardModal />, () => [
+     *   when(({ from }) => from.pathname.startsWith("/board")),
+     *   when(({ segments }) => segments.ids.includes("kanban-layout")),
+     * ])
+     * ```
+     * @param fn - Selector function receiving navigation context, returns boolean
+     */
+    when: (fn: InterceptWhenFn) => WhenItem;
+    /**
+     * Define cache configuration for segments
+     *
+     * Creates a cache boundary that applies to all children unless overridden.
+     * Cache config inherits down the route tree like middleware wrapping.
+     *
+     * When ttl is not specified, uses store defaults (explicit store first,
+     * then app-level store). When store is not specified, uses app-level store.
+     *
+     * Note: Loaders are NOT cached by default. Use cache() inside loader()
+     * to explicitly opt-in to loader caching.
+     *
+     * ```typescript
+     * // Using app-level defaults (ttl inherited from store.defaults)
+     * cache(() => [
+     *   layout(<BlogLayout />),      // cached with default TTL
+     *   route("post/:slug"),         // cached with default TTL
+     * ])
+     *
+     * // Cache all segments with explicit 60s TTL
+     * cache({ ttl: 60 }, () => [
+     *   layout(<BlogLayout />),      // cached
+     *   route("post/:slug"),         // cached
+     * ])
+     *
+     * // With stale-while-revalidate
+     * cache({ ttl: 60, swr: 300 }, () => [
+     *   route("product/:id"),
+     * ])
+     *
+     * // Override for specific section
+     * cache({ ttl: 60 }, () => [
+     *   layout(<RootLayout />),
+     *   cache({ ttl: 300 }, () => [
+     *     route("static-page"),     // longer TTL
+     *   ]),
+     *   cache(false, () => [
+     *     route("admin"),           // not cached
+     *   ]),
+     * ])
+     *
+     * // Use different store for specific routes
+     * cache({ store: kvStore, ttl: 3600 }, () => [
+     *   route("archive/:year"),     // uses KV store
+     * ])
+     *
+     * // Opt-in loader caching
+     * route("product/:id", ProductHandler, () => [
+     *   loader(ProductLoader),               // NOT cached (default)
+     *   loader(StaticMetadata, () => [
+     *     cache({ ttl: 3600 }),              // cached for 1 hour
+     *   ]),
+     * ])
+     * ```
+     * @param optionsOrChildren - Cache options, false to disable, or children callback
+     * @param children - Optional callback returning child segments (when first arg is options)
+     */
+    cache: {
+        (): CacheItem;
+        (children: () => AllUseItems[]): CacheItem;
+        (options: PartialCacheOptions | false, use?: () => AllUseItems[]): CacheItem;
+    };
+};
+/**
+ * Branded type for route handlers that carries the route type info.
+ * This enables type-safe verification that imported handlers match route definitions.
+ */
+export interface RouteHandlers<T extends RouteDefinition> {
+    (): Array<AllUseItems>;
+    /** Brand to carry route type info for type checking */
+    readonly __routes: T;
+}
+/**
+ * Type-safe handler definition helper
+ *
+ */
+export declare function map<const T extends RouteDefinition, TEnv = DefaultEnv>(builder: (helpers: RouteHelpers<T, TEnv>) => Array<AllUseItems>): RouteHandlers<T>;
+/**
+ * Create RouteHelpers for inline route definitions
+ * Used internally by router.map() for inline handler syntax
+ */
+export declare function createRouteHelpers<T extends RouteDefinition, TEnv>(): RouteHelpers<T, TEnv>;
+/**
+ * Create a loader definition
+ *
+ * Loaders are RSC-compatible data fetchers that:
+ * - Run after middleware, before handlers
+ * - Are scoped to where attached (layout/route subtree)
+ * - Revalidate independently from UI segments
+ * - Are memoized per request (multiple ctx.use() calls return same value)
+ *
+ * Use the `"use server"` directive inside the loader function to ensure
+ * the function is stripped from client bundles.
+ *
+ * Return type is automatically inferred from the callback.
+ *
+ * @param fn - Async function that fetches data (should contain "use server" directive)
+ * @param fetchable - Optional flag to make the loader fetchable via useFetchLoader
+ *
+ * @example
+ * ```typescript
+ * // loaders/cart.ts - return type inferred from callback
+ * export const CartLoader = createLoader(async (ctx) => {
+ *   "use server";
+ *   const user = ctx.get("user");
+ *   return await db.cart.get(user.id); // Return type inferred!
+ * });
+ *
+ * // loaders/product.ts - return type inferred
+ * export const ProductLoader = createLoader(async (ctx) => {
+ *   "use server";
+ *   const { slug } = ctx.params;
+ *   return await db.products.findBySlug(slug); // Return type inferred!
+ * });
+ *
+ * // Usage in handlers
+ * layout(<ShopLayout />, () => [
+ *   loader(CartLoader),
+ *   loader(CartLoader, () => [
+ *     revalidate(({ actionId }) => actionId?.includes("Cart") ?? false),
+ *   ]),
+ * ])
+ *
+ * // Server-side access
+ * route("cart", (ctx) => {
+ *   const cart = ctx.use(CartLoader);
+ *   return <CartPage cart={cart} />;
+ * });
+ *
+ * // Client-side access
+ * const cart = useLoader(CartLoader);
+ * ```
+ */
+export { createLoader } from "./loader.rsc.js";
+/**
+ * Create a soft redirect Response for middleware short-circuit
+ *
+ * Returns a Response that signals a client-side navigation to the target URL.
+ * Unlike Response.redirect() which causes a full page reload, this redirect
+ * is handled by the router for SPA-style navigation.
+ *
+ * @param url - The URL to redirect to
+ * @param status - HTTP status code (default: 302)
+ *
+ * @example
+ * ```typescript
+ * middleware((ctx, next) => {
+ *   if (!ctx.get('user')) {
+ *     return redirect('/login');
+ *   }
+ *   next();
+ * })
+ * ```
+ */
+export declare function redirect(url: string, status?: number): Response;
+//# sourceMappingURL=route-definition.d.ts.map

package/dist/route-definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-definition.d.ts","sourceRoot":"","sources":["../src/route-definition.ts"],"names":[],"mappings":"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"}