@remix-run/router 0.0.0-experimental-e960cf1a → 0.0.0-experimental-a0888892

package/dist/router.umd.js

@@ -1,5 +1,5 @@
 /**
- * @remix-run/router v0.0.0-experimental-e960cf1a
+ * @remix-run/router v0.0.0-experimental-a0888892
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -498,6 +498,10 @@
       // See https://bugzilla.mozilla.org/show_bug.cgi?id=878297
       let base = window.location.origin !== "null" ? window.location.origin : window.location.href;
       let href = typeof to === "string" ? to : createPath(to);
+      // Treating this as a full URL will strip any trailing spaces so we need to
+      // pre-encode them since they might be part of a matching splat param from
+      // an ancestor route
+      href = href.replace(/ $/, "%20");
       invariant(base, "No window.location.(origin|href) available to create URL for href: " + href);
       return new URL(href, base);
     }
@@ -575,6 +579,10 @@
    * 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.
@@ -754,14 +762,14 @@
     rankRouteBranches(branches);
     let matches = null;
     for (let i = 0; matches == null && i < branches.length; ++i) {
-      matches = matchRouteBranch(branches[i],
       // Incoming pathnames are generally encoded from either window.location
       // or from router.navigate, but we want to match against the unencoded
       // paths in the route definitions.  Memory router locations won't be
       // encoded here but there also shouldn't be anything to decode so this
       // should be a safe operation.  This avoids needing matchRoutes to be
       // history-aware.
-      safelyDecodeURI(pathname));
+      let decoded = decodePath(pathname);
+      matches = matchRouteBranch(branches[i], decoded);
     }
     return matches;
   }
@@ -891,7 +899,7 @@
     branches.sort((a, b) => a.score !== b.score ? b.score - a.score // Higher score first
     : compareIndexes(a.routesMeta.map(meta => meta.childrenIndex), b.routesMeta.map(meta => meta.childrenIndex)));
   }
-  const paramRe = /^:\w+$/;
+  const paramRe = /^:[\w-]+$/;
   const dynamicSegmentValue = 3;
   const indexRouteValue = 2;
   const emptySegmentValue = 1;
@@ -981,7 +989,7 @@
         // Apply the splat
         return stringify(params[star]);
       }
-      const keyMatch = segment.match(/^:(\w+)(\??)$/);
+      const keyMatch = segment.match(/^:([\w-]+)(\??)$/);
       if (keyMatch) {
         const [, key, optional] = keyMatch;
         let param = params[key];
@@ -1040,7 +1048,7 @@
       if (isOptional && !value) {
         memo[paramName] = undefined;
       } else {
-        memo[paramName] = safelyDecodeURIComponent(value || "", paramName);
+        memo[paramName] = (value || "").replace(/%2F/g, "/");
       }
       return memo;
     }, {});
@@ -1063,7 +1071,7 @@
     let regexpSource = "^" + path.replace(/\/*\*?$/, "") // Ignore trailing / and /*, we'll handle it below
     .replace(/^\/*/, "/") // Make sure it has a leading /
     .replace(/[\\.*+^${}|()[\]]/g, "\\$&") // Escape special regex chars
