react-router 7.5.0 → 7.5.1

package/dist/production/dom-export.js

@@ -1,5 +1,5 @@
 /**
- * react-router v7.5.0
+ * react-router v7.5.1
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -803,6 +803,7 @@ function createRouter(init) {
     init.routes.length > 0,
     "You must provide a non-empty routes array to createRouter"
   );
+  let hydrationRouteProperties2 = init.hydrationRouteProperties || [];
   let mapRouteProperties2 = init.mapRouteProperties || defaultMapRouteProperties;
   let manifest = {};
   let dataRoutes = convertRoutesToDataRoutes(
@@ -1275,6 +1276,7 @@ function createRouter(init) {
         matches,
         scopedContext,
         fogOfWar.active,
+        opts && opts.initialHydration === true,
         { replace: opts.replace, flushSync: flushSync2 }
       );
       if (actionResult.shortCircuited) {
@@ -1335,7 +1337,7 @@ function createRouter(init) {
       errors
     });
   }
-  async function handleAction(request, location, submission, matches, scopedContext, isFogOfWar, opts = {}) {
+  async function handleAction(request, location, submission, matches, scopedContext, isFogOfWar, initialHydration, opts = {}) {
     interruptActiveLoads();
     let navigation = getSubmittingNavigation(location, submission);
     updateState({ navigation }, { flushSync: opts.flushSync === true });
@@ -1389,11 +1391,18 @@ function createRouter(init) {
         })
       };
     } else {
-      let results = await callDataStrategy(
-        "action",
+      let dsMatches = getTargetedDataStrategyMatches(
+        mapRouteProperties2,
+        manifest,
         request,
-        [actionMatch],
         matches,
+        actionMatch,
+        initialHydration ? [] : hydrationRouteProperties2,
+        scopedContext
+      );
+      let results = await callDataStrategy(
+        request,
+        dsMatches,
         scopedContext,
         null
       );
@@ -1492,12 +1501,17 @@ function createRouter(init) {
       }
     }
     let routesToUse = inFlightDataRoutes || dataRoutes;
-    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(
+    let { dsMatches, revalidatingFetchers } = getMatchesToLoad(
+      request,
+      scopedContext,
+      mapRouteProperties2,
+      manifest,
       init.history,
       state,
       matches,
       activeSubmission,
       location,
+      initialHydration ? [] : hydrationRouteProperties2,
       initialHydration === true,
       isRevalidationRequired,
       cancelledFetcherLoads,
@@ -1509,7 +1523,7 @@ function createRouter(init) {
       pendingActionResult
     );
     pendingNavigationLoadId = ++incrementingLoadId;
-    if (matchesToLoad.length === 0 && revalidatingFetchers.length === 0) {
+    if (!init.dataStrategy && !dsMatches.some((m) => m.shouldLoad) && revalidatingFetchers.length === 0) {
       let updatedFetchers2 = markFetchRedirectsDone();
       completeNavigation(
         location,
@@ -1553,8 +1567,7 @@ function createRouter(init) {
       );
     }
     let { loaderResults, fetcherResults } = await callLoadersAndMaybeResolveData(
-      matches,
-      matchesToLoad,
+      dsMatches,
       revalidatingFetchers,
       request,
       scopedContext
@@ -1757,11 +1770,18 @@ function createRouter(init) {
     }
     fetchControllers.set(key, abortController);
     let originatingLoadId = incrementingLoadId;
-    let actionResults = await callDataStrategy(
-      "action",
+    let fetchMatches = getTargetedDataStrategyMatches(
+      mapRouteProperties2,
+      manifest,
       fetchRequest,
-      [match],
       requestMatches,
+      match,
+      hydrationRouteProperties2,
+      scopedContext
+    );
+    let actionResults = await callDataStrategy(
+      fetchRequest,
+      fetchMatches,
       scopedContext,
       key
     );
@@ -1810,12 +1830,17 @@ function createRouter(init) {
     fetchReloadIds.set(key, loadId);
     let loadFetcher = getLoadingFetcher(submission, actionResult.data);
     state.fetchers.set(key, loadFetcher);
-    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(
+    let { dsMatches, revalidatingFetchers } = getMatchesToLoad(
+      revalidationRequest,
+      scopedContext,
+      mapRouteProperties2,
+      manifest,
       init.history,
       state,
       matches,
       submission,
       nextLocation,
+      hydrationRouteProperties2,
       false,
       isRevalidationRequired,
       cancelledFetcherLoads,
@@ -1846,8 +1871,7 @@ function createRouter(init) {
       abortPendingFetchRevalidations
     );
     let { loaderResults, fetcherResults } = await callLoadersAndMaybeResolveData(
-      matches,
-      matchesToLoad,
+      dsMatches,
       revalidatingFetchers,
       revalidationRequest,
       scopedContext
@@ -1960,11 +1984,18 @@ function createRouter(init) {
     }
     fetchControllers.set(key, abortController);
     let originatingLoadId = incrementingLoadId;
-    let results = await callDataStrategy(
-      "loader",
+    let dsMatches = getTargetedDataStrategyMatches(
+      mapRouteProperties2,
+      manifest,
       fetchRequest,
-      [match],
       matches,
+      match,
+      hydrationRouteProperties2,
+      scopedContext
+    );
+    let results = await callDataStrategy(
+      fetchRequest,
+      dsMatches,
       scopedContext,
       key
     );
@@ -2067,23 +2098,20 @@ function createRouter(init) {
       });
     }
   }
-  async function callDataStrategy(type, request, matchesToLoad, matches, scopedContext, fetcherKey) {
+  async function callDataStrategy(request, matches, scopedContext, fetcherKey) {
     let results;
     let dataResults = {};
     try {
       results = await callDataStrategyImpl(
         dataStrategyImpl,
-        type,
         request,
-        matchesToLoad,
         matches,
         fetcherKey,
-        manifest,
-        mapRouteProperties2,
-        scopedContext
+        scopedContext,
+        false
       );
     } catch (e) {
-      matchesToLoad.forEach((m) => {
+      matches.filter((m) => m.shouldLoad).forEach((m) => {
         dataResults[m.route.id] = {
           type: "error" /* error */,
           error: e
