@remix-run/router 1.19.1 → 1.19.2

package/dist/router.umd.js

@@ -1,5 +1,5 @@
 /**
- * @remix-run/router v1.19.1
+ * @remix-run/router v1.19.2
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -579,10 +579,6 @@
    * Result from a loader or action - potentially successful or unsuccessful
    */
 
-  /**
-   * Result from a loader or action called via dataStrategy
-   */
-
   /**
    * Users can specify either lowercase or uppercase form methods on `<Form>`,
    * useSubmit(), `<fetcher.Form>`, etc.
@@ -648,6 +644,9 @@
    *
    * @deprecated Use `mapRouteProperties` instead
    */
+  /**
+   * Result from a loader or action called via dataStrategy
+   */
   /**
    * Function provided by the framework-aware layers to set any framework-specific
    * properties from framework-agnostic properties
@@ -1928,7 +1927,7 @@
 
     // Flag to ignore the next history update, so we can revert the URL change on
     // a POP navigation that was blocked by the user without touching router state
-    let ignoreNextHistoryUpdate = false;
+    let unblockBlockerHistoryUpdate = undefined;
 
     // Initialize the router, all side effects should be kicked off from here.
     // Implemented as a Fluent API for ease of:
@@ -1944,8 +1943,9 @@
         } = _ref;
         // Ignore this event if it was just us resetting the URL from a
         // blocked POP navigation
-        if (ignoreNextHistoryUpdate) {
-          ignoreNextHistoryUpdate = false;
+        if (unblockBlockerHistoryUpdate) {
+          unblockBlockerHistoryUpdate();
+          unblockBlockerHistoryUpdate = undefined;
           return;
         }
         warning(blockerFunctions.size === 0 || delta != null, "You are trying to use a blocker on a POP navigation to a location " + "that was not created by @remix-run/router. This will fail silently in " + "production. This can happen if you are navigating outside the router " + "via `window.history.pushState`/`window.location.hash` instead of using " + "router navigation APIs.  This can also happen if you are using " + "createHashRouter and the user manually changes the URL.");
@@ -1956,7 +1956,9 @@
         });
         if (blockerKey && delta != null) {
           // Restore the URL to match the current UI, but don't update router state
-          ignoreNextHistoryUpdate = true;
+          let nextHistoryUpdatePromise = new Promise(resolve => {
+            unblockBlockerHistoryUpdate = resolve;
+          });
           init.history.go(delta * -1);
 
           // Put the blocker into a blocked state
@@ -1970,8 +1972,10 @@
                 reset: undefined,
                 location
               });
-              // Re-do the same POP navigation we just blocked
-              init.history.go(delta);
+              // Re-do the same POP navigation we just blocked, after the url
+              // restoration is also complete.  See:
+              // https://github.com/remix-run/react-router/issues/11613
+              nextHistoryUpdatePromise.then(() => init.history.go(delta));
             },
             reset() {
               let blockers = new Map(state.blockers);
@@ -2291,7 +2295,9 @@
       // navigation to the navigation.location but do not trigger an uninterrupted
       // revalidation so that history correctly updates once the navigation completes
       startNavigation(pendingAction || state.historyAction, state.navigation.location, {
-        overrideNavigation: state.navigation
+        overrideNavigation: state.navigation,
+        // Proxy through any rending view transition
+        enableViewTransition: pendingViewTransitionEnabled === true
       });
     }
 
@@ -2492,8 +2498,8 @@
           })
         };
       } else {
-        let results = await callDataStrategy("action", request, [actionMatch], matches);
-        result = results[0];
+        let results = await callDataStrategy("action", state, request, [actionMatch], matches, null);
+        result = results[actionMatch.route.id];
         if (request.signal.aborted) {
           return {
             shortCircuited: true
@@ -2511,7 +2517,7 @@
           let location = normalizeRedirectLocation(result.response.headers.get("Location"), new URL(request.url), basename);
           replace = location === state.location.pathname + state.location.search;
         }
-        await startRedirectNavigation(request, result, {
+        await startRedirectNavigation(request, result, true, {
           submission,
           replace
         });
@@ -2681,7 +2687,7 @@
       let {
         loaderResults,
         fetcherResults
-      } = await callLoadersAndMaybeResolveData(state.matches, matches, matchesToLoad, revalidatingFetchers, request);
+      } = await callLoadersAndMaybeResolveData(state, matches, matchesToLoad, revalidatingFetchers, request);
       if (request.signal.aborted) {
         return {
           shortCircuited: true
@@ -2697,16 +2703,22 @@
       revalidatingFetchers.forEach(rf => fetchControllers.delete(rf.key));
 
       // If any loaders returned a redirect Response, start a new REPLACE navigation
-      let redirect = findRedirect([...loaderResults, ...fetcherResults]);
+      let redirect = findRedirect(loaderResults);
       if (redirect) {
-        if (redirect.idx >= matchesToLoad.length) {
-          // If this redirect came from a fetcher make sure we mark it in
-          // fetchRedirectIds so it doesn't get revalidated on the next set of
-          // loader executions
-          let fetcherKey = revalidatingFetchers[redirect.idx - matchesToLoad.length].key;
-          fetchRedirectIds.add(fetcherKey);
-        }
-        await startRedirectNavigation(request, redirect.result, {
+        await startRedirectNavigation(request, redirect.result, true, {
+          replace
+        });
+        return {
+          shortCircuited: true
+        };
+      }
+      redirect = findRedirect(fetcherResults);
+      if (redirect) {
+        // If this redirect came from a fetcher make sure we mark it in
+        // fetchRedirectIds so it doesn't get revalidated on the next set of
+        // loader executions
+        fetchRedirectIds.add(redirect.key);
+        await startRedirectNavigation(request, redirect.result, true, {
           replace
         });
         return {
@@ -2890,8 +2902,8 @@
       // Call the action for the fetcher
       fetchControllers.set(key, abortController);
       let originatingLoadId = incrementingLoadId;
-      let actionResults = await callDataStrategy("action", fetchRequest, [match], requestMatches);
-      let actionResult = actionResults[0];
+      let actionResults = await callDataStrategy("action", state, fetchRequest, [match], requestMatches, key);
+      let actionResult = actionResults[match.route.id];
       if (fetchRequest.signal.aborted) {
         // We can delete this so long as we weren't aborted by our own fetcher
         // re-submit which would have put _new_ controller is in fetchControllers
@@ -2923,7 +2935,7 @@
           } else {
             fetchRedirectIds.add(key);
             updateFetcherState(key, getLoadingFetcher(submission));
-            return startRedirectNavigation(fetchRequest, actionResult, {
+            return startRedirectNavigation(fetchRequest, actionResult, false, {
               fetcherSubmission: submission
             });
           }
@@ -2977,7 +2989,7 @@
       let {
         loaderResults,
         fetcherResults
-      } = await callLoadersAndMaybeResolveData(state.matches, matches, matchesToLoad, revalidatingFetchers, revalidationRequest);
+      } = await callLoadersAndMaybeResolveData(state, matches, matchesToLoad, revalidatingFetchers, revalidationRequest);
       if (abortController.signal.aborted) {
         return;
       }
@@ -2985,23 +2997,24 @@
       fetchReloadIds.delete(key);
       fetchControllers.delete(key);
       revalidatingFetchers.forEach(r => fetchControllers.delete(r.key));
-      let redirect = findRedirect([...loaderResults, ...fetcherResults]);
+      let redirect = findRedirect(loaderResults);
       if (redirect) {
-        if (redirect.idx >= matchesToLoad.length) {
-          // If this redirect came from a fetcher make sure we mark it in
-          // fetchRedirectIds so it doesn't get revalidated on the next set of
-          // loader executions
-          let fetcherKey = revalidatingFetchers[redirect.idx - matchesToLoad.length].key;
-          fetchRedirectIds.add(fetcherKey);
-        }
-        return startRedirectNavigation(revalidationRequest, redirect.result);
+        return startRedirectNavigation(revalidationRequest, redirect.result, false);
+      }
+      redirect = findRedirect(fetcherResults);
+      if (redirect) {
+        // If this redirect came from a fetcher make sure we mark it in
+        // fetchRedirectIds so it doesn't get revalidated on the next set of
+        // loader executions
+        fetchRedirectIds.add(redirect.key);
+        return startRedirectNavigation(revalidationRequest, redirect.result, false);
       }
 
       // Process and commit output from loaders
       let {
         loaderData,
         errors
-      } = processLoaderData(state, state.matches, matchesToLoad, loaderResults, undefined, revalidatingFetchers, fetcherResults, activeDeferreds);
+      } = processLoaderData(state, matches, matchesToLoad, loaderResults, undefined, revalidatingFetchers, fetcherResults, activeDeferreds);
 
       // Since we let revalidations complete even if the submitting fetcher was
       // deleted, only put it back to idle if it hasn't been deleted
@@ -3072,8 +3085,8 @@
       // Call the loader for this fetcher route match
       fetchControllers.set(key, abortController);
       let originatingLoadId = incrementingLoadId;
-      let results = await callDataStrategy("loader", fetchRequest, [match], matches);
-      let result = results[0];
+      let results = await callDataStrategy("loader", state, fetchRequest, [match], matches, key);
+      let result = results[match.route.id];
 
       // Deferred isn't supported for fetcher loads, await everything and treat it
       // as a normal load.  resolveDeferredData will return undefined if this
@@ -3108,7 +3121,7 @@
           return;
         } else {
           fetchRedirectIds.add(key);
-          await startRedirectNavigation(fetchRequest, result);
+          await startRedirectNavigation(fetchRequest, result, false);
           return;
         }
       }
@@ -3143,7 +3156,7 @@
      * actually touch history until we've processed redirects, so we just use
      * the history action from the original navigation (PUSH or REPLACE).
      */
