@tanstack/router-core 1.154.13 → 1.154.14

package/src/router.ts

@@ -56,7 +56,7 @@ import type {
   PickAsRequired,
   Updater,
 } from './utils'
-import type { MatchSnapshot, ParsedLocation } from './location'
+import type { ParsedLocation } from './location'
 import type {
   AnyContext,
   AnyRoute,
@@ -590,14 +590,6 @@ export interface MatchRoutesOpts {
   throwOnError?: boolean
   _buildLocation?: boolean
   dest?: BuildNextOptions
-  /** Optional match snapshot hint for fast-path (skips path matching) */
-  snapshot?: MatchSnapshot
-}
-
-export interface MatchRoutesResult {
-  matches: Array<AnyRouteMatch>
-  /** Raw string params extracted from path (before parsing) */
-  rawParams: Record<string, string>
 }
 
 export type InferRouterContext<TRouteTree extends AnyRoute> =
@@ -710,17 +702,14 @@ export type GetMatchRoutesFn = (pathname: string) => {
   /** exhaustive params, still in their string form */
   routeParams: Record<string, string>
   /** partial params, parsed from routeParams during matching */
-  parsedParams: Record<string, unknown>
+  parsedParams: Record<string, unknown> | undefined
   foundRoute: AnyRoute | undefined
   parseError?: unknown
 }
 
 export type EmitFn = (routerEvent: RouterEvent) => void
 
-export type LoadFn = (opts?: {
-  sync?: boolean
-  _skipUpdateLatestLocation?: boolean
-}) => Promise<void>
+export type LoadFn = (opts?: { sync?: boolean }) => Promise<void>
 
 export type CommitLocationFn = ({
   viewTransition,
@@ -903,6 +892,7 @@ export class RouterCore<
   tempLocationKey: string | undefined = `${Math.round(
     Math.random() * 10000000,
   )}`
+  resetNextScroll = true
   shouldViewTransition?: boolean | ViewTransitionOptions = undefined
   isViewTransitionTypesSupported?: boolean = undefined
   subscribers = new Set<RouterListener<RouterEvent>>()
@@ -927,8 +917,6 @@ export class RouterCore<
   origin?: string
   latestLocation!: ParsedLocation<FullSearchSchema<TRouteTree>>
   pendingBuiltLocation?: ParsedLocation<FullSearchSchema<TRouteTree>>
-  /** Session id for cached history snapshots */
-  private sessionId!: string
   basepath!: string
   routeTree!: TRouteTree
   routesById!: RoutesById<TRouteTree>
@@ -949,11 +937,6 @@ export class RouterCore<
       TDehydrated
     >,
   ) {
-    this.sessionId =
-      typeof crypto !== 'undefined' && 'randomUUID' in crypto
-        ? crypto.randomUUID()
-        : `${Date.now()}-${Math.random().toString(36).slice(2)}`
-
     this.update({
       defaultPreloadDelay: 50,
       defaultPendingMs: 1000,
@@ -1271,70 +1254,42 @@ export class RouterCore<
           search: locationSearchOrOpts,
         } as ParsedLocation,
         opts,
-      ).matches
+      )
     }
 
     return this.matchRoutesInternal(pathnameOrNext, locationSearchOrOpts)
-      .matches
   }
 
   private matchRoutesInternal(
     next: ParsedLocation,
     opts?: MatchRoutesOpts,
-  ): MatchRoutesResult {
-    // Fast-path: use snapshot hint if valid
-    const snapshot = opts?.snapshot
-    const snapshotValid =
-      snapshot &&
-      snapshot.routeIds.length > 0 &&
-      snapshot.routeIds.every((id) => this.routesById[id])
-
-    let matchedRoutes: ReadonlyArray<AnyRoute>
-    let routeParams: Record<string, string>
-    let rawParams: Record<string, string>
-    let globalNotFoundRouteId: string | undefined
-    let parsedParams: Record<string, unknown>
-
-    if (snapshotValid) {
-      // Rebuild matched routes from snapshot
-      matchedRoutes = snapshot.routeIds.map((id) => this.routesById[id]!)
-      routeParams = { ...snapshot.params }
-      rawParams = { ...snapshot.params }
-      globalNotFoundRouteId = snapshot.globalNotFoundRouteId
-      parsedParams = snapshot.parsedParams
-    } else {
-      // Normal path matching
-      const matchedRoutesResult = this.getMatchedRoutes(next.pathname)
-      const { foundRoute, routeParams: rp } = matchedRoutesResult
-      routeParams = rp
-      rawParams = { ...rp } // Capture before routeParams gets modified
-      matchedRoutes = matchedRoutesResult.matchedRoutes
-      parsedParams = matchedRoutesResult.parsedParams
+  ): Array<AnyRouteMatch> {
+    const matchedRoutesResult = this.getMatchedRoutes(next.pathname)
+    const { foundRoute, routeParams, parsedParams } = matchedRoutesResult
+    let { matchedRoutes } = matchedRoutesResult
+    let isGlobalNotFound = false
 
-      let isGlobalNotFound = false
-
-      // Check to see if the route needs a 404 entry
-      if (
-        // If we found a route, and it's not an index route and we have left over path
-        foundRoute
-          ? foundRoute.path !== '/' && routeParams['**']
-          : // Or if we didn't find a route and we have left over path
-            trimPathRight(next.pathname)
-      ) {
-        // If the user has defined an (old) 404 route, use it
-        if (this.options.notFoundRoute) {
-          matchedRoutes = [...matchedRoutes, this.options.notFoundRoute]
-        } else {
-          // If there is no routes found during path matching
-          isGlobalNotFound = true
-        }
+    // Check to see if the route needs a 404 entry
+    if (
+      // If we found a route, and it's not an index route and we have left over path
+      foundRoute
+        ? foundRoute.path !== '/' && routeParams['**']
+        : // Or if we didn't find a route and we have left over path
+          trimPathRight(next.pathname)
+    ) {
+      // If the user has defined an (old) 404 route, use it
+      if (this.options.notFoundRoute) {
+        matchedRoutes = [...matchedRoutes, this.options.notFoundRoute]
+      } else {
+        // If there is no routes found during path matching
+        isGlobalNotFound = true
       }
-
-      globalNotFoundRouteId = isGlobalNotFound
-        ? findGlobalNotFoundRouteId(this.options.notFoundMode, matchedRoutes)
-        : undefined
     }
 
+    const globalNotFoundRouteId = isGlobalNotFound
+      ? findGlobalNotFoundRouteId(this.options.notFoundMode, matchedRoutes)
+      : undefined
+
     const matches: Array<AnyRouteMatch> = []
 
     const getParentContext = (parentMatch?: AnyRouteMatch) => {
@@ -1347,19 +1302,6 @@ export class RouterCore<
       return parentContext
     }
 
-    // Check if we can use cached validated searches from snapshot
-    // Valid if: snapshot exists, searchStr matches, and validatedSearches has correct length
-    const canUseCachedSearch =
-      snapshotValid &&
-      snapshot.searchStr === next.searchStr &&
-      snapshot.validatedSearches?.length === matchedRoutes.length
-
-    // Collect validated searches to cache in snapshot (only when not using cache)
-    const validatedSearchesToCache: Array<{
-      search: Record<string, unknown>
-      strictSearch: Record<string, unknown>
-    }> = []
-
     matchedRoutes.forEach((route, index) => {
       // Take each matched route and resolve + validate its search params
       // This has to happen serially because each route's search params
@@ -1375,12 +1317,6 @@ export class RouterCore<
         Record<string, any>,
         any,
       ] = (() => {
-        // Fast-path: use cached validated search from snapshot
-        if (canUseCachedSearch) {
-          const cached = snapshot.validatedSearches![index]!
-          return [cached.search, cached.strictSearch, undefined]
-        }
-
         // Validate the search params and stabilize them
         const parentSearch = parentMatch?.search ?? next.search
         const parentStrictSearch = parentMatch?._strictSearch ?? undefined
@@ -1414,14 +1350,6 @@ export class RouterCore<
         }
       })()
 
-      // Cache the validated search for future pop navigations
-      if (!canUseCachedSearch) {
-        validatedSearchesToCache.push({
-          search: preMatchSearch,
-          strictSearch: strictMatchSearch,
-        })
-      }
-
       // This is where we need to call route.options.loaderDeps() to get any additional
       // deps that the route's loader function might need to run. We need to do this
       // before we create the match so that we can pass the deps to the route's
@@ -1588,18 +1516,6 @@ export class RouterCore<
       matches.push(match)
     })
 
-    // Cache validated searches in snapshot for future pop navigations
-    // Only update if we computed fresh values (not using cached)
-    if (!canUseCachedSearch && validatedSearchesToCache.length > 0) {
-      const existingSnapshot = next.state?.__TSR_matches as
-        | MatchSnapshot
-        | undefined
-      if (existingSnapshot) {
-        existingSnapshot.searchStr = next.searchStr
-        existingSnapshot.validatedSearches = validatedSearchesToCache
-      }
-    }
-
     matches.forEach((match, index) => {
       const route = this.looseRoutesById[match.routeId]!
       const existingMatch = this.getMatch(match.id)
@@ -1639,7 +1555,7 @@ export class RouterCore<
       }
     })
 
