@solidjs/router 0.17.0-next.5 → 0.17.0-next.6

package/dist/data/action.d.ts

@@ -1,5 +1,5 @@
 import { type JSX } from "@solidjs/web";
-import type { Submission, NarrowResponse } from "../types.js";
+import type { RouterContext, Submission, NarrowResponse } from "../types.js";
 export type Action<T extends Array<any>, U, V = T> = (T extends [FormData | URLSearchParams] | [] ? JSX.SerializableAttributeValue : unknown) & ((...vars: T) => Promise<NarrowResponse<U>>) & {
     url: string;
     with<A extends any[], B extends any[]>(this: (this: any, ...args: [...A, ...B]) => Promise<NarrowResponse<U>>, ...args: A): Action<B, U, V>;
@@ -16,4 +16,16 @@ export declare const actions: Map<string, Action<any, any, any>>;
 export declare function useSubmissions<T extends Array<any>, U, V>(fn: Action<T, U, V>, filter?: (input: V) => boolean): Submission<V, NarrowResponse<U>>[];
 export declare function useAction<T extends Array<any>, U, V>(action: Action<T, U, V>): (...args: Parameters<Action<T, U, V>>) => Promise<NarrowResponse<U>>;
 export declare const action: ActionFactory;
+/**
+ * Registers the router as the single-flight consumer of the server function
+ * transport. Subscribing is the opt-in: while registered, the transport
+ * sends the `X-Single-Flight` request header on mutations and delivers the
+ * folded payload here — fresh route data is seeded into the `query` cache
+ * and the envelope metadata (redirect `Location`, `X-Revalidate` keys) is
+ * applied, all before the action sees its plain return value. Called by the
+ * Router component on the client unless `singleFlight={false}`, which now
+ * simply means "never subscribe" — no consumer, no request header, no
+ * collection work on the server. Returns the unsubscribe function.
+ */
+export declare function setupFlightDataConsumer(router: RouterContext): () => void;
 export {};

package/dist/data/action.js

@@ -1,6 +1,6 @@
 import { $TRACK, action as createSolidAction, createMemo, onCleanup, getOwner } from "solid-js";
 import { isResponseEnvelope, isServer } from "@solidjs/web";
-import { decodeResponse } from "@solidjs/web/server-functions";
+import { decodeResponse, subscribeFlightData } from "@solidjs/web/server-functions";
 import { useRouter } from "../routing.js";
 import { mockBase, setFunctionName } from "../utils.js";
 import { cacheKeyOp, hashKey, revalidate, query } from "./query.js";
@@ -32,9 +32,10 @@ function actionImpl(fn, options = {}) {
         const form = this.f;
         const submitHooks = current[submitHooksSymbol];
         const settledHooks = current[settledHooksSymbol];
-        const runMutation = () => (router.singleFlight && fn.withOptions
-            ? fn.withOptions({ headers: { "X-Single-Flight": "true" } })
-            : fn)(...variables);
+        // Single-flight opt-in is no longer per call: the router's registered
+        // flight-data consumer (see setupFlightDataConsumer) makes the transport
+        // send the request header itself, so the mutation is just called.
+        const runMutation = () => fn(...variables);
         const run = createSolidAction(async function* (context) {
             context.optimistic?.();
             try {
@@ -147,11 +148,52 @@ async function settleActionResult(result) {
     }
     return result;
 }
+/**
+ * Registers the router as the single-flight consumer of the server function
+ * transport. Subscribing is the opt-in: while registered, the transport
+ * sends the `X-Single-Flight` request header on mutations and delivers the
+ * folded payload here — fresh route data is seeded into the `query` cache
+ * and the envelope metadata (redirect `Location`, `X-Revalidate` keys) is
+ * applied, all before the action sees its plain return value. Called by the
+ * Router component on the client unless `singleFlight={false}`, which now
+ * simply means "never subscribe" — no consumer, no request header, no
+ * collection work on the server. Returns the unsubscribe function.
+ */
+export function setupFlightDataConsumer(router) {
+    return subscribeFlightData((data, { response }) => applyResponseMetadata(response, router.navigatorFactory(), data));
+}
+/**
+ * Applies a server function response's integration metadata: `X-Revalidate`
+ * keys invalidate, `Location` navigates (hard for absolute urls), flight
+ * data seeds the query cache, and matching entries revalidate. Shared by
+ * the flight-data consumer and the action response path (which still sees
+ * metadata-bearing responses when no flight data was collected).
+ */
+async function applyResponseMetadata(metadata, navigate, flightData) {
+    let keys;
+    if (metadata) {
+        if (metadata.headers.has("X-Revalidate"))
+            keys = metadata.headers.get("X-Revalidate").split(",");
+        if (metadata.headers.has("Location")) {
+            const locationUrl = metadata.headers.get("Location") || "/";
+            if (locationUrl.startsWith("http")) {
+                window.location.href = locationUrl;
+            }
+            else {
+                navigate(locationUrl);
+            }
+        }
+    }
+    // invalidate
+    cacheKeyOp(keys, entry => (entry[0] = 0));
+    // set cache
+    flightData && Object.keys(flightData).forEach(k => query.set(k, flightData[k]));
+    // trigger revalidation
+    await revalidate(keys, false);
+}
 async function handleResponse(response, error, navigate) {
     let data;
-    let custom;
-    let keys;
-    let flightKeys;
+    let flightData;
     let metadata;
     if (isResponseEnvelope(response)) {
         // client-only respond(): the value rides in memory beside the metadata
@@ -160,15 +202,17 @@ async function handleResponse(response, error, navigate) {
     }
     else if (response instanceof Response) {
         metadata = response;
-        // responses the transport hands over whole (redirects, revalidation,
-        // single-flight) carry a codec-encoded body the router decodes itself
+        // responses the transport hands over whole (redirects, revalidation)
+        // carry a codec-encoded body the router decodes itself. With the
+        // flight-data consumer registered single-flight payloads never reach
+        // this path, but a manually opted-in call (no consumer) still can —
+        // unwrap the standardized { value, data } shape for it too.
         if (response.body) {
             data = await decodeResponse(response);
             if (response.headers.has("X-Single-Flight")) {
-                custom = data;
-                data = custom._$value;
-                delete custom._$value;
-                flightKeys = Object.keys(custom);
+                const payload = data;
+                data = payload.value;
+                flightData = payload.data;
             }
         }
     }
@@ -176,24 +220,6 @@ async function handleResponse(response, error, navigate) {
         return { error: response };
     else
         data = response;
-    if (metadata) {
-        if (metadata.headers.has("X-Revalidate"))
-            keys = metadata.headers.get("X-Revalidate").split(",");
-        if (metadata.headers.has("Location")) {
-            const locationUrl = metadata.headers.get("Location") || "/";
-            if (locationUrl.startsWith("http")) {
-                window.location.href = locationUrl;
-            }
-            else {
-                navigate(locationUrl);
-            }
-        }
-    }
-    // invalidate
-    cacheKeyOp(keys, entry => (entry[0] = 0));
-    // set cache
-    flightKeys && flightKeys.forEach(k => query.set(k, custom[k]));
-    // trigger revalidation
-    await revalidate(keys, false);
+    await applyResponseMetadata(metadata, navigate, flightData);
     return data != null ? { data } : undefined;
 }

package/dist/data/flash.d.ts

@@ -0,0 +1,25 @@
+export declare const FLASH_COOKIE = "flash";
+/** What rides the cookie: a Submission minus its lifecycle methods. */
+export interface FlashSubmission {
+    input: any[];
+    url: string;
+    result?: any;
+    error?: any;
+}
+/**
+ * Encodes the outcome of a no-JS submission as a Set-Cookie value. `url` is
+ * the action url (pathname + search of the server function call) so the
+ * seeded submission matches `useSubmission` filters; `thrown` errors land on
+ * `error`, returned values on `result` (mirroring the scripted split).
+ */
+export declare function encodeFlashCookie(url: string, result: any, input: any[], thrown?: boolean): string;
+/** The Set-Cookie value clearing the flash cookie after it has been read. */
+export declare function clearFlashCookie(): string;
+/** Whether a Cookie header carries a flash cookie (readable or not). */
+export declare function hasFlashCookie(cookieHeader: string | null): boolean;
+/**
+ * Decodes the flash cookie out of a request's Cookie header. Returns
+ * undefined when absent or unreadable (a malformed cookie must never take
+ * down SSR — it is cleared either way).
+ */
+export declare function decodeFlashCookie(cookieHeader: string | null): FlashSubmission | undefined;

package/dist/data/flash.js

@@ -0,0 +1,86 @@
+// The no-JS form convention's cookie codec. When a form posts to a server
+// function without the client runtime (no instance header), the server
+// handler redirects back carrying the outcome in a one-shot "flash" cookie;
+// the next SSR pass reads it here and seeds the router's submission state so
+// useSubmission() renders the result exactly as a scripted submission would.
+// Both halves live in this module so the write (src/server.ts, the handler's
+// handleNoJS) and the read (src/routing.ts, SSR initialization) can never
+// drift apart.
+export const FLASH_COOKIE = "flash";
+// Form payloads have no JSON encoding, so entries are captured as pair
+// arrays under a marker key ($f / $u) and revived to real FormData /
+// URLSearchParams on the way out. File entries cannot ride a cookie and are
+// dropped.
+function encodeInputValue(value) {
+    if (value instanceof FormData)
+        return { $f: [...value.entries()].filter(([, v]) => typeof v === "string") };
+    if (value instanceof URLSearchParams)
+        return { $u: [...value.entries()] };
+    return value;
+}
+function decodeInputValue(value) {
+    if (value && typeof value === "object") {
+        if (Array.isArray(value.$f)) {
+            const form = new FormData();
+            for (const [k, v] of value.$f)
+                form.append(k, v);
+            return form;
+        }
+        if (Array.isArray(value.$u))
+            return new URLSearchParams(value.$u);
+    }
+    return value;
+}
+/**
+ * Encodes the outcome of a no-JS submission as a Set-Cookie value. `url` is
+ * the action url (pathname + search of the server function call) so the
+ * seeded submission matches `useSubmission` filters; `thrown` errors land on
+ * `error`, returned values on `result` (mirroring the scripted split).
+ */
+export function encodeFlashCookie(url, result, input, thrown) {
+    const isError = result instanceof Error;
+    const payload = {
+        url,
+        result: isError ? result.message : result,
+        error: isError,
+        thrown: !!thrown,
+        input: input.map(encodeInputValue)
+    };
+    return `${FLASH_COOKIE}=${encodeURIComponent(JSON.stringify(payload))}; Secure; HttpOnly; Path=/`;
+}
+/** The Set-Cookie value clearing the flash cookie after it has been read. */
+export function clearFlashCookie() {
+    return `${FLASH_COOKIE}=; Max-Age=0; Path=/`;
+}
+const FLASH_MATCHER = new RegExp(`(?:^|;\\s*)${FLASH_COOKIE}=([^;]+)`);
+/** Whether a Cookie header carries a flash cookie (readable or not). */
+export function hasFlashCookie(cookieHeader) {
+    return !!cookieHeader && FLASH_MATCHER.test(cookieHeader);
+}
+/**
+ * Decodes the flash cookie out of a request's Cookie header. Returns
+ * undefined when absent or unreadable (a malformed cookie must never take
+ * down SSR — it is cleared either way).
+ */
+export function decodeFlashCookie(cookieHeader) {
+    if (!cookieHeader)
+        return;
+    const match = cookieHeader.match(FLASH_MATCHER);
+    if (!match)
+        return;
+    try {
+        const payload = JSON.parse(decodeURIComponent(match[1]));
+        if (!payload || !payload.result)
+            return;
+        const result = payload.error ? new Error(payload.result) : payload.result;
+        return {
+            input: Array.isArray(payload.input) ? payload.input.map(decodeInputValue) : [],
+            url: payload.url,
+            result: payload.thrown ? undefined : result,
+            error: payload.thrown ? result : undefined
+        };
+    }
+    catch (error) {
+        console.error(error);
+    }
+}

package/dist/data/query.js

@@ -1,6 +1,6 @@
 import { createSignal, getObserver, getOwner, onCleanup, sharedConfig } from "solid-js";
 import { getRequestEvent, isResponseEnvelope, isServer } from "@solidjs/web";
-import { decodeResponse } from "@solidjs/web/server-functions";
+import { GET, decodeResponse, getServerFunctionMetadata, isServerFunction } from "@solidjs/web/server-functions";
 import { useNavigate, getIntent, getInPreloadFn } from "../routing.js";
 const LocationHeader = "Location";
 const PRELOAD_TIMEOUT = 5000;
@@ -43,9 +43,16 @@ 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();