@solidjs/router 1.0.0-next.9 → 1.0.0

package/dist/paths.d.ts

@@ -1,117 +0,0 @@
-import type { Params, RouteDefinition, SearchParams, SetSearchParams, StandardSchemaV1, TypedPath, TypedSearchPath } from "./types.js";
-declare const FILTER_TYPE: unique symbol;
-/**
- * A match filter that also declares the TypeScript type accepted for the
- * param at `paths` callsites (the runtime param remains a string).
- */
-export interface TypedMatchFilter<T> {
-    (s: string): boolean;
-    readonly [FILTER_TYPE]: T;
-}
-/** Matches integer segments; types the param as `number` in the path proxy. */
-export declare const int: TypedMatchFilter<number>;
-type Flat<T> = {
-    [K in keyof T]: T[K];
-} & {};
-type SegmentsOf<P extends string> = P extends `${infer A}/${infer B}` ? [...SegmentsOf<A>, ...SegmentsOf<B>] : P extends "" ? [] : [P];
-type FilterArg<F> = F extends TypedMatchFilter<infer T> ? T : F extends readonly (infer S)[] ? S : string | number;
-type ParamArg<Name extends string, F> = Name extends keyof F ? FilterArg<F[Name]> : string | number;
-/** Collects a maximal run of required params (and a trailing splat) into one call's argument tuple. */
-type ParamRun<Segs extends readonly string[], F, Args extends readonly unknown[] = [], PAcc extends Params = {}> = Segs extends readonly [infer H extends string, ...infer R extends readonly string[]] ? H extends `:${string}?` ? {
-    args: Args;
-    params: PAcc;
-    rest: Segs;
-} : H extends `:${infer N}` ? ParamRun<R, F, [...Args, ParamArg<N, F>], PAcc & {
-    [K in N]: string;
-}> : H extends `*${infer N}` ? {
-    args: [...Args, string | number];
-    params: PAcc & {
-        [K in N]: string;
-    };
-    rest: R;
-} : {
-    args: Args;
-    params: PAcc;
-    rest: Segs;
-} : {
-    args: Args;
-    params: PAcc;
-    rest: Segs;
-};
-/** The search param types a route end carries: input builds URLs, output is what parsing returns. */
-export interface SearchTypes {
-    input: any;
-    output: any;
-}
-export interface DefaultSearchTypes {
-    input: SetSearchParams;
-    output: SearchParams;
-}
-/** Terminating calls available on every route end: zero-arg, or search object plus optional hash. */
-export interface PathEnd<Sch extends SearchTypes = DefaultSearchTypes, P extends Params = Params> extends TypedPath<P>, TypedSearchPath<Sch["input"], Sch["output"]> {
-    (): string;
-    (search: Sch["input"], hash?: string): string;
-}
-type SearchTypesOf<Def> = Def extends {
-    search: infer S;
-} ? S extends StandardSchemaV1<any, any> ? {
-    input: NonNullable<S["~standard"]["types"]>["input"];
-    output: NonNullable<S["~standard"]["types"]>["output"];
-} : DefaultSearchTypes : DefaultSearchTypes;
-type FiltersOf<Def> = Def extends {
-    matchFilters: infer F;
-} ? F : {};
-type ChildrenOf<Def> = Def extends {
-    children: infer C;
-} ? C : undefined;
-/**
- * Sees through a lazy `children` thunk: the routes the import's promise
- * resolves to (its `default` or `routes` export, matching the runtime) type
- * exactly like inline children. Only tables genuinely built at runtime —
- * where the thunk's return type is a plain `RouteDefinition[]` — degrade to
- * untyped, definitionally.
- */
-type ResolvedChildren<C> = C extends () => infer R ? Awaited<R> extends infer M ? M extends {
-    default: infer D;
-} ? D : M extends {
-    routes: infer D;
-} ? D : M : never : C;
-type ChildPaths<C, PAcc extends Params> = [C] extends [undefined] ? {} : ResolvedChildren<C> extends infer RC ? RC extends readonly unknown[] ? TuplePaths<RC, PAcc> : RouteContrib<RC, PAcc> : never;
-type TuplePaths<R extends readonly unknown[], PAcc extends Params> = R extends readonly [
-    infer H,
-    ...infer T extends readonly unknown[]
-] ? RouteContrib<H, PAcc> & TuplePaths<T, PAcc> : {};
-type PathLeaf<Sch extends SearchTypes, C, PAcc extends Params> = PathEnd<Sch, Flat<PAcc>> & ChildPaths<C, PAcc>;
-type PathNode<Segs extends readonly string[], F, Sch extends SearchTypes, C, PAcc extends Params> = Segs extends readonly [infer H extends string, ...infer R extends readonly string[]] ? H extends `:${infer N}?` ? ((arg: ParamArg<N, F>) => PathNode<R, F, Sch, C, PAcc & {
-    [K in N]?: string;
-}>) & PathNode<R, F, Sch, C, PAcc & {
-    [K in N]?: string;
-}> : H extends `:${string}` | `*${string}` ? ParamCallNode<Segs, F, Sch, C, PAcc> : {
-    [K in H]: PathNode<R, F, Sch, C, PAcc>;
-} : PathLeaf<Sch, C, PAcc>;
-type ParamCallNode<Segs extends readonly string[], F, Sch extends SearchTypes, C, PAcc extends Params> = ParamRun<Segs, F> extends {
-    args: infer A extends readonly unknown[];
-    params: infer P2 extends Params;
-    rest: infer R2 extends readonly string[];
-} ? ((...args: A) => PathNode<R2, F, Sch, C, PAcc & P2>) & (R2 extends readonly [] ? {
-    (...args: [...A, Sch["input"], string?]): string;
-} : {}) & TypedPath<Flat<PAcc & P2>> : never;
-type RouteContrib<Def, PAcc extends Params> = Def extends {
-    path: infer P;
-} ? [P] extends [undefined] ? ChildPaths<ChildrenOf<Def>, PAcc> : P extends readonly string[] ? MultiPathContrib<P, Def, PAcc> : P extends string ? string extends P ? any : PathNode<SegmentsOf<P>, FiltersOf<Def>, SearchTypesOf<Def>, ChildrenOf<Def>, PAcc> : any : ChildPaths<ChildrenOf<Def>, PAcc>;
-type MultiPathContrib<Ps extends readonly string[], Def, PAcc extends Params> = Ps extends readonly [infer H extends string, ...infer T extends readonly string[]] ? PathNode<SegmentsOf<H>, FiltersOf<Def>, SearchTypesOf<Def>, ChildrenOf<Def>, PAcc> & MultiPathContrib<T, Def, PAcc> : {};
-/**
- * The type of a router instance's `paths` proxy for a given route tree.
- * Requires the tree to be a literal tuple (`as const` or a `const` type
- * param); non-literal trees fall back to an untyped proxy.
- */
-export type RoutePaths<R extends readonly RouteDefinition[]> = number extends R["length"] ? any : PathEnd<DefaultSearchTypes, {}> & TuplePaths<R, {}>;
-/** Extracts the params record a paths node binds, as runtime (string-valued) params. */
-export type PathParamsOf<N> = N extends TypedPath<infer P> ? Flat<P> : Params;
-/**
- * Creates the runtime path proxy. It is instance-scoped: `renderPath` comes
- * from the router's history adapter (eg. hash routing prefixes `#`), and
- * `base` is baked into every produced path.
- */
-export declare function createPathsProxy(renderPath?: (path: string) => string, base?: string): any;
-export {};

