Changeset 0c6b92a for imaps-frontend/node_modules/@remix-run/router/dist/router.umd.js

Timestamp:

12/12/24 17:06:06 (5 weeks ago)

Author:

stefan toskovski <stefantoska84@…>

Branches:

main

Parents:

d565449

Message:

Pred finalna verzija

File:

• imaps-frontend/node_modules/@remix-run/router/dist/router.umd.js (modified) (103 diffs)

imaps-frontend/node_modules/@remix-run/router/dist/router.umd.js

@@ -1 +1 @@
 /**
- * @remix-run/router v1.19.0
+ * @remix-run/router v1.21.0
  *
  * Copyright (c) Remix Software Inc.
@@ -581 +581 @@
 
   /**
-   * 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 +644 @@
    *
    * @deprecated Use `mapRouteProperties` instead
+   */
+  /**
+   * Result from a loader or action called via dataStrategy
    */
   /**
@@ -748 +747 @@
    * Matches the given routes to a location and returns the match data.
    *
-   * @see https://reactrouter.com/utils/match-routes
+   * @see https://reactrouter.com/v6/utils/match-routes
    */
   function matchRoutes(routes, locationArg, basename) {
@@ -981 +980 @@
    * Returns a path with params interpolated.
    *
-   * @see https://reactrouter.com/utils/generate-path
+   * @see https://reactrouter.com/v6/utils/generate-path
    */
   function generatePath(originalPath, params) {
@@ -1033 +1032 @@
    * the match.
    *
-   * @see https://reactrouter.com/utils/match-path
+   * @see https://reactrouter.com/v6/utils/match-path
    */
   function matchPath(pattern, pathname) {
@@ -1148 +1147 @@
    * Returns a resolved path object relative to the given pathname.
    *
-   * @see https://reactrouter.com/utils/resolve-path
+   * @see https://reactrouter.com/v6/utils/resolve-path
    */
   function resolvePath(to, fromPathname) {
@@ -1314 +1313 @@
    * This is a shortcut for creating `application/json` responses. Converts `data`
    * to JSON and sets the `Content-Type` header.
+   *
+   * @deprecated The `json` method is deprecated in favor of returning raw objects.
+   * This method will be removed in v7.
    */
   const json = function json(data, init) {
@@ -1487 +1489 @@
     return value._data;
   }
+  /**
+   * @deprecated The `defer` method is deprecated in favor of returning raw
+   * objects. This method will be removed in v7.
+   */
   const defer = function defer(data, init) {
     if (init === void 0) {
@@ -1715 +1721 @@
     let inFlightDataRoutes;
     let basename = init.basename || "/";
-    let dataStrategyImpl = init.unstable_dataStrategy || defaultDataStrategy;
-    let patchRoutesOnMissImpl = init.unstable_patchRoutesOnMiss;
+    let dataStrategyImpl = init.dataStrategy || defaultDataStrategy;
+    let patchRoutesOnNavigationImpl = init.patchRoutesOnNavigation;
 
     // Config driven behavior flags
@@ -1746 +1752 @@
     let initialMatches = matchRoutes(dataRoutes, init.history.location, basename);
     let initialErrors = null;
-    if (initialMatches == null && !patchRoutesOnMissImpl) {
+    if (initialMatches == null && !patchRoutesOnNavigationImpl) {
       // If we do not match a user-provided-route, fall back to the root
       // to allow the error boundary to take over
@@ -1762 +1768 @@
     }
 
-    // In SPA apps, if the user provided a patchRoutesOnMiss implementation and
+    // In SPA apps, if the user provided a patchRoutesOnNavigation implementation and
     // our initial match is a splat route, clear them out so we run through lazy
     // discovery on hydration in case there's a more accurate lazy route match.
@@ -1780 +1786 @@
 
       // If partial hydration and fog of war is enabled, we will be running
-      // `patchRoutesOnMiss` during hydration so include any partial matches as
+      // `patchRoutesOnNavigation` during hydration so include any partial matches as
       // the initial matches so we can properly render `HydrateFallback`'s
       if (future.v7_partialHydration) {
@@ -1801 +1807 @@
       let loaderData = init.hydrationData ? init.hydrationData.loaderData : null;
       let errors = init.hydrationData ? init.hydrationData.errors : null;
-      let isRouteInitialized = m => {
-        // No loader, nothing to initialize
-        if (!m.route.loader) {
-          return true;
-        }
-        // Explicitly opting-in to running on hydration
-        if (typeof m.route.loader === "function" && m.route.loader.hydrate === true) {
-          return false;
-        }
-        // Otherwise, initialized if hydrated with data or an error
-        return loaderData && loaderData[m.route.id] !== undefined || errors && errors[m.route.id] !== undefined;
-      };
-
       // If errors exist, don't consider routes below the boundary
       if (errors) {
         let idx = initialMatches.findIndex(m => errors[m.route.id] !== undefined);
-        initialized = initialMatches.slice(0, idx + 1).every(isRouteInitialized);
+        initialized = initialMatches.slice(0, idx + 1).every(m => !shouldLoadRouteOnHydration(m.route, loaderData, errors));
       } else {
-        initialized = initialMatches.every(isRouteInitialized);
+        initialized = initialMatches.every(m => !shouldLoadRouteOnHydration(m.route, loaderData, errors));
       }
     } else {
@@ -1919 +1912 @@
     let blockerFunctions = new Map();
 
-    // Map of pending patchRoutesOnMiss() promises (keyed by path/matches) so
-    // that we only kick them off once for a given combo
-    let pendingPatchRoutes = new Map();
-
     // 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.
@@ -1941 +1930 @@
         // 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;
         }
@@ -1953 +1943 @@
         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);
 
@@ -1967 +1959 @@
                 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() {
@@ -2055 +2049 @@
       [...subscribers].forEach(subscriber => subscriber(state, {
         deletedFetchers: deletedFetchersKeys,
-        unstable_viewTransitionOpts: opts.viewTransitionOpts,
-        unstable_flushSync: opts.flushSync === true
+        viewTransitionOpts: opts.viewTransitionOpts,
+        flushSync: opts.flushSync === true
       }));
 
@@ -2216 +2210 @@
       }
       let preventScrollReset = opts && "preventScrollReset" in opts ? opts.preventScrollReset === true : undefined;
-      let flushSync = (opts && opts.unstable_flushSync) === true;
+      let flushSync = (opts && opts.flushSync) === true;
       let blockerKey = shouldBlockNavigation({
         currentLocation,
@@ -2254 +2248 @@
         preventScrollReset,
         replace: opts && opts.replace,
-        enableViewTransition: opts && opts.unstable_viewTransition,
+        enableViewTransition: opts && opts.viewTransition,
         flushSync
       });
@@ -2288 +2282 @@
       // 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
       });
     }
@@ -2340 +2336 @@
       // mutation submission.
       //
-      // Ignore on initial page loads because since the initial load will always
+      // Ignore on initial page loads because since the initial hydration will always
       // be "same hash".  For example, on /page#hash and submit a <Form method="post">
       // which will default to a navigation to /page
@@ -2447 +2443 @@
           };
         } else if (discoverResult.type === "error") {
-          let {
-            boundaryId,
-            error
-          } = handleDiscoverRouteError(location.pathname, discoverResult);
+          let boundaryId = findNearestBoundary(discoverResult.partialMatches).route.id;
           return {
             matches: discoverResult.partialMatches,
             pendingActionResult: [boundaryId, {
               type: ResultType.error,
-              error
+              error: discoverResult.error
             }]
           };
@@ -2489 +2482 @@
         };
       } 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 {
@@ -2508 +2501 @@
           replace = location === state.location.pathname + state.location.search;
         }
