react-router 7.1.5 → 7.2.0-pre.0

package/dist/development/dom-export.d.mts

@@ -1,6 +1,6 @@
 import * as React from 'react';
-import { R as RouterProviderProps$1 } from './fog-of-war-D6dP9JIt.mjs';
-import './route-data-Cq_b5feC.mjs';
+import { R as RouterProviderProps$1 } from './fog-of-war-Cyo_TZuh.mjs';
+import './route-data-DQbTMaUY.mjs';
 
 type RouterProviderProps = Omit<RouterProviderProps$1, "flushSync">;
 declare function RouterProvider(props: Omit<RouterProviderProps, "flushSync">): React.JSX.Element;

package/dist/development/dom-export.d.ts

@@ -1,6 +1,6 @@
 import * as React from 'react';
-import { R as RouterProviderProps$1 } from './fog-of-war-CCAcUMgB.js';
-import './route-data-Cq_b5feC.js';
+import { R as RouterProviderProps$1 } from './fog-of-war-Ax4Jg2xL.js';
+import './route-data-DQbTMaUY.js';
 
 type RouterProviderProps = Omit<RouterProviderProps$1, "flushSync">;
 declare function RouterProvider(props: Omit<RouterProviderProps, "flushSync">): React.JSX.Element;

package/dist/development/dom-export.js

@@ -1,5 +1,5 @@
 /**
- * react-router v7.1.5
+ * react-router v7.2.0-pre.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -2316,6 +2316,7 @@ function createRouter(init) {
       let localManifest = manifest;
       try {
         await patchRoutesOnNavigationImpl({
+          signal,
           path: pathname,
           matches: partialMatches,
           patch: (routeId, children) => {
@@ -4225,11 +4226,20 @@ async function loadRouteModule(route, routeModulesCache) {
 }
 
 // lib/dom/ssr/links.ts
+function getRouteCssDescriptors(route) {
+  if (!route.css) return [];
+  return route.css.map((href) => ({ rel: "stylesheet", href }));
+}
+async function prefetchRouteCss(route) {
+  if (!route.css) return;
+  let descriptors = getRouteCssDescriptors(route);
+  await Promise.all(descriptors.map(prefetchStyleLink));
+}
 async function prefetchStyleLinks(route, routeModule) {
   if (!route.css && !routeModule.links || !isPreloadSupported()) return;
   let descriptors = [];
   if (route.css) {
-    descriptors.push(...route.css.map((href) => ({ rel: "stylesheet", href })));
+    descriptors.push(...getRouteCssDescriptors(route));
   }
   if (routeModule.links) {
     descriptors.push(...routeModule.links());
@@ -4245,13 +4255,15 @@ async function prefetchStyleLinks(route, routeModule) {
       });
     }
   }
-  let matchingLinks = styleLinks.filter(
-    (link) => (!link.media || window.matchMedia(link.media).matches) && !document.querySelector(`link[rel="stylesheet"][href="${link.href}"]`)
-  );
-  await Promise.all(matchingLinks.map(prefetchStyleLink));
+  await Promise.all(styleLinks.map(prefetchStyleLink));
 }
 async function prefetchStyleLink(descriptor) {
   return new Promise((resolve) => {
+    if (descriptor.media && !window.matchMedia(descriptor.media).matches || document.querySelector(
+      `link[rel="stylesheet"][href="${descriptor.href}"]`
+    )) {
+      return resolve();
+    }
     let link = document.createElement("link");
     Object.assign(link, descriptor);
     function removeLink() {
@@ -4273,6 +4285,31 @@ async function prefetchStyleLink(descriptor) {
 function isPageLinkDescriptor(object) {
   return object != null && typeof object.page === "string";
 }
+function getModuleLinkHrefs(matches, manifest, { includeHydrateFallback } = {}) {
+  return dedupeHrefs(
+    matches.map((match) => {
+      let route = manifest.routes[match.route.id];
+      if (!route) return [];
+      let hrefs = [route.module];
+      if (route.clientActionModule) {
+        hrefs = hrefs.concat(route.clientActionModule);
+      }
+      if (route.clientLoaderModule) {
+        hrefs = hrefs.concat(route.clientLoaderModule);
+      }
+      if (includeHydrateFallback && route.hydrateFallbackModule) {
+        hrefs = hrefs.concat(route.hydrateFallbackModule);
+      }
+      if (route.imports) {
+        hrefs = hrefs.concat(route.imports);
+      }
+      return hrefs;
+    }).flat(1)
+  );
+}
+function dedupeHrefs(hrefs) {
+  return [...new Set(hrefs)];
+}
 var _isPreloadSupported;
 function isPreloadSupported() {
   if (_isPreloadSupported !== void 0) {
@@ -4316,17 +4353,31 @@ async function createRequestInit(request) {
 
 // lib/dom/ssr/single-fetch.tsx
 var SingleFetchRedirectSymbol = Symbol("SingleFetchRedirect");
-function getSingleFetchDataStrategy(manifest, routeModules, getRouter) {
+function getSingleFetchDataStrategy(manifest, routeModules, ssr, getRouter) {
   return async ({ request, matches, fetcherKey }) => {
     if (request.method !== "GET") {
       return singleFetchActionStrategy(request, matches);
     }
+    if (!ssr) {
+      let foundLoaderBelowRoot = matches.some(
+        (m) => m.route.id !== "root" && manifest.routes[m.route.id]?.hasLoader
+      );
+      if (!foundLoaderBelowRoot) {
+        let matchesToLoad = matches.filter((m) => m.shouldLoad);
+        let results = await Promise.all(matchesToLoad.map((m) => m.resolve()));
+        return results.reduce(
+          (acc, result, i) => Object.assign(acc, { [matchesToLoad[i].route.id]: result }),
+          {}
+        );
+      }
+    }
     if (fetcherKey) {
       return singleFetchLoaderFetcherStrategy(request, matches);
     }
     return singleFetchLoaderNavigationStrategy(
       manifest,
       routeModules,
+      ssr,
       getRouter(),
       request,
       matches
@@ -4360,7 +4411,7 @@ async function singleFetchActionStrategy(request, matches) {
     }
   };
 }
-async function singleFetchLoaderNavigationStrategy(manifest, routeModules, router2, request, matches) {
+async function singleFetchLoaderNavigationStrategy(manifest, routeModules, ssr, router2, request, matches) {
   let routesParams = /* @__PURE__ */ new Set();
   let foundOptOutRoute = false;
   let routeDfds = matches.map(() => createDeferred2());