package/dist/paths.js

@@ -1,41 +0,0 @@
-import { mergeSearchString, normalizePath } from "./utils.js";
-/** Matches integer segments; types the param as `number` in the path proxy. */
-export const int = ((s) => /^-?\d+$/.test(s));
-// ---------------------------------------------------------------------------
-// Runtime
-// ---------------------------------------------------------------------------
-const encodeParam = (value) => String(value).split("/").map(encodeURIComponent).join("/");
-/**
- * Creates the runtime path proxy. It is instance-scoped: `renderPath` comes
- * from the router's history adapter (eg. hash routing prefixes `#`), and
- * `base` is baked into every produced path.
- */
-export function createPathsProxy(renderPath = p => p, base = "") {
-    const toHref = (pathname, suffix = "") => renderPath(pathname || "/") + suffix;
-    function node(pathname) {
-        const build = (...args) => {
-            let path = pathname;
-            for (let i = 0; i < args.length; i++) {
-                const arg = args[i];
-                if (typeof arg === "object" && arg !== null) {
-                    // a search object terminates; an optional hash string may follow
-                    const hash = typeof args[i + 1] === "string" ? `#${args[i + 1]}` : "";
-                    return toHref(path, mergeSearchString("", arg) + hash);
-                }
-                path += `/${encodeParam(arg)}`;
-            }
-            // zero-arg calls terminate; param-only calls stay chainable
-            return args.length ? node(path) : toHref(path);
-        };
-        return new Proxy(build, {
-            get(_, prop) {
-                if (prop === "toString")
-                    return () => toHref(pathname);
-                if (typeof prop === "symbol")
-                    return prop === Symbol.toPrimitive ? () => toHref(pathname) : undefined;
-                return node(`${pathname}/${prop}`);
-            }
-        });
-    }
-    return node(normalizePath(base));
-}

