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

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # `@remix-run/router`
 
+## 1.8.0-pre.0
+
+### Minor Changes
+
+- Add's a new `redirectDocument()` function which allows users to specify that a redirect from a `loader`/`action` should trigger a document reload (via `window.location`) instead of attempting to navigate to the redirected location via React Router ([#10705](https://github.com/remix-run/react-router/pull/10705))
+
+### Patch Changes
+
+- Fix an issue in `queryRoute` that was not always identifying thrown `Response` instances ([#10717](https://github.com/remix-run/react-router/pull/10717))
+- Ensure hash history always includes a leading slash on hash pathnames ([#10753](https://github.com/remix-run/react-router/pull/10753))
+
 ## 1.7.2
 
 ### Patch Changes

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export type { ActionFunction, ActionFunctionArgs, AgnosticDataIndexRouteObject, AgnosticDataNonIndexRouteObject, AgnosticDataRouteMatch, AgnosticDataRouteObject, AgnosticIndexRouteObject, AgnosticNonIndexRouteObject, AgnosticRouteMatch, AgnosticRouteObject, LazyRouteFunction, TrackedPromise, FormEncType, FormMethod, HTMLFormMethod, JsonFunction, LoaderFunction, LoaderFunctionArgs, ParamParseKey, Params, PathMatch, PathPattern, RedirectFunction, ShouldRevalidateFunction, V7_FormMethod, } from "./utils";
-export { AbortedDeferredError, ErrorResponse, defer, generatePath, getToPathname, isRouteErrorResponse, joinPaths, json, matchPath, matchRoutes, normalizePathname, redirect, resolvePath, resolveTo, stripBasename, } from "./utils";
+export { AbortedDeferredError, ErrorResponse, defer, generatePath, getToPathname, isRouteErrorResponse, joinPaths, json, matchPath, matchRoutes, normalizePathname, redirect, redirectDocument, resolvePath, resolveTo, stripBasename, } from "./utils";
 export type { BrowserHistory, BrowserHistoryOptions, HashHistory, HashHistoryOptions, History, InitialEntry, Location, MemoryHistory, MemoryHistoryOptions, Path, To, } from "./history";
 export { Action, createBrowserHistory, createPath, createHashHistory, createMemoryHistory, parsePath, } from "./history";
 export * from "./router";

package/dist/router.cjs.js

@@ -1,5 +1,5 @@
 /**
- * @remix-run/router v1.7.2
+ * @remix-run/router v1.8.0-pre.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -34,31 +34,36 @@ function _extends() {
 /**
  * Actions represent the type of change to a location value.
  */
-exports.Action = void 0;
+let Action = /*#__PURE__*/function (Action) {
+  Action["Pop"] = "POP";
+  Action["Push"] = "PUSH";
+  Action["Replace"] = "REPLACE";
+  return Action;
+}({});
 
 /**
  * The pathname, search, and hash values of a URL.
  */
-(function (Action) {
-  Action["Pop"] = "POP";
-  Action["Push"] = "PUSH";
-  Action["Replace"] = "REPLACE";
-})(exports.Action || (exports.Action = {}));
+
 /**
  * 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`. 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
@@ -67,6 +72,7 @@ exports.Action = void 0;
  * It is similar to the DOM's `window.history` object, but with a smaller, more
  * focused API.
  */
+
 const PopStateEventType = "popstate";
 //#endregion
 
@@ -99,7 +105,7 @@ function createMemoryHistory(options) {
   let entries; // Declare so we can access from createMemoryLocation
   entries = initialEntries.map((entry, index) => createMemoryLocation(entry, typeof entry === "string" ? null : entry.state, index === 0 ? "default" : undefined));
   let index = clampIndex(initialIndex == null ? entries.length - 1 : initialIndex);
-  let action = exports.Action.Pop;
+  let action = Action.Pop;
   let listener = null;
   function clampIndex(n) {
     return Math.min(Math.max(n, 0), entries.length - 1);
@@ -141,7 +147,7 @@ function createMemoryHistory(options) {
       };
     },
     push(to, state) {
-      action = exports.Action.Push;
+      action = Action.Push;
       let nextLocation = createMemoryLocation(to, state);
       index += 1;
       entries.splice(index, entries.length, nextLocation);
@@ -154,7 +160,7 @@ function createMemoryHistory(options) {
       }
     },
     replace(to, state) {
-      action = exports.Action.Replace;
+      action = Action.Replace;
       let nextLocation = createMemoryLocation(to, state);
       entries[index] = nextLocation;
       if (v5Compat && listener) {
@@ -166,7 +172,7 @@ function createMemoryHistory(options) {
       }
     },
     go(delta) {
-      action = exports.Action.Pop;
+      action = Action.Pop;
       let nextIndex = clampIndex(index + delta);
       let nextLocation = entries[nextIndex];
       index = nextIndex;
@@ -265,6 +271,16 @@ function createHashHistory(options) {
       search = "",
       hash = ""
     } = parsePath(window.location.hash.substr(1));
+
+    // Hash URL should always have a leading / just like window.location.pathname
+    // does, so if an app ends up at a route like /#something then we add a
+    // leading slash so all of our path-matching behaves the same as if it would
+    // in a browser router.  This is particularly important when there exists a
+    // root splat route (<Route path="*">) since that matches internally against
+    // "/*" and we'd expect /#something to 404 in a hash router app.
+    if (!pathname.startsWith("/") && !pathname.startsWith(".")) {
+      pathname = "/" + pathname;
+    }
     return createLocation("", {
       pathname,
       search,
@@ -399,7 +415,7 @@ function getUrlBasedHistory(getLocation, createHref, validateLocation, options)
     v5Compat = false
   } = options;
   let globalHistory = window.history;
-  let action = exports.Action.Pop;
+  let action = Action.Pop;
   let listener = null;
   let index = getIndex();
   // Index should only be null when we initialize. If not, it's because the
@@ -418,7 +434,7 @@ function getUrlBasedHistory(getLocation, createHref, validateLocation, options)
     return state.idx;
   }
   function handlePop() {
-    action = exports.Action.Pop;
+    action = Action.Pop;
     let nextIndex = getIndex();
     let delta = nextIndex == null ? null : nextIndex - index;
     index = nextIndex;
@@ -431,7 +447,7 @@ function getUrlBasedHistory(getLocation, createHref, validateLocation, options)
     }
   }
   function push(to, state) {
-    action = exports.Action.Push;
+    action = Action.Push;
     let location = createLocation(history.location, to, state);
     if (validateLocation) validateLocation(location, to);
     index = getIndex() + 1;
@@ -462,7 +478,7 @@ function getUrlBasedHistory(getLocation, createHref, validateLocation, options)
     }
   }
   function replace(to, state) {
-    action = exports.Action.Replace;
+    action = Action.Replace;
     let location = createLocation(history.location, to, state);
     if (validateLocation) validateLocation(location, to);
     index = getIndex();
@@ -532,69 +548,85 @@ function getUrlBasedHistory(getLocation, createHref, validateLocation, options)
  * Map of routeId -> data returned from a loader/action/error
  */
 
-let ResultType;
-
-/**
- * Successful result from a loader or action
- */
-(function (ResultType) {
+let ResultType = /*#__PURE__*/function (ResultType) {
   ResultType["data"] = "data";
   ResultType["deferred"] = "deferred";
   ResultType["redirect"] = "redirect";
   ResultType["error"] = "error";
-})(ResultType || (ResultType = {}));
+  return ResultType;
+}({});
+
+/**
+ * Successful result from a loader or action
+ */
+
 /**
  * Successful defer() result from a loader or action
  */
+
 /**
  * Redirect result from a loader or action
  */
+
 /**
  * Unsuccessful result from a loader or action
  */
+
 /**
  * Result from a loader or action - potentially successful or unsuccessful
  */
+
 /**
  * Users can specify either lowercase or uppercase form methods on <Form>,
  * useSubmit(), <fetcher.Form>, etc.
  */
+
 /**
  * Active navigation/fetcher form methods are exposed in lowercase on the
  * RouterState
  */
+
 /**
  * In v7, active navigation/fetcher form methods are exposed in uppercase on the
  * RouterState.  This is to align with the normalization done via fetch().
  */
+
 // Thanks https://github.com/sindresorhus/type-fest!
+
 /**
  * @private
  * Internal interface to pass around for action submissions, not intended for
  * external consumption
  */
+
 /**
  * @private
  * Arguments passed to route loader/action functions.  Same for now but we keep
  * this as a private implementation detail in case they diverge in the future.
  */
+
 /**
  * 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
  */
+
 /**
  * Route shouldRevalidate function signature.  This runs after any submission
  * (navigation or fetcher), so we flatten the navigation/fetcher submission
@@ -602,21 +634,25 @@ let 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
  */
+
 /**
  * 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"]);
 
 /**
@@ -1414,6 +1450,17 @@ const redirect = function redirect(url, init) {
   }));
 };
 
+/**
+ * A redirect response that will force a document reload to the new location.
+ * Sets the status code and the `Location` header.
+ * Defaults to "302 Found".
+ */
+const redirectDocument = (url, init) => {
+  let response = redirect(url, init);
+  response.headers.set("X-Remix-Reload-Document", "true");
+  return response;
+};
+
 /**
  * @private
  * Utility class we use to hold auto-unwrapped 4xx/5xx Response bodies
@@ -1653,7 +1700,7 @@ function createRouter(init) {
 
   // -- Stateful internal variables to manage navigations --
   // Current navigation in progress (to be committed in completeNavigation)
-  let pendingAction = exports.Action.Pop;
+  let pendingAction = Action.Pop;
 
   // Should the current navigation prevent the scroll reset if scroll cannot
   // be restored?
@@ -1776,7 +1823,7 @@ function createRouter(init) {
     // resolved prior to router creation since we can't go into a fallbackElement
     // UI for SSR'd apps
     if (!state.initialized) {
-      startNavigation(exports.Action.Pop, state.location);
+      startNavigation(Action.Pop, state.location);
     }
     return router;
   }
@@ -1851,9 +1898,9 @@ function createRouter(init) {
       dataRoutes = inFlightDataRoutes;
       inFlightDataRoutes = undefined;
     }
-    if (isUninterruptedRevalidation) ; else if (pendingAction === exports.Action.Pop) ; else if (pendingAction === exports.Action.Push) {
+    if (isUninterruptedRevalidation) ; else if (pendingAction === Action.Pop) ; else if (pendingAction === Action.Push) {
       init.history.push(location, location.state);
-    } else if (pendingAction === exports.Action.Replace) {
+    } else if (pendingAction === Action.Replace) {
       init.history.replace(location, location.state);
     }
     updateState(_extends({}, newState, {
@@ -1871,7 +1918,7 @@ function createRouter(init) {
     }));
 
     // Reset stateful navigation vars
-    pendingAction = exports.Action.Pop;
+    pendingAction = Action.Pop;
     pendingPreventScrollReset = false;
     isUninterruptedRevalidation = false;
     isRevalidationRequired = false;
@@ -1902,15 +1949,15 @@ function createRouter(init) {
     // without having to touch history
     nextLocation = _extends({}, nextLocation, init.history.encodeLocation(nextLocation));
     let userReplace = opts && opts.replace != null ? opts.replace : undefined;
-    let historyAction = exports.Action.Push;
+    let historyAction = Action.Push;
     if (userReplace === true) {
-      historyAction = exports.Action.Replace;
+      historyAction = Action.Replace;
     } else if (userReplace === false) ; else if (submission != null && isMutationMethod(submission.formMethod) && submission.formAction === state.location.pathname + state.location.search) {
       // By default on submissions to the current location we REPLACE so that
       // users don't have to double-click the back button to get to the prior
       // location.  If the user redirects to a different location from the
       // action/loader this will be ignored and the redirect will be a PUSH
-      historyAction = exports.Action.Replace;
+      historyAction = Action.Replace;
     }
     let preventScrollReset = opts && "preventScrollReset" in opts ? opts.preventScrollReset === true : undefined;
     let blockerKey = shouldBlockNavigation({
@@ -2157,7 +2204,7 @@ function createRouter(init) {
       // back to PUSH so that the user can use the back button to get back to
       // the pre-submission form location to try again
       if ((opts && opts.replace) !== true) {
-        pendingAction = exports.Action.Push;
+        pendingAction = Action.Push;
       }
       return {
         // Send back an empty object we can use to clear out any prior actionData
@@ -2648,11 +2695,20 @@ function createRouter(init) {
       _isFetchActionRedirect: true
     } : {}));
     invariant(redirectLocation, "Expected a location on the redirect navigation");
-    // Check if this an absolute external redirect that goes to a new origin
-    if (ABSOLUTE_URL_REGEX.test(redirect.location) && isBrowser) {
-      let url = init.history.createURL(redirect.location);
-      let isDifferentBasename = stripBasename(url.pathname, basename) == null;
-      if (routerWindow.location.origin !== url.origin || isDifferentBasename) {
+    if (isBrowser) {
+      let isDocumentReload = false;
+      if (redirect.reloadDocument) {
+        // Hard reload if the response contained X-Remix-Reload-Document
+        isDocumentReload = true;
+      } else if (ABSOLUTE_URL_REGEX.test(redirect.location)) {
+        const url = init.history.createURL(redirect.location);
+        isDocumentReload =
+        // Hard reload if it's an absolute URL to a new origin
+        url.origin !== routerWindow.location.origin ||
+        // Hard reload if it's an absolute URL that does not match our basename
+        stripBasename(url.pathname, basename) == null;
+      }
+      if (isDocumentReload) {
         if (replace) {
           routerWindow.location.replace(redirect.location);
         } else {
@@ -2665,7 +2721,7 @@ function createRouter(init) {
     // There's no need to abort on redirects, since we don't detect the
     // redirect until the action/loaders have settled
     pendingNavigationController = null;
-    let redirectHistoryAction = replace === true ? exports.Action.Replace : exports.Action.Push;
+    let redirectHistoryAction = replace === true ? Action.Replace : Action.Push;
 
     // Use the incoming submission if provided, fallback on the active one in
     // state.navigation
@@ -3178,7 +3234,7 @@ function createStaticHandler(routes, opts) {
       // it to bail out and then return or throw here based on whether the user
       // returned or threw
       if (isQueryRouteResponse(e)) {
-        if (e.type === ResultType.error && !isRedirectResponse(e.response)) {
+        if (e.type === ResultType.error) {
           throw e.response;
         }
         return e.response;
@@ -3871,7 +3927,8 @@ async function callLoaderOrAction(type, request, match, matches, manifest, mapRo
         type: ResultType.redirect,
         status,
         location,
-        revalidate: result.headers.get("X-Remix-Revalidate") !== null
+        revalidate: result.headers.get("X-Remix-Revalidate") !== null,
+        reloadDocument: result.headers.get("X-Remix-Reload-Document") !== null
       };
     }
 
@@ -3879,11 +3936,11 @@ async function callLoaderOrAction(type, request, match, matches, manifest, mapRo
     // without unwrapping.  We do this with the QueryRouteResponse wrapper
     // interface so we can know whether it was returned or thrown
     if (opts.isRouteRequest) {
-      // eslint-disable-next-line no-throw-literal
-      throw {
-        type: resultType || ResultType.data,
+      let queryRouteResponse = {
+        type: resultType === ResultType.error ? ResultType.error : ResultType.data,
         response: result
       };
+      throw queryRouteResponse;
     }
     let data;
     let contentType = result.headers.get("Content-Type");
@@ -4241,7 +4298,7 @@ function isRedirectResponse(result) {
   return status >= 300 && status <= 399 && location != null;
 }
 function isQueryRouteResponse(obj) {
-  return obj && isResponse(obj.response) && (obj.type === ResultType.data || ResultType.error);
+  return obj && isResponse(obj.response) && (obj.type === ResultType.data || obj.type === ResultType.error);
 }
 function isValidMethod(method) {
   return validRequestMethods.has(method.toLowerCase());
@@ -4474,6 +4531,7 @@ function getDoneFetcher(data) {
 //#endregion
 
 exports.AbortedDeferredError = AbortedDeferredError;
+exports.Action = Action;
 exports.ErrorResponse = ErrorResponse;
 exports.IDLE_BLOCKER = IDLE_BLOCKER;
 exports.IDLE_FETCHER = IDLE_FETCHER;
@@ -4503,6 +4561,7 @@ exports.matchRoutes = matchRoutes;
 exports.normalizePathname = normalizePathname;
 exports.parsePath = parsePath;
 exports.redirect = redirect;
+exports.redirectDocument = redirectDocument;
 exports.resolvePath = resolvePath;
 exports.resolveTo = resolveTo;
 exports.stripBasename = stripBasename;