@@ -4426,7 +4477,7 @@ async function singleFetchLoaderNavigationStrategy(manifest, routeModules, route
     singleFetchDfd.resolve({});
   } else {
     try {
-      if (foundOptOutRoute && routesParams.size > 0) {
+      if (ssr && foundOptOutRoute && routesParams.size > 0) {
         url.searchParams.set(
           "_routes",
           matches.filter((m) => routesParams.has(m.route.id)).map((m) => m.route.id).join(",")
@@ -4754,11 +4805,12 @@ function getRouteComponents(route, routeModule, isSpaMode) {
   }
   return { Component: Component4, ErrorBoundary, HydrateFallback };
 }
-function createClientRoutesWithHMRRevalidationOptOut(needsRevalidation, manifest, routeModulesCache, initialState, future, isSpaMode) {
+function createClientRoutesWithHMRRevalidationOptOut(needsRevalidation, manifest, routeModulesCache, initialState, ssr, isSpaMode) {
   return createClientRoutes(
     manifest,
     routeModulesCache,
     initialState,
+    ssr,
     isSpaMode,
     "",
     groupRoutesByParentId(manifest),
@@ -4767,14 +4819,14 @@ function createClientRoutesWithHMRRevalidationOptOut(needsRevalidation, manifest
 }
 function preventInvalidServerHandlerCall(type, route, isSpaMode) {
   if (isSpaMode) {
-    let fn2 = type === "action" ? "serverAction()" : "serverLoader()";
-    let msg2 = `You cannot call ${fn2} in SPA Mode (routeId: "${route.id}")`;
-    console.error(msg2);
-    throw new ErrorResponseImpl(400, "Bad Request", new Error(msg2), true);
+    let fn = type === "action" ? "serverAction()" : "serverLoader()";
+    let msg = `You cannot call ${fn} in SPA Mode (routeId: "${route.id}")`;
+    console.error(msg);
+    throw new ErrorResponseImpl(400, "Bad Request", new Error(msg), true);
   }
-  let fn = type === "action" ? "serverAction()" : "serverLoader()";
-  let msg = `You are trying to call ${fn} on a route that does not have a server ${type} (routeId: "${route.id}")`;
   if (type === "loader" && !route.hasLoader || type === "action" && !route.hasAction) {
+    let fn = type === "action" ? "serverAction()" : "serverLoader()";
+    let msg = `You are trying to call ${fn} on a route that does not have a server ${type} (routeId: "${route.id}")`;
     console.error(msg);
     throw new ErrorResponseImpl(400, "Bad Request", new Error(msg), true);
   }
@@ -4785,7 +4837,7 @@ function noActionDefinedError(type, routeId) {
   console.error(msg);
   throw new ErrorResponseImpl(405, "Method Not Allowed", new Error(msg), true);
 }
-function createClientRoutes(manifest, routeModulesCache, initialState, isSpaMode, parentId = "", routesByParentId = groupRoutesByParentId(manifest), needsRevalidation) {
+function createClientRoutes(manifest, routeModulesCache, initialState, ssr, isSpaMode, parentId = "", routesByParentId = groupRoutesByParentId(manifest), needsRevalidation) {
   return (routesByParentId[parentId] || []).map((route) => {
     let routeModule = routeModulesCache[route.id];
     function fetchServerHandler(singleFetch) {
@@ -4805,6 +4857,21 @@ function createClientRoutes(manifest, routeModulesCache, initialState, isSpaMode
       }
       return fetchServerHandler(singleFetch);
     }
+    function prefetchModule(modulePath) {
+      import(
+        /* @vite-ignore */
+        /* webpackIgnore: true */
+        modulePath
+      );
+    }
+    function prefetchRouteModuleChunks(route2) {
+      if (route2.clientActionModule) {
+        prefetchModule(route2.clientActionModule);
+      }
+      if (route2.clientLoaderModule) {
+        prefetchModule(route2.clientLoaderModule);
+      }
+    }
     async function prefetchStylesAndCallHandler(handler) {
       let cachedModule = routeModulesCache[route.id];
       let linkPrefetchPromise = cachedModule ? prefetchStyleLinks(route, cachedModule) : Promise.resolve();
@@ -4826,7 +4893,8 @@ function createClientRoutes(manifest, routeModulesCache, initialState, isSpaMode
         handle: routeModule.handle,
         shouldRevalidate: getShouldRevalidateFunction(
           routeModule,
-          route.id,
+          route,
+          ssr,
           needsRevalidation
         )
       });
@@ -4843,7 +4911,6 @@ function createClientRoutes(manifest, routeModulesCache, initialState, isSpaMode
               "No `routeModule` available for critical-route loader"
             );
             if (!routeModule.clientLoader) {
-              if (isSpaMode) return null;
               return fetchServerLoader(singleFetch);
             }
             return routeModule.clientLoader({
@@ -4898,9 +4965,24 @@ function createClientRoutes(manifest, routeModulesCache, initialState, isSpaMode
     } else {
       if (!route.hasClientLoader) {
         dataRoute.loader = ({ request }, singleFetch) => prefetchStylesAndCallHandler(() => {
-          if (isSpaMode) return Promise.resolve(null);
           return fetchServerLoader(singleFetch);
         });
+      } else if (route.clientLoaderModule) {
+        dataRoute.loader = async (args, singleFetch) => {
+          invariant2(route.clientLoaderModule);
+          let { clientLoader } = await import(
+            /* @vite-ignore */
+            /* webpackIgnore: true */
+            route.clientLoaderModule
+          );
+          return clientLoader({
+            ...args,
+            async serverLoader() {
+              preventInvalidServerHandlerCall("loader", route, isSpaMode);
+              return fetchServerLoader(singleFetch);
+            }
+          });
+        };
       }
       if (!route.hasClientAction) {
         dataRoute.action = ({ request }, singleFetch) => prefetchStylesAndCallHandler(() => {
@@ -4909,12 +4991,34 @@ function createClientRoutes(manifest, routeModulesCache, initialState, isSpaMode
           }
           return fetchServerAction(singleFetch);
         });
+      } else if (route.clientActionModule) {
+        dataRoute.action = async (args, singleFetch) => {
+          invariant2(route.clientActionModule);
+          prefetchRouteModuleChunks(route);
+          let { clientAction } = await import(
+            /* @vite-ignore */
+            /* webpackIgnore: true */
+            route.clientActionModule
+          );
+          return clientAction({
+            ...args,
+            async serverAction() {
+              preventInvalidServerHandlerCall("action", route, isSpaMode);
+              return fetchServerAction(singleFetch);
+            }
+          });
+        };
       }
       dataRoute.lazy = async () => {
-        let mod = await loadRouteModuleWithBlockingLinks(
+        if (route.clientLoaderModule || route.clientActionModule) {
+          await new Promise((resolve) => setTimeout(resolve, 0));
+        }
+        let modPromise = loadRouteModuleWithBlockingLinks(
           route,
           routeModulesCache
         );
+        prefetchRouteModuleChunks(route);
+        let mod = await modPromise;
         let lazyRoute = { ...mod };
         if (mod.clientLoader) {
           let clientLoader = mod.clientLoader;
@@ -4942,7 +5046,8 @@ function createClientRoutes(manifest, routeModulesCache, initialState, isSpaMode
           hasErrorBoundary: lazyRoute.hasErrorBoundary,
           shouldRevalidate: getShouldRevalidateFunction(
             lazyRoute,
-            route.id,
+            route,
+            ssr,
             needsRevalidation
           ),
           handle: lazyRoute.handle,
@@ -4957,6 +5062,7 @@ function createClientRoutes(manifest, routeModulesCache, initialState, isSpaMode
       manifest,
       routeModulesCache,
       initialState,
+      ssr,
       isSpaMode,
       route.id,
       routesByParentId,
@@ -4966,15 +5072,18 @@ function createClientRoutes(manifest, routeModulesCache, initialState, isSpaMode
     return dataRoute;
   });
 }
-function getShouldRevalidateFunction(route, routeId, needsRevalidation) {
+function getShouldRevalidateFunction(route, manifestRoute, ssr, needsRevalidation) {
   if (needsRevalidation) {
     return wrapShouldRevalidateForHdr(
-      routeId,
+      manifestRoute.id,
       route.shouldRevalidate,
       needsRevalidation
     );
   }
-  if (route.shouldRevalidate) {
+  if (!ssr && manifestRoute.id === "root" && manifestRoute.hasLoader && !manifestRoute.hasClientLoader) {
+    return () => false;
+  }
+  if (ssr && route.shouldRevalidate) {
     let fn = route.shouldRevalidate;
     return (opts) => fn({ ...opts, defaultShouldRevalidate: true });
   }
@@ -4991,8 +5100,13 @@ function wrapShouldRevalidateForHdr(routeId, routeShouldRevalidate, needsRevalid
   };
 }
 async function loadRouteModuleWithBlockingLinks(route, routeModules) {
-  let routeModule = await loadRouteModule(route, routeModules);
-  await prefetchStyleLinks(route, routeModule);
+  let routeModulePromise = loadRouteModule(route, routeModules);
+  let prefetchRouteCssPromise = prefetchRouteCss(route);
+  let routeModule = await routeModulePromise;
+  await Promise.all([
+    prefetchRouteCssPromise,
+    prefetchStyleLinks(route, routeModule)
+  ]);
   return {
     Component: getRouteModuleComponent(routeModule),
     ErrorBoundary: routeModule.ErrorBoundary,
@@ -5020,8 +5134,8 @@ var nextPaths = /* @__PURE__ */ new Set();
 var discoveredPathsMaxSize = 1e3;
 var discoveredPaths = /* @__PURE__ */ new Set();
 var URL_LIMIT = 7680;
-function isFogOfWarEnabled(isSpaMode) {
-  return !isSpaMode;
+function isFogOfWarEnabled(ssr) {
+  return ssr === true;
 }
 function getPartialManifest(manifest, router2) {
   let routeIds = new Set(router2.state.matches.map((m) => m.route.id));
@@ -5047,11 +5161,11 @@ function getPartialManifest(manifest, router2) {
     routes: initialRoutes
   };
 }
-function getPatchRoutesOnNavigationFunction(manifest, routeModules, isSpaMode, basename) {
-  if (!isFogOfWarEnabled(isSpaMode)) {
+function getPatchRoutesOnNavigationFunction(manifest, routeModules, ssr, isSpaMode, basename) {
+  if (!isFogOfWarEnabled(ssr)) {
     return void 0;
   }
-  return async ({ path, patch }) => {
+  return async ({ path, patch, signal }) => {
     if (discoveredPaths.has(path)) {
       return;
     }
@@ -5059,15 +5173,17 @@ function getPatchRoutesOnNavigationFunction(manifest, routeModules, isSpaMode, b
       [path],
       manifest,
       routeModules,
+      ssr,
       isSpaMode,
       basename,
-      patch
+      patch,
+      signal
     );
   };
 }
-function useFogOFWarDiscovery(router2, manifest, routeModules, isSpaMode) {
+function useFogOFWarDiscovery(router2, manifest, routeModules, ssr, isSpaMode) {
   React8.useEffect(() => {
-    if (!isFogOfWarEnabled(isSpaMode) || navigator.connection?.saveData === true) {
+    if (!isFogOfWarEnabled(ssr) || navigator.connection?.saveData === true) {
       return;
     }
     function registerElement(el) {
@@ -5097,6 +5213,7 @@ function useFogOFWarDiscovery(router2, manifest, routeModules, isSpaMode) {
           lazyPaths,
           manifest,
           routeModules,
+          ssr,
           isSpaMode,
           router2.basename,
           router2.patchRoutes
@@ -5115,9 +5232,9 @@ function useFogOFWarDiscovery(router2, manifest, routeModules, isSpaMode) {
       attributeFilter: ["data-discover", "href", "action"]
     });
     return () => observer.disconnect();
-  }, [isSpaMode, manifest, routeModules, router2]);
+  }, [ssr, isSpaMode, manifest, routeModules, router2]);
 }
-async function fetchAndApplyManifestPatches(paths, manifest, routeModules, isSpaMode, basename, patchRoutes) {
+async function fetchAndApplyManifestPatches(paths, manifest, routeModules, ssr, isSpaMode, basename, patchRoutes, signal) {
   let manifestPath = `${basename != null ? basename : "/"}/__manifest`.replace(
     /\/+/g,
     "/"
@@ -5129,13 +5246,19 @@ async function fetchAndApplyManifestPatches(paths, manifest, routeModules, isSpa
     nextPaths.clear();
     return;
   }
-  let res = await fetch(url);
-  if (!res.ok) {
-    throw new Error(`${res.status} ${res.statusText}`);
-  } else if (res.status >= 400) {
-    throw new Error(await res.text());
+  let serverPatches;
+  try {
+    let res = await fetch(url, { signal });
+    if (!res.ok) {
+      throw new Error(`${res.status} ${res.statusText}`);
+    } else if (res.status >= 400) {
+      throw new Error(await res.text());
+    }
+    serverPatches = await res.json();
+  } catch (e) {
+    if (signal?.aborted) return;
+    throw e;
   }
-  let serverPatches = await res.json();
   let knownRoutes = new Set(Object.keys(manifest.routes));
   let patches = Object.values(serverPatches).reduce((acc, route) => {
     if (route && !knownRoutes.has(route.id)) {
@@ -5154,7 +5277,7 @@ async function fetchAndApplyManifestPatches(paths, manifest, routeModules, isSpa
   parentIds.forEach(
     (parentId) => patchRoutes(
       parentId || null,
-      createClientRoutes(patches, routeModules, null, isSpaMode, parentId)
+      createClientRoutes(patches, routeModules, null, ssr, isSpaMode, parentId)
     )
   );
 }
@@ -5212,10 +5335,10 @@ function getActiveMatches(matches, errors, isSpaMode) {
 }
 var isHydrated = false;
 function Scripts(props) {
-  let { manifest, serverHandoffString, isSpaMode, renderMeta } = useFrameworkContext();
+  let { manifest, serverHandoffString, isSpaMode, ssr, renderMeta } = useFrameworkContext();
   let { router: router2, static: isStatic, staticContext } = useDataRouterContext();
   let { matches: routerMatches } = useDataRouterStateContext();
-  let enableFogOfWar = isFogOfWarEnabled(isSpaMode);
+  let enableFogOfWar = isFogOfWarEnabled(ssr);
   if (renderMeta) {
     renderMeta.didRenderScripts = true;
   }
@@ -5227,11 +5350,44 @@ function Scripts(props) {
     let streamScript = "window.__reactRouterContext.stream = new ReadableStream({start(controller){window.__reactRouterContext.streamController = controller;}}).pipeThrough(new TextEncoderStream());";
     let contextScript = staticContext ? `window.__reactRouterContext = ${serverHandoffString};${streamScript}` : " ";
     let routeModulesScript = !isStatic ? " " : `${manifest.hmr?.runtime ? `import ${JSON.stringify(manifest.hmr.runtime)};` : ""}${!enableFogOfWar ? `import ${JSON.stringify(manifest.url)}` : ""};
-${matches.map(
-      (match, index) => `import * as route${index} from ${JSON.stringify(
-        manifest.routes[match.route.id].module
-      )};`
-    ).join("\n")}
+${matches.map((match, routeIndex) => {
+      let routeVarName = `route${routeIndex}`;
+      let manifestEntry = manifest.routes[match.route.id];
+      invariant2(manifestEntry, `Route ${match.route.id} not found in manifest`);
+      let {
+        clientActionModule,
+        clientLoaderModule,
+        hydrateFallbackModule,
+        module: module2
+      } = manifestEntry;
+      let chunks = [
+        ...clientActionModule ? [
+          {
+            module: clientActionModule,
+            varName: `${routeVarName}_clientAction`
+          }
+        ] : [],
+        ...clientLoaderModule ? [
+          {
+            module: clientLoaderModule,
+            varName: `${routeVarName}_clientLoader`
+          }
+        ] : [],
+        ...hydrateFallbackModule ? [
+          {
+            module: hydrateFallbackModule,
+            varName: `${routeVarName}_HydrateFallback`
+          }
+        ] : [],
+        { module: module2, varName: `${routeVarName}_main` }
+      ];
+      if (chunks.length === 1) {
+        return `import * as ${routeVarName} from ${JSON.stringify(module2)};`;
+      }
+      let chunkImportsSnippet = chunks.map((chunk) => `import * as ${chunk.varName} from "${chunk.module}";`).join("\n");
+      let mergedChunksSnippet = `const ${routeVarName} = {${chunks.map((chunk) => `...${chunk.varName}`).join(",")}};`;
+      return [chunkImportsSnippet, mergedChunksSnippet].join("\n");
+    }).join("\n")}
   ${enableFogOfWar ? (
       // Inline a minimal manifest with the SSR matches
       `window.__reactRouterManifest = ${JSON.stringify(
@@ -5262,11 +5418,11 @@ import(${JSON.stringify(manifest.entry.module)});`;
       }
     ));
   }, []);
-  let routePreloads = matches.map((match) => {
-    let route = manifest.routes[match.route.id];
-    return route ? (route.imports || []).concat([route.module]) : [];
-  }).flat(1);
-  let preloads = isHydrated ? [] : manifest.entry.imports.concat(routePreloads);
+  let preloads = isHydrated ? [] : manifest.entry.imports.concat(
+    getModuleLinkHrefs(matches, manifest, {
+      includeHydrateFallback: true
+    })
+  );
   return isHydrated ? null : /* @__PURE__ */ React9.createElement(React9.Fragment, null, !enableFogOfWar ? /* @__PURE__ */ React9.createElement(
     "link",
     {
@@ -5382,13 +5538,17 @@ function createHydratedRouter() {
     ssrInfo.manifest.routes,
     ssrInfo.routeModules,
     ssrInfo.context.state,
+    ssrInfo.context.ssr,
     ssrInfo.context.isSpaMode
   );
   let hydrationData = void 0;
-  if (!ssrInfo.context.isSpaMode) {
+  let loaderData = ssrInfo.context.state.loaderData;
+  if (ssrInfo.context.isSpaMode) {
+    hydrationData = { loaderData };
+  } else {
     hydrationData = {
       ...ssrInfo.context.state,
-      loaderData: { ...ssrInfo.context.state.loaderData }
+      loaderData: { ...loaderData }
     };
     let initialMatches = matchRoutes(
       routes,
@@ -5424,11 +5584,13 @@ function createHydratedRouter() {
     dataStrategy: getSingleFetchDataStrategy(
       ssrInfo.manifest,
       ssrInfo.routeModules,
+      ssrInfo.context.ssr,
       () => router2
     ),
     patchRoutesOnNavigation: getPatchRoutesOnNavigationFunction(
       ssrInfo.manifest,
       ssrInfo.routeModules,
+      ssrInfo.context.ssr,
       ssrInfo.context.isSpaMode,
       ssrInfo.context.basename
     )
@@ -5476,6 +5638,7 @@ function HydratedRouter() {
     router,
     ssrInfo.manifest,
     ssrInfo.routeModules,
+    ssrInfo.context.ssr,
     ssrInfo.context.isSpaMode
   );
   return (
@@ -5489,6 +5652,7 @@ function HydratedRouter() {
           routeModules: ssrInfo.routeModules,
           future: ssrInfo.context.future,
           criticalCss,
+          ssr: ssrInfo.context.ssr,
           isSpaMode: ssrInfo.context.isSpaMode
         }
       },

package/dist/development/dom-export.mjs

@@ -1,5 +1,5 @@
 /**
- * react-router v7.1.5
+ * react-router v7.2.0-pre.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -25,7 +25,7 @@ import {
   matchRoutes,
   shouldHydrateRouteLoader,
   useFogOFWarDiscovery
-} from "./chunk-IR6S3I6Y.mjs";
+} from "./chunk-HLU4BUUT.mjs";
 
 // lib/dom-export/dom-router-provider.tsx
 import * as React from "react";
@@ -79,13 +79,17 @@ function createHydratedRouter() {
     ssrInfo.manifest.routes,
     ssrInfo.routeModules,
     ssrInfo.context.state,
+    ssrInfo.context.ssr,
     ssrInfo.context.isSpaMode
   );
   let hydrationData = void 0;
-  if (!ssrInfo.context.isSpaMode) {
+  let loaderData = ssrInfo.context.state.loaderData;
+  if (ssrInfo.context.isSpaMode) {
+    hydrationData = { loaderData };
+  } else {
     hydrationData = {
       ...ssrInfo.context.state,
-      loaderData: { ...ssrInfo.context.state.loaderData }
+      loaderData: { ...loaderData }
     };
     let initialMatches = matchRoutes(
       routes,
@@ -121,11 +125,13 @@ function createHydratedRouter() {
     dataStrategy: getSingleFetchDataStrategy(
       ssrInfo.manifest,
       ssrInfo.routeModules,
+      ssrInfo.context.ssr,
       () => router2
     ),
     patchRoutesOnNavigation: getPatchRoutesOnNavigationFunction(
       ssrInfo.manifest,
       ssrInfo.routeModules,
+      ssrInfo.context.ssr,
       ssrInfo.context.isSpaMode,
       ssrInfo.context.basename
     )
@@ -173,6 +179,7 @@ function HydratedRouter() {
     router,
     ssrInfo.manifest,
     ssrInfo.routeModules,
+    ssrInfo.context.ssr,
     ssrInfo.context.isSpaMode
   );
   return (
@@ -186,6 +193,7 @@ function HydratedRouter() {
           routeModules: ssrInfo.routeModules,
           future: ssrInfo.context.future,
           criticalCss,
+          ssr: ssrInfo.context.ssr,
           isSpaMode: ssrInfo.context.isSpaMode
         }
       },