package/dist/routers/factory.d.ts

@@ -1,45 +0,0 @@
-import type { JSX } from "@solidjs/web";
-import type { RoutePaths } from "../paths.js";
-import type { OutputMatch, RouteDefinition, RoutePreloadFunc, RouteSectionProps } from "../types.js";
-import type { RouterHistory } from "./history.js";
-/**
- * Identity helper that preserves literal types when the route tree is
- * declared as a separate variable. `createRouter` infers literally from
- * inline arrays, but an extracted `const routes = [...]` widens paths to
- * `string` and silently degrades `paths` and the typed hooks unless it is
- * declared `as const` — `defineRoutes` makes that impossible to forget.
- */
-export declare function defineRoutes<const R extends readonly RouteDefinition[]>(routes: R): R;
-export interface RouterConfig<R extends readonly RouteDefinition[] = RouteDefinition[]> {
-    /** The route tree. Immutable per instance — it is the source of truth for matching *and* types. */
-    routes: R;
-    base?: string;
-    /**
-     * Runs once per mount/request (and on single-flight collection passes) to
-     * warm app-wide data. Its result is passed to the render-prop child as
-     * `props.data`.
-     */
-    preload?: RoutePreloadFunc;
-    /** History adapter; defaults to browser history on the client and the request URL on the server. */
-    history?: RouterHistory;
-    singleFlight?: boolean;
-    actionBase?: string;
-    explicitLinks?: boolean;
-    /** Preload route code/data on link hover and focus. Defaults to `true`. */
-    preloadLinks?: boolean;
-    transformUrl?: (url: string) => string;
-}
-export interface RouterInstance<R extends readonly RouteDefinition[] = RouteDefinition[]> {
-    /** The instance is the provider component; the render-prop child receives the matched content as `props.children`. */
-    (props: {
-        children?: (props: RouteSectionProps) => JSX.Element;
-    }): JSX.Element;
-    /** Typed path proxy — builds URLs through property access and calls. */
-    readonly paths: RoutePaths<R>;
-    readonly routes: R;
-    /** The config the instance was created with — lets server integrations (flight collector, no-JS handler) consume the instance directly. */
-    readonly config: RouterConfig<R>;
-    /** Pure matching against an arbitrary URL — no rendering or request context involved. Root→leaf; `[]` when nothing matches. */
-    match(url: string): OutputMatch[];
-}
-export declare function createRouter<const R extends readonly RouteDefinition[]>(config: RouterConfig<R>): RouterInstance<R>;

package/dist/routers/factory.jsx

