@remix-run/router 0.0.0-experimental-de419c3d → 0.0.0-experimental-432fcb2e

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # `@remix-run/router`
 
+## 1.15.2
+
+### Patch Changes
+
+- Preserve hydrated errors during partial hydration runs ([#11305](https://github.com/remix-run/react-router/pull/11305))
+
+## 1.15.1
+
+### Patch Changes
+
+- Fix encoding/decoding issues with pre-encoded dynamic parameter values ([#11199](https://github.com/remix-run/react-router/pull/11199))
+
 ## 1.15.0
 
 ### Minor Changes

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-export type { ActionFunction, ActionFunctionArgs, AgnosticDataIndexRouteObject, AgnosticDataNonIndexRouteObject, AgnosticDataRouteMatch, AgnosticDataRouteObject, AgnosticIndexRouteObject, AgnosticNonIndexRouteObject, AgnosticRouteMatch, AgnosticRouteObject, DataStrategyFunction, DataStrategyFunctionArgs, DataStrategyMatch, ErrorResponse, FormEncType, FormMethod, HTMLFormMethod, JsonFunction, LazyRouteFunction, LoaderFunction, LoaderFunctionArgs, ParamParseKey, Params, PathMatch, PathParam, PathPattern, RedirectFunction, ShouldRevalidateFunction, ShouldRevalidateFunctionArgs, TrackedPromise, UIMatch, V7_FormMethod, } from "./utils";
-export { AbortedDeferredError, DecodedResponse, defer, generatePath, getToPathname, isRouteErrorResponse, joinPaths, json, matchPath, matchRoutes, normalizePathname, redirect, redirectDocument, resolvePath, resolveTo, stripBasename, } from "./utils";
+export type { ActionFunction, ActionFunctionArgs, AgnosticDataIndexRouteObject, AgnosticDataNonIndexRouteObject, AgnosticDataRouteMatch, AgnosticDataRouteObject, AgnosticIndexRouteObject, AgnosticNonIndexRouteObject, AgnosticRouteMatch, AgnosticRouteObject, DataStrategyFunction, DataStrategyFunctionArgs, DataStrategyMatch, ErrorResponse, FormEncType, FormMethod, HandlerResult as unstable_HandlerResult, HTMLFormMethod, JsonFunction, LazyRouteFunction, LoaderFunction, LoaderFunctionArgs, ParamParseKey, Params, PathMatch, PathParam, PathPattern, RedirectFunction, ShouldRevalidateFunction, ShouldRevalidateFunctionArgs, TrackedPromise, UIMatch, V7_FormMethod, } from "./utils";
+export { AbortedDeferredError, 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, createHashHistory, createMemoryHistory, createPath, parsePath, } from "./history";
 export * from "./router";

package/dist/router.cjs.js

@@ -1,5 +1,5 @@
 /**
- * @remix-run/router v0.0.0-experimental-de419c3d
+ * @remix-run/router v0.0.0-experimental-432fcb2e
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -1519,22 +1519,6 @@ class ErrorResponseImpl {
   }
 }
 
-/**
- * Utility class we use to hold unwrapped Responses while preserving status
- * codes and headers.  This is most useful for dataStrategy implementations
- * where implementors want to use a custom decoding mechanism and return
- * pre-decoded data while also preserving response meta information
- */
-class DecodedResponse {
-  constructor(status, statusText, headers, data) {
-    this._isDecodedResponse = true;
-    this.status = status;
-    this.statusText = statusText;
-    this.headers = headers;
-    this.data = data;
-  }
-}
-
 /**
  * Check if the given error is an ErrorResponse generated from a 4xx/5xx
  * Response thrown from an action/loader
@@ -1543,13 +1527,6 @@ function isRouteErrorResponse(error) {
   return error != null && typeof error.status === "number" && typeof error.statusText === "string" && typeof error.internal === "boolean" && "data" in error;
 }
 
-/**
- * Check if the given error is an DecodedResponse
- */
-function isDecodedResponse(value) {
-  return value != null && value._isDecodedResponse === true && typeof value.status === "number" && typeof value.statusText === "string" && value.headers != null && "data" in value;
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 //#region Types and Constants
 ////////////////////////////////////////////////////////////////////////////////
@@ -2454,7 +2431,7 @@ function createRouter(init) {
     // preserving any new action data or existing action data (in the case of
     // a revalidation interrupting an actionReload)
     // If we have partialHydration enabled, then don't update the state for the
-    // initial data load since iot's not a "navigation"
+    // initial data load since it's not a "navigation"
     if (!isUninterruptedRevalidation && (!future.v7_partialHydration || !initialHydration)) {
       revalidatingFetchers.forEach(rf => {
         let fetcher = state.fetchers.get(rf.key);
@@ -2556,6 +2533,19 @@ function createRouter(init) {
         }
       });
     });
+
+    // During partial hydration, preserve SSR errors for routes that don't re-run
+    if (future.v7_partialHydration && initialHydration && state.errors) {
+      Object.entries(state.errors).filter(_ref2 => {
+        let [id] = _ref2;
+        return !matchesToLoad.some(m => m.route.id === id);
+      }).forEach(_ref3 => {
+        let [routeId, error] = _ref3;
+        errors = Object.assign(errors || {}, {
+          [routeId]: error
+        });
+      });
+    }
     let updatedFetchers = markFetchRedirectsDone();
     let didAbortFetchLoads = abortStaleFetchLoads(pendingNavigationLoadId);
     let shouldUpdateFetchers = updatedFetchers || didAbortFetchLoads || revalidatingFetchers.length > 0;
@@ -3156,12 +3146,12 @@ function createRouter(init) {
       blockers
     });
   }
-  function shouldBlockNavigation(_ref2) {
+  function shouldBlockNavigation(_ref4) {
     let {
       currentLocation,
       nextLocation,
       historyAction
-    } = _ref2;
+    } = _ref4;
     if (blockerFunctions.size === 0) {
       return;
     }
@@ -3832,8 +3822,8 @@ function normalizeNavigateOptions(normalizeFormMethod, isFetcher, path, opts) {
       }
       let text = typeof opts.body === "string" ? opts.body : opts.body instanceof FormData || opts.body instanceof URLSearchParams ?
       // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#plain-text-form-data
-      Array.from(opts.body.entries()).reduce((acc, _ref3) => {
-        let [name, value] = _ref3;
+      Array.from(opts.body.entries()).reduce((acc, _ref5) => {
+        let [name, value] = _ref5;
         return "" + acc + name + "=" + value + "\n";
       }, "") : String(opts.body);
       return {
@@ -4210,10 +4200,12 @@ async function callLoaderOrAction(type, request, match, manifest, mapRouteProper
   let runHandler = handler => {
     // Setup a promise we can race against so that abort signals short circuit
     let reject;
+    // This will never resolve so safe to type it as Promise<HandlerResult> to
+    // satisfy the function return value
     let abortPromise = new Promise((_, r) => reject = r);
     onReject = () => reject();
     request.signal.addEventListener("abort", onReject);
-    let runHandlerForReal = ctx => {
+    let actualHandler = ctx => {
       if (typeof handler !== "function") {
         return Promise.reject(new Error("You cannot call the handler for a route which defines a boolean " + ("\"" + type + "\" [routeId: " + match.route.id + "]")));
       }
@@ -4223,7 +4215,25 @@ async function callLoaderOrAction(type, request, match, manifest, mapRouteProper
         context: staticContext
       }, ...(ctx !== undefined ? [ctx] : []));
     };
-    let handlerPromise = handlerOverride ? handlerOverride(async ctx => runHandlerForReal(ctx)) : runHandlerForReal();
+    let handlerPromise;
+    if (handlerOverride) {
+      handlerPromise = handlerOverride(ctx => actualHandler(ctx));
+    } else {
+      handlerPromise = (async () => {
+        try {
+          let val = await actualHandler();
+          return {
+            type: "data",
+            result: val
+          };
+        } catch (e) {
+          return {
+            type: "error",
+            result: e
+          };
+        }
+      })();
+    }
     return Promise.race([handlerPromise, abortPromise]);
   };
   try {
@@ -4278,8 +4288,11 @@ async function callLoaderOrAction(type, request, match, manifest, mapRouteProper
     } else {
       result = await runHandler(handler);
     }
-    invariant(result !== undefined, "You defined " + (type === "action" ? "an action" : "a loader") + " for route " + ("\"" + match.route.id + "\" but didn't return anything from your `" + type + "` ") + "function. Please return a value or `null`.");
+    invariant(result.result !== undefined, "You defined " + (type === "action" ? "an action" : "a loader") + " for route " + ("\"" + match.route.id + "\" but didn't return anything from your `" + type + "` ") + "function. Please return a value or `null`.");
   } catch (e) {
+    // We should already be catching and converting normal handler executions to
+    // HandlerResults and returning them, so anything that throws here is an
+    // unexpected error we still need to wrap
     return {
       type: ResultType.error,
       result: e
@@ -4289,15 +4302,13 @@ async function callLoaderOrAction(type, request, match, manifest, mapRouteProper
       request.signal.removeEventListener("abort", onReject);
     }
   }
-  return {
-    type: ResultType.data,
-    result
-  };
+  return result;
 }
 async function convertHandlerResultToDataResult(handlerResult) {
   let {
     result,
-    type
+    type,
+    status
   } = handlerResult;
   if (isResponse(result)) {
     let data;
@@ -4322,7 +4333,7 @@ async function convertHandlerResultToDataResult(handlerResult) {
     }
     if (type === ResultType.error) {
       return {
-        type,
+        type: ResultType.error,
         error: new ErrorResponseImpl(result.status, result.statusText, data),
         statusCode: result.status,
         headers: result.headers
@@ -4335,27 +4346,11 @@ async function convertHandlerResultToDataResult(handlerResult) {
       headers: result.headers
     };
   }
-  if (isDecodedResponse(result)) {
-    if (type === ResultType.error) {
-      return {
-        type,
-        error: new ErrorResponseImpl(result.status, result.statusText, result.data),
-        statusCode: result.status,
-        headers: result.headers
-      };
-    }
-    return {
-      type: ResultType.data,
-      data: result.data,
-      statusCode: result.status,
-      headers: result.headers
-    };
-  }
   if (type === ResultType.error) {
     return {
-      type,
+      type: ResultType.error,
       error: result,
-      statusCode: isRouteErrorResponse(result) ? result.status : undefined
+      statusCode: isRouteErrorResponse(result) ? result.status : status
     };
   }
   if (isDeferredData(result)) {
@@ -4369,7 +4364,8 @@ async function convertHandlerResultToDataResult(handlerResult) {
   }
   return {
     type: ResultType.data,
-    data: result
+    data: result,
+    statusCode: status
   };
 }
 
@@ -4965,7 +4961,6 @@ function persistAppliedTransitions(_window, transitions) {
 
 exports.AbortedDeferredError = AbortedDeferredError;
 exports.Action = Action;
-exports.DecodedResponse = DecodedResponse;
 exports.IDLE_BLOCKER = IDLE_BLOCKER;
 exports.IDLE_FETCHER = IDLE_FETCHER;
 exports.IDLE_NAVIGATION = IDLE_NAVIGATION;