@tanstack/router-core 1.163.3 → 1.166.4

package/dist/cjs/load-matches.cjs

@@ -30,32 +30,29 @@ const buildMatchContext = (inner, index, includeCurrentMatch = true) => {
   }
   return context;
 };
-const _handleNotFound = (inner, err, routerCode) => {
-  const routeCursor = inner.router.routesById[err.routeId ?? ""] ?? inner.router.routeTree;
-  if (!routeCursor.options.notFoundComponent && inner.router.options?.defaultNotFoundComponent) {
-    routeCursor.options.notFoundComponent = inner.router.options.defaultNotFoundComponent;
+const getNotFoundBoundaryIndex = (inner, err) => {
+  if (!inner.matches.length) {
+    return void 0;
   }
-  const willWalkUp = routerCode === "BEFORE_LOAD" && routeCursor.parentRoute;
-  if (!willWalkUp) {
-    invariant(
-      routeCursor.options.notFoundComponent,
-      "No notFoundComponent found. Please set a notFoundComponent on your route or provide a defaultNotFoundComponent to the router."
-    );
-  }
-  const matchForRoute = inner.matches.find((m) => m.routeId === routeCursor.id);
-  invariant(matchForRoute, "Could not find match for route: " + routeCursor.id);
-  inner.updateMatch(matchForRoute.id, (prev) => ({
-    ...prev,
-    status: "notFound",
-    error: err,
-    isFetching: false
-  }));
-  if (willWalkUp) {
-    err.routeId = routeCursor.parentRoute.id;
-    _handleNotFound(inner, err, routerCode);
+  const requestedRouteId = err.routeId;
+  const matchedRootIndex = inner.matches.findIndex(
+    (m) => m.routeId === inner.router.routeTree.id
+  );
+  const rootIndex = matchedRootIndex >= 0 ? matchedRootIndex : 0;
+  let startIndex = requestedRouteId ? inner.matches.findIndex((match) => match.routeId === requestedRouteId) : inner.firstBadMatchIndex ?? inner.matches.length - 1;
+  if (startIndex < 0) {
+    startIndex = rootIndex;
+  }
+  for (let i = startIndex; i >= 0; i--) {
+    const match = inner.matches[i];
+    const route = inner.router.looseRoutesById[match.routeId];
+    if (route.options.notFoundComponent) {
+      return i;
+    }
   }
+  return requestedRouteId ? startIndex : rootIndex;
 };
-const handleRedirectAndNotFound = (inner, match, err, routerCode) => {
+const handleRedirectAndNotFound = (inner, match, err) => {
   if (!redirect.isRedirect(err) && !notFound.isNotFound(err)) return;
   if (redirect.isRedirect(err) && err.redirectHandled && !err.options.reloadDocument) {
     throw err;
@@ -65,11 +62,10 @@ const handleRedirectAndNotFound = (inner, match, err, routerCode) => {
     match._nonReactive.loaderPromise?.resolve();
     match._nonReactive.beforeLoadPromise = void 0;
     match._nonReactive.loaderPromise = void 0;
-    const status = redirect.isRedirect(err) ? "redirected" : "notFound";
     match._nonReactive.error = err;
     inner.updateMatch(match.id, (prev) => ({
       ...prev,
-      status,
+      status: redirect.isRedirect(err) ? "redirected" : prev.status === "pending" ? "success" : prev.status,
       context: buildMatchContext(inner, match.index),
       isFetching: false,
       error: err
@@ -84,14 +80,14 @@ const handleRedirectAndNotFound = (inner, match, err, routerCode) => {
     err.options._fromLocation = inner.location;
     err.redirectHandled = true;
     err = inner.router.resolveRedirect(err);
-    throw err;
-  } else {
-    _handleNotFound(inner, err, routerCode);
-    throw err;
   }
+  throw err;
 };
 const shouldSkipLoader = (inner, matchId) => {
   const match = inner.router.getMatch(matchId);
+  if (!match) {
+    return true;
+  }
   if (!(isServer.isServer ?? inner.router.isServer) && match._nonReactive.dehydrated) {
     return true;
   }
@@ -100,6 +96,15 @@ const shouldSkipLoader = (inner, matchId) => {
   }
   return false;
 };
+const syncMatchContext = (inner, matchId, index) => {
+  const nextContext = buildMatchContext(inner, index);
+  inner.updateMatch(matchId, (prev) => {
+    return {
+      ...prev,
+      context: nextContext
+    };
+  });
+};
 const handleSerialError = (inner, index, err, routerCode) => {
   const { id: matchId, routeId } = inner.matches[index];
   const route = inner.router.looseRoutesById[routeId];
@@ -108,22 +113,12 @@ const handleSerialError = (inner, index, err, routerCode) => {
   }
   err.routerCode = routerCode;
   inner.firstBadMatchIndex ??= index;
-  handleRedirectAndNotFound(
-    inner,
-    inner.router.getMatch(matchId),
-    err,
-    routerCode
-  );
+  handleRedirectAndNotFound(inner, inner.router.getMatch(matchId), err);
   try {
     route.options.onError?.(err);
   } catch (errorHandlerErr) {
     err = errorHandlerErr;
-    handleRedirectAndNotFound(
-      inner,
-      inner.router.getMatch(matchId),
-      err,
-      routerCode
-    );
+    handleRedirectAndNotFound(inner, inner.router.getMatch(matchId), err);
   }
   inner.updateMatch(matchId, (prev) => {
     prev._nonReactive.beforeLoadPromise?.resolve();
@@ -138,6 +133,9 @@ const handleSerialError = (inner, index, err, routerCode) => {
       abortController: new AbortController()
     };
   });
+  if (!inner.preload && !redirect.isRedirect(err) && !notFound.isNotFound(err)) {
+    inner.serialError ??= err;
+  }
 };
 const isBeforeLoadSsr = (inner, matchId, index, route) => {
   const existingMatch = inner.router.getMatch(matchId);
@@ -373,8 +371,8 @@ const executeHead = (inner, matchId, route) => {
     };
   });
 };
-const getLoaderContext = (inner, matchId, index, route) => {
-  const parentMatchPromise = inner.matchPromises[index - 1];
+const getLoaderContext = (inner, matchPromises, matchId, index, route) => {
+  const parentMatchPromise = matchPromises[index - 1];
   const { params, loaderDeps, abortController, cause } = inner.router.getMatch(matchId);
   const context = buildMatchContext(inner, index);
   const preload = resolvePreload(inner, matchId);
@@ -395,7 +393,7 @@ const getLoaderContext = (inner, matchId, index, route) => {
     ...inner.router.options.additionalContext
   };
 };
-const runLoader = async (inner, matchId, index, route) => {
+const runLoader = async (inner, matchPromises, matchId, index, route) => {
   try {
     const match = inner.router.getMatch(matchId);
     try {
@@ -403,7 +401,7 @@ const runLoader = async (inner, matchId, index, route) => {
         loadRouteChunk(route);
       }
       const loaderResult = route.options.loader?.(
-        getLoaderContext(inner, matchId, index, route)
+        getLoaderContext(inner, matchPromises, matchId, index, route)
       );
       const loaderResultIsPromise = route.options.loader && utils.isPromise(loaderResult);
       const willLoadSomething = !!(loaderResultIsPromise || route._lazyPromise || route._componentsPromise || route.options.head || route.options.scripts || route.options.headers || match._nonReactive.minPendingPromise);
@@ -487,20 +485,23 @@ const runLoader = async (inner, matchId, index, route) => {
     handleRedirectAndNotFound(inner, match, err);
   }
 };
-const loadRouteMatch = async (inner, index) => {
-  async function handleLoader(preload, prevMatch, match2, route2) {
+const loadRouteMatch = async (inner, matchPromises, index) => {
+  async function handleLoader(preload, prevMatch, previousRouteMatchId, match2, route2) {
     const age = Date.now() - prevMatch.updatedAt;
     const staleAge = preload ? route2.options.preloadStaleTime ?? inner.router.options.defaultPreloadStaleTime ?? 3e4 : route2.options.staleTime ?? inner.router.options.defaultStaleTime ?? 0;
     const shouldReloadOption = route2.options.shouldReload;
-    const shouldReload = typeof shouldReloadOption === "function" ? shouldReloadOption(getLoaderContext(inner, matchId, index, route2)) : shouldReloadOption;
+    const shouldReload = typeof shouldReloadOption === "function" ? shouldReloadOption(
+      getLoaderContext(inner, matchPromises, matchId, index, route2)
+    ) : shouldReloadOption;
     const { status, invalid } = match2;
-    loaderShouldRunAsync = status === "success" && (invalid || (shouldReload ?? age > staleAge));
+    const staleMatchShouldReload = age > staleAge && (!!inner.forceStaleReload || match2.cause === "enter" || previousRouteMatchId !== void 0 && previousRouteMatchId !== match2.id);
+    loaderShouldRunAsync = status === "success" && (invalid || (shouldReload ?? staleMatchShouldReload));
     if (preload && route2.options.preload === false) ;
     else if (loaderShouldRunAsync && !inner.sync) {
       loaderIsRunningAsync = true;
       (async () => {
         try {
-          await runLoader(inner, matchId, index, route2);
+          await runLoader(inner, matchPromises, matchId, index, route2);
           const match3 = inner.router.getMatch(matchId);
           match3._nonReactive.loaderPromise?.resolve();
           match3._nonReactive.loadPromise?.resolve();
@@ -512,7 +513,9 @@ const loadRouteMatch = async (inner, index) => {
         }
       })();
     } else if (status !== "success" || loaderShouldRunAsync && inner.sync) {
-      await runLoader(inner, matchId, index, route2);
+      await runLoader(inner, matchPromises, matchId, index, route2);
+    } else {
+      syncMatchContext(inner, matchId, index);
     }
   }
   const { id: matchId, routeId } = inner.matches[index];
@@ -520,11 +523,17 @@ const loadRouteMatch = async (inner, index) => {
   let loaderIsRunningAsync = false;
   const route = inner.router.looseRoutesById[routeId];
   if (shouldSkipLoader(inner, matchId)) {
+    const match2 = inner.router.getMatch(matchId);
+    if (!match2) {
+      return inner.matches[index];
+    }
+    syncMatchContext(inner, matchId, index);
     if (isServer.isServer ?? inner.router.isServer) {
       return inner.router.getMatch(matchId);
     }
   } else {
     const prevMatch = inner.router.getMatch(matchId);
+    const previousRouteMatchId = inner.router.state.matches[index]?.routeId === routeId ? inner.router.state.matches[index].id : inner.router.state.matches.find((d) => d.routeId === routeId)?.id;
     const preload = resolvePreload(inner, matchId);
     if (prevMatch._nonReactive.loaderPromise) {
       if (prevMatch.status === "success" && !inner.sync && !prevMatch.preload) {
@@ -537,7 +546,13 @@ const loadRouteMatch = async (inner, index) => {
         handleRedirectAndNotFound(inner, match2, error);
       }
       if (match2.status === "pending") {
-        await handleLoader(preload, prevMatch, match2, route);
+        await handleLoader(
+          preload,
+          prevMatch,
+          previousRouteMatchId,
+          match2,
+          route
+        );
       }
     } else {
       const nextPreload = preload && !inner.router.state.matches.some((d) => d.id === matchId);
@@ -549,7 +564,7 @@ const loadRouteMatch = async (inner, index) => {
           preload: nextPreload
         }));
       }
-      await handleLoader(preload, prevMatch, match2, route);
+      await handleLoader(preload, prevMatch, previousRouteMatchId, match2, route);
     }
   }
   const match = inner.router.getMatch(matchId);
@@ -574,65 +589,141 @@ const loadRouteMatch = async (inner, index) => {
   }
 };
 async function loadMatches(arg) {
-  const inner = Object.assign(arg, {
-    matchPromises: []
-  });
+  const inner = arg;
+  const matchPromises = [];
   if (!(isServer.isServer ?? inner.router.isServer) && inner.router.state.matches.some((d) => d._forcePending)) {
     triggerOnReady(inner);
   }
-  try {
-    for (let i = 0; i < inner.matches.length; i++) {
+  let beforeLoadNotFound;
+  for (let i = 0; i < inner.matches.length; i++) {
+    try {
       const beforeLoad = handleBeforeLoad(inner, i);
       if (utils.isPromise(beforeLoad)) await beforeLoad;
-    }
-    const max = inner.firstBadMatchIndex ?? inner.matches.length;
-    for (let i = 0; i < max; i++) {
-      inner.matchPromises.push(loadRouteMatch(inner, i));
-    }
-    const results = await Promise.allSettled(inner.matchPromises);
-    const failures = results.filter(
-      (result) => result.status === "rejected"
-    ).map((result) => result.reason);
-    let firstNotFound;
-    for (const err of failures) {
+    } catch (err) {
       if (redirect.isRedirect(err)) {
         throw err;
       }
-      if (!firstNotFound && notFound.isNotFound(err)) {
-        firstNotFound = err;
+      if (notFound.isNotFound(err)) {
+        beforeLoadNotFound = err;
+      } else {
+        if (!inner.preload) throw err;
       }
+      break;
     }
-    for (const match of inner.matches) {
-      const { id: matchId, routeId } = match;
-      const route = inner.router.looseRoutesById[routeId];
-      try {
-        const headResult = executeHead(inner, matchId, route);
-        if (headResult) {
-          const head = await headResult;
-          inner.updateMatch(matchId, (prev) => ({
-            ...prev,
-            ...head
-          }));
-        }
-      } catch (err) {
-        console.error(`Error executing head for route ${routeId}:`, err);
+    if (inner.serialError) {
+      break;
+    }
+  }
+  const baseMaxIndexExclusive = inner.firstBadMatchIndex ?? inner.matches.length;
+  const boundaryIndex = beforeLoadNotFound && !inner.preload ? getNotFoundBoundaryIndex(inner, beforeLoadNotFound) : void 0;
+  const maxIndexExclusive = beforeLoadNotFound && inner.preload ? 0 : boundaryIndex !== void 0 ? Math.min(boundaryIndex + 1, baseMaxIndexExclusive) : baseMaxIndexExclusive;
+  let firstNotFound;
+  let firstUnhandledRejection;
+  for (let i = 0; i < maxIndexExclusive; i++) {
+    matchPromises.push(loadRouteMatch(inner, matchPromises, i));
+  }
+  try {
+    await Promise.all(matchPromises);
+  } catch {
+    const settled = await Promise.allSettled(matchPromises);
+    for (const result of settled) {
+      if (result.status !== "rejected") continue;
+      const reason = result.reason;
+      if (redirect.isRedirect(reason)) {
+        throw reason;
+      }
+      if (notFound.isNotFound(reason)) {
+        firstNotFound ??= reason;
+      } else {
+        firstUnhandledRejection ??= reason;
       }
     }
-    if (firstNotFound) {
-      throw firstNotFound;
+    if (firstUnhandledRejection !== void 0) {
+      throw firstUnhandledRejection;
     }
-    const readyPromise = triggerOnReady(inner);
-    if (utils.isPromise(readyPromise)) await readyPromise;
-  } catch (err) {
-    if (notFound.isNotFound(err) && !inner.preload) {
-      const readyPromise = triggerOnReady(inner);
-      if (utils.isPromise(readyPromise)) await readyPromise;
-      throw err;
+  }
+  const notFoundToThrow = firstNotFound ?? (beforeLoadNotFound && !inner.preload ? beforeLoadNotFound : void 0);
+  let headMaxIndex = inner.serialError ? inner.firstBadMatchIndex ?? 0 : inner.matches.length - 1;
+  if (!notFoundToThrow && beforeLoadNotFound && inner.preload) {
+    return inner.matches;
+  }
+  if (notFoundToThrow) {
+    const renderedBoundaryIndex = getNotFoundBoundaryIndex(
+      inner,
+      notFoundToThrow
+    );
+    invariant(
+      renderedBoundaryIndex !== void 0,
+      "Could not find match for notFound boundary"
+    );
+    const boundaryMatch = inner.matches[renderedBoundaryIndex];
+    const boundaryRoute = inner.router.looseRoutesById[boundaryMatch.routeId];
+    const defaultNotFoundComponent = inner.router.options?.defaultNotFoundComponent;
+    if (!boundaryRoute.options.notFoundComponent && defaultNotFoundComponent) {
+      boundaryRoute.options.notFoundComponent = defaultNotFoundComponent;
     }
-    if (redirect.isRedirect(err)) {
-      throw err;
+    notFoundToThrow.routeId = boundaryMatch.routeId;
+    const boundaryIsRoot = boundaryMatch.routeId === inner.router.routeTree.id;
+    inner.updateMatch(boundaryMatch.id, (prev) => ({
+      ...prev,
+      ...boundaryIsRoot ? (
+        // For root boundary, use globalNotFound so the root component's
+        // shell still renders and <Outlet> handles the not-found display,
+        // instead of replacing the entire root shell via status='notFound'.
+        { status: "success", globalNotFound: true, error: void 0 }
+      ) : (
+        // For non-root boundaries, set status:'notFound' so MatchInner
+        // renders the notFoundComponent directly.
+        { status: "notFound", error: notFoundToThrow }
+      ),
+      isFetching: false
+    }));
+    headMaxIndex = renderedBoundaryIndex;
+    await loadRouteChunk(boundaryRoute);
+  } else if (!inner.preload) {
+    const rootMatch = inner.matches[0];
+    if (!rootMatch.globalNotFound) {
+      const currentRootMatch = inner.router.getMatch(rootMatch.id);
+      if (currentRootMatch?.globalNotFound) {
+        inner.updateMatch(rootMatch.id, (prev) => ({
+          ...prev,
+          globalNotFound: false,
+          error: void 0
+        }));
+      }
     }
   }
+  if (inner.serialError && inner.firstBadMatchIndex !== void 0) {
+    const errorRoute = inner.router.looseRoutesById[inner.matches[inner.firstBadMatchIndex].routeId];
+    await loadRouteChunk(errorRoute);
+  }
+  for (let i = 0; i <= headMaxIndex; i++) {
+    const match = inner.matches[i];
+    const { id: matchId, routeId } = match;
+    const route = inner.router.looseRoutesById[routeId];
+    try {
+      const headResult = executeHead(inner, matchId, route);
+      if (headResult) {
+        const head = await headResult;
+        inner.updateMatch(matchId, (prev) => ({
+          ...prev,
+          ...head
+        }));
+      }
+    } catch (err) {
+      console.error(`Error executing head for route ${routeId}:`, err);
+    }
+  }
+  const readyPromise = triggerOnReady(inner);
+  if (utils.isPromise(readyPromise)) {
+    await readyPromise;
+  }
+  if (notFoundToThrow) {
+    throw notFoundToThrow;
+  }
+  if (inner.serialError && !inner.preload && !inner.onReady) {
+    throw inner.serialError;
+  }
   return inner.matches;
 }
 async function loadRouteChunk(route) {