-    .replace(/\/:(\w+)(\?)?/g, (_, paramName, isOptional) => {
+    .replace(/\/:([\w-]+)(\?)?/g, (_, paramName, isOptional) => {
       params.push({
         paramName,
         isOptional: isOptional != null
@@ -1092,22 +1100,14 @@
     let matcher = new RegExp(regexpSource, caseSensitive ? undefined : "i");
     return [matcher, params];
   }
-  function safelyDecodeURI(value) {
+  function decodePath(value) {
     try {
-      return decodeURI(value);
+      return value.split("/").map(v => decodeURIComponent(v).replace(/\//g, "%2F")).join("/");
     } catch (error) {
       warning(false, "The URL path \"" + value + "\" could not be decoded because it is is a " + "malformed URL segment. This is probably due to a bad percent " + ("encoding (" + error + ")."));
       return value;
     }
   }
-  function safelyDecodeURIComponent(value, paramName) {
-    try {
-      return decodeURIComponent(value);
-    } catch (error) {
-      warning(false, "The value for the URL param \"" + paramName + "\" will not be decoded because" + (" the string \"" + value + "\" is a malformed URL segment. This is probably") + (" due to a bad percent encoding (" + error + ")."));
-      return value;
-    }
-  }
 
   /**
    * @private
@@ -1599,11 +1599,6 @@
   /**
    * Identified fetcher.load() calls that need to be revalidated
    */
-  /**
-   * Wrapper object to allow us to throw any response out from callLoaderOrAction
-   * for queryRouter while preserving whether or not it was thrown or returned
-   * from the loader/action
-   */
   const validMutationMethodsArr = ["post", "put", "patch", "delete"];
   const validMutationMethods = new Set(validMutationMethodsArr);
   const validRequestMethodsArr = ["get", ...validMutationMethodsArr];
@@ -1656,8 +1651,6 @@
     const isBrowser = typeof routerWindow !== "undefined" && typeof routerWindow.document !== "undefined" && typeof routerWindow.document.createElement !== "undefined";
     const isServer = !isBrowser;
     invariant(init.routes.length > 0, "You must provide a non-empty routes array to createRouter");
-    const dataStrategy = init.unstable_dataStrategy || defaultDataStrategy;
-    const callLoaderOrAction = createCallLoaderOrAction(dataStrategy);
     let mapRouteProperties;
     if (init.mapRouteProperties) {
       mapRouteProperties = init.mapRouteProperties;
@@ -1677,6 +1670,7 @@
     let dataRoutes = convertRoutesToDataRoutes(init.routes, mapRouteProperties, undefined, manifest);
     let inFlightDataRoutes;
     let basename = init.basename || "/";
+    let dataStrategyImpl = init.unstable_dataStrategy || defaultDataStrategy;
     // Config driven behavior flags
     let future = _extends({
       v7_fetcherPersist: false,
@@ -1719,18 +1713,28 @@
         [route.id]: error
       };
     }
-
-    // "Initialized" here really means "Can `RouterProvider` render my route tree?"
-    // Prior to `route.HydrateFallback`, we only had a root `fallbackElement` so we used
-    // `state.initialized` to render that instead of `<DataRoutes>`.  Now that we
-    // support route level fallbacks we can always render and we'll just render
-    // as deep as we have data for and detect the nearest ancestor HydrateFallback
-    let initialized = future.v7_partialHydration ||
-    // All initialMatches need to be loaded before we're ready.  If we have lazy
-    // functions around still then we'll need to run them in initialize()
-    !initialMatches.some(m => m.route.lazy) && (
-    // And we have to either have no loaders or have been provided hydrationData
-    !initialMatches.some(m => m.route.loader) || init.hydrationData != null);
+    let initialized;
+    let hasLazyRoutes = initialMatches.some(m => m.route.lazy);
+    let hasLoaders = initialMatches.some(m => m.route.loader);
+    if (hasLazyRoutes) {
+      // All initialMatches need to be loaded before we're ready.  If we have lazy
+      // functions around still then we'll need to run them in initialize()
+      initialized = false;
+    } else if (!hasLoaders) {
+      // If we've got no loaders to run, then we're good to go
+      initialized = true;
+    } else if (future.v7_partialHydration) {
+      // If partial hydration is enabled, we're initialized so long as we were
+      // provided with hydrationData for every route with a loader, and no loaders
+      // were marked for explicit hydration
+      let loaderData = init.hydrationData ? init.hydrationData.loaderData : null;
+      let errors = init.hydrationData ? init.hydrationData.errors : null;
+      initialized = initialMatches.every(m => m.route.loader && (typeof m.route.loader !== "function" || m.route.loader.hydrate !== true) && (loaderData && loaderData[m.route.id] !== undefined || errors && errors[m.route.id] !== undefined));
+    } else {
+      // Without partial hydration - we're initialized if we were provided any
+      // hydrationData - which is expected to be complete
+      initialized = init.hydrationData != null;
+    }
     let router;
     let state = {
       historyAction: init.history.action,
@@ -1897,7 +1901,7 @@
       // in the normal navigation flow.  For SSR it's expected that lazy modules are
       // resolved prior to router creation since we can't go into a fallbackElement
       // UI for SSR'd apps
-      if (!state.initialized || future.v7_partialHydration && state.matches.some(m => isUnhydratedRoute(state, m.route))) {
+      if (!state.initialized) {
         startNavigation(Action.Pop, state.location, {
           initialHydration: true
         });
@@ -2338,7 +2342,8 @@
           })
         };
       } else {
-        result = await callLoaderOrAction("action", request, actionMatch, matches, manifest, mapRouteProperties, basename, future.v7_relativeSplatPath);
+        let results = await callDataStrategy("action", request, [actionMatch], matches);
+        result = results[0];
         if (request.signal.aborted) {
           return {
             shortCircuited: true
@@ -2353,9 +2358,9 @@
           // If the user didn't explicity indicate replace behavior, replace if
           // we redirected to the exact same location we're currently at to avoid
           // double back-buttons
-          replace = result.location === state.location.pathname + state.location.search;
+          replace = result.response.headers.get("Location") === state.location.pathname + state.location.search;
         }
-        await startRedirectNavigation(state, result, {
+        await startRedirectNavigation(request, result, {
           submission,
           replace
         });
@@ -2478,7 +2483,7 @@
       let {
         loaderResults,
         fetcherResults
-      } = await loadDataAndMaybeResolveDeferred(state.matches, matches, matchesToLoad, revalidatingFetchers, request);
+      } = await callLoadersAndMaybeResolveData(state.matches, matches, matchesToLoad, revalidatingFetchers, request);
       if (request.signal.aborted) {
         return {
           shortCircuited: true
@@ -2503,7 +2508,7 @@
           let fetcherKey = revalidatingFetchers[redirect.idx - matchesToLoad.length].key;
           fetchRedirectIds.add(fetcherKey);
         }
-        await startRedirectNavigation(state, redirect.result, {
+        await startRedirectNavigation(request, redirect.result, {
           replace
         });
         return {
@@ -2612,7 +2617,8 @@
       let fetchRequest = createClientSideRequest(init.history, path, abortController.signal, submission);
       fetchControllers.set(key, abortController);
       let originatingLoadId = incrementingLoadId;
-      let actionResult = await callLoaderOrAction("action", fetchRequest, match, requestMatches, manifest, mapRouteProperties, basename, future.v7_relativeSplatPath);
+      let actionResults = await callDataStrategy("action", fetchRequest, [match], requestMatches);
+      let actionResult = actionResults[0];
       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
@@ -2644,7 +2650,7 @@
           } else {
             fetchRedirectIds.add(key);
             updateFetcherState(key, getLoadingFetcher(submission));
-            return startRedirectNavigation(state, actionResult, {
+            return startRedirectNavigation(fetchRequest, actionResult, {
               fetcherSubmission: submission
             });
           }
@@ -2701,7 +2707,7 @@
       let {
         loaderResults,
         fetcherResults
-      } = await loadDataAndMaybeResolveDeferred(state.matches, matches, matchesToLoad, revalidatingFetchers, revalidationRequest);
+      } = await callLoadersAndMaybeResolveData(state.matches, matches, matchesToLoad, revalidatingFetchers, revalidationRequest);
       if (abortController.signal.aborted) {
         return;
       }
@@ -2718,7 +2724,7 @@
           let fetcherKey = revalidatingFetchers[redirect.idx - matchesToLoad.length].key;
           fetchRedirectIds.add(fetcherKey);
         }
-        return startRedirectNavigation(state, redirect.result);
+        return startRedirectNavigation(revalidationRequest, redirect.result);
       }
 
       // Process and commit output from loaders
@@ -2772,7 +2778,8 @@
       let fetchRequest = createClientSideRequest(init.history, path, abortController.signal);
       fetchControllers.set(key, abortController);
       let originatingLoadId = incrementingLoadId;
-      let result = await callLoaderOrAction("loader", fetchRequest, match, matches, manifest, mapRouteProperties, basename, future.v7_relativeSplatPath);
+      let results = await callDataStrategy("loader", fetchRequest, [match], matches);
+      let result = results[0];
 
       // Deferred isn't supported for fetcher loads, await everything and treat it
       // as a normal load.  resolveDeferredData will return undefined if this
@@ -2807,7 +2814,7 @@
           return;
         } else {
           fetchRedirectIds.add(key);
-          await startRedirectNavigation(state, result);
+          await startRedirectNavigation(fetchRequest, result);
           return;
         }
       }
@@ -2842,26 +2849,40 @@
      * 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(state, redirect, _temp2) {
+    async function startRedirectNavigation(request, redirect, _temp2) {
       let {
         submission,
         fetcherSubmission,
         replace
       } = _temp2 === void 0 ? {} : _temp2;
-      if (redirect.revalidate) {
+      if (redirect.response.headers.has("X-Remix-Revalidate")) {
         isRevalidationRequired = true;
       }
-      let redirectLocation = createLocation(state.location, redirect.location, {
+      let location = redirect.response.headers.get("Location");
+      invariant(location, "Expected a Location header on the redirect Response");
+      let redirectLocation = createLocation(state.location, location, {
         _isRedirect: true
       });
-      invariant(redirectLocation, "Expected a location on the redirect navigation");
+      if (ABSOLUTE_URL_REGEX.test(location)) {
+        // Strip off the protocol+origin for same-origin + same-basename absolute redirects
+        let normalizedLocation = location;
+        let currentUrl = new URL(request.url);
+        let url = normalizedLocation.startsWith("//") ? new URL(currentUrl.protocol + normalizedLocation) : new URL(normalizedLocation);
+        let isSameBasename = stripBasename(url.pathname, basename) != null;
+        if (url.origin === currentUrl.origin && isSameBasename) {
+          normalizedLocation = url.pathname + url.search + url.hash;
+          redirectLocation = createLocation(state.location, normalizedLocation, {
+            _isRedirect: true
+          });
+        }
+      }
       if (isBrowser) {
         let isDocumentReload = false;
-        if (redirect.reloadDocument) {
+        if (redirect.response.headers.has("X-Remix-Reload-Document")) {
           // Hard reload if the response contained X-Remix-Reload-Document
           isDocumentReload = true;
-        } else if (ABSOLUTE_URL_REGEX.test(redirect.location)) {
-          const url = init.history.createURL(redirect.location);
+        } else if (ABSOLUTE_URL_REGEX.test(location)) {
+          const url = init.history.createURL(location);
           isDocumentReload =
           // Hard reload if it's an absolute URL to a new origin
           url.origin !== routerWindow.location.origin ||
@@ -2870,9 +2891,9 @@
         }
         if (isDocumentReload) {
           if (replace) {
-            routerWindow.location.replace(redirect.location);
+            routerWindow.location.replace(location);
           } else {
-            routerWindow.location.assign(redirect.location);
+            routerWindow.location.assign(location);
           }
           return;
         }
@@ -2898,10 +2919,10 @@
       // re-submit the GET/POST/PUT/PATCH/DELETE as a submission navigation to the
       // redirected location
       let activeSubmission = submission || fetcherSubmission;
-      if (redirectPreserveMethodStatusCodes.has(redirect.status) && activeSubmission && isMutationMethod(activeSubmission.formMethod)) {
+      if (redirectPreserveMethodStatusCodes.has(redirect.response.status) && activeSubmission && isMutationMethod(activeSubmission.formMethod)) {
         await startNavigation(redirectHistoryAction, redirectLocation, {
           submission: _extends({}, activeSubmission, {
-            formAction: redirect.location
+            formAction: location
           }),
           // Preserve this flag across redirects
           preventScrollReset: pendingPreventScrollReset
@@ -2919,16 +2940,36 @@
         });
       }
     }
-    async function loadDataAndMaybeResolveDeferred(currentMatches, matches, matchesToLoad, fetchersToLoad, request) {
-      let [loaderResults, ...fetcherResults] = await Promise.all([matchesToLoad.length ? dataStrategy({
-        matches: matchesToLoad.map(m => finesseToAgnosticDataStrategyMatch(m, mapRouteProperties, manifest)),
-        request,
-        type: "loader",
-        defaultStrategy(match) {
-          return callLoaderOrActionImplementation("loader", request, match, matches, basename, future.v7_relativeSplatPath);
-        }
-      }) : [], ...fetchersToLoad.map(f => {
-        if (!f.matches || !f.match || !f.controller) {
+
+    // Utility wrapper for calling dataStrategy client-side without having to
+    // pass around the manifest, mapRouteProperties, etc.
+    async function callDataStrategy(type, request, matchesToLoad, matches) {
+      try {
+        let results = await callDataStrategyImpl(dataStrategyImpl, type, request, matchesToLoad, matches, manifest, mapRouteProperties);
+        return await Promise.all(results.map((result, i) => {
+          if (isRedirectHandlerResult(result)) {
+            return {
+              type: ResultType.redirect,
+              response: normalizeRelativeRoutingRedirectResponse(result.result, request, matchesToLoad[i].route.id, matches, basename, future.v7_relativeSplatPath)
+            };
+          }
+          return convertHandlerResultToDataResult(result);
+        }));
+      } 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 => {
+        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]);
+        } else {
           return Promise.resolve({
             type: ResultType.error,
             error: getInternalRouterError(404, {
@@ -2936,16 +2977,6 @@
             })
           });
         }
-        return dataStrategy({
-          matches: [finesseToAgnosticDataStrategyMatch(f.match, mapRouteProperties, manifest)],
-          request,
-          type: "loader",
-          defaultStrategy(match) {
-            invariant(f.controller, "Expected controller for fetcher in defaultStrategy");
-            invariant(f.matches, "Expected matches for fetcher in defaultStrategy");
-            return callLoaderOrActionImplementation("loader", createClientSideRequest(init.history, f.path, f.controller.signal), match, f.matches, basename, future.v7_relativeSplatPath);
-          }
-        }).then(r => r[0]);
       })]);
       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)]);
       return {
@@ -3259,10 +3290,9 @@
 
   function createStaticHandler(routes, opts) {
     invariant(routes.length > 0, "You must provide a non-empty routes array to createStaticHandler");
-    const dataStrategy = (opts == null ? void 0 : opts.dataStrategy) || defaultDataStrategy;
-    const callLoaderOrAction = createCallLoaderOrAction(dataStrategy);
     let manifest = {};
     let basename = (opts ? opts.basename : null) || "/";
+    let dataStrategyImpl = (opts == null ? void 0 : opts.unstable_dataStrategy) || defaultDataStrategy;
     let mapRouteProperties;
     if (opts != null && opts.mapRouteProperties) {
       mapRouteProperties = opts.mapRouteProperties;
@@ -3277,7 +3307,8 @@
     }
     // Config driven behavior flags
     let future = _extends({
-      v7_relativeSplatPath: false
+      v7_relativeSplatPath: false,
+      v7_throwAbortReason: false
     }, opts ? opts.future : null);
     let dataRoutes = convertRoutesToDataRoutes(routes, mapRouteProperties, undefined, manifest);
 
@@ -3461,14 +3492,14 @@
           actionHeaders: {}
         });
       } catch (e) {
-        // If the user threw/returned a Response in callLoaderOrAction, we throw
-        // it to bail out and then return or throw here based on whether the user
-        // returned or threw
-        if (isQueryRouteResponse(e)) {
+        // If the user threw/returned a Response in callLoaderOrAction for a
+        // `queryRoute` call, we throw the `HandlerResult` to bail out early
+        // and then return or throw the raw Response here accordingly
+        if (isHandlerResult(e) && isResponse(e.result)) {
           if (e.type === ResultType.error) {
-            throw e.response;
+            throw e.result;
           }
-          return e.response;
+          return e.result;
         }
         // Redirects are always returned since they don't propagate to catch
         // boundaries
@@ -3494,14 +3525,10 @@
           error
         };
       } else {
-        result = await callLoaderOrAction("action", request, actionMatch, matches, manifest, mapRouteProperties, basename, future.v7_relativeSplatPath, {
-          isStaticRequest: true,
-          isRouteRequest,
-          requestContext
-        });
+        let results = await callDataStrategy("action", request, [actionMatch], matches, isRouteRequest, requestContext);
+        result = results[0];
         if (request.signal.aborted) {
-          let method = isRouteRequest ? "queryRoute" : "query";
-          throw new Error(method + "() call aborted: " + request.method + " " + request.url);
+          throwStaticHandlerAbortedError(request, isRouteRequest, future);
         }
       }
       if (isRedirectResult(result)) {
@@ -3510,9 +3537,9 @@
         // can get back on the "throw all redirect responses" train here should
         // this ever happen :/
         throw new Response(null, {
-          status: result.status,
+          status: result.response.status,
           headers: {
-            Location: result.location
+            Location: result.response.headers.get("Location")
           }
         });
       }
@@ -3561,8 +3588,8 @@
         return _extends({}, context, {
           statusCode: isRouteErrorResponse(result.error) ? result.error.status : 500,
           actionData: null,
-          actionHeaders: _extends({}, result.headers ? {
-            [actionMatch.route.id]: result.headers
+          actionHeaders: _extends({}, result.response ? {
+            [actionMatch.route.id]: result.response.headers
           } : {})
         });
       }
@@ -3574,15 +3601,17 @@
         signal: request.signal
       });
       let context = await loadRouteData(loaderRequest, matches, requestContext);
-      return _extends({}, context, result.statusCode ? {
-        statusCode: result.statusCode
-      } : {}, {
+      return _extends({}, context, {
         actionData: {
           [actionMatch.route.id]: result.data
-        },
-        actionHeaders: _extends({}, result.headers ? {
-          [actionMatch.route.id]: result.headers
-        } : {})
+        }
+      }, result.response ? {
+        statusCode: result.response.status,
+        actionHeaders: {
+          [actionMatch.route.id]: result.response.headers
+        }
+      } : {
+        actionHeaders: {}
       });
     }
     async function loadRouteData(request, matches, requestContext, routeMatch, pendingActionError) {
@@ -3613,21 +3642,9 @@
           activeDeferreds: null
         };
       }
-      let results = await dataStrategy({
-        matches: matchesToLoad.map(m => finesseToAgnosticDataStrategyMatch(m, mapRouteProperties, manifest)),
-        request,
-        type: "loader",
-        defaultStrategy(match) {
-          return callLoaderOrActionImplementation("loader", request, match, matches, basename, future.v7_relativeSplatPath, {
-            isStaticRequest: true,
-            isRouteRequest,
-            requestContext
-          });
-        }
-      });
+      let results = await callDataStrategy("loader", request, matchesToLoad, matches, isRouteRequest, requestContext);
       if (request.signal.aborted) {
-        let method = isRouteRequest ? "queryRoute" : "query";
-        throw new Error(method + "() call aborted: " + request.method + " " + request.url);
+        throwStaticHandlerAbortedError(request, isRouteRequest, future);
       }
 
       // Process and commit output from loaders
@@ -3646,6 +3663,25 @@
         activeDeferreds: activeDeferreds.size > 0 ? Object.fromEntries(activeDeferreds.entries()) : null
       });
     }
+
+    // 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) {
+      let results = await callDataStrategyImpl(dataStrategyImpl, type, request, matchesToLoad, matches, manifest, mapRouteProperties, requestContext);
+      return await Promise.all(results.map((result, i) => {
+        if (isRedirectHandlerResult(result)) {
+          // Throw redirects and let the server handle them with an HTTP redirect
+          throw normalizeRelativeRoutingRedirectResponse(result.result, request, matchesToLoad[i].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.  We do this with the QueryRouteResponse wrapper
+          // interface so we can know whether it was returned or thrown
+          throw result;
+        }
+        return convertHandlerResultToDataResult(result);
+      }));
+    }
     return {
       dataRoutes,
       query,
@@ -3659,27 +3695,26 @@
   //#region Helpers
   ////////////////////////////////////////////////////////////////////////////////
 
-  function defaultDataStrategy(_ref3) {
-    let {
-      defaultStrategy,
-      matches
-    } = _ref3;
-    return Promise.all(matches.map(match => defaultStrategy(match)));
-  }
-
   /**
    * Given an existing StaticHandlerContext and an error thrown at render time,
    * provide an updated StaticHandlerContext suitable for a second SSR render
    */
   function getStaticContextFromError(routes, context, error) {
     let newContext = _extends({}, context, {
-      statusCode: 500,
+      statusCode: isRouteErrorResponse(error) ? error.status : 500,
       errors: {
         [context._deepestRenderedBoundaryId || routes[0].id]: error
       }
     });
     return newContext;
   }
+  function throwStaticHandlerAbortedError(request, isRouteRequest, future) {
+    if (future.v7_throwAbortReason && request.signal.reason !== undefined) {
+      throw request.signal.reason;
+    }
+    let method = isRouteRequest ? "queryRoute" : "query";
+    throw new Error(method + "() call aborted: " + request.method + " " + request.url);
+  }
   function isSubmissionNavigation(opts) {
     return opts != null && ("formData" in opts && opts.formData != null || "body" in opts && opts.body !== undefined);
   }
@@ -3764,8 +3799,8 @@
         }
         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, _ref4) => {
-          let [name, value] = _ref4;
+        Array.from(opts.body.entries()).reduce((acc, _ref3) => {
+          let [name, value] = _ref3;
           return "" + acc + name + "=" + value + "\n";
         }, "") : String(opts.body);
         return {
@@ -3876,18 +3911,24 @@
     let boundaryId = pendingError ? Object.keys(pendingError)[0] : undefined;
     let boundaryMatches = getLoaderMatchesUntilBoundary(matches, boundaryId);
     let navigationMatches = boundaryMatches.filter((match, index) => {
-      if (isInitialLoad) {
-        // On initial hydration we don't do any shouldRevalidate stuff - we just
-        // call the unhydrated loaders
-        return isUnhydratedRoute(state, match.route);
-      }
-      if (match.route.lazy) {
+      let {
+        route
+      } = match;
+      if (route.lazy) {
         // We haven't loaded this route yet so we don't know if it's got a loader!
         return true;
       }
-      if (match.route.loader == null) {
+      if (route.loader == null) {
         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);
+      }
 
       // Always call the loader on new route instances and pending defer cancellations
       if (isNewLoader(state.loaderData, state.matches[index], match) || cancelledDeferredRoutes.some(id => id === match.route.id)) {
@@ -3989,20 +4030,6 @@
     });
     return [navigationMatches, revalidatingFetchers];
   }
-
-  // Is this route unhydrated (when v7_partialHydration=true) such that we need
-  // to call it's loader on the initial router creation
-  function isUnhydratedRoute(state, route) {
-    if (!route.loader) {
-      return false;
-    }
-    if (route.loader.hydrate) {
-      return true;
-    }
-    return state.loaderData[route.id] === undefined && (!state.errors ||
-    // Loader ran but errored - don't re-run
-    state.errors[route.id] === undefined);
-  }
   function isNewLoader(currentLoaderData, currentMatch, match) {
     let isNew =
     // [a] -> [a, b]
@@ -4090,44 +4117,57 @@
     }));
     return routeToUpdate;
   }
-  function createCallLoaderOrAction(dataStrategy) {
-    return async function (type, request, match, matches, manifest, mapRouteProperties, basename, v7_relativeSplatPath, opts) {
-      if (opts === void 0) {
-        opts = {};
-      }
-      let [result] = await dataStrategy({
-        matches: [finesseToAgnosticDataStrategyMatch(match, mapRouteProperties, manifest)],
-        request,
-        type,
-        defaultStrategy(match) {
-          return callLoaderOrActionImplementation(type, request, match, matches, basename, v7_relativeSplatPath, opts);
-        }
-      });
-      return result;
-    };
+
+  // Default implementation of `dataStrategy` which fetches all loaders in parallel
+  function defaultDataStrategy(opts) {
+    return Promise.all(opts.matches.map(m => m.bikeshed_loadRoute()));
   }
-  function finesseToAgnosticDataStrategyMatch(match, mapRouteProperties, manifest) {
-    let loadRoutePromise;
-    if (match.route.lazy) {
-      try {
-        loadRoutePromise = loadLazyRouteModule(match.route, mapRouteProperties, manifest);
-      } catch (error) {
-        loadRoutePromise = Promise.reject(error);
-      }
-    }
-    if (!loadRoutePromise) {
-      loadRoutePromise = Promise.resolve(match.route);
-    }
-    loadRoutePromise.catch(() => {});
-    return _extends({}, match, {
-      route: Object.assign(loadRoutePromise, match.route)
+  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();
+
+    // 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 => {
+        // `bikeshed_loadRoute` 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 bikeshed_loadRoute = handlerOverride => {
+          loadedMatches.add(match.route.id);
+          return routeIdsToLoad.has(match.route.id) ? callLoaderOrAction(type, request, match, manifest, mapRouteProperties, handlerOverride, requestContext) :
+          // TODO: What's the best thing to do here - return an empty "success" result?
+          // Or return a success result with the current route loader/action data?
+          // We strip these results out if the route didn't need to be revalidated in
+          // `callDataStrategy` so it doesn't matter for us.  It's more of a question
+          // of whether exposing the current data to the user is useful?
+          Promise.resolve({
+            type: ResultType.data,
+            result: undefined
+          });
+        };
+        return _extends({}, match, {
+          bikeshed_loadRoute
+        });
+      }),
+      request,
+      params: matches[0].params
     });
+
+    // Throw if any loadRoute implementations not called since they are what
+    // ensures a route is fully loaded
+    // Throw if any loadRoute implementations not called since they are what
+    // ensure a route is fully loaded
+    matches.forEach(m => invariant(loadedMatches.has(m.route.id), "`match.bikeshed_loadRoute()` was not called for route id \"" + m.route.id + "\". " + "You must call `match.bikeshed_loadRoute()` 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));
   }
-  async function callLoaderOrActionImplementation(type, request, match, matches, basename, v7_relativeSplatPath, opts) {
-    if (opts === void 0) {
-      opts = {};
-    }
-    let resultType;
+
+  // 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) {
     let result;
     let onReject;
     let runHandler = handler => {
@@ -4136,11 +4176,18 @@
       let abortPromise = new Promise((_, r) => reject = r);
       onReject = () => reject();
       request.signal.addEventListener("abort", onReject);
-      return Promise.race([handler({
-        request,
-        params: match.params,
-        context: opts.requestContext
-      }), abortPromise]);
+      let runHandlerForReal = ctx => {
+        if (typeof handler !== "function") {
+          return Promise.reject(new Error("You cannot call the handler for a route which defines a boolean " + ("\"" + type + "\" [routeId: " + match.route.id + "]")));
+        }
+        return handler({
+          request,
+          params: match.params,
+          context: staticContext
+        }, ...(ctx !== undefined ? [ctx] : []));
+      };
+      let handlerPromise = handlerOverride ? handlerOverride(async ctx => runHandlerForReal(ctx)) : runHandlerForReal();
+      return Promise.race([handlerPromise, abortPromise]);
     };
     try {
       let handler = match.route[type];
@@ -4154,17 +4201,17 @@
           // route has a boundary that can handle the error
           runHandler(handler).catch(e => {
             handlerError = e;
-          }), match.route]);
+          }), loadLazyRouteModule(match.route, mapRouteProperties, manifest)]);
           if (handlerError) {
             throw handlerError;
           }
           result = values[0];
         } else {
           // Load lazy route module, then run any returned handler
-          let route = await match.route;
-          handler = route[type];
+          await loadLazyRouteModule(match.route, mapRouteProperties, manifest);
+          handler = match.route[type];
           if (handler) {
-            // Handler still run even if we got interrupted to maintain consistency
+            // Handler still runs even if we got interrupted to maintain consistency
             // with un-abortable behavior of handler execution on non-lazy or
             // previously-lazy-loaded routes
             result = await runHandler(handler);
@@ -4181,7 +4228,7 @@
             // hit the invariant below that errors on returning undefined.
             return {
               type: ResultType.data,
-              data: undefined
+              result: undefined
             };
           }
         }
@@ -4196,70 +4243,37 @@
       }
       invariant(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) {
-      resultType = ResultType.error;
-      result = e;
+      return {
+        type: ResultType.error,
+        result: e
+      };
     } finally {
       if (onReject) {
         request.signal.removeEventListener("abort", onReject);
       }
     }
+    return {
+      type: ResultType.data,
+      result
+    };
+  }
+  async function convertHandlerResultToDataResult(handlerResult) {
+    let {
+      result,
+      type
+    } = handlerResult;
     if (isResponse(result)) {
-      let status = result.status;
-
-      // Process redirects
-      if (redirectStatusCodes.has(status)) {
-        let location = result.headers.get("Location");
-        invariant(location, "Redirects returned/thrown from loaders/actions must have a Location header");
-
-        // Support relative routing in internal redirects
-        if (!ABSOLUTE_URL_REGEX.test(location)) {
-          location = normalizeTo(new URL(request.url), matches.slice(0, matches.findIndex(m => m.route.id === match.route.id) + 1), basename, true, location, v7_relativeSplatPath);
-        } else if (!opts.isStaticRequest) {
-          // Strip off the protocol+origin for same-origin + same-basename absolute
-          // redirects. If this is a static request, we can let it go back to the
-          // browser as-is
-          let currentUrl = new URL(request.url);
-          let url = location.startsWith("//") ? new URL(currentUrl.protocol + location) : new URL(location);
-          let isSameBasename = stripBasename(url.pathname, basename) != null;
-          if (url.origin === currentUrl.origin && isSameBasename) {
-            location = url.pathname + url.search + url.hash;
-          }
-        }
-
-        // Don't process redirects in the router during static requests requests.
-        // Instead, throw the Response and let the server handle it with an HTTP
-        // redirect.  We also update the Location header in place in this flow so
-        // basename and relative routing is taken into account
-        if (opts.isStaticRequest) {
-          result.headers.set("Location", location);
-          throw result;
-        }
-        return {
-          type: ResultType.redirect,
-          status,
-          location,
-          revalidate: result.headers.get("X-Remix-Revalidate") !== null,
-          reloadDocument: result.headers.get("X-Remix-Reload-Document") !== null
-        };
-      }
-
-      // For SSR single-route requests, we want to hand Responses back directly
-      // without unwrapping.  We do this with the QueryRouteResponse wrapper
-      // interface so we can know whether it was returned or thrown
-      if (opts.isRouteRequest) {
-        let queryRouteResponse = {
-          type: resultType === ResultType.error ? ResultType.error : ResultType.data,
-          response: result
-        };
-        throw queryRouteResponse;
-      }
       let data;
       try {
         let contentType = result.headers.get("Content-Type");
         // Check between word boundaries instead of startsWith() due to the last
         // paragraph of https://httpwg.org/specs/rfc9110.html#field.content-type
         if (contentType && /\bapplication\/json\b/.test(contentType)) {
-          data = await result.json();
+          if (result.body == null) {
+            data = null;
+          } else {
+            data = await result.json();
+          }
         } else {
           data = await result.text();
         }
@@ -4269,23 +4283,22 @@
           error: e
         };
       }
-      if (resultType === ResultType.error) {
+      if (type === ResultType.error) {
         return {
-          type: resultType,
-          error: new ErrorResponseImpl(status, result.statusText, data),
-          headers: result.headers
+          type,
+          error: new ErrorResponseImpl(result.status, result.statusText, data),
+          response: result
         };
       }
       return {
         type: ResultType.data,
         data,
-        statusCode: result.status,
-        headers: result.headers
+        response: result
       };
     }
-    if (resultType === ResultType.error) {
+    if (type === ResultType.error) {
       return {
-        type: resultType,
+        type,
         error: result
       };
     }
@@ -4304,6 +4317,18 @@
     };
   }
 
+  // Support relative routing in internal redirects
+  function normalizeRelativeRoutingRedirectResponse(response, request, routeId, matches, basename, v7_relativeSplatPath) {
+    let location = response.headers.get("Location");
+    invariant(location, "Redirects returned/thrown from loaders/actions must have a Location header");
+    if (!ABSOLUTE_URL_REGEX.test(location)) {
+      let trimmedMatches = matches.slice(0, matches.findIndex(m => m.route.id === routeId) + 1);
+      location = normalizeTo(new URL(request.url), trimmedMatches, basename, true, location, v7_relativeSplatPath);
+      response.headers.set("Location", location);
+    }
+    return response;
+  }
+
   // Utility method for creating the Request instances for loaders/actions during
   // client-side navigations and fetches.  During SSR we will always have a
   // Request instance from the static handler (query/queryRoute)
@@ -4394,24 +4419,31 @@
           foundError = true;
           statusCode = isRouteErrorResponse(result.error) ? result.error.status : 500;
         }
-        if (result.headers) {
-          loaderHeaders[id] = result.headers;
+        if (result.response) {
+          loaderHeaders[id] = result.response.headers;
         }
       } else {
         if (isDeferredResult(result)) {
           activeDeferreds.set(id, result.deferredData);
           loaderData[id] = result.deferredData.data;
+          // Error status codes always override success status codes, but if all
+          // loaders are successful we take the deepest status code.
+          if (result.statusCode != null && result.statusCode !== 200 && !foundError) {
+            statusCode = result.statusCode;
+          }
+          if (result.headers) {
+            loaderHeaders[id] = result.headers;
+          }
         } else {
           loaderData[id] = result.data;
-        }
-
-        // Error status codes always override success status codes, but if all
-        // loaders are successful we take the deepest status code.
-        if (result.statusCode != null && result.statusCode !== 200 && !foundError) {
-          statusCode = result.statusCode;
-        }
-        if (result.headers) {
-          loaderHeaders[id] = result.headers;
+          // Error status codes always override success status codes, but if all
+          // loaders are successful we take the deepest status code.
+          if (result.response) {
+            if (result.response.status !== 200 && !foundError) {
+              statusCode = result.response.status;
+            }
+            loaderHeaders[id] = result.response.headers;
+          }
         }
       }
     });
