toiljs 0.0.7 → 0.0.9

package/build/client/index.d.ts

@@ -4,12 +4,14 @@ export { Link } from './navigation/Link.js';
 export type { LinkProps } from './navigation/Link.js';
 export { NavLink, matchActive } from './navigation/NavLink.js';
 export type { NavLinkProps, NavLinkState } from './navigation/NavLink.js';
-export { navigate, back, forward, refresh } from './navigation/navigation.js';
+export { navigate, back, forward, refresh, setViewTransitions } from './navigation/navigation.js';
 export type { NavigateOptions } from './navigation/navigation.js';
 export { useParams, useNavigate, useLocation, usePathname, useSearchParams, useRouter, useNavigationPending, } from './routing/hooks.js';
 export type { RouterInstance } from './routing/hooks.js';
-export { useLoaderData } from './routing/loader.js';
-export type { LoaderArgs, LoaderFunction } from './routing/loader.js';
+export { useLoaderData, revalidate, invalidateLoaderData } from './routing/loader.js';
+export type { LoaderArgs, LoaderFunction, LoaderData, Revalidate } from './routing/loader.js';
+export { useAction } from './routing/action.js';
+export type { UseActionOptions, ActionState, ActionHandle, RevalidateTarget, } from './routing/action.js';
 export { prefetch } from './navigation/prefetch.js';
 export type { RouteDef, LayoutLoader, LayoutComponentLoader, NotFoundLoader, RouteErrorProps, Register, RoutePath, Href, } from './types.js';
 export { matchRoute } from './routing/match.js';
@@ -18,3 +20,13 @@ export { connectChannel, useChannel, resolveChannelUrl } from './channel/channel
 export type { Channel, ChannelOptions, ChannelHook, ChannelData } from './channel/channel.js';
 export { useHead, useTitle, Head, mergeHead } from './head/head.js';
 export type { HeadSpec, MetaTag, LinkTag, ResolvedHead } from './head/head.js';
+export { resolveMetadata } from './head/metadata.js';
+export type { Metadata, GenerateMetadata, GenerateMetadataArgs, OpenGraph } from './head/metadata.js';
+export { Image } from './components/Image.js';
+export type { ImageProps } from './components/Image.js';
+export { Script } from './components/Script.js';
+export type { ScriptProps, ScriptStrategy } from './components/Script.js';
+export { Form } from './components/Form.js';
+export type { FormProps } from './components/Form.js';
+export { Slot } from './components/Slot.js';
+export type { SlotProps } from './components/Slot.js';

package/build/client/index.js

@@ -2,10 +2,16 @@ export { mount } from './routing/mount.js';
 export { Router } from './routing/Router.js';
 export { Link } from './navigation/Link.js';
 export { NavLink, matchActive } from './navigation/NavLink.js';
-export { navigate, back, forward, refresh } from './navigation/navigation.js';
+export { navigate, back, forward, refresh, setViewTransitions } from './navigation/navigation.js';
 export { useParams, useNavigate, useLocation, usePathname, useSearchParams, useRouter, useNavigationPending, } from './routing/hooks.js';
-export { useLoaderData } from './routing/loader.js';
+export { useLoaderData, revalidate, invalidateLoaderData } from './routing/loader.js';
+export { useAction } from './routing/action.js';
 export { prefetch } from './navigation/prefetch.js';
 export { matchRoute } from './routing/match.js';
 export { connectChannel, useChannel, resolveChannelUrl } from './channel/channel.js';
 export { useHead, useTitle, Head, mergeHead } from './head/head.js';
+export { resolveMetadata } from './head/metadata.js';
+export { Image } from './components/Image.js';
+export { Script } from './components/Script.js';
+export { Form } from './components/Form.js';
+export { Slot } from './components/Slot.js';

package/build/client/navigation/navigation.d.ts

@@ -1,4 +1,7 @@
 import type { Href } from '../types.js';
+export declare function setViewTransitions(enabled: boolean): void;
+export declare function isSoftNavigation(): boolean;
+export declare function previousPathname(): string;
 export declare function settleNavigation(): void;
 export declare function isNavigationPending(): boolean;
 export declare function navigationEpoch(): number;

package/build/client/navigation/navigation.js

@@ -1,16 +1,54 @@
+import { startTransition } from 'react';
+import { flushSync } from 'react-dom';
 import { enableManualScrollRestoration, planScroll, rememberScroll, } from './scroll.js';
 const listeners = new Set();
 let popstateBound = false;
