@tanstack/router-core 1.128.0 → 1.128.4

package/package.json

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

package/src/path.ts

@@ -7,6 +7,8 @@ export interface Segment {
   value: string
   prefixSegment?: string
   suffixSegment?: string
+  // Indicates if there is a static segment after this required/optional param
+  hasStaticAfter?: boolean
 }
 
 export function joinPaths(paths: Array<string | undefined>) {

package/src/router.ts

@@ -29,6 +29,7 @@ import { setupScrollRestoration } from './scroll-restoration'
 import { defaultParseSearch, defaultStringifySearch } from './searchParams'
 import { rootRouteId } from './root'
 import { isRedirect, redirect } from './redirect'
+import type { Segment } from './path'
 import type { SearchParser, SearchSerializer } from './searchParams'
 import type { AnyRedirect, ResolvedRedirect } from './redirect'
 import type {
@@ -1819,6 +1820,7 @@ export class RouterCore<
     this.__store.setState((s) => ({
       ...s,
       status: 'pending',
+      statusCode: 200,
       isLoading: true,
       location: this.latestLocation,
       pendingMatches,
@@ -3177,6 +3179,27 @@ export type ProcessRouteTreeResult<TRouteLike extends RouteLike> = {
   routesByPath: Record<string, TRouteLike>
   flatRoutes: Array<TRouteLike>
 }
+
+const REQUIRED_PARAM_BASE_SCORE = 0.5
+const OPTIONAL_PARAM_BASE_SCORE = 0.4
+const WILDCARD_PARAM_BASE_SCORE = 0.25
+
+function handleParam(segment: Segment, baseScore: number) {
+  if (segment.prefixSegment && segment.suffixSegment) {
+    return baseScore + 0.05
+  }
+
+  if (segment.prefixSegment) {
+    return baseScore + 0.02
+  }
+
+  if (segment.suffixSegment) {
+    return baseScore + 0.01
+  }
+
+  return baseScore
+}
+
 export function processRouteTree<TRouteLike extends RouteLike>({
   routeTree,
   initRoute,
@@ -3223,9 +3246,11 @@ export function processRouteTree<TRouteLike extends RouteLike>({
   const scoredRoutes: Array<{
     child: TRouteLike
     trimmed: string
-    parsed: ReturnType<typeof parsePathname>
+    parsed: Array<Segment>
     index: number
     scores: Array<number>
+    hasStaticAfter: boolean
+    optionalParamCount: number
   }> = []
 
   const routes: Array<TRouteLike> = Object.values(routesById)
@@ -3243,63 +3268,50 @@ export function processRouteTree<TRouteLike extends RouteLike>({
       parsed.shift()
     }
 
-    const scores = parsed.map((segment) => {
+    let optionalParamCount = 0
+    let hasStaticAfter = false
+    const scores = parsed.map((segment, index) => {
       if (segment.value === '/') {
         return 0.75
       }
 
+      let baseScore: number | undefined = undefined
       if (segment.type === 'param') {
-        if (segment.prefixSegment && segment.suffixSegment) {
-          return 0.55
-        }
-
-        if (segment.prefixSegment) {
-          return 0.52
-        }
-
-        if (segment.suffixSegment) {
-          return 0.51
-        }
-
-        return 0.5
+        baseScore = REQUIRED_PARAM_BASE_SCORE
+      } else if (segment.type === 'optional-param') {
+        baseScore = OPTIONAL_PARAM_BASE_SCORE
+        optionalParamCount++
+      } else if (segment.type === 'wildcard') {
+        baseScore = WILDCARD_PARAM_BASE_SCORE
       }
 
-      if (segment.type === 'optional-param') {
-        if (segment.prefixSegment && segment.suffixSegment) {
-          return 0.45
-        }
-
-        if (segment.prefixSegment) {
-          return 0.42
-        }
-
-        if (segment.suffixSegment) {
-          return 0.41
-        }
-
-        return 0.4
-      }
-
-      if (segment.type === 'wildcard') {
-        if (segment.prefixSegment && segment.suffixSegment) {
-          return 0.3
-        }
-
-        if (segment.prefixSegment) {
-          return 0.27
-        }
-
-        if (segment.suffixSegment) {
-          return 0.26
+      if (baseScore) {
+        // if there is any static segment (that is not an index) after a required / optional param,
+        // we will boost this param so it ranks higher than a required/optional param without a static segment after it
+        // JUST FOR SORTING, NOT FOR MATCHING
+        for (let i = index + 1; i < parsed.length; i++) {
+          const nextSegment = parsed[i]!
+          if (nextSegment.type === 'pathname' && nextSegment.value !== '/') {
+            hasStaticAfter = true
+            return handleParam(segment, baseScore + 0.2)
+          }
         }
 
-        return 0.25
+        return handleParam(segment, baseScore)
       }
 
       return 1
     })
 
-    scoredRoutes.push({ child: d, trimmed, parsed, index: i, scores })
+    scoredRoutes.push({
+      child: d,
+      trimmed,
+      parsed,
+      index: i,
+      scores,
+      optionalParamCount,
+      hasStaticAfter,
+    })
   })
 
   const flatRoutes = scoredRoutes
@@ -3315,17 +3327,16 @@ export function processRouteTree<TRouteLike extends RouteLike>({
 
       // If all common segments have equal scores, then consider length and specificity
       if (a.scores.length !== b.scores.length) {
-        // Count optional parameters in each route
-        const aOptionalCount = a.parsed.filter(
-          (seg) => seg.type === 'optional-param',
-        ).length
-        const bOptionalCount = b.parsed.filter(
-          (seg) => seg.type === 'optional-param',
-        ).length
-
         // If different number of optional parameters, fewer optional parameters wins (more specific)
-        if (aOptionalCount !== bOptionalCount) {
-          return aOptionalCount - bOptionalCount
+        // only if both or none of the routes has static segments after the params
+        if (a.optionalParamCount !== b.optionalParamCount) {
+          if (a.hasStaticAfter === b.hasStaticAfter) {
+            return a.optionalParamCount - b.optionalParamCount
+          } else if (a.hasStaticAfter && !b.hasStaticAfter) {
+            return -1
+          } else if (!a.hasStaticAfter && b.hasStaticAfter) {
+            return 1
+          }
         }
 
         // If same number of optional parameters, longer path wins (for static segments)