@tanstack/router-core 1.154.2 → 1.154.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/router-core",
-  "version": "1.154.2",
+  "version": "1.154.4",
   "description": "Modern and scalable routing for React applications",
   "author": "Tanner Linsley",
   "license": "MIT",

package/src/new-process-route-tree.ts

@@ -846,6 +846,13 @@ function findMatch<T extends RouteLike>(
   }
 }
 
+type ParamExtractionState = {
+  part: number
+  node: number
+  path: number
+  segment: number
+}
+
 /**
  * This function is "resumable":
  * - the `leaf` input can contain `extract` and `rawParams` properties from a previous `extractParams` call
@@ -859,27 +866,42 @@ function extractParams<T extends RouteLike>(
   leaf: {
     node: AnySegmentNode<T>
     skipped: number
-    extract?: { part: number; node: number; path: number }
+    extract?: ParamExtractionState
     rawParams?: Record<string, string>
   },
-): [
-  rawParams: Record<string, string>,
-  state: { part: number; node: number; path: number },
-] {
+): [rawParams: Record<string, string>, state: ParamExtractionState] {
   const list = buildBranch(leaf.node)
   let nodeParts: Array<string> | null = null
   const rawParams: Record<string, string> = {}
+  /** which segment of the path we're currently processing */
   let partIndex = leaf.extract?.part ?? 0
+  /** which node of the route tree branch we're currently processing */
   let nodeIndex = leaf.extract?.node ?? 0
+  /** index of the 1st character of the segment we're processing in the path string */
   let pathIndex = leaf.extract?.path ?? 0
-  for (; nodeIndex < list.length; partIndex++, nodeIndex++, pathIndex++) {
+  /** which fullPath segment we're currently processing */
+  let segmentCount = leaf.extract?.segment ?? 0
+  for (
+    ;
+    nodeIndex < list.length;
+    partIndex++, nodeIndex++, pathIndex++, segmentCount++
+  ) {
     const node = list[nodeIndex]!
+    // index nodes are terminating nodes, nothing to extract, just leave
+    if (node.kind === SEGMENT_TYPE_INDEX) break
+    // pathless nodes do not consume a path segment
+    if (node.kind === SEGMENT_TYPE_PATHLESS) {
+      segmentCount--
+      partIndex--
+      pathIndex--
+      continue
+    }
     const part = parts[partIndex]
     const currentPathIndex = pathIndex
     if (part) pathIndex += part.length
     if (node.kind === SEGMENT_TYPE_PARAM) {
       nodeParts ??= leaf.node.fullPath.split('/')
-      const nodePart = nodeParts[nodeIndex]!
+      const nodePart = nodeParts[segmentCount]!
       const preLength = node.prefix?.length ?? 0
       // we can't rely on the presence of prefix/suffix to know whether it's curly-braced or not, because `/{$param}/` is valid, but has no prefix/suffix
       const isCurlyBraced = nodePart.charCodeAt(preLength) === 123 // '{'
@@ -903,7 +925,7 @@ function extractParams<T extends RouteLike>(
         continue
       }
       nodeParts ??= leaf.node.fullPath.split('/')
-      const nodePart = nodeParts[nodeIndex]!
+      const nodePart = nodeParts[segmentCount]!
       const preLength = node.prefix?.length ?? 0
       const sufLength = node.suffix?.length ?? 0
       const name = nodePart.substring(
@@ -929,7 +951,15 @@ function extractParams<T extends RouteLike>(
     }
   }
   if (leaf.rawParams) Object.assign(rawParams, leaf.rawParams)
-  return [rawParams, { part: partIndex, node: nodeIndex, path: pathIndex }]
+  return [
+    rawParams,
+    {
+      part: partIndex,
+      node: nodeIndex,
+      path: pathIndex,
+      segment: segmentCount,
+    },
+  ]
 }
 
 function buildRouteBranch<T extends RouteLike>(route: T) {
@@ -968,7 +998,7 @@ type MatchStackFrame<T extends RouteLike> = {
   dynamics: number
   optionals: number
   /** intermediary state for param extraction */
-  extract?: { part: number; node: number; path: number }
+  extract?: ParamExtractionState
   /** intermediary params from param extraction */
   rawParams?: Record<string, string>
   parsedParams?: Record<string, unknown>

package/src/router.ts

@@ -594,6 +594,12 @@ export interface MatchRoutesOpts {
   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> =
   TRouteTree['types']['routerContext']
 
@@ -1265,16 +1271,17 @@ export class RouterCore<
           search: locationSearchOrOpts,
         } as ParsedLocation,
         opts,
-      )
+      ).matches
     }
 
     return this.matchRoutesInternal(pathnameOrNext, locationSearchOrOpts)
+      .matches
   }
 
   private matchRoutesInternal(
     next: ParsedLocation,
     opts?: MatchRoutesOpts,
-  ): Array<AnyRouteMatch> {
+  ): MatchRoutesResult {
     // Fast-path: use snapshot hint if valid
     const snapshot = opts?.snapshot
     const snapshotValid =
@@ -1284,6 +1291,7 @@ export class RouterCore<
 
     let matchedRoutes: ReadonlyArray<AnyRoute>
     let routeParams: Record<string, string>
+    let rawParams: Record<string, string>
     let globalNotFoundRouteId: string | undefined
     let parsedParams: Record<string, unknown>
 
@@ -1291,6 +1299,7 @@ export class RouterCore<
       // 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 {
@@ -1298,6 +1307,7 @@ export class RouterCore<
       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
 
@@ -1642,7 +1652,7 @@ export class RouterCore<
       }
     })
 
-    return matches
+    return { matches, rawParams }
   }
 
   getMatchedRoutes: GetMatchRoutesFn = (pathname) => {
@@ -1765,9 +1775,10 @@ export class RouterCore<
         params: nextParams,
       }).interpolatedPath
 
-      const destMatches = this.matchRoutes(interpolatedNextTo, undefined, {
-        _buildLocation: true,
-      })
+      const { matches: destMatches, rawParams } = this.matchRoutesInternal(
+        { pathname: interpolatedNextTo } as ParsedLocation,
+        { _buildLocation: true },
+      )
       const destRoutes = destMatches.map(
         (d) => this.looseRoutesById[d.routeId]!,
       )
@@ -1856,10 +1867,15 @@ export class RouterCore<
       nextState = replaceEqualDeep(currentLocation.state, nextState)
 
       // Build match snapshot for fast-path on back/forward navigation
-      // Use destRoutes and nextParams directly (after stringify)
+      // 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: nextParams,
+        params: snapshotParams,
         searchStr,
         globalNotFoundRouteId: globalNotFoundMatch?.routeId,
       })