@@ -2112,22 +2140,18 @@ function createRouter(init) {
     }
     return dataResults;
   }
-  async function callLoadersAndMaybeResolveData(matches, matchesToLoad, fetchersToLoad, request, scopedContext) {
+  async function callLoadersAndMaybeResolveData(matches, fetchersToLoad, request, scopedContext) {
     let loaderResultsPromise = callDataStrategy(
-      "loader",
       request,
-      matchesToLoad,
       matches,
       scopedContext,
       null
     );
     let fetcherResultsPromise = Promise.all(
       fetchersToLoad.map(async (f) => {
-        if (f.matches && f.match && f.controller) {
+        if (f.matches && f.match && f.request && f.controller) {
           let results = await callDataStrategy(
-            "loader",
-            createClientSideRequest(init.history, f.path, f.controller.signal),
-            [f.match],
+            f.request,
             f.matches,
             scopedContext,
             f.key
@@ -2645,62 +2669,78 @@ function normalizeNavigateOptions(isFetcher, path, opts) {
   parsedPath.search = `?${searchParams}`;
   return { path: createPath(parsedPath), submission };
 }
-function getLoaderMatchesUntilBoundary(matches, boundaryId, includeBoundary = false) {
-  let index = matches.findIndex((m) => m.route.id === boundaryId);
-  if (index >= 0) {
-    return matches.slice(0, includeBoundary ? index + 1 : index);
-  }
-  return matches;
-}
-function getMatchesToLoad(history, state, matches, submission, location, initialHydration, isRevalidationRequired, cancelledFetcherLoads, fetchersQueuedForDeletion, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, pendingActionResult) {
+function getMatchesToLoad(request, scopedContext, mapRouteProperties2, manifest, history, state, matches, submission, location, lazyRoutePropertiesToSkip, initialHydration, isRevalidationRequired, cancelledFetcherLoads, fetchersQueuedForDeletion, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, pendingActionResult) {
   let actionResult = pendingActionResult ? isErrorResult(pendingActionResult[1]) ? pendingActionResult[1].error : pendingActionResult[1].data : void 0;
   let currentUrl = history.createURL(state.location);
   let nextUrl = history.createURL(location);
-  let boundaryMatches = matches;
+  let maxIdx;
   if (initialHydration && state.errors) {
-    boundaryMatches = getLoaderMatchesUntilBoundary(
-      matches,
-      Object.keys(state.errors)[0],
-      true
-    );
+    let boundaryId = Object.keys(state.errors)[0];
+    maxIdx = matches.findIndex((m) => m.route.id === boundaryId);
   } else if (pendingActionResult && isErrorResult(pendingActionResult[1])) {
-    boundaryMatches = getLoaderMatchesUntilBoundary(
-      matches,
-      pendingActionResult[0]
-    );
+    let boundaryId = pendingActionResult[0];
+    maxIdx = matches.findIndex((m) => m.route.id === boundaryId) - 1;
   }
   let actionStatus = pendingActionResult ? pendingActionResult[1].statusCode : void 0;
   let shouldSkipRevalidation = actionStatus && actionStatus >= 400;
-  let navigationMatches = boundaryMatches.filter((match, index) => {
+  let baseShouldRevalidateArgs = {
+    currentUrl,
+    currentParams: state.matches[0]?.params || {},
+    nextUrl,
+    nextParams: matches[0].params,
+    ...submission,
+    actionResult,
+    actionStatus
+  };
+  let dsMatches = matches.map((match, index) => {
     let { route } = match;
-    if (route.lazy) {
-      return true;
+    let forceShouldLoad = null;
+    if (maxIdx != null && index > maxIdx) {
+      forceShouldLoad = false;
+    } else if (route.lazy) {
+      forceShouldLoad = true;
+    } else if (route.loader == null) {
+      forceShouldLoad = false;
+    } else if (initialHydration) {
+      forceShouldLoad = shouldLoadRouteOnHydration(
+        route,
+        state.loaderData,
+        state.errors
+      );
+    } else if (isNewLoader(state.loaderData, state.matches[index], match)) {
+      forceShouldLoad = true;
     }
-    if (route.loader == null) {
-      return false;
+    if (forceShouldLoad !== null) {
+      return getDataStrategyMatch(
+        mapRouteProperties2,
+        manifest,
+        request,
+        match,
+        lazyRoutePropertiesToSkip,
+        scopedContext,
+        forceShouldLoad
+      );
     }
-    if (initialHydration) {
-      return shouldLoadRouteOnHydration(route, state.loaderData, state.errors);
-    }
-    if (isNewLoader(state.loaderData, state.matches[index], match)) {
-      return true;
-    }
-    let currentRouteMatch = state.matches[index];
-    let nextRouteMatch = match;
-    return shouldRevalidateLoader(match, {
-      currentUrl,
-      currentParams: currentRouteMatch.params,
-      nextUrl,
-      nextParams: nextRouteMatch.params,
-      ...submission,
-      actionResult,
-      actionStatus,
-      defaultShouldRevalidate: shouldSkipRevalidation ? false : (
-        // Forced revalidation due to submission, useRevalidator, or X-Remix-Revalidate
-        isRevalidationRequired || currentUrl.pathname + currentUrl.search === nextUrl.pathname + nextUrl.search || // Search params affect all loaders
-        currentUrl.search !== nextUrl.search || isNewRouteInstance(currentRouteMatch, nextRouteMatch)
-      )
-    });
+    let defaultShouldRevalidate = shouldSkipRevalidation ? false : (
+      // Forced revalidation due to submission, useRevalidator, or X-Remix-Revalidate
+      isRevalidationRequired || currentUrl.pathname + currentUrl.search === nextUrl.pathname + nextUrl.search || // Search params affect all loaders
+      currentUrl.search !== nextUrl.search || isNewRouteInstance(state.matches[index], match)
+    );
+    let shouldRevalidateArgs = {
+      ...baseShouldRevalidateArgs,
+      defaultShouldRevalidate
+    };
+    let shouldLoad = shouldRevalidateLoader(match, shouldRevalidateArgs);
+    return getDataStrategyMatch(
+      mapRouteProperties2,
+      manifest,
+      request,
+      match,
+      lazyRoutePropertiesToSkip,
+      scopedContext,
+      shouldLoad,
+      shouldRevalidateArgs
+    );
   });
   let revalidatingFetchers = [];
   fetchLoadMatches.forEach((f, key) => {
@@ -2715,44 +2755,77 @@ function getMatchesToLoad(history, state, matches, submission, location, initial
         path: f.path,
         matches: null,
         match: null,
+        request: null,
         controller: null
       });
       return;
     }
+    if (fetchRedirectIds.has(key)) {
+      return;
+    }
     let fetcher = state.fetchers.get(key);
     let fetcherMatch = getTargetMatch(fetcherMatches, f.path);
-    let shouldRevalidate = false;
-    if (fetchRedirectIds.has(key)) {
-      shouldRevalidate = false;
-    } else if (cancelledFetcherLoads.has(key)) {
+    let fetchController = new AbortController();
+    let fetchRequest = createClientSideRequest(
+      history,
+      f.path,
+      fetchController.signal
+    );
+    let fetcherDsMatches = null;
+    if (cancelledFetcherLoads.has(key)) {
       cancelledFetcherLoads.delete(key);
-      shouldRevalidate = true;
+      fetcherDsMatches = getTargetedDataStrategyMatches(
+        mapRouteProperties2,
+        manifest,
+        fetchRequest,
+        fetcherMatches,
+        fetcherMatch,
+        lazyRoutePropertiesToSkip,
+        scopedContext
+      );
     } else if (fetcher && fetcher.state !== "idle" && fetcher.data === void 0) {
-      shouldRevalidate = isRevalidationRequired;
+      if (isRevalidationRequired) {
+        fetcherDsMatches = getTargetedDataStrategyMatches(
+          mapRouteProperties2,
+          manifest,
+          fetchRequest,
+          fetcherMatches,
+          fetcherMatch,
+          lazyRoutePropertiesToSkip,
+          scopedContext
+        );
+      }
     } else {
-      shouldRevalidate = shouldRevalidateLoader(fetcherMatch, {
-        currentUrl,
-        currentParams: state.matches[state.matches.length - 1].params,
-        nextUrl,
-        nextParams: matches[matches.length - 1].params,
-        ...submission,
-        actionResult,
-        actionStatus,
+      let shouldRevalidateArgs = {
+        ...baseShouldRevalidateArgs,
         defaultShouldRevalidate: shouldSkipRevalidation ? false : isRevalidationRequired
-      });
+      };
+      if (shouldRevalidateLoader(fetcherMatch, shouldRevalidateArgs)) {
+        fetcherDsMatches = getTargetedDataStrategyMatches(
+          mapRouteProperties2,
+          manifest,
+          fetchRequest,
+          fetcherMatches,
+          fetcherMatch,
+          lazyRoutePropertiesToSkip,
+          scopedContext,
+          shouldRevalidateArgs
+        );
+      }
     }
-    if (shouldRevalidate) {
+    if (fetcherDsMatches) {
       revalidatingFetchers.push({
         key,
         routeId: f.routeId,
         path: f.path,
-        matches: fetcherMatches,
+        matches: fetcherDsMatches,
         match: fetcherMatch,
-        controller: new AbortController()
+        request: fetchRequest,
+        controller: fetchController
       });
     }
   });
-  return [navigationMatches, revalidatingFetchers];
+  return { dsMatches, revalidatingFetchers };
 }
 function shouldLoadRouteOnHydration(route, loaderData, errors) {
   if (route.lazy) {
@@ -2898,7 +2971,7 @@ var loadLazyRouteProperty = ({
   return propertyPromise;
 };
 var lazyRouteFunctionCache = /* @__PURE__ */ new WeakMap();
-function loadLazyRoute(route, type, manifest, mapRouteProperties2) {
+function loadLazyRoute(route, type, manifest, mapRouteProperties2, lazyRoutePropertiesToSkip) {
   let routeToUpdate = manifest[route.id];
   invariant(routeToUpdate, "No route found in manifest");
   if (!route.lazy) {
@@ -2956,6 +3029,8 @@ function loadLazyRoute(route, type, manifest, mapRouteProperties2) {
       });
     })();
     lazyRouteFunctionCache.set(routeToUpdate, lazyRoutePromise2);
+    lazyRoutePromise2.catch(() => {
+    });
     return {
       lazyRoutePromise: lazyRoutePromise2,
       lazyHandlerPromise: lazyRoutePromise2
@@ -2965,6 +3040,9 @@ function loadLazyRoute(route, type, manifest, mapRouteProperties2) {
   let lazyPropertyPromises = [];
   let lazyHandlerPromise = void 0;
   for (let key of lazyKeys) {
+    if (lazyRoutePropertiesToSkip && lazyRoutePropertiesToSkip.includes(key)) {
+      continue;
+    }
     let promise = loadLazyRouteProperty({
       key,
       route,
@@ -2978,30 +3056,17 @@ function loadLazyRoute(route, type, manifest, mapRouteProperties2) {
       }
     }
   }
-  let lazyRoutePromise = Promise.all(lazyPropertyPromises).then(() => {
+  let lazyRoutePromise = lazyPropertyPromises.length > 0 ? Promise.all(lazyPropertyPromises).then(() => {
+  }) : void 0;
+  lazyRoutePromise?.catch(() => {
+  });
+  lazyHandlerPromise?.catch(() => {
   });
   return {
     lazyRoutePromise,
     lazyHandlerPromise
   };
 }
-function isNonNullable(value) {
-  return value !== void 0;
-}
-function loadLazyMiddlewareForMatches(matches, manifest, mapRouteProperties2) {
-  let promises = matches.map(({ route }) => {
-    if (typeof route.lazy !== "object" || !route.lazy.unstable_middleware) {
-      return void 0;
-    }
-    return loadLazyRouteProperty({
-      key: "unstable_middleware",
-      route,
-      manifest,
-      mapRouteProperties: mapRouteProperties2
-    });
-  }).filter(isNonNullable);
-  return promises.length > 0 ? Promise.all(promises) : void 0;
-}
 async function defaultDataStrategy(args) {
   let matchesToLoad = args.matches.filter((m) => m.shouldLoad);
   let keyedResults = {};
@@ -3116,59 +3181,145 @@ async function callRouteMiddleware(args, middlewares, propagateResult, middlewar
     throw error;
   }
 }
-async function callDataStrategyImpl(dataStrategyImpl, type, request, matchesToLoad, matches, fetcherKey, manifest, mapRouteProperties2, scopedContext) {
-  let loadMiddlewarePromise = loadLazyMiddlewareForMatches(
-    matches,
+function getDataStrategyMatchLazyPromises(mapRouteProperties2, manifest, request, match, lazyRoutePropertiesToSkip) {
+  let lazyMiddlewarePromise = loadLazyRouteProperty({
+    key: "unstable_middleware",
+    route: match.route,
     manifest,
-    mapRouteProperties2
+    mapRouteProperties: mapRouteProperties2
+  });
+  let lazyRoutePromises = loadLazyRoute(
+    match.route,
+    isMutationMethod(request.method) ? "action" : "loader",
+    manifest,
+    mapRouteProperties2,
+    lazyRoutePropertiesToSkip
   );
-  let lazyRoutePromises = matches.map(
-    (m) => loadLazyRoute(m.route, type, manifest, mapRouteProperties2)
+  return {
+    middleware: lazyMiddlewarePromise,
+    route: lazyRoutePromises.lazyRoutePromise,
+    handler: lazyRoutePromises.lazyHandlerPromise
+  };
+}
+function getDataStrategyMatch(mapRouteProperties2, manifest, request, match, lazyRoutePropertiesToSkip, scopedContext, shouldLoad, unstable_shouldRevalidateArgs = null) {
+  let isUsingNewApi = false;
+  let _lazyPromises = getDataStrategyMatchLazyPromises(
+    mapRouteProperties2,
+    manifest,
+    request,
+    match,
+    lazyRoutePropertiesToSkip
   );
-  if (loadMiddlewarePromise) {
-    await loadMiddlewarePromise;
-  }
-  let dsMatches = matches.map((match, 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({
-        type,
-        request,
-        match,
-        lazyHandlerPromise,
-        lazyRoutePromise,
-        handlerOverride,
-        scopedContext
-      }) : Promise.resolve({ type: "data" /* data */, result: void 0 });
-    };
-    return {
-      ...match,
-      shouldLoad,
-      resolve
-    };
+  return {
+    ...match,
+    _lazyPromises,
+    shouldLoad,
+    unstable_shouldRevalidateArgs,
+    unstable_shouldCallHandler(defaultShouldRevalidate) {
+      isUsingNewApi = true;
+      if (!unstable_shouldRevalidateArgs) {
+        return shouldLoad;
+      }
+      if (typeof defaultShouldRevalidate === "boolean") {
+        return shouldRevalidateLoader(match, {
+          ...unstable_shouldRevalidateArgs,
+          defaultShouldRevalidate
+        });
+      }
+      return shouldRevalidateLoader(match, unstable_shouldRevalidateArgs);
+    },
+    resolve(handlerOverride) {
+      if (isUsingNewApi || shouldLoad || handlerOverride && request.method === "GET" && (match.route.lazy || match.route.loader)) {
+        return callLoaderOrAction({
+          request,
+          match,
+          lazyHandlerPromise: _lazyPromises?.handler,
+          lazyRoutePromise: _lazyPromises?.route,
+          handlerOverride,
+          scopedContext
+        });
+      }
+      return Promise.resolve({ type: "data" /* data */, result: void 0 });
+    }
+  };
+}
+function getTargetedDataStrategyMatches(mapRouteProperties2, manifest, request, matches, targetMatch, lazyRoutePropertiesToSkip, scopedContext, shouldRevalidateArgs = null) {
+  return matches.map((match) => {
+    if (match.route.id !== targetMatch.route.id) {
+      return {
+        ...match,
+        shouldLoad: false,
+        unstable_shouldRevalidateArgs: shouldRevalidateArgs,
+        unstable_shouldCallHandler: () => false,
+        _lazyPromises: getDataStrategyMatchLazyPromises(
+          mapRouteProperties2,
+          manifest,
+          request,
+          match,
+          lazyRoutePropertiesToSkip
+        ),
+        resolve: () => Promise.resolve({ type: "data", result: void 0 })
+      };
+    }
+    return getDataStrategyMatch(
+      mapRouteProperties2,
+      manifest,
+      request,
+      match,
+      lazyRoutePropertiesToSkip,
+      scopedContext,
+      true,
+      shouldRevalidateArgs
+    );
   });
-  let results = await dataStrategyImpl({
-    matches: dsMatches,
+}
+async function callDataStrategyImpl(dataStrategyImpl, request, matches, fetcherKey, scopedContext, isStaticHandler) {
+  if (matches.some((m) => m._lazyPromises?.middleware)) {
+    await Promise.all(matches.map((m) => m._lazyPromises?.middleware));
+  }
+  let dataStrategyArgs = {
     request,
     params: matches[0].params,
+    context: scopedContext,
+    matches
+  };
+  let unstable_runClientMiddleware = isStaticHandler ? () => {
+    throw new Error(
+      "You cannot call `unstable_runClientMiddleware()` from a static handler `dataStrategy`. Middleware is run outside of `dataStrategy` during SSR in order to bubble up the Response.  You can enable middleware via the `respond` API in `query`/`queryRoute`"
+    );
+  } : (cb) => {
+    let typedDataStrategyArgs = dataStrategyArgs;
+    return runMiddlewarePipeline(
+      typedDataStrategyArgs,
+      false,
+      () => cb({
+        ...typedDataStrategyArgs,
+        fetcherKey,
+        unstable_runClientMiddleware: () => {
+          throw new Error(
+            "Cannot call `unstable_runClientMiddleware()` from within an `unstable_runClientMiddleware` handler"
+          );
+        }
+      }),
+      (error, routeId) => ({
+        [routeId]: { type: "error", result: error }
+      })
+    );
+  };
+  let results = await dataStrategyImpl({
+    ...dataStrategyArgs,
     fetcherKey,
-    context: scopedContext
+    unstable_runClientMiddleware
   });
-  let allLazyRoutePromises = lazyRoutePromises.flatMap(
-    (promiseMap) => Object.values(promiseMap).filter(isNonNullable)
-  );
   try {
-    await Promise.all(allLazyRoutePromises);
+    await Promise.all(
+      matches.flatMap((m) => [m._lazyPromises?.handler, m._lazyPromises?.route])
+    );
   } catch (e) {
   }
   return results;
 }
 async function callLoaderOrAction({
-  type,
   request,
   match,
   lazyHandlerPromise,
@@ -3178,6 +3329,8 @@ async function callLoaderOrAction({
 }) {
   let result;
   let onReject;
+  let isAction = isMutationMethod(request.method);
+  let type = isAction ? "action" : "loader";
   let runHandler = (handler) => {
     let reject;
     let abortPromise = new Promise((_, r) => reject = r);
@@ -3211,7 +3364,7 @@ async function callLoaderOrAction({
     return Promise.race([handlerPromise, abortPromise]);
   };
   try {
-    let handler = match.route[type];
+    let handler = isAction ? match.route.action : match.route.loader;
     if (lazyHandlerPromise || lazyRoutePromise) {
       if (handler) {
         let handlerError;
@@ -3232,9 +3385,9 @@ async function callLoaderOrAction({
         result = value;
       } else {
         await lazyHandlerPromise;
-        handler = match.route[type];
-        if (handler) {
-          [result] = await Promise.all([runHandler(handler), lazyRoutePromise]);
+        let handler2 = isAction ? match.route.action : match.route.loader;
+        if (handler2) {
+          [result] = await Promise.all([runHandler(handler2), lazyRoutePromise]);
         } else if (type === "action") {
           let url = new URL(request.url);
           let pathname = url.pathname + url.search;
@@ -3469,7 +3622,7 @@ function processLoaderData(state, matches, results, pendingActionResult, revalid
     results,
     pendingActionResult
   );
-  revalidatingFetchers.forEach((rf) => {
+  revalidatingFetchers.filter((f) => !f.matches || f.matches.some((m) => m.shouldLoad)).forEach((rf) => {
     let { key, match, controller } = rf;
     let result = fetcherResults[key];
     invariant(result, "Did not find corresponding fetcher result");
@@ -4258,6 +4411,10 @@ function mapRouteProperties(route) {
   }
   return updates;
 }
+var hydrationRouteProperties = [
+  "HydrateFallback",
+  "hydrateFallbackElement"
+];
 var Deferred = class {
   constructor() {
     this.status = "pending";
@@ -4678,71 +4835,55 @@ async function createRequestInit(request) {
 
 // lib/dom/ssr/single-fetch.tsx
 var SingleFetchRedirectSymbol = Symbol("SingleFetchRedirect");
-function handleMiddlewareError(error, routeId) {
-  return { [routeId]: { type: "error", result: error } };
+var NO_BODY_STATUS_CODES = /* @__PURE__ */ new Set([100, 101, 204, 205]);
+function getSingleFetchDataStrategy(getRouter, getRouteInfo, ssr, basename) {
+  let dataStrategy = getSingleFetchDataStrategyImpl(
+    getRouter,
+    getRouteInfo,
+    fetchAndDecodeViaTurboStream,
+    ssr,
+    basename
+  );
+  return async (args) => args.unstable_runClientMiddleware(dataStrategy);
 }
-function getSingleFetchDataStrategy(manifest, routeModules, ssr, basename, getRouter) {
+function getSingleFetchDataStrategyImpl(getRouter, getRouteInfo, fetchAndDecode, ssr, basename) {
   return async (args) => {
     let { request, matches, fetcherKey } = args;
+    let router2 = getRouter();
     if (request.method !== "GET") {
-      return runMiddlewarePipeline(
-        args,
-        false,
-        () => singleFetchActionStrategy(request, matches, basename),
-        handleMiddlewareError
-      );
+      return singleFetchActionStrategy(args, fetchAndDecode, basename);
     }
-    if (!ssr) {
-      let foundRevalidatingServerLoader = matches.some(
-        (m) => m.shouldLoad && manifest.routes[m.route.id]?.hasLoader && !manifest.routes[m.route.id]?.hasClientLoader
-      );
-      if (!foundRevalidatingServerLoader) {
-        return runMiddlewarePipeline(
-          args,
-          false,
-          () => nonSsrStrategy(manifest, request, matches, basename),
-          handleMiddlewareError
-        );
-      }
+    let foundRevalidatingServerLoader = matches.some((m) => {
+      let { hasLoader, hasClientLoader } = getRouteInfo(m.route.id);
+      return m.unstable_shouldCallHandler() && hasLoader && !hasClientLoader;
+    });
+    if (!ssr && !foundRevalidatingServerLoader) {
+      return nonSsrStrategy(args, getRouteInfo, fetchAndDecode, basename);
     }
     if (fetcherKey) {
-      return runMiddlewarePipeline(
-        args,
-        false,
-        () => singleFetchLoaderFetcherStrategy(request, matches, basename),
-        handleMiddlewareError
-      );
+      return singleFetchLoaderFetcherStrategy(args, fetchAndDecode, basename);
     }
-    return runMiddlewarePipeline(
+    return singleFetchLoaderNavigationStrategy(
       args,
-      false,
-      () => singleFetchLoaderNavigationStrategy(
-        manifest,
-        routeModules,
-        ssr,
-        getRouter(),
-        request,
-        matches,
-        basename
-      ),
-      handleMiddlewareError
+      router2,
+      getRouteInfo,
+      fetchAndDecode,
+      ssr,
+      basename
     );
   };
 }
-async function singleFetchActionStrategy(request, matches, basename) {
-  let actionMatch = matches.find((m) => m.shouldLoad);
+async function singleFetchActionStrategy(args, fetchAndDecode, basename) {
+  let actionMatch = args.matches.find((m) => m.unstable_shouldCallHandler());
   invariant2(actionMatch, "No action match found");
   let actionStatus = void 0;
   let result = await actionMatch.resolve(async (handler) => {
     let result2 = await handler(async () => {
-      let url = singleFetchUrl(request.url, basename);
-      let init = await createRequestInit(request);
-      let { data: data2, status } = await fetchAndDecode(url, init);
-      actionStatus = status;
-      return unwrapSingleFetchResult(
-        data2,
+      let { data: data2, status } = await fetchAndDecode(args, basename, [
         actionMatch.route.id
-      );
+      ]);
+      actionStatus = status;
+      return unwrapSingleFetchResult(data2, actionMatch.route.id);
     });
     return result2;
   });
@@ -4756,16 +4897,21 @@ async function singleFetchActionStrategy(request, matches, basename) {
     }
   };
 }
-async function nonSsrStrategy(manifest, request, matches, basename) {
-  let matchesToLoad = matches.filter((m) => m.shouldLoad);
-  let url = stripIndexParam(singleFetchUrl(request.url, basename));
-  let init = await createRequestInit(request);
+async function nonSsrStrategy(args, getRouteInfo, fetchAndDecode, basename) {
+  let matchesToLoad = args.matches.filter(
+    (m) => m.unstable_shouldCallHandler()
+  );
   let results = {};
   await Promise.all(
     matchesToLoad.map(
       (m) => m.resolve(async (handler) => {
         try {
-          let result = manifest.routes[m.route.id]?.hasClientLoader ? await fetchSingleLoader(handler, url, init, m.route.id) : await handler();
+          let { hasClientLoader } = getRouteInfo(m.route.id);
+          let routeId = m.route.id;
+          let result = hasClientLoader ? await handler(async () => {
+            let { data: data2 } = await fetchAndDecode(args, basename, [routeId]);
+            return unwrapSingleFetchResult(data2, routeId);
+          }) : await handler();
           results[m.route.id] = { type: "data", result };
         } catch (e) {
           results[m.route.id] = { type: "error", result: e };
@@ -4775,81 +4921,63 @@ async function nonSsrStrategy(manifest, request, matches, basename) {
   );
   return results;
 }
-async function singleFetchLoaderNavigationStrategy(manifest, routeModules, ssr, router2, request, matches, basename) {
+async function singleFetchLoaderNavigationStrategy(args, router2, getRouteInfo, fetchAndDecode, ssr, basename) {
   let routesParams = /* @__PURE__ */ new Set();
   let foundOptOutRoute = false;
-  let routeDfds = matches.map(() => createDeferred2());
-  let routesLoadedPromise = Promise.all(routeDfds.map((d) => d.promise));
+  let routeDfds = args.matches.map(() => createDeferred2());
   let singleFetchDfd = createDeferred2();
-  let url = stripIndexParam(singleFetchUrl(request.url, basename));
-  let init = await createRequestInit(request);
   let results = {};
   let resolvePromise = Promise.all(
-    matches.map(
+    args.matches.map(
       async (m, i) => m.resolve(async (handler) => {
         routeDfds[i].resolve();
-        let manifestRoute = manifest.routes[m.route.id];
-        if (!m.shouldLoad) {
-          if (!router2.state.initialized) {
-            return;
-          }
-          if (m.route.id in router2.state.loaderData && manifestRoute && m.route.shouldRevalidate) {
-            if (manifestRoute.hasLoader) {
-              foundOptOutRoute = true;
-            }
-            return;
-          }
+        let routeId = m.route.id;
+        let { hasLoader, hasClientLoader, hasShouldRevalidate } = getRouteInfo(routeId);
+        let defaultShouldRevalidate = !m.unstable_shouldRevalidateArgs || m.unstable_shouldRevalidateArgs.actionStatus == null || m.unstable_shouldRevalidateArgs.actionStatus < 400;
+        let shouldCall = m.unstable_shouldCallHandler(defaultShouldRevalidate);
+        if (!shouldCall) {
+          foundOptOutRoute || (foundOptOutRoute = m.unstable_shouldRevalidateArgs != null && // This is a revalidation,
+          hasLoader && // for a route with a server loader,
+          hasShouldRevalidate === true);
+          return;
         }
-        if (manifestRoute && manifestRoute.hasClientLoader) {
-          if (manifestRoute.hasLoader) {
+        if (hasClientLoader) {
+          if (hasLoader) {
             foundOptOutRoute = true;
           }
           try {
-            let result = await fetchSingleLoader(
-              handler,
-              url,
-              init,
-              m.route.id
-            );
-            results[m.route.id] = { type: "data", result };
+            let result = await handler(async () => {
+              let { data: data2 } = await fetchAndDecode(args, basename, [routeId]);
+              return unwrapSingleFetchResult(data2, routeId);
+            });
+            results[routeId] = { type: "data", result };
           } catch (e) {
-            results[m.route.id] = { type: "error", result: e };
+            results[routeId] = { type: "error", result: e };
           }
           return;
         }
-        if (manifestRoute && manifestRoute.hasLoader) {
-          routesParams.add(m.route.id);
+        if (hasLoader) {
+          routesParams.add(routeId);
         }
         try {
           let result = await handler(async () => {
             let data2 = await singleFetchDfd.promise;
-            return unwrapSingleFetchResults(data2, m.route.id);
+            return unwrapSingleFetchResult(data2, routeId);
           });
-          results[m.route.id] = {
-            type: "data",
-            result
-          };
+          results[routeId] = { type: "data", result };
         } catch (e) {
-          results[m.route.id] = {
-            type: "error",
-            result: e
-          };
+          results[routeId] = { type: "error", result: e };
         }
       })
     )
   );
-  await routesLoadedPromise;
+  await Promise.all(routeDfds.map((d) => d.promise));
   if ((!router2.state.initialized || routesParams.size === 0) && !window.__reactRouterHdrActive) {
     singleFetchDfd.resolve({});
   } else {
+    let targetRoutes = ssr && foundOptOutRoute && routesParams.size > 0 ? [...routesParams.keys()] : void 0;
     try {
-      if (ssr && foundOptOutRoute && routesParams.size > 0) {
-        url.searchParams.set(
-          "_routes",
-          matches.filter((m) => routesParams.has(m.route.id)).map((m) => m.route.id).join(",")
-        );
-      }
-      let data2 = await fetchAndDecode(url, init);
+      let data2 = await fetchAndDecode(args, basename, targetRoutes);
       singleFetchDfd.resolve(data2.data);
     } catch (e) {
       singleFetchDfd.reject(e);
@@ -4858,24 +4986,18 @@ async function singleFetchLoaderNavigationStrategy(manifest, routeModules, ssr,
   await resolvePromise;
   return results;
 }
-async function singleFetchLoaderFetcherStrategy(request, matches, basename) {
-  let fetcherMatch = matches.find((m) => m.shouldLoad);
+async function singleFetchLoaderFetcherStrategy(args, fetchAndDecode, basename) {
+  let fetcherMatch = args.matches.find((m) => m.unstable_shouldCallHandler());
   invariant2(fetcherMatch, "No fetcher match found");
-  let result = await fetcherMatch.resolve(async (handler) => {
-    let url = stripIndexParam(singleFetchUrl(request.url, basename));
-    let init = await createRequestInit(request);
-    return fetchSingleLoader(handler, url, init, fetcherMatch.route.id);
-  });
+  let routeId = fetcherMatch.route.id;
+  let result = await fetcherMatch.resolve(
+    async (handler) => handler(async () => {
+      let { data: data2 } = await fetchAndDecode(args, basename, [routeId]);
+      return unwrapSingleFetchResult(data2, routeId);
+    })
+  );
   return { [fetcherMatch.route.id]: result };
 }
-function fetchSingleLoader(handler, url, init, routeId) {
-  return handler(async () => {
-    let singleLoaderUrl = new URL(url);
-    singleLoaderUrl.searchParams.set("_routes", routeId);
-    let { data: data2 } = await fetchAndDecode(singleLoaderUrl, init);
-    return unwrapSingleFetchResults(data2, routeId);
-  });
-}
 function stripIndexParam(url) {
   let indexValues = url.searchParams.getAll("index");
   url.searchParams.delete("index");
@@ -4906,23 +5028,51 @@ function singleFetchUrl(reqUrl, basename) {
   }
   return url;
 }
-async function fetchAndDecode(url, init) {
-  let res = await fetch(url, init);
+async function fetchAndDecodeViaTurboStream(args, basename, targetRoutes) {
+  let { request } = args;
+  let url = singleFetchUrl(request.url, basename);
+  if (request.method === "GET") {
+    url = stripIndexParam(url);
+    if (targetRoutes) {
+      url.searchParams.set("_routes", targetRoutes.join(","));
+    }
+  }
+  let res = await fetch(url, await createRequestInit(request));
   if (res.status === 404 && !res.headers.has("X-Remix-Response")) {
     throw new ErrorResponseImpl(404, "Not Found", true);
   }
-  const NO_BODY_STATUS_CODES = /* @__PURE__ */ new Set([100, 101, 204, 205]);
   if (NO_BODY_STATUS_CODES.has(res.status)) {
-    if (!init.method || init.method === "GET") {
-      return { status: res.status, data: {} };
-    } else {
-      return { status: res.status, data: { data: void 0 } };
+    let routes = {};
+    if (targetRoutes && request.method !== "GET") {
+      routes[targetRoutes[0]] = { data: void 0 };
     }
+    return {
+      status: res.status,
+      data: { routes }
+    };
   }
   invariant2(res.body, "No response body to decode");
   try {
     let decoded = await decodeViaTurboStream(res.body, window);
-    return { status: res.status, data: decoded.value };
+    let data2;
+    if (request.method === "GET") {
+      let typed = decoded.value;
+      if (SingleFetchRedirectSymbol in typed) {
+        data2 = { redirect: typed[SingleFetchRedirectSymbol] };
+      } else {
+        data2 = { routes: typed };
+      }
+    } else {
+      let typed = decoded.value;
+      let routeId = targetRoutes?.[0];
+      invariant2(routeId, "No routeId found for single fetch call decoding");
+      if ("redirect" in typed) {
+        data2 = { redirect: typed };
+      } else {
+        data2 = { routes: { [routeId]: typed } };
+      }
+    }
+    return { status: res.status, data: data2 };
   } catch (e) {
     throw new Error("Unable to decode turbo-stream response");
   }
@@ -4960,30 +5110,30 @@ function decodeViaTurboStream(body, global) {
     ]
   });
 }
-function unwrapSingleFetchResults(results, routeId) {
-  let redirect2 = results[SingleFetchRedirectSymbol];
-  if (redirect2) {
-    return unwrapSingleFetchResult(redirect2, routeId);
-  }
-  return results[routeId] !== void 0 ? unwrapSingleFetchResult(results[routeId], routeId) : null;
-}
 function unwrapSingleFetchResult(result, routeId) {
-  if ("error" in result) {
-    throw result.error;
-  } else if ("redirect" in result) {
-    let headers = {};
-    if (result.revalidate) {
-      headers["X-Remix-Revalidate"] = "yes";
-    }
-    if (result.reload) {
-      headers["X-Remix-Reload-Document"] = "yes";
-    }
-    if (result.replace) {
-      headers["X-Remix-Replace"] = "yes";
-    }
-    throw redirect(result.redirect, { status: result.status, headers });
-  } else if ("data" in result) {
-    return result.data;
+  if ("redirect" in result) {
+    let {
+      redirect: location,
+      revalidate,
+      reload,
+      replace: replace2,
+      status
+    } = result.redirect;
+    throw redirect(location, {
+      status,
+      headers: {
+        // Three R's of redirecting (lol Veep)
+        ...revalidate ? { "X-Remix-Revalidate": "yes" } : null,
+        ...reload ? { "X-Remix-Reload-Document": "yes" } : null,
+        ...replace2 ? { "X-Remix-Replace": "yes" } : null
+      }
+    });
+  }
+  let routeResult = result.routes[routeId];
+  if ("error" in routeResult) {
+    throw routeResult.error;
+  } else if ("data" in routeResult) {
+    return routeResult.data;
   } else {
     throw new Error(`No response found for routeId "${routeId}"`);
   }
@@ -5255,6 +5405,7 @@ function createClientRoutes(manifest, routeModulesCache, initialState, ssr, isSp
         unstable_middleware: routeModule.unstable_clientMiddleware,
         handle: routeModule.handle,
         shouldRevalidate: getShouldRevalidateFunction(
+          dataRoute.path,
           routeModule,
           route,
           ssr,
@@ -5407,6 +5558,7 @@ function createClientRoutes(manifest, routeModulesCache, initialState, ssr, isSp
         shouldRevalidate: async () => {
           let lazyRoute = await getLazyRoute();
           return getShouldRevalidateFunction(
+            dataRoute.path,
             lazyRoute,
             route,
             ssr,
@@ -5434,7 +5586,7 @@ function createClientRoutes(manifest, routeModulesCache, initialState, ssr, isSp
     return dataRoute;
   });
 }
-function getShouldRevalidateFunction(route, manifestRoute, ssr, needsRevalidation) {
+function getShouldRevalidateFunction(path, route, manifestRoute, ssr, needsRevalidation) {
   if (needsRevalidation) {
     return wrapShouldRevalidateForHdr(
       manifestRoute.id,
@@ -5443,11 +5595,16 @@ function getShouldRevalidateFunction(route, manifestRoute, ssr, needsRevalidatio
     );
   }
   if (!ssr && manifestRoute.hasLoader && !manifestRoute.hasClientLoader) {
+    let myParams = path ? compilePath(path)[1].map((p) => p.paramName) : [];
+    const didParamsChange = (opts) => myParams.some((p) => opts.currentParams[p] !== opts.nextParams[p]);
     if (route.shouldRevalidate) {
       let fn = route.shouldRevalidate;
-      return (opts) => fn({ ...opts, defaultShouldRevalidate: false });
+      return (opts) => fn({
+        ...opts,
+        defaultShouldRevalidate: didParamsChange(opts)
+      });
     } else {
-      return () => false;
+      return (opts) => didParamsChange(opts);
     }
   }
   if (ssr && route.shouldRevalidate) {
@@ -6018,16 +6175,27 @@ function createHydratedRouter({
     basename: ssrInfo.context.basename,
     unstable_getContext,
     hydrationData,
+    hydrationRouteProperties,
     mapRouteProperties,
     future: {
       unstable_middleware: ssrInfo.context.future.unstable_middleware
     },
     dataStrategy: getSingleFetchDataStrategy(
-      ssrInfo.manifest,
-      ssrInfo.routeModules,
+      () => router2,
+      (routeId) => {
+        let manifestRoute = ssrInfo.manifest.routes[routeId];
+        invariant(manifestRoute, "Route not found in manifest/routeModules");
+        let routeModule = ssrInfo.routeModules[routeId];
+        return {
+          hasLoader: manifestRoute.hasLoader,
+          hasClientLoader: manifestRoute.hasClientLoader,
+          // In some cases the module may not be loaded yet and we don't care
+          // if it's got shouldRevalidate or not
+          hasShouldRevalidate: routeModule ? routeModule.shouldRevalidate != null : void 0
+        };
+      },
       ssrInfo.context.ssr,
-      ssrInfo.context.basename,
-      () => router2
+      ssrInfo.context.basename
     ),
     patchRoutesOnNavigation: getPatchRoutesOnNavigationFunction(
       ssrInfo.manifest,