@solidjs/router 1.0.0 → 2.0.0-next.13

package/dist/data/query.js

@@ -1,6 +1,7 @@
-import { createSignal, getListener, getOwner, onCleanup, sharedConfig, startTransition } from "solid-js";
-import { getRequestEvent, isServer } from "solid-js/web";
-import { useNavigate, getIntent, getInPreloadFn } from "../routing.js";
+import { createSignal, getObserver, getOwner, onCleanup, sharedConfig } from "solid-js";
+import { getRequestEvent, isResponseEnvelope, isServer, REVALIDATE_HEADER } from "@solidjs/web";
+import { GET, decodeResponse, getServerFunctionMetadata, isServerFunction } from "@solidjs/web/server-functions";
+import { useRouter, useRoute, getIntent, getInPreloadFn } from "../routing.js";
 const LocationHeader = "Location";
 const PRELOAD_TIMEOUT = 5000;
 const CACHE_TIMEOUT = 180000;
@@ -29,11 +30,9 @@ function getCache() {
  */
 export function revalidate(key, force = true) {
     const now = Date.now();
-    // force the cache miss synchronously so a `refetch` in the same tick sees it —
-    // startTransition defers its callback to a microtask (#497)
-    force && cacheKeyOp(key, entry => (entry[0] = 0));
-    return startTransition(() => {
-        cacheKeyOp(key, entry => entry[4][1](now)); // retrigger live signals
+    cacheKeyOp(key, entry => {
+        force && (entry[0] = 0); //force cache miss
+        entry[4][1](now); // retrigger live signals
     });
 }
 export function cacheKeyOp(key, fn) {
@@ -44,15 +43,24 @@ export function cacheKeyOp(key, fn) {
     }
 }
 export function query(fn, name) {
-    // prioritize GET for server functions
-    if (fn.GET)
-        fn = fn.GET;
+    // query implies GET: the router primitive is the declaration site, so a
+    // server function handed to query() is wrapped with core `GET(fn)` here,
+    // at query-creation (module scope) — the server half records the method
+    // declaration for dispatch, the client half swaps in the GET transport.
+    // An explicit `GET(fn)` already carries the declaration on the metadata
+    // channel (`getServerFunctionMetadata(fn)?.method === "GET"`) and passes
+    // through; non-server functions are untouched.
+    if (isServerFunction(fn) && !getServerFunctionMetadata(fn)?.method) {
+        fn = GET(fn);
+    }
     const cachedFn = ((...args) => {
         const cache = getCache();
         const intent = getIntent();
         const inPreloadFn = getInPreloadFn();
         const owner = getOwner();
-        const navigate = owner ? useNavigate() : undefined;
+        const router = owner ? useRouter() : undefined;
+        const route = owner ? useRoute() : undefined;
+        const navigate = router && router.navigatorFactory();
         const now = Date.now();
         const key = name + hashKey(args);
         let cached = cache.get(key);
@@ -72,21 +80,31 @@ export function query(fn, name) {
                 }
             }
         }
-        if (getListener() && !isServer) {
+        if (getObserver() && !isServer) {
             tracking = true;
             onCleanup(() => cached[4].count--);
         }
+        // A read under a route section the in-flight navigation is leaving keeps
+        // its invalidated value instead of refetching: this render is disposed at
+        // commit and never paints, and refiring would put a second request on
+        // what single flight promises is one. The entry stays a cache miss, so
+        // the fetch happens at its next real use — a later navigation's preload
+        // or read — unless the flight payload seeds it first. Retained sections
+        // still refetch here, inside the navigation's transition, so the
+        // redirect commits with fresh data.
+        const leaving = cached && !cached[0] && route && router.leaving?.(route);
         if (cached &&
-            cached[0] &&
-            (isServer ||
-                intent === "native" ||
-                cached[4].count ||
-                Date.now() - cached[0] < PRELOAD_TIMEOUT)) {
+            (cached[0]
+                ? isServer ||
+                    intent === "native" ||
+                    cached[4].count ||
+                    Date.now() - cached[0] < PRELOAD_TIMEOUT
+                : leaving)) {
             if (tracking) {
                 cached[4].count++;
                 cached[4][0](); // track
             }
-            if (cached[3] === "preload" && intent !== "preload") {
+            if (!leaving && cached[3] === "preload" && intent !== "preload") {
                 cached[0] = now;
             }
             let res = cached[1];
@@ -95,7 +113,7 @@ export function query(fn, name) {
                     "then" in cached[1]
                         ? cached[1].then(handleResponse(false), handleResponse(true))
                         : handleResponse(false)(cached[1]);
-                !isServer && intent === "navigate" && startTransition(() => cached[4][1](cached[0])); // update version
+                !leaving && !isServer && intent === "navigate" && cached[4][1](cached[0]); // update version
             }
             inPreloadFn && "then" in res && res.catch(() => { });
             return res;
@@ -112,10 +130,10 @@ export function query(fn, name) {
             cached[0] = now;
             cached[1] = res;
             cached[3] = intent;
-            !isServer && intent === "navigate" && startTransition(() => cached[4][1](cached[0])); // update version
+            !isServer && intent === "navigate" && cached[4][1](cached[0]); // update version
         }
         else {
-            cache.set(key, (cached = [now, res, , intent, createSignal(now)]));
+            cache.set(key, (cached = [now, res, , intent, createSignal(now, { ownedWrite: true })]));
             cached[4].count = 0;
         }
         if (tracking) {
@@ -145,6 +163,14 @@ export function query(fn, name) {
         return res;
         function handleResponse(error) {
             return async (v) => {
+                let enveloped;
+                let hasEnveloped = false;
+                if (isResponseEnvelope(v)) {
+                    // respond(): the value rides in memory beside the metadata
+                    enveloped = v.value;
+                    hasEnveloped = true;
+                    v = v.response;
+                }
                 if (v instanceof Response) {
                     const e = getRequestEvent();
                     if (e) {
@@ -157,19 +183,38 @@ export function query(fn, name) {
                     }
                     const url = v.headers.get(LocationHeader);
                     if (url !== null) {
+                        // invalidate the redirect's revalidation keys before navigating so
+                        // the destination's preloads see the miss and fetch fresh (#580 thread)
+                        const keys = !isServer && v.headers.get(REVALIDATE_HEADER)?.split(",");
+                        keys && cacheKeyOp(keys, entry => (entry[0] = 0));
                         // client + server relative redirect
-                        if (navigate && url.startsWith("/"))
-                            startTransition(() => {
-                                navigate(url, { replace: true });
-                            });
+                        const soft = navigate && url.startsWith("/");
+                        if (soft)
+                            navigate(url, { replace: true });
                         else if (!isServer)
                             window.location.href = url;
                         else if (e)
                             e.response.status = 302;
-                        return;
+                        // sweep the live signals inside the same transition as the
+                        // navigation: surviving consumers (shared layouts) refetch and
+                        // hold the commit, so the destination never paints stale data
+                        keys && revalidate(keys, false);
+                        // Hold the read pending on the client: the navigation unmounts this
+                        // consumer, and resolving `undefined` instead hands a missing value
+                        // to whatever renders before the transition commits (a downstream
+                        // `.map()` crashes). The server keeps resolving — its render can't
+                        // await a navigation and the 302 discards the body anyway.
+                        return isServer ? undefined : new Promise(() => { });
+                    }
+                    if (hasEnveloped)
+                        v = enveloped;
+                    else if (v.body) {
+                        // responses the transport hands over whole (revalidation) carry a
+                        // codec-encoded body; anything else (a raw user Response) stays whole
+                        const decoded = await decodeResponse(v);
+                        if (decoded !== undefined)
+                            v = decoded;
                     }
-                    if (v.customBody)
-                        v = await v.customBody();
                 }
                 if (error)
                     throw v;
@@ -197,14 +242,12 @@ query.set = (key, value) => {
         cached[3] = "preload";
     }
     else {
-        cache.set(key, (cached = [now, Promise.resolve(value), value, "preload", createSignal(now)]));
+        cache.set(key, (cached = [now, Promise.resolve(value), value, "preload", createSignal(now, { ownedWrite: true })]));
         cached[4].count = 0;
     }
 };
 query.delete = (key) => getCache().delete(key);
 query.clear = () => getCache().clear();
-/** @deprecated use query instead */
-export const cache = query;
 function matchKey(key, keys) {
     for (let k of keys) {
         if (k && key.startsWith(k))

package/dist/data/serverForms.d.ts

@@ -0,0 +1 @@
+export { submitServerForm } from "./action.js";

package/dist/data/serverForms.js

@@ -0,0 +1,5 @@
+// The delegation fallback's lazy entry (see data/events.ts). Nothing imports
+// this module statically — it exists so the dynamic import has a target that
+// bundlers can keep as a split point: router-only apps never load the action
+// machinery unless a server-action form actually submits.
+export { submitServerForm } from "./action.js";

package/dist/fs.d.ts

@@ -0,0 +1,94 @@
+import type { DefinedRouteFilters, RouteParams, RoutePreloadFunc, RoutePreloadFuncArgs, RouteInfo, RouteSectionComponent, StandardSchemaV1, TypedRouteConfig, ValidFilters } from "./types.js";
+/**
+ * The type `defineFileRoute` hands back: `matchFilters` and `search` stay
+ * literal — and only present when provided precisely, which is what the
+ * `paths` machinery keys on once the manifest spreads this into the
+ * definition — while `preload` widens back to the plain contract. The
+ * pattern rides along as a phantom brand so `RouteProps<typeof route>`
+ * can type the file's component from the same witness.
+ */
+export type FileRouteConfig<S extends string = string, T = unknown, F = undefined, Sch = undefined> = TypedRouteConfig<S> & ([F] extends [undefined] ? {} : DefinedRouteFilters<S> extends F ? {} : {
+    matchFilters: F;
+}) & ([Sch] extends [undefined] ? {} : {
+    search: Sch;
+}) & {
+    preload?: RoutePreloadFunc<T>;
+    info?: RouteInfo;
+};
+/**
+ * Identity helper for a route file's `route` export that types `preload`'s
+ * `args.params` from a pattern witness — the file's path pattern, which the
+ * manifest (not this string) still provides at runtime:
+ *
+ * ```ts
+ * // routes/blog/[id].tsx
+ * export const route = defineFileRoute("/blog/:id", {
+ *   matchFilters: { id: int },
+ *   preload: ({ params }) => getPost(params.id) // params.id: string
+ * });
+ *
+ * export default function Post(props: RouteProps<typeof route>) {} // params *and* data typed
+ * ```
+ *
+ * `matchFilters` are validated against the pattern's params, and their
+ * types (and any `search` schema) flow through the manifest into `paths`.
+ */
+export declare function defineFileRoute<S extends string, T = unknown, const F = DefinedRouteFilters<S>, Sch extends StandardSchemaV1<any, any> | undefined = undefined>(path: S, config: {
+    matchFilters?: F & ValidFilters<F, S>;
+    preload?: (args: RoutePreloadFuncArgs<RouteParams<S>>) => T;
+    /** Standard Schema validator for this route's search params; its input type flows into the typed path proxy. */
+    search?: Sch;
+    info?: RouteInfo;
+}): FileRouteConfig<S, T, F, Sch>;
+/** A code-split module ref: delivered as a dynamic import. */
+export interface FileRouteLazyRef<M = Record<string, unknown>> {
+    src: string;
+    import(): Promise<M>;
+}
+/** An eager module ref: its picked exports are imported statically. */
+export interface FileRouteEagerRef<M = Record<string, unknown>> {
+    require(): M;
+}
+/** The shape of a nested route-manifest entry the adapter consumes. */
+export interface FileRouteEntry {
+    path: string;
+    page?: boolean;
+    $component?: FileRouteLazyRef<any> | undefined;
+    $$route?: FileRouteEagerRef<any> | undefined;
+    children?: readonly FileRouteEntry[] | undefined;
+}
+type RouteConfigOf<E> = E extends {
+    $$route: {
+        require(): {
+            route: infer R;
+        };
+    };
+} ? R : {};
+/**
+ * One manifest entry as a route definition. `children` is a required key on
+ * purpose: an optional key infers as `C | undefined`, and that union
+ * distributes `RoutePaths` into an uncallable shape.
+ */
+export type FileRouteFrom<E> = RouteConfigOf<E> & {
+    path: E extends {
+        path: infer P extends string;
+    } ? P : never;
+    component: E extends {
+        $component: object;
+    } ? RouteSectionComponent : undefined;
+    children: E extends {
+        children: infer C extends readonly FileRouteEntry[];
+    } ? FileRoutesFrom<C> : undefined;
+};
+export type FileRoutesFrom<T extends readonly FileRouteEntry[]> = {
+    [K in keyof T]: FileRouteFrom<T[K]>;
+};
+/**
+ * Converts the nested page entries of a file-system route manifest into
+ * route definitions: `$component` refs become code-split `lazy` components
+ * (their `src` doubles as the `moduleUrl` core resolves assets and islands
+ * against), and each entry's `route` config export is spread into its
+ * definition. Pass the result to `createRouter({ routes })`.
+ */
+export declare function fileRoutes<const T extends readonly FileRouteEntry[]>(entries: T): FileRoutesFrom<T>;
+export {};

package/dist/fs.js

@@ -0,0 +1,51 @@
+import { lazy } from "solid-js";
+/**
+ * Identity helper for a route file's `route` export that types `preload`'s
+ * `args.params` from a pattern witness — the file's path pattern, which the
+ * manifest (not this string) still provides at runtime:
+ *
+ * ```ts
+ * // routes/blog/[id].tsx
+ * export const route = defineFileRoute("/blog/:id", {
+ *   matchFilters: { id: int },
+ *   preload: ({ params }) => getPost(params.id) // params.id: string
+ * });
+ *
+ * export default function Post(props: RouteProps<typeof route>) {} // params *and* data typed
+ * ```
+ *
+ * `matchFilters` are validated against the pattern's params, and their
+ * types (and any `search` schema) flow through the manifest into `paths`.
+ */
+export function defineFileRoute(path, config) {
+    return config;
+}
+/**
+ * Converts the nested page entries of a file-system route manifest into
+ * route definitions: `$component` refs become code-split `lazy` components
+ * (their `src` doubles as the `moduleUrl` core resolves assets and islands
+ * against), and each entry's `route` config export is spread into its
+ * definition. Pass the result to `createRouter({ routes })`.
+ */
+export function fileRoutes(entries) {
+    const components = new Map();
+    const componentOf = (ref) => {
+        let component = components.get(ref.src);
+        if (!component) {
+            component = lazy(ref.import, ref.src);
+            components.set(ref.src, component);
+        }
+        return component;
+    };
+    const toRoute = (entry) => {
+        const config = (entry.$$route?.require().route ?? {});
+        return {
+            ...config,
+            path: entry.path,
+            component: entry.$component ? componentOf(entry.$component) : undefined,
+            info: { ...config.info, filesystem: true },
+            children: entry.children ? entry.children.map(toRoute) : undefined
+        };
+    };
+    return entries.map(toRoute);
+}

package/dist/index.d.ts

@@ -1,7 +1,28 @@
+/**
+ * Arbitrary metadata attached to routes via `info`, surfaced through
+ * `useRouteMatches` and the instance's `match()`. Declared here — in the
+ * package entry — so apps can augment it for typed, discoverable metadata:
+ *
+ * ```ts
+ * declare module "@solidjs/router" {
+ *   interface RouteInfo {
+ *     breadcrumb?: string;
+ *   }
+ * }
+ * ```
+ *
+ * Declared keys are type-checked at route definitions and typed on reads;
+ * undeclared keys remain freeform.
+ */
+export interface RouteInfo {
+    [key: string]: any;
+}
 export * from "./routers/index.js";
-export * from "./components.jsx";
 export * from "./lifecycle.js";
-export { useHref, useIsRouting, useLocation, useMatch, useCurrentMatches, useNavigate, useParams, useResolvedPath, useSearchParams, useBeforeLeave, usePreloadRoute, RouterContextObj as RouterContext } from "./routing.js";
+export { useHref, useIsRouting, useLinkState, useLocation, useMatch, useNavigate, usePreloadRoute, useParams, useResolvedPath, useRouteMatches, useSearchParams, RouterContextObj as RouterContext } from "./routing.js";
+export type { LinkState } from "./routing.js";
 export { mergeSearchString as _mergeSearchString } from "./utils.js";
+export { int } from "./paths.js";
+export type { RoutePaths, PathParamsOf, PathEnd, TypedMatchFilter, DefaultSearchTypes } from "./paths.js";
 export * from "./data/index.js";
-export type { Location, LocationChange, SearchParams, MatchFilter, MatchFilters, NavigateOptions, Navigator, OutputMatch, Params, PathMatch, RouteSectionProps, RoutePreloadFunc, RoutePreloadFuncArgs, RouteDefinition, RouteDescription, RouteMatch, RouterIntegration, RouterUtils, SetParams, Submission, BeforeLeaveEventArgs, RouteLoadFunc, RouteLoadFuncArgs, RouterResponseInit, CustomResponse } from "./types.js";
+export type { Location, LocationChange, SearchParams, MatchFilter, MatchFilters, NavigateOptions, Navigator, OutputMatch, Params, PathMatch, RouteComponent, RouteParams, RouteProps, RouteSectionProps, RoutePreloadFunc, RoutePreloadFuncArgs, RouteDefinition, RouteDescription, RouteMatch, RouterIntegration, RouterUtils, SetParams, SetSearchParams, Submission, BeforeLeaveEventArgs, TypedPath, TypedSearchPath, StandardSchemaV1 } from "./types.js";