@tanstack/router-core 1.171.24 → 1.171.25

package/src/load-server.ts

@@ -82,17 +82,51 @@ function normalize(value: unknown, rejected: boolean): LoaderOutcome {
   return rejected ? [ERROR, value] : [SUCCESS, value]
 }
 
-function normalizeError(route: AnyRoute, cause: unknown): LoaderOutcome {
+function normalizeError(
+  router: AnyRouter,
+  lane: { location: ParsedLocation },
+  route: AnyRoute,
+  cause: unknown,
+  signal?: AbortSignal,
+  notify = true,
+): LoaderOutcome {
+  signal?.throwIfAborted()
   let outcome = normalize(cause, true)
   if (outcome[0] !== ERROR) {
-    return outcome
+    return materializeRedirect(router, lane, route, outcome, signal, notify)
   }
   try {
     route.options.onError?.(outcome[1])
   } catch (onErrorCause) {
     outcome = normalize(onErrorCause, true)
   }
-  return outcome
+  signal?.throwIfAborted()
+  return materializeRedirect(router, lane, route, outcome, signal, notify)
+}
+
+function materializeRedirect(
+  router: AnyRouter,
+  lane: { location: ParsedLocation },
+  route: AnyRoute,
+  outcome: LoaderOutcome,
+  signal?: AbortSignal,
+  notify = true,
+): LoaderOutcome {
+  if (outcome[0] !== REDIRECTED) {
+    return outcome
+  }
+  signal?.throwIfAborted()
+  try {
+    outcome[1].options._fromLocation = lane.location
+    router.resolveRedirect(outcome[1])
+    signal?.throwIfAborted()
+    return outcome
+  } catch (cause) {
+    signal?.throwIfAborted()
+    return notify
+      ? normalizeError(router, lane, route, cause, signal, false)
+      : [ERROR, cause]
+  }
 }
 
 function maybe<TValue>(
@@ -197,7 +231,13 @@ async function contextualize(
       match.ssr = await resolveSsr(router, lane, index)
     } catch (cause) {
       signal?.throwIfAborted()
-      failure = [index, stampNotFound(match, normalizeError(route, cause))]
+      failure = [
+        index,
+        stampNotFound(
+          match,
+          normalizeError(router, lane, route, cause, signal),
+        ),
+      ]
       end = index
     }
     signal?.throwIfAborted()
@@ -239,7 +279,13 @@ async function contextualize(
     } catch (cause) {
       signal?.throwIfAborted()
       if (!failure) {
-        failure = [index, stampNotFound(match, normalizeError(route, cause))]
+        failure = [
+          index,
+          stampNotFound(
+            match,
+            normalizeError(router, lane, route, cause, signal),
+          ),
+        ]
       }
       end = index
       break
@@ -252,7 +298,10 @@ async function contextualize(
     if (validationError !== undefined) {
       failure = [
         index,
-        stampNotFound(match, normalizeError(route, validationError)),
+        stampNotFound(
+          match,
+          normalizeError(router, lane, route, validationError, signal),
+        ),
       ]
       end = index
       break
@@ -293,7 +342,16 @@ async function contextualize(
     try {
       const beforeLoadContext = await route.options.beforeLoad(options)
       signal?.throwIfAborted()
-      const outcome = stampNotFound(match, normalize(beforeLoadContext, false))
+      const outcome = stampNotFound(
+        match,
+        materializeRedirect(
+          router,
+          lane,
+          route,
+          normalize(beforeLoadContext, false),
+          signal,
+        ),
+      )
       if (outcome[0] !== SUCCESS) {
         failure = [index, outcome]
         end = index
@@ -307,7 +365,13 @@ async function contextualize(
       parentContext = match.context
     } catch (cause) {
       signal?.throwIfAborted()
-      failure = [index, stampNotFound(match, normalizeError(route, cause))]
+      failure = [
+        index,
+        stampNotFound(
+          match,
+          normalizeError(router, lane, route, cause, signal),
+        ),
+      ]
       end = index
       break
     }
@@ -373,14 +437,13 @@ function createLoaderTask(
           (cause) => normalize(cause, true),
         )
         .then((result): LoaderOutcome => {
-          if (
-            result[0] !== REDIRECTED &&
-            (signal?.aborted || match.abortController.signal.reason === lane)
-          ) {
+          if (signal?.aborted || match.abortController.signal.reason === lane) {
             return [SKIPPED]
           }
           if (result[0] === ERROR) {
-            result = normalizeError(route, result[1])
+            result = normalizeError(router, lane, route, result[1], signal)
+          } else {
+            result = materializeRedirect(router, lane, route, result, signal)
           }
           return stampNotFound(match, result)
         })
@@ -424,13 +487,13 @@ async function getNotFoundBoundary(
   }
   for (let candidate = index; candidate >= 0; candidate--) {
     const route = getRoute(router, matches[candidate]!)
-    const loading = loadRouteChunk(route, false)
-    if (loading) {
-      try {
+    try {
+      const loading = loadRouteChunk(route, false)
+      if (loading) {
         await loading
-      } catch {
-        signal?.throwIfAborted()
       }
+    } catch {
+      signal?.throwIfAborted()
     }
     signal?.throwIfAborted()
     if (route.options.notFoundComponent) {
@@ -450,15 +513,6 @@ function abortMatches(
   }
 }
 
-function resolveServerRedirect(
-  router: AnyRouter,
-  location: ParsedLocation,
-  value: AnyRedirect,
-): ServerLoadResult {
-  value.options._fromLocation = location
-  return { type: 'redirect', redirect: router.resolveRedirect(value) }
-}
-
 async function applyFailure(
   router: AnyRouter,
   lane: ContextualizedLane,
@@ -530,7 +584,10 @@ async function loadNormalChunks(
             signal?.throwIfAborted()
             return [
               index,
-              stampNotFound(match, normalizeError(route, cause)),
+              stampNotFound(
+                match,
+                normalizeError(router, lane, route, cause, signal),
+              ),
             ] as IndexedOutcome
           },
         )
@@ -540,7 +597,13 @@ async function loadNormalChunks(
       }
     } catch (cause) {
       signal?.throwIfAborted()
-      chunks.push([index, stampNotFound(match, normalizeError(route, cause))])
+      chunks.push([
+        index,
+        stampNotFound(
+          match,
+          normalizeError(router, lane, route, cause, signal),
+        ),
+      ])
     }
   }
   for (const chunk of chunks) {
@@ -698,7 +761,7 @@ async function executeServerLane(
 
     if (control?.[1][0] === REDIRECTED) {
       abortMatches(lane.matches, 0, lane)
-      return resolveServerRedirect(router, location, control[1][1])
+      return { type: 'redirect', redirect: control[1][1] }
     }
 
     let failure = lane.failure ?? loaderFailure
@@ -742,7 +805,7 @@ async function executeServerLane(
     if (requiredFailure) {
       if (requiredFailure[1][0] === REDIRECTED) {
         abortMatches(lane.matches)
-        return resolveServerRedirect(router, location, requiredFailure[1][1])
+        return { type: 'redirect', redirect: requiredFailure[1][1] }
       }
       failure = requiredFailure
     }
@@ -808,9 +871,7 @@ export async function loadServerRoute(
     })
     if (next.publicHref !== canonical.publicHref) {
       const href = canonical.publicHref || '/'
-      throw canonical.external
-        ? redirect({ href })
-        : redirect({ href, _builtLocation: canonical })
+      throw redirect({ href })
     }
 
     const fromLocation = router.stores.resolvedLocation.get()
@@ -828,7 +889,8 @@ export async function loadServerRoute(
     if (!isRedirect(cause)) {
       throw cause
     }
-    result = resolveServerRedirect(router, next, cause)
+    cause.options._fromLocation = next
+    result = { type: 'redirect', redirect: router.resolveRedirect(cause) }
   }
 
   router._serverResult = result

package/src/redirect.ts

@@ -1,6 +1,5 @@
 import type { NavigateOptions } from './link'
 import type { AnyRouter, RegisteredRouter } from './router'
-import type { ParsedLocation } from './location'
 
 export type AnyRedirect = Redirect<any, any, any, any, any>
 
@@ -14,13 +13,7 @@ export type Redirect<
   TMaskFrom extends string = TFrom,
   TMaskTo extends string = '.',
 > = Response & {
-  options: NavigateOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo> & {
-    /**
-     * @internal
-     * A **trusted** built location that can be used to redirect to.
-     */
-    _builtLocation?: ParsedLocation
-  }
+  options: NavigateOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>
 }
 
 export type RedirectOptions<
@@ -50,11 +43,6 @@ export type RedirectOptions<
    * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RedirectType#headers-property)
    */
   headers?: HeadersInit
-  /**
-   * @internal
-   * A **trusted** built location that can be used to redirect to.
-   */
-  _builtLocation?: ParsedLocation
 } & NavigateOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>
 
 export type ResolvedRedirect<
@@ -122,11 +110,7 @@ export function redirect<
 ): Redirect<TRouter, TFrom, TTo, TMaskFrom, TMaskTo> {
   opts.statusCode = opts.statusCode || opts.code || 307
 
-  if (
-    !opts._builtLocation &&
-    !opts.reloadDocument &&
-    typeof opts.href === 'string'
-  ) {
+  if (!opts.reloadDocument && typeof opts.href === 'string') {
     try {
       new URL(opts.href)
       opts.reloadDocument = true

package/src/router.ts

@@ -692,13 +692,7 @@ export type PreloadRouteFn<
     TTo,
     TMaskFrom,
     TMaskTo
-  > & {
-    /**
-     * @internal
-     * A **trusted** built location that can be used to redirect to.
-     */
-    _builtLocation?: ParsedLocation
-  },
+  >,
 ) => Promise<Array<AnyRouteMatch> | undefined>
 
 export type MatchRouteFn<
@@ -937,10 +931,10 @@ export function runRouteLifecycle(
   router: AnyRouter,
   previous: Array<AnyRouteMatch>,
   matches: Array<AnyRouteMatch>,
-  isCurrent?: () => boolean,
+  owner?: LoadTransaction,
 ): void {
   for (const match of previous) {
-    if (isCurrent?.() === false) {
+    if (owner && router._tx !== owner) {
       return
     }
     if (!matches.some((candidate) => candidate.routeId === match.routeId)) {
@@ -950,7 +944,7 @@ export function runRouteLifecycle(
     }
   }
   for (const match of matches) {
-    if (isCurrent?.() === false) {
+    if (owner && router._tx !== owner) {
       return
     }
     const route = (router.routesById as Record<string, AnyRoute>)[
@@ -1846,6 +1840,19 @@ export class RouterCore<
         unmaskOnReload?: boolean
       } = {},
     ): ParsedLocation => {
+      if (dest.href) {
+        const parsed = parseHref(dest.href, {} as ParsedHistoryState)
+        dest = {
+          ...dest,
+          to: executeRewriteInput(
+            this.rewrite,
+            new URL(parsed.pathname, this.origin),
+          ).pathname,
+          search: this.options.parseSearch(parsed.search),
+          hash: parsed.hash.slice(1),
+        }
+      }
+
       // We allow the caller to override the current location
       const currentLocation =
         dest._fromLocation || this._pendingLocation || this.latestLocation
@@ -2216,38 +2223,12 @@ export class RouterCore<
     hashScrollIntoView,
     viewTransition,
     ignoreBlocker,
-    _redirects,
-    href,
     ...rest
-  }: BuildNextOptions &
-    CommitLocationOptions & { _redirects?: number } = {}) => {
-    if (href) {
-      const currentIndex = this.history.location.state.__TSR_index
-
-      const parsed = parseHref(href, {
-        __TSR_index: replace ? currentIndex : currentIndex + 1,
-      })
-
-      // If the href contains the basepath, we need to strip it before setting `to`
-      // because `buildLocation` will add the basepath back when creating the final URL.
-      // Without this, hrefs like '/app/about' would become '/app/app/about'.
-      const hrefUrl = new URL(parsed.pathname, this.origin)
-      const rewrittenUrl = executeRewriteInput(this.rewrite, hrefUrl)
-
-      rest.to = rewrittenUrl.pathname
-      rest.search = this.options.parseSearch(parsed.search)
-      // remove the leading `#` from the hash
-      rest.hash = parsed.hash.slice(1)
-    }
-
+  }: BuildNextOptions & CommitLocationOptions = {}) => {
     const location = this.buildLocation({
       ...(rest as any),
       _includeValidateSearch: true,
     })
-    if (_redirects) {
-      ;(location as typeof location & { _redirects?: number })._redirects =
-        _redirects
-    }
 
     this._pendingLocation = location as ParsedLocation<
       FullSearchSchema<TRouteTree>
@@ -2514,9 +2495,8 @@ export class RouterCore<
   resolveRedirect = (redirect: AnyRedirect): AnyRedirect => {
     const locationHeader = redirect.headers.get('Location')
 
-    if (!redirect.options.href || redirect.options._builtLocation) {
-      const location =
-        redirect.options._builtLocation ?? this.buildLocation(redirect.options)
+    if (!redirect.options.href) {
+      const location = this.buildLocation(redirect.options)
       const href = location.publicHref || '/'
       redirect.options.href = href
       redirect.headers.set('Location', href)
@@ -2535,7 +2515,6 @@ export class RouterCore<
 
     if (
       redirect.options.href &&
-      !redirect.options._builtLocation &&
       // Check for dangerous protocols before processing the redirect
       isDangerousProtocol(redirect.options.href, this.protocolAllowlist)
     ) {
@@ -2611,7 +2590,8 @@ export class RouterCore<
     TTrailingSlashOption,
     TDefaultStructuralSharingOption,
     TRouterHistory
-  > = (opts) => preloadClientRoute(this, opts)
+  > = (opts: any, builtLocation?: ParsedLocation) =>
+    preloadClientRoute(this, opts, 0, builtLocation)
 
   matchRoute: MatchRouteFn<
     TRouteTree,