react-router 7.13.2 → 7.14.0-pre.0

package/dist/development/{chunk-UVKPFVEO.mjs → chunk-47HDNIOI.mjs}

@@ -1,5 +1,5 @@
 /**
- * react-router v7.13.2
+ * react-router v7.14.0-pre.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -7181,7 +7181,10 @@ function createLineSplittingTransform() {
 }
 
 // vendor/turbo-stream-v2/flatten.ts
-function flatten(input) {
+var TIME_LIMIT_MS = 1;
+var getNow = () => Date.now();
+var yieldToMain = () => new Promise((resolve) => setTimeout(resolve, 0));
+async function flatten(input) {
   const { indices } = this;
   const existing = indices.get(input);
   if (existing) return [existing];
@@ -7193,55 +7196,76 @@ function flatten(input) {
   if (input === 0 && 1 / input < 0) return NEGATIVE_ZERO;
   const index = this.index++;
   indices.set(input, index);
-  stringify.call(this, input, index);
+  const stack = [[input, index]];
+  await stringify.call(this, stack);
   return index;
 }
-function stringify(input, index) {
-  const { deferred, plugins, postPlugins } = this;
+async function stringify(stack) {
+  const { deferred, indices, plugins, postPlugins } = this;
   const str = this.stringified;
-  const stack = [[input, index]];
+  let lastYieldTime = getNow();
+  const flattenValue = (value) => {
+    const existing = indices.get(value);
+    if (existing) return [existing];
+    if (value === void 0) return UNDEFINED;
+    if (value === null) return NULL;
+    if (Number.isNaN(value)) return NAN;
+    if (value === Number.POSITIVE_INFINITY) return POSITIVE_INFINITY;
+    if (value === Number.NEGATIVE_INFINITY) return NEGATIVE_INFINITY;
+    if (value === 0 && 1 / value < 0) return NEGATIVE_ZERO;
+    const index = this.index++;
+    indices.set(value, index);
+    stack.push([value, index]);
+    return index;
+  };
+  let i = 0;
   while (stack.length > 0) {
-    const [input2, index2] = stack.pop();
-    const partsForObj = (obj) => Object.keys(obj).map((k) => `"_${flatten.call(this, k)}":${flatten.call(this, obj[k])}`).join(",");
+    const now = getNow();
+    if (++i % 6e3 === 0 && now - lastYieldTime >= TIME_LIMIT_MS) {
+      await yieldToMain();
+      lastYieldTime = getNow();
+    }
+    const [input, index] = stack.pop();
+    const partsForObj = (obj) => Object.keys(obj).map((k) => `"_${flattenValue(k)}":${flattenValue(obj[k])}`).join(",");
     let error = null;
-    switch (typeof input2) {
+    switch (typeof input) {
       case "boolean":
       case "number":
       case "string":
-        str[index2] = JSON.stringify(input2);
+        str[index] = JSON.stringify(input);
         break;
       case "bigint":
-        str[index2] = `["${TYPE_BIGINT}","${input2}"]`;
+        str[index] = `["${TYPE_BIGINT}","${input}"]`;
         break;
       case "symbol": {
-        const keyFor = Symbol.keyFor(input2);
+        const keyFor = Symbol.keyFor(input);
         if (!keyFor) {
           error = new Error(
             "Cannot encode symbol unless created with Symbol.for()"
           );
         } else {
-          str[index2] = `["${TYPE_SYMBOL}",${JSON.stringify(keyFor)}]`;
+          str[index] = `["${TYPE_SYMBOL}",${JSON.stringify(keyFor)}]`;
         }
         break;
       }
       case "object": {
-        if (!input2) {
-          str[index2] = `${NULL}`;
+        if (!input) {
+          str[index] = `${NULL}`;
           break;
         }
-        const isArray = Array.isArray(input2);
+        const isArray = Array.isArray(input);
         let pluginHandled = false;
         if (!isArray && plugins) {
           for (const plugin of plugins) {
-            const pluginResult = plugin(input2);
+            const pluginResult = plugin(input);
             if (Array.isArray(pluginResult)) {
               pluginHandled = true;
               const [pluginIdentifier, ...rest] = pluginResult;
-              str[index2] = `[${JSON.stringify(pluginIdentifier)}`;
+              str[index] = `[${JSON.stringify(pluginIdentifier)}`;
               if (rest.length > 0) {
-                str[index2] += `,${rest.map((v) => flatten.call(this, v)).join(",")}`;
+                str[index] += `,${rest.map((v) => flattenValue(v)).join(",")}`;
               }
-              str[index2] += "]";
+              str[index] += "]";
               break;
             }
           }
@@ -7249,46 +7273,43 @@ function stringify(input, index) {
         if (!pluginHandled) {
           let result = isArray ? "[" : "{";
           if (isArray) {
-            for (let i = 0; i < input2.length; i++)
-              result += (i ? "," : "") + (i in input2 ? flatten.call(this, input2[i]) : HOLE);
-            str[index2] = `${result}]`;
-          } else if (input2 instanceof Date) {
-            const dateTime = input2.getTime();
-            str[index2] = `["${TYPE_DATE}",${Number.isNaN(dateTime) ? JSON.stringify("invalid") : dateTime}]`;
-          } else if (input2 instanceof URL) {
-            str[index2] = `["${TYPE_URL}",${JSON.stringify(input2.href)}]`;
-          } else if (input2 instanceof RegExp) {
-            str[index2] = `["${TYPE_REGEXP}",${JSON.stringify(
-              input2.source
-            )},${JSON.stringify(input2.flags)}]`;
-          } else if (input2 instanceof Set) {
-            if (input2.size > 0) {
-              str[index2] = `["${TYPE_SET}",${[...input2].map((val) => flatten.call(this, val)).join(",")}]`;
+            for (let i2 = 0; i2 < input.length; i2++)
+              result += (i2 ? "," : "") + (i2 in input ? flattenValue(input[i2]) : HOLE);
+            str[index] = `${result}]`;
+          } else if (input instanceof Date) {
+            const dateTime = input.getTime();
+            str[index] = `["${TYPE_DATE}",${Number.isNaN(dateTime) ? JSON.stringify("invalid") : dateTime}]`;
+          } else if (input instanceof URL) {
+            str[index] = `["${TYPE_URL}",${JSON.stringify(input.href)}]`;
+          } else if (input instanceof RegExp) {
+            str[index] = `["${TYPE_REGEXP}",${JSON.stringify(
+              input.source
+            )},${JSON.stringify(input.flags)}]`;
+          } else if (input instanceof Set) {
+            if (input.size > 0) {
+              str[index] = `["${TYPE_SET}",${[...input].map((val) => flattenValue(val)).join(",")}]`;
             } else {
-              str[index2] = `["${TYPE_SET}"]`;
+              str[index] = `["${TYPE_SET}"]`;
             }
-          } else if (input2 instanceof Map) {
-            if (input2.size > 0) {
-              str[index2] = `["${TYPE_MAP}",${[...input2].flatMap(([k, v]) => [
-                flatten.call(this, k),
-                flatten.call(this, v)
-              ]).join(",")}]`;
+          } else if (input instanceof Map) {
+            if (input.size > 0) {
+              str[index] = `["${TYPE_MAP}",${[...input].flatMap(([k, v]) => [flattenValue(k), flattenValue(v)]).join(",")}]`;
             } else {
-              str[index2] = `["${TYPE_MAP}"]`;
+              str[index] = `["${TYPE_MAP}"]`;
             }
-          } else if (input2 instanceof Promise) {
-            str[index2] = `["${TYPE_PROMISE}",${index2}]`;
-            deferred[index2] = input2;
-          } else if (input2 instanceof Error) {
-            str[index2] = `["${TYPE_ERROR}",${JSON.stringify(input2.message)}`;
-            if (input2.name !== "Error") {
-              str[index2] += `,${JSON.stringify(input2.name)}`;
+          } else if (input instanceof Promise) {
+            str[index] = `["${TYPE_PROMISE}",${index}]`;
+            deferred[index] = input;
+          } else if (input instanceof Error) {
+            str[index] = `["${TYPE_ERROR}",${JSON.stringify(input.message)}`;
+            if (input.name !== "Error") {
+              str[index] += `,${JSON.stringify(input.name)}`;
             }
-            str[index2] += "]";
-          } else if (Object.getPrototypeOf(input2) === null) {
-            str[index2] = `["${TYPE_NULL_OBJECT}",{${partsForObj(input2)}}]`;
-          } else if (isPlainObject2(input2)) {
-            str[index2] = `{${partsForObj(input2)}}`;
+            str[index] += "]";
+          } else if (Object.getPrototypeOf(input) === null) {
+            str[index] = `["${TYPE_NULL_OBJECT}",{${partsForObj(input)}}]`;
+          } else if (isPlainObject2(input)) {
+            str[index] = `{${partsForObj(input)}}`;
           } else {
             error = new Error("Cannot encode object with prototype");
           }
@@ -7296,19 +7317,19 @@ function stringify(input, index) {
         break;
       }
       default: {
-        const isArray = Array.isArray(input2);
+        const isArray = Array.isArray(input);
         let pluginHandled = false;
         if (!isArray && plugins) {
           for (const plugin of plugins) {
-            const pluginResult = plugin(input2);
+            const pluginResult = plugin(input);
             if (Array.isArray(pluginResult)) {
               pluginHandled = true;
               const [pluginIdentifier, ...rest] = pluginResult;
-              str[index2] = `[${JSON.stringify(pluginIdentifier)}`;
+              str[index] = `[${JSON.stringify(pluginIdentifier)}`;
               if (rest.length > 0) {
-                str[index2] += `,${rest.map((v) => flatten.call(this, v)).join(",")}`;
+                str[index] += `,${rest.map((v) => flattenValue(v)).join(",")}`;
               }
-              str[index2] += "]";
+              str[index] += "]";
               break;
             }
           }
@@ -7322,15 +7343,15 @@ function stringify(input, index) {
       let pluginHandled = false;
       if (postPlugins) {
         for (const plugin of postPlugins) {
-          const pluginResult = plugin(input2);
+          const pluginResult = plugin(input);
           if (Array.isArray(pluginResult)) {
             pluginHandled = true;
             const [pluginIdentifier, ...rest] = pluginResult;
-            str[index2] = `[${JSON.stringify(pluginIdentifier)}`;
+            str[index] = `[${JSON.stringify(pluginIdentifier)}`;
             if (rest.length > 0) {
-              str[index2] += `,${rest.map((v) => flatten.call(this, v)).join(",")}`;
+              str[index] += `,${rest.map((v) => flattenValue(v)).join(",")}`;
             }
-            str[index2] += "]";
+            str[index] += "]";
             break;
           }
         }
@@ -7667,7 +7688,7 @@ async function decodeDeferred(reader) {
   }
 }
 function encode(input, options) {
-  const { plugins, postPlugins, signal, onComplete } = options ?? {};
+  const { onComplete, plugins, postPlugins, signal } = options ?? {};
   const encoder = {
     deferred: {},
     index: 0,
@@ -7681,7 +7702,7 @@ function encode(input, options) {
   let lastSentIndex = 0;
   const readable = new ReadableStream({
     async start(controller) {
-      const id = flatten.call(encoder, input);
+      const id = await flatten.call(encoder, input);
       if (Array.isArray(id)) {
         throw new Error("This should never happen");
       }
@@ -7696,6 +7717,7 @@ function encode(input, options) {
         lastSentIndex = encoder.stringified.length - 1;
       }
       const seenPromises = /* @__PURE__ */ new WeakSet();
