@solidjs/router 2.0.0-next.30 → 2.0.0-next.32

package/README.md

@@ -850,7 +850,7 @@ const isRouting = useIsRouting();
 return <div classList={{ "grey-out": isRouting() }}>...</div>;
 ```
 
-In Solid's dev and observe builds the router also declares every navigation to the attribution engine (`solid-js/attribution`): holds and re-runs caused by a navigation are named after the route pattern (`navigation to /users/:id`), timed from the user event that started it, and redirect hops fold onto the navigation they belong to. `attribution.navigations()` and `feedback().navigations` list them; nothing of this exists in production builds.
+In Solid's dev and observe builds the router also declares every navigation to the attribution engine (`solid-js/attribution`): holds and re-runs caused by a navigation are named after the route pattern (`navigation to /users/:id`), timed from the user event that started it, and redirect hops fold onto the navigation they belong to. `attribution.history("navigation")` and `feedback().navigations` list them; nothing of this exists in production builds.
 
 ### useMatch
 

package/dist/data/action.js

@@ -29,9 +29,10 @@ export const actions = /* #__PURE__ */ new Map();
 export function handleFormAction(evt, router, actionBase) {
     if (evt.defaultPrevented)
         return;
+    const form = evt.target;
     let actionRef = evt.submitter && evt.submitter.hasAttribute("formaction")
         ? evt.submitter.getAttribute("formaction")
-        : evt.target.getAttribute("action");
+        : form.getAttribute("action");
     if (!actionRef)
         return;
     const serverAction = !actionRef.startsWith("https://action/");
@@ -42,7 +43,7 @@ export function handleFormAction(evt, router, actionBase) {
         if (!actionRef.startsWith(actionBase))
             return;
     }
-    if (evt.target.method.toUpperCase() !== "POST")
+    if (form.method.toUpperCase() !== "POST")
         throw new Error("Only POST forms are supported for Actions");
     // A registry miss on a server-action url is a direct bind whose module
     // never loaded client-side (server components): the url is self-describing
@@ -54,10 +55,8 @@ export function handleFormAction(evt, router, actionBase) {
     const handler = actions.get(actionRef) || (serverAction && createServerFormAction(actionRef));
     if (handler) {
         evt.preventDefault();
-        const data = new FormData(evt.target, evt.submitter);
-        handler.call({ r: router, f: evt.target }, evt.target.enctype === "multipart/form-data"
-            ? data
-            : new URLSearchParams(data));
+        const data = new FormData(form, evt.submitter);
+        handler.call({ r: router, f: form }, form.enctype === "multipart/form-data" ? data : new URLSearchParams(data));
     }
 }
 /**
@@ -159,18 +158,22 @@ function actionImpl(fn, options = {}) {
         const runMutation = () => fn(...variables);
         const run = createSolidAction(async function* (context) {
             context.optimistic?.();
+            let value;
+            let error = false;
             try {
-                const value = await context.call();
-                yield;
-                return { error: false, value };
+                value = await context.call();
             }
-            catch (error) {
-                yield;
-                return { error: true, value: error };
+            catch (e) {
+                value = e;
+                error = true;
             }
+            const read = await readResponse(value, error);
+            yield;
+            // Apply inside the transition so the default revalidation's refetch and
+            // the release of the caller's optimistic writes commit as one frame (#619).
+            return applyResponse(read, router.navigatorFactory(), flightApplications !== flightApplicationsBefore);
         });
         form && setFormBusy(form, 1);
-        let settled;
         let response;
         // The transport consumer is awaited before a single-flight mutation
         // resolves, so a counter delta over the call tells whether this action's
@@ -180,7 +183,7 @@ function actionImpl(fn, options = {}) {
         // which misses every response the server returned without flight data.
         const flightApplicationsBefore = flightApplications;
         try {
-            settled = await settleActionResult(run({
+            response = await settleActionResult(run({
                 call: runMutation,
                 optimistic: submitHooks.size
                     ? () => {
@@ -189,7 +192,6 @@ function actionImpl(fn, options = {}) {
                     }
                     : undefined
             }));
-            response = await handleResponse(settled.value, settled.error, router.navigatorFactory(), flightApplications !== flightApplicationsBefore);
         }
         finally {
             form && setFormBusy(form, -1);
@@ -198,8 +200,8 @@ function actionImpl(fn, options = {}) {
         submission = {
             input: variables,
             url,
-            result: response && response.data,
-            error: response && response.error,
+            result: response?.data,
+            error: response?.error,
             clear() {
                 router.submissions[1](entries => entries.filter(entry => entry !== submission));
             },
@@ -244,8 +246,7 @@ function toAction(invoke, url, boundArgs = [], base = url, submitHooks = new Map
     fn.with = function (...args) {
         const uri = new URL(url, mockBase);
         uri.searchParams.set("args", hashKey(args));
-        const next = toAction(invoke, (uri.origin === "https://action" ? uri.origin : "") + uri.pathname + uri.search, [...boundArgs, ...args], base, submitHooks, settledHooks);
-        return next;
+        return toAction(invoke, (uri.origin === "https://action" ? uri.origin : "") + uri.pathname + uri.search, [...boundArgs, ...args], base, submitHooks, settledHooks);
     };
     fn.onSubmit = function (hook) {
         const id = Symbol("actionOnSubmitHook");
@@ -362,8 +363,10 @@ function applyResponseMetadata(metadata, navigate, flightData) {
     cacheKeyOp(keys, entry => (entry[0] = 0));
     // set cache — and fan the payload out to other keyed stores (live query
     // channels adopt delivered values instead of reconnecting)
-    flightData && Object.keys(flightData).forEach(k => query.set(k, flightData[k]));
-    flightData && deliverFlightData(flightData);
+    if (flightData) {
+        Object.keys(flightData).forEach(k => query.set(k, flightData[k]));
+        deliverFlightData(flightData);
+    }
     // trigger revalidation inside the same transition as the navigation, so
     // the redirect commits atomically with fresh data: surviving consumers
     // (shared layouts) the flight payload didn't seed refetch and hold the
@@ -371,7 +374,7 @@ function applyResponseMetadata(metadata, navigate, flightData) {
     // are fresh again by now, so the sweep re-reads them from cache.
     revalidate(keys, false);
 }
-async function handleResponse(response, error, navigate, metadataHandled) {
+async function readResponse(response, error) {
     let data;
     let flightData;
     let metadata;
@@ -397,6 +400,12 @@ async function handleResponse(response, error, navigate, metadataHandled) {
         return { error: response };
     else
         data = response;
+    return { data, flightData, metadata };
+}
+function applyResponse(read, navigate, metadataHandled) {
+    if ("error" in read)
+        return read;
+    const { data, flightData, metadata } = read;
     // The transport consumer applies metadata before returning a server
     // function's unwrapped value. Do not treat that value as a second plain
     // action response and invalidate the freshly seeded query cache again.

package/dist/data/events.js

@@ -32,7 +32,7 @@ export function setupNativeEvents({ preload = true, explicitLinks = false, actio
             if (target || (!href && !a.hasAttribute("state")))
                 return;
             const rel = (a.getAttribute("rel") || "").split(/\s+/);
-            if (a.hasAttribute("download") || (rel && rel.includes("external")))
+            if (a.hasAttribute("download") || rel.includes("external"))
                 return;
             const url = svg ? new URL(href, document.baseURI) : new URL(href);
             // Skip non-http(s) schemes (blob:, mailto:, tel:, data:, ...). blob: URLs

package/dist/data/query.js

@@ -1,4 +1,4 @@
-import { createSignal, getObserver, getOwner, onCleanup, sharedConfig, untrack } from "solid-js";
+import { createSignal, getObserver, getOwner, isHydratable, onCleanup, untrack } from "solid-js";
 // Everything server-function-shaped comes off the CORE entry: detection
 // (isServerFunction/getServerFunctionMetadata, registered-symbol reads) and
 // the late-bound RPC seam (getServerFunctionRPC). The transport itself —
@@ -9,7 +9,7 @@ import { createSignal, getObserver, getOwner, onCleanup, sharedConfig, untrack }
 // into the seam when a `'use server'` reference is created (compiled
 // output, module scope), so by the time a server function can reach
 // query() the seam is filled; plain-fetch apps read undefined forever.
-import { getRequestEvent, getServerFunctionMetadata, getServerFunctionRPC, isResponseEnvelope, isServer, isServerFunction, REVALIDATE_HEADER } from "@solidjs/web";
+import { getHydrationWriter, getRequestEvent, getServerFunctionMetadata, getServerFunctionRPC, isResponseEnvelope, isServer, isServerFunction, REVALIDATE_HEADER, takeHydrationValue } from "@solidjs/web";
 // The redirect carrier's name and decoder are the exception: two pure,
 // dependency-free bindings off a `sideEffects: false` entry, so they
 // tree-shake to a few hundred bytes without dragging the codec in (the same
@@ -19,10 +19,34 @@ import { useRouter, getIntent, getInPreloadFn } from "../routing.js";
 const LocationHeader = "Location";
 const PRELOAD_TIMEOUT = 5000;
 const CACHE_TIMEOUT = 180000;
-// When this client booted. Flight-registry entries (sharedConfig.has/load)
+const responseBodyHeaders = /* #__PURE__ */ new Set([
+    "content-type",
+    "content-length",
+    "content-encoding",
+    "transfer-encoding",
+    "content-disposition",
+    "content-language",
+    "content-location",
+    "content-range",
+    "accept-ranges",
+    "etag",
+    "last-modified"
+]);
+const forwardedCookies = /* #__PURE__ */ new WeakMap();
+// When this client booted. Flight-registry entries (takeHydrationValue)
 // hold values the server computed while rendering THIS page, so their age is
 // anchored here — not at whenever a late query() call happens to consume one.
 const bootTime = Date.now();
+// Every hydratable read ships its entry: the writer keeps the first write
+// per key, so a read skipped in a NoHydration zone never hides the entry
+// from an island that reads the same key later.
+function serializeForHydration(key, res) {
+    const writer = getHydrationWriter();
+    if (!writer || !writer.async || !isHydratable())
+        return;
+    const e = getRequestEvent();
+    (!e || !e.serverOnly) && writer.write(key, res);
+}
 let cacheMap = new Map();
 // cleanup forward/back cache
 if (!isServer) {
@@ -156,13 +180,11 @@ export function query(fn, name) {
             }
             let res = cached[1];
             if (intent !== "preload") {
-                res =
-                    "then" in cached[1]
-                        ? cached[1].then(handleResponse(false), handleResponse(true))
-                        : handleResponse(false)(cached[1]);
+                res = settle(res);
                 !isServer && intent === "navigate" && cached[4][1](cached[0]); // update version
             }
             inPreloadFn && "then" in res && res.catch(() => { });
+            isServer && serializeForHydration(key, res);
             return res;
         }
         let res;
@@ -179,13 +201,17 @@ export function query(fn, name) {
         // active navigation (or its preload) accepts the payload only while a
         // real preload of the same age would still satisfy it — anything older
         // refetches instead of serving a minutes-old value on a fresh navigation.
-        if (!isServer && sharedConfig.has && sharedConfig.has(key)) {
-            const payloadAge = now - bootTime;
-            if (!intent || payloadAge < (intent === "native" ? CACHE_TIMEOUT : PRELOAD_TIMEOUT)) {
+        if (!isServer &&
+            (!intent || now - bootTime < (intent === "native" ? CACHE_TIMEOUT : PRELOAD_TIMEOUT))) {
+            const entry = takeHydrationValue(key); // hydrating
+            if (entry) {
                 adopted = true;
-                res = sharedConfig.load(key); // hydrating
-                // @ts-ignore at least until we add a delete method to sharedConfig
-                delete globalThis._$HY.r[key];
+                res =
+                    entry.status === "pending"
+                        ? entry.promise
+                        : entry.status === "resolved"
+                            ? Promise.resolve(entry.value)
+                            : Promise.reject(entry.error);
             }
             // A payload too old for this intent stays in the registry: it is
             // inert while the refetched entry below lives, but a later claim
@@ -201,6 +227,7 @@ export function query(fn, name) {
         // it would for a preload performed when the server fetched the data.
         const stamp = adopted ? bootTime : now;
         if (cached) {
+            isServer && forwardedCookies.delete(cached);
             cached[0] = stamp;
             cached[1] = res;
             cached[3] = intent;
@@ -225,23 +252,21 @@ export function query(fn, name) {
             if (e && e.router.dataOnly)
                 return (e.router.data[key] = res);
         }
-        if (intent !== "preload") {
-            res =
-                "then" in res
-                    ? res.then(handleResponse(false), handleResponse(true))
-                    : handleResponse(false)(res);
-        }
+        if (intent !== "preload")
+            res = settle(res);
         inPreloadFn && "then" in res && res.catch(() => { });
-        // serialize on server
-        if (isServer &&
-            sharedConfig.context &&
-            sharedConfig.context.async &&
-            !sharedConfig.context.noHydrate) {
-            const e = getRequestEvent();
-            (!e || !e.serverOnly) && sharedConfig.context.serialize(key, res);
-        }
+        isServer && serializeForHydration(key, res);
         return res;
-        function handleResponse(error) {
+        // a settled read: the response handling applied to the value or the promise
+        function settle(v) {
+            let cookies = isServer ? forwardedCookies.get(cached) : undefined;
+            if (isServer && !cookies)
+                forwardedCookies.set(cached, (cookies = new WeakSet()));
+            return "then" in v
+                ? v.then(handleResponse(false, cookies), handleResponse(true, cookies))
+                : handleResponse(false, cookies)(v);
+        }
+        function handleResponse(error, cookies) {
             return async (v) => {
                 let enveloped;
                 let hasEnveloped = false;
@@ -254,11 +279,22 @@ export function query(fn, name) {
                 if (v instanceof Response) {
                     const e = getRequestEvent();
                     if (e) {
+                        const headers = e.response.headers;
+                        const skipCookies = cookies?.has(headers);
                         for (const [key, value] of v.headers) {
-                            if (key == "set-cookie")
-                                e.response.headers.append("set-cookie", value);
-                            else
-                                e.response.headers.set(key, value);
+                            // Keep metadata for the query's body off the document response.
+                            if (responseBodyHeaders.has(key))
+                                continue;
+                            if (key === "set-cookie") {
+                                if (!skipCookies)
+                                    headers.append(key, value);
+                            }
+                            else if (headers.get(key) !== value)
+                                headers.set(key, value);
+                        }
+                        // Each cached result contributes its cookies once per document.
+                        if (!skipCookies && v.headers.has("set-cookie")) {
+                            cookies?.add(headers);
                         }
                     }
                     let url = v.headers.get(LocationHeader);
@@ -347,6 +383,7 @@ query.set = (key, value) => {
     const now = Date.now();
     let cached = cache.get(key);
     if (cached) {
+        isServer && forwardedCookies.delete(cached);
         cached[0] = now;
         cached[1] = Promise.resolve(value);
         cached[2] = value;
@@ -400,7 +437,7 @@ export function hashKey(args) {
             .reduce((result, key) => {
             result[key] = val[key];
             return result;
-        }, {})
+        }, Object.create(null))
         : val);
 }
 function isPlainObject(obj) {

package/dist/fs.d.ts

@@ -35,7 +35,7 @@ export type FileRouteConfig<S extends string = string, T = unknown, F = undefine
  * `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: {
+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>) | undefined;
     preload?: ((args: RoutePreloadFuncArgs<RouteParams<S>>) => T) | undefined;
     /** Standard Schema validator for this route's search params; its input type flows into the typed path proxy. */

package/dist/fs.js

@@ -20,7 +20,7 @@ import * as server from "./fsServer.js";
  * `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) {
+export function defineFileRoute(path, config = {}) {
     return config;
 }
 /**