+let viewTransitions = false;
+export function setViewTransitions(enabled) {
+    viewTransitions = enabled;
+}
+function shouldViewTransition() {
+    if (!viewTransitions || typeof document === 'undefined' || typeof window === 'undefined') {
+        return false;
+    }
+    if (typeof document.startViewTransition !== 'function')
+        return false;
+    return !window.matchMedia('(prefers-reduced-motion: reduce)').matches;
+}
 let keyCounter = 0;
 let currentKey = 'initial';
 function nextKey() {
     keyCounter += 1;
     return `t${String(keyCounter)}`;
 }
-function notify() {
+function runListeners() {
     for (const listener of listeners)
         listener();
 }
+function notify() {
+    if (shouldViewTransition()) {
+        document.startViewTransition?.(() => {
+            flushSync(runListeners);
+        });
+    }
+    else {
+        startTransition(runListeners);
+    }
+}
+let softNav = false;
+let currentPath = typeof window === 'undefined' ? '/' : window.location.pathname;
+let previousPath = currentPath;
+function recordTransition(soft) {
+    previousPath = currentPath;
+    currentPath = typeof window === 'undefined' ? '/' : window.location.pathname;
+    softNav = soft;
+}
+export function isSoftNavigation() {
+    return softNav;
+}
+export function previousPathname() {
+    return previousPath;
+}
 let startedTick = 0;
 let committedTick = 0;
 const pendingListeners = new Set();
@@ -68,6 +106,7 @@ export function navigate(href, options) {
         currentKey = nextKey();
         window.history.pushState({ __toilKey: currentKey }, '', href);
     }
+    recordTransition(true);
     planScroll({ hash, toTop: options?.scroll !== false });
     notify();
 }