+      let processingChain = Promise.resolve();
       if (Object.keys(encoder.deferred).length) {
         let raceDone;
         const racePromise = new Promise((resolve, reject) => {
@@ -7723,65 +7745,71 @@ function encode(input, options) {
                 deferred
               ]).then(
                 (resolved) => {
-                  const id2 = flatten.call(encoder, resolved);
-                  if (Array.isArray(id2)) {
-                    controller.enqueue(
-                      textEncoder.encode(
-                        `${TYPE_PROMISE}${deferredId}:[["${TYPE_PREVIOUS_RESOLVED}",${id2[0]}]]
+                  processingChain = processingChain.then(async () => {
+                    const id2 = await flatten.call(encoder, resolved);
+                    if (Array.isArray(id2)) {
+                      controller.enqueue(
+                        textEncoder.encode(
+                          `${TYPE_PROMISE}${deferredId}:[["${TYPE_PREVIOUS_RESOLVED}",${id2[0]}]]
 `
-                      )
-                    );
-                    encoder.index++;
-                    lastSentIndex++;
-                  } else if (id2 < 0) {
-                    controller.enqueue(
-                      textEncoder.encode(
-                        `${TYPE_PROMISE}${deferredId}:${id2}
+                        )
+                      );
+                      encoder.index++;
+                      lastSentIndex++;
+                    } else if (id2 < 0) {
+                      controller.enqueue(
+                        textEncoder.encode(
+                          `${TYPE_PROMISE}${deferredId}:${id2}
 `
-                      )
-                    );
-                  } else {
-                    const values = encoder.stringified.slice(lastSentIndex + 1).join(",");
-                    controller.enqueue(
-                      textEncoder.encode(
-                        `${TYPE_PROMISE}${deferredId}:[${values}]
+                        )
+                      );
+                    } else {
+                      const values = encoder.stringified.slice(lastSentIndex + 1).join(",");
+                      controller.enqueue(
+                        textEncoder.encode(
+                          `${TYPE_PROMISE}${deferredId}:[${values}]
 `
-                      )
-                    );
-                    lastSentIndex = encoder.stringified.length - 1;
-                  }
+                        )
+                      );
+                      lastSentIndex = encoder.stringified.length - 1;
+                    }
+                  });
+                  return processingChain;
                 },
                 (reason) => {
-                  if (!reason || typeof reason !== "object" || !(reason instanceof Error)) {
-                    reason = new Error("An unknown error occurred");
-                  }
-                  const id2 = flatten.call(encoder, reason);
-                  if (Array.isArray(id2)) {
-                    controller.enqueue(
-                      textEncoder.encode(
-                        `${TYPE_ERROR}${deferredId}:[["${TYPE_PREVIOUS_RESOLVED}",${id2[0]}]]
+                  processingChain = processingChain.then(async () => {
+                    if (!reason || typeof reason !== "object" || !(reason instanceof Error)) {
+                      reason = new Error("An unknown error occurred");
+                    }
+                    const id2 = await flatten.call(encoder, reason);
+                    if (Array.isArray(id2)) {
+                      controller.enqueue(
+                        textEncoder.encode(
+                          `${TYPE_ERROR}${deferredId}:[["${TYPE_PREVIOUS_RESOLVED}",${id2[0]}]]
 `
-                      )
-                    );
-                    encoder.index++;
-                    lastSentIndex++;
-                  } else if (id2 < 0) {
-                    controller.enqueue(
-                      textEncoder.encode(
-                        `${TYPE_ERROR}${deferredId}:${id2}
+                        )
+                      );
+                      encoder.index++;
+                      lastSentIndex++;
+                    } else if (id2 < 0) {
+                      controller.enqueue(
+                        textEncoder.encode(
+                          `${TYPE_ERROR}${deferredId}:${id2}
 `
-                      )
-                    );
-                  } else {
-                    const values = encoder.stringified.slice(lastSentIndex + 1).join(",");
-                    controller.enqueue(
-                      textEncoder.encode(
-                        `${TYPE_ERROR}${deferredId}:[${values}]
+                        )
+                      );
+                    } else {
+                      const values = encoder.stringified.slice(lastSentIndex + 1).join(",");
+                      controller.enqueue(
+                        textEncoder.encode(
+                          `${TYPE_ERROR}${deferredId}:[${values}]
 `
-                      )
-                    );
-                    lastSentIndex = encoder.stringified.length - 1;
-                  }
+                        )
+                      );
+                      lastSentIndex = encoder.stringified.length - 1;
+                    }
+                  });
+                  return processingChain;
                 }
               ).finally(() => {
                 delete encoder.deferred[Number(deferredId)];
@@ -7793,8 +7821,9 @@ function encode(input, options) {
         raceDone();
       }
       await Promise.all(Object.values(encoder.deferred));
-      onComplete?.();
+      await processingChain;
       controller.close();
+      onComplete?.();
     }
   });
   return readable;
@@ -9391,6 +9420,7 @@ function Links({ nonce, crossOrigin }) {
   ));
 }
 function PrefetchPageLinks({ page, ...linkProps }) {
+  let rsc = useIsRSCRouterContext();
   let { router } = useDataRouterContext2();
   let matches = React8.useMemo(
     () => matchRoutes(router.routes, page, router.basename),
@@ -9399,6 +9429,9 @@ function PrefetchPageLinks({ page, ...linkProps }) {
   if (!matches) {
     return null;
   }
+  if (rsc) {
+    return /* @__PURE__ */ React8.createElement(RSCPrefetchPageLinksImpl, { page, matches, ...linkProps });
+  }
   return /* @__PURE__ */ React8.createElement(PrefetchPageLinksImpl, { page, matches, ...linkProps });
 }
 function useKeyedPrefetchLinks(matches) {
@@ -9419,6 +9452,46 @@ function useKeyedPrefetchLinks(matches) {
   }, [matches, manifest, routeModules]);
   return keyedPrefetchLinks;
 }
+function RSCPrefetchPageLinksImpl({
+  page,
+  matches: nextMatches,
+  ...linkProps
+}) {
+  let location = useLocation();
+  let { future } = useFrameworkContext();
+  let { basename } = useDataRouterContext2();
+  let dataHrefs = React8.useMemo(() => {
+    if (page === location.pathname + location.search + location.hash) {
+      return [];
+    }
+    let url = singleFetchUrl(
+      page,
+      basename,
+      future.unstable_trailingSlashAwareDataRequests,
+      "rsc"
+    );
+    let hasSomeRoutesWithShouldRevalidate = false;
+    let targetRoutes = [];
+    for (let match of nextMatches) {
+      if (typeof match.route.shouldRevalidate === "function") {
+        hasSomeRoutesWithShouldRevalidate = true;
+      } else {
+        targetRoutes.push(match.route.id);
+      }
+    }
+    if (hasSomeRoutesWithShouldRevalidate && targetRoutes.length > 0) {
+      url.searchParams.set("_routes", targetRoutes.join(","));
+    }
+    return [url.pathname + url.search];
+  }, [
+    basename,
+    future.unstable_trailingSlashAwareDataRequests,
+    page,
+    location,
+    nextMatches
+  ]);
+  return /* @__PURE__ */ React8.createElement(React8.Fragment, null, dataHrefs.map((href) => /* @__PURE__ */ React8.createElement("link", { key: href, rel: "prefetch", as: "fetch", href, ...linkProps })));
+}
 function PrefetchPageLinksImpl({
   page,
   matches: nextMatches,
@@ -9897,7 +9970,7 @@ var isBrowser2 = typeof window !== "undefined" && typeof window.document !== "un
 try {
   if (isBrowser2) {
     window.__reactRouterVersion = // @ts-expect-error
-    "7.13.2";
+    "7.14.0-pre.0";
   }
 } catch (e) {
 }

package/dist/development/{chunk-UALY5CBT.mjs → chunk-D73YQQSY.mjs}

@@ -1,5 +1,5 @@
 /**
- * react-router v7.13.2
+ * react-router v7.14.0-pre.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -51,7 +51,7 @@ import {
   withComponentProps,
   withErrorBoundaryProps,
   withHydrateFallbackProps
-} from "./chunk-UVKPFVEO.mjs";
+} from "./chunk-47HDNIOI.mjs";
 
 // lib/dom/ssr/server.tsx
 import * as React from "react";
@@ -1096,14 +1096,24 @@ function getSingleFetchRedirect(status, headers, basename) {
 function encodeViaTurboStream(data2, requestSignal, streamTimeout, serverMode) {
   let controller = new AbortController();
   let timeoutId = setTimeout(
-    () => controller.abort(new Error("Server Timeout")),
+    () => {
+      controller.abort(new Error("Server Timeout"));
+      cleanupCallbacks();
+    },
     typeof streamTimeout === "number" ? streamTimeout : 4950
   );
-  let clearStreamTimeout = () => clearTimeout(timeoutId);
-  requestSignal.addEventListener("abort", clearStreamTimeout);
+  let abortControllerOnRequestAbort = () => {
+    controller.abort(requestSignal.reason);
+    cleanupCallbacks();
+  };
+  requestSignal.addEventListener("abort", abortControllerOnRequestAbort);
+  let cleanupCallbacks = () => {
+    clearTimeout(timeoutId);
+    requestSignal.removeEventListener("abort", abortControllerOnRequestAbort);
+  };
   return encode(data2, {
     signal: controller.signal,
-    onComplete: clearStreamTimeout,
+    onComplete: cleanupCallbacks,
     plugins: [
       (value) => {
         if (value instanceof Error) {
@@ -2057,6 +2067,7 @@ function populateRSCRouteModules(routeModules, matches) {
 var noopComponent = () => null;
 
 // lib/rsc/server.ssr.tsx
+var defaultManifestPath = "/__manifest";
 var REACT_USE = "use";
 var useImpl = React4[REACT_USE];
 function useSafe(promise) {
@@ -2437,7 +2448,10 @@ function RSCStaticRouter({ getPayload }) {
         imports: []
       }
     },
-    routeDiscovery: { mode: "lazy", manifestPath: "/__manifest" },
+    routeDiscovery: payload.routeDiscovery.mode === "initial" ? { mode: "initial", manifestPath: defaultManifestPath } : {
+      mode: "lazy",
+      manifestPath: payload.routeDiscovery.manifestPath || defaultManifestPath
+    },
     routeModules: createRSCRouteModules(payload)
   };
   return /* @__PURE__ */ React4.createElement(RSCRouterContext.Provider, { value: true }, /* @__PURE__ */ React4.createElement(RSCRouterGlobalErrorBoundary, { location: payload.location }, /* @__PURE__ */ React4.createElement(FrameworkContext.Provider, { value: frameworkContext }, /* @__PURE__ */ React4.createElement(