@@ -4591,6 +4623,12 @@
     // /page#hash -> /page
     return false;
   }
+  function isHandlerResult(result) {
+    return result != null && typeof result === "object" && "type" in result && "result" in result && (result.type === ResultType.data || result.type === ResultType.error);
+  }
+  function isRedirectHandlerResult(result) {
+    return isResponse(result.result) && redirectStatusCodes.has(result.result.status);
+  }
   function isDeferredResult(result) {
     return result.type === ResultType.deferred;
   }
@@ -4615,9 +4653,6 @@
     let location = result.headers.get("Location");
     return status >= 300 && status <= 399 && location != null;
   }
-  function isQueryRouteResponse(obj) {
-    return obj && isResponse(obj.response) && (obj.type === ResultType.data || obj.type === ResultType.error);
-  }
   function isValidMethod(method) {
     return validRequestMethods.has(method.toLowerCase());
   }
@@ -4861,7 +4896,6 @@
   exports.IDLE_BLOCKER = IDLE_BLOCKER;
   exports.IDLE_FETCHER = IDLE_FETCHER;
   exports.IDLE_NAVIGATION = IDLE_NAVIGATION;
-  exports.ResultType = ResultType;
   exports.UNSAFE_DEFERRED_SYMBOL = UNSAFE_DEFERRED_SYMBOL;
   exports.UNSAFE_DeferredData = DeferredData;
   exports.UNSAFE_ErrorResponseImpl = ErrorResponseImpl;