react-router 7.4.0 → 7.4.1

package/dist/production/index.js

@@ -1,5 +1,5 @@
 /**
- * react-router v7.4.0
+ * react-router v7.4.1
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -531,12 +531,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) {
@@ -2355,8 +2357,7 @@ function createRouter(init) {
         fetcherKey,
         manifest,
         mapRouteProperties2,
-        scopedContext,
-        future.unstable_middleware
+        scopedContext
       );
     } catch (e) {
       matchesToLoad.forEach((m) => {
@@ -2829,12 +2830,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(
           {
@@ -2950,11 +2954,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,
@@ -3271,9 +3278,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(
@@ -3674,38 +3679,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);
@@ -3821,12 +3868,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];
@@ -6888,6 +6936,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));
@@ -6922,7 +6985,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,
@@ -7556,6 +7618,7 @@ ${matches.map((match, routeIndex) => {
       let {
         clientActionModule,
         clientLoaderModule,
+        clientMiddlewareModule,
         hydrateFallbackModule,
         module: module2
       } = manifestEntry;
@@ -7572,6 +7635,12 @@ ${matches.map((match, routeIndex) => {
             varName: `${routeVarName}_clientLoader`
           }
         ] : [],
+        ...clientMiddlewareModule ? [
+          {
+            module: clientMiddlewareModule,
+            varName: `${routeVarName}_clientMiddleware`
+          }
+        ] : [],
         ...hydrateFallbackModule ? [
           {
             module: hydrateFallbackModule,
@@ -7665,7 +7734,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";
+    window.__reactRouterVersion = "7.4.1";
   }
 } catch (e) {
 }
@@ -8875,16 +8944,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/production/index.mjs

@@ -1,5 +1,5 @@
 /**
- * react-router v7.4.0
+ * react-router v7.4.1
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -123,7 +123,7 @@ import {
   useSearchParams,
   useSubmit,
   useViewTransitionState
-} from "./chunk-SXJRHUAY.mjs";
+} from "./chunk-T6D7EGPT.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-CGHGzi13.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-BL8ToWby.mjs';
 import { M as MiddlewareEnabled, A as AppLoadContext } from '../../future-ldDp5FKH.mjs';
 import 'react';
 
@@ -139,8 +139,8 @@ type ServerDataFunctionArgs<T extends RouteInfo> = {
      */
     context: MiddlewareEnabled extends true ? unstable_RouterContextProvider : AppLoadContext;
 };