-    async function startRedirectNavigation(request, redirect, _temp2) {
+    async function startRedirectNavigation(request, redirect, isNavigation, _temp2) {
       let {
         submission,
         fetcherSubmission,
@@ -3206,8 +3219,9 @@
           submission: _extends({}, activeSubmission, {
             formAction: location
           }),
-          // Preserve this flag across redirects
-          preventScrollReset: pendingPreventScrollReset
+          // Preserve these flags across redirects
+          preventScrollReset: pendingPreventScrollReset,
+          enableViewTransition: isNavigation ? pendingViewTransitionEnabled : undefined
         });
       } else {
         // If we have a navigation submission, we will preserve it through the
@@ -3217,51 +3231,71 @@
           overrideNavigation,
           // Send fetcher submissions through for shouldRevalidate
           fetcherSubmission,
-          // Preserve this flag across redirects
-          preventScrollReset: pendingPreventScrollReset
+          // Preserve these flags across redirects
+          preventScrollReset: pendingPreventScrollReset,
+          enableViewTransition: isNavigation ? pendingViewTransitionEnabled : undefined
         });
       }
     }
 
     // Utility wrapper for calling dataStrategy client-side without having to
     // pass around the manifest, mapRouteProperties, etc.
-    async function callDataStrategy(type, request, matchesToLoad, matches) {
+    async function callDataStrategy(type, state, request, matchesToLoad, matches, fetcherKey) {
+      let results;
+      let dataResults = {};
       try {
-        let results = await callDataStrategyImpl(dataStrategyImpl, type, request, matchesToLoad, matches, manifest, mapRouteProperties);
-        return await Promise.all(results.map((result, i) => {
-          if (isRedirectHandlerResult(result)) {
-            let response = result.result;
-            return {
-              type: ResultType.redirect,
-              response: normalizeRelativeRoutingRedirectResponse(response, request, matchesToLoad[i].route.id, matches, basename, future.v7_relativeSplatPath)
-            };
-          }
-          return convertHandlerResultToDataResult(result);
-        }));
+        results = await callDataStrategyImpl(dataStrategyImpl, type, state, request, matchesToLoad, matches, fetcherKey, manifest, mapRouteProperties);
       } catch (e) {
         // If the outer dataStrategy method throws, just return the error for all
         // matches - and it'll naturally bubble to the root
-        return matchesToLoad.map(() => ({
-          type: ResultType.error,
-          error: e
-        }));
+        matchesToLoad.forEach(m => {
+          dataResults[m.route.id] = {
+            type: ResultType.error,
+            error: e
+          };
+        });
+        return dataResults;
+      }
+      for (let [routeId, result] of Object.entries(results)) {
+        if (isRedirectDataStrategyResultResult(result)) {
+          let response = result.result;
+          dataResults[routeId] = {
+            type: ResultType.redirect,
+            response: normalizeRelativeRoutingRedirectResponse(response, request, routeId, matches, basename, future.v7_relativeSplatPath)
+          };
+        } else {
+          dataResults[routeId] = await convertDataStrategyResultToDataResult(result);
+        }
       }
+      return dataResults;
     }
-    async function callLoadersAndMaybeResolveData(currentMatches, matches, matchesToLoad, fetchersToLoad, request) {
-      let [loaderResults, ...fetcherResults] = await Promise.all([matchesToLoad.length ? callDataStrategy("loader", request, matchesToLoad, matches) : [], ...fetchersToLoad.map(f => {
+    async function callLoadersAndMaybeResolveData(state, matches, matchesToLoad, fetchersToLoad, request) {
+      let currentMatches = state.matches;
+
+      // Kick off loaders and fetchers in parallel
+      let loaderResultsPromise = callDataStrategy("loader", state, request, matchesToLoad, matches, null);
+      let fetcherResultsPromise = Promise.all(fetchersToLoad.map(async f => {
         if (f.matches && f.match && f.controller) {
-          let fetcherRequest = createClientSideRequest(init.history, f.path, f.controller.signal);
-          return callDataStrategy("loader", fetcherRequest, [f.match], f.matches).then(r => r[0]);
+          let results = await callDataStrategy("loader", state, createClientSideRequest(init.history, f.path, f.controller.signal), [f.match], f.matches, f.key);
+          let result = results[f.match.route.id];
+          // Fetcher results are keyed by fetcher key from here on out, not routeId
+          return {
+            [f.key]: result
+          };
         } else {
           return Promise.resolve({
-            type: ResultType.error,
-            error: getInternalRouterError(404, {
-              pathname: f.path
-            })
+            [f.key]: {
+              type: ResultType.error,
+              error: getInternalRouterError(404, {
+                pathname: f.path
+              })
+            }
           });
         }
-      })]);
-      await Promise.all([resolveDeferredResults(currentMatches, matchesToLoad, loaderResults, loaderResults.map(() => request.signal), false, state.loaderData), resolveDeferredResults(currentMatches, fetchersToLoad.map(f => f.match), fetcherResults, fetchersToLoad.map(f => f.controller ? f.controller.signal : null), true)]);
+      }));
+      let loaderResults = await loaderResultsPromise;
+      let fetcherResults = (await fetcherResultsPromise).reduce((acc, r) => Object.assign(acc, r), {});
+      await Promise.all([resolveNavigationDeferredResults(matches, loaderResults, request.signal, currentMatches, state.loaderData), resolveFetcherDeferredResults(matches, fetcherResults, fetchersToLoad)]);
       return {
         loaderResults,
         fetcherResults
@@ -3928,9 +3962,9 @@
         });
       } catch (e) {
         // If the user threw/returned a Response in callLoaderOrAction for a
-        // `queryRoute` call, we throw the `HandlerResult` to bail out early
+        // `queryRoute` call, we throw the `DataStrategyResult` to bail out early
         // and then return or throw the raw Response here accordingly
-        if (isHandlerResult(e) && isResponse(e.result)) {
+        if (isDataStrategyResult(e) && isResponse(e.result)) {
           if (e.type === ResultType.error) {
             throw e.result;
           }
@@ -3961,7 +3995,7 @@
         };
       } else {
         let results = await callDataStrategy("action", request, [actionMatch], matches, isRouteRequest, requestContext, unstable_dataStrategy);
-        result = results[0];
+        result = results[actionMatch.route.id];
         if (request.signal.aborted) {
           throwStaticHandlerAbortedError(request, isRouteRequest, future);
         }
@@ -4083,7 +4117,7 @@
 
       // Process and commit output from loaders
       let activeDeferreds = new Map();
-      let context = processRouteLoaderData(matches, matchesToLoad, results, pendingActionResult, activeDeferreds, skipLoaderErrorBubbling);
+      let context = processRouteLoaderData(matches, results, pendingActionResult, activeDeferreds, skipLoaderErrorBubbling);
 
       // Add a null for any non-loader matches for proper revalidation on the client
       let executedLoaders = new Set(matchesToLoad.map(match => match.route.id));
@@ -4101,20 +4135,26 @@
     // Utility wrapper for calling dataStrategy server-side without having to
     // pass around the manifest, mapRouteProperties, etc.
     async function callDataStrategy(type, request, matchesToLoad, matches, isRouteRequest, requestContext, unstable_dataStrategy) {
-      let results = await callDataStrategyImpl(unstable_dataStrategy || defaultDataStrategy, type, request, matchesToLoad, matches, manifest, mapRouteProperties, requestContext);
-      return await Promise.all(results.map((result, i) => {
-        if (isRedirectHandlerResult(result)) {
+      let results = await callDataStrategyImpl(unstable_dataStrategy || defaultDataStrategy, type, null, request, matchesToLoad, matches, null, manifest, mapRouteProperties, requestContext);
+      let dataResults = {};
+      await Promise.all(matches.map(async match => {
+        if (!(match.route.id in results)) {
+          return;
+        }
+        let result = results[match.route.id];
+        if (isRedirectDataStrategyResultResult(result)) {
           let response = result.result;
           // Throw redirects and let the server handle them with an HTTP redirect
-          throw normalizeRelativeRoutingRedirectResponse(response, request, matchesToLoad[i].route.id, matches, basename, future.v7_relativeSplatPath);
+          throw normalizeRelativeRoutingRedirectResponse(response, request, match.route.id, matches, basename, future.v7_relativeSplatPath);
         }
         if (isResponse(result.result) && isRouteRequest) {
           // For SSR single-route requests, we want to hand Responses back
           // directly without unwrapping
           throw result;
         }
-        return convertHandlerResultToDataResult(result);
+        dataResults[match.route.id] = await convertDataStrategyResultToDataResult(result);
       }));
+      return dataResults;
     }
     return {
       dataRoutes,
@@ -4603,56 +4643,70 @@
   }
 
   // Default implementation of `dataStrategy` which fetches all loaders in parallel
-  function defaultDataStrategy(opts) {
-    return Promise.all(opts.matches.map(m => m.resolve()));
+  async function defaultDataStrategy(_ref6) {
+    let {
+      matches
+    } = _ref6;
+    let matchesToLoad = matches.filter(m => m.shouldLoad);
+    let results = await Promise.all(matchesToLoad.map(m => m.resolve()));
+    return results.reduce((acc, result, i) => Object.assign(acc, {
+      [matchesToLoad[i].route.id]: result
+    }), {});
   }
-  async function callDataStrategyImpl(dataStrategyImpl, type, request, matchesToLoad, matches, manifest, mapRouteProperties, requestContext) {
-    let routeIdsToLoad = matchesToLoad.reduce((acc, m) => acc.add(m.route.id), new Set());
-    let loadedMatches = new Set();
+  async function callDataStrategyImpl(dataStrategyImpl, type, state, request, matchesToLoad, matches, fetcherKey, manifest, mapRouteProperties, requestContext) {
+    let loadRouteDefinitionsPromises = matches.map(m => m.route.lazy ? loadLazyRouteModule(m.route, mapRouteProperties, manifest) : undefined);
+    let dsMatches = matches.map((match, i) => {
+      let loadRoutePromise = loadRouteDefinitionsPromises[i];
+      let shouldLoad = matchesToLoad.some(m => m.route.id === match.route.id);
+      // `resolve` encapsulates route.lazy(), executing the loader/action,
+      // and mapping return values/thrown errors to a `DataStrategyResult`.  Users
+      // can pass a callback to take fine-grained control over the execution
+      // of the loader/action
+      let resolve = async handlerOverride => {
+        if (handlerOverride && request.method === "GET" && (match.route.lazy || match.route.loader)) {
+          shouldLoad = true;
+        }
+        return shouldLoad ? callLoaderOrAction(type, request, match, loadRoutePromise, handlerOverride, requestContext) : Promise.resolve({
+          type: ResultType.data,
+          result: undefined
+        });
+      };
+      return _extends({}, match, {
+        shouldLoad,
+        resolve
+      });
+    });
 
     // Send all matches here to allow for a middleware-type implementation.
     // handler will be a no-op for unneeded routes and we filter those results
     // back out below.
     let results = await dataStrategyImpl({
-      matches: matches.map(match => {
-        let shouldLoad = routeIdsToLoad.has(match.route.id);
-        // `resolve` encapsulates the route.lazy, executing the
-        // loader/action, and mapping return values/thrown errors to a
-        // HandlerResult.  Users can pass a callback to take fine-grained control
-        // over the execution of the loader/action
-        let resolve = handlerOverride => {
-          loadedMatches.add(match.route.id);
-          return shouldLoad ? callLoaderOrAction(type, request, match, manifest, mapRouteProperties, handlerOverride, requestContext) : Promise.resolve({
-            type: ResultType.data,
-            result: undefined
-          });
-        };
-        return _extends({}, match, {
-          shouldLoad,
-          resolve
-        });
-      }),
+      matches: dsMatches,
       request,
       params: matches[0].params,
+      fetcherKey,
       context: requestContext
     });
 
-    // Throw if any loadRoute implementations not called since they are what
-    // ensures a route is fully loaded
-    matches.forEach(m => invariant(loadedMatches.has(m.route.id), "`match.resolve()` was not called for route id \"" + m.route.id + "\". " + "You must call `match.resolve()` on every match passed to " + "`dataStrategy` to ensure all routes are properly loaded."));
-
-    // Filter out any middleware-only matches for which we didn't need to run handlers
-    return results.filter((_, i) => routeIdsToLoad.has(matches[i].route.id));
+    // Wait for all routes to load here but 'swallow the error since we want
+    // it to bubble up from the `await loadRoutePromise` in `callLoaderOrAction` -
+    // called from `match.resolve()`
+    try {
+      await Promise.all(loadRouteDefinitionsPromises);
+    } catch (e) {
+      // No-op
+    }
+    return results;
   }
 
   // Default logic for calling a loader/action is the user has no specified a dataStrategy
-  async function callLoaderOrAction(type, request, match, manifest, mapRouteProperties, handlerOverride, staticContext) {
+  async function callLoaderOrAction(type, request, match, loadRoutePromise, handlerOverride, staticContext) {
     let result;
     let onReject;
     let runHandler = handler => {
       // Setup a promise we can race against so that abort signals short circuit
       let reject;
-      // This will never resolve so safe to type it as Promise<HandlerResult> to
+      // This will never resolve so safe to type it as Promise<DataStrategyResult> to
       // satisfy the function return value
       let abortPromise = new Promise((_, r) => reject = r);
       onReject = () => reject();
@@ -4667,30 +4721,27 @@
           context: staticContext
         }, ...(ctx !== undefined ? [ctx] : []));
       };
-      let handlerPromise;
-      if (handlerOverride) {
-        handlerPromise = handlerOverride(ctx => actualHandler(ctx));
-      } else {
-        handlerPromise = (async () => {
-          try {
-            let val = await actualHandler();
-            return {
-              type: "data",
-              result: val
-            };
-          } catch (e) {
-            return {
-              type: "error",
-              result: e
-            };
-          }
-        })();
-      }
+      let handlerPromise = (async () => {
+        try {
+          let val = await (handlerOverride ? handlerOverride(ctx => actualHandler(ctx)) : actualHandler());
+          return {
+            type: "data",
+            result: val
+          };
+        } catch (e) {
+          return {
+            type: "error",
+            result: e
+          };
+        }
+      })();
       return Promise.race([handlerPromise, abortPromise]);
     };
     try {
       let handler = match.route[type];
-      if (match.route.lazy) {
+
+      // If we have a route.lazy promise, await that first
+      if (loadRoutePromise) {
         if (handler) {
           // Run statically defined handler in parallel with lazy()
           let handlerError;
@@ -4700,14 +4751,14 @@
           // route has a boundary that can handle the error
           runHandler(handler).catch(e => {
             handlerError = e;
-          }), loadLazyRouteModule(match.route, mapRouteProperties, manifest)]);
+          }), loadRoutePromise]);
           if (handlerError !== undefined) {
             throw handlerError;
           }
           result = value;
         } else {
           // Load lazy route module, then run any returned handler
-          await loadLazyRouteModule(match.route, mapRouteProperties, manifest);
+          await loadRoutePromise;
           handler = match.route[type];
           if (handler) {
             // Handler still runs even if we got interrupted to maintain consistency
@@ -4743,7 +4794,7 @@
       invariant(result.result !== undefined, "You defined " + (type === "action" ? "an action" : "a loader") + " for route " + ("\"" + match.route.id + "\" but didn't return anything from your `" + type + "` ") + "function. Please return a value or `null`.");
     } catch (e) {
       // We should already be catching and converting normal handler executions to
-      // HandlerResults and returning them, so anything that throws here is an
+      // DataStrategyResults and returning them, so anything that throws here is an
       // unexpected error we still need to wrap
       return {
         type: ResultType.error,
@@ -4756,11 +4807,11 @@
     }
     return result;
   }
-  async function convertHandlerResultToDataResult(handlerResult) {
+  async function convertDataStrategyResultToDataResult(dataStrategyResult) {
     let {
       result,
       type
-    } = handlerResult;
+    } = dataStrategyResult;
     if (isResponse(result)) {
       let data;
       try {
@@ -4916,7 +4967,7 @@
     }
     return formData;
   }
-  function processRouteLoaderData(matches, matchesToLoad, results, pendingActionResult, activeDeferreds, skipLoaderErrorBubbling) {
+  function processRouteLoaderData(matches, results, pendingActionResult, activeDeferreds, skipLoaderErrorBubbling) {
     // Fill in loaderData/errors from our loaders
     let loaderData = {};
     let errors = null;
@@ -4926,8 +4977,12 @@
     let pendingError = pendingActionResult && isErrorResult(pendingActionResult[1]) ? pendingActionResult[1].error : undefined;
 
     // Process loader results into state.loaderData/state.errors
-    results.forEach((result, index) => {
-      let id = matchesToLoad[index].route.id;
+    matches.forEach(match => {
+      if (!(match.route.id in results)) {
+        return;
+      }
+      let id = match.route.id;
+      let result = results[id];
       invariant(!isRedirectResult(result), "Cannot handle redirect results in processLoaderData");
       if (isErrorResult(result)) {
         let error = result.error;
@@ -5009,23 +5064,23 @@
     let {
       loaderData,
       errors
-    } = processRouteLoaderData(matches, matchesToLoad, results, pendingActionResult, activeDeferreds, false // This method is only called client side so we always want to bubble
+    } = processRouteLoaderData(matches, results, pendingActionResult, activeDeferreds, false // This method is only called client side so we always want to bubble
     );
 
     // Process results from our revalidating fetchers
-    for (let index = 0; index < revalidatingFetchers.length; index++) {
+    revalidatingFetchers.forEach(rf => {
       let {
         key,
         match,
         controller
-      } = revalidatingFetchers[index];
-      invariant(fetcherResults !== undefined && fetcherResults[index] !== undefined, "Did not find corresponding fetcher result");
-      let result = fetcherResults[index];
+      } = rf;
+      let result = fetcherResults[key];
+      invariant(result, "Did not find corresponding fetcher result");
 
       // Process fetcher non-redirect errors
       if (controller && controller.signal.aborted) {
         // Nothing to do for aborted fetchers
-        continue;
+        return;
       } else if (isErrorResult(result)) {
         let boundaryMatch = findNearestBoundary(state.matches, match == null ? void 0 : match.route.id);
         if (!(errors && errors[boundaryMatch.route.id])) {
@@ -5046,7 +5101,7 @@
         let doneFetcher = getDoneFetcher(result.data);
         state.fetchers.set(key, doneFetcher);
       }
-    }
+    });
     return {
       loaderData,
       errors
@@ -5148,12 +5203,13 @@
 
   // Find any returned redirect errors, starting from the lowest match
   function findRedirect(results) {
-    for (let i = results.length - 1; i >= 0; i--) {
-      let result = results[i];
+    let entries = Object.entries(results);
+    for (let i = entries.length - 1; i >= 0; i--) {
+      let [key, result] = entries[i];
       if (isRedirectResult(result)) {
         return {
-          result,
-          idx: i
+          key,
+          result
         };
       }
     }
@@ -5186,10 +5242,10 @@
   function isPromise(val) {
     return typeof val === "object" && val != null && "then" in val;
   }
-  function isHandlerResult(result) {
+  function isDataStrategyResult(result) {
     return result != null && typeof result === "object" && "type" in result && "result" in result && (result.type === ResultType.data || result.type === ResultType.error);
   }
-  function isRedirectHandlerResult(result) {
+  function isRedirectDataStrategyResultResult(result) {
     return isResponse(result.result) && redirectStatusCodes.has(result.result.status);
   }
   function isDeferredResult(result) {
@@ -5225,10 +5281,11 @@
   function isMutationMethod(method) {
     return validMutationMethods.has(method.toLowerCase());
   }
-  async function resolveDeferredResults(currentMatches, matchesToLoad, results, signals, isFetcher, currentLoaderData) {
-    for (let index = 0; index < results.length; index++) {
-      let result = results[index];
-      let match = matchesToLoad[index];
+  async function resolveNavigationDeferredResults(matches, results, signal, currentMatches, currentLoaderData) {
+    let entries = Object.entries(results);
+    for (let index = 0; index < entries.length; index++) {
+      let [routeId, result] = entries[index];
+      let match = matches.find(m => (m == null ? void 0 : m.route.id) === routeId);
       // If we don't have a match, then we can have a deferred result to do
       // anything with.  This is for revalidating fetchers where the route was
       // removed during HMR
@@ -5237,15 +5294,41 @@
       }
       let currentMatch = currentMatches.find(m => m.route.id === match.route.id);
       let isRevalidatingLoader = currentMatch != null && !isNewRouteInstance(currentMatch, match) && (currentLoaderData && currentLoaderData[match.route.id]) !== undefined;
-      if (isDeferredResult(result) && (isFetcher || isRevalidatingLoader)) {
+      if (isDeferredResult(result) && isRevalidatingLoader) {
+        // Note: we do not have to touch activeDeferreds here since we race them
+        // against the signal in resolveDeferredData and they'll get aborted
+        // there if needed
+        await resolveDeferredData(result, signal, false).then(result => {
+          if (result) {
+            results[routeId] = result;
+          }
+        });
+      }
+    }
+  }
+  async function resolveFetcherDeferredResults(matches, results, revalidatingFetchers) {
+    for (let index = 0; index < revalidatingFetchers.length; index++) {
+      let {
+        key,
+        routeId,
+        controller
+      } = revalidatingFetchers[index];
+      let result = results[key];
+      let match = matches.find(m => (m == null ? void 0 : m.route.id) === routeId);
+      // If we don't have a match, then we can have a deferred result to do
+      // anything with.  This is for revalidating fetchers where the route was
+      // removed during HMR
+      if (!match) {
+        continue;
+      }
+      if (isDeferredResult(result)) {
         // Note: we do not have to touch activeDeferreds here since we race them
         // against the signal in resolveDeferredData and they'll get aborted
         // there if needed
-        let signal = signals[index];
-        invariant(signal, "Expected an AbortSignal for revalidating fetcher deferred result");
-        await resolveDeferredData(result, signal, isFetcher).then(result => {
+        invariant(controller, "Expected an AbortController for revalidating fetcher deferred result");
+        await resolveDeferredData(result, controller.signal, true).then(result => {
           if (result) {
-            results[index] = result || results[index];
+            results[key] = result;
           }
         });
       }