@remix-run/router 1.3.2 → 1.3.3-pre.1

package/dist/router.umd.js

@@ -1,5 +1,5 @@
 /**
- * @remix-run/router v1.3.2
+ * @remix-run/router v1.3.3-pre.1
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -1491,7 +1491,8 @@
 
   function createRouter(init) {
     invariant(init.routes.length > 0, "You must provide a non-empty routes array to createRouter");
-    let dataRoutes = convertRoutesToDataRoutes(init.routes); // Cleanup function for history
+    let dataRoutes = convertRoutesToDataRoutes(init.routes);
+    let inFlightDataRoutes; // Cleanup function for history
 
     let unlistenHistory = null; // Externally-provided functions to call on all state changes
 
@@ -1727,6 +1728,12 @@
 
 
       let preventScrollReset = pendingPreventScrollReset === true || state.navigation.formMethod != null && isMutationMethod(state.navigation.formMethod) && ((_location$state2 = location.state) == null ? void 0 : _location$state2._isRedirect) !== true;
+
+      if (inFlightDataRoutes) {
+        dataRoutes = inFlightDataRoutes;
+        inFlightDataRoutes = undefined;
+      }
+
       updateState(_extends({}, newState, {
         // matches, errors, fetchers go through as-is
         actionData,
@@ -1882,8 +1889,9 @@
 
       saveScrollPosition(state.location, state.matches);
       pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;
+      let routesToUse = inFlightDataRoutes || dataRoutes;
       let loadingNavigation = opts && opts.overrideNavigation;
-      let matches = matchRoutes(dataRoutes, location, init.basename); // Short circuit with a 404 on the root error boundary if we match nothing
+      let matches = matchRoutes(routesToUse, location, init.basename); // Short circuit with a 404 on the root error boundary if we match nothing
 
       if (!matches) {
         let error = getInternalRouterError(404, {
@@ -1892,7 +1900,7 @@
         let {
           matches: notFoundMatches,
           route
-        } = getShortCircuitMatches(dataRoutes); // Cancel all pending deferred on 404s since we don't keep any routes
+        } = getShortCircuitMatches(routesToUse); // Cancel all pending deferred on 404s since we don't keep any routes
 
         cancelActiveDeferreds();
         completeNavigation(location, {
@@ -2097,7 +2105,8 @@
         formData: loadingNavigation.formData,
         formEncType: loadingNavigation.formEncType
       } : undefined;
-      let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, activeSubmission, location, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, pendingActionData, pendingError, fetchLoadMatches); // Cancel pending deferreds for no-longer-matched routes or routes we're
+      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
       // 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
 
@@ -2214,7 +2223,8 @@
       }
 
       if (fetchControllers.has(key)) abortFetcher(key);
-      let matches = matchRoutes(dataRoutes, href, init.basename);
+      let routesToUse = inFlightDataRoutes || dataRoutes;
+      let matches = matchRoutes(routesToUse, href, init.basename);
 
       if (!matches) {
         setFetcherError(key, routeId, getInternalRouterError(404, {
@@ -2239,9 +2249,7 @@
 
       fetchLoadMatches.set(key, {
         routeId,
-        path,
-        match,
-        matches
+        path
       });
       handleFetcherLoader(key, routeId, path, match, matches, submission);
     } // Call the action for the matched fetcher.submit(), and then handle redirects,
@@ -2328,7 +2336,8 @@
 
       let nextLocation = state.navigation.location || state.location;
       let revalidationRequest = createClientSideRequest(init.history, nextLocation, abortController.signal);
-      let matches = state.navigation.state !== "idle" ? matchRoutes(dataRoutes, state.navigation.location, init.basename) : state.matches;
+      let routesToUse = inFlightDataRoutes || dataRoutes;
+      let matches = state.navigation.state !== "idle" ? matchRoutes(routesToUse, state.navigation.location, init.basename) : state.matches;
       invariant(matches, "Didn't find any matches after fetcher action");
       let loadId = ++incrementingLoadId;
       fetchReloadIds.set(key, loadId);
@@ -2341,10 +2350,10 @@
       });
 
       state.fetchers.set(key, loadFetcher);
-      let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, submission, nextLocation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, {
+      let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, submission, nextLocation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, fetchLoadMatches, routesToUse, init.basename, {
         [match.route.id]: actionResult.data
-      }, undefined, // No need to send through errors since we short circuit above
-      fetchLoadMatches); // Put all revalidating fetchers into the loading state, except for the
+      }, undefined // No need to send through errors since we short circuit above
+      ); // Put all revalidating fetchers into the loading state, except for the
       // current fetcher which we want to keep in it's current loading state which
       // contains it's action submission info + action data
 
@@ -2550,9 +2559,10 @@
       invariant(redirectLocation, "Expected a location on the redirect navigation"); // Check if this an absolute external redirect that goes to a new origin
 
       if (ABSOLUTE_URL_REGEX.test(redirect.location) && isBrowser && typeof ((_window = window) == null ? void 0 : _window.location) !== "undefined") {
-        let newOrigin = init.history.createURL(redirect.location).origin;
+        let url = init.history.createURL(redirect.location);
+        let isDifferentBasename = stripBasename(url.pathname, init.basename || "/") == null;
 
-        if (window.location.origin !== newOrigin) {
+        if (window.location.origin !== url.origin || isDifferentBasename) {
           if (replace) {
             window.location.replace(redirect.location);
           } else {
@@ -2618,7 +2628,19 @@
       // 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, router.basename)), ...fetchersToLoad.map(f => callLoaderOrAction("loader", createClientSideRequest(init.history, f.path, request.signal), f.match, f.matches, router.basename))]);
+      let results = await Promise.all([...matchesToLoad.map(match => callLoaderOrAction("loader", request, match, matches, router.basename)), ...fetchersToLoad.map(f => {
+        if (f.matches && f.match) {
+          return callLoaderOrAction("loader", createClientSideRequest(init.history, f.path, request.signal), f.match, f.matches, router.basename);
+        } else {
+          let error = {
+            type: ResultType.error,
+            error: getInternalRouterError(404, {
+              pathname: f.path
+            })
+          };
+          return error;
+        }
+      })]);
       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)]);
@@ -2853,6 +2875,10 @@
       return null;
     }
 
+    function _internalSetRoutes(newRoutes) {
+      inFlightDataRoutes = newRoutes;
+    }
+
     router = {
       get basename() {
         return init.basename;
@@ -2882,7 +2908,10 @@
       getBlocker,
       deleteBlocker,
       _internalFetchControllers: fetchControllers,
-      _internalActiveDeferreds: activeDeferreds
+      _internalActiveDeferreds: activeDeferreds,
+      // TODO: Remove setRoutes, it's temporary to avoid dealing with
+      // updating the tree while validating the update algorithm.
+      _internalSetRoutes
     };
     return router;
   } //#endregion
@@ -3383,7 +3412,7 @@
     return boundaryMatches;
   }
 
-  function getMatchesToLoad(history, state, matches, submission, location, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, pendingActionData, pendingError, fetchLoadMatches) {
+  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);
@@ -3422,36 +3451,56 @@
     }); // Pick fetcher.loads that need to be revalidated
 
     let revalidatingFetchers = [];
-    fetchLoadMatches && fetchLoadMatches.forEach((f, key) => {
+    fetchLoadMatches.forEach((f, key) => {
+      // Don't revalidate if fetcher won't be present in the subsequent render
       if (!matches.some(m => m.route.id === f.routeId)) {
-        // This fetcher is not going to be present in the subsequent render so
-        // there's no need to revalidate it
         return;
-      } else if (cancelledFetcherLoads.includes(key)) {
-        // This fetcher was cancelled from a prior action submission - force reload
+      }
+
+      let fetcherMatches = matchRoutes(routesToUse, f.path, basename); // If the fetcher path no longer matches, push it in with null matches so
+      // we can trigger a 404 in callLoadersAndMaybeResolveData
+
+      if (!fetcherMatches) {
         revalidatingFetchers.push(_extends({
           key
-        }, f));
-      } else {
-        // Revalidating fetchers are decoupled from the route matches since they
-        // hit a static href, so they _always_ check shouldRevalidate and the
-        // default is strictly if a revalidation is explicitly required (action
-        // submissions, useRevalidator, X-Remix-Revalidate).
-        let shouldRevalidate = shouldRevalidateLoader(f.match, _extends({
-          currentUrl,
-          currentParams: state.matches[state.matches.length - 1].params,
-          nextUrl,
-          nextParams: matches[matches.length - 1].params
-        }, submission, {
-          actionResult,
-          defaultShouldRevalidate
+        }, f, {
+          matches: null,
+          match: null
         }));
+        return;
+      }
 
-        if (shouldRevalidate) {
-          revalidatingFetchers.push(_extends({
-            key
-          }, f));
-        }
+      let fetcherMatch = getTargetMatch(fetcherMatches, f.path);
+
+      if (cancelledFetcherLoads.includes(key)) {
+        revalidatingFetchers.push(_extends({
+          key,
+          matches: fetcherMatches,
+          match: fetcherMatch
+        }, f));
+        return;
+      } // Revalidating fetchers are decoupled from the route matches since they
+      // hit a static href, so they _always_ check shouldRevalidate and the
+      // default is strictly if a revalidation is explicitly required (action
+      // submissions, useRevalidator, X-Remix-Revalidate).
+
+
+      let shouldRevalidate = shouldRevalidateLoader(fetcherMatch, _extends({
+        currentUrl,
+        currentParams: state.matches[state.matches.length - 1].params,
+        nextUrl,
+        nextParams: matches[matches.length - 1].params
+      }, submission, {
+        actionResult,
+        defaultShouldRevalidate
+      }));
+
+      if (shouldRevalidate) {
+        revalidatingFetchers.push(_extends({
+          key,
+          matches: fetcherMatches,
+          match: fetcherMatch
+        }, f));
       }
     });
     return [navigationMatches, revalidatingFetchers];
@@ -3548,13 +3597,14 @@
 
           location = createPath(resolvedLocation);
         } else if (!isStaticRequest) {
-          // Strip off the protocol+origin for same-origin absolute redirects.
-          // If this is a static reques, we can let it go back to the browser
-          // as-is
+          // 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) {
+          if (url.origin === currentUrl.origin && isSameBasename) {
             location = url.pathname + url.search + url.hash;
           }
         } // Don't process redirects in the router during static requests requests.
@@ -3621,9 +3671,13 @@
     }
 
     if (result instanceof DeferredData) {
+      var _result$init, _result$init2;
+
       return {
         type: ResultType.deferred,
-        deferredData: result
+        deferredData: result,
+        statusCode: (_result$init = result.init) == null ? void 0 : _result$init.status,
+        headers: ((_result$init2 = result.init) == null ? void 0 : _result$init2.headers) && new Headers(result.init.headers)
       };
     }
 
@@ -3760,7 +3814,7 @@
       let result = fetcherResults[index]; // Process fetcher non-redirect errors
 
       if (isErrorResult(result)) {
-        let boundaryMatch = findNearestBoundary(state.matches, match.route.id);
+        let boundaryMatch = findNearestBoundary(state.matches, match == null ? void 0 : match.route.id);
 
         if (!(errors && errors[boundaryMatch.route.id])) {
           errors = _extends({}, errors, {
@@ -3807,7 +3861,9 @@
         if (newLoaderData[id] !== undefined) {
           mergedLoaderData[id] = newLoaderData[id];
         }
-      } else if (loaderData[id] !== undefined) {
+      } else if (loaderData[id] !== undefined && match.route.loader) {
+        // Preserve existing keys not included in newLoaderData and where a loader
+        // wasn't removed by HMR
         mergedLoaderData[id] = loaderData[id];
       }
 
@@ -3944,7 +4000,14 @@
   async function resolveDeferredResults(currentMatches, matchesToLoad, results, signal, isFetcher, currentLoaderData) {
     for (let index = 0; index < results.length; index++) {
       let result = results[index];
-      let match = matchesToLoad[index];
+      let match = matchesToLoad[index]; // If we don't have a match, then we can have a deferred result to do
+      // anything with.  This is for revalidating fetchers where the route was
+      // removed during HMR
+
+      if (!match) {
+        continue;
+      }
+
       let currentMatch = currentMatches.find(m => m.route.id === match.route.id);
       let isRevalidatingLoader = currentMatch != null && !isNewRouteInstance(currentMatch, match) && (currentLoaderData && currentLoaderData[match.route.id]) !== undefined;
 
@@ -4037,6 +4100,7 @@
   exports.UNSAFE_DeferredData = DeferredData;
   exports.UNSAFE_convertRoutesToDataRoutes = convertRoutesToDataRoutes;
   exports.UNSAFE_getPathContributingMatches = getPathContributingMatches;
+  exports.UNSAFE_invariant = invariant;
   exports.createBrowserHistory = createBrowserHistory;
   exports.createHashHistory = createHashHistory;
   exports.createMemoryHistory = createMemoryHistory;
@@ -4047,7 +4111,6 @@
   exports.generatePath = generatePath;
   exports.getStaticContextFromError = getStaticContextFromError;
   exports.getToPathname = getToPathname;
-  exports.invariant = invariant;
   exports.isRouteErrorResponse = isRouteErrorResponse;
   exports.joinPaths = joinPaths;
   exports.json = json;