-    return { matches, rawParams }
+    return matches
   }
 
   getMatchedRoutes: GetMatchRoutesFn = (pathname) => {
@@ -1767,7 +1683,6 @@ export class RouterCore<
       // which are expensive and not needed for buildLocation
       const destMatchResult = this.getMatchedRoutes(interpolatedNextTo)
       let destRoutes = destMatchResult.matchedRoutes
-      const rawParams = destMatchResult.routeParams
 
       // Compute globalNotFoundRouteId using the same logic as matchRoutesInternal
       const isGlobalNotFound = destMatchResult.foundRoute
@@ -1867,20 +1782,6 @@ export class RouterCore<
       // Replace the equal deep
       nextState = replaceEqualDeep(currentLocation.state, nextState)
 
-      // Build match snapshot for fast-path on back/forward navigation
-      // Use raw params captured during matchRoutesInternal (needed for literal path navigation
-      // where nextParams may be empty but path contains param values)
-      const snapshotParams = {
-        ...rawParams,
-        ...nextParams,
-      }
-      const matchSnapshot = buildMatchSnapshotFromRoutes({
-        routes: destRoutes,
-        params: snapshotParams,
-        searchStr,
-        globalNotFoundRouteId,
-      })
-
       // Create the full path of the location
       const fullPath = `${nextPathname}${searchStr}${hashStr}`
 
@@ -1890,13 +1791,10 @@ export class RouterCore<
       // If a rewrite function is provided, use it to rewrite the URL
       const rewrittenUrl = executeRewriteOutput(this.rewrite, url)
 
-      // Use encoded URL path for href (consistent with parseLocation)
-      const encodedHref = url.href.replace(url.origin, '')
-
       return {
         publicHref:
           rewrittenUrl.pathname + rewrittenUrl.search + rewrittenUrl.hash,
-        href: encodedHref,
+        href: fullPath,
         url: rewrittenUrl,
         pathname: nextPathname,
         search: nextSearch,
@@ -1904,7 +1802,6 @@ export class RouterCore<
         state: nextState as any,
         hash: hash ?? '',
         unmaskOnReload: dest.unmaskOnReload,
-        _matchSnapshot: matchSnapshot,
       }
     }
 