-        await startRedirectNavigation(request, result, {
+        await startRedirectNavigation(request, result, true, {
           submission,
           replace
@@ -2585 +2578 @@
           };
         } else if (discoverResult.type === "error") {
-          let {
-            boundaryId,
-            error
-          } = handleDiscoverRouteError(location.pathname, discoverResult);
+          let boundaryId = findNearestBoundary(discoverResult.partialMatches).route.id;
           return {
             matches: discoverResult.partialMatches,
             loaderData: {},
             errors: {
-              [boundaryId]: error
+              [boundaryId]: discoverResult.error
             }
           };
@@ -2659 +2649 @@
       }
       revalidatingFetchers.forEach(rf => {
-        if (fetchControllers.has(rf.key)) {
-          abortFetcher(rf.key);
-        }
+        abortFetcher(rf.key);
         if (rf.controller) {
           // Fetchers use an independent AbortController so that aborting a fetcher
@@ -2678 +2666 @@
         loaderResults,
         fetcherResults
-      } = await callLoadersAndMaybeResolveData(state.matches, matches, matchesToLoad, revalidatingFetchers, request);
+      } = await callLoadersAndMaybeResolveData(state, matches, matchesToLoad, revalidatingFetchers, request);
       if (request.signal.aborted) {
         return {
@@ -2694 +2682 @@
 
       // 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
         });
@@ -2710 +2691 @@
         };
       }
+      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 {
+          shortCircuited: true
+        };
+      }
 
       // Process and commit output from loaders
@@ -2715 +2709 @@
         loaderData,
         errors
-      } = processLoaderData(state, matches, matchesToLoad, loaderResults, pendingActionResult, revalidatingFetchers, fetcherResults, activeDeferreds);
+      } = processLoaderData(state, matches, loaderResults, pendingActionResult, revalidatingFetchers, fetcherResults, activeDeferreds);
 
       // Wire up subscribers to update loaderData as promises settle
@@ -2729 +2723 @@
       });
 
-      // During partial hydration, preserve SSR errors for routes that don't re-run
+      // Preserve SSR errors during partial hydration
       if (future.v7_partialHydration && initialHydration && state.errors) {
-        Object.entries(state.errors).filter(_ref2 => {
-          let [id] = _ref2;
-          return !matchesToLoad.some(m => m.route.id === id);
-        }).forEach(_ref3 => {
-          let [routeId, error] = _ref3;
-          errors = Object.assign(errors || {}, {
-            [routeId]: error
-          });
-        });
+        errors = _extends({}, state.errors, errors);
       }
       let updatedFetchers = markFetchRedirectsDone();
@@ -2782 +2768 @@
         throw new Error("router.fetch() was called during the server render, but it shouldn't be. " + "You are likely calling a useFetcher() method in the body of your component. " + "Try moving it to a useEffect or a callback.");
       }