@@ -1,143 +0,0 @@
-/*@refresh skip*/
-import { createSignal, getOwner, onCleanup, sharedConfig, untrack } from "solid-js";
-import { getRequestEvent, isServer } from "@solidjs/web";
-import { setupLinkClaims } from "../claims.js";
-import { setupNativeEvents } from "../data/events.js";
-import { createPathsProxy } from "../paths.js";
-import { createBranches, createRouterContext, getRouteMatches, registerFlightRouter, RouterContextObj, trackLazySubtrees, useOptionalContext } from "../routing.js";
-import { mockBase } from "../utils.js";
-import { Root, Routes } from "./components.jsx";
-import { browserHistory } from "./history.js";
-/**
- * Identity helper that preserves literal types when the route tree is
- * declared as a separate variable. `createRouter` infers literally from
- * inline arrays, but an extracted `const routes = [...]` widens paths to
- * `string` and silently degrades `paths` and the typed hooks unless it is
- * declared `as const` — `defineRoutes` makes that impossible to forget.
- */
-export function defineRoutes(routes) {
-    return routes;
-}
-/** Wraps a history adapter in the integration signal the router core consumes. Must run under a reactive owner. */
-function createIntegration(history) {
-    let ignore = false;
-    const wrap = (value) => (typeof value === "string" ? { value } : value);
-    const [read, write] = createSignal(wrap(history.get()), {
-        equals: (a, b) => a.value === b.value && a.state === b.state,
-        ownedWrite: true
-    });
-    const signal = [
-        read,
-        (next) => {
-            !ignore && history.set(next);
-            if (sharedConfig.registry && !sharedConfig.done)
-                sharedConfig.done = true;
-            write(next);
-        }
-    ];
-    history.init &&
-        onCleanup(history.init((value = history.get()) => {
-            ignore = true;
-            signal[1](wrap(value));
-            ignore = false;
-        }));
-    return { signal, utils: history.utils };
-}
-/**
- * Server default: a static view of the request URL — no signal machinery, a
- * server render never navigates. Without a request event (SSG scripts,
- * server-side tests) the configured history adapter provides the location,
- * so e.g. `memoryHistory("/page")` works isomorphically.
- */
-function staticIntegration(history) {
-    const e = getRequestEvent();
-    let value = "";
-    if (e) {
-        const url = new URL(e.request.url);
-        value = url.pathname + url.search;
-    }
-    else if (history) {
-        value = history.get();
-    }
-    const obj = typeof value === "string" ? { value } : { ...value };
-    return { signal: [() => obj, next => Object.assign(obj, next)], utils: history && history.utils };
-}
-export function createRouter(config) {
-    const basePath = config.base || "";
-    // Routes are immutable per instance, so compilation is shared by every
-    // mount, request, and `match()` call — recompiled only when a lazy subtree
-    // resolves (append-only: resolution, not mutation). Reading the version
-    // inside a computation subscribes it; plain calls just see current state.
-    let compiled;
-    let compiledVersion = -1;
-    const branches = () => {
-        const version = trackLazySubtrees();
-        if (!compiled || compiledVersion !== version) {
-            compiled = createBranches(config.routes, basePath);
-            compiledVersion = version;
-        }
-        return compiled;
-    };
-    const renderPath = (config.history && config.history.utils && config.history.utils.renderPath) || undefined;
-    function RouterComponent(props) {
-        // One router per app: the session (location, history, delegation, link
-        // claims, preloading) has a single owner, and a second instance would
-        // fight it — stale content on click navigations, conflicting link
-        // attributes. Compose route trees instead; lazy subtrees are the planned
-        // answer for definitions unknown at build time.
-        if (useOptionalContext(RouterContextObj)) {
-            console.warn("Mounting a router inside another router is not supported. " +
-                "Compose route trees in one createRouter config instead.");
-        }
-        const root = untrack(() => props.children);
-        const integration = isServer
-            ? staticIntegration(config.history)
-            : createIntegration(config.history || browserHistory());
-        let context;
-        const routerState = createRouterContext(integration, branches, () => context, {
-            base: basePath,
-            singleFlight: config.singleFlight,
-            transformUrl: config.transformUrl
-        });
-        if (!isServer) {
-            setupNativeEvents({
-                preload: config.preloadLinks,
-                explicitLinks: config.explicitLinks,
-                actionBase: config.actionBase,
-                transformUrl: config.transformUrl
-            })(routerState);
-            setupLinkClaims(routerState, config.explicitLinks);
-            if (routerState.singleFlight)
-                onCleanup(registerFlightRouter(routerState));
-        }
-        return (<RouterContextObj value={routerState}>
-        <Root routerState={routerState} root={root} preload={config.preload}>
-          {(context = getOwner()) && null}
-          <Routes routerState={routerState} branches={branches}/>
-        </Root>
-      </RouterContextObj>);
-    }
-    const instance = Object.assign(RouterComponent, {
-        routes: config.routes,
-        config,
-        match(url) {
-            const u = new URL(url, mockBase);
-            const pathname = config.transformUrl ? config.transformUrl(u.pathname) : u.pathname;
-            return getRouteMatches(branches(), pathname).map(({ route, path, params }) => ({
-                path: route.originalPath,
-                pattern: route.pattern,
-                match: path,
-                params,
-                info: route.info
-            }));
-        }
-    });
-    // Built on first access (a getter via Object.assign would run during the
-    // copy) so runtimes without Proxy — some older TVs — can still route as
-    // long as they never touch typed paths.
-    let paths;
-    Object.defineProperty(instance, "paths", {
-        get: () => paths || (paths = createPathsProxy(renderPath, basePath))
-    });
-    return instance;
-}

