@remix-run/router 1.7.1 → 1.7.2-pre.0

package/dist/router.umd.js

@@ -1,5 +1,5 @@
 /**
- * @remix-run/router v1.7.1
+ * @remix-run/router v1.7.2-pre.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -1281,7 +1281,7 @@
 
       // We store a little wrapper promise that will be extended with
       // _data/_error props upon resolve/reject
-      let promise = Promise.race([value, this.abortPromise]).then(data => this.onSettle(promise, key, null, data), error => this.onSettle(promise, key, error));
+      let promise = Promise.race([value, this.abortPromise]).then(data => this.onSettle(promise, key, undefined, data), error => this.onSettle(promise, key, error));
 
       // Register rejection listeners to avoid uncaught promise rejections on
       // errors or aborted deferred values
@@ -1304,7 +1304,18 @@
         // Nothing left to abort!
         this.unlistenAbortSignal();
       }
-      if (error) {
+
+      // If the promise was resolved/rejected with undefined, we'll throw an error as you
+      // should always resolve with a value or null
+      if (error === undefined && data === undefined) {
+        let undefinedError = new Error("Deferred data for key \"" + key + "\" resolved/rejected with `undefined`, " + "you must resolve/reject with a value or `null`.");
+        Object.defineProperty(promise, "_error", {
+          get: () => undefinedError
+        });
+        this.emit(false, key);
+        return Promise.reject(undefinedError);
+      }
+      if (data === undefined) {
         Object.defineProperty(promise, "_error", {
           get: () => error
         });
@@ -2266,7 +2277,14 @@
       // If any loaders returned a redirect Response, start a new REPLACE navigation
       let redirect = findRedirect(results);
       if (redirect) {
-        await startRedirectNavigation(state, redirect, {
+        if (redirect.idx >= matchesToLoad.length) {
+          // If this redirect came from a fetcher make sure we mark it in
+          // fetchRedirectIds so it doesn't get revalidated on the next set of
+          // loader executions
+          let fetcherKey = revalidatingFetchers[redirect.idx - matchesToLoad.length].key;
+          fetchRedirectIds.add(fetcherKey);
+        }
+        await startRedirectNavigation(state, redirect.result, {
           replace
         });
         return {
@@ -2372,6 +2390,7 @@
       let abortController = new AbortController();
       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);
       if (fetchRequest.signal.aborted) {
         // We can delete this so long as we weren't aborted by ou our own fetcher
@@ -2383,16 +2402,29 @@
       }
       if (isRedirectResult(actionResult)) {
         fetchControllers.delete(key);
-        fetchRedirectIds.add(key);
-        let loadingFetcher = getLoadingFetcher(submission);
-        state.fetchers.set(key, loadingFetcher);
-        updateState({
-          fetchers: new Map(state.fetchers)
-        });
-        return startRedirectNavigation(state, actionResult, {
-          submission,
-          isFetchActionRedirect: true
-        });
+        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
+          let doneFetcher = getDoneFetcher(undefined);
+          state.fetchers.set(key, doneFetcher);
+          updateState({
+            fetchers: new Map(state.fetchers)
+          });
+          return;
+        } else {
+          fetchRedirectIds.add(key);
+          let loadingFetcher = getLoadingFetcher(submission);
+          state.fetchers.set(key, loadingFetcher);
+          updateState({
+            fetchers: new Map(state.fetchers)
+          });
+          return startRedirectNavigation(state, actionResult, {
+            submission,
+            isFetchActionRedirect: true
+          });
+        }
       }
 
       // Process any non-redirect errors thrown
@@ -2456,7 +2488,14 @@
       revalidatingFetchers.forEach(r => fetchControllers.delete(r.key));
       let redirect = findRedirect(results);
       if (redirect) {
-        return startRedirectNavigation(state, redirect);
+        if (redirect.idx >= matchesToLoad.length) {
+          // If this redirect came from a fetcher make sure we mark it in
+          // fetchRedirectIds so it doesn't get revalidated on the next set of
+          // loader executions
+          let fetcherKey = revalidatingFetchers[redirect.idx - matchesToLoad.length].key;
+          fetchRedirectIds.add(fetcherKey);
+        }
+        return startRedirectNavigation(state, redirect.result);
       }
 
       // Process and commit output from loaders
@@ -2513,6 +2552,7 @@
       let abortController = new AbortController();
       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);
 
       // Deferred isn't supported for fetcher loads, await everything and treat it
@@ -2534,9 +2574,20 @@
 
       // If the loader threw a redirect Response, start a new REPLACE navigation
       if (isRedirectResult(result)) {
-        fetchRedirectIds.add(key);
-        await startRedirectNavigation(state, result);
-        return;
+        if (pendingNavigationLoadId > originatingLoadId) {
+          // A new navigation was kicked off after our loader started, so that
+          // should take precedence over this redirect navigation
+          let doneFetcher = getDoneFetcher(undefined);
+          state.fetchers.set(key, doneFetcher);
+          updateState({
+            fetchers: new Map(state.fetchers)
+          });
+          return;
+        } else {
+          fetchRedirectIds.add(key);
+          await startRedirectNavigation(state, result);
+          return;
+        }
       }
 
       // Process any non-redirect errors thrown
@@ -3573,7 +3624,9 @@
       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
+      // we can trigger a 404 in callLoadersAndMaybeResolveData.  Note this is
+      // currently only a use-case for Remix HMR where the route tree can change
+      // at runtime and remove a route previously loaded via a fetcher
       if (!fetcherMatches) {
         revalidatingFetchers.push({
           key,
@@ -3587,30 +3640,35 @@
       }
 
       // Revalidating fetchers are decoupled from the route matches since they
-      // load from a static href.  They only set `defaultShouldRevalidate` on
-      // explicit revalidation due to submission, useRevalidator, or X-Remix-Revalidate
-      //
-      // They automatically revalidate without even calling shouldRevalidate if:
-      // - They were cancelled
-      // - They're in the middle of their first load and therefore this is still
-      //   an initial load and not a revalidation
-      //
-      // If neither of those is true, then they _always_ check shouldRevalidate
+      // load from a static href.  They revalidate based on explicit revalidation
+      // (submission, useRevalidator, or X-Remix-Revalidate)
       let fetcher = state.fetchers.get(key);
-      let isPerformingInitialLoad = fetcher && fetcher.state !== "idle" && fetcher.data === undefined &&
-      // If a fetcher.load redirected then it'll be "loading" without any data
-      // so ensure we're not processing the redirect from this fetcher
-      !fetchRedirectIds.has(key);
       let fetcherMatch = getTargetMatch(fetcherMatches, f.path);
-      let shouldRevalidate = cancelledFetcherLoads.includes(key) || isPerformingInitialLoad || shouldRevalidateLoader(fetcherMatch, _extends({
-        currentUrl,
-        currentParams: state.matches[state.matches.length - 1].params,
-        nextUrl,
-        nextParams: matches[matches.length - 1].params
-      }, submission, {
-        actionResult,
-        defaultShouldRevalidate: isRevalidationRequired
-      }));
+      let shouldRevalidate = false;
+      if (fetchRedirectIds.has(key)) {
+        // Never trigger a revalidation of an actively redirecting fetcher
+        shouldRevalidate = false;
+      } else if (cancelledFetcherLoads.includes(key)) {
+        // Always revalidate if the fetcher was cancelled
+        shouldRevalidate = true;
+      } else if (fetcher && fetcher.state !== "idle" && fetcher.data === undefined) {
+        // If the fetcher hasn't ever completed loading yet, then this isn't a
+        // revalidation, it would just be a brand new load if an explicit
+        // revalidation is required
+        shouldRevalidate = isRevalidationRequired;
+      } else {
+        // Otherwise fall back on any user-defined shouldRevalidate, defaulting
+        // to explicit revalidations only
+        shouldRevalidate = shouldRevalidateLoader(fetcherMatch, _extends({
+          currentUrl,
+          currentParams: state.matches[state.matches.length - 1].params,
+          nextUrl,
+          nextParams: matches[matches.length - 1].params
+        }, submission, {
+          actionResult,
+          defaultShouldRevalidate: isRevalidationRequired
+        }));
+      }
       if (shouldRevalidate) {
         revalidatingFetchers.push({
           key,
@@ -4128,7 +4186,10 @@
     for (let i = results.length - 1; i >= 0; i--) {
       let result = results[i];
       if (isRedirectResult(result)) {
-        return result;
+        return {
+          result,
+          idx: i
+        };
       }
     }
   }