-      if (fetchControllers.has(key)) abortFetcher(key);
-      let flushSync = (opts && opts.unstable_flushSync) === true;
+      abortFetcher(key);
+      let flushSync = (opts && opts.flushSync) === true;
       let routesToUse = inFlightDataRoutes || dataRoutes;
       let normalizedPath = normalizeTo(state.location, state.matches, basename, future.v7_prependBasename, href, future.v7_relativeSplatPath, routeId, opts == null ? void 0 : opts.relative);
@@ -2811 +2797 @@
       }
       let match = getTargetMatch(matches, path);
-      pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;
+      let preventScrollReset = (opts && opts.preventScrollReset) === true;
       if (submission && isMutationMethod(submission.formMethod)) {
-        handleFetcherAction(key, routeId, path, match, matches, fogOfWar.active, flushSync, submission);
+        handleFetcherAction(key, routeId, path, match, matches, fogOfWar.active, flushSync, preventScrollReset, submission);
         return;
       }
@@ -2823 +2809 @@
         path
       });
-      handleFetcherLoader(key, routeId, path, match, matches, fogOfWar.active, flushSync, submission);
+      handleFetcherLoader(key, routeId, path, match, matches, fogOfWar.active, flushSync, preventScrollReset, submission);
     }
 
     // Call the action for the matched fetcher.submit(), and then handle redirects,
     // errors, and revalidation
-    async function handleFetcherAction(key, routeId, path, match, requestMatches, isFogOfWar, flushSync, submission) {
+    async function handleFetcherAction(key, routeId, path, match, requestMatches, isFogOfWar, flushSync, preventScrollReset, submission) {
       interruptActiveLoads();
       fetchLoadMatches.delete(key);
@@ -2861 +2847 @@
           return;
         } else if (discoverResult.type === "error") {
-          let {
-            error
-          } = handleDiscoverRouteError(path, discoverResult);
-          setFetcherError(key, routeId, error, {
+          setFetcherError(key, routeId, discoverResult.error, {
             flushSync
           });
@@ -2887 +2870 @@
       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
@@ -2920 +2903 @@
             fetchRedirectIds.add(key);
             updateFetcherState(key, getLoadingFetcher(submission));
-            return startRedirectNavigation(fetchRequest, actionResult, {
-              fetcherSubmission: submission
+            return startRedirectNavigation(fetchRequest, actionResult, false, {
+              fetcherSubmission: submission,
+              preventScrollReset
             });
           }
@@ -2959 +2943 @@
         let revalidatingFetcher = getLoadingFetcher(undefined, existingFetcher ? existingFetcher.data : undefined);
         state.fetchers.set(staleKey, revalidatingFetcher);
-        if (fetchControllers.has(staleKey)) {
-          abortFetcher(staleKey);
-        }
+        abortFetcher(staleKey);
         if (rf.controller) {
           fetchControllers.set(staleKey, rf.controller);
@@ -2974 +2956 @@
         loaderResults,
         fetcherResults
-      } = await callLoadersAndMaybeResolveData(state.matches, matches, matchesToLoad, revalidatingFetchers, revalidationRequest);
+      } = await callLoadersAndMaybeResolveData(state, matches, matchesToLoad, revalidatingFetchers, revalidationRequest);
       if (abortController.signal.aborted) {
         return;
@@ -2982 +2964 @@
       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, {
+          preventScrollReset
+        });
+      }
+      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, {
+          preventScrollReset
+        });
       }
 
@@ -2998 +2985 @@
         loaderData,
         errors
-      } = processLoaderData(state, state.matches, matchesToLoad, loaderResults, undefined, revalidatingFetchers, fetcherResults, activeDeferreds);
+      } = processLoaderData(state, matches, loaderResults, undefined, revalidatingFetchers, fetcherResults, activeDeferreds);
 
       // Since we let revalidations complete even if the submitting fetcher was
@@ -3034 +3021 @@
 
     // Call the matched loader for fetcher.load(), handling redirects, errors, etc.
-    async function handleFetcherLoader(key, routeId, path, match, matches, isFogOfWar, flushSync, submission) {
+    async function handleFetcherLoader(key, routeId, path, match, matches, isFogOfWar, flushSync, preventScrollReset, submission) {
       let existingFetcher = state.fetchers.get(key);
       updateFetcherState(key, getLoadingFetcher(submission, existingFetcher ? existingFetcher.data : undefined), {
@@ -3046 +3033 @@
           return;
         } else if (discoverResult.type === "error") {
-          let {
-            error
-          } = handleDiscoverRouteError(path, discoverResult);
-          setFetcherError(key, routeId, error, {
+          setFetcherError(key, routeId, discoverResult.error, {
             flushSync
           });
@@ -3069 +3053 @@
       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
@@ -3105 +3089 @@
         } else {
           fetchRedirectIds.add(key);
-          await startRedirectNavigation(fetchRequest, result);
+          await startRedirectNavigation(fetchRequest, result, false, {
+            preventScrollReset
+          });
           return;
         }
@@ -3140 +3126 @@
      * 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,
+        preventScrollReset,
         replace
       } = _temp2 === void 0 ? {} : _temp2;
@@ -3203 +3190 @@
             formAction: location
           }),
-          // Preserve this flag across redirects
-          preventScrollReset: pendingPreventScrollReset
+          // Preserve these flags across redirects
+          preventScrollReset: preventScrollReset || pendingPreventScrollReset,
+          enableViewTransition: isNavigation ? pendingViewTransitionEnabled : undefined
         });
       } else {
@@ -3214 +3202 @@
           // Send fetcher submissions through for shouldRevalidate
           fetcherSubmission,
-          // Preserve this flag across redirects
-          preventScrollReset: pendingPreventScrollReset
+          // Preserve these flags across redirects
+          preventScrollReset: preventScrollReset || pendingPreventScrollReset,
+          enableViewTransition: isNavigation ? pendingViewTransitionEnabled : undefined
         });
       }