@@ -78,6 +117,7 @@ export function forward() {
     window.history.forward();
 }
 export function refresh() {
+    beginNavigation();
     notify();
 }
 function handlePopState(event) {
@@ -85,6 +125,7 @@ function handlePopState(event) {
     rememberScroll(currentKey);
     const state = event.state;
     currentKey = state?.__toilKey ?? 'initial';
+    recordTransition(true);
     planScroll({ restoreKey: currentKey, hash: window.location.hash, toTop: false });
     notify();
 }

package/build/client/routing/Router.d.ts

@@ -5,4 +5,5 @@ export declare function Router(props: {
     layout?: LayoutLoader;
     notFound?: NotFoundLoader;
     globalError?: ErrorComponentLoader;
+    slots?: Record<string, RouteDef[]>;
 }): ReactNode;

package/build/client/routing/Router.js

@@ -3,60 +3,82 @@ import { createElement, Suspense, useLayoutEffect } from 'react';
 import { ErrorBoundary } from './error-boundary.js';
 import { useLocation } from './hooks.js';
 import { errorComponent, loadingComponent, nestedLayout, resolveLayout, resolveNotFound, } from './lazy.js';
-import { LoaderDataContext, readRouteData } from './loader.js';
+import { loaderKey, LoaderDataContext, readRouteData } from './loader.js';
 import { matchRoute } from './match.js';
+import { useRouteHead } from '../head/head.js';
 import { ParamsContext } from './params-context.js';
-import { navigationEpoch, settleNavigation } from '../navigation/navigation.js';
+import { SlotContext } from './slot-context.js';
+import { isSoftNavigation, navigationEpoch, previousPathname, settleNavigation, } from '../navigation/navigation.js';
 import { applyScroll } from '../navigation/scroll.js';
 function RoutePage(props) {
-    const { Component, data } = readRouteData(props.route, props.params, props.dataKey);
+    const { Component, data, head } = readRouteData(props.route, props.params, props.dataKey, props.epoch);
+    useRouteHead(head);
     return _jsx(LoaderDataContext.Provider, { value: data, children: createElement(Component) });
 }
+function renderMatched(matched, params, pathname, epoch, keyPrefix) {
+    const search = typeof window === 'undefined' ? '' : window.location.search;
+    const dataKey = keyPrefix + loaderKey(pathname, search);
+    const fallback = matched.loading
+        ? createElement(Suspense, { fallback: null }, createElement(loadingComponent(matched.loading)))
+        : null;
+    let content = (_jsx(Suspense, { fallback: fallback, children: _jsx(RoutePage, { route: matched, params: params, dataKey: dataKey, epoch: epoch }) }, matched.loading ? `${dataKey}:${String(epoch)}` : undefined));
+    const templates = matched.templates ?? [];
+    for (let i = templates.length - 1; i >= 0; i--) {
+        const Template = nestedLayout(templates[i]);
+        content = (_jsx(Suspense, { fallback: null, children: _jsx(Template, { children: content }) }, `${keyPrefix}${pathname}:${String(i)}`));
+    }
+    const chain = matched.layouts ?? [];
+    for (let i = chain.length - 1; i >= 0; i--) {
+        const NestedLayout = nestedLayout(chain[i]);
+        content = (_jsx(Suspense, { fallback: null, children: _jsx(NestedLayout, { children: content }) }));
+    }
+    if (matched.errorComponent) {
+        content = _jsx(ErrorBoundary, { fallback: errorComponent(matched.errorComponent), children: content });
+    }
+    return content;
+}
+function match(routes, pathname, allowIntercept = true) {
+    for (const route of routes) {
+        if (route.intercept && !allowIntercept)
+            continue;
+        const params = matchRoute(route.pattern, pathname);
+        if (params)
+            return { route, params };
+    }
+    return null;
+}
 export function Router(props) {
-    const { routes, layout = null, notFound = null, globalError = null } = props;
+    const { routes, layout = null, notFound = null, globalError = null, slots = {} } = props;
     const pathname = useLocation();
     useLayoutEffect(() => {
         applyScroll();
         settleNavigation();
     });
-    let matched;
-    let params = {};
-    for (const route of routes) {
-        const result = matchRoute(route.pattern, pathname);
-        if (result) {
-            matched = route;
-            params = result;
-            break;
-        }
+    const epoch = navigationEpoch();
+    const soft = isSoftNavigation();
+    const slotElements = {};
+    let intercepting = false;
+    for (const [name, defs] of Object.entries(slots)) {
+        const slotMatch = match(defs, pathname, soft);
+        if (!slotMatch)
+            continue;
+        if (slotMatch.route.intercept)
+            intercepting = true;
+        slotElements[name] = (_jsx(ParamsContext.Provider, { value: slotMatch.params, children: renderMatched(slotMatch.route, slotMatch.params, pathname, epoch, `@${name} `) }));
     }
+    const mainPath = intercepting ? previousPathname() : pathname;
+    const matched = match(routes, mainPath);
+    const params = matched?.params ?? {};
     let content;
     if (matched) {
-        const fallback = matched.loading
-            ? createElement(Suspense, { fallback: null }, createElement(loadingComponent(matched.loading)))
-            : null;
-        const search = typeof window === 'undefined' ? '' : window.location.search;
-        const dataKey = `${String(navigationEpoch())}:${pathname}${search}`;
-        content = (_jsx(Suspense, { fallback: fallback, children: _jsx(RoutePage, { route: matched, params: params, dataKey: dataKey }) }));
-        const templates = matched.templates ?? [];
-        for (let i = templates.length - 1; i >= 0; i--) {
-            const Template = nestedLayout(templates[i]);
-            content = (_jsx(Suspense, { fallback: null, children: _jsx(Template, { children: content }) }, `${pathname}:${String(i)}`));
-        }
-        const chain = matched.layouts ?? [];
-        for (let i = chain.length - 1; i >= 0; i--) {
-            const NestedLayout = nestedLayout(chain[i]);
-            content = (_jsx(Suspense, { fallback: null, children: _jsx(NestedLayout, { children: content }) }));
-        }
-        if (matched.errorComponent) {
-            content = (_jsx(ErrorBoundary, { fallback: errorComponent(matched.errorComponent), children: content }));
-        }
+        content = renderMatched(matched.route, matched.params, mainPath, epoch, '');
     }
     else if (notFound) {
         const NotFound = resolveNotFound(notFound);
         content = (_jsx(Suspense, { fallback: null, children: _jsx(NotFound, {}) }));
     }
     else {
-        content = _jsx("div", { style: { padding: 24, fontFamily: 'system-ui' }, children: "404 \u2014 Not found" });
+        content = _jsx("div", { style: { padding: 24, fontFamily: 'system-ui' }, children: "404, Not found" });
     }
     if (layout) {
         const Layout = resolveLayout(layout);
@@ -65,5 +87,5 @@ export function Router(props) {
     if (globalError) {
         content = _jsx(ErrorBoundary, { fallback: errorComponent(globalError), children: content });
     }
-    return _jsx(ParamsContext.Provider, { value: params, children: content });
+    return (_jsx(ParamsContext.Provider, { value: params, children: _jsx(SlotContext.Provider, { value: slotElements, children: content }) }));
 }

package/build/client/routing/action.d.ts

@@ -0,0 +1,17 @@
+import type { Href } from '../types.js';
+export type RevalidateTarget = boolean | Href | readonly Href[];
+export interface UseActionOptions<TData> {
+    readonly revalidate?: RevalidateTarget;
+    readonly onSuccess?: (data: TData) => void;
+    readonly onError?: (error: unknown) => void;
+}
+export interface ActionState<TData> {
+    readonly pending: boolean;
+    readonly error: unknown;
+    readonly data: TData | undefined;
+}
+export interface ActionHandle<TInput, TData> extends ActionState<TData> {
+    run: (input: TInput) => Promise<TData | undefined>;
+    reset: () => void;
+}
+export declare function useAction<TInput = void, TData = unknown>(fn: (input: TInput) => TData | Promise<TData>, options?: UseActionOptions<TData>): ActionHandle<TInput, TData>;

package/build/client/routing/action.js

@@ -0,0 +1,55 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { invalidateLoaderData } from './loader.js';
+import { refresh } from '../navigation/navigation.js';
+function applyRevalidate(target) {
+    if (target === false)
+        return;
+    if (target === undefined || target === true) {
+        invalidateLoaderData();
+    }
+    else {
+        const hrefs = typeof target === 'string' ? [target] : target;
+        for (const href of hrefs)
+            invalidateLoaderData(href);
+    }
+    refresh();
+}
+export function useAction(fn, options = {}) {
+    const [state, setState] = useState({
+        pending: false,
+        error: undefined,
+        data: undefined,
+    });
+    const latest = useRef({ fn, options });
+    latest.current = { fn, options };
+    const runId = useRef(0);
+    const mounted = useRef(true);
+    useEffect(() => () => {
+        mounted.current = false;
+    }, []);
+    const run = useCallback(async (input) => {
+        const id = ++runId.current;
+        setState((s) => ({ ...s, pending: true, error: undefined }));
+        try {
+            const data = await latest.current.fn(input);
+            if (mounted.current && id === runId.current) {
+                setState({ pending: false, error: undefined, data });
+            }
+            applyRevalidate(latest.current.options.revalidate);
+            latest.current.options.onSuccess?.(data);
+            return data;
+        }
+        catch (error) {
+            if (mounted.current && id === runId.current) {
+                setState({ pending: false, error, data: undefined });
+            }
+            latest.current.options.onError?.(error);
+            return undefined;
+        }
+    }, []);
+    const reset = useCallback(() => {
+        runId.current += 1;
+        setState({ pending: false, error: undefined, data: undefined });
+    }, []);
+    return { ...state, run, reset };
+}

package/build/client/routing/hooks.d.ts

@@ -7,6 +7,7 @@ export interface RouterInstance {
     back(): void;
     forward(): void;
     refresh(): void;
+    revalidate(href?: Href): void;
     prefetch(href: Href): void;
 }
 export declare function useParams<T extends RouteParams = RouteParams>(): T;

package/build/client/routing/hooks.js

@@ -1,6 +1,6 @@
-import { startTransition, useContext, useEffect, useMemo, useReducer, useSyncExternalStore, } from 'react';
+import { useContext, useEffect, useMemo, useReducer, useSyncExternalStore } from 'react';
 import { back, forward, isNavigationPending, navigate, refresh, subscribeLocation, subscribePending, } from '../navigation/navigation.js';
-import { clearLoaderData } from './loader.js';
+import { clearLoaderData, revalidate as revalidateData } from './loader.js';
 import { ParamsContext } from './params-context.js';
 import { prefetch } from '../navigation/prefetch.js';
 const ROUTER = {
@@ -16,6 +16,9 @@ const ROUTER = {
         clearLoaderData();
         refresh();
     },
+    revalidate: (href) => {
+        revalidateData(href);
+    },
     prefetch,
 };
 export function useParams() {
@@ -29,11 +32,7 @@ export function useRouter() {
 }
 function useLocationSubscription() {
     const [, forceUpdate] = useReducer((n) => n + 1, 0);
-    useEffect(() => subscribeLocation(() => {
-        startTransition(() => {
-            forceUpdate();
-        });
-    }), []);
+    useEffect(() => subscribeLocation(forceUpdate), []);
 }
 export function useLocation() {
     useLocationSubscription();

package/build/client/routing/loader.d.ts

@@ -1,4 +1,5 @@
 import { type ComponentType } from 'react';
+import type { HeadSpec } from '../head/head.js';
 import type { RouteDef } from '../types.js';
 import type { RouteParams } from './match.js';
 export interface LoaderArgs {
@@ -6,12 +7,19 @@ export interface LoaderArgs {
     readonly searchParams: URLSearchParams;
 }
 export type LoaderFunction<T = unknown> = (args: LoaderArgs) => T | Promise<T>;
+export type Revalidate = number | false;
+export type LoaderData<T> = T extends (...args: never[]) => infer R ? Awaited<R> : T;
 interface RouteData {
     Component: ComponentType;
     data: unknown;
+    head?: HeadSpec;
 }
-export declare function readRouteData(route: RouteDef, params: RouteParams, key: string): RouteData;
+export declare function loaderKey(pathname: string, search: string): string;
+export declare function readRouteData(route: RouteDef, params: RouteParams, key: string, epoch: number): RouteData;
 export declare function clearLoaderData(): void;
+export declare function invalidateLoaderData(href?: string): void;
+export declare function revalidate(href?: string): void;
 export declare const LoaderDataContext: import("react").Context<unknown>;
-export declare function useLoaderData<T = unknown>(): T;
+export declare function useLoaderData<L extends LoaderFunction>(loader: L): Awaited<ReturnType<L>>;
+export declare function useLoaderData<T = unknown>(): LoaderData<T>;
 export {};

package/build/client/routing/loader.js

@@ -1,51 +1,110 @@
 import { createContext, useContext } from 'react';
-import { navigationEpoch } from '../navigation/navigation.js';
+import { resolveMetadata } from '../head/metadata.js';
+import { refresh as rerender } from '../navigation/navigation.js';
 const cache = new Map();
-const MAX_ENTRIES = 16;
+const MAX_ENTRIES = 32;
+export function loaderKey(pathname, search) {
+    return `${pathname}${search}`;
+}
 async function loadRoute(route, params) {
     const mod = await route.load();
     const searchParams = new URLSearchParams(typeof window === 'undefined' ? '' : window.location.search);
     const data = mod.loader ? await mod.loader({ params, searchParams }) : undefined;
-    return { Component: mod.default, data };
-}
-function prune() {
-    const current = `${String(navigationEpoch())}:`;
-    for (const key of cache.keys()) {
-        if (!key.startsWith(current))
-            cache.delete(key);
+    let head;
+    if (mod.generateMetadata) {
+        head = resolveMetadata(await mod.generateMetadata({ params, searchParams, data }));
     }
+    else if (mod.metadata) {
+        head = resolveMetadata(mod.metadata);
+    }
+    return {
+        data: { Component: mod.default, data, head },
+        revalidate: mod.revalidate ?? 0,
+        hasLoader: mod.loader != null,
+    };
+}
+function isStale(entry, epoch) {
+    if (entry.status === 'error')
+        return true;
+    if (!entry.hasLoader)
+        return false;
+    if (entry.revalidate === false)
+        return false;
+    if (entry.revalidate === 0)
+        return entry.epoch !== epoch;
+    return Date.now() - entry.loadedAt >= entry.revalidate * 1000;
+}
+function startFetch(route, params, key, epoch) {
+    const created = {
+        status: 'pending',
+        promise: Promise.resolve(),
+        loadedAt: 0,
+        revalidate: 0,
+        epoch,
+        hasLoader: false,
+    };
+    created.promise = loadRoute(route, params).then((result) => {
+        created.value = result.data;
+        created.revalidate = result.revalidate;
+        created.hasLoader = result.hasLoader;
+        created.loadedAt = Date.now();
+        created.status = 'done';
+    }, (error) => {
+        created.error = error;
+        created.loadedAt = Date.now();
+        created.status = 'error';
+    });
+    cache.set(key, created);
     while (cache.size > MAX_ENTRIES) {
         const oldest = cache.keys().next().value;
-        if (oldest === undefined)
+        if (oldest === undefined || oldest === key)
             break;
         cache.delete(oldest);
     }
+    return created;
 }
-export function readRouteData(route, params, key) {
+export function readRouteData(route, params, key, epoch) {
     let entry = cache.get(key);
-    if (!entry) {
-        const created = { status: 'pending', promise: Promise.resolve() };
-        created.promise = loadRoute(route, params).then((value) => {
-            created.value = value;
-            created.status = 'done';
-        }, (error) => {
-            created.error = error;
-            created.status = 'error';
-        });
-        cache.set(key, created);
-        prune();
-        entry = created;
+    if (entry && entry.status !== 'pending' && isStale(entry, epoch)) {
+        entry = undefined;
     }
+    entry ??= startFetch(route, params, key, epoch);
     if (entry.status === 'pending')
         throw entry.promise;
     if (entry.status === 'error')
         throw entry.error;
+    if (!entry.value)
+        throw entry.promise;
     return entry.value;
 }
 export function clearLoaderData() {
     cache.clear();
 }
+function keyForHref(href) {
+    if (typeof window === 'undefined')
+        return undefined;
+    try {
+        const url = new URL(href, window.location.href);
+        return loaderKey(url.pathname, url.search);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function invalidateLoaderData(href) {
+    if (href === undefined) {
+        cache.clear();
+        return;
+    }
+    const key = keyForHref(href);
+    if (key !== undefined)
+        cache.delete(key);
+}
+export function revalidate(href) {
+    invalidateLoaderData(href);
+    rerender();
+}
 export const LoaderDataContext = createContext(undefined);
-export function useLoaderData() {
+export function useLoaderData(_loader) {
     return useContext(LoaderDataContext);
 }

package/build/client/routing/mount.d.ts

@@ -1,2 +1,2 @@
 import type { ErrorComponentLoader, LayoutLoader, NotFoundLoader, RouteDef } from '../types.js';
-export declare function mount(routes: RouteDef[], layout?: LayoutLoader, notFound?: NotFoundLoader, globalError?: ErrorComponentLoader): void;
+export declare function mount(routes: RouteDef[], layout?: LayoutLoader, notFound?: NotFoundLoader, globalError?: ErrorComponentLoader, slots?: Record<string, RouteDef[]>): void;

package/build/client/routing/mount.js

@@ -1,13 +1,21 @@
-import { jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { createRoot } from 'react-dom/client';
+import { DevErrorBoundary, DevErrorOverlay, initDevErrorOverlay, isDevMode, } from '../dev/error-overlay.js';
 import { initNavigation } from '../navigation/navigation.js';
 import { startPrefetcher } from '../navigation/prefetch.js';
 import { Router } from './Router.js';
-export function mount(routes, layout = null, notFound = null, globalError = null) {
+export function mount(routes, layout = null, notFound = null, globalError = null, slots = {}) {
     const el = document.getElementById('root');
     if (!el)
         throw new Error('toil: #root element not found');
     initNavigation();
-    createRoot(el).render(_jsx(Router, { routes: routes, layout: layout, notFound: notFound, globalError: globalError }));
-    startPrefetcher(routes);
+    const app = (_jsx(Router, { routes: routes, layout: layout, notFound: notFound, globalError: globalError, slots: slots }));
+    if (isDevMode()) {
+        initDevErrorOverlay();
+        createRoot(el).render(_jsxs(_Fragment, { children: [_jsx(DevErrorBoundary, { children: app }), _jsx(DevErrorOverlay, {})] }));
+    }
+    else {
+        createRoot(el).render(app);
+    }
+    startPrefetcher([...routes, ...Object.values(slots).flat()]);
 }

package/build/client/routing/slot-context.d.ts

@@ -0,0 +1,2 @@
+import { type ReactNode } from 'react';
+export declare const SlotContext: import("react").Context<Record<string, ReactNode>>;

package/build/client/routing/slot-context.js

@@ -0,0 +1,2 @@
+import { createContext } from 'react';
+export const SlotContext = createContext({});

package/build/client/types.d.ts

@@ -30,6 +30,7 @@ export interface RouteDef {
     readonly errorComponent?: () => Promise<{
         default: ComponentType<RouteErrorProps>;
     }>;
+    readonly intercept?: boolean;
 }
 export type LayoutLoader = LayoutComponentLoader | null;
 export type NotFoundLoader = (() => Promise<{