@rsc-kit/core 0.30.20 → 0.30.22

package/dist/js/navigate.js

@@ -320,10 +320,12 @@ export function setCallServer(fn) {
     callServerFn = fn;
 }
 /**
- * The urls a route.ts answers, so a link to one is treated as the anchor it
- * is: no prefetch - a hover must not run a route - and a full navigation
- * rather than a payload fetch, since the answer is a Response, not a page.
- * Baked into the generated browser entry from the route tree.
+ * The urls a route.ts answers, and everything under a prefix the app named in
+ * `backendPaths`, so a link to one is treated as the anchor it is: no prefetch
+ * - a hover must not run a route, or start an OAuth flow - and a full
+ * navigation rather than a payload fetch, since the answer is a Response or
+ * the backend's, not a page. Baked into the generated browser entry from the
+ * route tree and the config.
  */
 let apiRoutePatterns = [];
 export function setApiRoutes(patterns) {
@@ -334,7 +336,22 @@ export function setApiRoutes(patterns) {
             .join("/") +
         "/?$"));
 }
-/** Whether a url is one a route.ts answers. */
+/**
+ * Leave for a document load, and say why.
+ *
+ * In place of the entry being left when the navigation was asked to replace
+ * it. A redirect from inside a boundary is performed after its page was
+ * shown and pushed, and `href` would keep that url in history: Back from where
+ * it went returns to a page that redirects again.
+ */
+function loadDocument(url, reason, replace) {
+    announceDocumentLoad(url, reason);
+    if (replace)
+        window.location.replace(url);
+    else
+        window.location.href = url;
+}
+/** Whether a url is one a route.ts answers, or the backend's by name. */
 export function isApiRoute(url) {
     if (apiRoutePatterns.length === 0)
         return false;
@@ -500,7 +517,10 @@ notFound = false) {
  * hoists document metadata into <head>. Nothing needs injecting from headers.
  */
 function deserializeResponse(response) {
-    return flightDeserializer(response.body, {
+    return deserializeStream(response.body);
+}
+function deserializeStream(stream) {
+    return flightDeserializer(stream, {
         callServer: callServerFn ??
             (async () => {
                 throw new Error("Server actions not initialized");
@@ -578,8 +598,7 @@ export async function navigate(url, opts) {
     // advice. Not for a restore: going back to a page still held asks the
     // server for nothing.
     if (!opts?.restore && isUpdated()) {
-        announceDocumentLoad(url, "newer-build");
-        window.location.href = url;
+        loadDocument(url, "newer-build", opts?.replace);
         return;
     }
     if (redirectsFollowed > MAX_REDIRECTS) {
@@ -587,15 +606,15 @@ export async function navigate(url, opts) {
     }
     // External URLs can't be fetched (CORS) — go directly to full page navigation
     if (isExternalUrl(url)) {
-        announceDocumentLoad(url, "external");
-        window.location.href = url;
+        loadDocument(url, "external", opts?.replace);
         return;
     }
     // A route.ts answers with a Response, not a page: a download, a redirect
     // that decides where someone belongs, a sign-out. The browser goes there.
+    // So does a url the app named as its backend's, which may bounce to another
+    // site - an OAuth start - that a fetch cannot follow.
     if (isApiRoute(url)) {
-        announceDocumentLoad(url, "api-route");
-        window.location.href = url;
+        loadDocument(url, "api-route", opts?.replace);
         return;
     }
     // Hash-only URLs — let the browser handle scrolling natively
@@ -713,7 +732,6 @@ export async function navigate(url, opts) {
         // open over the page behind it.
         const usable = isUsable(cached, chain);
         if (usable) {
-            treePromise = cached.tree;
             // Read after the tree resolves, not now. A prefetch fills these in when
             // its response lands, and a click can land first — hover a modal link
             // and click it quickly and the entry still says depth 0, so the
@@ -722,6 +740,26 @@ export async function navigate(url, opts) {
             // waiting for it is what makes them true.
             reused = cached;
             cache.delete(cacheKey);
+            if (reused.settled) {
+                treePromise = reused.tree;
+            }
+            else {
+                // Still arriving, so read it as it comes - see follow(). The request
+                // is this navigation's from here: leaving the link, or an action
+                // dropping the other prefetches, must not cut short a page the
+                // visitor is waiting on, and being overtaken by another navigation
+                // must stop it as it would a request of its own.
+                const arriving = reused;
+                prefetchControllers.delete(cacheKey);
+                controller.signal.addEventListener("abort", () => arriving.cancel(), { once: true });
+                // A request that dies is asked again, as a prefetch that died before
+                // the click is; the entry says which it was once it has settled.
+                treePromise = arriving.follow().catch((error) => arriving.body.then(() => {
+                    if (arriving.failed)
+                        return null;
+                    throw error;
+                }));
+            }
         }
         else {
             cache.delete(cacheKey);
@@ -762,8 +800,7 @@ export async function navigate(url, opts) {
             const contentType = response.headers.get("Content-Type") ?? "";
             if (staticPayloadSuffix === null &&
                 !contentType.includes("text/x-component")) {
-                announceDocumentLoad(url, `not-a-payload:${response.status}:${contentType.split(";")[0]}`);
-                window.location.href = url;
+                loadDocument(url, `not-a-payload:${response.status}:${contentType.split(";")[0]}`, opts?.replace);
                 return;
             }
             // Headers on a server; worked out locally on a static host, where there
@@ -850,11 +887,12 @@ export async function navigate(url, opts) {
         // moved: the entry left behind can never be gone back to, and mounting a
         // new one showed every fallback in the page - a new chat's first message
         // redirects /chat to /chat?c=25 this way. A push keeps its own page, so
-        // Back still restores the one it came from.
-        const inPlaceOf = opts?.replace && !interceptSlot && new URL(url, window.location.origin).pathname === new URL(previousUrl, window.location.origin).pathname
+        // Back still restores the one it came from - except a search on the page
+        // it is on, which asks for the same place and keeps the old page behind it.
+        const inPlaceOf = (opts?.replace || opts?.inPlace) && !interceptSlot && new URL(url, window.location.origin).pathname === new URL(previousUrl, window.location.origin).pathname
             ? retentionKey(previousUrl, null)
             : null;
-        onNavigate?.(tree, activityKey, segmentDepth, inPlaceOf);
+        onNavigate?.(tree, activityKey, segmentDepth, inPlaceOf, !opts?.replace);
         if (!opts?.preserveScroll && !interceptSlot) {
             // Wait for React to commit the DOM update before scrolling.
             // Intercepted navigations preserve scroll (e.g. modal over current page).
@@ -871,8 +909,7 @@ export async function navigate(url, opts) {
         // A chunk the deploy no longer serves: the browser would have loaded the
         // document, and the new names with it. Do what it would have done.
         if (isStaleAssetError(err)) {
-            announceDocumentLoad(url, `stale-asset:${String(err?.message ?? err).slice(0, 120)}`);
-            window.location.href = url;
+            loadDocument(url, `stale-asset:${String(err?.message ?? err).slice(0, 120)}`, opts?.replace);
             return;
         }
         // Without this a navigation that fails does nothing observable: the click
@@ -1172,6 +1209,11 @@ function warm(entry, cacheKey, followed = new Set()) {
             return;
         // The page about to show: its pictures ahead of every other page's.
         preloadImages(text, "high");
+        // Taken by a click before it had all arrived, which read it as it came:
+        // the page is on its way to the screen, and decoding it again here would
+        // be the same chunks asked for twice.
+        if (cache.get(cacheKey) !== entry)
+            return;
         return entry.tree.then((tree) => {
             if (entry.slot !== null ||
                 entry.segmentDepth === 0 ||
@@ -1200,11 +1242,24 @@ function prefetchUrl(cacheKey, url, ttl, interceptSlot, refererUrl, held = { int
     const controller = new AbortController();
     prefetchControllers.set(cacheKey, controller);
     let decoded = null;
+    // Settled once the response has said whether there is a page to follow: its
+    // bytes as they arrive, or nothing for a redirect or a failure.
+    let arriving;
+    let followed = false;
+    const followable = new Promise((resolve) => {
+        arriving = resolve;
+    });
     const entry = {
         body: Promise.resolve(null),
         get tree() {
             return (decoded ??= this.body.then((text) => (text === null ? null : deserializeResponse(new Response(text)))));
         },
+        settled: false,
+        follow() {
+            followed = true;
+            return followable.then((stream) => (stream ? deserializeStream(stream) : null));
+        },
+        cancel: () => controller.abort(),
         expiresAt: Date.now() + ttl,
         segmentDepth: 0,
         layouts: null,
@@ -1237,6 +1292,7 @@ function prefetchUrl(cacheKey, url, ttl, interceptSlot, refererUrl, held = { int
             entry.redirectTo = redirectTo;
             if (!isExternalUrl(redirectTo) && isSafeRedirect(redirectTo))
                 prefetch(redirectTo, ttl);
+            arriving(null);
             return null;
         }
         entry.slot = response.headers.get("X-RSC-Revalidate");
@@ -1261,7 +1317,16 @@ function prefetchUrl(cacheKey, url, ttl, interceptSlot, refererUrl, held = { int
         // - unless the visitor is already on the way, see prefetch(). The
         // pictures the page shows are asked for now, though: on a phone they
         // take longer than the touch-to-click a hidden render has.
+        //
+        // Read twice: whole, for the cache, and from the first byte by a click
+        // that lands before the last of them - see follow(). The second read is
+        // let go as soon as the first is complete and nobody took it.
+        const copy = response.clone().body;
+        arriving(copy);
         return response.text().then((text) => {
+            entry.settled = true;
+            if (!followed)
+                copy?.cancel();
             preloadImages(text);
             // And the code for its client components, so the first visit to a
             // page does not wait on a chunk after it has arrived.
@@ -1272,6 +1337,7 @@ function prefetchUrl(cacheKey, url, ttl, interceptSlot, refererUrl, held = { int
         .catch(() => {
         entry.failed = true;
         cache.delete(cacheKey);
+        arriving(null);
         return null;
     })
         .finally(() => {