@@ -2010,105 +1907,65 @@ export class RouterCore<
     // Don't commit to history if nothing changed
     if (isSameUrl && isSameState()) {
       this.load()
-      return this.commitLocationPromise
-    }
-
-    let {
-      // eslint-disable-next-line prefer-const
-      maskedLocation,
-      // eslint-disable-next-line prefer-const
-      hashScrollIntoView,
-      // don't pass url into history since it is a URL instance that cannot be serialized
-      // eslint-disable-next-line prefer-const
-      url: _url,
-      ...nextHistory
-    } = next
-
-    if (maskedLocation) {
-      nextHistory = {
-        ...maskedLocation,
-        state: {
-          ...maskedLocation.state,
-          __tempKey: undefined,
-          __tempLocation: {
-            ...nextHistory,
-            search: nextHistory.searchStr,
-            state: {
-              ...nextHistory.state,
-              __tempKey: undefined!,
-              __tempLocation: undefined!,
-              __TSR_key: undefined!,
-              key: undefined!, // TODO: Remove in v2 - use __TSR_key instead
+    } else {
+      let {
+        // eslint-disable-next-line prefer-const
+        maskedLocation,
+        // eslint-disable-next-line prefer-const
+        hashScrollIntoView,
+        // don't pass url into history since it is a URL instance that cannot be serialized
+        // eslint-disable-next-line prefer-const
+        url: _url,
+        ...nextHistory
+      } = next
+
+      if (maskedLocation) {
+        nextHistory = {
+          ...maskedLocation,
+          state: {
+            ...maskedLocation.state,
+            __tempKey: undefined,
+            __tempLocation: {
+              ...nextHistory,
+              search: nextHistory.searchStr,
+              state: {
+                ...nextHistory.state,
+                __tempKey: undefined!,
+                __tempLocation: undefined!,
+                __TSR_key: undefined!,
+                key: undefined!, // TODO: Remove in v2 - use __TSR_key instead
+              },
             },
           },
-        },
-      }
+        }
 
-      if (nextHistory.unmaskOnReload ?? this.options.unmaskOnReload ?? false) {
-        nextHistory.state.__tempKey = this.tempLocationKey
+        if (
+          nextHistory.unmaskOnReload ??
+          this.options.unmaskOnReload ??
+          false
+        ) {
+          nextHistory.state.__tempKey = this.tempLocationKey
+        }
       }
-    }
-
-    nextHistory.state.__hashScrollIntoViewOptions =
-      hashScrollIntoView ?? this.options.defaultHashScrollIntoView ?? true
-
-    // Store resetScroll in history state so it survives back/forward navigation
-    nextHistory.state.__TSR_resetScroll = next.resetScroll ?? true
 
-    this.shouldViewTransition = viewTransition
+      nextHistory.state.__hashScrollIntoViewOptions =
+        hashScrollIntoView ?? this.options.defaultHashScrollIntoView ?? true
 
-    // Store session id for this router lifetime
-    nextHistory.state.__TSR_sessionId = this.sessionId
+      this.shouldViewTransition = viewTransition
 
-    // Use match snapshot from buildLocation if available, otherwise compute it.
-    // Stored in history state for pop/back/forward fast-path.
-    nextHistory.state.__TSR_matches =
-      next._matchSnapshot ??
-      buildMatchSnapshot({
-        matchResult: this.getMatchedRoutes(next.pathname),
-        pathname: next.pathname,
-        searchStr: next.searchStr,
-        notFoundRoute: this.options.notFoundRoute,
-        notFoundMode: this.options.notFoundMode,
-      })
-
-    // Build the pre-computed ParsedLocation to avoid re-parsing after push
-    // Spread next (which has href, pathname, search, etc.) and override with final state
-    const precomputedLocation: ParsedLocation = {
-      ...next,
-      publicHref: nextHistory.publicHref,
-      state: nextHistory.state,
-      maskedLocation,
+      this.history[next.replace ? 'replace' : 'push'](
+        nextHistory.publicHref,
+        nextHistory.state,
+        { ignoreBlocker },
+      )
     }
 
-    // Await push/replace to handle blockers before proceeding
-    // Pass skipTransitionerLoad so Transitioner doesn't call load() - we handle it below
-    const result = await this.history[next.replace ? 'replace' : 'push'](
-      nextHistory.publicHref,
-      nextHistory.state,
-      { ignoreBlocker, skipTransitionerLoad: true },
-    )
-
-    // If blocked, resolve promise and return
-    if (result.type === 'BLOCKED') {
-      this.commitLocationPromise?.resolve()
-      return this.commitLocationPromise
-    }
+    this.resetNextScroll = next.resetScroll ?? true
 
-    // Check if another navigation has superseded this one while we awaited
-    // If so, let the newer navigation handle things - don't overwrite latestLocation
-    if (this.history.location.href !== nextHistory.publicHref) {
-      return this.commitLocationPromise
+    if (!this.history.subscribers.size) {
+      this.load()
     }
 
-    // Success: set latestLocation directly (we skip updateLatestLocation in load)
-    this.latestLocation = precomputedLocation as unknown as ParsedLocation<
-      FullSearchSchema<TRouteTree>
-    >
-
-    // Call load() with _skipUpdateLatestLocation since we already set latestLocation
-    this.load({ _skipUpdateLatestLocation: true })
-
     return this.commitLocationPromise
   }
 
@@ -2260,14 +2117,10 @@ export class RouterCore<
 
   latestLoadPromise: undefined | Promise<void>
 
-  beforeLoad = (opts?: { _skipUpdateLatestLocation?: boolean }) => {
+  beforeLoad = () => {
     // Cancel any pending matches
     this.cancelMatches()
-    if (!opts?._skipUpdateLatestLocation) {
-      this.updateLatestLocation()
-    } else {
-      // Already have latestLocation from commitLocation, skip parsing
-    }
+    this.updateLatestLocation()
 
     if (this.isServer) {
       // for SPAs on the initial load, this is handled by the Transitioner
@@ -2291,12 +2144,7 @@ export class RouterCore<
     }
 
     // Match the routes
-    // Use snapshot from history state for fast-path only within same router lifetime
-    const snapshot =
-      this.latestLocation.state.__TSR_sessionId === this.sessionId
-        ? this.latestLocation.state.__TSR_matches
-        : undefined
-    const pendingMatches = this.matchRoutes(this.latestLocation, { snapshot })
+    const pendingMatches = this.matchRoutes(this.latestLocation)
 
     // Ingest the new matches
     this.__store.setState((s) => ({
@@ -2313,10 +2161,7 @@ export class RouterCore<
     }))
   }
 
-  load: LoadFn = async (opts?: {
-    sync?: boolean
-    _skipUpdateLatestLocation?: boolean
-  }): Promise<void> => {
+  load: LoadFn = async (opts?: { sync?: boolean }): Promise<void> => {
     let redirect: AnyRedirect | undefined
     let notFound: NotFoundError | undefined
     let loadPromise: Promise<void>
@@ -2325,9 +2170,7 @@ export class RouterCore<
     loadPromise = new Promise<void>((resolve) => {
       this.startTransition(async () => {
         try {
-          this.beforeLoad({
-            _skipUpdateLatestLocation: opts?._skipUpdateLatestLocation,
-          })
+          this.beforeLoad()
           const next = this.latestLocation
           const prevLocation = this.state.resolvedLocation
 
@@ -2935,7 +2778,7 @@ export function getMatchedRoutes<TRouteLike extends RouteLike>({
   const trimmedPath = trimPathRight(pathname)
 
   let foundRoute: TRouteLike | undefined = undefined
-  let parsedParams: Record<string, unknown> = {}
+  let parsedParams: Record<string, unknown> | undefined = undefined
   const match = findRouteMatch<TRouteLike>(trimmedPath, processedTree, true)
   if (match) {
     foundRoute = match.route
@@ -2948,96 +2791,6 @@ export function getMatchedRoutes<TRouteLike extends RouteLike>({
   return { matchedRoutes, routeParams, foundRoute, parsedParams }
 }
 
-/**
- * Build a MatchSnapshot from a getMatchedRoutes result.
- * Determines globalNotFoundRouteId using the same logic as matchRoutesInternal.
- */
-export function buildMatchSnapshot({
-  matchResult,
-  pathname,
-  searchStr,
-  notFoundRoute,
-  notFoundMode,
-}: {
-  matchResult: ReturnType<typeof getMatchedRoutes>
-  pathname: string
-  searchStr?: string
-  notFoundRoute?: AnyRoute
-  notFoundMode?: 'root' | 'fuzzy'
-}): MatchSnapshot {
-  const snapshot: MatchSnapshot = {
-    routeIds: matchResult.matchedRoutes.map((r) => r.id),
-    params: matchResult.routeParams,
-    parsedParams: matchResult.parsedParams,
-    searchStr,
-  }
-
-  const isGlobalNotFound = matchResult.foundRoute
-    ? matchResult.foundRoute.path !== '/' && matchResult.routeParams['**']
-    : trimPathRight(pathname)
-
-  if (isGlobalNotFound) {
-    if (notFoundRoute) {
-      // Custom notFoundRoute provided - use its id
-      snapshot.globalNotFoundRouteId = notFoundRoute.id
-    } else {
-      if (notFoundMode !== 'root') {
-        for (let i = matchResult.matchedRoutes.length - 1; i >= 0; i--) {
-          const route = matchResult.matchedRoutes[i]!
-          if (route.children) {
-            snapshot.globalNotFoundRouteId = route.id
-            break
-          }
-        }
-      }
-      if (!snapshot.globalNotFoundRouteId) {
-        snapshot.globalNotFoundRouteId = rootRouteId
-      }
-    }
-  }
-
-  return snapshot
-}
-
-/**
- * Build a MatchSnapshot from routes and params directly.
- * Used by buildLocation to avoid duplicate getMatchedRoutes call.
- */
-export function buildMatchSnapshotFromRoutes({
-  routes,
-  params,
-  searchStr,
-  globalNotFoundRouteId,
-}: {
-  routes: ReadonlyArray<AnyRoute>
-  params: Record<string, unknown>
-  searchStr?: string
-  globalNotFoundRouteId?: string
-}): MatchSnapshot {
-  // Convert all params to strings for snapshot storage
-  // (params from path matching are always strings)
-  const stringParams: Record<string, string> = {}
-  for (const key in params) {
-    const value = params[key]
-    if (value != null) {
-      stringParams[key] = String(value)
-    }
-  }
-
-  const snapshot: MatchSnapshot = {
-    routeIds: routes.map((r) => r.id),
-    params: stringParams,
-    parsedParams: params,
-    searchStr,
-  }
-
-  if (globalNotFoundRouteId) {
-    snapshot.globalNotFoundRouteId = globalNotFoundRouteId
-  }
-
-  return snapshot
-}
-
 /**
  * TODO: once caches are persisted across requests on the server,
  * we can cache the built middleware chain using `last(destRoutes)` as the key

package/src/scroll-restoration.ts

@@ -340,8 +340,8 @@ export function setupScrollRestoration(router: AnyRouter, force?: boolean) {
 
     // If the user doesn't want to restore the scroll position,
     // we don't need to do anything.
-    const resetScroll = event.toLocation.state.__TSR_resetScroll ?? true
-    if (!resetScroll) {
+    if (!router.resetNextScroll) {
+      router.resetNextScroll = true
       return
     }
     if (typeof router.options.scrollRestoration === 'function') {