@tanstack/router-core 1.171.23 → 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/new-process-route-tree.ts

@@ -27,18 +27,6 @@ type ExtendedSegmentKind =
   | typeof SEGMENT_TYPE_INDEX
   | typeof SEGMENT_TYPE_PATHLESS
 
-function getOpenAndCloseBraces(
-  part: string,
-): [openBrace: number, closeBrace: number] | null {
-  const openBrace = part.indexOf('{')
-  if (openBrace === -1) return null
-  const closeBrace = part.indexOf('}', openBrace)
-  if (closeBrace === -1) return null
-  const afterOpen = openBrace + 1
-  if (afterOpen >= part.length) return null
-  return [openBrace, closeBrace]
-}
-
 type ParsedSegment = Uint16Array & {
   /** segment type (0 = pathname, 1 = param, 2 = wildcard, 3 = optional param) */
   0: SegmentKind
@@ -116,9 +104,13 @@ export function parseSegment(
     return output as ParsedSegment
   }
 
-  const braces = getOpenAndCloseBraces(part)
-  if (braces) {
-    const [openBrace, closeBrace] = braces
+  const openBrace = part.indexOf('{')
+  let closeBrace
+  if (
+    openBrace !== -1 &&
+    openBrace + 1 < part.length &&
+    (closeBrace = part.indexOf('}', openBrace)) !== -1
+  ) {
     const firstChar = part.charCodeAt(openBrace + 1)
 
     // Check for {-$...} (optional param)

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
@@ -2082,59 +2089,35 @@ export class RouterCore<
       }
     }
 
-    const buildWithMatches = (
-      dest: BuildNextOptions = {},
-      maskedDest?: BuildNextOptions,
-    ) => {
-      const next = build(dest)
-
-      let maskedNext = maskedDest ? build(maskedDest) : undefined
-
-      if (!maskedNext) {
-        const params = Object.create(null)
-
-        if (this.options.routeMasks) {
-          const match = findFlatMatch<RouteMask<TRouteTree>>(
-            next.pathname,
-            this.processedTree,
-          )
-          if (match) {
-            Object.assign(params, match.rawParams) // Copy params, because they're cached
-            const {
-              from: _from,
-              params: maskParams,
-              ...maskProps
-            } = match.route
-
-            // If mask has a params function, call it with the matched params as context
-            // Otherwise, use the matched params or the provided params value
-            const nextParams = resolveNextParams(maskParams, params)
-
-            maskedDest = {
-              from: opts.from,
-              ...maskProps,
-              params: nextParams,
-            }
-            maskedNext = build(maskedDest)
-          }
-        }
-      }
-
-      if (maskedNext) {
-        next.maskedLocation = maskedNext
-      }
-
-      return next
-    }
+    const next = build(opts)
 
     if (opts.mask) {
-      return buildWithMatches(opts, {
+      next.maskedLocation = build({
         from: opts.from,
         ...opts.mask,
       })
+    } else if (this.options.routeMasks) {
+      const match = findFlatMatch<RouteMask<TRouteTree>>(
+        next.pathname,
+        this.processedTree,
+      )
+      if (match) {
+        const params = Object.assign(Object.create(null), match.rawParams)
+        const { from: _from, params: maskParams, ...maskProps } = match.route
+
+        // If mask has a params function, call it with the matched params as context
+        // Otherwise, use the matched params or the provided params value
+        const nextParams = resolveNextParams(maskParams, params)
+
+        next.maskedLocation = build({
+          from: opts.from,
+          ...maskProps,
+          params: nextParams,
+        })
+      }
     }
 
-    return buildWithMatches(opts)
+    return next
   }
 
   _commitPromise: (Promise<void> & { resolve: () => void }) | undefined
@@ -2240,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>
@@ -2538,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)
@@ -2559,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)
     ) {
@@ -2635,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,

package/src/utils.ts

@@ -193,10 +193,6 @@ export function last<T>(arr: ReadonlyArray<T>) {
   return arr[arr.length - 1]
 }
 
-function isFunction(d: any): d is Function {
-  return typeof d === 'function'
-}
-
 /**
  * Apply a value-or-updater to a previous value.
  * Accepts either a literal value or a function of the previous value.
@@ -205,8 +201,8 @@ export function functionalUpdate<TPrevious, TResult = TPrevious>(
   updater: Updater<TPrevious, TResult> | NonNullableUpdater<TPrevious, TResult>,
   previous: TPrevious,
 ): TResult {
-  if (isFunction(updater)) {
-    return updater(previous)
+  if (typeof updater === 'function') {
+    return (updater as Function)(previous)
   }
 
   return updater