@remix-run/router 0.0.0-experimental-0141b5ec → 0.0.0-experimental-71108452

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 as unstable_DecodedResponse, defer, generatePath, getToPathname, isDecodedResponse as unstable_isDecodedResponse, 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-0141b5ec
+ * @remix-run/router v0.0.0-experimental-71108452
  *
  * 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
 ////////////////////////////////////////////////////////////////////////////////
@@ -1751,7 +1728,26 @@ function createRouter(init) {
     // were marked for explicit hydration
     let loaderData = init.hydrationData ? init.hydrationData.loaderData : null;
     let errors = init.hydrationData ? init.hydrationData.errors : null;
-    initialized = initialMatches.every(m => m.route.loader && (typeof m.route.loader !== "function" || m.route.loader.hydrate !== true) && (loaderData && loaderData[m.route.id] !== undefined || errors && errors[m.route.id] !== undefined));
+    let isRouteInitialized = m => {
+      // No loader, nothing to initialize
+      if (!m.route.loader) {
+        return true;
+      }
+      // Explicitly opting-in to running on hydration
+      if (typeof m.route.loader === "function" && m.route.loader.hydrate === true) {
+        return false;
+      }
+      // Otherwise, initialized if hydrated with data or an error
+      return loaderData && loaderData[m.route.id] !== undefined || errors && errors[m.route.id] !== undefined;
+    };
+
+    // If errors exist, don't consider routes below the boundary
+    if (errors) {
+      let idx = initialMatches.findIndex(m => errors[m.route.id] !== undefined);
+      initialized = initialMatches.slice(0, idx + 1).every(isRouteInitialized);
+    } else {
+      initialized = initialMatches.every(isRouteInitialized);
+    }
   } else {
     // Without partial hydration - we're initialized if we were provided any
     // hydrationData - which is expected to be complete
@@ -4223,10 +4219,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 + "]")));
       }
@@ -4236,7 +4234,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 {
@@ -4291,8 +4307,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
@@ -4302,15 +4321,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;
@@ -4335,7 +4352,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
@@ -4348,27 +4365,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)) {
@@ -4382,7 +4383,8 @@ async function convertHandlerResultToDataResult(handlerResult) {
   }
   return {
     type: ResultType.data,
-    data: result
+    data: result,
+    statusCode: status
   };
 }
 
@@ -5012,6 +5014,4 @@ exports.redirectDocument = redirectDocument;
 exports.resolvePath = resolvePath;
 exports.resolveTo = resolveTo;
 exports.stripBasename = stripBasename;
-exports.unstable_DecodedResponse = DecodedResponse;
-exports.unstable_isDecodedResponse = isDecodedResponse;
 //# sourceMappingURL=router.cjs.js.map