@solidjs/router 2.0.0-next.37 → 2.0.0-next.38

package/dist/index.jsx

@@ -1,7 +1,9 @@
 export * from "./routers/index.js";
 export * from "./lifecycle.js";
-export { useHref, useIsRouting, useLinkState, useLocation, useMatch, useNavigate, usePreloadRoute, useParams, useResolvedPath, useRouteMatches, useSearchParams, RouterContextObj as RouterContext } from "./routing.js";
+export { useHref, useIsRouting, useLinkState, useLocation, useMatch, useNavigate, useParams, useResolvedPath, useRouteMatches, useSearchParams, RouterContextObj as RouterContext } from "./routing.js";
 export { pendingLinks } from "./pending.js";
+export { eagerPreload, intentPreload, tapPreload, viewportPreload } from "./preload.js";
+export { usePreloadRoute } from "./preloadRoute.js";
 export { mergeSearchString as _mergeSearchString } from "./utils.js";
 export { int } from "./paths.js";
 export { serverRouteComponent } from "./serverRouteComponent.js";

package/dist/pending.js

@@ -1,5 +1,5 @@
 import { createMemo, DEV, isPending, latest, NotReadyError, runWithOwner } from "solid-js";
-import { matchLink } from "./utils.js";
+import { linkMatcher } from "./utils.js";
 /**
  * Pending navigation state, for the opt-in readers only: `useIsRouting`,
  * `useLinkState().pending` and the `pendingLinks` claims plugin. `isPending`
@@ -45,7 +45,7 @@ export function pendingTarget(router) {
 /** Whether `to` is the destination of the in-flight navigation. */
 export function linkPending(router, to, base, end) {
     const target = pendingTarget(router);
-    return !!target && matchLink({ pathname: target.value, search: "" }, to, base, end).active;
+    return !!target && linkMatcher({ pathname: target.value, search: "" }, base, end)(to).active;
 }
 /**
  * Opt-in `data-pending` for plain anchors. Marks claimed links whose path

package/dist/preload.d.ts

@@ -0,0 +1,53 @@
+import type { LinkPreload } from "./types.js";
+/**
+ * Preload a link when the pointer rests on it for `delay` ms (default 20),
+ * when it takes focus, and on touchstart. Moving over a link that already
+ * preloaded does not preload it again until the pointer leaves. These
+ * listeners do not check modifier keys or `defaultPrevented`; clicks still do.
+ * Warms route code and, unless `data` is false (default true), runs the
+ * matched routes' `preload` functions.
+ *
+ * @example
+ * ```ts
+ * const Router = createRouter({ routes, preloadLinks: intentPreload() });
+ * ```
+ */
+export declare const intentPreload: ({ delay, data }?: {
+    delay?: number;
+    data?: boolean;
+}) => LinkPreload;
+/**
+ * Preload a link on `pointerdown` (mouse, touch, or pen), ahead of its click.
+ * Does not check modifier keys or `defaultPrevented`. Warms route code and,
+ * unless `data` is false (default true), route data.
+ */
+export declare const tapPreload: ({ data }?: {
+    data?: boolean;
+}) => LinkPreload;
+/**
+ * Preload a link once it has stayed in the viewport for `delay` ms (default
+ * 100), when the browser is next idle (`requestIdleCallback`, or `setTimeout`
+ * where that is missing). Each link preloads once, and again after its `href`
+ * changes; a link that leaves before then is dropped. One `IntersectionObserver`
+ * is shared. `rootMargin` is passed through to it (the observer's own `"0px"`
+ * when omitted). Applies to links with `preload="viewport"`, or with `all`
+ * (default false) to every link except `preload="false"`. Skips Save-Data and
+ * 2g connections. Warms route code only unless `data` is true (default false).
+ */
+export declare const viewportPreload: ({ all, data, delay, rootMargin }?: {
+    all?: boolean;
+    data?: boolean;
+    delay?: number;
+    rootMargin?: string;
+}) => LinkPreload;
+/**
+ * Preload links as soon as the page has loaded and the browser is idle,
+ * including links mounted later. A link removed before the flush is dropped.
+ * Applies to links with `preload="eager"`, or with `all` (default false) to
+ * every link except `preload="false"`. Skips Save-Data and 2g connections.
+ * Warms route code only unless `data` is true (default false).
+ */
+export declare const eagerPreload: ({ all, data }?: {
+    all?: boolean;
+    data?: boolean;
+}) => LinkPreload;

