react-router 7.13.2 → 7.14.0-pre.0

package/dist/development/{chunk-GO74ODU3.js → chunk-GE4J47XT.js}

@@ -1,5 +1,5 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }/**
- * react-router v7.13.2
+ * react-router v7.14.0-pre.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -5590,7 +5590,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];
@@ -5602,55 +5605,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;
             }
           }
@@ -5658,46 +5682,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");
           }
@@ -5705,19 +5726,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;
             }
           }
@@ -5731,15 +5752,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;
           }
         }
@@ -6076,7 +6097,7 @@ async function decodeDeferred(reader) {
   }
 }
 function encode(input, options) {
-  const { plugins, postPlugins, signal, onComplete } = _nullishCoalesce(options, () => ( {}));
+  const { onComplete, plugins, postPlugins, signal } = _nullishCoalesce(options, () => ( {}));
   const encoder = {
     deferred: {},
     index: 0,
@@ -6090,7 +6111,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");
       }
@@ -6105,6 +6126,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) => {
@@ -6132,65 +6154,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)];
@@ -6202,8 +6230,9 @@ function encode(input, options) {
         raceDone();
       }
       await Promise.all(Object.values(encoder.deferred));
-      _optionalChain([onComplete, 'optionalCall', _82 => _82()]);
+      await processingChain;
       controller.close();
+      _optionalChain([onComplete, 'optionalCall', _82 => _82()]);
     }
   });
   return readable;
@@ -8544,6 +8573,7 @@ function Links({ nonce, crossOrigin }) {
   ));
 }
 function PrefetchPageLinks({ page, ...linkProps }) {
+  let rsc = useIsRSCRouterContext();
   let { router } = useDataRouterContext2();
   let matches = React7.useMemo(
     () => matchRoutes(router.routes, page, router.basename),
@@ -8552,6 +8582,9 @@ function PrefetchPageLinks({ page, ...linkProps }) {
   if (!matches) {
     return null;
   }
+  if (rsc) {
+    return /* @__PURE__ */ React7.createElement(RSCPrefetchPageLinksImpl, { page, matches, ...linkProps });
+  }
   return /* @__PURE__ */ React7.createElement(PrefetchPageLinksImpl, { page, matches, ...linkProps });
 }
 function useKeyedPrefetchLinks(matches) {
@@ -8572,6 +8605,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 = React7.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__ */ React7.createElement(React7.Fragment, null, dataHrefs.map((href) => /* @__PURE__ */ React7.createElement("link", { key: href, rel: "prefetch", as: "fetch", href, ...linkProps })));
+}
 function PrefetchPageLinksImpl({
   page,
   matches: nextMatches,