@@ -3222 +3211 @@
     // 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
-        }));
-      }
-    }
-    async function callLoadersAndMaybeResolveData(currentMatches, matches, matchesToLoad, fetchersToLoad, request) {
-      let [loaderResults, ...fetcherResults] = await Promise.all([matchesToLoad.length ? callDataStrategy("loader", request, matchesToLoad, matches) : [], ...fetchersToLoad.map(f => {
+        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(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,
@@ -3276 +3284 @@
         if (fetchControllers.has(key)) {
           cancelledFetcherLoads.add(key);
-          abortFetcher(key);
-        }
+        }
+        abortFetcher(key);
       });
     }
@@ -3350 +3358 @@
     function abortFetcher(key) {
       let controller = fetchControllers.get(key);
-      invariant(controller, "Expected fetch controller: " + key);
-      controller.abort();
-      fetchControllers.delete(key);
+      if (controller) {
+        controller.abort();
+        fetchControllers.delete(key);
+      }
     }
     function markFetchersDone(keys) {
@@ -3417 +3426 @@
       });
     }
-    function shouldBlockNavigation(_ref4) {
+    function shouldBlockNavigation(_ref2) {
       let {
         currentLocation,
         nextLocation,
         historyAction
-      } = _ref4;
+      } = _ref2;
       if (blockerFunctions.size === 0) {
         return;
@@ -3467 +3476 @@
         route,
         error
-      };
-    }
-    function handleDiscoverRouteError(pathname, discoverResult) {
-      return {
-        boundaryId: findNearestBoundary(discoverResult.partialMatches).route.id,
-        error: getInternalRouterError(400, {
-          type: "route-discovery",
-          pathname,
-          message: discoverResult.error != null && "message" in discoverResult.error ? discoverResult.error : String(discoverResult.error)
-        })
       };
     }