package/dist/preload.js

@@ -0,0 +1,175 @@
+import { registerElementClaim } from "@solidjs/web";
+import { getOwner, onCleanup } from "solid-js";
+import { setLinkPreloader } from "./data/events.js";
+import { preloadRoute } from "./preloadRoute.js";
+/**
+ * Anchors as the runtime claims them: at creation and again on `href`
+ * writes. `disarm` runs when the creating owner is disposed. Claims fire
+ * before dynamic attributes are applied (solidjs/solid#3923), so whether a
+ * link is opted in, and where it points, is read when it preloads.
+ */
+function claimAnchors(arm, disarm) {
+    const seen = new WeakSet();
+    setLinkPreloader(preloadRoute);
+    onCleanup(registerElementClaim(node => {
+        if (node.nodeName.toUpperCase() !== "A")
+            return;
+        arm(node);
+        // a re-claim runs under the owner writing `href`, not the anchor's
+        if (seen.has(node))
+            return;
+        seen.add(node);
+        getOwner() && onCleanup(() => disarm(node));
+    }));
+}
+// requests made before the browser is idle run together once it is
+function whenIdle(fn) {
+    let scheduled = false;
+    return () => {
+        if (scheduled)
+            return;
+        scheduled = true;
+        (window.requestIdleCallback || setTimeout)(() => {
+            scheduled = false;
+            fn();
+        });
+    };
+}
+/**
+ * Preloads an ambient strategy's anchor: one that names the strategy in its
+ * `preload` attribute, or with `all` any but `preload="false"`. Skipped when
+ * the user asked to save data or the connection is 2g (where the Network
+ * Information API is available).
+ */
+const ambientPreload = ({ url, preload }, name, all, data) => (a) => {
+    const value = a.getAttribute("preload");
+    const connection = navigator.connection;
+    const href = (value === name || (all && value !== "false")) &&
+        !(connection && (connection.saveData || /2g/.test(connection.effectiveType))) &&
+        url(a);
+    href && preload(href, data);
+};
+/**
+ * Preload a link when the pointer rests on it for `delay` ms (default 20),
+ * when it takes focus, and on touchstart. Moving over a link that already
+ * preloaded does not preload it again until the pointer leaves. These
+ * listeners do not check modifier keys or `defaultPrevented`; clicks still do.
+ * Warms route code and, unless `data` is false (default true), runs the
+ * matched routes' `preload` functions.
+ *
+ * @example
+ * ```ts
+ * const Router = createRouter({ routes, preloadLinks: intentPreload() });
+ * ```
+ */
+export const intentPreload = ({ delay = 20, data = true } = {}) => ctx => {
+    let timeout;
+    let lastElement;
+    setLinkPreloader(preloadRoute);
+    const onIntent = (evt) => {
+        // clear before resolving: a throw must not leave the rest timer armed
+        if (evt.type === "mousemove")
+            clearTimeout(timeout);
+        const res = ctx.anchor(evt);
+        const link = res && res[0].getAttribute("preload") !== "false" ? res : undefined;
+        if (evt.type !== "mousemove")
+            return link && ctx.preload(link[1], data);
+        if (!link)
+            return (lastElement = undefined);
+        const [a, url] = link;
+        if (lastElement === a)
+            return;
+        timeout = setTimeout(() => {
+            ctx.preload(url, data);
+            lastElement = a;
+        }, delay);
+    };
+    const passive = { passive: true };
+    document.addEventListener("focusin", onIntent, passive);
+    document.addEventListener("touchstart", onIntent, passive);
+    document.addEventListener("mousemove", onIntent, passive);
+    onCleanup(() => {
+        clearTimeout(timeout);
+        document.removeEventListener("focusin", onIntent);
+        document.removeEventListener("touchstart", onIntent);
+        document.removeEventListener("mousemove", onIntent);
+    });
+};
+/**
+ * Preload a link on `pointerdown` (mouse, touch, or pen), ahead of its click.
+ * Does not check modifier keys or `defaultPrevented`. Warms route code and,
+ * unless `data` is false (default true), route data.
+ */
+export const tapPreload = ({ data = true } = {}) => ctx => {
+    setLinkPreloader(preloadRoute);
+    const onTap = (evt) => {
+        const res = ctx.anchor(evt);
+        res && res[0].getAttribute("preload") !== "false" && ctx.preload(res[1], data);
+    };
+    document.addEventListener("pointerdown", onTap, { passive: true });
+    onCleanup(() => document.removeEventListener("pointerdown", onTap));
+};
+/**
+ * Preload a link once it has stayed in the viewport for `delay` ms (default
+ * 100), when the browser is next idle (`requestIdleCallback`, or `setTimeout`
+ * where that is missing). Each link preloads once, and again after its `href`
+ * changes; a link that leaves before then is dropped. One `IntersectionObserver`
+ * is shared. `rootMargin` is passed through to it (the observer's own `"0px"`
+ * when omitted). Applies to links with `preload="viewport"`, or with `all`
+ * (default false) to every link except `preload="false"`. Skips Save-Data and
+ * 2g connections. Warms route code only unless `data` is true (default false).
+ */
+export const viewportPreload = ({ all, data = false, delay = 100, rootMargin } = {}) => ctx => {
+    if (typeof IntersectionObserver === "undefined")
+        return;
+    const warm = ambientPreload(ctx, "viewport", all, data);
+    // visible anchors: a pending dwell timer, or `true` once due
+    const visible = new Map();
+    let observer;
+    const leave = (a) => {
+        clearTimeout(visible.get(a));
+        visible.delete(a);
+    };
+    const flush = whenIdle(() => visible.forEach((due, a) => {
+        if (due !== true)
+            return;
+        observer.unobserve(a);
+        visible.delete(a);
+        warm(a);
+    }));
+    const intersect = (entries) => entries.forEach(({ target: a, isIntersecting }) => isIntersecting
+        ? visible.set(a, setTimeout(() => (visible.set(a, true), flush()), delay))
+        : leave(a));
+    claimAnchors(a => (observer ||= new IntersectionObserver(intersect, { rootMargin })).observe(a), a => {
+        observer.unobserve(a);
+        leave(a);
+    });
+    onCleanup(() => {
+        observer && observer.disconnect();
+        visible.forEach((_, a) => leave(a));
+    });
+};
+/**
+ * Preload links as soon as the page has loaded and the browser is idle,
+ * including links mounted later. A link removed before the flush is dropped.
+ * Applies to links with `preload="eager"`, or with `all` (default false) to
+ * every link except `preload="false"`. Skips Save-Data and 2g connections.
+ * Warms route code only unless `data` is true (default false).
+ */
+export const eagerPreload = ({ all, data = false } = {}) => ctx => {
+    const warm = ambientPreload(ctx, "eager", all, data);
+    const queue = new Set();
+    const flush = whenIdle(() => {
+        queue.forEach(warm);
+        queue.clear();
+    });
+    addEventListener("load", flush, { once: true });
+    claimAnchors(a => {
+        queue.add(a);
+        document.readyState === "complete" && flush();
+    }, a => queue.delete(a));
+    onCleanup(() => {
+        removeEventListener("load", flush);
+        queue.clear();
+    });
+};

