react-router 7.4.1 → 7.5.0-pre.0

package/dist/production/index.d.ts

@@ -1,7 +1,7 @@
-import { a as RouteModules, b as Router, D as DataStrategyFunction, c as RouteManifest, S as ServerRouteModule, u as unstable_RouterContextProvider, L as LoaderFunctionArgs, A as ActionFunctionArgs, T as To, d as RelativeRoutingType, e as Location, f as Action, P as ParamParseKey, g as Path, h as PathPattern, i as PathMatch, N as NavigateOptions, j as Params$1, k as RouteObject, l as Navigation, m as RevalidationState, U as UIMatch, n as SerializeFrom, B as BlockerFunction, o as Blocker, p as StaticHandlerContext, q as StaticHandler, F as FutureConfig$1, C as CreateStaticHandlerOptions$1, I as InitialEntry, H as HydrationState, r as unstable_InitialContext, s as IndexRouteObject, t as LoaderFunction, v as ActionFunction, M as MetaFunction, w as LinksFunction, x as NonIndexRouteObject, E as Equal, y as RouterState } from './route-data-BL8ToWby.js';
-export { au as ClientActionFunction, av as ClientActionFunctionArgs, aw as ClientLoaderFunction, ax as ClientLoaderFunctionArgs, ao as DataRouteMatch, ap as DataRouteObject, W as DataStrategyFunctionArgs, X as DataStrategyMatch, Y as DataStrategyResult, _ as ErrorResponse, J as Fetcher, $ as FormEncType, a0 as FormMethod, G as GetScrollPositionFunction, z as GetScrollRestorationKeyFunction, a1 as HTMLFormMethod, ay as HeadersArgs, az as HeadersFunction, aD as HtmlLinkDescriptor, ae as IDLE_BLOCKER, ad as IDLE_FETCHER, ac as IDLE_NAVIGATION, a2 as LazyRouteFunction, aE as LinkDescriptor, aA as MetaArgs, aB as MetaDescriptor, K as NavigationStates, aq as Navigator, aC as PageLinkDescriptor, ar as PatchRoutesOnNavigationFunction, as as PatchRoutesOnNavigationFunctionArgs, a4 as PathParam, a5 as RedirectFunction, at as RouteMatch, V as RouterFetchOptions, R as RouterInit, Q as RouterNavigateOptions, O as RouterSubscriber, a7 as ShouldRevalidateFunction, a8 as ShouldRevalidateFunctionArgs, aK as UNSAFE_DataRouterContext, aL as UNSAFE_DataRouterStateContext, Z as UNSAFE_DataWithResponseInit, aJ as UNSAFE_ErrorResponseImpl, aM as UNSAFE_FetchersContext, aN as UNSAFE_LocationContext, aO as UNSAFE_NavigationContext, aP as UNSAFE_RouteContext, aQ as UNSAFE_ViewTransitionContext, aG as UNSAFE_createBrowserHistory, aI as UNSAFE_createRouter, aH as UNSAFE_invariant, aa as createPath, af as data, ag as generatePath, ah as isRouteErrorResponse, ai as matchPath, aj as matchRoutes, ab as parsePath, ak as redirect, al as redirectDocument, am as replace, an as resolvePath, a3 as unstable_MiddlewareFunction, a6 as unstable_RouterContext, aF as unstable_SerializesTo, a9 as unstable_createContext } from './route-data-BL8ToWby.js';
-import { A as AssetsManifest, a as Route, F as FutureConfig, E as EntryContext, C as CriticalCss } from './fog-of-war-BaM-ohjc.js';
-export { g as Await, b as AwaitProps, T as BrowserRouter, B as BrowserRouterProps, D as DOMRouterOpts, w as FetcherFormProps, G as FetcherSubmitFunction, a7 as FetcherSubmitOptions, J as FetcherWithComponents, Y as Form, x as FormProps, U as HashRouter, H as HashRouterProps, s as HistoryRouterProps, I as IndexRouteProps, L as LayoutRouteProps, V as Link, t as LinkProps, ae as Links, h as MemoryRouter, M as MemoryRouterOpts, c as MemoryRouterProps, ad as Meta, X as NavLink, u as NavLinkProps, v as NavLinkRenderProps, i as Navigate, N as NavigateProps, j as Outlet, O as OutletProps, a8 as ParamKeyValuePair, P as PathRouteProps, ag as PrefetchPageLinks, k as Route, d as RouteProps, l as Router, e as RouterProps, m as RouterProvider, R as RouterProviderProps, n as Routes, f as RoutesProps, af as Scripts, ah as ScriptsProps, Z as ScrollRestoration, S as ScrollRestorationProps, y as SetURLSearchParams, z as SubmitFunction, a9 as SubmitOptions, ab as SubmitTarget, aj as UNSAFE_FrameworkContext, am as UNSAFE_createClientRoutes, an as UNSAFE_createClientRoutesWithHMRRevalidationOptOut, ak as UNSAFE_getPatchRoutesOnNavigationFunction, ai as UNSAFE_mapRouteProperties, ao as UNSAFE_shouldHydrateRouteLoader, al as UNSAFE_useFogOFWarDiscovery, ap as UNSAFE_useScrollRestoration, aa as URLSearchParamsInit, K as createBrowserRouter, Q as createHashRouter, o as createMemoryRouter, p as createRoutesFromChildren, q as createRoutesFromElements, ac as createSearchParams, r as renderMatches, W as unstable_HistoryRouter, a5 as unstable_usePrompt, a4 as useBeforeUnload, a2 as useFetcher, a3 as useFetchers, a1 as useFormAction, _ as useLinkClickHandler, $ as useSearchParams, a0 as useSubmit, a6 as useViewTransitionState } from './fog-of-war-BaM-ohjc.js';
+import { a as RouteModules, b as Router, D as DataStrategyFunction, c as RouteManifest, S as ServerRouteModule, u as unstable_RouterContextProvider, L as LoaderFunctionArgs, A as ActionFunctionArgs, T as To, d as RelativeRoutingType, e as Location, f as Action, P as ParamParseKey, g as Path, h as PathPattern, i as PathMatch, N as NavigateOptions, j as Params$1, k as RouteObject, l as Navigation, m as RevalidationState, U as UIMatch, n as SerializeFrom, B as BlockerFunction, o as Blocker, p as StaticHandlerContext, q as StaticHandler, F as FutureConfig$1, C as CreateStaticHandlerOptions$1, I as InitialEntry, H as HydrationState, r as unstable_InitialContext, s as IndexRouteObject, t as LoaderFunction, v as ActionFunction, M as MetaFunction, w as LinksFunction, x as NonIndexRouteObject, E as Equal, y as RouterState } from './route-data-5OzAzQtT.js';
+export { au as ClientActionFunction, av as ClientActionFunctionArgs, aw as ClientLoaderFunction, ax as ClientLoaderFunctionArgs, ao as DataRouteMatch, ap as DataRouteObject, W as DataStrategyFunctionArgs, X as DataStrategyMatch, Y as DataStrategyResult, _ as ErrorResponse, J as Fetcher, $ as FormEncType, a0 as FormMethod, G as GetScrollPositionFunction, z as GetScrollRestorationKeyFunction, a1 as HTMLFormMethod, ay as HeadersArgs, az as HeadersFunction, aD as HtmlLinkDescriptor, ae as IDLE_BLOCKER, ad as IDLE_FETCHER, ac as IDLE_NAVIGATION, a2 as LazyRouteFunction, aE as LinkDescriptor, aA as MetaArgs, aB as MetaDescriptor, K as NavigationStates, aq as Navigator, aC as PageLinkDescriptor, ar as PatchRoutesOnNavigationFunction, as as PatchRoutesOnNavigationFunctionArgs, a4 as PathParam, a5 as RedirectFunction, at as RouteMatch, V as RouterFetchOptions, R as RouterInit, Q as RouterNavigateOptions, O as RouterSubscriber, a7 as ShouldRevalidateFunction, a8 as ShouldRevalidateFunctionArgs, aK as UNSAFE_DataRouterContext, aL as UNSAFE_DataRouterStateContext, Z as UNSAFE_DataWithResponseInit, aJ as UNSAFE_ErrorResponseImpl, aM as UNSAFE_FetchersContext, aN as UNSAFE_LocationContext, aO as UNSAFE_NavigationContext, aP as UNSAFE_RouteContext, aQ as UNSAFE_ViewTransitionContext, aG as UNSAFE_createBrowserHistory, aI as UNSAFE_createRouter, aH as UNSAFE_invariant, aa as createPath, af as data, ag as generatePath, ah as isRouteErrorResponse, ai as matchPath, aj as matchRoutes, ab as parsePath, ak as redirect, al as redirectDocument, am as replace, an as resolvePath, a3 as unstable_MiddlewareFunction, a6 as unstable_RouterContext, aF as unstable_SerializesTo, a9 as unstable_createContext } from './route-data-5OzAzQtT.js';
+import { A as AssetsManifest, a as Route, F as FutureConfig, E as EntryContext, C as CriticalCss } from './fog-of-war-oa9CGk10.js';
+export { g as Await, b as AwaitProps, T as BrowserRouter, B as BrowserRouterProps, D as DOMRouterOpts, w as FetcherFormProps, G as FetcherSubmitFunction, a7 as FetcherSubmitOptions, J as FetcherWithComponents, Y as Form, x as FormProps, U as HashRouter, H as HashRouterProps, s as HistoryRouterProps, I as IndexRouteProps, L as LayoutRouteProps, V as Link, t as LinkProps, ae as Links, h as MemoryRouter, M as MemoryRouterOpts, c as MemoryRouterProps, ad as Meta, X as NavLink, u as NavLinkProps, v as NavLinkRenderProps, i as Navigate, N as NavigateProps, j as Outlet, O as OutletProps, a8 as ParamKeyValuePair, P as PathRouteProps, ag as PrefetchPageLinks, k as Route, d as RouteProps, l as Router, e as RouterProps, m as RouterProvider, R as RouterProviderProps, n as Routes, f as RoutesProps, af as Scripts, ah as ScriptsProps, Z as ScrollRestoration, S as ScrollRestorationProps, y as SetURLSearchParams, z as SubmitFunction, a9 as SubmitOptions, ab as SubmitTarget, aj as UNSAFE_FrameworkContext, am as UNSAFE_createClientRoutes, an as UNSAFE_createClientRoutesWithHMRRevalidationOptOut, ak as UNSAFE_getPatchRoutesOnNavigationFunction, ai as UNSAFE_mapRouteProperties, ao as UNSAFE_shouldHydrateRouteLoader, al as UNSAFE_useFogOFWarDiscovery, ap as UNSAFE_useScrollRestoration, aa as URLSearchParamsInit, K as createBrowserRouter, Q as createHashRouter, o as createMemoryRouter, p as createRoutesFromChildren, q as createRoutesFromElements, ac as createSearchParams, r as renderMatches, W as unstable_HistoryRouter, a5 as unstable_usePrompt, a4 as useBeforeUnload, a2 as useFetcher, a3 as useFetchers, a1 as useFormAction, _ as useLinkClickHandler, $ as useSearchParams, a0 as useSubmit, a6 as useViewTransitionState } from './fog-of-war-oa9CGk10.js';
 import * as React from 'react';
 import { ReactElement } from 'react';
 import { ParseOptions, SerializeOptions } from 'cookie';

