@tanstack/router-core 1.157.7 → 1.157.9

package/package.json

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

package/src/path.ts

@@ -1,3 +1,4 @@
+import { isServer } from '@tanstack/router-core/isServer'
 import { last } from './utils'
 import {
   SEGMENT_TYPE_OPTIONAL_PARAM,
@@ -224,6 +225,11 @@ interface InterpolatePathOptions {
    * Obtained from `compileDecodeCharMap(pathParamsAllowedCharacters)`.
    */
   decoder?: (encoded: string) => string
+  /**
+   * @internal
+   * For testing only, in development mode we use the router.isServer value
+   */
+  server?: boolean
 }
 
 type InterPolatePathResult = {
@@ -258,6 +264,7 @@ export function interpolatePath({
   path,
   params,
   decoder,
+  server,
 }: InterpolatePathOptions): InterPolatePathResult {
   // Tracking if any params are missing in the `params` object
   // when interpolating the path
@@ -269,6 +276,65 @@ export function interpolatePath({
   if (!path.includes('$'))
     return { interpolatedPath: path, usedParams, isMissingParams }
 
+  if (isServer ?? server) {
+    // Fast path for common templates like `/posts/$id` or `/files/$`.
+    // Braced segments (`{...}`) are more complex (prefix/suffix/optional) and are
+    // handled by the general parser below.
+    if (path.indexOf('{') === -1) {
+      const length = path.length
+      let cursor = 0
+      let joined = ''
+
+      while (cursor < length) {
+        // Skip slashes between segments. '/' code is 47
+        while (cursor < length && path.charCodeAt(cursor) === 47) cursor++
+        if (cursor >= length) break
+
+        const start = cursor
+        let end = path.indexOf('/', cursor)
+        if (end === -1) end = length
+        cursor = end
+
+        const part = path.substring(start, end)
+        if (!part) continue
+
+        // `$id` or `$` (splat). '$' code is 36
+        if (part.charCodeAt(0) === 36) {
+          if (part.length === 1) {
+            const splat = params._splat
+            usedParams._splat = splat
+            // TODO: Deprecate *
+            usedParams['*'] = splat
+
+            if (!splat) {
+              isMissingParams = true
+              continue
+            }
+
+            const value = encodeParam('_splat', params, decoder)
+            joined += '/' + value
+          } else {
+            const key = part.substring(1)
+            if (!isMissingParams && !(key in params)) {
+              isMissingParams = true
+            }
+            usedParams[key] = params[key]
+
+            const value = encodeParam(key, params, decoder) ?? 'undefined'
+            joined += '/' + value
+          }
+        } else {
+          joined += '/' + part
+        }
+      }
+
+      if (path.endsWith('/')) joined += '/'
+
+      const interpolatedPath = joined || '/'
+      return { usedParams, interpolatedPath, isMissingParams }
+    }
+  }
+
   const length = path.length
   let cursor = 0
   let segment

package/src/router.ts

@@ -1440,6 +1440,7 @@ export class RouterCore<
         path: route.fullPath,
         params: routeParams,
         decoder: this.pathParamsDecoder,
+        server: this.isServer,
       })
 
       // Waste not, want not. If we already have a match for this route,
@@ -1804,6 +1805,8 @@ export class RouterCore<
       const interpolatedNextTo = interpolatePath({
         path: nextTo,
         params: nextParams,
+        decoder: this.pathParamsDecoder,
+        server: this.isServer,
       }).interpolatedPath
 
       // Use lightweight getMatchedRoutes instead of matchRoutesInternal
@@ -1831,11 +1834,13 @@ export class RouterCore<
       }
 
       // If there are any params, we need to stringify them
+      let changedParams = false
       if (Object.keys(nextParams).length > 0) {
         for (const route of destRoutes) {
           const fn =
             route.options.params?.stringify ?? route.options.stringifyParams
           if (fn) {
+            changedParams = true
             Object.assign(nextParams, fn(nextParams))
           }
         }
@@ -1846,11 +1851,14 @@ export class RouterCore<
           // This preserves the original parameter syntax including optional parameters
           nextTo
         : decodePath(
-            interpolatePath({
-              path: nextTo,
-              params: nextParams,
-              decoder: this.pathParamsDecoder,
-            }).interpolatedPath,
+            !changedParams
+              ? interpolatedNextTo
+              : interpolatePath({
+                  path: nextTo,
+                  params: nextParams,
+                  decoder: this.pathParamsDecoder,
+                  server: this.isServer,
+                }).interpolatedPath,
           )
 
       // Resolve the next search