@remix-run/router 1.5.0 → 1.6.0

package/dist/router.umd.js

@@ -1,5 +1,5 @@
 /**
- * @remix-run/router v1.5.0
+ * @remix-run/router v1.6.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -578,7 +578,7 @@
   // solely with AgnosticDataRouteObject's within the Router
 
 
-  function convertRoutesToDataRoutes(routes, detectErrorBoundary, parentPath, manifest) {
+  function convertRoutesToDataRoutes(routes, mapRouteProperties, parentPath, manifest) {
     if (parentPath === void 0) {
       parentPath = [];
     }
@@ -594,24 +594,22 @@
       invariant(!manifest[id], "Found a route id collision on id \"" + id + "\".  Route " + "id's must be globally unique within Data Router usages");
 
       if (isIndexRoute(route)) {
-        let indexRoute = _extends({}, route, {
-          hasErrorBoundary: detectErrorBoundary(route),
+        let indexRoute = _extends({}, route, mapRouteProperties(route), {
           id
         });
 
         manifest[id] = indexRoute;
         return indexRoute;
       } else {
-        let pathOrLayoutRoute = _extends({}, route, {
+        let pathOrLayoutRoute = _extends({}, route, mapRouteProperties(route), {
           id,
-          hasErrorBoundary: detectErrorBoundary(route),
           children: undefined
         });
 
         manifest[id] = pathOrLayoutRoute;
 
         if (route.children) {
-          pathOrLayoutRoute.children = convertRoutesToDataRoutes(route.children, detectErrorBoundary, treePath, manifest);
+          pathOrLayoutRoute.children = convertRoutesToDataRoutes(route.children, mapRouteProperties, treePath, manifest);
         }
 
         return pathOrLayoutRoute;
@@ -1473,7 +1471,9 @@
   const isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined";
   const isServer = !isBrowser;
 
-  const defaultDetectErrorBoundary = route => Boolean(route.hasErrorBoundary); //#endregion
+  const defaultMapRouteProperties = route => ({
+    hasErrorBoundary: Boolean(route.hasErrorBoundary)
+  }); //#endregion
   ////////////////////////////////////////////////////////////////////////////////
   //#region createRouter
   ////////////////////////////////////////////////////////////////////////////////
@@ -1485,15 +1485,31 @@
 
   function createRouter(init) {
     invariant(init.routes.length > 0, "You must provide a non-empty routes array to createRouter");
-    let detectErrorBoundary = init.detectErrorBoundary || defaultDetectErrorBoundary; // Routes keyed by ID
+    let mapRouteProperties;
+
+    if (init.mapRouteProperties) {
+      mapRouteProperties = init.mapRouteProperties;
+    } else if (init.detectErrorBoundary) {
+      // If they are still using the deprecated version, wrap it with the new API
+      let detectErrorBoundary = init.detectErrorBoundary;
+
+      mapRouteProperties = route => ({
+        hasErrorBoundary: detectErrorBoundary(route)
+      });
+    } else {
+      mapRouteProperties = defaultMapRouteProperties;
+    } // Routes keyed by ID
+
 
     let manifest = {}; // Routes in tree format for matching
 
-    let dataRoutes = convertRoutesToDataRoutes(init.routes, detectErrorBoundary, undefined, manifest);
-    let inFlightDataRoutes; // Config driven behavior flags
+    let dataRoutes = convertRoutesToDataRoutes(init.routes, mapRouteProperties, undefined, manifest);
+    let inFlightDataRoutes;
+    let basename = init.basename || "/"; // Config driven behavior flags
 
     let future = _extends({
-      v7_normalizeFormMethod: false
+      v7_normalizeFormMethod: false,
+      v7_prependBasename: false
     }, init.future); // Cleanup function for history
 
 
@@ -1513,7 +1529,7 @@
     // SSR did the initial scroll restoration.
 
     let initialScrollRestored = init.hydrationData != null;
-    let initialMatches = matchRoutes(dataRoutes, init.history.location, init.basename);
+    let initialMatches = matchRoutes(dataRoutes, init.history.location, basename);
     let initialErrors = null;
 
     if (initialMatches == null) {
@@ -1565,7 +1581,7 @@
 
     let isUninterruptedRevalidation = false; // Use this internal flag to force revalidation of all loaders:
     //  - submissions (completed or interrupted)
-    //  - useRevalidate()
+    //  - useRevalidator()
     //  - X-Remix-Revalidate (from redirect)
 
     let isRevalidationRequired = false; // Use this internal array to capture routes that require revalidation due
@@ -1584,7 +1600,7 @@
 
     let pendingNavigationLoadId = -1; // Fetchers that triggered data reloads as a result of their actions
 
-    let fetchReloadIds = new Map(); // Fetchers that triggered redirect navigations from their actions
+    let fetchReloadIds = new Map(); // Fetchers that triggered redirect navigations
 
     let fetchRedirectIds = new Set(); // Most recent href/match for fetcher.load calls for fetchers
 
@@ -1781,11 +1797,12 @@
         return;
       }
 
+      let normalizedPath = normalizeTo(state.location, state.matches, basename, future.v7_prependBasename, to, opts == null ? void 0 : opts.fromRouteId, opts == null ? void 0 : opts.relative);
       let {
         path,
         submission,
         error
-      } = normalizeNavigateOptions(to, future, opts);
+      } = normalizeNavigateOptions(future.v7_normalizeFormMethod, false, normalizedPath, opts);
       let currentLocation = state.location;
       let nextLocation = createLocation(state.location, path, opts && opts.state); // When using navigate as a PUSH/REPLACE we aren't reading an already-encoded
       // URL from window.location, so we need to encode it here so the behavior
@@ -1901,7 +1918,7 @@
       pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;
       let routesToUse = inFlightDataRoutes || dataRoutes;
       let loadingNavigation = opts && opts.overrideNavigation;
-      let matches = matchRoutes(routesToUse, location, init.basename); // Short circuit with a 404 on the root error boundary if we match nothing
+      let matches = matchRoutes(routesToUse, location, basename); // Short circuit with a 404 on the root error boundary if we match nothing
 
       if (!matches) {
         let error = getInternalRouterError(404, {
@@ -2024,7 +2041,7 @@
           })
         };
       } else {
-        result = await callLoaderOrAction("action", request, actionMatch, matches, manifest, detectErrorBoundary, router.basename);
+        result = await callLoaderOrAction("action", request, actionMatch, matches, manifest, mapRouteProperties, basename);
 
         if (request.signal.aborted) {
           return {
@@ -2116,13 +2133,14 @@
         formEncType: loadingNavigation.formEncType
       } : undefined;
       let routesToUse = inFlightDataRoutes || dataRoutes;
-      let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, activeSubmission, location, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, fetchLoadMatches, routesToUse, init.basename, pendingActionData, pendingError); // Cancel pending deferreds for no-longer-matched routes or routes we're
+      let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, activeSubmission, location, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, fetchLoadMatches, routesToUse, basename, pendingActionData, pendingError); // Cancel pending deferreds for no-longer-matched routes or routes we're
       // about to reload.  Note that if this is an action reload we would have
       // already cancelled all pending deferreds so this would be a no-op
 
       cancelActiveDeferreds(routeId => !(matches && matches.some(m => m.route.id === routeId)) || matchesToLoad && matchesToLoad.some(m => m.route.id === routeId)); // Short circuit if we have no loaders to run
 
       if (matchesToLoad.length === 0 && revalidatingFetchers.length === 0) {
+        let updatedFetchers = markFetchRedirectsDone();
         completeNavigation(location, _extends({
           matches,
           loaderData: {},
@@ -2130,6 +2148,8 @@
           errors: pendingError || null
         }, pendingActionData ? {
           actionData: pendingActionData
+        } : {}, updatedFetchers ? {
+          fetchers: new Map(state.fetchers)
         } : {}));
         return {
           shortCircuited: true
@@ -2167,7 +2187,21 @@
       }
 
       pendingNavigationLoadId = ++incrementingLoadId;
-      revalidatingFetchers.forEach(rf => fetchControllers.set(rf.key, pendingNavigationController));
+      revalidatingFetchers.forEach(rf => {
+        if (rf.controller) {
+          // Fetchers use an independent AbortController so that aborting a fetcher
+          // (via deleteFetcher) does not abort the triggering navigation that
+          // triggered the revalidation
+          fetchControllers.set(rf.key, rf.controller);
+        }
+      }); // Proxy navigation abort through to revalidation fetchers
+
+      let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach(f => abortFetcher(f.key));
+
+      if (pendingNavigationController) {
+        pendingNavigationController.signal.addEventListener("abort", abortPendingFetchRevalidations);
+      }
+
       let {
         results,
         loaderResults,
@@ -2183,6 +2217,10 @@
       // reassigned to new controllers for the next navigation
 
 
+      if (pendingNavigationController) {
+        pendingNavigationController.signal.removeEventListener("abort", abortPendingFetchRevalidations);
+      }
+
       revalidatingFetchers.forEach(rf => fetchControllers.delete(rf.key)); // If any loaders returned a redirect Response, start a new REPLACE navigation
 
       let redirect = findRedirect(results);
@@ -2212,12 +2250,13 @@
           }
         });
       });
-      markFetchRedirectsDone();
+      let updatedFetchers = markFetchRedirectsDone();
       let didAbortFetchLoads = abortStaleFetchLoads(pendingNavigationLoadId);
+      let shouldUpdateFetchers = updatedFetchers || didAbortFetchLoads || revalidatingFetchers.length > 0;
       return _extends({
         loaderData,
         errors
-      }, didAbortFetchLoads || revalidatingFetchers.length > 0 ? {
+      }, shouldUpdateFetchers ? {
         fetchers: new Map(state.fetchers)
       } : {});
     }
@@ -2234,11 +2273,12 @@
 
       if (fetchControllers.has(key)) abortFetcher(key);
       let routesToUse = inFlightDataRoutes || dataRoutes;
-      let matches = matchRoutes(routesToUse, href, init.basename);
+      let normalizedPath = normalizeTo(state.location, state.matches, basename, future.v7_prependBasename, href, routeId, opts == null ? void 0 : opts.relative);
+      let matches = matchRoutes(routesToUse, normalizedPath, basename);
 
       if (!matches) {
         setFetcherError(key, routeId, getInternalRouterError(404, {
-          pathname: href
+          pathname: normalizedPath
         }));
         return;
       }
@@ -2246,7 +2286,7 @@
       let {
         path,
         submission
-      } = normalizeNavigateOptions(href, future, opts, true);
+      } = normalizeNavigateOptions(future.v7_normalizeFormMethod, true, normalizedPath, opts);
       let match = getTargetMatch(matches, path);
       pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;
 
@@ -2298,7 +2338,7 @@
       let abortController = new AbortController();
       let fetchRequest = createClientSideRequest(init.history, path, abortController.signal, submission);
       fetchControllers.set(key, abortController);
-      let actionResult = await callLoaderOrAction("action", fetchRequest, match, requestMatches, manifest, detectErrorBoundary, router.basename);
+      let actionResult = await callLoaderOrAction("action", fetchRequest, match, requestMatches, manifest, mapRouteProperties, basename);
 
       if (fetchRequest.signal.aborted) {
         // We can delete this so long as we weren't aborted by ou our own fetcher
@@ -2348,7 +2388,7 @@
       let nextLocation = state.navigation.location || state.location;
       let revalidationRequest = createClientSideRequest(init.history, nextLocation, abortController.signal);
       let routesToUse = inFlightDataRoutes || dataRoutes;
-      let matches = state.navigation.state !== "idle" ? matchRoutes(routesToUse, state.navigation.location, init.basename) : state.matches;
+      let matches = state.navigation.state !== "idle" ? matchRoutes(routesToUse, state.navigation.location, basename) : state.matches;
       invariant(matches, "Didn't find any matches after fetcher action");
       let loadId = ++incrementingLoadId;
       fetchReloadIds.set(key, loadId);
@@ -2361,7 +2401,7 @@
       });
 
       state.fetchers.set(key, loadFetcher);
-      let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, submission, nextLocation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, fetchLoadMatches, routesToUse, init.basename, {
+      let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, submission, nextLocation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, fetchLoadMatches, routesToUse, basename, {
         [match.route.id]: actionResult.data
       }, undefined // No need to send through errors since we short circuit above
       ); // Put all revalidating fetchers into the loading state, except for the
@@ -2381,11 +2421,18 @@
           " _hasFetcherDoneAnything ": true
         };
         state.fetchers.set(staleKey, revalidatingFetcher);
-        fetchControllers.set(staleKey, abortController);
+
+        if (rf.controller) {
+          fetchControllers.set(staleKey, rf.controller);
+        }
       });
       updateState({
         fetchers: new Map(state.fetchers)
       });
+
+      let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach(rf => abortFetcher(rf.key));
+
+      abortController.signal.addEventListener("abort", abortPendingFetchRevalidations);
       let {
         results,
         loaderResults,
@@ -2396,6 +2443,7 @@
         return;
       }
 
+      abortController.signal.removeEventListener("abort", abortPendingFetchRevalidations);
       fetchReloadIds.delete(key);
       fetchControllers.delete(key);
       revalidatingFetchers.forEach(r => fetchControllers.delete(r.key));
@@ -2470,14 +2518,14 @@
       let abortController = new AbortController();
       let fetchRequest = createClientSideRequest(init.history, path, abortController.signal);
       fetchControllers.set(key, abortController);
-      let result = await callLoaderOrAction("loader", fetchRequest, match, matches, manifest, detectErrorBoundary, router.basename); // Deferred isn't supported for fetcher loads, await everything and treat it
+      let result = await callLoaderOrAction("loader", fetchRequest, match, matches, manifest, mapRouteProperties, basename); // Deferred isn't supported for fetcher loads, await everything and treat it
       // as a normal load.  resolveDeferredData will return undefined if this
       // fetcher gets aborted, so we just leave result untouched and short circuit
       // below if that happens
 
       if (isDeferredResult(result)) {
         result = (await resolveDeferredData(result, fetchRequest.signal, true)) || result;
-      } // We can delete this so long as we weren't aborted by ou our own fetcher
+      } // We can delete this so long as we weren't aborted by our our own fetcher
       // re-load which would have put _new_ controller is in fetchControllers
 
 
@@ -2491,6 +2539,7 @@
 
 
       if (isRedirectResult(result)) {
+        fetchRedirectIds.add(key);
         await startRedirectNavigation(state, result);
         return;
       } // Process any non-redirect errors thrown
@@ -2571,7 +2620,7 @@
 
       if (ABSOLUTE_URL_REGEX.test(redirect.location) && isBrowser && typeof ((_window = window) == null ? void 0 : _window.location) !== "undefined") {
         let url = init.history.createURL(redirect.location);
-        let isDifferentBasename = stripBasename(url.pathname, init.basename || "/") == null;
+        let isDifferentBasename = stripBasename(url.pathname, basename) == null;
 
         if (window.location.origin !== url.origin || isDifferentBasename) {
           if (replace) {
@@ -2655,9 +2704,9 @@
       // Call all navigation loaders and revalidating fetcher loaders in parallel,
       // then slice off the results into separate arrays so we can handle them
       // accordingly
-      let results = await Promise.all([...matchesToLoad.map(match => callLoaderOrAction("loader", request, match, matches, manifest, detectErrorBoundary, router.basename)), ...fetchersToLoad.map(f => {
-        if (f.matches && f.match) {
-          return callLoaderOrAction("loader", createClientSideRequest(init.history, f.path, request.signal), f.match, f.matches, manifest, detectErrorBoundary, router.basename);
+      let results = await Promise.all([...matchesToLoad.map(match => callLoaderOrAction("loader", request, match, matches, manifest, mapRouteProperties, basename)), ...fetchersToLoad.map(f => {
+        if (f.matches && f.match && f.controller) {
+          return callLoaderOrAction("loader", createClientSideRequest(init.history, f.path, f.controller.signal), f.match, f.matches, manifest, mapRouteProperties, basename);
         } else {
           let error = {
             type: ResultType.error,
@@ -2670,7 +2719,7 @@
       })]);
       let loaderResults = results.slice(0, matchesToLoad.length);
       let fetcherResults = results.slice(matchesToLoad.length);
-      await Promise.all([resolveDeferredResults(currentMatches, matchesToLoad, loaderResults, request.signal, false, state.loaderData), resolveDeferredResults(currentMatches, fetchersToLoad.map(f => f.match), fetcherResults, request.signal, true)]);
+      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 {
         results,
         loaderResults,
@@ -2737,6 +2786,7 @@
 
     function markFetchRedirectsDone() {
       let doneKeys = [];
+      let updatedFetchers = false;
 
       for (let key of fetchRedirectIds) {
         let fetcher = state.fetchers.get(key);
@@ -2745,10 +2795,12 @@
         if (fetcher.state === "loading") {
           fetchRedirectIds.delete(key);
           doneKeys.push(key);
+          updatedFetchers = true;
         }
       }
 
       markFetchersDone(doneKeys);
+      return updatedFetchers;
     }
 
     function abortStaleFetchLoads(landedId) {
@@ -2908,7 +2960,7 @@
 
     router = {
       get basename() {
-        return init.basename;
+        return basename;
       },
 
       get state() {
@@ -2950,9 +3002,23 @@
   function createStaticHandler(routes, opts) {
     invariant(routes.length > 0, "You must provide a non-empty routes array to createStaticHandler");
     let manifest = {};
-    let detectErrorBoundary = (opts == null ? void 0 : opts.detectErrorBoundary) || defaultDetectErrorBoundary;
-    let dataRoutes = convertRoutesToDataRoutes(routes, detectErrorBoundary, undefined, manifest);
     let basename = (opts ? opts.basename : null) || "/";
+    let mapRouteProperties;
+
+    if (opts != null && opts.mapRouteProperties) {
+      mapRouteProperties = opts.mapRouteProperties;
+    } else if (opts != null && opts.detectErrorBoundary) {
+      // If they are still using the deprecated version, wrap it with the new API
+      let detectErrorBoundary = opts.detectErrorBoundary;
+
+      mapRouteProperties = route => ({
+        hasErrorBoundary: detectErrorBoundary(route)
+      });
+    } else {
+      mapRouteProperties = defaultMapRouteProperties;
+    }
+
+    let dataRoutes = convertRoutesToDataRoutes(routes, mapRouteProperties, undefined, manifest);
     /**
      * The query() method is intended for document requests, in which we want to
      * call an optional action and potentially multiple loaders for all nested
@@ -3189,7 +3255,7 @@
           error
         };
       } else {
-        result = await callLoaderOrAction("action", request, actionMatch, matches, manifest, detectErrorBoundary, basename, true, isRouteRequest, requestContext);
+        result = await callLoaderOrAction("action", request, actionMatch, matches, manifest, mapRouteProperties, basename, true, isRouteRequest, requestContext);
 
         if (request.signal.aborted) {
           let method = isRouteRequest ? "queryRoute" : "query";
@@ -3312,7 +3378,7 @@
         };
       }
 
-      let results = await Promise.all([...matchesToLoad.map(match => callLoaderOrAction("loader", request, match, matches, manifest, detectErrorBoundary, basename, true, isRouteRequest, requestContext))]);
+      let results = await Promise.all([...matchesToLoad.map(match => callLoaderOrAction("loader", request, match, matches, manifest, mapRouteProperties, basename, true, isRouteRequest, requestContext))]);
 
       if (request.signal.aborted) {
         let method = isRouteRequest ? "queryRoute" : "query";
@@ -3363,17 +3429,62 @@
 
   function isSubmissionNavigation(opts) {
     return opts != null && "formData" in opts;
-  } // Normalize navigation options by converting formMethod=GET formData objects to
-  // URLSearchParams so they behave identically to links with query params
+  }
 
+  function normalizeTo(location, matches, basename, prependBasename, to, fromRouteId, relative) {
+    let contextualMatches;
+    let activeRouteMatch;
 
-  function normalizeNavigateOptions(to, future, opts, isFetcher) {
-    if (isFetcher === void 0) {
-      isFetcher = false;
+    if (fromRouteId != null && relative !== "path") {
+      // Grab matches up to the calling route so our route-relative logic is
+      // relative to the correct source route.  When using relative:path,
+      // fromRouteId is ignored since that is always relative to the current
+      // location path
+      contextualMatches = [];
+
+      for (let match of matches) {
+        contextualMatches.push(match);
+
+        if (match.route.id === fromRouteId) {
+          activeRouteMatch = match;
+          break;
+        }
+      }
+    } else {
+      contextualMatches = matches;
+      activeRouteMatch = matches[matches.length - 1];
+    } // Resolve the relative path
+
+
+    let path = resolveTo(to ? to : ".", getPathContributingMatches(contextualMatches).map(m => m.pathnameBase), location.pathname, relative === "path"); // When `to` is not specified we inherit search/hash from the current
+    // location, unlike when to="." and we just inherit the path.
+    // See https://github.com/remix-run/remix/issues/927
+
+    if (to == null) {
+      path.search = location.search;
+      path.hash = location.hash;
+    } // Add an ?index param for matched index routes if we don't already have one
+
+
+    if ((to == null || to === "" || to === ".") && activeRouteMatch && activeRouteMatch.route.index && !hasNakedIndexQuery(path.search)) {
+      path.search = path.search ? path.search.replace(/^\?/, "?index&") : "?index";
+    } // If we're operating within a basename, prepend it to the pathname.  If
+    // this is a root navigation, then just use the raw basename which allows
+    // the basename to have full control over the presence of a trailing slash
+    // on root actions
+
+
+    if (prependBasename && basename !== "/") {
+      path.pathname = path.pathname === "/" ? basename : joinPaths([basename, path.pathname]);
     }
 
-    let path = typeof to === "string" ? to : createPath(to); // Return location verbatim on non-submission navigations
+    return createPath(path);
+  } // Normalize navigation options by converting formMethod=GET formData objects to
+  // URLSearchParams so they behave identically to links with query params
+
 
+  function normalizeNavigateOptions(normalizeFormMethod, isFetcher, path, opts) {
+    // Return location verbatim on non-submission navigations
     if (!opts || !isSubmissionNavigation(opts)) {
       return {
         path
@@ -3395,7 +3506,7 @@
     if (opts.formData) {
       let formMethod = opts.formMethod || "get";
       submission = {
-        formMethod: future.v7_normalizeFormMethod ? formMethod.toUpperCase() : formMethod.toLowerCase(),
+        formMethod: normalizeFormMethod ? formMethod.toUpperCase() : formMethod.toLowerCase(),
         formAction: stripHashFromPath(path),
         formEncType: opts && opts.formEncType || "application/x-www-form-urlencoded",
         formData: opts.formData
@@ -3411,9 +3522,9 @@
 
 
     let parsedPath = parsePath(path);
-    let searchParams = convertFormDataToSearchParams(opts.formData); // Since fetcher GET submissions only run a single loader (as opposed to
-    // navigation GET submissions which run all loaders), we need to preserve
-    // any incoming ?index params
+    let searchParams = convertFormDataToSearchParams(opts.formData); // On GET navigation submissions we can drop the ?index param from the
+    // resulting location since all loaders will run.  But fetcher GET submissions
+    // only run a single loader so we need to preserve any incoming ?index params
 
     if (isFetcher && parsedPath.search && hasNakedIndexQuery(parsedPath.search)) {
       searchParams.append("index", "");
@@ -3445,11 +3556,7 @@
   function getMatchesToLoad(history, state, matches, submission, location, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, fetchLoadMatches, routesToUse, basename, pendingActionData, pendingError) {
     let actionResult = pendingError ? Object.values(pendingError)[0] : pendingActionData ? Object.values(pendingActionData)[0] : undefined;
     let currentUrl = history.createURL(state.location);
-    let nextUrl = history.createURL(location);
-    let defaultShouldRevalidate = // Forced revalidation due to submission, useRevalidate, or X-Remix-Revalidate
-    isRevalidationRequired || // Clicked the same link, resubmitted a GET form
-    currentUrl.toString() === nextUrl.toString() || // Search params affect all loaders
-    currentUrl.search !== nextUrl.search; // Pick navigation matches that are net-new or qualify for revalidation
+    let nextUrl = history.createURL(location); // Pick navigation matches that are net-new or qualify for revalidation
 
     let boundaryId = pendingError ? Object.keys(pendingError)[0] : undefined;
     let boundaryMatches = getLoaderMatchesUntilBoundary(matches, boundaryId);
@@ -3481,7 +3588,10 @@
         nextParams: nextRouteMatch.params
       }, submission, {
         actionResult,
-        defaultShouldRevalidate: defaultShouldRevalidate || isNewRouteInstance(currentRouteMatch, nextRouteMatch)
+        defaultShouldRevalidate: // Forced revalidation due to submission, useRevalidator, or X-Remix-Revalidate
+        isRevalidationRequired || // Clicked the same link, resubmitted a GET form
+        currentUrl.toString() === nextUrl.toString() || // Search params affect all loaders
+        currentUrl.search !== nextUrl.search || isNewRouteInstance(currentRouteMatch, nextRouteMatch)
       }));
     }); // Pick fetcher.loads that need to be revalidated
 
@@ -3496,23 +3606,28 @@
       // we can trigger a 404 in callLoadersAndMaybeResolveData
 
       if (!fetcherMatches) {
-        revalidatingFetchers.push(_extends({
-          key
-        }, f, {
+        revalidatingFetchers.push({
+          key,
+          routeId: f.routeId,
+          path: f.path,
           matches: null,
-          match: null
-        }));
+          match: null,
+          controller: null
+        });
         return;
       }
 
       let fetcherMatch = getTargetMatch(fetcherMatches, f.path);
 
       if (cancelledFetcherLoads.includes(key)) {
-        revalidatingFetchers.push(_extends({
+        revalidatingFetchers.push({
           key,
+          routeId: f.routeId,
+          path: f.path,
           matches: fetcherMatches,
-          match: fetcherMatch
-        }, f));
+          match: fetcherMatch,
+          controller: new AbortController()
+        });
         return;
       } // Revalidating fetchers are decoupled from the route matches since they
       // hit a static href, so they _always_ check shouldRevalidate and the
@@ -3527,15 +3642,19 @@
         nextParams: matches[matches.length - 1].params
       }, submission, {
         actionResult,
-        defaultShouldRevalidate
+        // Forced revalidation due to submission, useRevalidator, or X-Remix-Revalidate
+        defaultShouldRevalidate: isRevalidationRequired
       }));
 
       if (shouldRevalidate) {
-        revalidatingFetchers.push(_extends({
+        revalidatingFetchers.push({
           key,
+          routeId: f.routeId,
+          path: f.path,
           matches: fetcherMatches,
-          match: fetcherMatch
-        }, f));
+          match: fetcherMatch,
+          controller: new AbortController()
+        });
       }
     });
     return [navigationMatches, revalidatingFetchers];
@@ -3579,7 +3698,7 @@
    */
 
 