package/dist/preloadRoute.d.ts

@@ -0,0 +1,23 @@
+import type { RouterContext, TypedPath } from "./types.js";
+/**
+ * Warms the routes `url` matches: their lazy components (and any lazy
+ * subtree on the way) load, and with `preloadData` their `preload` functions
+ * run under `intent: "preload"`. Only link preload strategies and
+ * `usePreloadRoute` import it, so apps using neither don't ship it.
+ */
+export declare function preloadRoute(router: RouterContext, url: URL, preloadData?: boolean): void;
+/**
+ * `usePreloadRoute` returns a function for warming a route by hand — the same
+ * work link preloading triggers: the matched routes' lazy components load,
+ * and with `preloadData` their `preload` functions run.
+ *
+ * @example
+ * ```js
+ * const preload = usePreloadRoute();
+ *
+ * preload(paths.users(2).settings, { preloadData: true });
+ * ```
+ */
+export declare const usePreloadRoute: () => (url: string | URL | TypedPath, options?: {
+    preloadData?: boolean;
+}) => void;

package/dist/preloadRoute.js

@@ -0,0 +1,92 @@
+import { runWithOwner, untrack } from "solid-js";
+import { resolveLazySubtree, setInPreloadFn, setPreloadIntent, useRouter } from "./routing.js";
+import { serverRouteArgs, serverRouteArgsEqual, serverRouteOf } from "./serverRouteShared.js";
+import { extractSearchParams, mockBase } from "./utils.js";
+/**
+ * Warms the routes `url` matches: their lazy components (and any lazy
+ * subtree on the way) load, and with `preloadData` their `preload` functions
+ * run under `intent: "preload"`. Only link preload strategies and
+ * `usePreloadRoute` import it, so apps using neither don't ship it.
+ */
+export function preloadRoute(router, url, preloadData) {
+    const next = router._match(url.pathname);
+    // An unresolved lazy subtree in the chain: the placeholder's
+    // component.preload (below) kicks the table load; once it lands,
+    // preload again so the real inner routes warm too. Preloads are
+    // speculative: a failed load (held sync throw or rejection) is ignored
+    // here — the real navigation surfaces and retries it.
+    const boundary = next.find(m => m.route.lazy && !m.route.lazy.resolved);
+    if (boundary) {
+        try {
+            resolveLazySubtree(boundary.route.lazy).then(() => preloadRoute(router, url, preloadData), () => { });
+        }
+        catch { }
+    }
+    // Data preloads run only for levels a navigation would mount fresh or
+    // reuse with changed inputs: this level's params, and search as the
+    // declared schema's output or else the raw string. Navigation itself is
+    // already this selective (a matching level is reused and re-reads through
+    // tracked params), so an unchanged level has nothing new to warm.
+    let current;
+    try {
+        current = untrack(router.matches);
+    }
+    catch { }
+    const { location } = router;
+    const query = extractSearchParams(url);
+    const inputs = (p, q, s, r) => {
+        const a = serverRouteArgs(r, p, q);
+        a.search === undefined && (a.search = s);
+        return a;
+    };
+    const prevIntent = setPreloadIntent("preload");
+    for (let match in next) {
+        const { route, params } = next[match];
+        const { preload, component } = route;
+        component?.preload?.();
+        const now = current && current[match];
+        const unchanged = now &&
+            now.route.key === route.key &&
+            serverRouteArgsEqual(inputs(params, query, url.search, route), inputs(now.params, location.query, location.search, route));
+        setInPreloadFn(true);
+        preloadData &&
+            !unchanged &&
+            runWithOwner(router._routeOwner(), () => {
+                // A server component route's data IS its call: warm the same
+                // query entry the render will read, under the same derived args.
+                const server = serverRouteOf(component);
+                server && server.call(serverRouteArgs(route, params, query));
+                preload &&
+                    preload({
+                        params,
+                        location: {
+                            pathname: url.pathname,
+                            search: url.search,
+                            hash: url.hash,
+                            query,
+                            state: null,
+                            key: ""
+                        },
+                        intent: "preload"
+                    });
+            });
+        setInPreloadFn(false);
+    }
+    setPreloadIntent(prevIntent);
+}
+/**
+ * `usePreloadRoute` returns a function for warming a route by hand — the same
+ * work link preloading triggers: the matched routes' lazy components load,
+ * and with `preloadData` their `preload` functions run.
+ *
+ * @example
+ * ```js
+ * const preload = usePreloadRoute();
+ *
+ * preload(paths.users(2).settings, { preloadData: true });
+ * ```
+ */
+export const usePreloadRoute = () => {
+    const router = useRouter();
+    return (url, options) => preloadRoute(router, url instanceof URL ? url : new URL(String(url), mockBase), options?.preloadData);
+};