@@ -3543 +3542 @@
     }
     function checkFogOfWar(matches, routesToUse, pathname) {
-      if (patchRoutesOnMissImpl) {
+      if (patchRoutesOnNavigationImpl) {
         if (!matches) {
           let fogMatches = matchRoutesImpl(routesToUse, pathname, basename, true);
@@ -3551 +3550 @@
           };
         } else {
-          let leafRoute = matches[matches.length - 1].route;
-          if (leafRoute.path && (leafRoute.path === "*" || leafRoute.path.endsWith("/*"))) {
-            // If we matched a splat, it might only be because we haven't yet fetched
-            // the children that would match with a higher score, so let's fetch
-            // around and find out
+          if (Object.keys(matches[0].params).length > 0) {
+            // If we matched a dynamic param or a splat, it might only be because
+            // we haven't yet discovered other routes that would match with a
+            // higher score.  Call patchRoutesOnNavigation just to be sure
             let partialMatches = matchRoutesImpl(routesToUse, pathname, basename, true);
             return {
@@ -3570 +3568 @@
     }
     async function discoverRoutes(matches, pathname, signal) {
+      if (!patchRoutesOnNavigationImpl) {
+        return {
+          type: "success",
+          matches
+        };
+      }
       let partialMatches = matches;
-      let route = partialMatches.length > 0 ? partialMatches[partialMatches.length - 1].route : null;
       while (true) {
         let isNonHMR = inFlightDataRoutes == null;
         let routesToUse = inFlightDataRoutes || dataRoutes;
+        let localManifest = manifest;
         try {
-          await loadLazyRouteChildren(patchRoutesOnMissImpl, pathname, partialMatches, routesToUse, manifest, mapRouteProperties, pendingPatchRoutes, signal);
+          await patchRoutesOnNavigationImpl({
+            path: pathname,
+            matches: partialMatches,
+            patch: (routeId, children) => {
+              if (signal.aborted) return;
+              patchRoutesImpl(routeId, children, routesToUse, localManifest, mapRouteProperties);
+            }
+          });
         } catch (e) {
           return {
@@ -3590 +3601 @@
           // HMR will already update the identity and reflow when it lands
           // `inFlightDataRoutes` in `completeNavigation`
-          if (isNonHMR) {
+          if (isNonHMR && !signal.aborted) {
             dataRoutes = [...dataRoutes];
           }
@@ -3600 +3611 @@
         }
         let newMatches = matchRoutes(routesToUse, pathname, basename);
-        let matchedSplat = false;
         if (newMatches) {
-          let leafRoute = newMatches[newMatches.length - 1].route;
-          if (leafRoute.index) {
-            // If we found an index route, we can stop
-            return {
-              type: "success",
-              matches: newMatches
-            };
-          }
-          if (leafRoute.path && leafRoute.path.length > 0) {
-            if (leafRoute.path === "*") {
-              // If we found a splat route, we can't be sure there's not a
-              // higher-scoring route down some partial matches trail so we need
-              // to check that out
-              matchedSplat = true;
-            } else {
-              // If we found a non-splat route, we can stop
-              return {
-                type: "success",
-                matches: newMatches
-              };
-            }
-          }
-        }
-        let newPartialMatches = matchRoutesImpl(routesToUse, pathname, basename, true);
-
-        // If we are no longer partially matching anything, this was either a
-        // legit splat match above, or it's a 404.  Also avoid loops if the
-        // second pass results in the same partial matches
-        if (!newPartialMatches || partialMatches.map(m => m.route.id).join("-") === newPartialMatches.map(m => m.route.id).join("-")) {
           return {
             type: "success",
-            matches: matchedSplat ? newMatches : null
+            matches: newMatches
           };
         }
-        partialMatches = newPartialMatches;
-        route = partialMatches[partialMatches.length - 1].route;
-        if (route.path === "*") {
-          // The splat is still our most accurate partial, so run with it
+        let newPartialMatches = matchRoutesImpl(routesToUse, pathname, basename, true);
+
+        // Avoid loops if the second pass results in the same partial matches
+        if (!newPartialMatches || partialMatches.length === newPartialMatches.length && partialMatches.every((m, i) => m.route.id === newPartialMatches[i].route.id)) {
           return {
             type: "success",
-            matches: partialMatches
+            matches: null
           };
         }
+        partialMatches = newPartialMatches;
       }
     }
@@ -3771 +3753 @@
         requestContext,
         skipLoaderErrorBubbling,
-        unstable_dataStrategy
+        dataStrategy
       } = _temp3 === void 0 ? {} : _temp3;
       let url = new URL(request.url);
@@ -3824 +3806 @@
         };
       }
-      let result = await queryImpl(request, location, matches, requestContext, unstable_dataStrategy || null, skipLoaderErrorBubbling === true, null);
+      let result = await queryImpl(request, location, matches, requestContext, dataStrategy || null, skipLoaderErrorBubbling === true, null);
       if (isResponse(result)) {
         return result;
@@ -3868 +3850 @@
         routeId,
         requestContext,
-        unstable_dataStrategy
+        dataStrategy
       } = _temp4 === void 0 ? {} : _temp4;
       let url = new URL(request.url);
@@ -3897 +3879 @@
         });
       }
-      let result = await queryImpl(request, location, matches, requestContext, unstable_dataStrategy || null, false, match);
+      let result = await queryImpl(request, location, matches, requestContext, dataStrategy || null, false, match);
       if (isResponse(result)) {
         return result;
@@ -3924 +3906 @@
       return undefined;
     }
-    async function queryImpl(request, location, matches, requestContext, unstable_dataStrategy, skipLoaderErrorBubbling, routeMatch) {
+    async function queryImpl(request, location, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch) {
       invariant(request.signal, "query()/queryRoute() requests must contain an AbortController signal");
       try {
         if (isMutationMethod(request.method.toLowerCase())) {
-          let result = await submit(request, matches, routeMatch || getTargetMatch(matches, location), requestContext, unstable_dataStrategy, skipLoaderErrorBubbling, routeMatch != null);
+          let result = await submit(request, matches, routeMatch || getTargetMatch(matches, location), requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch != null);
           return result;
         }
-        let result = await loadRouteData(request, matches, requestContext, unstable_dataStrategy, skipLoaderErrorBubbling, routeMatch);
+        let result = await loadRouteData(request, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch);
         return isResponse(result) ? result : _extends({}, result, {
           actionData: null,
@@ -3938 +3920 @@
       } 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;
@@ -3954 +3936 @@
       }
     }
-    async function submit(request, matches, actionMatch, requestContext, unstable_dataStrategy, skipLoaderErrorBubbling, isRouteRequest) {
+    async function submit(request, matches, actionMatch, requestContext, dataStrategy, skipLoaderErrorBubbling, isRouteRequest) {
       let result;
       if (!actionMatch.route.action && !actionMatch.route.lazy) {
@@ -3970 +3952 @@
         };
       } else {
-        let results = await callDataStrategy("action", request, [actionMatch], matches, isRouteRequest, requestContext, unstable_dataStrategy);
-        result = results[0];
+        let results = await callDataStrategy("action", request, [actionMatch], matches, isRouteRequest, requestContext, dataStrategy);
+        result = results[actionMatch.route.id];
         if (request.signal.aborted) {
           throwStaticHandlerAbortedError(request, isRouteRequest, future);
@@ -4032 +4014 @@
         // to call and will commit it when we complete the navigation
         let boundaryMatch = skipLoaderErrorBubbling ? actionMatch : findNearestBoundary(matches, actionMatch.route.id);
-        let context = await loadRouteData(loaderRequest, matches, requestContext, unstable_dataStrategy, skipLoaderErrorBubbling, null, [boundaryMatch.route.id, result]);
+        let context = await loadRouteData(loaderRequest, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, null, [boundaryMatch.route.id, result]);
 
         // action status codes take precedence over loader status codes
@@ -4043 +4025 @@
         });
       }
-      let context = await loadRouteData(loaderRequest, matches, requestContext, unstable_dataStrategy, skipLoaderErrorBubbling, null);
+      let context = await loadRouteData(loaderRequest, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, null);
       return _extends({}, context, {
         actionData: {
@@ -4056 +4038 @@
       });
     }
-    async function loadRouteData(request, matches, requestContext, unstable_dataStrategy, skipLoaderErrorBubbling, routeMatch, pendingActionResult) {
+    async function loadRouteData(request, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch, pendingActionResult) {
       let isRouteRequest = routeMatch != null;
 
@@ -4086 +4068 @@
         };
       }
-      let results = await callDataStrategy("loader", request, matchesToLoad, matches, isRouteRequest, requestContext, unstable_dataStrategy);
+      let results = await callDataStrategy("loader", request, matchesToLoad, matches, isRouteRequest, requestContext, dataStrategy);
       if (request.signal.aborted) {
         throwStaticHandlerAbortedError(request, isRouteRequest, future);
@@ -4093 +4075 @@
       // 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
@@ -4110 +4092 @@
     // 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)) {
+    async function callDataStrategy(type, request, matchesToLoad, matches, isRouteRequest, requestContext, dataStrategy) {
+      let results = await callDataStrategyImpl(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) {
@@ -4123 +4110 @@
           throw result;
         }
-        return convertHandlerResultToDataResult(result);
+        dataResults[match.route.id] = await convertDataStrategyResultToDataResult(result);
       }));
+      return dataResults;
     }
     return {
@@ -4192 +4180 @@
     }
 
-    // Add an ?index param for matched index routes if we don't already have one
-    if ((to == null || to === "" || to === ".") && activeRouteMatch && activeRouteMatch.route.index && !hasNakedIndexQuery(path.search)) {
-      path.search = path.search ? path.search.replace(/^\?/, "?index&") : "?index";
+    // Account for `?index` params when routing to the current location
+    if ((to == null || to === "" || to === ".") && activeRouteMatch) {
+      let nakedIndex = hasNakedIndexQuery(path.search);
+      if (activeRouteMatch.route.index && !nakedIndex) {
+        // Add one when we're targeting an index route
+        path.search = path.search ? path.search.replace(/^\?/, "?index&") : "?index";
+      } else if (!activeRouteMatch.route.index && nakedIndex) {
+        // Remove existing ones when we're not
+        let params = new URLSearchParams(path.search);
+        let indexValues = params.getAll("index");
+        params.delete("index");
+        indexValues.filter(v => v).forEach(v => params.append("index", v));
+        let qs = params.toString();
+        path.search = qs ? "?" + qs : "";
+      }
     }
 
@@ -4243 +4243 @@
         let text = typeof opts.body === "string" ? opts.body : opts.body instanceof FormData || opts.body instanceof URLSearchParams ?
         // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#plain-text-form-data
-        Array.from(opts.body.entries()).reduce((acc, _ref5) => {
-          let [name, value] = _ref5;
+        Array.from(opts.body.entries()).reduce((acc, _ref3) => {
+          let [name, value] = _ref3;
           return "" + acc + name + "=" + value + "\n";
         }, "") : String(opts.body);
@@ -4334 +4334 @@
   }
 
-  // Filter out all routes below any caught error as they aren't going to
+  // Filter out all routes at/below any caught error as they aren't going to
   // render so we don't need to load them
-  function getLoaderMatchesUntilBoundary(matches, boundaryId) {
-    let boundaryMatches = matches;
-    if (boundaryId) {
-      let index = matches.findIndex(m => m.route.id === boundaryId);
-      if (index >= 0) {
-        boundaryMatches = matches.slice(0, index);
-      }
-    }
-    return boundaryMatches;
-  }
-  function getMatchesToLoad(history, state, matches, submission, location, isInitialLoad, skipActionErrorRevalidation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, pendingActionResult) {
+  function getLoaderMatchesUntilBoundary(matches, boundaryId, includeBoundary) {
+    if (includeBoundary === void 0) {
+      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, skipActionErrorRevalidation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, pendingActionResult) {
     let actionResult = pendingActionResult ? isErrorResult(pendingActionResult[1]) ? pendingActionResult[1].error : pendingActionResult[1].data : undefined;
     let currentUrl = history.createURL(state.location);
@@ -4352 +4352 @@
 
     // Pick navigation matches that are net-new or qualify for revalidation
-    let boundaryId = pendingActionResult && isErrorResult(pendingActionResult[1]) ? pendingActionResult[0] : undefined;
-    let boundaryMatches = boundaryId ? getLoaderMatchesUntilBoundary(matches, boundaryId) : matches;
+    let boundaryMatches = matches;
+    if (initialHydration && state.errors) {
+      // On initial hydration, only consider matches up to _and including_ the boundary.
+      // This is inclusive to handle cases where a server loader ran successfully,
+      // a child server loader bubbled up to this route, but this route has
+      // `clientLoader.hydrate` so we want to still run the `clientLoader` so that
+      // we have a complete version of `loaderData`
+      boundaryMatches = getLoaderMatchesUntilBoundary(matches, Object.keys(state.errors)[0], true);
+    } else if (pendingActionResult && isErrorResult(pendingActionResult[1])) {
+      // If an action threw an error, we call loaders up to, but not including the
+      // boundary
+      boundaryMatches = getLoaderMatchesUntilBoundary(matches, pendingActionResult[0]);
+    }
 
     // Don't revalidate loaders by default after action 4xx/5xx responses
@@ -4371 +4382 @@
         return false;
       }
-      if (isInitialLoad) {
-        if (typeof route.loader !== "function" || route.loader.hydrate) {
-          return true;
-        }
-        return state.loaderData[route.id] === undefined && (
-        // Don't re-run if the loader ran and threw an error
-        !state.errors || state.errors[route.id] === undefined);
+      if (initialHydration) {
+        return shouldLoadRouteOnHydration(route, state.loaderData, state.errors);
       }
 
@@ -4411 +4417 @@
     fetchLoadMatches.forEach((f, key) => {
       // Don't revalidate:
-      //  - on initial load (shouldn't be any fetchers then anyway)
+      //  - on initial hydration (shouldn't be any fetchers then anyway)
       //  - if fetcher won't be present in the subsequent render
       //    - no longer matches the URL (v7_fetcherPersist=false)
       //    - was unmounted but persisted due to v7_fetcherPersist=true
-      if (isInitialLoad || !matches.some(m => m.route.id === f.routeId) || deletedFetchers.has(key)) {
+      if (initialHydration || !matches.some(m => m.route.id === f.routeId) || deletedFetchers.has(key)) {
         return;
       }
@@ -4481 +4487 @@
     return [navigationMatches, revalidatingFetchers];
   }
+  function shouldLoadRouteOnHydration(route, loaderData, errors) {
+    // We dunno if we have a loader - gotta find out!
+    if (route.lazy) {
+      return true;
+    }
+
+    // No loader, nothing to initialize
+    if (!route.loader) {
+      return false;
+    }
+    let hasData = loaderData != null && loaderData[route.id] !== undefined;
+    let hasError = errors != null && errors[route.id] !== undefined;
+
+    // Don't run if we error'd during SSR
+    if (!hasData && hasError) {
+      return false;
+    }
+
+    // Explicitly opting-in to running on hydration
+    if (typeof route.loader === "function" && route.loader.hydrate === true) {
+      return true;
+    }
+
+    // Otherwise, run if we're not yet initialized with anything
+    return !hasData && !hasError;
+  }
   function isNewLoader(currentLoaderData, currentMatch, match) {
     let isNew =
@@ -4514 +4546 @@
     return arg.defaultShouldRevalidate;
   }
-
-  /**
-   * Idempotent utility to execute patchRoutesOnMiss() to lazily load route
-   * definitions and update the routes/routeManifest
-   */
-  async function loadLazyRouteChildren(patchRoutesOnMissImpl, path, matches, routes, manifest, mapRouteProperties, pendingRouteChildren, signal) {
-    let key = [path, ...matches.map(m => m.route.id)].join("-");
-    try {
-      let pending = pendingRouteChildren.get(key);
-      if (!pending) {
-        pending = patchRoutesOnMissImpl({
-          path,
-          matches,
-          patch: (routeId, children) => {
-            if (!signal.aborted) {
-              patchRoutesImpl(routeId, children, routes, manifest, mapRouteProperties);
-            }
-          }
-        });
-        pendingRouteChildren.set(key, pending);
-      }
-      if (pending && isPromise(pending)) {
-        await pending;
-      }
-    } finally {
-      pendingRouteChildren.delete(key);
-    }
-  }
   function patchRoutesImpl(routeId, children, routesToUse, manifest, mapRouteProperties) {
+    var _childrenToPatch;
+    let childrenToPatch;
     if (routeId) {
-      var _route$children;
       let route = manifest[routeId];
       invariant(route, "No route found to patch children into: routeId = " + routeId);
-      let dataChildren = convertRoutesToDataRoutes(children, mapRouteProperties, [routeId, "patch", String(((_route$children = route.children) == null ? void 0 : _route$children.length) || "0")], manifest);
-      if (route.children) {
-        route.children.push(...dataChildren);
-      } else {
-        route.children = dataChildren;
-      }
+      if (!route.children) {
+        route.children = [];
+      }
+      childrenToPatch = route.children;
     } else {
-      let dataChildren = convertRoutesToDataRoutes(children, mapRouteProperties, ["patch", String(routesToUse.length || "0")], manifest);
-      routesToUse.push(...dataChildren);
-    }
+      childrenToPatch = routesToUse;
+    }
+
+    // Don't patch in routes we already know about so that `patch` is idempotent
+    // to simplify user-land code. This is useful because we re-call the
+    // `patchRoutesOnNavigation` function for matched routes with params.
+    let uniqueChildren = children.filter(newRoute => !childrenToPatch.some(existingRoute => isSameRoute(newRoute, existingRoute)));
+    let newRoutes = convertRoutesToDataRoutes(uniqueChildren, mapRouteProperties, [routeId || "_", "patch", String(((_childrenToPatch = childrenToPatch) == null ? void 0 : _childrenToPatch.length) || "0")], manifest);
+    childrenToPatch.push(...newRoutes);
+  }
+  function isSameRoute(newRoute, existingRoute) {
+    // Most optimal check is by id
+    if ("id" in newRoute && "id" in existingRoute && newRoute.id === existingRoute.id) {
+      return true;
+    }
+
+    // Second is by pathing differences
+    if (!(newRoute.index === existingRoute.index && newRoute.path === existingRoute.path && newRoute.caseSensitive === existingRoute.caseSensitive)) {
+      return false;
+    }
+
+    // Pathless layout routes are trickier since we need to check children.
+    // If they have no children then they're the same as far as we can tell
+    if ((!newRoute.children || newRoute.children.length === 0) && (!existingRoute.children || existingRoute.children.length === 0)) {
+      return true;
+    }
+
+    // Otherwise, we look to see if every child in the new route is already
+    // represented in the existing route's children
+    return newRoute.children.every((aChild, i) => {
+      var _existingRoute$childr;
+      return (_existingRoute$childr = existingRoute.children) == null ? void 0 : _existingRoute$childr.some(bChild => isSameRoute(aChild, bChild));
+    });
   }
 
@@ -4613 +4646 @@
 
   // Default implementation of `dataStrategy` which fetches all loaders in parallel
-  function defaultDataStrategy(opts) {
-    return Promise.all(opts.matches.map(m => m.resolve()));
-  }
-  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 defaultDataStrategy(_ref4) {
+    let {
+      matches
+    } = _ref4;
+    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, 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.
@@ -4624 +4684 @@
     // 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;
@@ -4662 +4709 @@
       // 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);
@@ -4677 +4724 @@
         }, ...(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()
@@ -4710 +4754 @@
           runHandler(handler).catch(e => {
             handlerError = e;
-          }), loadLazyRouteModule(match.route, mapRouteProperties, manifest)]);
+          }), loadRoutePromise]);
           if (handlerError !== undefined) {
             throw handlerError;
@@ -4717 +4761 @@
         } else {
           // Load lazy route module, then run any returned handler
-          await loadLazyRouteModule(match.route, mapRouteProperties, manifest);
+          await loadRoutePromise;
           handler = match.route[type];
           if (handler) {
@@ -4753 +4797 @@
     } 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 {
@@ -4766 +4810 @@
     return result;
   }
-  async function convertHandlerResultToDataResult(handlerResult) {
+  async function convertDataStrategyResultToDataResult(dataStrategyResult) {
     let {
       result,
       type
-    } = handlerResult;
+    } = dataStrategyResult;
     if (isResponse(result)) {
       let data;
@@ -4819 +4863 @@
         }
 
-        // Convert thrown unstable_data() to ErrorResponse instances
+        // Convert thrown data() to ErrorResponse instances
         result = new ErrorResponseImpl(((_result$init2 = result.init) == null ? void 0 : _result$init2.status) || 500, undefined, result.data);
       }
@@ -4926 +4970 @@
     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 = {};
@@ -4936 +4980 @@
 
     // 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)) {
@@ -5015 +5063 @@
     };
   }
-  function processLoaderData(state, matches, matchesToLoad, results, pendingActionResult, revalidatingFetchers, fetcherResults, activeDeferreds) {
+  function processLoaderData(state, matches, results, pendingActionResult, revalidatingFetchers, fetcherResults, activeDeferreds) {
     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);
@@ -5056 +5104 @@
         state.fetchers.set(key, doneFetcher);
       }
-    }
+    });
     return {
       loaderData,
@@ -5130 +5178 @@
     if (status === 400) {
       statusText = "Bad Request";
-      if (type === "route-discovery") {
-        errorMessage = "Unable to match URL \"" + pathname + "\" - the `unstable_patchRoutesOnMiss()` " + ("function threw the following error:\n" + message);
-      } else if (method && pathname && routeId) {
+      if (method && pathname && routeId) {
         errorMessage = "You made a " + method + " request to \"" + pathname + "\" but " + ("did not provide a `loader` for route \"" + routeId + "\", ") + "so there is no way to handle the request.";
       } else if (type === "defer-action") {
@@ -5158 +5204 @@
   // 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
         };
       }
@@ -5193 +5240 @@
     return false;
   }
-  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);
   }
@@ -5235 +5279 @@
     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
@@ -5247 +5292 @@
       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
-        let signal = signals[index];
-        invariant(signal, "Expected an AbortSignal for revalidating fetcher deferred result");
-        await resolveDeferredData(result, signal, isFetcher).then(result => {
+        await resolveDeferredData(result, signal, false).then(result => {
           if (result) {
-            results[index] = result || results[index];
+            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
+        invariant(controller, "Expected an AbortController for revalidating fetcher deferred result");
+        await resolveDeferredData(result, controller.signal, true).then(result => {
+          if (result) {
+            results[key] = result;
           }
         });
@@ -5486 +5557 @@
   exports.createRouter = createRouter;
   exports.createStaticHandler = createStaticHandler;
+  exports.data = data;
   exports.defer = defer;
   exports.generatePath = generatePath;
@@ -5505 +5577 @@
   exports.resolveTo = resolveTo;
   exports.stripBasename = stripBasename;
-  exports.unstable_data = data;
 
   Object.defineProperty(exports, '__esModule', { value: true });