@remix-run/router 1.14.0 → 1.14.1

package/dist/router.umd.js

@@ -1,5 +1,5 @@
 /**
- * @remix-run/router v1.14.0
+ * @remix-run/router v1.14.1
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -1239,37 +1239,21 @@
     // to the current location's pathname and *not* the route pathname.
     if (toPathname == null) {
       from = locationPathname;
-    } else if (isPathRelative) {
-      let fromSegments = routePathnames.length === 0 ? [] : routePathnames[routePathnames.length - 1].replace(/^\//, "").split("/");
-      if (toPathname.startsWith("..")) {
-        let toSegments = toPathname.split("/");
-
-        // With relative="path", each leading .. segment means "go up one URL segment"
-        while (toSegments[0] === "..") {
-          toSegments.shift();
-          fromSegments.pop();
-        }
-        to.pathname = toSegments.join("/");
-      }
-      from = "/" + fromSegments.join("/");
     } else {
       let routePathnameIndex = routePathnames.length - 1;
-      if (toPathname.startsWith("..")) {
-        let toSegments = toPathname.split("/");
 
-        // With relative="route" (the default), each leading .. segment means
-        // "go up one route" instead of "go up one URL segment".  This is a key
-        // difference from how <a href> works and a major reason we call this a
-        // "to" value instead of a "href".
+      // With relative="route" (the default), each leading .. segment means
+      // "go up one route" instead of "go up one URL segment".  This is a key
+      // difference from how <a href> works and a major reason we call this a
+      // "to" value instead of a "href".
+      if (!isPathRelative && toPathname.startsWith("..")) {
+        let toSegments = toPathname.split("/");
         while (toSegments[0] === "..") {
           toSegments.shift();
           routePathnameIndex -= 1;
         }
         to.pathname = toSegments.join("/");
       }
-
-      // If there are more ".." segments than parent routes, resolve relative to
-      // the root / URL.
       from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : "/";
     }
     let path = resolvePath(to, from);
@@ -2646,32 +2630,40 @@
         }
         return;
       }
-      if (deletedFetchers.has(key)) {
-        updateFetcherState(key, getDoneFetcher(undefined));
-        return;
-      }
-      if (isRedirectResult(actionResult)) {
-        fetchControllers.delete(key);
-        if (pendingNavigationLoadId > originatingLoadId) {
-          // A new navigation was kicked off after our action started, so that
-          // should take precedence over this redirect navigation.  We already
-          // set isRevalidationRequired so all loaders for the new route should
-          // fire unless opted out via shouldRevalidate
+
+      // When using v7_fetcherPersist, we don't want errors bubbling up to the UI
+      // or redirects processed for unmounted fetchers so we just revert them to
+      // idle
+      if (future.v7_fetcherPersist && deletedFetchers.has(key)) {
+        if (isRedirectResult(actionResult) || isErrorResult(actionResult)) {
           updateFetcherState(key, getDoneFetcher(undefined));
           return;
-        } else {
-          fetchRedirectIds.add(key);
-          updateFetcherState(key, getLoadingFetcher(submission));
-          return startRedirectNavigation(state, actionResult, {
-            fetcherSubmission: submission
-          });
         }
-      }
+        // Let SuccessResult's fall through for revalidation
+      } else {
+        if (isRedirectResult(actionResult)) {
+          fetchControllers.delete(key);
+          if (pendingNavigationLoadId > originatingLoadId) {
+            // A new navigation was kicked off after our action started, so that
+            // should take precedence over this redirect navigation.  We already
+            // set isRevalidationRequired so all loaders for the new route should
+            // fire unless opted out via shouldRevalidate
+            updateFetcherState(key, getDoneFetcher(undefined));
+            return;
+          } else {
+            fetchRedirectIds.add(key);
+            updateFetcherState(key, getLoadingFetcher(submission));
+            return startRedirectNavigation(state, actionResult, {
+              fetcherSubmission: submission
+            });
+          }
+        }
 
-      // Process any non-redirect errors thrown
-      if (isErrorResult(actionResult)) {
-        setFetcherError(key, routeId, actionResult.error);
-        return;
+        // Process any non-redirect errors thrown
+        if (isErrorResult(actionResult)) {
+          setFetcherError(key, routeId, actionResult.error);
+          return;
+        }
       }
       if (isDeferredResult(actionResult)) {
         throw getInternalRouterError(400, {
@@ -2808,6 +2800,9 @@
       if (fetchRequest.signal.aborted) {
         return;
       }
+
+      // We don't want errors bubbling up or redirects followed for unmounted
+      // fetchers, so short circuit here if it was removed from the UI
       if (deletedFetchers.has(key)) {
         updateFetcherState(key, getDoneFetcher(undefined));
         return;
@@ -3866,18 +3861,24 @@
     let boundaryId = pendingError ? Object.keys(pendingError)[0] : undefined;
     let boundaryMatches = getLoaderMatchesUntilBoundary(matches, boundaryId);
     let navigationMatches = boundaryMatches.filter((match, index) => {
-      if (isInitialLoad) {
-        // On initial hydration we don't do any shouldRevalidate stuff - we just
-        // call the unhydrated loaders
-        return isUnhydratedRoute(state, match.route);
-      }
-      if (match.route.lazy) {
+      let {
+        route
+      } = match;
+      if (route.lazy) {
         // We haven't loaded this route yet so we don't know if it's got a loader!
         return true;
       }
-      if (match.route.loader == null) {
+      if (route.loader == null) {
         return false;
       }
+      if (isInitialLoad) {
+        if (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)) {
@@ -3979,20 +3980,6 @@
     });
     return [navigationMatches, revalidatingFetchers];
   }
-
-  // Is this route unhydrated (when v7_partialHydration=true) such that we need
-  // to call it's loader on the initial router creation
-  function isUnhydratedRoute(state, route) {
-    if (!route.loader) {
-      return false;
-    }
-    if (route.loader.hydrate) {
-      return true;
-    }
-    return state.loaderData[route.id] === undefined && (!state.errors ||
-    // Loader ran but errored - don't re-run
-    state.errors[route.id] === undefined);
-  }
   function isNewLoader(currentLoaderData, currentMatch, match) {
     let isNew =
     // [a] -> [a, b]