-  async function loadLazyRouteModule(route, detectErrorBoundary, manifest) {
+  async function loadLazyRouteModule(route, mapRouteProperties, manifest) {
     if (!route.lazy) {
       return;
     }
@@ -3615,27 +3734,19 @@
         routeUpdates[lazyRouteProperty] = lazyRoute[lazyRouteProperty];
       }
     } // Mutate the route with the provided updates.  Do this first so we pass
-    // the updated version to detectErrorBoundary
+    // the updated version to mapRouteProperties
 
 
     Object.assign(routeToUpdate, routeUpdates); // Mutate the `hasErrorBoundary` property on the route based on the route
     // updates and remove the `lazy` function so we don't resolve the lazy
     // route again.
 
-    Object.assign(routeToUpdate, {
-      // To keep things framework agnostic, we use the provided
-      // `detectErrorBoundary` function to set the `hasErrorBoundary` route
-      // property since the logic will differ between frameworks.
-      hasErrorBoundary: detectErrorBoundary(_extends({}, routeToUpdate)),
+    Object.assign(routeToUpdate, _extends({}, mapRouteProperties(routeToUpdate), {
       lazy: undefined
-    });
+    }));
   }
 
-  async function callLoaderOrAction(type, request, match, matches, manifest, detectErrorBoundary, basename, isStaticRequest, isRouteRequest, requestContext) {
-    if (basename === void 0) {
-      basename = "/";
-    }
-
+  async function callLoaderOrAction(type, request, match, matches, manifest, mapRouteProperties, basename, isStaticRequest, isRouteRequest, requestContext) {
     if (isStaticRequest === void 0) {
       isStaticRequest = false;
     }
@@ -3669,11 +3780,11 @@
       if (match.route.lazy) {
         if (handler) {
           // Run statically defined handler in parallel with lazy()
-          let values = await Promise.all([runHandler(handler), loadLazyRouteModule(match.route, detectErrorBoundary, manifest)]);
+          let values = await Promise.all([runHandler(handler), loadLazyRouteModule(match.route, mapRouteProperties, manifest)]);
           result = values[0];
         } else {
           // Load lazy route module, then run any returned handler
-          await loadLazyRouteModule(match.route, detectErrorBoundary, manifest);
+          await loadLazyRouteModule(match.route, mapRouteProperties, manifest);
           handler = match.route[type];
 
           if (handler) {
@@ -3682,9 +3793,11 @@
             // previously-lazy-loaded routes
             result = await runHandler(handler);
           } else if (type === "action") {
+            let url = new URL(request.url);
+            let pathname = url.pathname + url.search;
             throw getInternalRouterError(405, {
               method: request.method,
-              pathname: new URL(request.url).pathname,
+              pathname,
               routeId: match.route.id
             });
           } else {
@@ -3696,8 +3809,13 @@
             };
           }
         }
+      } else if (!handler) {
+        let url = new URL(request.url);
+        let pathname = url.pathname + url.search;
+        throw getInternalRouterError(404, {
+          pathname
+        });
       } else {
-        invariant(handler, "Could not find the " + type + " to run on the \"" + match.route.id + "\" route");
         result = await runHandler(handler);
       }
 
@@ -3719,17 +3837,7 @@
         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)) {
-          let activeMatches = matches.slice(0, matches.indexOf(match) + 1);
-          let routePathnames = getPathContributingMatches(activeMatches).map(match => match.pathnameBase);
-          let resolvedLocation = resolveTo(location, routePathnames, new URL(request.url).pathname);
-          invariant(createPath(resolvedLocation), "Unable to resolve redirect location: " + location); // Prepend the basename to the redirect location if we have one
-
-          if (basename) {
-            let path = resolvedLocation.pathname;
-            resolvedLocation.pathname = path === "/" ? basename : joinPaths([basename, path]);
-          }
-
-          location = createPath(resolvedLocation);
+          location = normalizeTo(new URL(request.url), matches.slice(0, matches.indexOf(match) + 1), basename, true, location);
         } else if (!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
@@ -3945,12 +4053,16 @@
     for (let index = 0; index < revalidatingFetchers.length; index++) {
       let {
         key,
-        match
+        match,
+        controller
       } = revalidatingFetchers[index];
       invariant(fetcherResults !== undefined && fetcherResults[index] !== undefined, "Did not find corresponding fetcher result");
       let result = fetcherResults[index]; // Process fetcher non-redirect errors
 
-      if (isErrorResult(result)) {
+      if (controller && controller.signal.aborted) {
+        // Nothing to do for aborted fetchers
+        continue;
+      } else if (isErrorResult(result)) {
         let boundaryMatch = findNearestBoundary(state.matches, match == null ? void 0 : match.route.id);
 
         if (!(errors && errors[boundaryMatch.route.id])) {
@@ -4139,7 +4251,7 @@
     return validMutationMethods.has(method.toLowerCase());
   }
 
-  async function resolveDeferredResults(currentMatches, matchesToLoad, results, signal, isFetcher, currentLoaderData) {
+  async function resolveDeferredResults(currentMatches, matchesToLoad, results, signals, isFetcher, currentLoaderData) {
     for (let index = 0; index < results.length; index++) {
       let result = results[index];
       let match = matchesToLoad[index]; // If we don't have a match, then we can have a deferred result to do
@@ -4157,6 +4269,8 @@
         // Note: we do not have to touch activeDeferreds here since we race them
         // against the signal in resolveDeferredData and they'll get aborted
         // there if needed
+        let signal = signals[index];
+        invariant(signal, "Expected an AbortSignal for revalidating fetcher deferred result");
         await resolveDeferredData(result, signal, isFetcher).then(result => {
           if (result) {
             results[index] = result || results[index];