package/dist/routers/factory.d.ts

@@ -1,6 +1,6 @@
 import type { JSX } from "@solidjs/web";
 import type { RoutePaths } from "../paths.js";
-import type { DefinedRouteFilters, LazyRouteChildren, LinksPlugin, OutputMatch, Params, RouteDefinition, RouteInfo, RouteParams, RoutePreloadFunc, RoutePreloadFuncArgs, RouteSectionComponent, RouteSectionProps, StandardSchemaV1, TypedPath, ValidFilters } from "../types.js";
+import type { DefinedRouteFilters, LazyRouteChildren, LinkPreload, LinksPlugin, OutputMatch, Params, RouteDefinition, RouteInfo, RouteParams, RoutePreloadFunc, RoutePreloadFuncArgs, RouteSectionComponent, RouteSectionProps, StandardSchemaV1, TypedPath, ValidFilters } from "../types.js";
 import type { RouterHistory } from "./history.js";
 /**
  * Identity helper that preserves literal types when the route tree is
@@ -96,8 +96,18 @@ export interface RouterConfig<R extends readonly RouteDefinition[] = RouteDefini
      * ```
      */
     links?: LinksPlugin;
-    /** Preload route code/data on link hover and focus. Defaults to `true`. */
-    preloadLinks?: boolean;
+    /**
+     * Link preload strategies: when to warm a link's route code and data ahead
+     * of the click. None by default. Client-only.
+     *
+     * @example
+     * ```ts
+     * import { createRouter, intentPreload } from "@solidjs/router";
+     *
+     * const Router = createRouter({ routes, preloadLinks: intentPreload() });
+     * ```
+     */
+    preloadLinks?: LinkPreload | readonly LinkPreload[];
     /**
      * Explicit scroll restoration for back/forward navigation: positions are
      * saved per history entry and restored once the navigation settles,

package/dist/routers/factory.jsx

@@ -218,6 +218,10 @@ function staticIntegration(url, utils) {
     };
 }
 export function createRouter(config) {
+    if (DEV && typeof config.preloadLinks === "boolean") {
+        console.warn("`preloadLinks` takes preload strategies, not a boolean, and preloads nothing by default. " +
+            "Use `preloadLinks: intentPreload()` for hover/focus preloading.");
+    }
     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
@@ -272,8 +276,7 @@ export function createRouter(config) {
             setupNativeEvents({
                 preload: config.preloadLinks,
                 explicitLinks: config.explicitLinks,
-                actionBase: config.actionBase,
-                transformUrl: config.transformUrl
+                actionBase: config.actionBase
             })(routerState);
             setupLinkClaims(routerState, config.explicitLinks, config.links);
             if (routerState.singleFlight)

package/dist/routing.d.ts

@@ -104,21 +104,6 @@ export declare const useMatch: <S extends string | TypedPath>(path: () => S, mat
  * ```
  */
 export declare const useRouteMatches: () => () => RouteMatch[];