-type CreateServerMiddlewareFunction<T extends RouteInfo> = (args: ServerDataFunctionArgs<T>, next: unstable_MiddlewareNextFunction<Response>) => MaybePromise<Response | undefined>;
-type CreateClientMiddlewareFunction<T extends RouteInfo> = (args: ClientDataFunctionArgs<T>, next: unstable_MiddlewareNextFunction<undefined>) => MaybePromise<undefined>;
+type CreateServerMiddlewareFunction<T extends RouteInfo> = (args: ServerDataFunctionArgs<T>, next: unstable_MiddlewareNextFunction<Response>) => MaybePromise<Response | void>;
+type CreateClientMiddlewareFunction<T extends RouteInfo> = (args: ClientDataFunctionArgs<T>, next: unstable_MiddlewareNextFunction<undefined>) => MaybePromise<void>;
 type CreateServerLoaderArgs<T extends RouteInfo> = ServerDataFunctionArgs<T>;
 type CreateClientLoaderArgs<T extends RouteInfo> = ClientDataFunctionArgs<T> & {
     /** This is an asynchronous function to get the data from the server loader for this route. On client-side navigations, this will make a {@link https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API fetch} call to the React Router server loader. If you opt-into running your clientLoader on hydration, then this function will return the data that was already loaded on the server (via Promise.resolve). */

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-CGHGzi13.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-BL8ToWby.js';
 import { M as MiddlewareEnabled, A as AppLoadContext } from '../../future-ldDp5FKH.js';
 import 'react';
 
@@ -139,8 +139,8 @@ type ServerDataFunctionArgs<T extends RouteInfo> = {
      */
     context: MiddlewareEnabled extends true ? unstable_RouterContextProvider : AppLoadContext;
 };
-type CreateServerMiddlewareFunction<T extends RouteInfo> = (args: ServerDataFunctionArgs<T>, next: unstable_MiddlewareNextFunction<Response>) => MaybePromise<Response | undefined>;
-type CreateClientMiddlewareFunction<T extends RouteInfo> = (args: ClientDataFunctionArgs<T>, next: unstable_MiddlewareNextFunction<undefined>) => MaybePromise<undefined>;
+type CreateServerMiddlewareFunction<T extends RouteInfo> = (args: ServerDataFunctionArgs<T>, next: unstable_MiddlewareNextFunction<Response>) => MaybePromise<Response | void>;
+type CreateClientMiddlewareFunction<T extends RouteInfo> = (args: ClientDataFunctionArgs<T>, next: unstable_MiddlewareNextFunction<undefined>) => MaybePromise<void>;
 type CreateServerLoaderArgs<T extends RouteInfo> = ServerDataFunctionArgs<T>;
 type CreateClientLoaderArgs<T extends RouteInfo> = ClientDataFunctionArgs<T> & {
     /** This is an asynchronous function to get the data from the server loader for this route. On client-side navigations, this will make a {@link https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API fetch} call to the React Router server loader. If you opt-into running your clientLoader on hydration, then this function will return the data that was already loaded on the server (via Promise.resolve). */

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

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

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

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

package/dist/production/{route-data-CGHGzi13.d.ts → route-data-BL8ToWby.d.mts}

@@ -332,7 +332,7 @@ interface unstable_MiddlewareNextFunction<Result = unknown> {
  * a `next` function as the second parameter which will call downstream handlers
  * and then complete middlewares from the bottom-up
  */
-type unstable_MiddlewareFunction<Result = unknown> = (args: DataFunctionArgs<unstable_RouterContextProvider>, next: unstable_MiddlewareNextFunction<Result>) => MaybePromise<Result | undefined>;
+type unstable_MiddlewareFunction<Result = unknown> = (args: DataFunctionArgs<unstable_RouterContextProvider>, next: unstable_MiddlewareNextFunction<Result>) => MaybePromise<Result | void>;
 /**
  * Arguments passed to loader functions
  */
@@ -468,7 +468,7 @@ interface MapRoutePropertiesFunction {
  * onto the route. Either they're meaningful to the router, or they'll get
  * ignored.
  */
-type ImmutableRouteKey = "lazy" | "caseSensitive" | "path" | "id" | "index" | "children";
+type UnsupportedLazyRouteFunctionKey = "lazy" | "caseSensitive" | "path" | "id" | "index" | "unstable_middleware" | "unstable_lazyMiddleware" | "children";
 type RequireOne<T, Key = keyof T> = Exclude<{
     [K in keyof T]: K extends Key ? Omit<T, K> & Required<Pick<T, K>> : never;
 }[keyof T], undefined>;
@@ -477,7 +477,10 @@ type RequireOne<T, Key = keyof T> = Exclude<{
  * related properties to a route
  */
 interface LazyRouteFunction<R extends AgnosticRouteObject> {
-    (): Promise<RequireOne<Omit<R, ImmutableRouteKey>>>;
+    (): Promise<RequireOne<Omit<R, UnsupportedLazyRouteFunctionKey>>>;
+}
+interface LazyMiddlewareFunction {
+    (): Promise<unstable_MiddlewareFunction[]>;
 }
 /**
  * Base RouteObject with common props shared by all types of routes
@@ -487,6 +490,7 @@ type AgnosticBaseRouteObject = {
     path?: string;
     id?: string;
     unstable_middleware?: unstable_MiddlewareFunction[];
+    unstable_lazyMiddleware?: LazyMiddlewareFunction;
     loader?: LoaderFunction | boolean;
     action?: ActionFunction | boolean;
     hasErrorBoundary?: boolean;
@@ -1251,6 +1255,7 @@ interface IndexRouteObject {
     path?: AgnosticIndexRouteObject["path"];
     id?: AgnosticIndexRouteObject["id"];
     unstable_middleware?: AgnosticIndexRouteObject["unstable_middleware"];
+    unstable_lazyMiddleware?: AgnosticIndexRouteObject["unstable_lazyMiddleware"];
     loader?: AgnosticIndexRouteObject["loader"];
     action?: AgnosticIndexRouteObject["action"];
     hasErrorBoundary?: AgnosticIndexRouteObject["hasErrorBoundary"];
@@ -1271,6 +1276,7 @@ interface NonIndexRouteObject {
     path?: AgnosticNonIndexRouteObject["path"];
     id?: AgnosticNonIndexRouteObject["id"];
     unstable_middleware?: AgnosticNonIndexRouteObject["unstable_middleware"];
+    unstable_lazyMiddleware?: AgnosticNonIndexRouteObject["unstable_lazyMiddleware"];
     loader?: AgnosticNonIndexRouteObject["loader"];
     action?: AgnosticNonIndexRouteObject["action"];
     hasErrorBoundary?: AgnosticNonIndexRouteObject["hasErrorBoundary"];

package/dist/{development/route-data-CGHGzi13.d.mts → production/route-data-BL8ToWby.d.ts}

@@ -332,7 +332,7 @@ interface unstable_MiddlewareNextFunction<Result = unknown> {
  * a `next` function as the second parameter which will call downstream handlers
  * and then complete middlewares from the bottom-up
  */
-type unstable_MiddlewareFunction<Result = unknown> = (args: DataFunctionArgs<unstable_RouterContextProvider>, next: unstable_MiddlewareNextFunction<Result>) => MaybePromise<Result | undefined>;
+type unstable_MiddlewareFunction<Result = unknown> = (args: DataFunctionArgs<unstable_RouterContextProvider>, next: unstable_MiddlewareNextFunction<Result>) => MaybePromise<Result | void>;
 /**
  * Arguments passed to loader functions
  */
@@ -468,7 +468,7 @@ interface MapRoutePropertiesFunction {
  * onto the route. Either they're meaningful to the router, or they'll get
  * ignored.
  */
-type ImmutableRouteKey = "lazy" | "caseSensitive" | "path" | "id" | "index" | "children";
+type UnsupportedLazyRouteFunctionKey = "lazy" | "caseSensitive" | "path" | "id" | "index" | "unstable_middleware" | "unstable_lazyMiddleware" | "children";
 type RequireOne<T, Key = keyof T> = Exclude<{
     [K in keyof T]: K extends Key ? Omit<T, K> & Required<Pick<T, K>> : never;
 }[keyof T], undefined>;
@@ -477,7 +477,10 @@ type RequireOne<T, Key = keyof T> = Exclude<{
  * related properties to a route
  */
 interface LazyRouteFunction<R extends AgnosticRouteObject> {
-    (): Promise<RequireOne<Omit<R, ImmutableRouteKey>>>;
+    (): Promise<RequireOne<Omit<R, UnsupportedLazyRouteFunctionKey>>>;
+}
+interface LazyMiddlewareFunction {
+    (): Promise<unstable_MiddlewareFunction[]>;
 }
 /**
  * Base RouteObject with common props shared by all types of routes
@@ -487,6 +490,7 @@ type AgnosticBaseRouteObject = {
     path?: string;
     id?: string;
     unstable_middleware?: unstable_MiddlewareFunction[];
+    unstable_lazyMiddleware?: LazyMiddlewareFunction;
     loader?: LoaderFunction | boolean;
     action?: ActionFunction | boolean;
     hasErrorBoundary?: boolean;
@@ -1251,6 +1255,7 @@ interface IndexRouteObject {
     path?: AgnosticIndexRouteObject["path"];
     id?: AgnosticIndexRouteObject["id"];
     unstable_middleware?: AgnosticIndexRouteObject["unstable_middleware"];
+    unstable_lazyMiddleware?: AgnosticIndexRouteObject["unstable_lazyMiddleware"];
     loader?: AgnosticIndexRouteObject["loader"];
     action?: AgnosticIndexRouteObject["action"];
     hasErrorBoundary?: AgnosticIndexRouteObject["hasErrorBoundary"];
@@ -1271,6 +1276,7 @@ interface NonIndexRouteObject {
     path?: AgnosticNonIndexRouteObject["path"];
     id?: AgnosticNonIndexRouteObject["id"];
     unstable_middleware?: AgnosticNonIndexRouteObject["unstable_middleware"];
+    unstable_lazyMiddleware?: AgnosticNonIndexRouteObject["unstable_lazyMiddleware"];
     loader?: AgnosticNonIndexRouteObject["loader"];
     action?: AgnosticNonIndexRouteObject["action"];
     hasErrorBoundary?: AgnosticNonIndexRouteObject["hasErrorBoundary"];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-router",
-  "version": "7.4.0",
+  "version": "7.4.1",
   "description": "Declarative routing for React",
   "keywords": [
     "react",