react-router 7.15.0 → 7.15.1

package/dist/development/{chunk-5KNZJZUH.mjs → chunk-4N6VE7H7.mjs}

@@ -1,5 +1,5 @@
 /**
- * react-router v7.15.0
+ * react-router v7.15.1
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -1323,6 +1323,8 @@ var redirectPreserveMethodStatusCodes = /* @__PURE__ */ new Set([307, 308]);
 var IDLE_NAVIGATION = {
   state: "idle",
   location: void 0,
+  matches: void 0,
+  historyAction: void 0,
   formMethod: void 0,
   formAction: void 0,
   formEncType: void 0,
@@ -1441,6 +1443,7 @@ function createRouter(init) {
   };
   let unlistenHistory = null;
   let subscribers = /* @__PURE__ */ new Set();
+  let bufferedInitialStateUpdate = null;
   let savedScrollPositions2 = null;
   let getScrollRestorationKey2 = null;
   let getScrollPosition = null;
@@ -1622,11 +1625,21 @@ function createRouter(init) {
     }
     subscribers.clear();
     pendingNavigationController && pendingNavigationController.abort();
-    state.fetchers.forEach((_, key) => deleteFetcher(key));
+    state.fetchers.forEach((_, key) => deleteFetcher(state.fetchers, key));
     state.blockers.forEach((_, key) => deleteBlocker(key));
   }
   function subscribe(fn) {
     subscribers.add(fn);
+    if (bufferedInitialStateUpdate) {
+      let { newErrors } = bufferedInitialStateUpdate;
+      bufferedInitialStateUpdate = null;
+      fn(state, {
+        deletedFetchers: [],
+        newErrors,
+        viewTransitionOpts: void 0,
+        flushSync: false
+      });
+    }
     return () => subscribers.delete(fn);
   }
   function updateState(newState, opts = {}) {
@@ -1663,6 +1676,9 @@ function createRouter(init) {
         unmountedFetchers.push(key);
       }
     });
