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

package/dist/router.cjs.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.
  *
@@ -496,6 +496,10 @@ function getUrlBasedHistory(getLocation, createHref, validateLocation, options)
     // 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);
   }
@@ -573,6 +577,10 @@ let ResultType = /*#__PURE__*/function (ResultType) {
  * 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.
@@ -752,14 +760,14 @@ function matchRoutes(routes, locationArg, basename) {
   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;
 }
@@ -889,7 +897,7 @@ function rankRouteBranches(branches) {
   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;
@@ -979,7 +987,7 @@ function generatePath(originalPath, params) {
       // 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];
@@ -1038,7 +1046,7 @@ function matchPath(pattern, pathname) {
     if (isOptional && !value) {
       memo[paramName] = undefined;
     } else {
-      memo[paramName] = safelyDecodeURIComponent(value || "", paramName);
+      memo[paramName] = (value || "").replace(/%2F/g, "/");
     }
     return memo;
   }, {});
@@ -1061,7 +1069,7 @@ function compilePath(path, caseSensitive, end) {
   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
@@ -1090,22 +1098,14 @@ function compilePath(path, caseSensitive, end) {
   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
@@ -1597,11 +1597,6 @@ function isRouteErrorResponse(error) {
 /**
  * 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];
@@ -1654,8 +1649,6 @@ function createRouter(init) {
   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;
@@ -1675,6 +1668,7 @@ function createRouter(init) {
   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,
@@ -1717,18 +1711,28 @@ function createRouter(init) {
       [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,
@@ -1895,7 +1899,7 @@ function createRouter(init) {
     // 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
       });
@@ -2336,7 +2340,8 @@ function createRouter(init) {
         })
       };
     } 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
@@ -2351,9 +2356,9 @@ function createRouter(init) {
         // 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
       });
@@ -2476,7 +2481,7 @@ function createRouter(init) {
     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
@@ -2501,7 +2506,7 @@ function createRouter(init) {
         let fetcherKey = revalidatingFetchers[redirect.idx - matchesToLoad.length].key;
         fetchRedirectIds.add(fetcherKey);
       }
-      await startRedirectNavigation(state, redirect.result, {
+      await startRedirectNavigation(request, redirect.result, {
         replace
       });
       return {
@@ -2610,7 +2615,8 @@ function createRouter(init) {
     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
@@ -2642,7 +2648,7 @@ function createRouter(init) {
         } else {
           fetchRedirectIds.add(key);
           updateFetcherState(key, getLoadingFetcher(submission));
-          return startRedirectNavigation(state, actionResult, {
+          return startRedirectNavigation(fetchRequest, actionResult, {
             fetcherSubmission: submission
           });
         }
@@ -2699,7 +2705,7 @@ function createRouter(init) {
     let {
       loaderResults,
       fetcherResults
-    } = await loadDataAndMaybeResolveDeferred(state.matches, matches, matchesToLoad, revalidatingFetchers, revalidationRequest);
+    } = await callLoadersAndMaybeResolveData(state.matches, matches, matchesToLoad, revalidatingFetchers, revalidationRequest);
     if (abortController.signal.aborted) {
       return;
     }
@@ -2716,7 +2722,7 @@ function createRouter(init) {
         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
@@ -2770,7 +2776,8 @@ function createRouter(init) {
     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
@@ -2805,7 +2812,7 @@ function createRouter(init) {
         return;
       } else {
         fetchRedirectIds.add(key);
-        await startRedirectNavigation(state, result);
+        await startRedirectNavigation(fetchRequest, result);
         return;
       }
     }
@@ -2840,26 +2847,40 @@ function createRouter(init) {
    * 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 ||
@@ -2868,9 +2889,9 @@ function createRouter(init) {
       }
       if (isDocumentReload) {
         if (replace) {
-          routerWindow.location.replace(redirect.location);
+          routerWindow.location.replace(location);
         } else {
-          routerWindow.location.assign(redirect.location);
+          routerWindow.location.assign(location);
         }
         return;
       }
@@ -2896,10 +2917,10 @@ function createRouter(init) {
     // 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
@@ -2917,16 +2938,36 @@ function createRouter(init) {
       });
     }
   }
-  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, {
@@ -2934,16 +2975,6 @@ function createRouter(init) {
           })
         });
       }
-      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 {
@@ -3257,10 +3288,9 @@ const UNSAFE_DEFERRED_SYMBOL = Symbol("deferred");
 
 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;
@@ -3275,7 +3305,8 @@ function createStaticHandler(routes, opts) {
   }
   // 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);
 
@@ -3459,14 +3490,14 @@ function createStaticHandler(routes, opts) {
         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
@@ -3492,14 +3523,10 @@ function createStaticHandler(routes, opts) {
         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)) {
@@ -3508,9 +3535,9 @@ function createStaticHandler(routes, opts) {
       // 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")
         }
       });
     }
@@ -3559,8 +3586,8 @@ function createStaticHandler(routes, opts) {
       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
         } : {})
       });
     }
@@ -3572,15 +3599,17 @@ function createStaticHandler(routes, opts) {
       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) {
@@ -3611,21 +3640,9 @@ function createStaticHandler(routes, opts) {
         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
@@ -3644,6 +3661,25 @@ function createStaticHandler(routes, opts) {
       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,
@@ -3657,27 +3693,26 @@ function createStaticHandler(routes, opts) {
 //#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);
 }
@@ -3762,8 +3797,8 @@ function normalizeNavigateOptions(normalizeFormMethod, isFetcher, path, opts) {
       }
       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 {
@@ -3874,18 +3909,24 @@ function getMatchesToLoad(history, state, matches, submission, location, isIniti
   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)) {
@@ -3987,20 +4028,6 @@ function getMatchesToLoad(history, state, matches, submission, location, isIniti
   });
   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]
@@ -4088,44 +4115,57 @@ async function loadLazyRouteModule(route, mapRouteProperties, manifest) {
   }));
   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 => {
@@ -4134,11 +4174,18 @@ async function callLoaderOrActionImplementation(type, request, match, matches, b
     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];
@@ -4152,17 +4199,17 @@ async function callLoaderOrActionImplementation(type, request, match, matches, b
         // 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);
@@ -4179,7 +4226,7 @@ async function callLoaderOrActionImplementation(type, request, match, matches, b
           // hit the invariant below that errors on returning undefined.
           return {
             type: ResultType.data,
-            data: undefined
+            result: undefined
           };
         }
       }
@@ -4194,70 +4241,37 @@ async function callLoaderOrActionImplementation(type, request, match, matches, b
     }
     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();
       }
@@ -4267,23 +4281,22 @@ async function callLoaderOrActionImplementation(type, request, match, matches, b
         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
     };
   }
@@ -4302,6 +4315,18 @@ async function callLoaderOrActionImplementation(type, request, match, matches, b
   };
 }
 
+// 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)
@@ -4392,24 +4417,31 @@ function processRouteLoaderData(matches, matchesToLoad, results, pendingError, a
         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;
+        }
       }
     }
   });
@@ -4589,6 +4621,12 @@ function isHashChangeOnly(a, b) {
   // /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;
 }
@@ -4613,9 +4651,6 @@ function isRedirectResponse(result) {
   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());
 }
@@ -4859,7 +4894,6 @@ exports.Action = Action;
 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;