@rangojs/router 0.0.0-experimental.101 → 0.0.0-experimental.102

package/dist/route-definition.js

@@ -1,868 +0,0 @@
-import { getContext, getNamePrefix, getUrlPrefix, } from "./server/context";
-import { invariant } from "./errors";
-import { isStaticHandler } from "./static-handler.js";
-import RootLayout from "./server/root-layout";
-/**
- * Check if a value is a RouteConfig object
- */
-function isRouteConfig(value) {
-    return (typeof value === "object" &&
-        value !== null &&
-        "path" in value &&
-        typeof value.path === "string");
-}
-/**
- * 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 function route(input, options) {
-    const trailingSlash = {};
-    const routes = flattenRoutes(input, "", trailingSlash, options?.trailingSlash);
-    // Attach trailing slash config as a non-enumerable property
-    // This keeps backwards compatibility while passing the config through
-    const result = routes;
-    if (Object.keys(trailingSlash).length > 0) {
-        Object.defineProperty(result, "__trailingSlash", {
-            value: trailingSlash,
-            enumerable: false,
-            writable: false,
-        });
-    }
-    return result;
-}
-/**
- * Flatten nested route definitions
- */
-function flattenRoutes(routes, prefix, trailingSlashConfig, defaultTrailingSlash) {
-    const flattened = {};
-    for (const [key, value] of Object.entries(routes)) {
-        const fullKey = prefix + key;
-        if (typeof value === "string") {
-            // Direct route pattern - include prefix
-            flattened[fullKey] = value;
-            // Apply default trailing slash if set
-            if (defaultTrailingSlash) {
-                trailingSlashConfig[fullKey] = defaultTrailingSlash;
-            }
-        }
-        else if (isRouteConfig(value)) {
-            // Route config object with path and optional trailingSlash
-            flattened[fullKey] = value.path;
-            // Use route-specific config or fall back to default
-            const mode = value.trailingSlash ?? defaultTrailingSlash;
-            if (mode) {
-                trailingSlashConfig[fullKey] = mode;
-            }
-        }
-        else {
-            // Nested routes - flatten recursively
-            const nested = flattenRoutes(value, `${fullKey}.`, trailingSlashConfig, defaultTrailingSlash);
-            Object.assign(flattened, nested);
-        }
-    }
-    return flattened;
-}
-/**
- * Check if an item contains routes (directly or inside nested structures like cache).
- * Used to determine if a layout or cache should be treated as an orphan.
- */
-const hasRoutesInItem = (item) => {
-    if (item.type === "route")
-        return true;
-    // Lazy includes contain deferred routes — treat them as having routes
-    // to prevent the parent layout from being misclassified as orphan,
-    // which would clear its parent pointer and break the middleware chain.
-    if (item.type === "include")
-        return true;
-    if (item.type === "cache" && item.uses) {
-        return item.uses.some((child) => hasRoutesInItem(child));
-    }
-    if (item.type === "layout" && item.uses) {
-        return item.uses.some((child) => hasRoutesInItem(child));
-    }
-    return false;
-};
-const revalidate = (fn) => {
-    const ctx = getContext().getStore();
-    if (!ctx)
-        throw new Error("revalidate() must be called inside map()");
-    // Attach to last entry in stack
-    const parent = ctx.parent;
-    if (!parent || !("revalidate" in parent)) {
-        invariant(false, "No parent entry available for revalidate()");
-    }
-    const name = `$${getContext().getNextIndex("revalidate")}`;
-    parent.revalidate.push(fn);
-    return { name, type: "revalidate" };
-};
-/**
- * Error boundary helper - attaches an error fallback to the current entry
- *
- * When an error occurs during rendering of this segment or its children,
- * the fallback will be rendered instead. The fallback can be:
- * - A static ReactNode (e.g., <ErrorPage />)
- * - A handler function that receives error info and reset function
- *
- * Error boundaries catch errors from:
- * - Middleware execution
- * - Loader execution
- * - Handler/component rendering
- *
- * @example
- * ```typescript
- * layout(<ShopLayout />, () => [
- *   errorBoundary(<ShopErrorFallback />),
- *   route("products.detail", ProductDetail),
- * ])
- *
- * // Or with handler for dynamic error UI:
- * route("products.detail", ProductDetail, () => [
- *   errorBoundary(({ error, reset }) => (
- *     <div>
- *       <h2>Product failed to load</h2>
- *       <p>{error.message}</p>
- *       <button onClick={reset}>Retry</button>
- *     </div>
- *   )),
- * ])
- * ```
- */
-const errorBoundary = (fallback) => {
-    const ctx = getContext().getStore();
-    if (!ctx)
-        throw new Error("errorBoundary() must be called inside map()");
-    // Attach to parent entry in stack
-    const parent = ctx.parent;
-    if (!parent || !("errorBoundary" in parent)) {
-        invariant(false, "No parent entry available for errorBoundary()");
-    }
-    const name = `$${getContext().getNextIndex("errorBoundary")}`;
-    parent.errorBoundary.push(fallback);
-    return { name, type: "errorBoundary" };
-};
-/**
- * NotFound boundary helper - attaches a not-found fallback to the current entry
- *
- * When a DataNotFoundError is thrown (via notFound()) during rendering of this
- * segment or its children, the fallback will be rendered instead. The fallback can be:
- * - A static ReactNode (e.g., <ProductNotFound />)
- * - A handler function that receives not found info
- *
- * NotFound boundaries catch DataNotFoundError from:
- * - Loader execution
- * - Handler/component rendering
- *
- * @example
- * ```typescript
- * layout(<ShopLayout />, () => [
- *   notFoundBoundary(<ProductNotFound />),
- *   route("products.detail", ProductDetail),
- * ])
- *
- * // Or with handler for dynamic not found UI:
- * route("products.detail", ProductDetail, () => [
- *   notFoundBoundary(({ notFound }) => (
- *     <div>
- *       <h2>Product not found</h2>
- *       <p>{notFound.message}</p>
- *       <a href="/products">Browse all products</a>
- *     </div>
- *   )),
- * ])
- * ```
- */
-const notFoundBoundary = (fallback) => {
-    const ctx = getContext().getStore();
-    if (!ctx)
-        throw new Error("notFoundBoundary() must be called inside map()");
-    // Attach to parent entry in stack
-    const parent = ctx.parent;
-    if (!parent || !("notFoundBoundary" in parent)) {
-        invariant(false, "No parent entry available for notFoundBoundary()");
-    }
-    const name = `$${getContext().getNextIndex("notFoundBoundary")}`;
-    parent.notFoundBoundary.push(fallback);
-    return { name, type: "notFoundBoundary" };
-};
-/**
- * When helper - defines a condition for intercept activation
- *
- * Only valid inside intercept() use() callback. The when() function
- * is captured by the intercept and stored in its `when` array.
- * During soft navigation, all when() conditions must return true
- * for the intercept to activate.
- */
-const when = (fn) => {
-    const ctx = getContext().getStore();
-    if (!ctx)
-        throw new Error("when() must be called inside intercept()");
-    // The when() function needs to be captured by the intercept's tempParent
-    // which should have a `when` array. If not present, we're not inside intercept()
-    const parent = ctx.parent;
-    if (!parent || !("when" in parent)) {
-        invariant(false, "when() can only be used inside intercept() use() callback");
-    }
-    const name = `$${getContext().getNextIndex("when")}`;
-    parent.when.push(fn);
-    return { name, type: "when" };
-};
-/**
- * Cache helper - defines caching configuration for segments
- *
- * Creates a cache boundary that applies to all children unless overridden.
- * When used without children, attaches cache config to the parent entry
- * (e.g., for loader-specific caching).
- *
- * Supports three call signatures:
- * - cache() - no args, uses app-level defaults (for loader caching)
- * - cache(() => [...]) - wraps children with app-level defaults
- * - cache({ ttl: 60 }, () => [...]) - with explicit options
- */
-const cache = (optionsOrChildren, maybeChildren) => {
-    const store = getContext();
-    const ctx = store.getStore();
-    if (!ctx)
-        throw new Error("cache() must be called inside map()");
-    // Handle overloaded signature: cache(), cache(children), or cache(options, children)
-    let options;
-    let children;
-    if (optionsOrChildren === undefined) {
-        // cache() - no args, use defaults
-        options = {};
-        children = undefined;
-    }
-    else if (typeof optionsOrChildren === "function") {
-        // cache(() => [...]) - use empty options (will use defaults)
-        options = {};
-        children = optionsOrChildren;
-    }
-    else {
-        // cache(options, children) - explicit options
-        options = optionsOrChildren;
-        children = maybeChildren;
-    }
-    const name = `$${store.getNextIndex("cache")}`;
-    const cacheConfig = { options };
-    // If no children, create an orphan cache entry (like orphan layouts)
-    // This allows cache() to wrap subsequent siblings
-    if (!children) {
-        const parent = ctx.parent;
-        // Check if we're inside a loader() use() callback - special case for loader caching
-        if (parent && parent.type === "loader") {
-            // Direct assignment to loader entry's cache field
-            parent.cache = cacheConfig;
-            return { name, type: "cache" };
-        }
-        // Create orphan cache entry (like orphan layout)
-        // Subsequent siblings in the same array will attach to this entry
-        const namespace = `${ctx.namespace}.${store.getNextIndex("cache")}`;
-        const cacheUrlPrefix = getUrlPrefix();
-        const entry = {
-            id: namespace,
-            shortCode: store.getShortCode("cache"),
-            type: "cache",
-            parent: parent, // link to current parent for hierarchy
-            cache: cacheConfig,
-            handler: RootLayout,
-            middleware: [],
-            revalidate: [],
-            errorBoundary: [],
-            notFoundBoundary: [],
-            layout: [],
-            parallel: [],
-            intercept: [],
-            loader: [],
-            ...(cacheUrlPrefix ? { mountPath: cacheUrlPrefix } : {}),
-        };
-        // Attach to parent's layout array (cache entries are structural like layouts)
-        if (parent && "layout" in parent) {
-            parent.layout.push(entry);
-        }
-        // Update context parent so subsequent siblings attach to this cache entry
-        // This makes cache() act as sugar for cache(() => [...])
-        ctx.parent = entry;
-        return { name: namespace, type: "cache" };
-    }
-    // With children: create a cache entry (like layout with caching semantics)
-    const cacheNextIndex = store.getNextIndex("cache");
-    const namespace = `${ctx.namespace}.${cacheNextIndex}`;
-    const cacheShortCode = store.getShortCode("cache");
-    const cacheUrlPrefix2 = getUrlPrefix();
-    const entry = {
-        id: namespace,
-        shortCode: cacheShortCode,
-        type: "cache",
-        parent: ctx.parent,
-        cache: cacheConfig,
-        // Cache entries render like layouts (with Outlet as default handler)
-        handler: RootLayout, // RootLayout just renders <Outlet />
-        middleware: [],
-        revalidate: [],
-        errorBoundary: [],
-        notFoundBoundary: [],
-        layout: [],
-        parallel: [],
-        intercept: [],
-        loader: [],
-        ...(cacheUrlPrefix2 ? { mountPath: cacheUrlPrefix2 } : {}),
-    };
-    // Run children with cache entry as parent
-    const result = store.run(namespace, entry, children);
-    invariant(Array.isArray(result) && result.every((item) => isValidUseItem(item)), `cache() children callback must return an array of use items [${namespace}]`);
-    // Check if this cache has routes (including nested caches/layouts)
-    const hasRoutes = result &&
-        Array.isArray(result) &&
-        result.some((item) => hasRoutesInItem(item));
-    if (!hasRoutes) {
-        const parent = ctx.parent;
-        if (parent && "layout" in parent) {
-            // Attach to parent's layout array (cache entries are structural like layouts)
-            entry.parent = null;
-            parent.layout.push(entry);
-        }
-    }
-    return { name: namespace, type: "cache", uses: result };
-};
-const middleware = (...fn) => {
-    const ctx = getContext().getStore();
-    if (!ctx)
-        throw new Error("middleware() must be called inside map()");
-    // Attach to last entry in stack
-    const parent = ctx.parent;
-    if (!parent || !("middleware" in parent)) {
-        invariant(false, "No parent entry available for middleware()");
-    }
-    const name = `$${getContext().getNextIndex("middleware")}`;
-    parent.middleware.push(...fn);
-    return { name, type: "middleware" };
-};
-const parallel = (slots, use) => {
-    const store = getContext();
-    const ctx = store.getStore();
-    if (!ctx)
-        throw new Error("parallel() must be called inside map()");
-    if (!ctx.parent || !ctx.parent?.parallel) {
-        invariant(false, "No parent entry available for parallel()");
-    }
-    invariant(ctx.parent.type !== "parallel", "parallel() cannot be nested inside another parallel()");
-    const namespace = `${ctx.namespace}.$${store.getNextIndex("parallel")}`;
-    // Unwrap any static handler definitions in parallel slots
-    const unwrappedSlots = {};
-    let hasStaticSlot = false;
-    for (const [slotName, slotHandler] of Object.entries(slots)) {
-        if (isStaticHandler(slotHandler)) {
-            hasStaticSlot = true;
-            unwrappedSlots[slotName] = slotHandler.handler;
-        }
-        else {
-            unwrappedSlots[slotName] = slotHandler;
-        }
-    }
-    // Create full EntryData for parallel with its own loaders/revalidate/loading
-    const parallelUrlPrefix = getUrlPrefix();
-    const entry = {
-        id: namespace,
-        shortCode: store.getShortCode("parallel"),
-        type: "parallel",
-        parent: null, // Parallels don't participate in parent chain traversal
-        handler: unwrappedSlots,
-        loading: undefined, // Allow loading() to attach loading state
-        middleware: [],
-        revalidate: [],
-        errorBoundary: [],
-        notFoundBoundary: [],
-        layout: [],
-        parallel: [],
-        intercept: [],
-        loader: [],
-        ...(parallelUrlPrefix ? { mountPath: parallelUrlPrefix } : {}),
-        ...(hasStaticSlot ? { isStaticPrerender: true } : {}),
-    };
-    // Run use callback if provided to collect loaders, revalidate, loading
-    if (use && typeof use === "function") {
-        const result = store.run(namespace, entry, use);
-        invariant(Array.isArray(result) && result.every((item) => isValidUseItem(item)), `parallel() use() callback must return an array of use items [${namespace}]`);
-    }
-    ctx.parent.parallel.push(entry);
-    return { name: namespace, type: "parallel" };
-};
-/**
- * Intercept helper - defines an intercepting route for soft navigation
- */
-const intercept = (slotName, routeName, handler, use) => {
-    const store = getContext();
-    const ctx = store.getStore();
-    if (!ctx)
-        throw new Error("intercept() must be called inside map()");
-    if (!ctx.parent || !ctx.parent?.intercept) {
-        invariant(false, "No parent entry available for intercept()");
-    }
-    invariant(ctx.parent.type !== "parallel", "intercept() cannot be used inside parallel()");
-    const namespace = `${ctx.namespace}.$${store.getNextIndex("intercept")}.${slotName}`;
-    // Apply name prefix to routeName (from include())
-    // This ensures intercepts match prefixed route keys
-    const namePrefix = getNamePrefix();
-    const prefixedRouteName = namePrefix ? `${namePrefix}.${routeName}` : routeName;
-    // Create intercept entry with its own loaders/revalidate/middleware/when
-    const entry = {
-        slotName: slotName,
-        routeName: prefixedRouteName,
-        handler,
-        middleware: [],
-        revalidate: [],
-        errorBoundary: [],
-        notFoundBoundary: [],
-        loader: [],
-        when: [], // Selector conditions for conditional interception
-    };
-    // Run use callback if provided to collect loaders, revalidate, middleware, etc.
-    if (use && typeof use === "function") {
-        // Create a temporary parent context for the use() callback
-        // so that middleware, loader, revalidate attach to the intercept entry
-        const originalParent = ctx.parent;
-        // Capture layouts in a temporary array
-        const capturedLayouts = [];
-        const tempParent = {
-            ...originalParent,
-            middleware: entry.middleware,
-            revalidate: entry.revalidate,
-            errorBoundary: entry.errorBoundary,
-            notFoundBoundary: entry.notFoundBoundary,
-            loader: entry.loader,
-            layout: capturedLayouts, // Capture layout() calls
-            when: entry.when, // Capture when() conditions
-            // Use getter/setter to capture loading on the entry
-            get loading() {
-                return entry.loading;
-            },
-            set loading(value) {
-                entry.loading = value;
-            },
-        };
-        ctx.parent = tempParent;
-        const result = use();
-        // Restore original parent
-        ctx.parent = originalParent;
-        // Extract layout from captured layouts (use first one if multiple)
-        // Layout inside intercept should always be ReactNode or Handler, not Record slots
-        if (capturedLayouts.length > 0 && capturedLayouts[0].type === "layout") {
-            entry.layout = capturedLayouts[0].handler;
-        }
-        invariant(Array.isArray(result) && result.every((item) => isValidUseItem(item)), `intercept() use() callback must return an array of use items [${namespace}]`);
-    }
-    ctx.parent.intercept.push(entry);
-    return { name: namespace, type: "intercept" };
-};
-/**
- * Loader helper - attaches a loader to the current entry
- */
-const loaderFn = (loaderDef, use) => {
-    const store = getContext();
-    const ctx = store.getStore();
-    if (!ctx)
-        throw new Error("loader() must be called inside map()");
-    // Attach to last entry in stack
-    if (!ctx.parent || !ctx.parent?.loader) {
-        invariant(false, "No parent entry available for loader()");
-    }
-    const name = `${ctx.namespace}.$${store.getNextIndex("loader")}`;
-    // Create loader entry with empty revalidate array
-    const loaderEntry = {
-        loader: loaderDef,
-        revalidate: [],
-    };
-    // If use() callback provided, run it to collect revalidation rules
-    if (use && typeof use === "function") {
-        // Temporarily set context for revalidate() calls to target this loader
-        const originalParent = ctx.parent;
-        // Create a temporary "parent" that has the revalidate array we want to populate
-        const tempParent = {
-            ...originalParent,
-            revalidate: loaderEntry.revalidate,
-        };
-        ctx.parent = tempParent;
-        const result = use();
-        // Restore original parent
-        ctx.parent = originalParent;
-        invariant(Array.isArray(result) && result.every((item) => isValidUseItem(item)), `loader() use() callback must return an array of use items [${name}]`);
-    }
-    ctx.parent.loader.push(loaderEntry);
-    return { name, type: "loader" };
-};
-/**
- * Loading helper - attaches a loading component to the current entry
- * Loading components are static (no context) and shown during navigation
- */
-const loadingFn = (component, options) => {
-    const store = getContext();
-    const ctx = store.getStore();
-    if (!ctx)
-        throw new Error("loading() must be called inside map()");
-    const parent = ctx.parent;
-    if (!parent || !("loading" in parent)) {
-        invariant(false, "No parent entry available for loading()");
-    }
-    // If ssr: false and we're in SSR, set loading to false
-    if (options?.ssr === false && ctx.isSSR) {
-        parent.loading = false;
-    }
-    else {
-        parent.loading = component;
-    }
-    const name = `$${store.getNextIndex("loading")}`;
-    return { name, type: "loading" };
-};
-const routeFn = (name, handler, use) => {
-    const store = getContext();
-    const ctx = store.getStore();
-    if (!ctx)
-        throw new Error("route() must be called inside map()");
-    const namespace = `${ctx.namespace}.${store.getNextIndex("route")}.${name}`;
-    const entry = {
-        id: namespace,
-        shortCode: store.getShortCode("route"),
-        type: "route",
-        parent: ctx.parent,
-        handler,
-        loading: undefined, // Allow loading() to attach loading state
-        middleware: [],
-        revalidate: [],
-        errorBoundary: [],
-        notFoundBoundary: [],
-        layout: [],
-        parallel: [],
-        intercept: [],
-        loader: [],
-    };
-    /* We will throw if user is registring same route name twice */
-    invariant(ctx.manifest.get(name) === undefined, `Duplicate route name: ${name} at ${namespace}`);
-    /* Register route entry */
-    ctx.manifest.set(name, entry);
-    /* Run use and attach handlers */
-    if (use && typeof use === "function") {
-        const result = store.run(namespace, entry, use);
-        invariant(Array.isArray(result) && result.every((item) => isValidUseItem(item)), `route() use() callback must return an array of use items [${namespace}]`);
-        return { name: namespace, type: "route", uses: result };
-    }
-    /* typesafe item */
-    return { name: namespace, type: "route" };
-};
-const layout = (handler, use) => {
-    const store = getContext();
-    const ctx = store.getStore();
-    if (!ctx)
-        throw new Error("layout() must be called inside map()");
-    invariant(!ctx.parent || ctx.parent.type !== "parallel", "layout() cannot be used inside parallel()");
-    const isRoot = !ctx.parent || ctx.parent === null;
-    const nextIndex = isRoot ? "$root" : store.getNextIndex("layout");
-    const namespace = `${ctx.namespace}.${nextIndex}`;
-    const shortCode = store.getShortCode("layout");
-    // Unwrap static handler definition, extract the actual handler function
-    const isStatic = isStaticHandler(handler);
-    const unwrappedHandler = isStatic ? handler.handler : handler;
-    const urlPrefix = getUrlPrefix();
-    const entry = {
-        id: namespace,
-        shortCode,
-        type: "layout",
-        parent: ctx.parent,
-        handler: unwrappedHandler,
-        loading: undefined, // Allow loading() to attach loading state
-        middleware: [],
-        revalidate: [],
-        errorBoundary: [],
-        notFoundBoundary: [],
-        parallel: [],
-        intercept: [],
-        layout: [],
-        loader: [],
-        ...(urlPrefix ? { mountPath: urlPrefix } : {}),
-        ...(isStatic ? { isStaticPrerender: true } : {}),
-    };
-    // Run use callback if provided
-    let result;
-    if (use && typeof use === "function") {
-        result = store.run(namespace, entry, use);
-        invariant(Array.isArray(result) && result.every((item) => isValidUseItem(item)), `layout() use() callback must return an array of use items [${namespace}]`);
-    }
-    // Check if this is an orphan layout (no routes in children, including nested caches)
-    const hasRoutes = result &&
-        Array.isArray(result) &&
-        result.some((item) => hasRoutesInItem(item));
-    if (!hasRoutes) {
-        // Orphan layouts must not contain other layouts as children.
-        // If we're here, all child layouts are also orphan (if any had routes,
-        // hasRoutesInItem would have returned true). Nested orphan chains are
-        // confusing — use sibling orphan layouts instead.
-        if (result) {
-            invariant(!result.some((item) => item?.type === "layout"), `orphan layout cannot contain other layouts as children [${namespace}]`);
-        }
-        const parent = ctx.parent;
-        // Allow orphan layouts at root level if they're part of map() builder result
-        if (!parent || parent === null) {
-            if (!isRoot) {
-                invariant(false, `Orphan layout cannot be used at non-root level without parent [${namespace}]`);
-            }
-            // Root-level orphan is allowed (e.g., sibling layouts in map() builder)
-        }
-        else {
-            // Has parent - register as orphan layout
-            invariant(parent.type === "route" ||
-                parent.type === "layout" ||
-                parent.type === "cache", `Orphan layouts can only be defined inside route or layout > check [${namespace}]`);
-            // Clear parent pointer for orphan layouts to prevent duplicate processing
-            entry.parent = null;
-            parent.layout.push(entry);
-        }
-    }
-    if (result) {
-        return { name: namespace, type: "layout", uses: result };
-    }
-    return {
-        name: namespace,
-        type: "layout",
-    };
-};
-const isValidUseItem = (item) => {
-    return (typeof item === "undefined" ||
-        item === null ||
-        (item &&
-            typeof item === "object" &&
-            "type" in item &&
-            [
-                "layout",
-                "route",
-                "middleware",
-                "revalidate",
-                "parallel",
-                "intercept",
-                "loader",
-                "loading",
-                "errorBoundary",
-                "notFoundBoundary",
-                "when",
-                "cache",
-                "include", // For urls() include() helper
-            ].includes(item.type)));
-};
-const isOrphanLayout = (item) => {
-    return (item.type === "layout" &&
-        !item.uses?.some((child) => hasRoutesInItem(child)));
-};
-/*
- * Create revalidate helper
- */
-const createRevalidateHelper = () => {
-    return revalidate;
-};
-/**
- * Create errorBoundary helper
- */
-const createErrorBoundaryHelper = () => {
-    return errorBoundary;
-};
-/**
- * Create notFoundBoundary helper
- */
-const createNotFoundBoundaryHelper = () => {
-    return notFoundBoundary;
-};
-/**
- * Create middleware helper
- */
-const createMiddlewareHelper = () => {
-    return middleware;
-};
-/**
- * Create parallel helper
- */
-const createParallelHelper = () => {
-    return parallel;
-};
-/**
- * Create intercept helper
- */
-const createInterceptHelper = () => {
-    return intercept;
-};
-/**
- * Create loader helper
- */
-const createLoaderHelper = () => {
-    return loaderFn;
-};
-/**
- * Create loading helper
- */
-const createLoadingHelper = () => {
-    return loadingFn;
-};
-/**
- * Create route helper
- */
-const createRouteHelper = () => {
-    return routeFn;
-};
-/**
- * Create layout helper
- */
-const createLayoutHelper = () => {
-    return layout;
-};
-/**
- * Create when helper for intercept conditions
- */
-const createWhenHelper = () => {
-    return when;
-};
-/**
- * Create cache helper for cache configuration
- */
-const createCacheHelper = () => {
-    return cache;
-};
-/**
- * Type-safe handler definition helper
- *
- */
-export function map(builder) {
-    const handler = () => {
-        // Check if it's a builder function (array-based API)
-        invariant(typeof builder === "function", "map() expects a builder function as its argument");
-        // Create helpers
-        const helpers = {
-            route: createRouteHelper(),
-            layout: createLayoutHelper(),
-            parallel: createParallelHelper(),
-            intercept: createInterceptHelper(),
-            middleware: createMiddlewareHelper(),
-            revalidate: createRevalidateHelper(),
-            loader: createLoaderHelper(),
-            loading: createLoadingHelper(),
-            errorBoundary: createErrorBoundaryHelper(),
-            notFoundBoundary: createNotFoundBoundaryHelper(),
-            when: createWhenHelper(),
-            cache: createCacheHelper(),
-        };
-        return [layout(RootLayout, () => builder(helpers))].flat(3);
-    };
-    // Cast to RouteHandlers to carry the route type brand
-    return handler;
-}
-/**
- * Create RouteHelpers for inline route definitions
- * Used internally by router.map() for inline handler syntax
- */
-export function createRouteHelpers() {
-    return {
-        route: createRouteHelper(),
-        layout: createLayoutHelper(),
-        parallel: createParallelHelper(),
-        intercept: createInterceptHelper(),
-        middleware: createMiddlewareHelper(),
-        revalidate: createRevalidateHelper(),
-        loader: createLoaderHelper(),
-        loading: createLoadingHelper(),
-        errorBoundary: createErrorBoundaryHelper(),
-        notFoundBoundary: createNotFoundBoundaryHelper(),
-        when: createWhenHelper(),
-        cache: createCacheHelper(),
-    };
-}
-/**
- * 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);
- * ```
- */
-// Re-export createLoader from loader.rsc.ts for RSC/server context
-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 function redirect(url, status = 302) {
-    return new Response(null, {
-        status,
-        headers: {
-            Location: url,
-            "X-RSC-Redirect": "soft",
-        },
-    });
-}
-//# sourceMappingURL=route-definition.js.map