@tanstack/router-core 1.171.24 → 1.171.26

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

@@ -582,7 +582,7 @@ export function findFlatMatch<T extends Extract<RouteLike, { from: string }>>(
 ) {
   path ||= '/'
   const cached = processedTree.flatCache!.get(path)
-  if (cached) return cached
+  if (cached !== undefined) return cached
   const result = findMatch(path, processedTree.masksTree!)
   processedTree.flatCache!.set(path, result)
   return result

package/src/path.ts

@@ -112,13 +112,25 @@ export function resolvePath({
   trailingSlash = 'never',
   cache,
 }: ResolvePathOptions) {
-  const isBase = to === '.'
-  const isAbsolute = to.startsWith('/')
+  if (to.includes('//')) {
+    to = cleanPath(to)
+  }
+
+  if (to.startsWith('/')) {
+    if (to.length === 1 || trailingSlash === 'preserve') {
+      return to
+    }
+    if (trailingSlash === 'always') {
+      return to.endsWith('/') ? to : `${to}/`
+    }
+    return to.endsWith('/') ? to.slice(0, -1) : to
+  }
 
+  const isBase = to === '.'
   let key
   if (cache) {
     // `trailingSlash` is static per router, so it doesn't need to be part of the cache key
-    key = isAbsolute ? to : isBase ? base : base + '\0' + to
+    key = isBase ? base : base + '\0' + to
     const cached = cache.get(key)
     if (cached) return cached
   }
@@ -126,9 +138,10 @@ export function resolvePath({
   let baseSegments: Array<string>
   if (isBase) {
     baseSegments = base.split('/')
-  } else if (isAbsolute) {
-    baseSegments = to.split('/')
   } else {
+    if (base.includes('//')) {
+      base = cleanPath(base)
+    }
     baseSegments = base.split('/')
     while (baseSegments.length > 1 && last(baseSegments) === '') {
       baseSegments.pop()
@@ -171,7 +184,8 @@ export function resolvePath({
     }
   }
 
-  const result = cleanPath(baseSegments.join('/')) || '/'
+  const joined = baseSegments.join('/')
+  const result = (isBase ? cleanPath(joined) : joined) || '/'
   if (key && cache) cache.set(key, result)
   return 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

@@ -22,7 +22,6 @@ import {
   processRouteTree,
 } from './new-process-route-tree'
 import {
-  cleanPath,
   compileDecodeCharMap,
   interpolatePath,
   resolvePath,
@@ -692,13 +691,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 +930,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 +943,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>)[
@@ -1475,7 +1468,7 @@ export class RouterCore<
   resolvePathWithBase = (from: string, path: string) => {
     return resolvePath({
       base: from,
-      to: path.includes('//') ? cleanPath(path) : path,
+      to: path,
       trailingSlash: this.options.trailingSlash,
       cache: this.resolvePathCache,
     })
@@ -1846,6 +1839,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
@@ -1885,28 +1891,19 @@ export class RouterCore<
         dest.unsafeRelative === 'path'
           ? currentLocation.pathname
           : (dest.from ?? lightweightResult[1 /* fullPath */])
-      const destTo = dest.to ? `${dest.to}` : undefined
 
       // From search should always use the current location
       const fromSearch = lightweightResult[2 /* search */]
       // Same with params. It can't hurt to provide as many as possible
-      const fromParams = Object.assign(
-        Object.create(null),
-        lightweightResult[3 /* params */],
-      )
-
-      const isAbsoluteTo = destTo?.charCodeAt(0) === 47
-      const sourcePath = isAbsoluteTo
-        ? '/'
-        : this.resolvePathWithBase(defaultedFromPath, '.')
+      const fromParams = lightweightResult[3 /* params */]
 
-      // Resolve the destination. Absolute destinations don't need the source path.
-      const nextTo = destTo
-        ? this.resolvePathWithBase(sourcePath, destTo)
-        : sourcePath
+      const nextTo = this.resolvePathWithBase(
+        defaultedFromPath,
+        dest.to ? `${dest.to}` : '.',
+      )
 
       // Resolve the next params
-      const nextParams = resolveNextParams(dest.params, fromParams)
+      let nextParams = resolveNextParams(dest.params, fromParams)
 
       const destRoute = this.routesByPath[
         trimPathRight(nextTo) as keyof typeof this.routesByPath
@@ -1938,6 +1935,9 @@ export class RouterCore<
           const fn =
             route.options.params?.stringify ?? route.options.stringifyParams
           if (fn) {
+            if (nextParams === fromParams) {
+              nextParams = Object.assign(Object.create(null), nextParams)
+            }
             try {
               Object.assign(nextParams, fn(nextParams))
             } catch {
@@ -2036,7 +2036,9 @@ export class RouterCore<
             : {}
 
       // Replace the equal deep
-      nextState = replaceEqualDeep(currentLocation.state, nextState)
+      if (dest.state) {
+        nextState = replaceEqualDeep(currentLocation.state, nextState)
+      }
 
       // Create the full path of the location
       const fullPath = `${nextPathname}${searchStr}${hashStr}`
@@ -2216,38 +2218,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 +2490,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 +2510,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 +2585,8 @@ export class RouterCore<
     TTrailingSlashOption,
     TDefaultStructuralSharingOption,
     TRouterHistory
-  > = (opts) => preloadClientRoute(this, opts)
+  > = (opts: any, builtLocation?: ParsedLocation) =>
+    preloadClientRoute(this, opts, 0, builtLocation)
 
   matchRoute: MatchRouteFn<
     TRouteTree,
@@ -2797,24 +2772,22 @@ function applySearchMiddleware(
     }
 
     const routeValidateSearch = routeOptions.validateSearch
-    if (routeValidateSearch) {
+    if (includeValidateSearch && routeValidateSearch) {
       const validate: SearchMiddleware<any> = ({ search, next, meta }) => {
         const result = next(search)
-        if (includeValidateSearch) {
-          try {
-            const validated = validateSearch(routeValidateSearch, result) as any
-
-            if (meta && validated) {
-              for (const key in validated) {
-                if (!(key in result)) {
-                  ;(meta.defaulted ||= new Map()).set(key, validated[key])
-                }
+        try {
+          const validated = validateSearch(routeValidateSearch, result) as any
+
+          if (meta && validated) {
+            for (const key in validated) {
+              if (!(key in result)) {
+                ;(meta.defaulted ||= new Map()).set(key, validated[key])
               }
             }
-            return { ...result, ...validated }
-          } catch {
-            // ignore errors here because they are already handled in matchRoutes
           }
+          return { ...result, ...validated }
+        } catch {
+          // ignore errors here because they are already handled in matchRoutes
         }
         return result
       }
@@ -2884,11 +2857,14 @@ function resolveNextParams(
   spec: unknown,
   base: Record<string, unknown>,
 ): Record<string, unknown> {
-  return spec === false || spec === null
-    ? Object.create(null)
-    : (spec ?? true) === true
-      ? base
-      : Object.assign(base, functionalUpdate(spec as any, base))
+  if (spec === false || spec === null) {
+    return Object.create(null)
+  }
+  if ((spec ?? true) === true) {
+    return base
+  }
+  const next = Object.assign(Object.create(null), base)
+  return Object.assign(next, functionalUpdate(spec as any, next))
 }
 
 function extractStrictParams(