package/dist/production/index.js

@@ -1,5 +1,5 @@
 /**
- * react-router v7.4.1
+ * react-router v7.5.0-pre.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -531,6 +531,19 @@ var unstable_RouterContextProvider = class {
   }
 };
 _map = new WeakMap();
+var unsupportedLazyRouteObjectKeys = /* @__PURE__ */ new Set([
+  "lazy",
+  "caseSensitive",
+  "path",
+  "id",
+  "index",
+  "children"
+]);
+function isUnsupportedLazyRouteObjectKey(key) {
+  return unsupportedLazyRouteObjectKeys.has(
+    key
+  );
+}
 var unsupportedLazyRouteFunctionKeys = /* @__PURE__ */ new Set([
   "lazy",
   "caseSensitive",
@@ -538,9 +551,13 @@ var unsupportedLazyRouteFunctionKeys = /* @__PURE__ */ new Set([
   "id",
   "index",
   "unstable_middleware",
-  "unstable_lazyMiddleware",
   "children"
 ]);
+function isUnsupportedLazyRouteFunctionKey(key) {
+  return unsupportedLazyRouteFunctionKeys.has(
+    key
+  );
+}
 function isIndexRoute(route) {
   return route.index === true;
 }
@@ -2831,14 +2848,18 @@ function createStaticHandler(routes, opts) {
       return respond ? respond(staticContext) : staticContext;
     }
     if (respond && matches.some(
-      (m) => m.route.unstable_middleware || m.route.unstable_lazyMiddleware
+      (m) => m.route.unstable_middleware || typeof m.route.lazy === "object" && m.route.lazy.unstable_middleware
     )) {
       invariant(
         requestContext instanceof unstable_RouterContextProvider,
         "When using middleware in `staticHandler.query()`, any provided `requestContext` must be an instance of `unstable_RouterContextProvider`"
       );
       try {
-        await loadLazyMiddlewareForMatches(matches, manifest);
+        await loadLazyMiddlewareForMatches(
+          matches,
+          manifest,
+          mapRouteProperties2
+        );
         let renderedStaticContext;
         let response = await runMiddlewarePipeline(
           {
@@ -2955,13 +2976,13 @@ function createStaticHandler(routes, opts) {
       throw getInternalRouterError(404, { pathname: location.pathname });
     }
     if (respond && matches.some(
-      (m) => m.route.unstable_middleware || m.route.unstable_lazyMiddleware
+      (m) => m.route.unstable_middleware || typeof m.route.lazy === "object" && m.route.lazy.unstable_middleware
     )) {
       invariant(
         requestContext instanceof unstable_RouterContextProvider,
         "When using middleware in `staticHandler.queryRoute()`, any provided `requestContext` must be an instance of `unstable_RouterContextProvider`"
       );
-      await loadLazyMiddlewareForMatches(matches, manifest);
+      await loadLazyMiddlewareForMatches(matches, manifest, mapRouteProperties2);
       let response = await runMiddlewarePipeline(
         {
           request,
@@ -3679,79 +3700,139 @@ function isSameRoute(newRoute, existingRoute) {
     (aChild, i) => existingRoute.children?.some((bChild) => isSameRoute(aChild, bChild))
   );
 }
-var lazyRouteFunctionCache = /* @__PURE__ */ new WeakMap();
-async function loadLazyRouteModule(route, mapRouteProperties2, manifest) {
+var lazyRoutePropertyCache = /* @__PURE__ */ new WeakMap();
+var loadLazyRouteProperty = ({
+  key,
+  route,
+  manifest,
+  mapRouteProperties: mapRouteProperties2
+}) => {
   let routeToUpdate = manifest[route.id];
   invariant(routeToUpdate, "No route found in manifest");
-  if (!route.lazy) {
+  if (!routeToUpdate.lazy || typeof routeToUpdate.lazy !== "object") {
     return;
   }
-  let cachedPromise = lazyRouteFunctionCache.get(routeToUpdate);
-  if (cachedPromise) {
-    await cachedPromise;
+  let lazyFn = routeToUpdate.lazy[key];
+  if (!lazyFn) {
     return;
   }
-  let lazyRoutePromise = route.lazy().then((lazyRoute) => {
-    let routeUpdates = {};
-    for (let lazyRouteProperty in lazyRoute) {
-      let staticRouteValue = routeToUpdate[lazyRouteProperty];
-      let isPropertyStaticallyDefined = staticRouteValue !== void 0 && // This property isn't static since it should always be updated based
-      // on the route updates
-      lazyRouteProperty !== "hasErrorBoundary";
+  let cache = lazyRoutePropertyCache.get(routeToUpdate);
+  if (!cache) {
+    cache = {};
+    lazyRoutePropertyCache.set(routeToUpdate, cache);
+  }
+  let cachedPromise = cache[key];
+  if (cachedPromise) {
+    return cachedPromise;
+  }
+  let propertyPromise = (async () => {
+    let isUnsupported = isUnsupportedLazyRouteObjectKey(key);
+    let staticRouteValue = routeToUpdate[key];
+    let isStaticallyDefined = staticRouteValue !== void 0 && key !== "hasErrorBoundary";
+    if (isUnsupported) {
       warning(
-        !isPropertyStaticallyDefined,
-        `Route "${routeToUpdate.id}" has a static property "${lazyRouteProperty}" defined but its lazy function is also returning a value for this property. The lazy route property "${lazyRouteProperty}" will be ignored.`
+        !isUnsupported,
+        "Route property " + key + " is not a supported lazy route property. This property will be ignored."
       );
+      cache[key] = Promise.resolve();
+    } else if (isStaticallyDefined) {
       warning(
-        !unsupportedLazyRouteFunctionKeys.has(
-          lazyRouteProperty
-        ),
-        "Route property " + lazyRouteProperty + " is not a supported property to be returned from a lazy route function. This property will be ignored."
+        false,
+        `Route "${routeToUpdate.id}" has a static property "${key}" defined. The lazy property will be ignored.`
       );
-      if (!isPropertyStaticallyDefined && !unsupportedLazyRouteFunctionKeys.has(
-        lazyRouteProperty
-      )) {
-        routeUpdates[lazyRouteProperty] = lazyRoute[lazyRouteProperty];
+    } else {
+      let value = await lazyFn();
+      if (value != null) {
+        Object.assign(routeToUpdate, { [key]: value });
+        Object.assign(routeToUpdate, mapRouteProperties2(routeToUpdate));
       }
     }
-    Object.assign(routeToUpdate, routeUpdates);
-    Object.assign(routeToUpdate, {
-      // To keep things framework agnostic, we use the provided `mapRouteProperties`
-      // function to set the framework-aware properties (`element`/`hasErrorBoundary`)
-      // since the logic will differ between frameworks.
-      ...mapRouteProperties2(routeToUpdate),
-      lazy: void 0
-    });
-  });
-  lazyRouteFunctionCache.set(routeToUpdate, lazyRoutePromise);
-  await lazyRoutePromise;
-}
-async function loadLazyMiddleware(route, manifest) {
-  if (!route.unstable_lazyMiddleware) {
-    return;
-  }
+    if (typeof routeToUpdate.lazy === "object") {
+      routeToUpdate.lazy[key] = void 0;
+      if (Object.values(routeToUpdate.lazy).every((value) => value === void 0)) {
+        routeToUpdate.lazy = void 0;
+      }
+    }
+  })();
+  cache[key] = propertyPromise;
+  return propertyPromise;
+};
+var lazyRouteFunctionCache = /* @__PURE__ */ new WeakMap();
+async function loadLazyRoute(route, manifest, mapRouteProperties2) {
   let routeToUpdate = manifest[route.id];
   invariant(routeToUpdate, "No route found in manifest");
-  if (routeToUpdate.unstable_middleware) {
-    warning(
-      false,
-      `Route "${routeToUpdate.id}" has a static property "unstable_middleware" defined. The "unstable_lazyMiddleware" function will be ignored.`
-    );
-  } else {
-    let middleware = await route.unstable_lazyMiddleware();
-    if (!route.unstable_lazyMiddleware) {
+  if (!route.lazy) {
+    return;
+  }
+  if (typeof route.lazy === "function") {
+    let cachedPromise = lazyRouteFunctionCache.get(routeToUpdate);
+    if (cachedPromise) {
+      await cachedPromise;
       return;
     }
-    if (!routeToUpdate.unstable_middleware) {
-      routeToUpdate.unstable_middleware = middleware;
-    }
+    let lazyRoutePromise = route.lazy().then((lazyRoute) => {
+      let routeUpdates = {};
+      for (let lazyRouteProperty in lazyRoute) {
+        let lazyValue = lazyRoute[lazyRouteProperty];
+        if (lazyValue === void 0) {
+          continue;
+        }
+        let isUnsupported = isUnsupportedLazyRouteFunctionKey(lazyRouteProperty);
+        let staticRouteValue = routeToUpdate[lazyRouteProperty];
+        let isStaticallyDefined = staticRouteValue !== void 0 && // This property isn't static since it should always be updated based
+        // on the route updates
+        lazyRouteProperty !== "hasErrorBoundary";
+        if (isUnsupported) {
+          warning(
+            !isUnsupported,
+            "Route property " + lazyRouteProperty + " is not a supported property to be returned from a lazy route function. This property will be ignored."
+          );
+        } else if (isStaticallyDefined) {
+          warning(
+            !isStaticallyDefined,
+            `Route "${routeToUpdate.id}" has a static property "${lazyRouteProperty}" defined but its lazy function is also returning a value for this property. The lazy route property "${lazyRouteProperty}" will be ignored.`
+          );
+        } else {
+          routeUpdates[lazyRouteProperty] = lazyValue;
+        }
+      }
+      Object.assign(routeToUpdate, routeUpdates);
+      Object.assign(routeToUpdate, {
+        // To keep things framework agnostic, we use the provided `mapRouteProperties`
+        // function to set the framework-aware properties (`element`/`hasErrorBoundary`)
+        // since the logic will differ between frameworks.
+        ...mapRouteProperties2(routeToUpdate),
+        lazy: void 0
+      });
+    });
+    lazyRouteFunctionCache.set(routeToUpdate, lazyRoutePromise);
+    await lazyRoutePromise;
+    return;
   }
-  routeToUpdate.unstable_lazyMiddleware = void 0;
+  let lazyKeys = Object.keys(route.lazy);
+  await Promise.all(
+    lazyKeys.map(
+      (key) => loadLazyRouteProperty({
+        key,
+        route,
+        manifest,
+        mapRouteProperties: mapRouteProperties2
+      })
+    )
+  );
 }
-function loadLazyMiddlewareForMatches(matches, manifest) {
-  let promises = matches.map(
-    (m) => m.route.unstable_lazyMiddleware ? loadLazyMiddleware(m.route, manifest) : void 0
-  ).filter(Boolean);
+function loadLazyMiddlewareForMatches(matches, manifest, mapRouteProperties2) {
+  let promises = matches.map(({ route }) => {
+    if (typeof route.lazy !== "object" || !route.lazy.unstable_middleware) {
+      return void 0;
+    }
+    return loadLazyRouteProperty({
+      key: "unstable_middleware",
+      route,
+      manifest,
+      mapRouteProperties: mapRouteProperties2
+    });
+  }).filter((p) => p != null);
   return promises.length > 0 ? Promise.all(promises) : void 0;
 }
 async function defaultDataStrategy(args) {
@@ -3869,15 +3950,19 @@ async function callRouteMiddleware(args, middlewares, propagateResult, middlewar
   }
 }
 async function callDataStrategyImpl(dataStrategyImpl, type, request, matchesToLoad, matches, fetcherKey, manifest, mapRouteProperties2, scopedContext) {
-  let loadMiddlewarePromise = loadLazyMiddlewareForMatches(matches, manifest);
-  let loadRouteDefinitionsPromises = matches.map(
-    (m) => m.route.lazy ? loadLazyRouteModule(m.route, mapRouteProperties2, manifest) : void 0
+  let loadMiddlewarePromise = loadLazyMiddlewareForMatches(
+    matches,
+    manifest,
+    mapRouteProperties2
+  );
+  let loadLazyRoutePromises = matches.map(
+    (m) => m.route.lazy ? loadLazyRoute(m.route, manifest, mapRouteProperties2) : void 0
   );
   if (loadMiddlewarePromise) {
     await loadMiddlewarePromise;
   }
   let dsMatches = matches.map((match, i) => {
-    let loadRoutePromise = loadRouteDefinitionsPromises[i];
+    let loadRoutePromise = loadLazyRoutePromises[i];
     let shouldLoad = matchesToLoad.some((m) => m.route.id === match.route.id);
     let resolve = async (handlerOverride) => {
       if (handlerOverride && request.method === "GET" && (match.route.lazy || match.route.loader)) {
@@ -3906,7 +3991,7 @@ async function callDataStrategyImpl(dataStrategyImpl, type, request, matchesToLo
     context: scopedContext
   });
   try {
-    await Promise.all(loadRouteDefinitionsPromises);
+    await Promise.all(loadLazyRoutePromises);
   } catch (e) {
   }
   return results;
@@ -6894,22 +6979,6 @@ function createClientRoutes(manifest, routeModulesCache, initialState, ssr, isSp
         dataRoute.loader = (_, singleFetch) => prefetchStylesAndCallHandler(() => {
           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);
-              return fetchServerLoader(singleFetch);
-            }
-          });
-        };
       }
       if (!route.hasClientAction) {
         dataRoute.action = (_, singleFetch) => prefetchStylesAndCallHandler(() => {
@@ -6918,86 +6987,84 @@ function createClientRoutes(manifest, routeModulesCache, initialState, ssr, isSp
           }
           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
+      }
+      let lazyRoutePromise;
+      async function getLazyRoute() {
+        if (lazyRoutePromise) {
+          return await lazyRoutePromise;
+        }
+        lazyRoutePromise = (async () => {
+          if (route.clientLoaderModule || route.clientActionModule) {
+            await new Promise((resolve) => setTimeout(resolve, 0));
+          }
+          let routeModulePromise = loadRouteModuleWithBlockingLinks(
+            route,
+            routeModulesCache
           );
-          return clientAction({
-            ...args,
-            async serverAction() {
-              preventInvalidServerHandlerCall("action", route);
-              return fetchServerAction(singleFetch);
-            }
-          });
-        };
+          prefetchRouteModuleChunks(route);
+          return await routeModulePromise;
+        })();
+        return await lazyRoutePromise;
       }
-      if (route.hasClientMiddleware) {
-        dataRoute.unstable_lazyMiddleware = async () => {
-          invariant2(route);
-          let clientMiddlewareModule = await import(
+      dataRoute.lazy = {
+        loader: route.hasClientLoader ? async () => {
+          let { clientLoader } = route.clientLoaderModule ? await import(
             /* @vite-ignore */
             /* webpackIgnore: true */
-            route.clientMiddlewareModule || route.module
-          );
-          invariant2(
-            clientMiddlewareModule?.unstable_clientMiddleware,
-            "No `unstable_clientMiddleware` export in chunk"
-          );
-          return clientMiddlewareModule.unstable_clientMiddleware;
-        };
-      }
-      dataRoute.lazy = async () => {
-        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;
-          lazyRoute.loader = (args, singleFetch) => clientLoader({
+            route.clientLoaderModule
+          ) : await getLazyRoute();
+          invariant2(clientLoader, "No `clientLoader` export found");
+          return (args, singleFetch) => clientLoader({
             ...args,
             async serverLoader() {
               preventInvalidServerHandlerCall("loader", route);
               return fetchServerLoader(singleFetch);
             }
           });
-        }
-        if (mod.clientAction) {
-          let clientAction = mod.clientAction;
-          lazyRoute.action = (args, singleFetch) => clientAction({
+        } : void 0,
+        action: route.hasClientAction ? async () => {
+          let clientActionPromise = route.clientActionModule ? import(
+            /* @vite-ignore */
+            /* webpackIgnore: true */
+            route.clientActionModule
+          ) : getLazyRoute();
+          prefetchRouteModuleChunks(route);
+          let { clientAction } = await clientActionPromise;
+          invariant2(clientAction, "No `clientAction` export found");
+          return (args, singleFetch) => clientAction({
             ...args,
             async serverAction() {
               preventInvalidServerHandlerCall("action", route);
               return fetchServerAction(singleFetch);
             }
           });
-        }
-        return {
-          ...lazyRoute.loader ? { loader: lazyRoute.loader } : {},
-          ...lazyRoute.action ? { action: lazyRoute.action } : {},
-          hasErrorBoundary: lazyRoute.hasErrorBoundary,
-          shouldRevalidate: getShouldRevalidateFunction(
+        } : void 0,
+        unstable_middleware: route.hasClientMiddleware ? async () => {
+          let { unstable_clientMiddleware } = route.clientMiddlewareModule ? await import(
+            /* @vite-ignore */
+            /* webpackIgnore: true */
+            route.clientMiddlewareModule
+          ) : await getLazyRoute();
+          invariant2(
+            unstable_clientMiddleware,
+            "No `unstable_clientMiddleware` export found"
+          );
+          return unstable_clientMiddleware;
+        } : void 0,
+        shouldRevalidate: async () => {
+          let lazyRoute = await getLazyRoute();
+          return getShouldRevalidateFunction(
             lazyRoute,
             route,
             ssr,
             needsRevalidation
-          ),
-          handle: lazyRoute.handle,
-          // No need to wrap these in layout since the root route is never
-          // loaded via route.lazy()
-          Component: lazyRoute.Component,
-          ErrorBoundary: lazyRoute.ErrorBoundary
-        };
+          );
+        },
+        handle: async () => (await getLazyRoute()).handle,
+        // No need to wrap these in layout since the root route is never
+        // loaded via route.lazy()
+        Component: async () => (await getLazyRoute()).Component,
+        ErrorBoundary: route.hasErrorBoundary ? async () => (await getLazyRoute()).ErrorBoundary : void 0
       };
     }
     let children = createClientRoutes(
@@ -7085,7 +7152,7 @@ var URL_LIMIT = 7680;
 function isFogOfWarEnabled(ssr) {
   return ssr === true;
 }
-function getPartialManifest(manifest, router) {
+function getPartialManifest({ sri, ...manifest }, router) {
   let routeIds = new Set(router.state.matches.map((m) => m.route.id));
   let segments = router.state.location.pathname.split("/").filter(Boolean);
   let paths = ["/"];
@@ -7106,7 +7173,8 @@ function getPartialManifest(manifest, router) {
   );
   return {
     ...manifest,
-    routes: initialRoutes
+    routes: initialRoutes,
+    sri: sri ? true : void 0
   };
 }
 function getPatchRoutesOnNavigationFunction(manifest, routeModules, ssr, isSpaMode, basename) {
@@ -7686,32 +7754,53 @@ import(${JSON.stringify(manifest.entry.module)});`;
       }
     ));
   }, []);
-  let preloads = isHydrated ? [] : manifest.entry.imports.concat(
-    getModuleLinkHrefs(matches, manifest, {
-      includeHydrateFallback: true
-    })
+  let preloads = isHydrated ? [] : dedupe(
+    manifest.entry.imports.concat(
+      getModuleLinkHrefs(matches, manifest, {
+        includeHydrateFallback: true
+      })
+    )
   );
-  return isHydrated ? null : /* @__PURE__ */ React9.createElement(React9.Fragment, null, !enableFogOfWar ? /* @__PURE__ */ React9.createElement(
+  let sri = typeof manifest.sri === "object" ? manifest.sri : {};
+  return isHydrated ? null : /* @__PURE__ */ React9.createElement(React9.Fragment, null, typeof manifest.sri === "object" ? /* @__PURE__ */ React9.createElement(
+    "script",
+    {
+      "rr-importmap": "",
+      type: "importmap",
+      suppressHydrationWarning: true,
+      dangerouslySetInnerHTML: {
+        __html: JSON.stringify({
+          integrity: sri
+        })
+      }
+    }
+  ) : null, !enableFogOfWar ? /* @__PURE__ */ React9.createElement(
     "link",
     {
       rel: "modulepreload",
       href: manifest.url,
-      crossOrigin: props.crossOrigin
+      crossOrigin: props.crossOrigin,
+      integrity: sri[manifest.url],
+      suppressHydrationWarning: true
     }
   ) : null, /* @__PURE__ */ React9.createElement(
     "link",
     {
       rel: "modulepreload",
       href: manifest.entry.module,
-      crossOrigin: props.crossOrigin
+      crossOrigin: props.crossOrigin,
+      integrity: sri[manifest.entry.module],
+      suppressHydrationWarning: true
     }
-  ), dedupe(preloads).map((path) => /* @__PURE__ */ React9.createElement(
+  ), preloads.map((path) => /* @__PURE__ */ React9.createElement(
     "link",
     {
       key: path,
       rel: "modulepreload",
       href: path,
-      crossOrigin: props.crossOrigin
+      crossOrigin: props.crossOrigin,
+      integrity: sri[path],
+      suppressHydrationWarning: true
     }
   )), initialScripts);
 }
@@ -7734,7 +7823,7 @@ function mergeRefs(...refs) {
 var isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined";
 try {
   if (isBrowser) {
-    window.__reactRouterVersion = "7.4.1";
+    window.__reactRouterVersion = "7.5.0-pre.0";
   }
 } catch (e) {
 }
@@ -8889,6 +8978,7 @@ function createRoutesStub(routes, unstable_getContext) {
     if (routerRef.current == null) {
       remixContextRef.current = {
         future: {
+          unstable_subResourceIntegrity: future?.unstable_subResourceIntegrity === true,
           unstable_middleware: future?.unstable_middleware === true
         },
         manifest: {

package/dist/production/index.mjs

@@ -1,5 +1,5 @@
 /**
- * react-router v7.4.1
+ * react-router v7.5.0-pre.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -123,7 +123,7 @@ import {
   useSearchParams,
   useSubmit,
   useViewTransitionState
-} from "./chunk-T6D7EGPT.mjs";
+} from "./chunk-RSOGH2WR.mjs";
 export {
   Await,
   BrowserRouter,

package/dist/production/lib/types/route-module.d.mts

@@ -1,4 +1,4 @@
-import { aE as LinkDescriptor, aB as MetaDescriptor, aT as ServerDataFrom, aU as ClientDataFrom, aV as Func, aW as unstable_MiddlewareNextFunction, E as Equal, u as unstable_RouterContextProvider, aX as Pretty } from '../../route-data-BL8ToWby.mjs';
+import { aE as LinkDescriptor, aB as MetaDescriptor, aT as ServerDataFrom, aU as ClientDataFrom, aV as Func, aW as unstable_MiddlewareNextFunction, E as Equal, u as unstable_RouterContextProvider, aX as Pretty } from '../../route-data-5OzAzQtT.mjs';
 import { M as MiddlewareEnabled, A as AppLoadContext } from '../../future-ldDp5FKH.mjs';
 import 'react';
 

package/dist/production/lib/types/route-module.d.ts

@@ -1,4 +1,4 @@
-import { aE as LinkDescriptor, aB as MetaDescriptor, aT as ServerDataFrom, aU as ClientDataFrom, aV as Func, aW as unstable_MiddlewareNextFunction, E as Equal, u as unstable_RouterContextProvider, aX as Pretty } from '../../route-data-BL8ToWby.js';
+import { aE as LinkDescriptor, aB as MetaDescriptor, aT as ServerDataFrom, aU as ClientDataFrom, aV as Func, aW as unstable_MiddlewareNextFunction, E as Equal, u as unstable_RouterContextProvider, aX as Pretty } from '../../route-data-5OzAzQtT.js';
 import { M as MiddlewareEnabled, A as AppLoadContext } from '../../future-ldDp5FKH.js';
 import 'react';
 

package/dist/production/lib/types/route-module.js

@@ -1,5 +1,5 @@
 /**
- * react-router v7.4.1
+ * react-router v7.5.0-pre.0
  *
  * Copyright (c) Remix Software Inc.
  *

package/dist/production/lib/types/route-module.mjs

@@ -1,5 +1,5 @@
 /**
- * react-router v7.4.1
+ * react-router v7.5.0-pre.0
  *
  * Copyright (c) Remix Software Inc.
  *