@tanstack/router-core 1.128.4 → 1.128.7

package/src/router.ts

@@ -14,6 +14,10 @@ import {
   replaceEqualDeep,
 } from './utils'
 import {
+  SEGMENT_TYPE_OPTIONAL_PARAM,
+  SEGMENT_TYPE_PARAM,
+  SEGMENT_TYPE_PATHNAME,
+  SEGMENT_TYPE_WILDCARD,
   cleanPath,
   interpolatePath,
   joinPaths,
@@ -3246,7 +3250,7 @@ export function processRouteTree<TRouteLike extends RouteLike>({
   const scoredRoutes: Array<{
     child: TRouteLike
     trimmed: string
-    parsed: Array<Segment>
+    parsed: ReadonlyArray<Segment>
     index: number
     scores: Array<number>
     hasStaticAfter: boolean
@@ -3261,12 +3265,14 @@ export function processRouteTree<TRouteLike extends RouteLike>({
     }
 
     const trimmed = trimPathLeft(d.fullPath)
-    const parsed = parsePathname(trimmed)
+    let parsed = parsePathname(trimmed)
 
     // Removes the leading slash if it is not the only remaining segment
-    while (parsed.length > 1 && parsed[0]?.value === '/') {
-      parsed.shift()
+    let skip = 0
+    while (parsed.length > skip + 1 && parsed[skip]?.value === '/') {
+      skip++
     }
+    if (skip > 0) parsed = parsed.slice(skip)
 
     let optionalParamCount = 0
     let hasStaticAfter = false
@@ -3276,12 +3282,12 @@ export function processRouteTree<TRouteLike extends RouteLike>({
       }
 
       let baseScore: number | undefined = undefined
-      if (segment.type === 'param') {
+      if (segment.type === SEGMENT_TYPE_PARAM) {
         baseScore = REQUIRED_PARAM_BASE_SCORE
-      } else if (segment.type === 'optional-param') {
+      } else if (segment.type === SEGMENT_TYPE_OPTIONAL_PARAM) {
         baseScore = OPTIONAL_PARAM_BASE_SCORE
         optionalParamCount++
-      } else if (segment.type === 'wildcard') {
+      } else if (segment.type === SEGMENT_TYPE_WILDCARD) {
         baseScore = WILDCARD_PARAM_BASE_SCORE
       }
 
@@ -3291,7 +3297,10 @@ export function processRouteTree<TRouteLike extends RouteLike>({
         // 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 !== '/') {
+          if (
+            nextSegment.type === SEGMENT_TYPE_PATHNAME &&
+            nextSegment.value !== '/'
+          ) {
             hasStaticAfter = true
             return handleParam(segment, baseScore + 0.2)
           }
@@ -3384,7 +3393,8 @@ export function getMatchedRoutes<TRouteLike extends RouteLike>({
     const result = matchPathname(basepath, trimmedPath, {
       to: route.fullPath,
       caseSensitive: route.options?.caseSensitive ?? caseSensitive,
-      fuzzy: false,
+      // we need fuzzy matching for `notFoundMode: 'fuzzy'`
+      fuzzy: true,
     })
     return result
   }
@@ -3394,16 +3404,34 @@ export function getMatchedRoutes<TRouteLike extends RouteLike>({
   if (foundRoute) {
     routeParams = getMatchedParams(foundRoute)!
   } else {
-    foundRoute = flatRoutes.find((route) => {
+    // iterate over flatRoutes to find the best match
+    // if we find a fuzzy matching route, keep looking for a perfect fit
+    let fuzzyMatch:
+      | { foundRoute: TRouteLike; routeParams: Record<string, string> }
+      | undefined = undefined
+    for (const route of flatRoutes) {
       const matchedParams = getMatchedParams(route)
 
       if (matchedParams) {
-        routeParams = matchedParams
-        return true
+        if (
+          route.path !== '/' &&
+          (matchedParams as Record<string, string>)['**']
+        ) {
+          if (!fuzzyMatch) {
+            fuzzyMatch = { foundRoute: route, routeParams: matchedParams }
+          }
+        } else {
+          foundRoute = route
+          routeParams = matchedParams
+          break
+        }
       }
-
-      return false
-    })
+    }
+    // did not find a perfect fit, so take the fuzzy matching route if it exists
+    if (!foundRoute && fuzzyMatch) {
+      foundRoute = fuzzyMatch.foundRoute
+      routeParams = fuzzyMatch.routeParams
+    }
   }
 
   let routeCursor: TRouteLike = foundRoute || routesById[rootRouteId]!
@@ -3412,8 +3440,9 @@ export function getMatchedRoutes<TRouteLike extends RouteLike>({
 
   while (routeCursor.parentRoute) {
     routeCursor = routeCursor.parentRoute as TRouteLike
-    matchedRoutes.unshift(routeCursor)
+    matchedRoutes.push(routeCursor)
   }
+  matchedRoutes.reverse()
 
   return { matchedRoutes, routeParams, foundRoute }
 }