react-router 0.0.0-experimental-2a6c7bc → 0.0.0-experimental-e89ad3012

package/dist/{development/chunk-M2KD4YIT.mjs → production/chunk-J6PLTU3O.mjs}

@@ -1,5 +1,5 @@
 /**
- * react-router v0.0.0-experimental-2a6c7bc
+ * react-router v0.0.0-experimental-e89ad3012
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -57,7 +57,7 @@ import {
   withComponentProps,
   withErrorBoundaryProps,
   withHydrateFallbackProps
-} from "./chunk-VEWXUMGM.mjs";
+} from "./chunk-QI3NR5VQ.mjs";
 
 // lib/dom/ssr/server.tsx
 import * as React from "react";
@@ -772,42 +772,6 @@ var SERVER_NO_BODY_STATUS_CODES = /* @__PURE__ */ new Set([
 ]);
 async function singleFetchAction(build, serverMode, staticHandler, request, handlerUrl, loadContext, handleError) {
   try {
-    let respond2 = function(context) {
-      let headers = getDocumentHeaders(context, build);
-      if (isRedirectStatusCode(context.statusCode) && headers.has("Location")) {
-        return generateSingleFetchResponse(request, build, serverMode, {
-          result: getSingleFetchRedirect(
-            context.statusCode,
-            headers,
-            build.basename
-          ),
-          headers,
-          status: SINGLE_FETCH_REDIRECT_STATUS
-        });
-      }
-      if (context.errors) {
-        Object.values(context.errors).forEach((err) => {
-          if (!isRouteErrorResponse(err) || err.error) {
-            handleError(err);
-          }
-        });
-        context.errors = sanitizeErrors(context.errors, serverMode);
-      }
-      let singleFetchResult;
-      if (context.errors) {
-        singleFetchResult = { error: Object.values(context.errors)[0] };
-      } else {
-        singleFetchResult = {
-          data: Object.values(context.actionData || {})[0]
-        };
-      }
-      return generateSingleFetchResponse(request, build, serverMode, {
-        result: singleFetchResult,
-        headers,
-        status: context.statusCode
-      });
-    };
-    var respond = respond2;
     let handlerRequest = new Request(handlerUrl, {
       method: request.method,
       body: request.body,
@@ -819,10 +783,22 @@ async function singleFetchAction(build, serverMode, staticHandler, request, hand
       requestContext: loadContext,
       skipLoaderErrorBubbling: true,
       skipRevalidation: true,
-      unstable_respond: respond2
+      unstable_generateMiddlewareResponse: build.future.unstable_middleware ? async (query) => {
+        try {
+          let innerResult = await query(handlerRequest);
+          return handleQueryResult(innerResult);
+        } catch (error) {
+          return handleQueryError(error);
+        }
+      } : void 0
     });
+    return handleQueryResult(result);
+  } catch (error) {
+    return handleQueryError(error);
+  }
+  function handleQueryResult(result) {
     if (!isResponse(result)) {
-      result = respond2(result);
+      result = staticContextToResponse(result);
     }
     if (isRedirectResponse(result)) {
       return generateSingleFetchResponse(request, build, serverMode, {
@@ -836,7 +812,8 @@ async function singleFetchAction(build, serverMode, staticHandler, request, hand
       });
     }
     return result;
-  } catch (error) {
+  }
+  function handleQueryError(error) {
     handleError(error);
     return generateSingleFetchResponse(request, build, serverMode, {
       result: { error },
@@ -844,92 +821,137 @@ async function singleFetchAction(build, serverMode, staticHandler, request, hand
       status: 500
     });
   }
-}
-async function singleFetchLoaders(build, serverMode, staticHandler, request, handlerUrl, loadContext, handleError) {
-  try {
-    let respond2 = function(context) {
-      let headers = getDocumentHeaders(context, build);
-      if (isRedirectStatusCode(context.statusCode) && headers.has("Location")) {
-        return generateSingleFetchResponse(request, build, serverMode, {
-          result: {
-            [SingleFetchRedirectSymbol]: getSingleFetchRedirect(
-              context.statusCode,
-              headers,
-              build.basename
-            )
-          },
-          headers,
-          status: SINGLE_FETCH_REDIRECT_STATUS
-        });
-      }
-      if (context.errors) {
-        Object.values(context.errors).forEach((err) => {
-          if (!isRouteErrorResponse(err) || err.error) {
-            handleError(err);
-          }
-        });
-        context.errors = sanitizeErrors(context.errors, serverMode);
-      }
-      let results = {};
-      let loadedMatches = new Set(
-        context.matches.filter(
-          (m) => loadRouteIds ? loadRouteIds.has(m.route.id) : m.route.loader != null
-        ).map((m) => m.route.id)
-      );
-      if (context.errors) {
-        for (let [id, error] of Object.entries(context.errors)) {
-          results[id] = { error };
-        }
-      }
-      for (let [id, data2] of Object.entries(context.loaderData)) {
-        if (!(id in results) && loadedMatches.has(id)) {
-          results[id] = { data: data2 };
-        }
-      }
+  function staticContextToResponse(context) {
+    let headers = getDocumentHeaders(context, build);
+    if (isRedirectStatusCode(context.statusCode) && headers.has("Location")) {
       return generateSingleFetchResponse(request, build, serverMode, {
-        result: results,
+        result: getSingleFetchRedirect(
+          context.statusCode,
+          headers,
+          build.basename
+        ),
         headers,
-        status: context.statusCode
+        status: SINGLE_FETCH_REDIRECT_STATUS
       });
-    };
-    var respond = respond2;
+    }
+    if (context.errors) {
+      Object.values(context.errors).forEach((err) => {
+        if (!isRouteErrorResponse(err) || err.error) {
+          handleError(err);
+        }
+      });
+      context.errors = sanitizeErrors(context.errors, serverMode);
+    }
+    let singleFetchResult;
+    if (context.errors) {
+      singleFetchResult = { error: Object.values(context.errors)[0] };
+    } else {
+      singleFetchResult = {
+        data: Object.values(context.actionData || {})[0]
+      };
+    }
+    return generateSingleFetchResponse(request, build, serverMode, {
+      result: singleFetchResult,
+      headers,
+      status: context.statusCode
+    });
+  }
+}
+async function singleFetchLoaders(build, serverMode, staticHandler, request, handlerUrl, loadContext, handleError) {
+  let routesParam = new URL(request.url).searchParams.get("_routes");
+  let loadRouteIds = routesParam ? new Set(routesParam.split(",")) : null;
+  try {
     let handlerRequest = new Request(handlerUrl, {
       headers: request.headers,
       signal: request.signal
     });
-    let routesParam = new URL(request.url).searchParams.get("_routes");
-    let loadRouteIds = routesParam ? new Set(routesParam.split(",")) : null;
     let result = await staticHandler.query(handlerRequest, {
       requestContext: loadContext,
       filterMatchesToLoad: (m) => !loadRouteIds || loadRouteIds.has(m.route.id),
       skipLoaderErrorBubbling: true,
-      unstable_respond: respond2
+      unstable_generateMiddlewareResponse: build.future.unstable_middleware ? async (query) => {
+        try {
+          let innerResult = await query(handlerRequest);
+          return handleQueryResult(innerResult);
+        } catch (error) {
+          return handleQueryError(error);
+        }
+      } : void 0
     });
-    if (!isResponse(result)) {
-      result = respond2(result);
-    }
-    if (isRedirectResponse(result)) {
+    return handleQueryResult(result);
+  } catch (error) {
+    return handleQueryError(error);
+  }
+  function handleQueryResult(result) {
+    let response = isResponse(result) ? result : staticContextToResponse(result);
+    if (isRedirectResponse(response)) {
       return generateSingleFetchResponse(request, build, serverMode, {
         result: {
           [SingleFetchRedirectSymbol]: getSingleFetchRedirect(
-            result.status,
-            result.headers,
+            response.status,
+            response.headers,
             build.basename
           )
         },
-        headers: result.headers,
+        headers: response.headers,
         status: SINGLE_FETCH_REDIRECT_STATUS
       });
     }
-    return result;
-  } catch (error) {
+    return response;
+  }
+  function handleQueryError(error) {
     handleError(error);
     return generateSingleFetchResponse(request, build, serverMode, {
-      result: { root: { error } },
+      result: { error },
       headers: new Headers(),
       status: 500
     });
   }
+  function staticContextToResponse(context) {
+    let headers = getDocumentHeaders(context, build);
+    if (isRedirectStatusCode(context.statusCode) && headers.has("Location")) {
+      return generateSingleFetchResponse(request, build, serverMode, {
+        result: {
+          [SingleFetchRedirectSymbol]: getSingleFetchRedirect(
+            context.statusCode,
+            headers,
+            build.basename
+          )
+        },
+        headers,
+        status: SINGLE_FETCH_REDIRECT_STATUS
+      });
+    }
+    if (context.errors) {
+      Object.values(context.errors).forEach((err) => {
+        if (!isRouteErrorResponse(err) || err.error) {
+          handleError(err);
+        }
+      });
+      context.errors = sanitizeErrors(context.errors, serverMode);
+    }
+    let results = {};
+    let loadedMatches = new Set(
+      context.matches.filter(
+        (m) => loadRouteIds ? loadRouteIds.has(m.route.id) : m.route.loader != null
+      ).map((m) => m.route.id)
+    );
+    if (context.errors) {
+      for (let [id, error] of Object.entries(context.errors)) {
+        results[id] = { error };
+      }
+    }
+    for (let [id, data2] of Object.entries(context.loaderData)) {
+      if (!(id in results) && loadedMatches.has(id)) {
+        results[id] = { data: data2 };
+      }
+    }
+    return generateSingleFetchResponse(request, build, serverMode, {
+      result: results,
+      headers,
+      status: context.statusCode
+    });
+  }
 }
 function generateSingleFetchResponse(request, build, serverMode, {
   result,
@@ -1295,19 +1317,30 @@ async function handleSingleFetchRequest(serverMode, build, staticHandler, reques
 }
 async function handleDocumentRequest(serverMode, build, staticHandler, request, loadContext, handleError, isSpaMode, criticalCss) {
   try {
-    let response = await staticHandler.query(request, {
+    let result = await staticHandler.query(request, {
       requestContext: loadContext,
-      unstable_respond: build.future.unstable_middleware ? (ctx) => renderHtml(ctx, isSpaMode) : void 0
+      unstable_generateMiddlewareResponse: build.future.unstable_middleware ? async (query) => {
+        try {
+          let innerResult = await query(request);
+          if (!isResponse(innerResult)) {
+            innerResult = await renderHtml(innerResult, isSpaMode);
+          }
+          return innerResult;
+        } catch (error) {
+          handleError(error);
+          return new Response(null, { status: 500 });
+        }
+      } : void 0
     });
-    return isResponse(response) ? response : renderHtml(response, isSpaMode);
+    if (!isResponse(result)) {
+      result = await renderHtml(result, isSpaMode);
+    }
+    return result;
   } catch (error) {
     handleError(error);
     return new Response(null, { status: 500 });
   }
   async function renderHtml(context, isSpaMode2) {
-    if (isResponse(context)) {
-      return context;
-    }
     let headers = getDocumentHeaders(context, build);
     if (SERVER_NO_BODY_STATUS_CODES.has(context.statusCode)) {
       return new Response(null, { status: context.statusCode, headers });
@@ -1419,55 +1452,38 @@ async function handleDocumentRequest(serverMode, build, staticHandler, request,
 }
 async function handleResourceRequest(serverMode, build, staticHandler, routeId, request, loadContext, handleError) {
   try {
-    let response = await staticHandler.queryRoute(request, {
+    let result = await staticHandler.queryRoute(request, {
       routeId,
       requestContext: loadContext,
-      unstable_stream: build.future.unstable_middleware ? async (_, queryRoute) => {
+      unstable_generateMiddlewareResponse: build.future.unstable_middleware ? async (queryRoute) => {
         try {
-          let result = await queryRoute(request);
-          if (isResponse(result)) {
-            return result;
-          }
-          if (typeof result === "string") {
-            return new Response(result);
-          }
-          return Response.json(result);
+          let innerResult = await queryRoute(request);
+          return handleQueryRouteResult(innerResult);
         } catch (error) {
-          if (isResponse(error)) {
-            return error;
-          }
-          if (isRouteErrorResponse(error)) {
-            handleError(error);
-            return errorResponseToJson(error, serverMode);
-          }
-          if (error instanceof Error && error.message === "Expected a response from queryRoute") {
-            let newError = new Error(
-              "Expected a Response to be returned from resource route handler"
-            );
-            handleError(newError);
-            return returnLastResortErrorResponse(newError, serverMode);
-          }
-          handleError(error);
-          return returnLastResortErrorResponse(error, serverMode);
+          return handleQueryRouteError(error);
         }
       } : void 0
     });
-    if (isResponse(response)) {
-      return response;
+    return handleQueryRouteResult(result);
+  } catch (error) {
+    return handleQueryRouteError(error);
+  }
+  function handleQueryRouteResult(result) {
+    if (isResponse(result)) {
+      return result;
     }
-    if (typeof response === "string") {
-      return new Response(response);
+    if (typeof result === "string") {
+      return new Response(result);
     }
-    return Response.json(response);
-  } catch (error) {
+    return Response.json(result);
+  }
+  function handleQueryRouteError(error) {
     if (isResponse(error)) {
       error.headers.set("X-Remix-Catch", "yes");
       return error;
     }
     if (isRouteErrorResponse(error)) {
-      if (error) {
-        handleError(error);
-      }
+      handleError(error);
       return errorResponseToJson(error, serverMode);
     }
     if (error instanceof Error && error.message === "Expected a response from queryRoute") {