react-router 7.7.1 → 7.8.0-pre.0

package/dist/development/index-react-server.mjs

@@ -6,7 +6,7 @@ export { Await, BrowserRouter, Form, HashRouter, Link, Links, MemoryRouter, Meta
 import { serialize, parse } from 'cookie';
 
 /**
- * react-router v7.7.1
+ * react-router v7.8.0-pre.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -92,6 +92,10 @@ function unstable_createContext(defaultValue) {
 }
 var _map;
 var unstable_RouterContextProvider = class {
+  /**
+   * Create a new `unstable_RouterContextProvider` instance
+   * @param init An optional initial context map to populate the provider with
+   */
   constructor(init) {
     __privateAdd(this, _map, /* @__PURE__ */ new Map());
     if (init) {
@@ -100,6 +104,14 @@ var unstable_RouterContextProvider = class {
       }
     }
   }
+  /**
+   * Access a value from the context. If no value has been set for the context,
+   * it will return the context's `defaultValue` if provided, or throw an error
+   * if no `defaultValue` was set.
+   * @param context The context to get the value for
+   * @returns The value for the context, or the context's `defaultValue` if no
+   * value was set
+   */
   get(context) {
     if (__privateGet(this, _map).has(context)) {
       return __privateGet(this, _map).get(context);
@@ -109,6 +121,14 @@ var unstable_RouterContextProvider = class {
     }
     throw new Error("No value found for context");
   }
+  /**
+   * Set a value for the context. If the context already has a value set, this
+   * will overwrite it.
+   *
+   * @param context The context to set the value for
+   * @param value The value to set for the context
+   * @returns {void}
+   */
   set(context, value) {
     __privateGet(this, _map).set(context, value);
   }
@@ -214,6 +234,7 @@ function convertRouteMatchToUiMatch(match, loaderData) {
     pathname,
     params,
     data: loaderData[route.id],
+    loaderData: loaderData[route.id],
     handle: route.handle
   };
 }
@@ -644,20 +665,13 @@ function createStaticHandler(routes, opts) {
     skipLoaderErrorBubbling,
     skipRevalidation,
     dataStrategy,
-    unstable_stream: stream,
-    unstable_respond: respond
+    unstable_generateMiddlewareResponse: generateMiddlewareResponse
   } = {}) {
     let url = new URL(request.url);
     let method = request.method;
     let location = createLocation("", createPath(url), null, "default");
     let matches = matchRoutes(dataRoutes, location, basename);
     requestContext = requestContext != null ? requestContext : new unstable_RouterContextProvider();
-    let respondOrStreamStaticContext = (ctx) => {
-      return stream ? stream(
-        requestContext,
-        () => Promise.resolve(ctx)
-      ) : respond ? respond(ctx) : ctx;
-    };
     if (!isValidMethod(method) && method !== "HEAD") {
       let error = getInternalRouterError(405, { method });
       let { matches: methodNotAllowedMatches, route } = getShortCircuitMatches(dataRoutes);
@@ -674,7 +688,7 @@ function createStaticHandler(routes, opts) {
         loaderHeaders: {},
         actionHeaders: {}
       };
-      return respondOrStreamStaticContext(staticContext);
+      return generateMiddlewareResponse ? generateMiddlewareResponse(() => Promise.resolve(staticContext)) : staticContext;
     } else if (!matches) {
       let error = getInternalRouterError(404, { pathname: location.pathname });
       let { matches: notFoundMatches, route } = getShortCircuitMatches(dataRoutes);
@@ -691,11 +705,9 @@ function createStaticHandler(routes, opts) {
         loaderHeaders: {},
         actionHeaders: {}
       };
-      return respondOrStreamStaticContext(staticContext);
+      return generateMiddlewareResponse ? generateMiddlewareResponse(() => Promise.resolve(staticContext)) : staticContext;
     }
-    if (stream || respond && matches.some(
-      (m) => m.route.unstable_middleware || typeof m.route.lazy === "object" && m.route.lazy.unstable_middleware
-    )) {
+    if (generateMiddlewareResponse) {
       invariant(
         requestContext instanceof unstable_RouterContextProvider,
         "When using middleware in `staticHandler.query()`, any provided `requestContext` must be an instance of `unstable_RouterContextProvider`"
@@ -707,7 +719,7 @@ function createStaticHandler(routes, opts) {
           mapRouteProperties
         );
         let renderedStaticContext;
-        let response = await runMiddlewarePipeline(
+        let response = await runServerMiddlewarePipeline(
           {
             request,
             matches,
@@ -716,45 +728,27 @@ function createStaticHandler(routes, opts) {
             // this to the proper type knowing it's not an `AppLoadContext`
             context: requestContext
           },
-          true,
           async () => {
-            if (stream) {
-              let res2 = await stream(
-                requestContext,
-                async (revalidationRequest) => {
-                  let result3 = await queryImpl(
-                    revalidationRequest,
-                    location,
-                    matches,
-                    requestContext,
-                    dataStrategy || null,
-                    skipLoaderErrorBubbling === true,
-                    null,
-                    filterMatchesToLoad || null,
-                    skipRevalidation === true
-                  );
-                  return isResponse(result3) ? result3 : { location, basename, ...result3 };
+            let res = await generateMiddlewareResponse(
+              async (revalidationRequest) => {
+                let result2 = await queryImpl(
+                  revalidationRequest,
+                  location,
+                  matches,
+                  requestContext,
+                  dataStrategy || null,
+                  skipLoaderErrorBubbling === true,
+                  null,
+                  filterMatchesToLoad || null,
+                  skipRevalidation === true
+                );
+                if (isResponse(result2)) {
+                  return result2;
                 }
-              );
-              return res2;
-            }
-            invariant(respond, "Expected respond to be defined");
-            let result2 = await queryImpl(
-              request,
-              location,
-              matches,
-              requestContext,
-              dataStrategy || null,
-              skipLoaderErrorBubbling === true,
-              null,
-              filterMatchesToLoad || null,
-              skipRevalidation === true
+                renderedStaticContext = { location, basename, ...result2 };
+                return renderedStaticContext;
+              }
             );
-            if (isResponse(result2)) {
-              return result2;
-            }
-            renderedStaticContext = { location, basename, ...result2 };
-            let res = await respond(renderedStaticContext);
             return res;
           },
           async (error, routeId) => {
@@ -771,7 +765,9 @@ function createStaticHandler(routes, opts) {
                 error,
                 skipLoaderErrorBubbling ? routeId : findNearestBoundary(matches, routeId).route.id
               );
-              return respondOrStreamStaticContext(staticContext);
+              return generateMiddlewareResponse(
+                () => Promise.resolve(staticContext)
+              );
             } else {
               let boundaryRouteId = skipLoaderErrorBubbling ? routeId : findNearestBoundary(
                 matches,
@@ -792,7 +788,9 @@ function createStaticHandler(routes, opts) {
                 actionHeaders: {},
                 loaderHeaders: {}
               };
-              return respondOrStreamStaticContext(staticContext);
+              return generateMiddlewareResponse(
+                () => Promise.resolve(staticContext)
+              );
             }
           }
         );
@@ -825,7 +823,7 @@ function createStaticHandler(routes, opts) {
     routeId,
     requestContext,
     dataStrategy,
-    unstable_respond: respond
+    unstable_generateMiddlewareResponse: generateMiddlewareResponse
   } = {}) {
     let url = new URL(request.url);
     let method = request.method;
@@ -846,15 +844,13 @@ function createStaticHandler(routes, opts) {
     } else if (!match) {
       throw getInternalRouterError(404, { pathname: location.pathname });
     }
-    if (respond && matches.some(
-      (m) => m.route.unstable_middleware || typeof m.route.lazy === "object" && m.route.lazy.unstable_middleware
-    )) {
+    if (generateMiddlewareResponse) {
       invariant(
         requestContext instanceof unstable_RouterContextProvider,
         "When using middleware in `staticHandler.queryRoute()`, any provided `requestContext` must be an instance of `unstable_RouterContextProvider`"
       );
       await loadLazyMiddlewareForMatches(matches, manifest, mapRouteProperties);
-      let response = await runMiddlewarePipeline(
+      let response = await runServerMiddlewarePipeline(
         {
           request,
           matches,
@@ -863,37 +859,31 @@ function createStaticHandler(routes, opts) {
           // this to the proper type knowing it's not an `AppLoadContext`
           context: requestContext
         },
-        true,
         async () => {
-          let result2 = await queryImpl(
-            request,
-            location,
-            matches,
-            requestContext,
-            dataStrategy || null,
-            false,
-            match,
-            null,
-            false
+          let res = await generateMiddlewareResponse(
+            async (innerRequest) => {
+              let result2 = await queryImpl(
+                innerRequest,
+                location,
+                matches,
+                requestContext,
+                dataStrategy || null,
+                false,
+                match,
+                null,
+                false
+              );
+              let processed = handleQueryResult(result2);
+              return isResponse(processed) ? processed : typeof processed === "string" ? new Response(processed) : Response.json(processed);
+            }
           );
-          if (isResponse(result2)) {
-            return respond(result2);
-          }
-          let error2 = result2.errors ? Object.values(result2.errors)[0] : void 0;
-          if (error2 !== void 0) {
-            throw error2;
-          }
-          let value = result2.actionData ? Object.values(result2.actionData)[0] : Object.values(result2.loaderData)[0];
-          return typeof value === "string" ? new Response(value) : Response.json(value);
+          return res;
         },
-        (error2) => {
-          if (isResponse(error2)) {
-            return respond(error2);
+        (error) => {
+          if (isResponse(error)) {
+            return Promise.resolve(error);
           }
-          return new Response(String(error2), {
-            status: 500,
-            statusText: "Unexpected Server Error"
-          });
+          throw error;
         }
       );
       return response;
@@ -909,20 +899,23 @@ function createStaticHandler(routes, opts) {
       null,
       false
     );
-    if (isResponse(result)) {
-      return result;
-    }
-    let error = result.errors ? Object.values(result.errors)[0] : void 0;
-    if (error !== void 0) {
-      throw error;
-    }
-    if (result.actionData) {
-      return Object.values(result.actionData)[0];
-    }
-    if (result.loaderData) {
-      return Object.values(result.loaderData)[0];
+    return handleQueryResult(result);
+    function handleQueryResult(result2) {
+      if (isResponse(result2)) {
+        return result2;
+      }
+      let error = result2.errors ? Object.values(result2.errors)[0] : void 0;
+      if (error !== void 0) {
+        throw error;
+      }
+      if (result2.actionData) {
+        return Object.values(result2.actionData)[0];
+      }
+      if (result2.loaderData) {
+        return Object.values(result2.loaderData)[0];
+      }
+      return void 0;
     }
-    return void 0;
   }
   async function queryImpl(request, location, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch, filterMatchesToLoad, skipRevalidation) {
     invariant(
@@ -1469,37 +1462,29 @@ async function defaultDataStrategy(args) {
   });
   return keyedResults;
 }
-async function runMiddlewarePipeline(args, propagateResult, handler, errorHandler) {
+async function runServerMiddlewarePipeline(args, handler, errorHandler) {
   let { matches, request, params, context } = args;
-  let middlewareState = {
-    handlerResult: void 0
-  };
-  try {
-    let tuples = matches.flatMap(
-      (m) => m.route.unstable_middleware ? m.route.unstable_middleware.map((fn) => [m.route.id, fn]) : []
-    );
-    let result = await callRouteMiddleware(
-      { request, params, context },
-      tuples,
-      propagateResult,
-      middlewareState,
-      handler
-    );
-    return propagateResult ? result : middlewareState.handlerResult;
-  } catch (e) {
-    if (!middlewareState.middlewareError) {
-      throw e;
-    }
-    let result = await errorHandler(
-      middlewareState.middlewareError.error,
-      middlewareState.middlewareError.routeId
+  let tuples = matches.flatMap(
+    (m) => m.route.unstable_middleware ? m.route.unstable_middleware.map((fn) => [m.route.id, fn]) : []
+  );
+  let result = await callServerRouteMiddleware(
+    { request, params, context },
+    tuples,
+    handler,
+    errorHandler
+  );
+  if (isDataWithResponseInit(result)) {
+    return new Response(
+      typeof result.data === "string" ? result.data : JSON.stringify(result.data),
+      { ...result.init }
     );
-    {
-      return result;
-    }
   }
+  if (isResponse(result)) {
+    return result;
+  }
+  invariant(false, `Expected a Response to be returned from route middleware`);
 }
-async function callRouteMiddleware(args, middlewares, propagateResult, middlewareState, handler, idx = 0) {
+async function callServerRouteMiddleware(args, middlewares, handler, errorHandler, idx = 0) {
   let { request } = args;
   if (request.signal.aborted) {
     if (request.signal.reason) {
@@ -1511,8 +1496,8 @@ async function callRouteMiddleware(args, middlewares, propagateResult, middlewar
   }
   let tuple = middlewares[idx];
   if (!tuple) {
-    middlewareState.handlerResult = await handler();
-    return middlewareState.handlerResult;
+    let result = await handler();
+    return result;
   }
   let [routeId, middleware] = tuple;
   let nextCalled = false;
@@ -1522,17 +1507,19 @@ async function callRouteMiddleware(args, middlewares, propagateResult, middlewar
       throw new Error("You may only call `next()` once per middleware");
     }
     nextCalled = true;
-    let result = await callRouteMiddleware(
-      args,
-      middlewares,
-      propagateResult,
-      middlewareState,
-      handler,
-      idx + 1
-    );
-    {
+    try {
+      let result = await callServerRouteMiddleware(
+        args,
+        middlewares,
+        handler,
+        errorHandler,
+        idx + 1
+      );
       nextResult = result;
       return nextResult;
+    } catch (e) {
+      nextResult = await errorHandler(e, routeId);
+      return nextResult;
     }
   };
   try {
@@ -1545,21 +1532,16 @@ async function callRouteMiddleware(args, middlewares, propagateResult, middlewar
       next
     );
     if (nextCalled) {
-      if (result === void 0) {
-        return nextResult;
-      } else {
-        return result;
-      }
+      return typeof result === "undefined" ? nextResult : result;
+    } else if (isResponse(result) || isDataWithResponseInit(result)) {
+      return result;
     } else {
-      return next();
+      nextResult = await next();
+      return nextResult;
     }
   } catch (error) {
-    if (!middlewareState.middlewareError) {
-      middlewareState.middlewareError = { routeId, error };
-    } else if (middlewareState.middlewareError.error !== error) {
-      middlewareState.middlewareError = { routeId, error };
-    }
-    throw error;
+    let response = await errorHandler(error, routeId);
+    return response;
   }
 }
 function getDataStrategyMatchLazyPromises(mapRouteProperties, manifest, request, match, lazyRoutePropertiesToSkip) {
@@ -2334,7 +2316,6 @@ async function processServerAction(request, basename, decodeReply, loadServerAct
   }
 }
 async function generateResourceResponse(request, routes, basename, routeId, requestContext, onError) {
-  let result;
   try {
     const staticHandler = createStaticHandler(routes, {
       basename
@@ -2342,41 +2323,45 @@ async function generateResourceResponse(request, routes, basename, routeId, requ
     let response = await staticHandler.queryRoute(request, {
       routeId,
       requestContext,
-      unstable_respond: (ctx) => ctx
-    });
-    if (isResponse(response)) {
-      result = response;
-    } else {
-      if (typeof response === "string") {
-        result = new Response(response);
-      } else {
-        result = Response.json(response);
+      async unstable_generateMiddlewareResponse(queryRoute) {
+        try {
+          let response2 = await queryRoute(request);
+          return generateResourceResponse2(response2);
+        } catch (error) {
+          return generateErrorResponse(error);
+        }
       }
-    }
+    });
+    return response;
   } catch (error) {
+    return generateErrorResponse(error);
+  }
+  function generateErrorResponse(error) {
+    let response;
     if (isResponse(error)) {
-      result = error;
+      response = error;
     } else if (isRouteErrorResponse(error)) {
       onError?.(error);
       const errorMessage = typeof error.data === "string" ? error.data : error.statusText;
-      result = new Response(errorMessage, {
+      response = new Response(errorMessage, {
         status: error.status,
         statusText: error.statusText
       });
     } else {
       onError?.(error);
-      result = new Response("Internal Server Error", {
-        status: 500
-      });
+      response = new Response("Internal Server Error", { status: 500 });
     }
+    return generateResourceResponse2(response);
+  }
+  function generateResourceResponse2(response) {
+    const headers = new Headers(response.headers);
+    headers.set("React-Router-Resource", "true");
+    return new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers
+    });
   }
-  const headers = new Headers(result.headers);
-  headers.set("React-Router-Resource", "true");
-  return new Response(result.body, {
-    status: result.status,
-    statusText: result.statusText,
-    headers
-  });
 }
 async function generateRenderResponse(request, routes, basename, isDataRequest, decodeReply, requestContext, loadServerAction, decodeAction, decodeFormState, onError, generateResponse, temporaryReferences) {
   let statusCode = 200;
@@ -2398,7 +2383,7 @@ async function generateRenderResponse(request, routes, basename, isDataRequest,
       skipLoaderErrorBubbling: isDataRequest,
       skipRevalidation: isSubmission,
       ...routeIdsToLoad ? { filterMatchesToLoad: (m) => routeIdsToLoad.includes(m.route.id) } : null,
-      async unstable_stream(_, query) {
+      async unstable_generateMiddlewareResponse(query) {
         let formState;
         if (request.method === "POST") {
           let result2 = await processServerAction(
@@ -2583,13 +2568,15 @@ async function getRenderPayload(baseRenderPayload, routes, basename, routeIdsToL
   });
   let matchesPromise = Promise.all(
     staticContext.matches.map((match, i) => {
-      let shouldRenderComponent = i <= deepestRenderedRouteIdx && (!routeIdsToLoad || routeIdsToLoad.includes(match.route.id)) && (!staticContext.errors || !(match.route.id in staticContext.errors));
-      return getRSCRouteMatch(
+      let isBelowErrorBoundary = i > deepestRenderedRouteIdx;
+      let parentId = parentIds[match.route.id];
+      return getRSCRouteMatch({
         staticContext,
         match,
-        shouldRenderComponent,
-        parentIds[match.route.id]
-      );
+        routeIdsToLoad,
+        isBelowErrorBoundary,
+        parentId
+      });
     })
   );
   let patchesPromise = getAdditionalRoutePatches(
@@ -2605,7 +2592,13 @@ async function getRenderPayload(baseRenderPayload, routes, basename, routeIdsToL
     patches
   };
 }
-async function getRSCRouteMatch(staticContext, match, shouldRenderComponent, parentId) {
+async function getRSCRouteMatch({
+  staticContext,
+  match,
+  isBelowErrorBoundary,
+  routeIdsToLoad,
+  parentId
+}) {
   await explodeLazyRoute(match.route);
   const Layout = match.route.Layout || React2.Fragment;
   const Component = match.route.Component;
@@ -2615,8 +2608,9 @@ async function getRSCRouteMatch(staticContext, match, shouldRenderComponent, par
   const actionData = staticContext.actionData?.[match.route.id];
   const params = match.params;
   let element = void 0;
-  if (Component) {
-    element = shouldRenderComponent ? React2.createElement(
+  let shouldLoadRoute = !routeIdsToLoad || routeIdsToLoad.includes(match.route.id);
+  if (Component && shouldLoadRoute) {
+    element = !isBelowErrorBoundary ? React2.createElement(
       Layout,
       null,
       isClientReference(Component) ? React2.createElement(WithComponentProps, {