@remix-run/router 1.3.1-pre.0 → 1.3.2-pre.0

package/CHANGELOG.md

@@ -1,14 +1,24 @@
 # `@remix-run/router`
 
-## 1.3.1-pre.0
+## 1.3.2-pre.0
 
 ### Patch Changes
 
-- Respect `preventScrollReset` on `fetcher.Form` ([#9963](https://github.com/remix-run/react-router/pull/9963))
-- Fix revalidating fetcher `shouldRevalidate` params ([#9948](https://github.com/remix-run/react-router/pull/9948))
+- Remove inaccurate console warning for POP navigations ([#10030](https://github.com/remix-run/react-router/pull/10030))
+- Only check for differing origin on absolute URL redirects ([#10033](https://github.com/remix-run/react-router/pull/10033))
+
+## 1.3.1
+
+### Patch Changes
+
+- Fixes 2 separate issues for revalidating fetcher `shouldRevalidate` calls ([#9948](https://github.com/remix-run/react-router/pull/9948))
+  - The `shouldRevalidate` function was only being called for _explicit_ revalidation scenarios (after a mutation, manual `useRevalidator` call, or an `X-Remix-Revalidate` header used for cookie setting in Remix). It was not properly being called on _implicit_ revalidation scenarios that also apply to navigation `loader` revalidation, such as a change in search params or clicking a link for the page we're already on. It's now correctly called in those additional scenarios.
+  - The parameters being passed were incorrect and inconsistent with one another since the `current*`/`next*` parameters reflected the static `fetcher.load` URL (and thus were identical). Instead, they should have reflected the the navigation that triggered the revalidation (as the `form*` parameters did). These parameters now correctly reflect the triggering navigation.
+- Respect `preventScrollReset` on `<fetcher.Form>` ([#9963](https://github.com/remix-run/react-router/pull/9963))
 - Do not short circuit on hash change only mutation submissions ([#9944](https://github.com/remix-run/react-router/pull/9944))
 - Remove `instanceof` check from `isRouteErrorResponse` to avoid bundling issues on the server ([#9930](https://github.com/remix-run/react-router/pull/9930))
-- Detect no lazy data and remove abort controller for `defer` ([#9965](https://github.com/remix-run/react-router/pull/9965))
+- Fix navigation for hash routers on manual URL changes ([#9980](https://github.com/remix-run/react-router/pull/9980))
+- Detect when a `defer` call only contains critical data and remove the `AbortController` ([#9965](https://github.com/remix-run/react-router/pull/9965))
 - Send the name as the value when url-encoding `File` `FormData` entries ([#9867](https://github.com/remix-run/react-router/pull/9867))
 
 ## 1.3.0

package/dist/history.d.ts

@@ -71,7 +71,7 @@ export interface Update {
     /**
      * The delta between this location and the former location in the history stack
      */
-    delta: number;
+    delta: number | null;
 }
 /**
  * A function that receives notifications about location changes.

package/dist/router.cjs.js

@@ -1,5 +1,5 @@
 /**
- * @remix-run/router v1.3.1-pre.0
+ * @remix-run/router v1.3.2-pre.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -433,23 +433,17 @@ function getUrlBasedHistory(getLocation, createHref, validateLocation, options)
   }
 
   function handlePop() {
-    let nextAction = exports.Action.Pop;
+    action = exports.Action.Pop;
     let nextIndex = getIndex();
+    let delta = nextIndex == null ? null : nextIndex - index;
+    index = nextIndex;
 
-    if (nextIndex != null) {
-      let delta = nextIndex - index;
-      action = nextAction;
-      index = nextIndex;
-
-      if (listener) {
-        listener({
-          action,
-          location: history.location,
-          delta
-        });
-      }
-    } else {
-      warning$1(false, "You are trying to perform a POP navigation to a location that was not " + "created by @remix-run/router. This will fail silently in production.  " + "You should navigate via the router to avoid this situation (instead of " + "using window.history.pushState/window.location.hash).");
+    if (listener) {
+      listener({
+        action,
+        location: history.location,
+        delta
+      });
     }
   }
 
@@ -1482,6 +1476,7 @@ const IDLE_BLOCKER = {
   reset: undefined,
   location: undefined
 };
+const ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
 const isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined";
 const isServer = !isBrowser; //#endregion
 ////////////////////////////////////////////////////////////////////////////////
@@ -1589,10 +1584,7 @@ function createRouter(init) {
   // promise resolves we update loaderData.  If a new navigation starts we
   // cancel active deferreds for eliminated routes.
 
-  let activeDeferreds = new Map(); // We ony support a single active blocker at the moment since we don't have
-  // any compelling use cases for multi-blocker yet
-
-  let activeBlocker = null; // Store blocker functions in a separate Map outside of router state since
+  let activeDeferreds = new Map(); // Store blocker functions in a separate Map outside of router state since
   // we don't need to update UI state if they change
 
   let blockerFunctions = new Map(); // Flag to ignore the next history update, so we can revert the URL change on
@@ -1619,13 +1611,14 @@ function createRouter(init) {
         return;
       }
 
+      warning(blockerFunctions.size === 0 || delta != null, "You are trying to use a blocker on a POP navigation to a location " + "that was not created by @remix-run/router. This will fail silently in " + "production. This can happen if you are navigating outside the router " + "via `window.history.pushState`/`window.location.hash` instead of using " + "router navigation APIs.  This can also happen if you are using " + "createHashRouter and the user manually changes the URL.");
       let blockerKey = shouldBlockNavigation({
         currentLocation: state.location,
         nextLocation: location,
         historyAction
       });
 
-      if (blockerKey) {
+      if (blockerKey && delta != null) {
         // Restore the URL to match the current UI, but don't update router state
         ignoreNextHistoryUpdate = true;
         init.history.go(delta * -1); // Put the blocker into a blocked state
@@ -2552,9 +2545,9 @@ function createRouter(init) {
     }, isFetchActionRedirect ? {
       _isFetchActionRedirect: true
     } : {}));
-    invariant(redirectLocation, "Expected a location on the redirect navigation"); // Check if this an external redirect that goes to a new origin
+    invariant(redirectLocation, "Expected a location on the redirect navigation"); // Check if this an absolute external redirect that goes to a new origin
 
-    if (isBrowser && typeof ((_window = window) == null ? void 0 : _window.location) !== "undefined") {
+    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;
 
       if (window.location.origin !== newOrigin) {
@@ -2732,13 +2725,6 @@ function createRouter(init) {
 
     if (blockerFunctions.get(key) !== fn) {
       blockerFunctions.set(key, fn);
-
-      if (activeBlocker == null) {
-        // This is now the active blocker
-        activeBlocker = key;
-      } else if (key !== activeBlocker) {
-        warning(false, "A router only supports one blocker at a time");
-      }
     }
 
     return blocker;
@@ -2747,10 +2733,6 @@ function createRouter(init) {
   function deleteBlocker(key) {
     state.blockers.delete(key);
     blockerFunctions.delete(key);
-
-    if (activeBlocker === key) {
-      activeBlocker = null;
-    }
   } // Utility function to update blockers, ensuring valid state transitions
 
 
@@ -2772,15 +2754,19 @@ function createRouter(init) {
       historyAction
     } = _ref2;
 
-    if (activeBlocker == null) {
+    if (blockerFunctions.size === 0) {
       return;
-    } // We only allow a single blocker at the moment.  This will need to be
-    // updated if we enhance to support multiple blockers in the future
+    } // We ony support a single active blocker at the moment since we don't have
+    // any compelling use cases for multi-blocker yet
 
 
-    let blockerFunction = blockerFunctions.get(activeBlocker);
-    invariant(blockerFunction, "Could not find a function for the active blocker");
-    let blocker = state.blockers.get(activeBlocker);
+    if (blockerFunctions.size > 1) {
+      warning(false, "A router only supports one blocker at a time");
+    }
+
+    let entries = Array.from(blockerFunctions.entries());
+    let [blockerKey, blockerFunction] = entries[entries.length - 1];
+    let blocker = state.blockers.get(blockerKey);
 
     if (blocker && blocker.state === "proceeding") {
       // If the blocker is currently proceeding, we don't need to re-check
@@ -2795,7 +2781,7 @@ function createRouter(init) {
       nextLocation,
       historyAction
     })) {
-      return activeBlocker;
+      return blockerKey;
     }
   }
 
@@ -3545,10 +3531,9 @@ async function callLoaderOrAction(type, request, match, matches, basename, isSta
 
     if (redirectStatusCodes.has(status)) {
       let location = result.headers.get("Location");
-      invariant(location, "Redirects returned/thrown from loaders/actions must have a Location header");
-      let isAbsolute = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i.test(location); // Support relative routing in internal redirects
+      invariant(location, "Redirects returned/thrown from loaders/actions must have a Location header"); // Support relative routing in internal redirects
 
-      if (!isAbsolute) {
+      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);