@remix-run/router 1.23.2 → 1.23.4

package/dist/router.umd.js

@@ -1,5 +1,5 @@
 /**
- * @remix-run/router v1.23.2
+ * @remix-run/router v1.23.4
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -15,18 +15,13 @@
 })(this, (function (exports) { 'use strict';
 
   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);
   }
 
   ////////////////////////////////////////////////////////////////////////////////
@@ -37,8 +32,24 @@
    * 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;
   }({});
@@ -49,21 +60,26 @@
 
   // 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
@@ -72,6 +88,7 @@
    * It is similar to the DOM's `window.history` object, but with a smaller, more
    * focused API.
    */
+
   const PopStateEventType = "popstate";
   //#endregion
 
@@ -83,11 +100,13 @@
    * 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.
@@ -205,6 +224,7 @@
    *
    * @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
@@ -252,6 +272,7 @@
    *
    * @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
@@ -312,6 +333,7 @@
   /**
    * @private
    */
+
   function invariant(value, message) {
     if (value === false || value === null || typeof value === "undefined") {
       throw new Error(message);
@@ -611,26 +633,33 @@
   // 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
@@ -638,24 +667,29 @@
    * 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"]);
 
   /**
@@ -699,12 +733,15 @@
   // 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;
   }
@@ -763,6 +800,7 @@
     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
@@ -770,7 +808,6 @@
       // 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;
@@ -1142,8 +1179,6 @@
     }
     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.
@@ -1161,19 +1196,11 @@
     } = 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;
@@ -1309,11 +1336,12 @@
     // 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
@@ -1606,69 +1634,92 @@
   /**
    * 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];
@@ -4971,7 +5022,7 @@
       }
       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 {