@remix-run/router 1.23.2 → 1.23.4

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # `@remix-run/router`
 
+## v1.23.4
+
+### Patch Changes
+
+- Fix double slash normalization for `useNavigate` colon urls ([3ed85d5](https://github.com/remix-run/react-router/commit/3ed85d5))
+
+  - As a reminder, `navigate()` is only intended for navigations within the React Router application and not for external navigations to other domains
+  - This change may be a breaking bug fix if you are using `navigate` for external navigations
+
+## v1.23.3
+
+### Patch Changes
+
+- Lift `decodePath` call out of hot path during route matching ([#15119](https://github.com/remix-run/react-router/pull/15119))
+- Normalize double slashes in redirect paths ([#15118](https://github.com/remix-run/react-router/pull/15118))
+
 ## 1.23.2
 
 ### Patch Changes

package/dist/router.cjs.js

@@ -1,5 +1,5 @@
 /**
- * @remix-run/router v1.23.2
+ * @remix-run/router v1.23.4
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -13,18 +13,13 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function _extends() {
-  _extends = Object.assign ? Object.assign.bind() : function (target) {
-    for (var i = 1; i < arguments.length; i++) {
-      var source = arguments[i];
-      for (var key in source) {
-        if (Object.prototype.hasOwnProperty.call(source, key)) {
-          target[key] = source[key];
-        }
-      }
+  return _extends = Object.assign ? Object.assign.bind() : function (n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
     }
-    return target;
-  };
-  return _extends.apply(this, arguments);
+    return n;
+  }, _extends.apply(null, arguments);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -35,8 +30,24 @@ function _extends() {
  * Actions represent the type of change to a location value.
  */
 let Action = /*#__PURE__*/function (Action) {
+  /**
+   * A POP indicates a change to an arbitrary index in the history stack, such
+   * as a back or forward navigation. It does not describe the direction of the
+   * navigation, only that the current index changed.
+   *
+   * Note: This is the default action for newly created history objects.
+   */
   Action["Pop"] = "POP";
+  /**
+   * A PUSH indicates a new entry being added to the history stack, such as when
+   * a link is clicked and a new page loads. When this happens, all subsequent
+   * entries in the stack are lost.
+   */
   Action["Push"] = "PUSH";
+  /**
+   * A REPLACE indicates the entry at the current index in the history stack
+   * being replaced by a new one.
+   */
   Action["Replace"] = "REPLACE";
   return Action;
 }({});
@@ -47,21 +58,26 @@ let Action = /*#__PURE__*/function (Action) {
 
 // TODO: (v7) Change the Location generic default from `any` to `unknown` and
 // remove Remix `useLocation` wrapper.
+
 /**
  * An entry in a history stack. A location contains information about the
  * URL path, as well as possibly some arbitrary state and a key.
  */
+
 /**
  * A change to the current location.
  */
+
 /**
  * A function that receives notifications about location changes.
  */
+
 /**
  * Describes a location that is the destination of some navigation, either via
  * `history.push` or `history.replace`. This may be either a URL or the pieces
  * of a URL path.
  */
+
 /**
  * A history is an interface to the navigation stack. The history serves as the
  * source of truth for the current location, as well as provides a set of
@@ -70,6 +86,7 @@ let Action = /*#__PURE__*/function (Action) {
  * It is similar to the DOM's `window.history` object, but with a smaller, more
  * focused API.
  */
+
 const PopStateEventType = "popstate";
 //#endregion
 
@@ -81,11 +98,13 @@ const PopStateEventType = "popstate";
  * A user-supplied object that describes a location. Used when providing
  * entries to `createMemoryHistory` via its `initialEntries` option.
  */
+
 /**
  * A memory history stores locations in memory. This is useful in stateful
  * environments where there is no web browser, such as node tests or React
  * Native.
  */
+
 /**
  * Memory history stores the current location in memory. It is designed for use
  * in stateful non-browser environments like tests and React Native.
@@ -203,6 +222,7 @@ function createMemoryHistory(options) {
  *
  * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#browserhistory
  */
+
 /**
  * Browser history stores the location in regular URLs. This is the standard for
  * most web apps, but it requires some configuration on the server to ensure you
@@ -250,6 +270,7 @@ function createBrowserHistory(options) {
  *
  * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#hashhistory
  */
+
 /**
  * Hash history stores the location in window.location.hash. This makes it ideal
  * for situations where you don't want to send the location to the server for
@@ -310,6 +331,7 @@ function createHashHistory(options) {
 /**
  * @private
  */
+
 function invariant(value, message) {
   if (value === false || value === null || typeof value === "undefined") {
     throw new Error(message);
@@ -609,26 +631,33 @@ let ResultType = /*#__PURE__*/function (ResultType) {
 // TODO: (v7) Change the defaults from any to unknown in and remove Remix wrappers:
 //   ActionFunction, ActionFunctionArgs, LoaderFunction, LoaderFunctionArgs
 //   Also, make them a type alias instead of an interface
+
 /**
  * Arguments passed to loader functions
  */
+
 /**
  * Arguments passed to action functions
  */
+
 /**
  * Loaders and actions can return anything except `undefined` (`null` is a
  * valid return value if there is no data to return).  Responses are preferred
  * and will ease any future migration to Remix
  */
+
 /**
  * Route loader function signature
  */
+
 /**
  * Route action function signature
  */
+
 /**
  * Arguments passed to shouldRevalidate function
  */
+
 /**
  * Route shouldRevalidate function signature.  This runs after any submission
  * (navigation or fetcher), so we flatten the navigation/fetcher submission
@@ -636,24 +665,29 @@ let ResultType = /*#__PURE__*/function (ResultType) {
  * or a fetcher, what really matters is the URLs and the formData since loaders
  * have to re-run based on the data models that were potentially mutated.
  */
+
 /**
  * Function provided by the framework-aware layers to set `hasErrorBoundary`
  * from the framework-aware `errorElement` prop
  *
  * @deprecated Use `mapRouteProperties` instead
  */
+
 /**
  * Result from a loader or action called via dataStrategy
  */
+
 /**
  * Function provided by the framework-aware layers to set any framework-specific
  * properties from framework-agnostic properties
  */
+
 /**
  * Keys we cannot change from within a lazy() function. We spread all other keys
  * onto the route. Either they're meaningful to the router, or they'll get
  * ignored.
  */
+
 const immutableRouteKeys = new Set(["lazy", "caseSensitive", "path", "id", "index", "children"]);
 
 /**
@@ -697,12 +731,15 @@ const immutableRouteKeys = new Set(["lazy", "caseSensitive", "path", "id", "inde
 // Attempt to parse the given string segment. If it fails, then just return the
 // plain string type as a default fallback. Otherwise, return the union of the
 // parsed string literals that were referenced as dynamic segments in the route.
+
 /**
  * The parameters that were parsed from the URL path.
  */
+
 /**
  * A RouteMatch contains info about how a route matched a URL.
  */
+
 function isIndexRoute(route) {
   return route.index === true;
 }
@@ -761,6 +798,7 @@ function matchRoutesImpl(routes, locationArg, basename, allowPartial) {
   let branches = flattenRoutes(routes);
   rankRouteBranches(branches);
   let matches = null;
+  let decoded = decodePath(pathname);
   for (let i = 0; matches == null && i < branches.length; ++i) {
     // Incoming pathnames are generally encoded from either window.location
     // or from router.navigate, but we want to match against the unencoded
@@ -768,7 +806,6 @@ function matchRoutesImpl(routes, locationArg, basename, allowPartial) {
     // encoded here but there also shouldn't be anything to decode so this
     // should be a safe operation.  This avoids needing matchRoutes to be
     // history-aware.
-    let decoded = decodePath(pathname);
     matches = matchRouteBranch(branches[i], decoded, allowPartial);
   }
   return matches;
@@ -1140,8 +1177,6 @@ function stripBasename(pathname, basename) {
   }
   return pathname.slice(startIndex) || "/";
 }
-const ABSOLUTE_URL_REGEX$1 = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
-const isAbsoluteUrl = url => ABSOLUTE_URL_REGEX$1.test(url);
 
 /**
  * Returns a resolved path object relative to the given pathname.
@@ -1159,19 +1194,11 @@ function resolvePath(to, fromPathname) {
   } = typeof to === "string" ? parsePath(to) : to;
   let pathname;
   if (toPathname) {
-    if (isAbsoluteUrl(toPathname)) {
-      pathname = toPathname;
+    toPathname = removeDoubleSlashes(toPathname);
+    if (toPathname.startsWith("/")) {
+      pathname = resolvePathname(toPathname.substring(1), "/");
     } else {
-      if (toPathname.includes("//")) {
-        let oldPathname = toPathname;
-        toPathname = toPathname.replace(/\/\/+/g, "/");
-        warning(false, "Pathnames cannot have embedded double slashes - normalizing " + (oldPathname + " -> " + toPathname));
-      }
-      if (toPathname.startsWith("/")) {
-        pathname = resolvePathname(toPathname.substring(1), "/");
-      } else {
-        pathname = resolvePathname(toPathname, fromPathname);
-      }
+      pathname = resolvePathname(toPathname, fromPathname);
     }
   } else {
     pathname = fromPathname;
@@ -1307,11 +1334,12 @@ function getToPathname(to) {
   // Empty strings should be treated the same as / paths
   return to === "" || to.pathname === "" ? "/" : typeof to === "string" ? parsePath(to).pathname : to.pathname;
 }
+const removeDoubleSlashes = path => path.replace(/\/\/+/g, "/");
 
 /**
  * @private
  */
-const joinPaths = paths => paths.join("/").replace(/\/\/+/g, "/");
+const joinPaths = paths => removeDoubleSlashes(paths.join("/"));
 
 /**
  * @private
@@ -1604,69 +1632,92 @@ function isRouteErrorResponse(error) {
 /**
  * A Router instance manages all navigation and data loading/mutations
  */
+
 /**
  * State maintained internally by the router.  During a navigation, all states
  * reflect the the "old" location unless otherwise noted.
  */
+
 /**
  * Data that can be passed into hydrate a Router from SSR
  */
+
 /**
  * Future flags to toggle new feature behavior
  */
+
 /**
  * Initialization options for createRouter
  */
+
 /**
  * State returned from a server-side query() call
  */
+
 /**
  * A StaticHandler instance manages a singular SSR navigation/fetch event
  */
+
 /**
  * Subscriber function signature for changes to router state
  */
+
 /**
  * Function signature for determining the key to be used in scroll restoration
  * for a given location
  */
+
 /**
  * Function signature for determining the current scroll position
  */
+
 // Allowed for any navigation or fetch
+
 // Only allowed for navigations
+
 // Only allowed for submission navigations
+
 /**
  * Options for a navigate() call for a normal (non-submission) navigation
  */
+
 /**
  * Options for a navigate() call for a submission navigation
  */
+
 /**
  * Options to pass to navigate() for a navigation
  */
+
 /**
  * Options for a fetch() load
  */
+
 /**
  * Options for a fetch() submission
  */
+
 /**
  * Options to pass to fetch()
  */
+
 /**
  * Potential states for state.navigation
  */
+
 /**
  * Potential states for fetchers
  */
+
 /**
  * Cached info for active fetcher.load() instances so they can participate
  * in revalidation
  */
+
 /**
  * Identified fetcher.load() calls that need to be revalidated
  */
+
 const validMutationMethodsArr = ["post", "put", "patch", "delete"];
 const validMutationMethods = new Set(validMutationMethodsArr);
 const validRequestMethodsArr = ["get", ...validMutationMethodsArr];
@@ -4969,7 +5020,7 @@ function normalizeRedirectLocation(location, currentUrl, basename, historyInstan
     }
     let isSameBasename = stripBasename(url.pathname, basename) != null;
     if (url.origin === currentUrl.origin && isSameBasename) {
-      return url.pathname + url.search + url.hash;
+      return removeDoubleSlashes(url.pathname) + url.search + url.hash;
     }
   }
   try {