package/dist/routers/history.d.ts

@@ -1,24 +0,0 @@
-import type { LocationChange, RouterUtils } from "../types.js";
-/**
- * A history adapter: the source of truth for the current URL and how
- * navigations write back to it. Adapters are plain imported values so
- * unused ones never enter the bundle — `createRouter` defaults to browser
- * history on the client and the request URL on the server.
- */
-export interface RouterHistory {
-    get: () => string | LocationChange;
-    set: (next: LocationChange) => void;
-    init?: (notify: (value?: string | LocationChange) => void) => () => void;
-    utils?: Partial<RouterUtils>;
-}
-export declare function browserHistory(): RouterHistory;
-export declare function hashParser(str: string): string;
-export declare function hashHistory(): RouterHistory;
-export interface MemoryHistoryAdapter extends RouterHistory {
-    get: () => string;
-    go: (delta: number) => void;
-    back: () => void;
-    forward: () => void;
-    listen: (listener: (value: string) => void) => () => void;
-}
-export declare function memoryHistory(initial?: string): MemoryHistoryAdapter;

package/dist/routers/history.js

@@ -1,180 +0,0 @@
-import { isServer } from "@solidjs/web";
-function bindEvent(target, type, handler) {
-    target.addEventListener(type, handler);
-    return () => target.removeEventListener(type, handler);
-}
-// Depth stamping supports blocking browser-initiated navigation (back/forward)
-// for `useBeforeLeave`. It stays always-on — a couple of history.state writes —
-// so blocking stays exact no matter when the first guard subscribes, while the
-// guard machinery itself lives behind the lazy `beforeLeave` slot.
-let depth;
-function saveCurrentDepth() {
-    if (!window.history.state || window.history.state._depth == null) {
-        window.history.replaceState({ ...window.history.state, _depth: window.history.length - 1 }, "");
-    }
-    depth = window.history.state._depth;
-}
-function keepDepth(state) {
-    return {
-        ...state,
-        _depth: window.history.state && window.history.state._depth
-    };
-}
-function notifyIfNotBlocked(notify, block) {
-    let ignore = false;
-    return () => {
-        const prevDepth = depth;
-        saveCurrentDepth();
-        const delta = prevDepth == null ? null : depth - prevDepth;
-        if (ignore) {
-            ignore = false;
-            return;
-        }
-        if (delta && block(delta)) {
-            ignore = true;
-            window.history.go(-delta);
-        }
-        else {
-            notify();
-        }
-    };
-}
-function scrollToHash(hash, fallbackTop) {
-    const el = hash && document.getElementById(hash);
-    if (el) {
-        el.scrollIntoView();
-    }
-    else if (fallbackTop) {
-        window.scrollTo(0, 0);
-    }
-}
-export function browserHistory() {
-    const getSource = () => {
-        const url = window.location.pathname + window.location.search;
-        const state = window.history.state &&
-            window.history.state._depth &&
-            Object.keys(window.history.state).length === 1
-            ? undefined
-            : window.history.state;
-        return {
-            value: url + window.location.hash,
-            state
-        };
-    };
-    const beforeLeave = {};
-    if (!isServer)
-        saveCurrentDepth();
-    return {
-        get: getSource,
-        set({ value, replace, scroll, state }) {
-            if (replace) {
-                window.history.replaceState(keepDepth(state), "", value);
-            }
-            else {
-                window.history.pushState(state, "", value);
-            }
-            scrollToHash(decodeURIComponent(window.location.hash.slice(1)), scroll);
-            saveCurrentDepth();
-        },
-        init: notify => bindEvent(window, "popstate", notifyIfNotBlocked(notify, delta => {
-            const guard = beforeLeave.current;
-            if (!guard)
-                return false;
-            if (delta) {
-                return !guard.confirm(delta);
-            }
-            else {
-                const s = getSource();
-                return !guard.confirm(s.value, { state: s.state });
-            }
-        })),
-        utils: {
-            go: delta => window.history.go(delta),
-            beforeLeave
-        }
-    };
-}
-export function hashParser(str) {
-    const to = str.replace(/^.*?#/, "");
-    // Hash-only hrefs like `#foo` from plain anchors will come in as `/#foo` whereas a link to
-    // `/foo` will be `/#/foo`. Check if the to starts with a `/` and if not append it as a hash
-    // to the current path so we can handle these in-page anchors correctly.
-    if (!to.startsWith("/")) {
-        const [, path = "/"] = window.location.hash.split("#", 2);
-        return `${path}#${to}`;
-    }
-    return to;
-}
-export function hashHistory() {
-    const getSource = () => window.location.hash.slice(1);
-    const beforeLeave = {};
-    if (!isServer)
-        saveCurrentDepth();
-    return {
-        get: getSource,
-        set({ value, replace, scroll, state }) {
-            if (replace) {
-                window.history.replaceState(keepDepth(state), "", "#" + value);
-            }
-            else {
-                window.history.pushState(state, "", "#" + value);
-            }
-            const hashIndex = value.indexOf("#");
-            const hash = hashIndex >= 0 ? value.slice(hashIndex + 1) : "";
-            scrollToHash(hash, scroll);
-            saveCurrentDepth();
-        },
-        init: notify => bindEvent(window, "hashchange", notifyIfNotBlocked(notify, delta => {
-            const guard = beforeLeave.current;
-            return !!guard && !guard.confirm(delta && delta < 0 ? delta : getSource());
-        })),
-        utils: {
-            go: delta => window.history.go(delta),
-            renderPath: path => `#${path}`,
-            parsePath: hashParser,
-            beforeLeave
-        }
-    };
-}
-export function memoryHistory(initial = "/") {
-    const entries = [initial];
-    let index = 0;
-    const listeners = [];
-    const go = (n) => {
-        // https://github.com/remix-run/react-router/blob/682810ca929d0e3c64a76f8d6e465196b7a2ac58/packages/router/history.ts#L245
-        index = Math.max(0, Math.min(index + n, entries.length - 1));
-        const value = entries[index];
-        listeners.forEach(listener => listener(value));
-    };
-    const listen = (listener) => {
-        listeners.push(listener);
-        return () => {
-            const i = listeners.indexOf(listener);
-            listeners.splice(i, 1);
-        };
-    };
-    return {
-        get: () => entries[index],
-        set: ({ value, scroll, replace }) => {
-            if (replace) {
-                entries[index] = value;
-            }
-            else {
-                entries.splice(index + 1, entries.length - index, value);
-                index++;
-            }
-            listeners.forEach(listener => listener(value));
-            setTimeout(() => {
-                if (scroll) {
-                    scrollToHash(value.split("#")[1] || "", true);
-                }
-            }, 0);
-        },
-        back: () => go(-1),
-        forward: () => go(1),
-        go,
-        listen,
-        init: listen,
-        utils: { go }
-    };
-}

package/dist/server.d.ts

@@ -1,75 +0,0 @@
-import type { JSX } from "@solidjs/web";
-import type { CollectFlightDataHook, ServerFunctionOutcome } from "@solidjs/web/server-functions/server";
-import type { RouteDefinition, RoutePreloadFunc } from "./types.js";
-export type { FlashSubmission } from "./data/flash.js";
-export type { CollectFlightDataHook, ServerFunctionOutcome };
-export interface FlightDataCollectorOptions {
-    /**
-     * The app's route tree — the same config objects the `createRouter`
-     * factory receives, an array of them, or a thunk producing either (for
-     * lazily/per-request built trees). Flight data is produced by the pure
-     * preload runner: the target URL is matched against the tree and the
-     * matched routes' `preload` functions run in data-only mode.
-     */
-    routes: RouteDefinition | readonly RouteDefinition[] | (() => RouteDefinition | readonly RouteDefinition[]);
-    /**
-     * The root layout's preload — the same function the app passes to the
-     * `createRouter` factory's `preload` option. Runs before the matched
-     * routes' preloads with the semantics the root gets during a real server
-     * render: the merged params of every match and `intent: "initial"`.
-     */
-    rootPreload?: RoutePreloadFunc;
-    /** The app's base path, for resolving redirect `Location`s and matching. */
-    base?: string;
-}
-/** A `createRouter` instance carries everything the collector needs. */
-interface RouterInstanceLike {
-    (props: any): JSX.Element;
-    readonly routes: readonly RouteDefinition[];
-    readonly config: {
-        base?: string;
-        preload?: RoutePreloadFunc;
-    };
-}
-/**
- * Produces the `collectFlightData` implementation for
- * `configureServerFunctionsServer` (or `handleServerFunctionRequest`
- * options). Accepts a `createRouter` instance directly — its routes, base,
- * and `preload` are the single source of truth — or an options object for
- * trees not created through the factory.
- *
- * Strategy: rerun the route data for the URL the client will show
- * after the mutation — the redirect `Location` when the outcome carries
- * one, the referring page otherwise — collecting each `query` result under
- * its cache key, scoped to the outcome's `X-Revalidate` keys when present
- * (routes newly entered via redirect always collect fully). The returned
- * payload seeds the client router's cache through its registered
- * flight-data consumer.
- */
-export declare function createFlightDataCollector(options: FlightDataCollectorOptions | RouterInstanceLike): CollectFlightDataHook;
-/**
- * The request headers for the flight-data collection pass: the source
- * request's headers with the mutation's `Set-Cookie` mutations folded into
- * the `Cookie` header, so preloads observe the post-mutation cookie state
- * (deletions honored via Max-Age/Expires).
- */
-export declare function createSingleFlightHeaders(sourceEvent: {
-    request: Request;
-    response?: {
-        headers?: Headers;
-    };
-}): Headers;
-export interface NoJSHandlerOptions {
-    /** The app's base path, for resolving redirect `Location`s. */
-    base?: string;
-}
-/**
- * Produces the `handleNoJS` implementation for
- * `handleServerFunctionRequest` options: form posts made without the client
- * runtime redirect back to the referring page (or to the result's
- * `Location`) with the outcome riding a one-shot `flash` cookie. The
- * router's SSR initialization reads the cookie into submission state, so
- * `useSubmission()` renders the result exactly as a scripted submission
- * would — progressive enhancement with no app code.
- */
-export declare function createNoJSHandler(options?: NoJSHandlerOptions): (result: unknown, request: Request, args: unknown[], thrown?: boolean) => Response;