@tanstack/router-core 1.142.11 → 1.143.3

package/src/load-matches.ts

@@ -683,8 +683,6 @@ const runLoader = async (
       // so we need to wait for it to resolve before
       // we can use the options
       if (route._lazyPromise) await route._lazyPromise
-      const headResult = executeHead(inner, matchId, route)
-      const head = headResult ? await headResult : undefined
       const pendingPromise = match._nonReactive.minPendingPromise
       if (pendingPromise) await pendingPromise
 
@@ -697,7 +695,6 @@ const runLoader = async (
         status: 'success',
         isFetching: false,
         updatedAt: Date.now(),
-        ...head,
       }))
     } catch (e) {
       let error = e
@@ -721,28 +718,17 @@ const runLoader = async (
           onErrorError,
         )
       }
-      const headResult = executeHead(inner, matchId, route)
-      const head = headResult ? await headResult : undefined
       inner.updateMatch(matchId, (prev) => ({
         ...prev,
         error,
         status: 'error',
         isFetching: false,
-        ...head,
       }))
     }
   } catch (err) {
     const match = inner.router.getMatch(matchId)
     // in case of a redirecting match during preload, the match does not exist
     if (match) {
-      const headResult = executeHead(inner, matchId, route)
-      if (headResult) {
-        const head = await headResult
-        inner.updateMatch(matchId, (prev) => ({
-          ...prev,
-          ...head,
-        }))
-      }
       match._nonReactive.loaderPromise = undefined
     }
     handleRedirectAndNotFound(inner, match, err)
@@ -767,14 +753,6 @@ const loadRouteMatch = async (
 
   if (shouldSkipLoader(inner, matchId)) {
     if (inner.router.isServer) {
-      const headResult = executeHead(inner, matchId, route)
-      if (headResult) {
-        const head = await headResult
-        inner.updateMatch(matchId, (prev) => ({
-          ...prev,
-          ...head,
-        }))
-      }
       return inner.router.getMatch(matchId)!
     }
   } else {
@@ -852,18 +830,6 @@ const loadRouteMatch = async (
         })()
       } else if (status !== 'success' || (loaderShouldRunAsync && inner.sync)) {
         await runLoader(inner, matchId, index, route)
-      } else {
-        // if the loader did not run, still update head.
-        // reason: parent's beforeLoad may have changed the route context
-        // and only now do we know the route context (and that the loader would not run)
-        const headResult = executeHead(inner, matchId, route)
-        if (headResult) {
-          const head = await headResult
-          inner.updateMatch(matchId, (prev) => ({
-            ...prev,
-            ...head,
-          }))
-        }
       }
     }
   }
@@ -931,7 +897,52 @@ export async function loadMatches(arg: {
     for (let i = 0; i < max; i++) {
       inner.matchPromises.push(loadRouteMatch(inner, i))
     }
-    await Promise.all(inner.matchPromises)
+    // Use allSettled to ensure all loaders complete regardless of success/failure
+    const results = await Promise.allSettled(inner.matchPromises)
+
+    const failures = results
+      // TODO when we drop support for TS 5.4, we can use the built-in type guard for PromiseRejectedResult
+      .filter(
+        (result): result is PromiseRejectedResult =>
+          result.status === 'rejected',
+      )
+      .map((result) => result.reason)
+
+    // Find first redirect (throw immediately) or notFound (throw after head execution)
+    let firstNotFound: unknown
+    for (const err of failures) {
+      if (isRedirect(err)) {
+        throw err
+      }
+      if (!firstNotFound && isNotFound(err)) {
+        firstNotFound = err
+      }
+    }
+
+    // serially execute head functions after all loaders have completed (successfully or not)
+    // Each head execution is wrapped in try-catch to ensure all heads run even if one fails
+    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) {
+        // Log error but continue executing other head functions
+        console.error(`Error executing head for route ${routeId}:`, err)
+      }
+    }
+
+    // Throw notFound after head execution
+    if (firstNotFound) {
+      throw firstNotFound
+    }
 
     const readyPromise = triggerOnReady(inner)
     if (isPromise(readyPromise)) await readyPromise
@@ -945,7 +956,6 @@ export async function loadMatches(arg: {
       throw err
     }
   }
-
   return inner.matches
 }
 

package/src/router.ts

@@ -1177,6 +1177,7 @@ export class RouterCore<
       // Before we do any processing, we need to allow rewrites to modify the URL
       // build up the full URL by combining the href from history with the router's origin
       const fullUrl = new URL(href, this.origin)
+
       const url = executeRewriteInput(this.rewrite, fullUrl)
 
       const parsedSearch = this.options.parseSearch(url.search)
@@ -1187,11 +1188,33 @@ export class RouterCore<
 
       const fullPath = url.href.replace(url.origin, '')
 
+      // Save the internal pathname for route matching (before output rewrite)
+      const internalPathname = url.pathname
+
+      // Compute publicHref by applying the output rewrite.
+      //
+      // The publicHref represents the URL as it should appear in the browser.
+      // This must match what buildLocation computes for the same logical route,
+      // otherwise the server-side redirect check will see a mismatch and trigger
+      // an infinite redirect loop.
+      //
+      // We always apply the output rewrite (not conditionally) because the
+      // incoming URL may have already been transformed by external middleware
+      // before reaching the router. In that case, the input rewrite has nothing
+      // to do, but we still need the output rewrite to reconstruct the correct
+      // public-facing URL.
+      //
+      // Clone the URL to avoid mutating the one used for route matching.
+      const urlForOutput = new URL(url.href)
+      const rewrittenUrl = executeRewriteOutput(this.rewrite, urlForOutput)
+      const publicHref =
+        rewrittenUrl.pathname + rewrittenUrl.search + rewrittenUrl.hash
+
       return {
         href: fullPath,
-        publicHref: href,
+        publicHref,
         url: url,
-        pathname: decodePath(url.pathname),
+        pathname: decodePath(internalPathname),
         searchStr,
         search: replaceEqualDeep(previousLocation?.search, parsedSearch) as any,
         hash: url.hash.split('#').reverse()[0] ?? '',