@remix-run/router 1.18.0 → 1.19.0-pre.0

package/dist/router.umd.js

@@ -1,5 +1,5 @@
 /**
- * @remix-run/router v1.18.0
+ * @remix-run/router v1.19.0-pre.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -1329,6 +1329,23 @@
       headers
     }));
   };
+  class DataWithResponseInit {
+    constructor(data, init) {
+      this.type = "DataWithResponseInit";
+      this.data = data;
+      this.init = init || null;
+    }
+  }
+
+  /**
+   * Create "responses" that contain `status`/`headers` without forcing
+   * serialization into an actual `Response` - used by Remix single fetch
+   */
+  function data(data, init) {
+    return new DataWithResponseInit(data, typeof init === "number" ? {
+      status: init
+    } : init);
+  }
   class AbortedDeferredError extends Error {}
   class DeferredData {
     constructor(data, responseInit) {
@@ -1511,6 +1528,18 @@
     response.headers.set("X-Remix-Reload-Document", "true");
     return response;
   };
+
+  /**
+   * A redirect response that will perform a `history.replaceState` instead of a
+   * `history.pushState` for client-side navigation redirects.
+   * Sets the status code and the `Location` header.
+   * Defaults to "302 Found".
+   */
+  const replace = (url, init) => {
+    let response = redirect(url, init);
+    response.headers.set("X-Remix-Replace", "true");
+    return response;
+  };
   /**
    * @private
    * Utility class we use to hold auto-unwrapped 4xx/5xx Response bodies
@@ -1738,7 +1767,7 @@
     // In SSR apps (with `hydrationData`), we expect that the server will send
     // up the proper matched routes so we don't want to run lazy discovery on
     // initial hydration and want to hydrate into the splat route.
-    if (initialMatches && patchRoutesOnMissImpl && !init.hydrationData) {
+    if (initialMatches && !init.hydrationData) {
       let fogOfWar = checkFogOfWar(initialMatches, dataRoutes, init.history.location.pathname);
       if (fogOfWar.active) {
         initialMatches = null;
@@ -1746,9 +1775,18 @@
     }
     let initialized;
     if (!initialMatches) {
-      // We need to run patchRoutesOnMiss in initialize()
       initialized = false;
       initialMatches = [];
+
+      // If partial hydration and fog of war is enabled, we will be running
+      // `patchRoutesOnMiss` during hydration so include any partial matches as
+      // the initial matches so we can properly render `HydrateFallback`'s
+      if (future.v7_partialHydration) {
+        let fogOfWar = checkFogOfWar(null, dataRoutes, init.history.location.pathname);
+        if (fogOfWar.active && fogOfWar.matches) {
+          initialMatches = fogOfWar.matches;
+        }
+      }
     } else if (initialMatches.some(m => m.route.lazy)) {
       // All initialMatches need to be loaded before we're ready.  If we have lazy
       // functions around still then we'll need to run them in initialize()
@@ -1841,7 +1879,7 @@
 
     // Use this internal array to capture fetcher loads that were cancelled by an
     // action navigation and require revalidation
-    let cancelledFetcherLoads = [];
+    let cancelledFetcherLoads = new Set();
 
     // AbortControllers for any in-flight fetchers
     let fetchControllers = new Map();
@@ -2141,7 +2179,6 @@
       isUninterruptedRevalidation = false;
       isRevalidationRequired = false;
       cancelledDeferredRoutes = [];
-      cancelledFetcherLoads = [];
     }
 
     // Trigger a navigation event, which can either be a numerical POP or a PUSH
@@ -3143,7 +3180,7 @@
       // 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 ? Action.Replace : Action.Push;
+      let redirectHistoryAction = replace === true || redirect.response.headers.has("X-Remix-Replace") ? Action.Replace : Action.Push;
 
       // Use the incoming submission if provided, fallback on the active one in
       // state.navigation
@@ -3237,7 +3274,7 @@
       // Abort in-flight fetcher loads
       fetchLoadMatches.forEach((_, key) => {
         if (fetchControllers.has(key)) {
-          cancelledFetcherLoads.push(key);
+          cancelledFetcherLoads.add(key);
           abortFetcher(key);
         }
       });
@@ -3291,6 +3328,7 @@
       fetchReloadIds.delete(key);
       fetchRedirectIds.delete(key);
       deletedFetchers.delete(key);
+      cancelledFetcherLoads.delete(key);
       state.fetchers.delete(key);
     }
     function deleteFetcherAndUpdateState(key) {
@@ -4406,8 +4444,9 @@
       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
+      } else if (cancelledFetcherLoads.has(key)) {
+        // Always mark for revalidation if the fetcher was cancelled
+        cancelledFetcherLoads.delete(key);
         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
@@ -4729,8 +4768,7 @@
   async function convertHandlerResultToDataResult(handlerResult) {
     let {
       result,
-      type,
-      status
+      type
     } = handlerResult;
     if (isResponse(result)) {
       let data;
@@ -4769,25 +4807,47 @@
       };
     }
     if (type === ResultType.error) {
+      if (isDataWithResponseInit(result)) {
+        var _result$init2;
+        if (result.data instanceof Error) {
+          var _result$init;
+          return {
+            type: ResultType.error,
+            error: result.data,
+            statusCode: (_result$init = result.init) == null ? void 0 : _result$init.status
+          };
+        }
+
+        // Convert thrown unstable_data() to ErrorResponse instances
+        result = new ErrorResponseImpl(((_result$init2 = result.init) == null ? void 0 : _result$init2.status) || 500, undefined, result.data);
+      }
       return {
         type: ResultType.error,
         error: result,
-        statusCode: isRouteErrorResponse(result) ? result.status : status
+        statusCode: isRouteErrorResponse(result) ? result.status : undefined
       };
     }
     if (isDeferredData(result)) {
-      var _result$init, _result$init2;
+      var _result$init3, _result$init4;
       return {
         type: ResultType.deferred,
         deferredData: result,
-        statusCode: (_result$init = result.init) == null ? void 0 : _result$init.status,
-        headers: ((_result$init2 = result.init) == null ? void 0 : _result$init2.headers) && new Headers(result.init.headers)
+        statusCode: (_result$init3 = result.init) == null ? void 0 : _result$init3.status,
+        headers: ((_result$init4 = result.init) == null ? void 0 : _result$init4.headers) && new Headers(result.init.headers)
+      };
+    }
+    if (isDataWithResponseInit(result)) {
+      var _result$init5, _result$init6;
+      return {
+        type: ResultType.data,
+        data: result.data,
+        statusCode: (_result$init5 = result.init) == null ? void 0 : _result$init5.status,
+        headers: (_result$init6 = result.init) != null && _result$init6.headers ? new Headers(result.init.headers) : undefined
       };
     }
     return {
       type: ResultType.data,
-      data: result,
-      statusCode: status
+      data: result
     };
   }
 
@@ -5150,6 +5210,9 @@
   function isRedirectResult(result) {
     return (result && result.type) === ResultType.redirect;
   }
+  function isDataWithResponseInit(value) {
+    return typeof value === "object" && value != null && "type" in value && "data" in value && "init" in value && value.type === "DataWithResponseInit";
+  }
   function isDeferredData(value) {
     let deferred = value;
     return deferred && typeof deferred === "object" && typeof deferred.data === "object" && typeof deferred.subscribe === "function" && typeof deferred.cancel === "function" && typeof deferred.resolveData === "function";
@@ -5426,6 +5489,7 @@
   exports.generatePath = generatePath;
   exports.getStaticContextFromError = getStaticContextFromError;
   exports.getToPathname = getToPathname;
+  exports.isDataWithResponseInit = isDataWithResponseInit;
   exports.isDeferredData = isDeferredData;
   exports.isRouteErrorResponse = isRouteErrorResponse;
   exports.joinPaths = joinPaths;
@@ -5436,9 +5500,11 @@
   exports.parsePath = parsePath;
   exports.redirect = redirect;
   exports.redirectDocument = redirectDocument;
+  exports.replace = replace;
   exports.resolvePath = resolvePath;
   exports.resolveTo = resolveTo;
   exports.stripBasename = stripBasename;
+  exports.unstable_data = data;
 
   Object.defineProperty(exports, '__esModule', { value: true });