+    if (subscribers.size === 0) {
+      bufferedInitialStateUpdate = { newErrors: newState.errors ?? null };
+    }
     [...subscribers].forEach(
       (subscriber) => subscriber(state, {
         deletedFetchers: unmountedFetchers,
@@ -1671,7 +1687,7 @@ function createRouter(init) {
         flushSync: opts.flushSync === true
       })
     );
-    unmountedFetchers.forEach((key) => deleteFetcher(key));
+    unmountedFetchers.forEach((key) => deleteFetcher(state.fetchers, key));
     mountedFetchers.forEach((key) => state.fetchers.delete(key));
   }
   function completeNavigation(location, newState, { flushSync } = {}) {
@@ -1900,7 +1916,6 @@ function createRouter(init) {
     pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;
     pendingViewTransitionEnabled = (opts && opts.enableViewTransition) === true;
     let routesToUse = dataRoutes.activeRoutes;
-    let loadingNavigation = opts && opts.overrideNavigation;
     let matches = opts?.initialHydration && state.matches && state.matches.length > 0 && !initialMatchesIsFOW ? (
       // `matchRoutes()` has already been called if we're in here via `router.initialize()`
       state.matches
@@ -1937,6 +1952,11 @@ function createRouter(init) {
       );
       return;
     }
+    let loadingNavigation = opts && opts.overrideNavigation ? {
+      ...opts.overrideNavigation,
+      matches,
+      historyAction
+    } : void 0;
     pendingNavigationController = new AbortController();
     let request = createClientSideRequest(
       init.history,
@@ -1957,6 +1977,7 @@ function createRouter(init) {
         location,
         opts.submission,
         matches,
+        historyAction,
         scopedContext,
         fogOfWar.active,
         opts && opts.initialHydration === true,
@@ -1981,7 +2002,12 @@ function createRouter(init) {
       }
       matches = actionResult.matches || matches;
       pendingActionResult = actionResult.pendingActionResult;
-      loadingNavigation = getLoadingNavigation(location, opts.submission);
+      loadingNavigation = getLoadingNavigation(
+        location,
+        matches,
+        historyAction,
+        opts.submission
+      );
       flushSync = false;
       fogOfWar.active = false;
       request = createClientSideRequest(
@@ -1994,11 +2020,13 @@ function createRouter(init) {
       shortCircuited,
       matches: updatedMatches,
       loaderData,
-      errors
+      errors,
+      workingFetchers
     } = await handleLoaders(
       request,
       location,
       matches,
+      historyAction,
       scopedContext,
       fogOfWar.active,
       loadingNavigation,
@@ -2018,12 +2046,18 @@ function createRouter(init) {
       matches: updatedMatches || matches,
       ...getActionDataForCommit(pendingActionResult),
       loaderData,
-      errors
+      errors,
+      ...workingFetchers ? { fetchers: workingFetchers } : {}
     });
   }
-  async function handleAction(request, location, submission, matches, scopedContext, isFogOfWar, initialHydration, opts = {}) {
+  async function handleAction(request, location, submission, matches, historyAction, scopedContext, isFogOfWar, initialHydration, opts = {}) {
     interruptActiveLoads();
-    let navigation = getSubmittingNavigation(location, submission);
+    let navigation = getSubmittingNavigation(
+      location,
+      matches,
+      historyAction,
+      submission
+    );
     updateState({ navigation }, { flushSync: opts.flushSync === true });
     if (isFogOfWar) {
       let discoverResult = await discoverRoutes(
@@ -2158,8 +2192,8 @@ function createRouter(init) {
       pendingActionResult: [actionMatch.route.id, result]
     };
   }
-  async function handleLoaders(request, location, matches, scopedContext, isFogOfWar, overrideNavigation, submission, fetcherSubmission, replace2, initialHydration, flushSync, pendingActionResult, callSiteDefaultShouldRevalidate) {
-    let loadingNavigation = overrideNavigation || getLoadingNavigation(location, submission);
+  async function handleLoaders(request, location, matches, historyAction, scopedContext, isFogOfWar, overrideNavigation, submission, fetcherSubmission, replace2, initialHydration, flushSync, pendingActionResult, callSiteDefaultShouldRevalidate) {
+    let loadingNavigation = overrideNavigation || getLoadingNavigation(location, matches, historyAction, submission);
     let activeSubmission = submission || fetcherSubmission || getSubmissionFromNavigation(loadingNavigation);
     let shouldUpdateNavigationState = !isUninterruptedRevalidation && !initialHydration;
     if (isFogOfWar) {
@@ -2247,7 +2281,8 @@ function createRouter(init) {
     if (!init.dataStrategy && !dsMatches.some((m) => m.shouldLoad) && !dsMatches.some(
       (m) => m.route.middleware && m.route.middleware.length > 0
     ) && revalidatingFetchers.length === 0) {
-      let updatedFetchers2 = markFetchRedirectsDone();
+      let workingFetchers2 = new Map(state.fetchers);
+      let didUpdateFetcherRedirects2 = markFetchRedirectsDone(workingFetchers2);
       completeNavigation(
         location,
         {
@@ -2256,7 +2291,7 @@ function createRouter(init) {
           // Commit pending error if we're short circuiting
           errors: pendingActionResult && isErrorResult(pendingActionResult[1]) ? { [pendingActionResult[0]]: pendingActionResult[1].error } : null,
           ...getActionDataForCommit(pendingActionResult),
-          ...updatedFetchers2 ? { fetchers: new Map(state.fetchers) } : {}
+          ...didUpdateFetcherRedirects2 ? { fetchers: workingFetchers2 } : {}
         },
         { flushSync }
       );
@@ -2321,25 +2356,30 @@ function createRouter(init) {
       });
       return { shortCircuited: true };
     }
+    let workingFetchers = new Map(state.fetchers);
     let { loaderData, errors } = processLoaderData(
       state,
       matches,
       loaderResults,
       pendingActionResult,
       revalidatingFetchers,
-      fetcherResults
+      fetcherResults,
+      workingFetchers
     );
     if (initialHydration && state.errors) {
       errors = { ...state.errors, ...errors };
     }
-    let updatedFetchers = markFetchRedirectsDone();
-    let didAbortFetchLoads = abortStaleFetchLoads(pendingNavigationLoadId);
-    let shouldUpdateFetchers = updatedFetchers || didAbortFetchLoads || revalidatingFetchers.length > 0;
+    let didUpdateFetcherRedirects = markFetchRedirectsDone(workingFetchers);
+    let didAbortFetchLoads = abortStaleFetchLoads(
+      pendingNavigationLoadId,
+      workingFetchers
+    );
+    let shouldUpdateFetchers = didUpdateFetcherRedirects || didAbortFetchLoads || revalidatingFetchers.length > 0;
     return {
       matches,
       loaderData,
       errors,
-      ...shouldUpdateFetchers ? { fetchers: new Map(state.fetchers) } : {}
+      ...shouldUpdateFetchers ? { workingFetchers } : {}
     };
   }
   function getUpdatedActionData(pendingActionResult) {
@@ -2356,15 +2396,16 @@ function createRouter(init) {
     }
   }
   function getUpdatedRevalidatingFetchers(revalidatingFetchers) {
+    let workingFetchers = new Map(state.fetchers);
     revalidatingFetchers.forEach((rf) => {
-      let fetcher = state.fetchers.get(rf.key);
+      let fetcher = workingFetchers.get(rf.key);
       let revalidatingFetcher = getLoadingFetcher(
         void 0,
         fetcher ? fetcher.data : void 0
       );
-      state.fetchers.set(rf.key, revalidatingFetcher);
+      workingFetchers.set(rf.key, revalidatingFetcher);
     });
-    return new Map(state.fetchers);
+    return workingFetchers;
   }
   async function fetch2(key, routeId, href, opts) {
     abortFetcher(key);
@@ -2561,8 +2602,6 @@ function createRouter(init) {
     invariant(matches, "Didn't find any matches after fetcher action");
     let loadId = ++incrementingLoadId;
     fetchReloadIds.set(key, loadId);
-    let loadFetcher = getLoadingFetcher(submission, actionResult.data);
-    state.fetchers.set(key, loadFetcher);
     let { dsMatches, revalidatingFetchers } = getMatchesToLoad(
       revalidationRequest,
       scopedContext,
@@ -2587,20 +2626,23 @@ function createRouter(init) {
       [match.route.id, actionResult],
       callSiteDefaultShouldRevalidate
     );
+    let loadFetcher = getLoadingFetcher(submission, actionResult.data);
+    let workingFetchers = new Map(state.fetchers);
+    workingFetchers.set(key, loadFetcher);
     revalidatingFetchers.filter((rf) => rf.key !== key).forEach((rf) => {
       let staleKey = rf.key;
-      let existingFetcher2 = state.fetchers.get(staleKey);
+      let existingFetcher2 = workingFetchers.get(staleKey);
       let revalidatingFetcher = getLoadingFetcher(
         void 0,
         existingFetcher2 ? existingFetcher2.data : void 0
       );
-      state.fetchers.set(staleKey, revalidatingFetcher);
+      workingFetchers.set(staleKey, revalidatingFetcher);
       abortFetcher(staleKey);
       if (rf.controller) {
         fetchControllers.set(staleKey, rf.controller);
       }
     });
-    updateState({ fetchers: new Map(state.fetchers) });
+    updateState({ fetchers: workingFetchers });
     let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach((rf) => abortFetcher(rf.key));
     abortController.signal.addEventListener(
       "abort",
@@ -2623,12 +2665,16 @@ function createRouter(init) {
     fetchReloadIds.delete(key);
     fetchControllers.delete(key);
     revalidatingFetchers.forEach((r) => fetchControllers.delete(r.key));
-    if (state.fetchers.has(key)) {
-      let doneFetcher = getDoneFetcher(actionResult.data);
-      state.fetchers.set(key, doneFetcher);
-    }
+    let fetcherIsMounted = state.fetchers.has(key);
+    let getRedirectStateWithDoneFetcher = (s) => {
+      if (!fetcherIsMounted) return s;
+      let workingFetchers2 = new Map(s.fetchers);
+      workingFetchers2.set(key, getDoneFetcher(actionResult.data));
+      return { ...s, fetchers: workingFetchers2 };
+    };
     let redirect2 = findRedirect(loaderResults);
     if (redirect2) {
+      state = getRedirectStateWithDoneFetcher(state);
       return startRedirectNavigation(
         revalidationRequest,
         redirect2.result,
@@ -2639,6 +2685,7 @@ function createRouter(init) {
     redirect2 = findRedirect(fetcherResults);
     if (redirect2) {
       fetchRedirectIds.add(redirect2.key);
+      state = getRedirectStateWithDoneFetcher(state);
       return startRedirectNavigation(
         revalidationRequest,
         redirect2.result,
@@ -2646,15 +2693,20 @@ function createRouter(init) {
         { preventScrollReset }
       );
     }
+    let finalFetchers = new Map(state.fetchers);
+    if (fetcherIsMounted) {
+      finalFetchers.set(key, getDoneFetcher(actionResult.data));
+    }
     let { loaderData, errors } = processLoaderData(
       state,
       matches,
       loaderResults,
       void 0,
       revalidatingFetchers,
-      fetcherResults
+      fetcherResults,
+      finalFetchers
     );
-    abortStaleFetchLoads(loadId);
+    abortStaleFetchLoads(loadId, finalFetchers);
     if (state.navigation.state === "loading" && loadId > pendingNavigationLoadId) {
       invariant(pendingAction, "Expected pending action");
       pendingNavigationController && pendingNavigationController.abort();
@@ -2662,7 +2714,7 @@ function createRouter(init) {
         matches,
         loaderData,
         errors,
-        fetchers: new Map(state.fetchers)
+        fetchers: finalFetchers
       });
     } else {
       updateState({
@@ -2673,7 +2725,7 @@ function createRouter(init) {
           matches,
           errors
         ),
-        fetchers: new Map(state.fetchers)
+        fetchers: finalFetchers
       });
       isRevalidationRequired = false;
     }
@@ -2838,6 +2890,8 @@ function createRouter(init) {
     } else {
       let overrideNavigation = getLoadingNavigation(
         redirectLocation,
+        [],
+        redirectNavigationType,
         submission
       );
       await startNavigation(redirectNavigationType, redirectLocation, {
@@ -2961,21 +3015,23 @@ function createRouter(init) {
     });
   }
   function updateFetcherState(key, fetcher, opts = {}) {
-    state.fetchers.set(key, fetcher);
+    let workingFetchers = new Map(state.fetchers);
+    workingFetchers.set(key, fetcher);
     updateState(
-      { fetchers: new Map(state.fetchers) },
+      { fetchers: workingFetchers },
       { flushSync: (opts && opts.flushSync) === true }
     );
   }
   function setFetcherError(key, routeId, error, opts = {}) {
     let boundaryMatch = findNearestBoundary(state.matches, routeId);
-    deleteFetcher(key);
+    let workingFetchers = new Map(state.fetchers);
+    deleteFetcher(workingFetchers, key);
     updateState(
       {
         errors: {
           [boundaryMatch.route.id]: error
         },
-        fetchers: new Map(state.fetchers)
+        fetchers: workingFetchers
       },
       { flushSync: (opts && opts.flushSync) === true }
     );
@@ -2991,7 +3047,7 @@ function createRouter(init) {
     abortFetcher(key, opts?.reason);
     updateFetcherState(key, getDoneFetcher(null));
   }
-  function deleteFetcher(key) {
+  function deleteFetcher(fetchers, key) {
     let fetcher = state.fetchers.get(key);
     if (fetchControllers.has(key) && !(fetcher && fetcher.state === "loading" && fetchReloadIds.has(key))) {
       abortFetcher(key);
@@ -3001,7 +3057,7 @@ function createRouter(init) {
     fetchRedirectIds.delete(key);
     fetchersQueuedForDeletion.delete(key);
     cancelledFetcherLoads.delete(key);
-    state.fetchers.delete(key);
+    fetchers.delete(key);
   }
   function queueFetcherForDeletion(key) {
     let count = (activeFetchers.get(key) || 0) - 1;
@@ -3020,33 +3076,34 @@ function createRouter(init) {
       fetchControllers.delete(key);
     }
   }
-  function markFetchersDone(keys) {
+  function markFetchersDone(keys, fetchers) {
     for (let key of keys) {
-      let fetcher = getFetcher(key);
+      let fetcher = fetchers.get(key);
+      invariant(fetcher, `Expected fetcher: ${key}`);
       let doneFetcher = getDoneFetcher(fetcher.data);
-      state.fetchers.set(key, doneFetcher);
+      fetchers.set(key, doneFetcher);
     }
   }
-  function markFetchRedirectsDone() {
+  function markFetchRedirectsDone(fetchers) {
     let doneKeys = [];
-    let updatedFetchers = false;
+    let didUpdateFetchers = false;
     for (let key of fetchRedirectIds) {
-      let fetcher = state.fetchers.get(key);
+      let fetcher = fetchers.get(key);
       invariant(fetcher, `Expected fetcher: ${key}`);
       if (fetcher.state === "loading") {
         fetchRedirectIds.delete(key);
         doneKeys.push(key);
-        updatedFetchers = true;
+        didUpdateFetchers = true;
       }
     }
-    markFetchersDone(doneKeys);
-    return updatedFetchers;
+    markFetchersDone(doneKeys, fetchers);
+    return didUpdateFetchers;
   }
-  function abortStaleFetchLoads(landedId) {
+  function abortStaleFetchLoads(landedId, fetchers) {
     let yeetedKeys = [];
     for (let [key, id] of fetchReloadIds) {
       if (id < landedId) {
-        let fetcher = state.fetchers.get(key);
+        let fetcher = fetchers.get(key);
         invariant(fetcher, `Expected fetcher: ${key}`);
         if (fetcher.state === "loading") {
           abortFetcher(key);
@@ -3055,7 +3112,7 @@ function createRouter(init) {
         }
       }
     }
-    markFetchersDone(yeetedKeys);
+    markFetchersDone(yeetedKeys, fetchers);
     return yeetedKeys.length > 0;
   }
   function getBlocker(key, fn) {
@@ -5283,7 +5340,7 @@ function processRouteLoaderData(matches, results, pendingActionResult, isStaticH
     loaderHeaders
   };
 }
-function processLoaderData(state, matches, results, pendingActionResult, revalidatingFetchers, fetcherResults) {
+function processLoaderData(state, matches, results, pendingActionResult, revalidatingFetchers, fetcherResults, workingFetchers) {
   let { loaderData, errors } = processRouteLoaderData(
     matches,
     results,
@@ -5304,12 +5361,12 @@ function processLoaderData(state, matches, results, pendingActionResult, revalid
           [boundaryMatch.route.id]: result.error
         };
       }
-      state.fetchers.delete(key);
+      workingFetchers.delete(key);
     } else if (isRedirectResult(result)) {
       invariant(false, "Unhandled fetcher revalidation redirect");
     } else {
       let doneFetcher = getDoneFetcher(result.data);
-      state.fetchers.set(key, doneFetcher);
+      workingFetchers.set(key, doneFetcher);
     }
   });
   return { loaderData, errors };
@@ -5516,11 +5573,13 @@ function getSubmissionFromNavigation(navigation) {
     };
   }
 }
-function getLoadingNavigation(location, submission) {
+function getLoadingNavigation(location, matches, historyAction, submission) {
   if (submission) {
     let navigation = {
       state: "loading",
       location,
+      matches,
+      historyAction,
       formMethod: submission.formMethod,
       formAction: submission.formAction,
       formEncType: submission.formEncType,
@@ -5533,6 +5592,8 @@ function getLoadingNavigation(location, submission) {
     let navigation = {
       state: "loading",
       location,
+      matches,
+      historyAction,
       formMethod: void 0,
       formAction: void 0,
       formEncType: void 0,
@@ -5543,10 +5604,12 @@ function getLoadingNavigation(location, submission) {
     return navigation;
   }
 }
-function getSubmittingNavigation(location, submission) {
+function getSubmittingNavigation(location, matches, historyAction, submission) {
   let navigation = {
     state: "submitting",
     location,
+    matches,
+    historyAction,
     formMethod: submission.formMethod,
     formAction: submission.formAction,
     formEncType: submission.formEncType,
@@ -6279,7 +6342,10 @@ function useRouteId() {
 }
 function useNavigation() {
   let state = useDataRouterState("useNavigation" /* UseNavigation */);
-  return state.navigation;
+  return React2.useMemo(() => {
+    let { matches, historyAction, ...rest } = state.navigation;
+    return rest;
+  }, [state.navigation]);
 }
 function useRevalidator() {
   let dataRouterContext = useDataRouterContext("useRevalidator" /* UseRevalidator */);
@@ -6414,6 +6480,65 @@ function useRoute(...args) {
     actionData: state.actionData?.[id]
   };
 }
+function toRouterStateMatch(match) {
+  return {
+    id: match.route.id,
+    pathname: match.pathname,
+    params: match.params,
+    handle: match.route.handle
+  };
+}
+function useRouterState() {
+  let {
+    location,
+    historyAction: type,
+    matches,
+    navigation
+  } = useDataRouterState("unstable_useRouterState" /* UseRouterState */);
+  let active = React2.useMemo(
+    () => ({
+      type,
+      location,
+      searchParams: new URLSearchParams(location.search),
+      params: matches[matches.length - 1]?.params ?? {},
+      matches: matches.map((m) => toRouterStateMatch(m))
+    }),
+    [location, matches, type]
+  );
+  let pending = React2.useMemo(() => {
+    if (navigation.state === "idle") return null;
+    let shared = {
+      type: navigation.historyAction,
+      location: navigation.location,
+      searchParams: new URLSearchParams(navigation.location.search),
+      params: navigation.matches[navigation.matches.length - 1]?.params ?? {},
+      matches: navigation.matches.map((m) => toRouterStateMatch(m))
+    };
+    return navigation.state === "loading" ? {
+      ...shared,
+      state: "loading",
+      formMethod: navigation.formMethod,
+      formAction: navigation.formAction,
+      formEncType: navigation.formEncType,
+      formData: navigation.formData,
+      json: navigation.json,
+      text: navigation.text
+    } : {
+      ...shared,
+      state: "submitting",
+      formMethod: navigation.formMethod,
+      formAction: navigation.formAction,
+      formEncType: navigation.formEncType,
+      formData: navigation.formData,
+      json: navigation.json,
+      text: navigation.text
+    };
+  }, [navigation]);
+  return React2.useMemo(
+    () => ({ active, pending }),
+    [active, pending]
+  );
+}
 
 // lib/components.tsx
 import * as React3 from "react";
@@ -6644,16 +6769,6 @@ function RouterProvider({
     ]
   );
   React3.useLayoutEffect(() => router.subscribe(setState), [router, setState]);
-  let initialized = state.initialized;
-  React3.useLayoutEffect(() => {
-    if (!initialized && router.state.initialized) {
-      setState(router.state, {
-        deletedFetchers: [],
-        flushSync: false,
-        newErrors: null
-      });
-    }
-  }, [initialized, setState, router.state]);
   React3.useEffect(() => {
     if (vtContext.isTransitioning && !vtContext.flushSync) {
       setRenderDfd(new Deferred());
@@ -8971,39 +9086,37 @@ function createClientRoutes(manifest, routeModulesCache, initialState, ssr, isSp
       let initialError = hasInitialError ? initialState?.errors?.[route.id] : void 0;
       let isHydrationRequest = needsRevalidation == null && (routeModule.clientLoader?.hydrate === true || !route.hasLoader);
       dataRoute.loader = async ({ request, params, context, pattern, url }, singleFetch) => {
-        try {
-          let result = await prefetchStylesAndCallHandler(async () => {
-            invariant2(
-              routeModule,
-              "No `routeModule` available for critical-route loader"
-            );
-            if (!routeModule.clientLoader) {
-              return fetchServerLoader(singleFetch);
-            }
-            return routeModule.clientLoader({
-              request,
-              params,
-              context,
-              pattern,
-              url,
-              async serverLoader() {
-                preventInvalidServerHandlerCall("loader", route);
-                if (isHydrationRequest) {
-                  if (hasInitialData) {
-                    return initialData;
-                  }
-                  if (hasInitialError) {
-                    throw initialError;
-                  }
+        let _isHydrationRequest = isHydrationRequest;
+        isHydrationRequest = false;
+        let result = await prefetchStylesAndCallHandler(async () => {
+          invariant2(
+            routeModule,
+            "No `routeModule` available for critical-route loader"
+          );
+          if (!routeModule.clientLoader) {
+            return fetchServerLoader(singleFetch);
+          }
+          return routeModule.clientLoader({
+            request,
+            params,
+            context,
+            pattern,
+            url,
+            async serverLoader() {
+              preventInvalidServerHandlerCall("loader", route);
+              if (_isHydrationRequest) {
+                if (hasInitialData) {
+                  return initialData;
+                }
+                if (hasInitialError) {
+                  throw initialError;
                 }
-                return fetchServerLoader(singleFetch);
               }
-            });
+              return fetchServerLoader(singleFetch);
+            }
           });
-          return result;
-        } finally {
-          isHydrationRequest = false;
-        }
+        });
+        return result;
       };
       dataRoute.loader.hydrate = shouldHydrateRouteLoader(
         route.id,
@@ -9828,7 +9941,7 @@ function Meta() {
             dangerouslySetInnerHTML: { __html: escapeHtml(json) }
           }
         );
-      } catch (err) {
+      } catch (e) {
         return null;
       }
     }
@@ -9944,13 +10057,16 @@ import(${JSON.stringify(manifest.entry.module)});`;
       }
     ));
   }, []);
-  let preloads = isHydrated || isRSCRouterContext ? [] : dedupe(
-    manifest.entry.imports.concat(
-      getModuleLinkHrefs(matches, manifest, {
-        includeHydrateFallback: true
-      })
+  let preloads = isHydrated || isRSCRouterContext ? [] : [
+    // Dedupe through a Set
+    ...new Set(
+      manifest.entry.imports.concat(
+        getModuleLinkHrefs(matches, manifest, {
+          includeHydrateFallback: true
+        })
+      )
     )
-  );
+  ];
   let sri = typeof manifest.sri === "object" ? manifest.sri : {};
   warnOnce(
     !isRSCRouterContext,
@@ -10002,9 +10118,6 @@ import(${JSON.stringify(manifest.entry.module)});`;
     }
   )), initialScripts);
 }
-function dedupe(array) {
-  return [...new Set(array)];
-}
 function mergeRefs(...refs) {
   return (value) => {
     refs.forEach((ref) => {
@@ -10120,7 +10233,7 @@ var isBrowser2 = typeof window !== "undefined" && typeof window.document !== "un
 try {
   if (isBrowser2) {
     window.__reactRouterVersion = // @ts-expect-error
-    "7.15.0";
+    "7.15.1";
   }
 } catch (e) {
 }
@@ -10814,10 +10927,13 @@ function useFetcher({
 }
 function useFetchers() {
   let state = useDataRouterState2("useFetchers" /* UseFetchers */);
-  return Array.from(state.fetchers.entries()).map(([key, fetcher]) => ({
-    ...fetcher,
-    key
-  }));
+  return React10.useMemo(
+    () => Array.from(state.fetchers.entries()).map(([key, fetcher]) => ({
+      ...fetcher,
+      key
+    })),
+    [state.fetchers]
+  );
 }
 var SCROLL_RESTORATION_STORAGE_KEY = "react-router-scroll-positions";
 var savedScrollPositions = {};
@@ -11334,6 +11450,7 @@ export {
   useAsyncError,
   useBlocker,
   useRoute,
+  useRouterState,
   warnOnce,
   mapRouteProperties,
   hydrationRouteProperties,