react-router 7.5.0-pre.0 → 7.5.0

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # `react-router`
 
-## 7.5.0-pre.0
+## 7.5.0
 
 ### Minor Changes
 

package/dist/development/{chunk-YTH545ZN.mjs → chunk-KNED5TY2.mjs}

@@ -1,5 +1,5 @@
 /**
- * react-router v7.5.0-pre.0
+ * react-router v7.5.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -3610,19 +3610,29 @@ var loadLazyRouteProperty = ({
   return propertyPromise;
 };
 var lazyRouteFunctionCache = /* @__PURE__ */ new WeakMap();
-async function loadLazyRoute(route, manifest, mapRouteProperties2) {
+function loadLazyRoute(route, type, manifest, mapRouteProperties2) {
   let routeToUpdate = manifest[route.id];
   invariant(routeToUpdate, "No route found in manifest");
   if (!route.lazy) {
-    return;
+    return {
+      lazyRoutePromise: void 0,
+      lazyHandlerPromise: void 0
+    };
   }
   if (typeof route.lazy === "function") {
     let cachedPromise = lazyRouteFunctionCache.get(routeToUpdate);
     if (cachedPromise) {
-      await cachedPromise;
-      return;
+      return {
+        lazyRoutePromise: cachedPromise,
+        lazyHandlerPromise: cachedPromise
+      };
     }
-    let lazyRoutePromise = route.lazy().then((lazyRoute) => {
+    let lazyRoutePromise2 = (async () => {
+      invariant(
+        typeof route.lazy === "function",
+        "No lazy route function found"
+      );
+      let lazyRoute = await route.lazy();
       let routeUpdates = {};
       for (let lazyRouteProperty in lazyRoute) {
         let lazyValue = lazyRoute[lazyRouteProperty];
@@ -3656,22 +3666,39 @@ async function loadLazyRoute(route, manifest, mapRouteProperties2) {
         ...mapRouteProperties2(routeToUpdate),
         lazy: void 0
       });
-    });
-    lazyRouteFunctionCache.set(routeToUpdate, lazyRoutePromise);
-    await lazyRoutePromise;
-    return;
+    })();
+    lazyRouteFunctionCache.set(routeToUpdate, lazyRoutePromise2);
+    return {
+      lazyRoutePromise: lazyRoutePromise2,
+      lazyHandlerPromise: lazyRoutePromise2
+    };
   }
   let lazyKeys = Object.keys(route.lazy);
-  await Promise.all(
-    lazyKeys.map(
-      (key) => loadLazyRouteProperty({
-        key,
-        route,
-        manifest,
-        mapRouteProperties: mapRouteProperties2
-      })
-    )
-  );
+  let lazyPropertyPromises = [];
+  let lazyHandlerPromise = void 0;
+  for (let key of lazyKeys) {
+    let promise = loadLazyRouteProperty({
+      key,
+      route,
+      manifest,
+      mapRouteProperties: mapRouteProperties2
+    });
+    if (promise) {
+      lazyPropertyPromises.push(promise);
+      if (key === type) {
+        lazyHandlerPromise = promise;
+      }
+    }
+  }
+  let lazyRoutePromise = Promise.all(lazyPropertyPromises).then(() => {
+  });
+  return {
+    lazyRoutePromise,
+    lazyHandlerPromise
+  };
+}
+function isNonNullable(value) {
+  return value !== void 0;
 }
 function loadLazyMiddlewareForMatches(matches, manifest, mapRouteProperties2) {
   let promises = matches.map(({ route }) => {
@@ -3684,7 +3711,7 @@ function loadLazyMiddlewareForMatches(matches, manifest, mapRouteProperties2) {
       manifest,
       mapRouteProperties: mapRouteProperties2
     });
-  }).filter((p) => p != null);
+  }).filter(isNonNullable);
   return promises.length > 0 ? Promise.all(promises) : void 0;
 }
 async function defaultDataStrategy(args) {
@@ -3807,27 +3834,28 @@ async function callDataStrategyImpl(dataStrategyImpl, type, request, matchesToLo
     manifest,
     mapRouteProperties2
   );
-  let loadLazyRoutePromises = matches.map(
-    (m) => m.route.lazy ? loadLazyRoute(m.route, manifest, mapRouteProperties2) : void 0
+  let lazyRoutePromises = matches.map(
+    (m) => loadLazyRoute(m.route, type, manifest, mapRouteProperties2)
   );
   if (loadMiddlewarePromise) {
     await loadMiddlewarePromise;
   }
   let dsMatches = matches.map((match, i) => {
-    let loadRoutePromise = loadLazyRoutePromises[i];
+    let { lazyRoutePromise, lazyHandlerPromise } = lazyRoutePromises[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)) {
         shouldLoad = true;
       }
-      return shouldLoad ? callLoaderOrAction(
+      return shouldLoad ? callLoaderOrAction({
         type,
         request,
         match,
-        loadRoutePromise,
+        lazyHandlerPromise,
+        lazyRoutePromise,
         handlerOverride,
         scopedContext
-      ) : Promise.resolve({ type: "data" /* data */, result: void 0 });
+      }) : Promise.resolve({ type: "data" /* data */, result: void 0 });
     };
     return {
       ...match,
@@ -3842,13 +3870,24 @@ async function callDataStrategyImpl(dataStrategyImpl, type, request, matchesToLo
     fetcherKey,
     context: scopedContext
   });
+  let allLazyRoutePromises = lazyRoutePromises.flatMap(
+    (promiseMap) => Object.values(promiseMap).filter(isNonNullable)
+  );
   try {
-    await Promise.all(loadLazyRoutePromises);
+    await Promise.all(allLazyRoutePromises);
   } catch (e) {
   }
   return results;
 }
-async function callLoaderOrAction(type, request, match, loadRoutePromise, handlerOverride, scopedContext) {
+async function callLoaderOrAction({
+  type,
+  request,
+  match,
+  lazyHandlerPromise,
+  lazyRoutePromise,
+  handlerOverride,
+  scopedContext
+}) {
   let result;
   let onReject;
   let runHandler = (handler) => {
@@ -3885,7 +3924,7 @@ async function callLoaderOrAction(type, request, match, loadRoutePromise, handle
   };
   try {
     let handler = match.route[type];
-    if (loadRoutePromise) {
+    if (lazyHandlerPromise || lazyRoutePromise) {
       if (handler) {
         let handlerError;
         let [value] = await Promise.all([
@@ -3895,17 +3934,19 @@ async function callLoaderOrAction(type, request, match, loadRoutePromise, handle
           runHandler(handler).catch((e) => {
             handlerError = e;
           }),
-          loadRoutePromise
+          // Ensure all lazy route promises are resolved before continuing
+          lazyHandlerPromise,
+          lazyRoutePromise
         ]);
         if (handlerError !== void 0) {
           throw handlerError;
         }
         result = value;
       } else {
-        await loadRoutePromise;
+        await lazyHandlerPromise;
         handler = match.route[type];
         if (handler) {
-          result = await runHandler(handler);
+          [result] = await Promise.all([runHandler(handler), lazyRoutePromise]);
         } else if (type === "action") {
           let url = new URL(request.url);
           let pathname = url.pathname + url.search;
@@ -7675,7 +7716,7 @@ function mergeRefs(...refs) {
 var isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined";
 try {
   if (isBrowser) {
-    window.__reactRouterVersion = "7.5.0-pre.0";
+    window.__reactRouterVersion = "7.5.0";
   }
 } catch (e) {
 }

package/dist/development/dom-export.js

@@ -1,5 +1,5 @@
 /**
- * react-router v7.5.0-pre.0
+ * react-router v7.5.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -2898,19 +2898,29 @@ var loadLazyRouteProperty = ({
   return propertyPromise;
 };
 var lazyRouteFunctionCache = /* @__PURE__ */ new WeakMap();
-async function loadLazyRoute(route, manifest, mapRouteProperties2) {
+function loadLazyRoute(route, type, manifest, mapRouteProperties2) {
   let routeToUpdate = manifest[route.id];
   invariant(routeToUpdate, "No route found in manifest");
   if (!route.lazy) {
-    return;
+    return {
+      lazyRoutePromise: void 0,
+      lazyHandlerPromise: void 0
+    };
   }
   if (typeof route.lazy === "function") {
     let cachedPromise = lazyRouteFunctionCache.get(routeToUpdate);
     if (cachedPromise) {
-      await cachedPromise;
-      return;
+      return {
+        lazyRoutePromise: cachedPromise,
+        lazyHandlerPromise: cachedPromise
+      };
     }
-    let lazyRoutePromise = route.lazy().then((lazyRoute) => {
+    let lazyRoutePromise2 = (async () => {
+      invariant(
+        typeof route.lazy === "function",
+        "No lazy route function found"
+      );
+      let lazyRoute = await route.lazy();
       let routeUpdates = {};
       for (let lazyRouteProperty in lazyRoute) {
         let lazyValue = lazyRoute[lazyRouteProperty];
@@ -2944,22 +2954,39 @@ async function loadLazyRoute(route, manifest, mapRouteProperties2) {
         ...mapRouteProperties2(routeToUpdate),
         lazy: void 0
       });
-    });
-    lazyRouteFunctionCache.set(routeToUpdate, lazyRoutePromise);
-    await lazyRoutePromise;
-    return;
+    })();
+    lazyRouteFunctionCache.set(routeToUpdate, lazyRoutePromise2);
+    return {
+      lazyRoutePromise: lazyRoutePromise2,
+      lazyHandlerPromise: lazyRoutePromise2
+    };
   }
   let lazyKeys = Object.keys(route.lazy);
-  await Promise.all(
-    lazyKeys.map(
-      (key) => loadLazyRouteProperty({
-        key,
-        route,
-        manifest,
-        mapRouteProperties: mapRouteProperties2
-      })
-    )
-  );
+  let lazyPropertyPromises = [];
+  let lazyHandlerPromise = void 0;
+  for (let key of lazyKeys) {
+    let promise = loadLazyRouteProperty({
+      key,
+      route,
+      manifest,
+      mapRouteProperties: mapRouteProperties2
+    });
+    if (promise) {
+      lazyPropertyPromises.push(promise);
+      if (key === type) {
+        lazyHandlerPromise = promise;
+      }
+    }
+  }
+  let lazyRoutePromise = Promise.all(lazyPropertyPromises).then(() => {
+  });
+  return {
+    lazyRoutePromise,
+    lazyHandlerPromise
+  };
+}
+function isNonNullable(value) {
+  return value !== void 0;
 }
 function loadLazyMiddlewareForMatches(matches, manifest, mapRouteProperties2) {
   let promises = matches.map(({ route }) => {
@@ -2972,7 +2999,7 @@ function loadLazyMiddlewareForMatches(matches, manifest, mapRouteProperties2) {
       manifest,
       mapRouteProperties: mapRouteProperties2
     });
-  }).filter((p) => p != null);
+  }).filter(isNonNullable);
   return promises.length > 0 ? Promise.all(promises) : void 0;
 }
 async function defaultDataStrategy(args) {
@@ -3095,27 +3122,28 @@ async function callDataStrategyImpl(dataStrategyImpl, type, request, matchesToLo
     manifest,
     mapRouteProperties2
   );
-  let loadLazyRoutePromises = matches.map(
-    (m) => m.route.lazy ? loadLazyRoute(m.route, manifest, mapRouteProperties2) : void 0
+  let lazyRoutePromises = matches.map(
+    (m) => loadLazyRoute(m.route, type, manifest, mapRouteProperties2)
   );
   if (loadMiddlewarePromise) {
     await loadMiddlewarePromise;
   }
   let dsMatches = matches.map((match, i) => {
-    let loadRoutePromise = loadLazyRoutePromises[i];
+    let { lazyRoutePromise, lazyHandlerPromise } = lazyRoutePromises[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)) {
         shouldLoad = true;
       }
-      return shouldLoad ? callLoaderOrAction(
+      return shouldLoad ? callLoaderOrAction({
         type,
         request,
         match,
-        loadRoutePromise,
+        lazyHandlerPromise,
+        lazyRoutePromise,
         handlerOverride,
         scopedContext
-      ) : Promise.resolve({ type: "data" /* data */, result: void 0 });
+      }) : Promise.resolve({ type: "data" /* data */, result: void 0 });
     };
     return {
       ...match,
@@ -3130,13 +3158,24 @@ async function callDataStrategyImpl(dataStrategyImpl, type, request, matchesToLo
     fetcherKey,
     context: scopedContext
   });
+  let allLazyRoutePromises = lazyRoutePromises.flatMap(
+    (promiseMap) => Object.values(promiseMap).filter(isNonNullable)
+  );
   try {
-    await Promise.all(loadLazyRoutePromises);
+    await Promise.all(allLazyRoutePromises);
   } catch (e) {
   }
   return results;
 }
-async function callLoaderOrAction(type, request, match, loadRoutePromise, handlerOverride, scopedContext) {
+async function callLoaderOrAction({
+  type,
+  request,
+  match,
+  lazyHandlerPromise,
+  lazyRoutePromise,
+  handlerOverride,
+  scopedContext
+}) {
   let result;
   let onReject;
   let runHandler = (handler) => {
@@ -3173,7 +3212,7 @@ async function callLoaderOrAction(type, request, match, loadRoutePromise, handle
   };
   try {
     let handler = match.route[type];
-    if (loadRoutePromise) {
+    if (lazyHandlerPromise || lazyRoutePromise) {
       if (handler) {
         let handlerError;
         let [value] = await Promise.all([
@@ -3183,17 +3222,19 @@ async function callLoaderOrAction(type, request, match, loadRoutePromise, handle
           runHandler(handler).catch((e) => {
             handlerError = e;
           }),
-          loadRoutePromise
+          // Ensure all lazy route promises are resolved before continuing
+          lazyHandlerPromise,
+          lazyRoutePromise
         ]);
         if (handlerError !== void 0) {
           throw handlerError;
         }
         result = value;
       } else {
-        await loadRoutePromise;
+        await lazyHandlerPromise;
         handler = match.route[type];
         if (handler) {
-          result = await runHandler(handler);
+          [result] = await Promise.all([runHandler(handler), lazyRoutePromise]);
         } else if (type === "action") {
           let url = new URL(request.url);
           let pathname = url.pathname + url.search;

package/dist/development/dom-export.mjs

@@ -1,5 +1,5 @@
 /**
- * react-router v7.5.0-pre.0
+ * react-router v7.5.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -25,7 +25,7 @@ import {
   matchRoutes,
   shouldHydrateRouteLoader,
   useFogOFWarDiscovery
-} from "./chunk-YTH545ZN.mjs";
+} from "./chunk-KNED5TY2.mjs";
 
 // lib/dom-export/dom-router-provider.tsx
 import * as React from "react";

package/dist/development/index.js

@@ -1,5 +1,5 @@
 /**
- * react-router v7.5.0-pre.0
+ * react-router v7.5.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -3758,19 +3758,29 @@ var loadLazyRouteProperty = ({
   return propertyPromise;
 };
 var lazyRouteFunctionCache = /* @__PURE__ */ new WeakMap();
-async function loadLazyRoute(route, manifest, mapRouteProperties2) {
+function loadLazyRoute(route, type, manifest, mapRouteProperties2) {
   let routeToUpdate = manifest[route.id];
   invariant(routeToUpdate, "No route found in manifest");
   if (!route.lazy) {
-    return;
+    return {
+      lazyRoutePromise: void 0,
+      lazyHandlerPromise: void 0
+    };
   }
   if (typeof route.lazy === "function") {
     let cachedPromise = lazyRouteFunctionCache.get(routeToUpdate);
     if (cachedPromise) {
-      await cachedPromise;
-      return;
+      return {
+        lazyRoutePromise: cachedPromise,
+        lazyHandlerPromise: cachedPromise
+      };
     }
-    let lazyRoutePromise = route.lazy().then((lazyRoute) => {
+    let lazyRoutePromise2 = (async () => {
+      invariant(
+        typeof route.lazy === "function",
+        "No lazy route function found"
+      );
+      let lazyRoute = await route.lazy();
       let routeUpdates = {};
       for (let lazyRouteProperty in lazyRoute) {
         let lazyValue = lazyRoute[lazyRouteProperty];
@@ -3804,22 +3814,39 @@ async function loadLazyRoute(route, manifest, mapRouteProperties2) {
         ...mapRouteProperties2(routeToUpdate),
         lazy: void 0
       });
-    });
-    lazyRouteFunctionCache.set(routeToUpdate, lazyRoutePromise);
-    await lazyRoutePromise;
-    return;
+    })();
+    lazyRouteFunctionCache.set(routeToUpdate, lazyRoutePromise2);
+    return {
+      lazyRoutePromise: lazyRoutePromise2,
+      lazyHandlerPromise: lazyRoutePromise2
+    };
   }
   let lazyKeys = Object.keys(route.lazy);
-  await Promise.all(
-    lazyKeys.map(
-      (key) => loadLazyRouteProperty({
-        key,
-        route,
-        manifest,
-        mapRouteProperties: mapRouteProperties2
-      })
-    )
-  );
+  let lazyPropertyPromises = [];
+  let lazyHandlerPromise = void 0;
+  for (let key of lazyKeys) {
+    let promise = loadLazyRouteProperty({
+      key,
+      route,
+      manifest,
+      mapRouteProperties: mapRouteProperties2
+    });
+    if (promise) {
+      lazyPropertyPromises.push(promise);
+      if (key === type) {
+        lazyHandlerPromise = promise;
+      }
+    }
+  }
+  let lazyRoutePromise = Promise.all(lazyPropertyPromises).then(() => {
+  });
+  return {
+    lazyRoutePromise,
+    lazyHandlerPromise
+  };
+}
+function isNonNullable(value) {
+  return value !== void 0;
 }
 function loadLazyMiddlewareForMatches(matches, manifest, mapRouteProperties2) {
   let promises = matches.map(({ route }) => {
@@ -3832,7 +3859,7 @@ function loadLazyMiddlewareForMatches(matches, manifest, mapRouteProperties2) {
       manifest,
       mapRouteProperties: mapRouteProperties2
     });
-  }).filter((p) => p != null);
+  }).filter(isNonNullable);
   return promises.length > 0 ? Promise.all(promises) : void 0;
 }
 async function defaultDataStrategy(args) {
@@ -3955,27 +3982,28 @@ async function callDataStrategyImpl(dataStrategyImpl, type, request, matchesToLo
     manifest,
     mapRouteProperties2
   );
-  let loadLazyRoutePromises = matches.map(
-    (m) => m.route.lazy ? loadLazyRoute(m.route, manifest, mapRouteProperties2) : void 0
+  let lazyRoutePromises = matches.map(
+    (m) => loadLazyRoute(m.route, type, manifest, mapRouteProperties2)
   );
   if (loadMiddlewarePromise) {
     await loadMiddlewarePromise;
   }
   let dsMatches = matches.map((match, i) => {
-    let loadRoutePromise = loadLazyRoutePromises[i];
+    let { lazyRoutePromise, lazyHandlerPromise } = lazyRoutePromises[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)) {
         shouldLoad = true;
       }
-      return shouldLoad ? callLoaderOrAction(
+      return shouldLoad ? callLoaderOrAction({
         type,
         request,
         match,
-        loadRoutePromise,
+        lazyHandlerPromise,
+        lazyRoutePromise,
         handlerOverride,
         scopedContext
-      ) : Promise.resolve({ type: "data" /* data */, result: void 0 });
+      }) : Promise.resolve({ type: "data" /* data */, result: void 0 });
     };
     return {
       ...match,
@@ -3990,13 +4018,24 @@ async function callDataStrategyImpl(dataStrategyImpl, type, request, matchesToLo
     fetcherKey,
     context: scopedContext
   });
+  let allLazyRoutePromises = lazyRoutePromises.flatMap(
+    (promiseMap) => Object.values(promiseMap).filter(isNonNullable)
+  );
   try {
-    await Promise.all(loadLazyRoutePromises);
+    await Promise.all(allLazyRoutePromises);
   } catch (e) {
   }
   return results;
 }
-async function callLoaderOrAction(type, request, match, loadRoutePromise, handlerOverride, scopedContext) {
+async function callLoaderOrAction({
+  type,
+  request,
+  match,
+  lazyHandlerPromise,
+  lazyRoutePromise,
+  handlerOverride,
+  scopedContext
+}) {
   let result;
   let onReject;
   let runHandler = (handler) => {
@@ -4033,7 +4072,7 @@ async function callLoaderOrAction(type, request, match, loadRoutePromise, handle
   };
   try {
     let handler = match.route[type];
-    if (loadRoutePromise) {
+    if (lazyHandlerPromise || lazyRoutePromise) {
       if (handler) {
         let handlerError;
         let [value] = await Promise.all([
@@ -4043,17 +4082,19 @@ async function callLoaderOrAction(type, request, match, loadRoutePromise, handle
           runHandler(handler).catch((e) => {
             handlerError = e;
           }),
-          loadRoutePromise
+          // Ensure all lazy route promises are resolved before continuing
+          lazyHandlerPromise,
+          lazyRoutePromise
         ]);
         if (handlerError !== void 0) {
           throw handlerError;
         }
         result = value;
       } else {
-        await loadRoutePromise;
+        await lazyHandlerPromise;
         handler = match.route[type];
         if (handler) {
-          result = await runHandler(handler);
+          [result] = await Promise.all([runHandler(handler), lazyRoutePromise]);
         } else if (type === "action") {
           let url = new URL(request.url);
           let pathname = url.pathname + url.search;
@@ -7823,7 +7864,7 @@ function mergeRefs(...refs) {
 var isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined";
 try {
   if (isBrowser) {
-    window.__reactRouterVersion = "7.5.0-pre.0";
+    window.__reactRouterVersion = "7.5.0";
   }
 } catch (e) {
 }

package/dist/development/index.mjs

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

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

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

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

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

package/dist/production/{chunk-RSOGH2WR.mjs → chunk-ZIM7OIE3.mjs}

@@ -1,5 +1,5 @@
 /**
- * react-router v7.5.0-pre.0
+ * react-router v7.5.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -3610,19 +3610,29 @@ var loadLazyRouteProperty = ({
   return propertyPromise;
 };
 var lazyRouteFunctionCache = /* @__PURE__ */ new WeakMap();
-async function loadLazyRoute(route, manifest, mapRouteProperties2) {
+function loadLazyRoute(route, type, manifest, mapRouteProperties2) {
   let routeToUpdate = manifest[route.id];
   invariant(routeToUpdate, "No route found in manifest");
   if (!route.lazy) {
-    return;
+    return {
+      lazyRoutePromise: void 0,
+      lazyHandlerPromise: void 0
+    };
   }
   if (typeof route.lazy === "function") {
     let cachedPromise = lazyRouteFunctionCache.get(routeToUpdate);
     if (cachedPromise) {
-      await cachedPromise;
-      return;
+      return {
+        lazyRoutePromise: cachedPromise,
+        lazyHandlerPromise: cachedPromise
+      };
     }
-    let lazyRoutePromise = route.lazy().then((lazyRoute) => {
+    let lazyRoutePromise2 = (async () => {
+      invariant(
+        typeof route.lazy === "function",
+        "No lazy route function found"
+      );
+      let lazyRoute = await route.lazy();
       let routeUpdates = {};
       for (let lazyRouteProperty in lazyRoute) {
         let lazyValue = lazyRoute[lazyRouteProperty];
@@ -3656,22 +3666,39 @@ async function loadLazyRoute(route, manifest, mapRouteProperties2) {
         ...mapRouteProperties2(routeToUpdate),
         lazy: void 0
       });
-    });
-    lazyRouteFunctionCache.set(routeToUpdate, lazyRoutePromise);
-    await lazyRoutePromise;
-    return;
+    })();
+    lazyRouteFunctionCache.set(routeToUpdate, lazyRoutePromise2);
+    return {
+      lazyRoutePromise: lazyRoutePromise2,
+      lazyHandlerPromise: lazyRoutePromise2
+    };
   }
   let lazyKeys = Object.keys(route.lazy);
-  await Promise.all(
-    lazyKeys.map(
-      (key) => loadLazyRouteProperty({
-        key,
-        route,
-        manifest,
-        mapRouteProperties: mapRouteProperties2
-      })
-    )
-  );
+  let lazyPropertyPromises = [];
+  let lazyHandlerPromise = void 0;
+  for (let key of lazyKeys) {
+    let promise = loadLazyRouteProperty({
+      key,
+      route,
+      manifest,
+      mapRouteProperties: mapRouteProperties2
+    });
+    if (promise) {
+      lazyPropertyPromises.push(promise);
+      if (key === type) {
+        lazyHandlerPromise = promise;
+      }
+    }
+  }
+  let lazyRoutePromise = Promise.all(lazyPropertyPromises).then(() => {
+  });
+  return {
+    lazyRoutePromise,
+    lazyHandlerPromise
+  };
+}
+function isNonNullable(value) {
+  return value !== void 0;
 }
 function loadLazyMiddlewareForMatches(matches, manifest, mapRouteProperties2) {
   let promises = matches.map(({ route }) => {
@@ -3684,7 +3711,7 @@ function loadLazyMiddlewareForMatches(matches, manifest, mapRouteProperties2) {
       manifest,
       mapRouteProperties: mapRouteProperties2
     });
-  }).filter((p) => p != null);
+  }).filter(isNonNullable);
   return promises.length > 0 ? Promise.all(promises) : void 0;
 }
 async function defaultDataStrategy(args) {
@@ -3807,27 +3834,28 @@ async function callDataStrategyImpl(dataStrategyImpl, type, request, matchesToLo
     manifest,
     mapRouteProperties2
   );
-  let loadLazyRoutePromises = matches.map(
-    (m) => m.route.lazy ? loadLazyRoute(m.route, manifest, mapRouteProperties2) : void 0
+  let lazyRoutePromises = matches.map(
+    (m) => loadLazyRoute(m.route, type, manifest, mapRouteProperties2)
   );
   if (loadMiddlewarePromise) {
     await loadMiddlewarePromise;
   }
   let dsMatches = matches.map((match, i) => {
-    let loadRoutePromise = loadLazyRoutePromises[i];
+    let { lazyRoutePromise, lazyHandlerPromise } = lazyRoutePromises[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)) {
         shouldLoad = true;
       }
-      return shouldLoad ? callLoaderOrAction(
+      return shouldLoad ? callLoaderOrAction({
         type,
         request,
         match,
-        loadRoutePromise,
+        lazyHandlerPromise,
+        lazyRoutePromise,
         handlerOverride,
         scopedContext
-      ) : Promise.resolve({ type: "data" /* data */, result: void 0 });
+      }) : Promise.resolve({ type: "data" /* data */, result: void 0 });
     };
     return {
       ...match,
@@ -3842,13 +3870,24 @@ async function callDataStrategyImpl(dataStrategyImpl, type, request, matchesToLo
     fetcherKey,
     context: scopedContext
   });
+  let allLazyRoutePromises = lazyRoutePromises.flatMap(
+    (promiseMap) => Object.values(promiseMap).filter(isNonNullable)
+  );
   try {
-    await Promise.all(loadLazyRoutePromises);
+    await Promise.all(allLazyRoutePromises);
   } catch (e) {
   }
   return results;
 }
-async function callLoaderOrAction(type, request, match, loadRoutePromise, handlerOverride, scopedContext) {
+async function callLoaderOrAction({
+  type,
+  request,
+  match,
+  lazyHandlerPromise,
+  lazyRoutePromise,
+  handlerOverride,
+  scopedContext
+}) {
   let result;
   let onReject;
   let runHandler = (handler) => {
@@ -3885,7 +3924,7 @@ async function callLoaderOrAction(type, request, match, loadRoutePromise, handle
   };
   try {
     let handler = match.route[type];
-    if (loadRoutePromise) {
+    if (lazyHandlerPromise || lazyRoutePromise) {
       if (handler) {
         let handlerError;
         let [value] = await Promise.all([
@@ -3895,17 +3934,19 @@ async function callLoaderOrAction(type, request, match, loadRoutePromise, handle
           runHandler(handler).catch((e) => {
             handlerError = e;
           }),
-          loadRoutePromise
+          // Ensure all lazy route promises are resolved before continuing
+          lazyHandlerPromise,
+          lazyRoutePromise
         ]);
         if (handlerError !== void 0) {
           throw handlerError;
         }
         result = value;
       } else {
-        await loadRoutePromise;
+        await lazyHandlerPromise;
         handler = match.route[type];
         if (handler) {
-          result = await runHandler(handler);
+          [result] = await Promise.all([runHandler(handler), lazyRoutePromise]);
         } else if (type === "action") {
           let url = new URL(request.url);
           let pathname = url.pathname + url.search;
@@ -7675,7 +7716,7 @@ function mergeRefs(...refs) {
 var isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined";
 try {
   if (isBrowser) {
-    window.__reactRouterVersion = "7.5.0-pre.0";
+    window.__reactRouterVersion = "7.5.0";
   }
 } catch (e) {
 }

package/dist/production/dom-export.js

@@ -1,5 +1,5 @@
 /**
- * react-router v7.5.0-pre.0
+ * react-router v7.5.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -2898,19 +2898,29 @@ var loadLazyRouteProperty = ({
   return propertyPromise;
 };
 var lazyRouteFunctionCache = /* @__PURE__ */ new WeakMap();
-async function loadLazyRoute(route, manifest, mapRouteProperties2) {
+function loadLazyRoute(route, type, manifest, mapRouteProperties2) {
   let routeToUpdate = manifest[route.id];
   invariant(routeToUpdate, "No route found in manifest");
   if (!route.lazy) {
-    return;
+    return {
+      lazyRoutePromise: void 0,
+      lazyHandlerPromise: void 0
+    };
   }
   if (typeof route.lazy === "function") {
     let cachedPromise = lazyRouteFunctionCache.get(routeToUpdate);
     if (cachedPromise) {
-      await cachedPromise;
-      return;
+      return {
+        lazyRoutePromise: cachedPromise,
+        lazyHandlerPromise: cachedPromise
+      };
     }
-    let lazyRoutePromise = route.lazy().then((lazyRoute) => {
+    let lazyRoutePromise2 = (async () => {
+      invariant(
+        typeof route.lazy === "function",
+        "No lazy route function found"
+      );
+      let lazyRoute = await route.lazy();
       let routeUpdates = {};
       for (let lazyRouteProperty in lazyRoute) {
         let lazyValue = lazyRoute[lazyRouteProperty];
@@ -2944,22 +2954,39 @@ async function loadLazyRoute(route, manifest, mapRouteProperties2) {
         ...mapRouteProperties2(routeToUpdate),
         lazy: void 0
       });
-    });
-    lazyRouteFunctionCache.set(routeToUpdate, lazyRoutePromise);
-    await lazyRoutePromise;
-    return;
+    })();
+    lazyRouteFunctionCache.set(routeToUpdate, lazyRoutePromise2);
+    return {
+      lazyRoutePromise: lazyRoutePromise2,
+      lazyHandlerPromise: lazyRoutePromise2
+    };
   }
   let lazyKeys = Object.keys(route.lazy);
-  await Promise.all(
-    lazyKeys.map(
-      (key) => loadLazyRouteProperty({
-        key,
-        route,
-        manifest,
-        mapRouteProperties: mapRouteProperties2
-      })
-    )
-  );
+  let lazyPropertyPromises = [];
+  let lazyHandlerPromise = void 0;
+  for (let key of lazyKeys) {
+    let promise = loadLazyRouteProperty({
+      key,
+      route,
+      manifest,
+      mapRouteProperties: mapRouteProperties2
+    });
+    if (promise) {
+      lazyPropertyPromises.push(promise);
+      if (key === type) {
+        lazyHandlerPromise = promise;
+      }
+    }
+  }
+  let lazyRoutePromise = Promise.all(lazyPropertyPromises).then(() => {
+  });
+  return {
+    lazyRoutePromise,
+    lazyHandlerPromise
+  };
+}
+function isNonNullable(value) {
+  return value !== void 0;
 }
 function loadLazyMiddlewareForMatches(matches, manifest, mapRouteProperties2) {
   let promises = matches.map(({ route }) => {
@@ -2972,7 +2999,7 @@ function loadLazyMiddlewareForMatches(matches, manifest, mapRouteProperties2) {
       manifest,
       mapRouteProperties: mapRouteProperties2
     });
-  }).filter((p) => p != null);
+  }).filter(isNonNullable);
   return promises.length > 0 ? Promise.all(promises) : void 0;
 }
 async function defaultDataStrategy(args) {
@@ -3095,27 +3122,28 @@ async function callDataStrategyImpl(dataStrategyImpl, type, request, matchesToLo
     manifest,
     mapRouteProperties2
   );
-  let loadLazyRoutePromises = matches.map(
-    (m) => m.route.lazy ? loadLazyRoute(m.route, manifest, mapRouteProperties2) : void 0
+  let lazyRoutePromises = matches.map(
+    (m) => loadLazyRoute(m.route, type, manifest, mapRouteProperties2)
   );
   if (loadMiddlewarePromise) {
     await loadMiddlewarePromise;
   }
   let dsMatches = matches.map((match, i) => {
-    let loadRoutePromise = loadLazyRoutePromises[i];
+    let { lazyRoutePromise, lazyHandlerPromise } = lazyRoutePromises[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)) {
         shouldLoad = true;
       }
-      return shouldLoad ? callLoaderOrAction(
+      return shouldLoad ? callLoaderOrAction({
         type,
         request,
         match,
-        loadRoutePromise,
+        lazyHandlerPromise,
+        lazyRoutePromise,
         handlerOverride,
         scopedContext
-      ) : Promise.resolve({ type: "data" /* data */, result: void 0 });
+      }) : Promise.resolve({ type: "data" /* data */, result: void 0 });
     };
     return {
       ...match,
@@ -3130,13 +3158,24 @@ async function callDataStrategyImpl(dataStrategyImpl, type, request, matchesToLo
     fetcherKey,
     context: scopedContext
   });
+  let allLazyRoutePromises = lazyRoutePromises.flatMap(
+    (promiseMap) => Object.values(promiseMap).filter(isNonNullable)
+  );
   try {
-    await Promise.all(loadLazyRoutePromises);
+    await Promise.all(allLazyRoutePromises);
   } catch (e) {
   }
   return results;
 }
-async function callLoaderOrAction(type, request, match, loadRoutePromise, handlerOverride, scopedContext) {
+async function callLoaderOrAction({
+  type,
+  request,
+  match,
+  lazyHandlerPromise,
+  lazyRoutePromise,
+  handlerOverride,
+  scopedContext
+}) {
   let result;
   let onReject;
   let runHandler = (handler) => {
@@ -3173,7 +3212,7 @@ async function callLoaderOrAction(type, request, match, loadRoutePromise, handle
   };
   try {
     let handler = match.route[type];
-    if (loadRoutePromise) {
+    if (lazyHandlerPromise || lazyRoutePromise) {
       if (handler) {
         let handlerError;
         let [value] = await Promise.all([
@@ -3183,17 +3222,19 @@ async function callLoaderOrAction(type, request, match, loadRoutePromise, handle
           runHandler(handler).catch((e) => {
             handlerError = e;
           }),
-          loadRoutePromise
+          // Ensure all lazy route promises are resolved before continuing
+          lazyHandlerPromise,
+          lazyRoutePromise
         ]);
         if (handlerError !== void 0) {
           throw handlerError;
         }
         result = value;
       } else {
-        await loadRoutePromise;
+        await lazyHandlerPromise;
         handler = match.route[type];
         if (handler) {
-          result = await runHandler(handler);
+          [result] = await Promise.all([runHandler(handler), lazyRoutePromise]);
         } else if (type === "action") {
           let url = new URL(request.url);
           let pathname = url.pathname + url.search;

package/dist/production/dom-export.mjs

@@ -1,5 +1,5 @@
 /**
- * react-router v7.5.0-pre.0
+ * react-router v7.5.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -25,7 +25,7 @@ import {
   matchRoutes,
   shouldHydrateRouteLoader,
   useFogOFWarDiscovery
-} from "./chunk-RSOGH2WR.mjs";
+} from "./chunk-ZIM7OIE3.mjs";
 
 // lib/dom-export/dom-router-provider.tsx
 import * as React from "react";

package/dist/production/index.js

@@ -1,5 +1,5 @@
 /**
- * react-router v7.5.0-pre.0
+ * react-router v7.5.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -3758,19 +3758,29 @@ var loadLazyRouteProperty = ({
   return propertyPromise;
 };
 var lazyRouteFunctionCache = /* @__PURE__ */ new WeakMap();
-async function loadLazyRoute(route, manifest, mapRouteProperties2) {
+function loadLazyRoute(route, type, manifest, mapRouteProperties2) {
   let routeToUpdate = manifest[route.id];
   invariant(routeToUpdate, "No route found in manifest");
   if (!route.lazy) {
-    return;
+    return {
+      lazyRoutePromise: void 0,
+      lazyHandlerPromise: void 0
+    };
   }
   if (typeof route.lazy === "function") {
     let cachedPromise = lazyRouteFunctionCache.get(routeToUpdate);
     if (cachedPromise) {
-      await cachedPromise;
-      return;
+      return {
+        lazyRoutePromise: cachedPromise,
+        lazyHandlerPromise: cachedPromise
+      };
     }
-    let lazyRoutePromise = route.lazy().then((lazyRoute) => {
+    let lazyRoutePromise2 = (async () => {
+      invariant(
+        typeof route.lazy === "function",
+        "No lazy route function found"
+      );
+      let lazyRoute = await route.lazy();
       let routeUpdates = {};
       for (let lazyRouteProperty in lazyRoute) {
         let lazyValue = lazyRoute[lazyRouteProperty];
@@ -3804,22 +3814,39 @@ async function loadLazyRoute(route, manifest, mapRouteProperties2) {
         ...mapRouteProperties2(routeToUpdate),
         lazy: void 0
       });
-    });
-    lazyRouteFunctionCache.set(routeToUpdate, lazyRoutePromise);
-    await lazyRoutePromise;
-    return;
+    })();
+    lazyRouteFunctionCache.set(routeToUpdate, lazyRoutePromise2);
+    return {
+      lazyRoutePromise: lazyRoutePromise2,
+      lazyHandlerPromise: lazyRoutePromise2
+    };
   }
   let lazyKeys = Object.keys(route.lazy);
-  await Promise.all(
-    lazyKeys.map(
-      (key) => loadLazyRouteProperty({
-        key,
-        route,
-        manifest,
-        mapRouteProperties: mapRouteProperties2
-      })
-    )
-  );
+  let lazyPropertyPromises = [];
+  let lazyHandlerPromise = void 0;
+  for (let key of lazyKeys) {
+    let promise = loadLazyRouteProperty({
+      key,
+      route,
+      manifest,
+      mapRouteProperties: mapRouteProperties2
+    });
+    if (promise) {
+      lazyPropertyPromises.push(promise);
+      if (key === type) {
+        lazyHandlerPromise = promise;
+      }
+    }
+  }
+  let lazyRoutePromise = Promise.all(lazyPropertyPromises).then(() => {
+  });
+  return {
+    lazyRoutePromise,
+    lazyHandlerPromise
+  };
+}
+function isNonNullable(value) {
+  return value !== void 0;
 }
 function loadLazyMiddlewareForMatches(matches, manifest, mapRouteProperties2) {
   let promises = matches.map(({ route }) => {
@@ -3832,7 +3859,7 @@ function loadLazyMiddlewareForMatches(matches, manifest, mapRouteProperties2) {
       manifest,
       mapRouteProperties: mapRouteProperties2
     });
-  }).filter((p) => p != null);
+  }).filter(isNonNullable);
   return promises.length > 0 ? Promise.all(promises) : void 0;
 }
 async function defaultDataStrategy(args) {
@@ -3955,27 +3982,28 @@ async function callDataStrategyImpl(dataStrategyImpl, type, request, matchesToLo
     manifest,
     mapRouteProperties2
   );
-  let loadLazyRoutePromises = matches.map(
-    (m) => m.route.lazy ? loadLazyRoute(m.route, manifest, mapRouteProperties2) : void 0
+  let lazyRoutePromises = matches.map(
+    (m) => loadLazyRoute(m.route, type, manifest, mapRouteProperties2)
   );
   if (loadMiddlewarePromise) {
     await loadMiddlewarePromise;
   }
   let dsMatches = matches.map((match, i) => {
-    let loadRoutePromise = loadLazyRoutePromises[i];
+    let { lazyRoutePromise, lazyHandlerPromise } = lazyRoutePromises[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)) {
         shouldLoad = true;
       }
-      return shouldLoad ? callLoaderOrAction(
+      return shouldLoad ? callLoaderOrAction({
         type,
         request,
         match,
-        loadRoutePromise,
+        lazyHandlerPromise,
+        lazyRoutePromise,
         handlerOverride,
         scopedContext
-      ) : Promise.resolve({ type: "data" /* data */, result: void 0 });
+      }) : Promise.resolve({ type: "data" /* data */, result: void 0 });
     };
     return {
       ...match,
@@ -3990,13 +4018,24 @@ async function callDataStrategyImpl(dataStrategyImpl, type, request, matchesToLo
     fetcherKey,
     context: scopedContext
   });
+  let allLazyRoutePromises = lazyRoutePromises.flatMap(
+    (promiseMap) => Object.values(promiseMap).filter(isNonNullable)
+  );
   try {
-    await Promise.all(loadLazyRoutePromises);
+    await Promise.all(allLazyRoutePromises);
   } catch (e) {
   }
   return results;
 }
-async function callLoaderOrAction(type, request, match, loadRoutePromise, handlerOverride, scopedContext) {
+async function callLoaderOrAction({
+  type,
+  request,
+  match,
+  lazyHandlerPromise,
+  lazyRoutePromise,
+  handlerOverride,
+  scopedContext
+}) {
   let result;
   let onReject;
   let runHandler = (handler) => {
@@ -4033,7 +4072,7 @@ async function callLoaderOrAction(type, request, match, loadRoutePromise, handle
   };
   try {
     let handler = match.route[type];
-    if (loadRoutePromise) {
+    if (lazyHandlerPromise || lazyRoutePromise) {
       if (handler) {
         let handlerError;
         let [value] = await Promise.all([
@@ -4043,17 +4082,19 @@ async function callLoaderOrAction(type, request, match, loadRoutePromise, handle
           runHandler(handler).catch((e) => {
             handlerError = e;
           }),
-          loadRoutePromise
+          // Ensure all lazy route promises are resolved before continuing
+          lazyHandlerPromise,
+          lazyRoutePromise
         ]);
         if (handlerError !== void 0) {
           throw handlerError;
         }
         result = value;
       } else {
-        await loadRoutePromise;
+        await lazyHandlerPromise;
         handler = match.route[type];
         if (handler) {
-          result = await runHandler(handler);
+          [result] = await Promise.all([runHandler(handler), lazyRoutePromise]);
         } else if (type === "action") {
           let url = new URL(request.url);
           let pathname = url.pathname + url.search;
@@ -7823,7 +7864,7 @@ function mergeRefs(...refs) {
 var isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined";
 try {
   if (isBrowser) {
-    window.__reactRouterVersion = "7.5.0-pre.0";
+    window.__reactRouterVersion = "7.5.0";
   }
 } catch (e) {
 }

package/dist/production/index.mjs

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

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

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

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-router",
-  "version": "7.5.0-pre.0",
+  "version": "7.5.0",
   "description": "Declarative routing for React",
   "keywords": [
     "react",