Convert other single fetch flows to use new API

Author: brophdawg11

packages/react-router/lib/dom-export/hydrated-router.tsx

@@ -209,7 +209,6 @@ function createHydratedRouter({
     },
     dataStrategy: getSingleFetchDataStrategy(
       ssrInfo.manifest,
-      ssrInfo.routeModules,
       ssrInfo.context.ssr,
       ssrInfo.context.basename,
       () => router

packages/react-router/lib/dom/ssr/single-fetch.tsx

@@ -139,7 +139,6 @@ function handleMiddlewareError(error: unknown, routeId: string) {
 
 export function getSingleFetchDataStrategy(
   manifest: AssetsManifest,
-  routeModules: RouteModules,
   ssr: boolean,
   basename: string | undefined,
   getRouter: () => DataRouter
@@ -152,12 +151,11 @@ export function getSingleFetchDataStrategy(
       return runMiddlewarePipeline(
         args,
         false,
-        () => singleFetchActionStrategy(request, matches, basename),
+        () => singleFetchActionStrategy(args, basename),
         handleMiddlewareError
       ) as Promise<Record<string, DataStrategyResult>>;
     }
 
-    // TODO: Enable middleware for this flow
     if (!ssr) {
       // If this is SPA mode, there won't be any loaders below root and we'll
       // disable single fetch.  We have to keep the `dataStrategy` defined for
@@ -193,15 +191,15 @@ export function getSingleFetchDataStrategy(
       //   the other end
       let foundRevalidatingServerLoader = matches.some(
         (m) =>
-          m.shouldLoad &&
+          m.unstable_shouldCallHandler() &&
           manifest.routes[m.route.id]?.hasLoader &&
           !manifest.routes[m.route.id]?.hasClientLoader
       );
       if (!foundRevalidatingServerLoader) {
         return runMiddlewarePipeline(
           args,
           false,
-          () => nonSsrStrategy(manifest, request, matches, basename),
+          () => nonSsrStrategy(args, manifest, basename),
           handleMiddlewareError
         ) as Promise<Record<string, DataStrategyResult>>;
       }
@@ -223,12 +221,10 @@ export function getSingleFetchDataStrategy(
       false,
       () =>
         singleFetchLoaderNavigationStrategy(
+          args,
           manifest,
           ssr,
           getRouter(),
-          request,
-          matches,
-          args.unstable_shouldRevalidateArgs,
           basename
         ),
       handleMiddlewareError
@@ -239,11 +235,10 @@ export function getSingleFetchDataStrategy(
 // Actions are simple since they're singular calls to the server for both
 // navigations and fetchers)
 async function singleFetchActionStrategy(
-  request: Request,
-  matches: DataStrategyFunctionArgs["matches"],
+  { request, matches }: DataStrategyFunctionArgs,
   basename: string | undefined
 ) {
-  let actionMatch = matches.find((m) => m.shouldLoad);
+  let actionMatch = matches.find((m) => m.unstable_shouldCallHandler());
   invariant(actionMatch, "No action match found");
   let actionStatus: number | undefined = undefined;
   let result = await actionMatch.resolve(async (handler) => {
@@ -276,12 +271,11 @@ async function singleFetchActionStrategy(
 
 // We want to opt-out of Single Fetch when we aren't in SSR mode
 async function nonSsrStrategy(
+  { request, matches }: DataStrategyFunctionArgs,
   manifest: AssetsManifest,
-  request: Request,
-  matches: DataStrategyFunctionArgs["matches"],
   basename: string | undefined
 ) {
-  let matchesToLoad = matches.filter((m) => m.shouldLoad);
+  let matchesToLoad = matches.filter((m) => m.unstable_shouldCallHandler());
   let url = stripIndexParam(singleFetchUrl(request.url, basename));
   let init = await createRequestInit(request);
   let results: Record<string, DataStrategyResult> = {};
@@ -308,12 +302,14 @@ async function nonSsrStrategy(
 // Loaders are trickier since we only want to hit the server once, so we
 // create a singular promise for all server-loader routes to latch onto.
 async function singleFetchLoaderNavigationStrategy(
+  {
+    request,
+    matches,
+    unstable_shouldRevalidateArgs: shouldRevalidateArgs,
+  }: DataStrategyFunctionArgs,
   manifest: AssetsManifest,
   ssr: boolean,
   router: DataRouter,
-  request: Request,
-  matches: DataStrategyFunctionArgs["matches"],
-  shouldRevalidateArgs: DataStrategyFunctionArgs["unstable_shouldRevalidateArgs"],
   basename: string | undefined
 ) {
   // Track which routes need a server load - in case we need to tack on a
@@ -458,7 +454,7 @@ async function singleFetchLoaderFetcherStrategy(
   matches: DataStrategyFunctionArgs["matches"],
   basename: string | undefined
 ) {
-  let fetcherMatch = matches.find((m) => m.shouldLoad);
+  let fetcherMatch = matches.find((m) => m.unstable_shouldCallHandler());
   invariant(fetcherMatch, "No fetcher match found");
   let result = await fetcherMatch.resolve(async (handler) => {
     let url = stripIndexParam(singleFetchUrl(request.url, basename));