@rangojs/router 0.0.0-experimental.42 → 0.0.0-experimental.44

package/dist/route-content-wrapper.js

@@ -1,77 +0,0 @@
-"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

@@ -1 +0,0 @@
-{"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

@@ -1,421 +0,0 @@
-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

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