-/**
- * `usePreloadRoute` returns a function for warming a route by hand — the same
- * work link hover/focus intent triggers automatically: the matched routes'
- * lazy components load, and with `preloadData` their `preload` functions run.
- *
- * @example
- * ```js
- * const preload = usePreloadRoute();
- *
- * preload(paths.users(2).settings, { preloadData: true });
- * ```
- */
-export declare const usePreloadRoute: () => (url: string | URL | TypedPath, options?: {
-    preloadData?: boolean;
-}) => void;
 /**
  * Retrieves a reactive, store-like object containing the current route path parameters as defined in the Route.
  *
@@ -256,6 +241,7 @@ export declare function provideFlightConsumer(factory: (router: RouterContext) =
 type FlashDecoder = (cookieHeader: string | null) => Promise<FlashSubmission | undefined>;
 export declare function provideFlashDecoder(decoder: FlashDecoder): void;
 export declare function getIntent(): Intent | undefined;
+export declare function setPreloadIntent(intent: Intent | undefined): Intent | undefined;
 export declare function getInPreloadFn(): boolean;
 export declare function setInPreloadFn(value: boolean): void;
 export declare function createRouterContext(integration: RouterIntegration, branches: () => Branch[], getContext?: () => any, options?: {

package/dist/routing.js

@@ -4,7 +4,7 @@ import { runWithOwner } from "solid-js";
 import { DEV } from "solid-js";
 import { createComponent, createContext, createMemo, createSignal, getOwner, NotReadyError, untrack, useContext } from "solid-js";
 import { clearFlashCookie, getRequestEvent, hasFlashCookie, isServer } from "@solidjs/web";
-import { mockBase, createMemoObject, extractSearchParams, invariant, matchLink, resolvePath, createMatcher, joinPaths, scoreRoute, mergeSearchString, expandOptionals, validateSearch } from "./utils.js";
+import { mockBase, createMemoObject, extractSearchParams, invariant, linkMatcher, resolvePath, createMatcher, joinPaths, scoreRoute, mergeSearchString, expandOptionals, validateSearch } from "./utils.js";
 import { HREF } from "./paths.js";
 import { linkPending, routingState } from "./pending.js";
 import { serverRouteOf, serverRouteArgs, serverRouteArgsEqual } from "./serverRouteShared.js";
@@ -148,22 +148,6 @@ export const useRouteMatches = () => {
     // return a copy so user mutations (eg. `.reverse()`) can't corrupt router state
     return () => router.matches().slice();
 };
-/**
- * `usePreloadRoute` returns a function for warming a route by hand — the same
- * work link hover/focus intent triggers automatically: the matched routes'
- * lazy components load, and with `preloadData` their `preload` functions run.
- *
- * @example
- * ```js
- * const preload = usePreloadRoute();
- *
- * preload(paths.users(2).settings, { preloadData: true });
- * ```
- */
-export const usePreloadRoute = () => {
-    const pre = useRouter().preloadRoute;
-    return (url, options = {}) => pre(url instanceof URL ? url : new URL(String(url), mockBase), options.preloadData);
-};
 export function useParams(_path) {
     return useRoute().params;
 }
