react-router 7.4.0-pre.0 → 7.4.1-pre.0

package/CHANGELOG.md

@@ -1,15 +1,27 @@
 # `react-router`
 
-## 7.4.0-pre.0
+## 7.4.1-pre.0
+
+### Patch Changes
+
+- Fix types on `unstable_MiddlewareFunction` to avoid type errors when a middleware doesn't return a value ([#13311](https://github.com/remix-run/react-router/pull/13311))
+- Dedupe calls to `route.lazy` functions ([#13260](https://github.com/remix-run/react-router/pull/13260))
+- Add support for `route.unstable_lazyMiddleware` function to allow lazy loading of middleware logic. ([#13210](https://github.com/remix-run/react-router/pull/13210))
+
+  **Breaking change for `unstable_middleware` consumers**
+
+  The `route.unstable_middleware` property is no longer supported in the return value from `route.lazy`. If you want to lazily load middleware, you must use `route.unstable_lazyMiddleware`.
+
+## 7.4.0
 
 ### Patch Changes
 
-- - UNSTABLE(BREAKING): If a middleware throws an error, ensure we only bubble the error itself via `next()` and are no longer leaking the `MiddlewareError` implementation detail ([#13180](https://github.com/remix-run/react-router/pull/13180))
-- Fix `RequestHandler` `loadContext` parameter type when middleware is enabled ([#13204](https://github.com/remix-run/react-router/pull/13204))
 - Fix root loader data on initial load redirects in SPA mode ([#13222](https://github.com/remix-run/react-router/pull/13222))
 - Load ancestor pathless/index routes in lazy route discovery for upwards non-eager-discoery routing ([#13203](https://github.com/remix-run/react-router/pull/13203))
 - Fix `shouldRevalidate` behavior for `clientLoader`-only routes in `ssr:true` apps ([#13221](https://github.com/remix-run/react-router/pull/13221))
-- [UNSTABLE] Update `Route.unstable_MiddlewareFunction` to have a return value of `Response | undefined` instead of `Response | void` becaue you should not return anything if you aren't returning the `Response` ([#13199](https://github.com/remix-run/react-router/pull/13199))
+- UNSTABLE: Fix `RequestHandler` `loadContext` parameter type when middleware is enabled ([#13204](https://github.com/remix-run/react-router/pull/13204))
+- UNSTABLE: Update `Route.unstable_MiddlewareFunction` to have a return value of `Response | undefined` instead of `Response | void` becaue you should not return anything if you aren't returning the `Response` ([#13199](https://github.com/remix-run/react-router/pull/13199))
+- UNSTABLE(BREAKING): If a middleware throws an error, ensure we only bubble the error itself via `next()` and are no longer leaking the `MiddlewareError` implementation detail ([#13180](https://github.com/remix-run/react-router/pull/13180))
 
 ## 7.3.0
 
@@ -431,7 +443,7 @@ _No changes_
   - Collapse `@remix-run/server-runtime` into `react-router`
   - Collapse `@remix-run/testing` into `react-router`
 
-- Remove single_fetch future flag. ([#11522](https://github.com/remix-run/react-router/pull/11522))
+- Remove single fetch future flag. ([#11522](https://github.com/remix-run/react-router/pull/11522))
 
 - Drop support for Node 16, React Router SSR now requires Node 18 or higher ([#11391](https://github.com/remix-run/react-router/pull/11391))
 

package/dist/development/{chunk-RYZWEUVP.mjs → chunk-EC6TQTU3.mjs}

@@ -1,5 +1,5 @@
 /**
- * react-router v7.4.0-pre.0
+ * react-router v7.4.1-pre.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -383,12 +383,14 @@ var unstable_RouterContextProvider = class {
   }
 };
 _map = new WeakMap();
-var immutableRouteKeys = /* @__PURE__ */ new Set([
+var unsupportedLazyRouteFunctionKeys = /* @__PURE__ */ new Set([
   "lazy",
   "caseSensitive",
   "path",
   "id",
   "index",
+  "unstable_middleware",
+  "unstable_lazyMiddleware",
   "children"
 ]);
 function isIndexRoute(route) {
@@ -2207,8 +2209,7 @@ function createRouter(init) {
         fetcherKey,
         manifest,
         mapRouteProperties2,
-        scopedContext,
-        future.unstable_middleware
+        scopedContext
       );
     } catch (e) {
       matchesToLoad.forEach((m) => {
@@ -2681,12 +2682,15 @@ function createStaticHandler(routes, opts) {
       };
       return respond ? respond(staticContext) : staticContext;
     }
-    if (respond && matches.some((m) => m.route.unstable_middleware)) {
+    if (respond && matches.some(
+      (m) => m.route.unstable_middleware || m.route.unstable_lazyMiddleware
+    )) {
       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);
         let renderedStaticContext;
         let response = await runMiddlewarePipeline(
           {
@@ -2802,11 +2806,14 @@ function createStaticHandler(routes, opts) {
     } else if (!match) {
       throw getInternalRouterError(404, { pathname: location.pathname });
     }
-    if (respond && matches.some((m) => m.route.unstable_middleware)) {
+    if (respond && matches.some(
+      (m) => m.route.unstable_middleware || m.route.unstable_lazyMiddleware
+    )) {
       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);
       let response = await runMiddlewarePipeline(
         {
           request,
@@ -3123,9 +3130,7 @@ function createStaticHandler(routes, opts) {
       null,
       manifest,
       mapRouteProperties2,
-      requestContext,
-      false
-      // middleware not done via dataStrategy in the static handler
+      requestContext
     );
     let dataResults = {};
     await Promise.all(
@@ -3526,38 +3531,80 @@ function isSameRoute(newRoute, existingRoute) {
     (aChild, i) => existingRoute.children?.some((bChild) => isSameRoute(aChild, bChild))
   );
 }
+var lazyRouteFunctionCache = /* @__PURE__ */ new WeakMap();
 async function loadLazyRouteModule(route, mapRouteProperties2, manifest) {
+  let routeToUpdate = manifest[route.id];
+  invariant(routeToUpdate, "No route found in manifest");
   if (!route.lazy) {
     return;
   }
-  let lazyRoute = await route.lazy();
-  if (!route.lazy) {
+  let cachedPromise = lazyRouteFunctionCache.get(routeToUpdate);
+  if (cachedPromise) {
+    await cachedPromise;
+    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";
+      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.`
+      );
+      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."
+      );
+      if (!isPropertyStaticallyDefined && !unsupportedLazyRouteFunctionKeys.has(
+        lazyRouteProperty
+      )) {
+        routeUpdates[lazyRouteProperty] = lazyRoute[lazyRouteProperty];
+      }
+    }
+    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;
   }
   let routeToUpdate = manifest[route.id];
   invariant(routeToUpdate, "No route found in manifest");
-  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";
+  if (routeToUpdate.unstable_middleware) {
     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.`
+      false,
+      `Route "${routeToUpdate.id}" has a static property "unstable_middleware" defined. The "unstable_lazyMiddleware" function will be ignored.`
     );
-    if (!isPropertyStaticallyDefined && !immutableRouteKeys.has(lazyRouteProperty)) {
-      routeUpdates[lazyRouteProperty] = lazyRoute[lazyRouteProperty];
+  } else {
+    let middleware = await route.unstable_lazyMiddleware();
+    if (!route.unstable_lazyMiddleware) {
+      return;
+    }
+    if (!routeToUpdate.unstable_middleware) {
+      routeToUpdate.unstable_middleware = middleware;
     }
   }
-  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
-  });
+  routeToUpdate.unstable_lazyMiddleware = void 0;
+}
+function loadLazyMiddlewareForMatches(matches, manifest) {
+  let promises = matches.map(
+    (m) => m.route.unstable_lazyMiddleware ? loadLazyMiddleware(m.route, manifest) : void 0
+  ).filter(Boolean);
+  return promises.length > 0 ? Promise.all(promises) : void 0;
 }
 async function defaultDataStrategy(args) {
   let matchesToLoad = args.matches.filter((m) => m.shouldLoad);
@@ -3673,12 +3720,13 @@ async function callRouteMiddleware(args, middlewares, propagateResult, middlewar
     throw error;
   }
 }
-async function callDataStrategyImpl(dataStrategyImpl, type, request, matchesToLoad, matches, fetcherKey, manifest, mapRouteProperties2, scopedContext, enableMiddleware) {
+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
   );
-  if (enableMiddleware) {
-    await Promise.all(loadRouteDefinitionsPromises);
+  if (loadMiddlewarePromise) {
+    await loadMiddlewarePromise;
   }
   let dsMatches = matches.map((match, i) => {
     let loadRoutePromise = loadRouteDefinitionsPromises[i];
@@ -6740,6 +6788,21 @@ function createClientRoutes(manifest, routeModulesCache, initialState, ssr, isSp
           });
         };
       }
+      if (route.hasClientMiddleware) {
+        dataRoute.unstable_lazyMiddleware = async () => {
+          invariant2(route);
+          let clientMiddlewareModule = 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));
@@ -6774,7 +6837,6 @@ function createClientRoutes(manifest, routeModulesCache, initialState, ssr, isSp
         return {
           ...lazyRoute.loader ? { loader: lazyRoute.loader } : {},
           ...lazyRoute.action ? { action: lazyRoute.action } : {},
-          unstable_middleware: mod.unstable_clientMiddleware,
           hasErrorBoundary: lazyRoute.hasErrorBoundary,
           shouldRevalidate: getShouldRevalidateFunction(
             lazyRoute,
@@ -7408,6 +7470,7 @@ ${matches.map((match, routeIndex) => {
       let {
         clientActionModule,
         clientLoaderModule,
+        clientMiddlewareModule,
         hydrateFallbackModule,
         module
       } = manifestEntry;
@@ -7424,6 +7487,12 @@ ${matches.map((match, routeIndex) => {
             varName: `${routeVarName}_clientLoader`
           }
         ] : [],
+        ...clientMiddlewareModule ? [
+          {
+            module: clientMiddlewareModule,
+            varName: `${routeVarName}_clientMiddleware`
+          }
+        ] : [],
         ...hydrateFallbackModule ? [
           {
             module: hydrateFallbackModule,
@@ -7517,7 +7586,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.0-pre.0";
+    window.__reactRouterVersion = "7.4.1-pre.0";
   }
 } catch (e) {
 }
@@ -8727,16 +8796,18 @@ function processRoutes(routes, manifest, routeModules, parentId) {
       parentId,
       hasAction: route.action != null,
       hasLoader: route.loader != null,
-      // When testing routes, you should just be stubbing loader/action, not
-      // trying to re-implement the full loader/clientLoader/SSR/hydration flow.
-      // That is better tested via E2E tests.
+      // When testing routes, you should be stubbing loader/action/middleware,
+      // not trying to re-implement the full loader/clientLoader/SSR/hydration
+      // flow. That is better tested via E2E tests.
       hasClientAction: false,
       hasClientLoader: false,
+      hasClientMiddleware: false,
       hasErrorBoundary: route.ErrorBoundary != null,
       // any need for these?
       module: "build/stub-path-to-module.js",
       clientActionModule: void 0,
       clientLoaderModule: void 0,
+      clientMiddlewareModule: void 0,
       hydrateFallbackModule: void 0
     };
     manifest.routes[newRoute.id] = entryRoute;

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-BQyvjjKg.mjs';
-import { R as RouterInit } from './route-data-CGHGzi13.mjs';
+import { R as RouterProviderProps$1 } from './fog-of-war-BjgPfDmv.mjs';
+import { R as RouterInit } from './route-data-BL8ToWby.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-CGNKxM4z.js';
-import { R as RouterInit } from './route-data-CGHGzi13.js';
+import { R as RouterProviderProps$1 } from './fog-of-war-BaM-ohjc.js';
+import { R as RouterInit } from './route-data-BL8ToWby.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.4.0-pre.0
+ * react-router v7.4.1-pre.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -275,12 +275,14 @@ var unstable_RouterContextProvider = class {
   }
 };
 _map = new WeakMap();
-var immutableRouteKeys = /* @__PURE__ */ new Set([
+var unsupportedLazyRouteFunctionKeys = /* @__PURE__ */ new Set([
   "lazy",
   "caseSensitive",
   "path",
   "id",
   "index",
+  "unstable_middleware",
+  "unstable_lazyMiddleware",
   "children"
 ]);
 function isIndexRoute(route) {
@@ -2061,8 +2063,7 @@ function createRouter(init) {
         fetcherKey,
         manifest,
         mapRouteProperties2,
-        scopedContext,
-        future.unstable_middleware
+        scopedContext
       );
     } catch (e) {
       matchesToLoad.forEach((m) => {
@@ -2822,38 +2823,80 @@ function isSameRoute(newRoute, existingRoute) {
     (aChild, i) => existingRoute.children?.some((bChild) => isSameRoute(aChild, bChild))
   );
 }
+var lazyRouteFunctionCache = /* @__PURE__ */ new WeakMap();
 async function loadLazyRouteModule(route, mapRouteProperties2, manifest) {
+  let routeToUpdate = manifest[route.id];
+  invariant(routeToUpdate, "No route found in manifest");
   if (!route.lazy) {
     return;
   }
-  let lazyRoute = await route.lazy();
-  if (!route.lazy) {
+  let cachedPromise = lazyRouteFunctionCache.get(routeToUpdate);
+  if (cachedPromise) {
+    await cachedPromise;
+    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";
+      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.`
+      );
+      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."
+      );
+      if (!isPropertyStaticallyDefined && !unsupportedLazyRouteFunctionKeys.has(
+        lazyRouteProperty
+      )) {
+        routeUpdates[lazyRouteProperty] = lazyRoute[lazyRouteProperty];
+      }
+    }
+    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;
   }
   let routeToUpdate = manifest[route.id];
   invariant(routeToUpdate, "No route found in manifest");
-  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";
+  if (routeToUpdate.unstable_middleware) {
     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.`
+      false,
+      `Route "${routeToUpdate.id}" has a static property "unstable_middleware" defined. The "unstable_lazyMiddleware" function will be ignored.`
     );
-    if (!isPropertyStaticallyDefined && !immutableRouteKeys.has(lazyRouteProperty)) {
-      routeUpdates[lazyRouteProperty] = lazyRoute[lazyRouteProperty];
+  } else {
+    let middleware = await route.unstable_lazyMiddleware();
+    if (!route.unstable_lazyMiddleware) {
+      return;
+    }
+    if (!routeToUpdate.unstable_middleware) {
+      routeToUpdate.unstable_middleware = middleware;
     }
   }
-  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
-  });
+  routeToUpdate.unstable_lazyMiddleware = void 0;
+}
+function loadLazyMiddlewareForMatches(matches, manifest) {
+  let promises = matches.map(
+    (m) => m.route.unstable_lazyMiddleware ? loadLazyMiddleware(m.route, manifest) : void 0
+  ).filter(Boolean);
+  return promises.length > 0 ? Promise.all(promises) : void 0;
 }
 async function defaultDataStrategy(args) {
   let matchesToLoad = args.matches.filter((m) => m.shouldLoad);
@@ -2969,12 +3012,13 @@ async function callRouteMiddleware(args, middlewares, propagateResult, middlewar
     throw error;
   }
 }
-async function callDataStrategyImpl(dataStrategyImpl, type, request, matchesToLoad, matches, fetcherKey, manifest, mapRouteProperties2, scopedContext, enableMiddleware) {
+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
   );
-  if (enableMiddleware) {
-    await Promise.all(loadRouteDefinitionsPromises);
+  if (loadMiddlewarePromise) {
+    await loadMiddlewarePromise;
   }
   let dsMatches = matches.map((match, i) => {
     let loadRoutePromise = loadRouteDefinitionsPromises[i];
@@ -5208,6 +5252,21 @@ function createClientRoutes(manifest, routeModulesCache, initialState, ssr, isSp
           });
         };
       }
+      if (route.hasClientMiddleware) {
+        dataRoute.unstable_lazyMiddleware = async () => {
+          invariant2(route);
+          let clientMiddlewareModule = 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));
@@ -5242,7 +5301,6 @@ function createClientRoutes(manifest, routeModulesCache, initialState, ssr, isSp
         return {
           ...lazyRoute.loader ? { loader: lazyRoute.loader } : {},
           ...lazyRoute.action ? { action: lazyRoute.action } : {},
-          unstable_middleware: mod.unstable_clientMiddleware,
           hasErrorBoundary: lazyRoute.hasErrorBoundary,
           shouldRevalidate: getShouldRevalidateFunction(
             lazyRoute,
@@ -5583,6 +5641,7 @@ ${matches.map((match, routeIndex) => {
       let {
         clientActionModule,
         clientLoaderModule,
+        clientMiddlewareModule,
         hydrateFallbackModule,
         module: module2
       } = manifestEntry;
@@ -5599,6 +5658,12 @@ ${matches.map((match, routeIndex) => {
             varName: `${routeVarName}_clientLoader`
           }
         ] : [],
+        ...clientMiddlewareModule ? [
+          {
+            module: clientMiddlewareModule,
+            varName: `${routeVarName}_clientMiddleware`
+          }
+        ] : [],
         ...hydrateFallbackModule ? [
           {
             module: hydrateFallbackModule,

package/dist/development/dom-export.mjs

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

package/dist/{production/fog-of-war-BQyvjjKg.d.mts → development/fog-of-war-BaM-ohjc.d.ts}

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import { k as RouteObject, R as RouterInit, F as FutureConfig$1, H as HydrationState, I as InitialEntry, D as DataStrategyFunction, ar as PatchRoutesOnNavigationFunction, b as Router$1, T as To, d as RelativeRoutingType, x as NonIndexRouteObject, a2 as LazyRouteFunction, s as IndexRouteObject, e as Location, f as Action, aq as Navigator, at as RouteMatch, p as StaticHandlerContext, c as RouteManifest, a as RouteModules, ap as DataRouteObject, aR as RouteModule, a1 as HTMLFormMethod, $ as FormEncType, aC as PageLinkDescriptor, aS as History, z as GetScrollRestorationKeyFunction, N as NavigateOptions, J as Fetcher, n as SerializeFrom, B as BlockerFunction } from './route-data-CGHGzi13.mjs';
+import { k as RouteObject, R as RouterInit, F as FutureConfig$1, H as HydrationState, I as InitialEntry, D as DataStrategyFunction, ar as PatchRoutesOnNavigationFunction, b as Router$1, T as To, d as RelativeRoutingType, x as NonIndexRouteObject, a2 as LazyRouteFunction, s as IndexRouteObject, e as Location, f as Action, aq as Navigator, at as RouteMatch, p as StaticHandlerContext, c as RouteManifest, a as RouteModules, ap as DataRouteObject, aR as RouteModule, a1 as HTMLFormMethod, $ as FormEncType, aC as PageLinkDescriptor, aS as History, z as GetScrollRestorationKeyFunction, N as NavigateOptions, J as Fetcher, n as SerializeFrom, B as BlockerFunction } from './route-data-BL8ToWby.js';
 
 /**
  * @private
@@ -472,12 +472,14 @@ interface EntryRoute extends Route {
     hasLoader: boolean;
     hasClientAction: boolean;
     hasClientLoader: boolean;
+    hasClientMiddleware: boolean;
     hasErrorBoundary: boolean;
     imports?: string[];
     css?: string[];
     module: string;
     clientActionModule: string | undefined;
     clientLoaderModule: string | undefined;
+    clientMiddlewareModule: string | undefined;
     hydrateFallbackModule: string | undefined;
     parentId?: string;
 }

package/dist/development/{fog-of-war-CGNKxM4z.d.ts → fog-of-war-BjgPfDmv.d.mts}

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import { k as RouteObject, R as RouterInit, F as FutureConfig$1, H as HydrationState, I as InitialEntry, D as DataStrategyFunction, ar as PatchRoutesOnNavigationFunction, b as Router$1, T as To, d as RelativeRoutingType, x as NonIndexRouteObject, a2 as LazyRouteFunction, s as IndexRouteObject, e as Location, f as Action, aq as Navigator, at as RouteMatch, p as StaticHandlerContext, c as RouteManifest, a as RouteModules, ap as DataRouteObject, aR as RouteModule, a1 as HTMLFormMethod, $ as FormEncType, aC as PageLinkDescriptor, aS as History, z as GetScrollRestorationKeyFunction, N as NavigateOptions, J as Fetcher, n as SerializeFrom, B as BlockerFunction } from './route-data-CGHGzi13.js';
+import { k as RouteObject, R as RouterInit, F as FutureConfig$1, H as HydrationState, I as InitialEntry, D as DataStrategyFunction, ar as PatchRoutesOnNavigationFunction, b as Router$1, T as To, d as RelativeRoutingType, x as NonIndexRouteObject, a2 as LazyRouteFunction, s as IndexRouteObject, e as Location, f as Action, aq as Navigator, at as RouteMatch, p as StaticHandlerContext, c as RouteManifest, a as RouteModules, ap as DataRouteObject, aR as RouteModule, a1 as HTMLFormMethod, $ as FormEncType, aC as PageLinkDescriptor, aS as History, z as GetScrollRestorationKeyFunction, N as NavigateOptions, J as Fetcher, n as SerializeFrom, B as BlockerFunction } from './route-data-BL8ToWby.mjs';
 
 /**
  * @private
@@ -472,12 +472,14 @@ interface EntryRoute extends Route {
     hasLoader: boolean;
     hasClientAction: boolean;
     hasClientLoader: boolean;
+    hasClientMiddleware: boolean;
     hasErrorBoundary: boolean;
     imports?: string[];
     css?: string[];
     module: string;
     clientActionModule: string | undefined;
     clientLoaderModule: string | undefined;
+    clientMiddlewareModule: string | undefined;
     hydrateFallbackModule: string | undefined;
     parentId?: string;
 }

package/dist/development/index.d.mts

@@ -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-CGHGzi13.mjs';
-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-CGHGzi13.mjs';
-import { A as AssetsManifest, a as Route, F as FutureConfig, E as EntryContext, C as CriticalCss } from './fog-of-war-BQyvjjKg.mjs';
-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-BQyvjjKg.mjs';
+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.mjs';
+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.mjs';
+import { A as AssetsManifest, a as Route, F as FutureConfig, E as EntryContext, C as CriticalCss } from './fog-of-war-BjgPfDmv.mjs';
+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-BjgPfDmv.mjs';
 import * as React from 'react';
 import { ReactElement } from 'react';
 import { ParseOptions, SerializeOptions } from 'cookie';