@@ -231,7 +215,7 @@ export const useLinkState = (href, options = {}) => {
     const location = router.location;
     const to = useResolvedPath(() => String(href()));
     const base = router.base.path();
-    const state = createMemo(() => matchLink(location, to(), base, options.end));
+    const state = createMemo(() => linkMatcher(location, base, options.end)(to()));
     return {
         active: createMemo(() => state().active),
         current: createMemo(() => state().current),
@@ -551,6 +535,11 @@ let preloadIntent;
 export function getIntent() {
     return preloadIntent || useOptionalContext(RouterContextObj)?.intent?.();
 }
+export function setPreloadIntent(intent) {
+    const prev = preloadIntent;
+    preloadIntent = intent;
+    return prev;
+}
 let inPreloadFn = false;
 export function getInPreloadFn() {
     return inPreloadFn;
@@ -663,11 +652,9 @@ export function createRouterContext(integration, branches, getContext, options =
         }
         return read();
     };
+    const matchPath = (pathname) => getRouteMatches(branches(), options.transformUrl ? options.transformUrl(pathname) : pathname);
     const matches = createMemo(() => {
-        const pathname = typeof options.transformUrl === "function"
-            ? options.transformUrl(location.pathname)
-            : location.pathname;
-        const m = getRouteMatches(branches(), pathname);
+        const m = matchPath(location.pathname);
         // An unresolved lazy subtree parks readers on not-ready semantics — the
         // navigation transition (or the SSR stream) holds until the table lands.
         // NotReadyError (not a returned promise) because a match chain is full
@@ -726,12 +713,13 @@ export function createRouterContext(integration, branches, getContext, options =
         intent: transitionIntent,
         _source: source,
         _owner: routerOwner,
+        _routeOwner: getContext,
+        _match: matchPath,
         renderPath,
         parsePath,
         navigatorFactory,
         matches,
         beforeLeave,
-        preloadRoute,
         singleFlight: options.singleFlight === undefined ? true : options.singleFlight,
         get submissions() {
             return (submissions ||= createSignal(isServer ? initSubmissions() : [], { ownedWrite: true }));
@@ -860,72 +848,6 @@ export function createRouterContext(integration, branches, getContext, options =
         route = route || useOptionalContext(RouteContextObj) || baseRoute;
         return ((to, options) => navigateFromRoute(route, to, options));
     }
-    function preloadRoute(url, preloadData) {
-        const next = getRouteMatches(branches(), url.pathname);
-        // An unresolved lazy subtree in the chain: the placeholder's
-        // component.preload (below) kicks the table load; once it lands,
-        // preload again so the real inner routes warm too. Preloads are
-        // speculative: a failed load (held sync throw or rejection) is ignored
-        // here — the real navigation surfaces and retries it.
-        const boundary = next.find(m => m.route.lazy && !m.route.lazy.resolved);
-        if (boundary) {
-            try {
-                resolveLazySubtree(boundary.route.lazy).then(() => preloadRoute(url, preloadData), () => { });
-            }
-            catch { }
-        }
-        // Data preloads run only for levels a navigation would mount fresh or
-        // reuse with changed inputs: this level's params, and search as the
-        // declared schema's output or else the raw string. Navigation itself is
-        // already this selective (a matching level is reused and re-reads through
-        // tracked params), so an unchanged level has nothing new to warm.
-        let current;
-        try {
-            current = untrack(matches);
-        }
-        catch { }
-        const query = extractSearchParams(url);
-        const inputs = (p, q, s, r) => {
-            const a = serverRouteArgs(r, p, q);
-            a.search === undefined && (a.search = s);
-            return a;
-        };
-        const prevIntent = preloadIntent;
-        preloadIntent = "preload";
-        for (let match in next) {
-            const { route, params } = next[match];
-            const { preload, component } = route;
-            component?.preload?.();
-            const now = current && current[match];
-            const unchanged = now &&
-                now.route.key === route.key &&
-                serverRouteArgsEqual(inputs(params, query, url.search, route), inputs(now.params, location.query, location.search, route));
-            inPreloadFn = true;
-            preloadData &&
-                !unchanged &&
-                runWithOwner(getContext(), () => {
-                    // A server component route's data IS its call: warm the same
-                    // query entry the render will read, under the same derived args.
-                    const server = serverRouteOf(component);
-                    server && server.call(serverRouteArgs(route, params, query));
-                    preload &&
-                        preload({
-                            params,
-                            location: {
-                                pathname: url.pathname,
-                                search: url.search,
-                                hash: url.hash,
-                                query,
-                                state: null,
-                                key: ""
-                            },
-                            intent: "preload"
-                        });
-                });
-            inPreloadFn = false;
-        }
-        preloadIntent = prevIntent;
-    }
     // Seeds the initial submission from a no-JS form post: the server
     // function runtime redirected back with the outcome in a one-shot flash
     // cookie (its default no-JS convention), consumed eagerly above and

package/dist/types.d.ts

@@ -336,11 +336,14 @@ export interface RouterContext {
     _source: () => LocationChange;
     /** @internal The owner the router's own computations live under. */
     _owner: Owner | null;
+    /** @internal The owner route components and their `preload` functions run under. */
+    _routeOwner: () => Owner;
+    /** @internal Route matches for a pathname, after `transformUrl`. */
+    _match: (pathname: string) => RouteMatch[];
     matches: () => RouteMatch[];
     renderPath(path: string): string;
     parsePath(str: string): string;
     beforeLeave: BeforeLeaveSlot;
-    preloadRoute: (url: URL, preloadData?: boolean) => void;
     singleFlight: boolean;
     submissions: Signal<Submission<any, any>[]>;
 }
@@ -360,6 +363,21 @@ export type LinksPlugin = (router: RouterContext, base: string) => {
     /** Whether an anchor resolving to `target` is the in-flight destination; read when `track()` is truthy. */
     pending(target: string | undefined): boolean;
 };
+/** @internal What the router hands a link preload strategy. */
+export interface LinkPreloadContext {
+    /** The router-managed anchor on an event's composed path, with its URL. */
+    anchor(evt: Event): readonly [HTMLAnchorElement | SVGAElement, URL] | undefined;
+    /** An anchor's URL, resolved now, when the router manages it. */
+    url(a: HTMLAnchorElement | SVGAElement): URL | undefined;
+    /** Warm `url`: route code always, `preload` functions too when `data` is true. */
+    preload(url: URL, data: boolean): void;
+}
+/**
+ * A link preload strategy for the router's `preloadLinks` option, such as
+ * `intentPreload()`. Client-only: runs once under the router's owner and
+ * cleans up with it.
+ */
+export type LinkPreload = (ctx: LinkPreloadContext) => void;
 export interface BeforeLeaveEventArgs {
     from: Location;
     to: string | number;