@tanstack/router-core 1.132.0-alpha.4 → 1.132.0

package/src/path.ts

@@ -97,11 +97,9 @@ export function exactPathTest(
 // /a/b/c + d/ = /a/b/c/d
 // /a/b/c + d/e = /a/b/c/d/e
 interface ResolvePathOptions {
-  basepath: string
   base: string
   to: string
   trailingSlash?: 'always' | 'never' | 'preserve'
-  caseSensitive?: boolean
   parseCache?: ParsePathnameCache
 }
 
@@ -151,18 +149,13 @@ function segmentToString(segment: Segment): string {
 }
 
 export function resolvePath({
-  basepath,
   base,
   to,
   trailingSlash = 'never',
-  caseSensitive,
   parseCache,
 }: ResolvePathOptions) {
-  base = removeBasepath(basepath, base, caseSensitive)
-  to = removeBasepath(basepath, to, caseSensitive)
-
-  let baseSegments = parsePathname(base, parseCache).slice()
-  const toSegments = parsePathname(to, parseCache)
+  let baseSegments = parseBasePathSegments(base, parseCache).slice()
+  const toSegments = parseRoutePathSegments(to, parseCache)
 
   if (baseSegments.length > 1 && last(baseSegments)?.value === '/') {
     baseSegments.pop()
@@ -201,19 +194,32 @@ export function resolvePath({
   }
 
   const segmentValues = baseSegments.map(segmentToString)
-  const joined = joinPaths([basepath, ...segmentValues])
+  // const joined = joinPaths([basepath, ...segmentValues])
+  const joined = joinPaths(segmentValues)
   return joined
 }
 
 export type ParsePathnameCache = LRUCache<string, ReadonlyArray<Segment>>
+
+export const parseBasePathSegments = (
+  pathname?: string,
+  cache?: ParsePathnameCache,
+): ReadonlyArray<Segment> => parsePathname(pathname, cache, true)
+
+export const parseRoutePathSegments = (
+  pathname?: string,
+  cache?: ParsePathnameCache,
+): ReadonlyArray<Segment> => parsePathname(pathname, cache, false)
+
 export const parsePathname = (
   pathname?: string,
   cache?: ParsePathnameCache,
+  basePathValues?: boolean,
 ): ReadonlyArray<Segment> => {
   if (!pathname) return []
   const cached = cache?.get(pathname)
   if (cached) return cached
-  const parsed = baseParsePathname(pathname)
+  const parsed = baseParsePathname(pathname, basePathValues)
   cache?.set(pathname, parsed)
   return parsed
 }
@@ -243,7 +249,10 @@ const WILDCARD_W_CURLY_BRACES_RE = /^(.*?)\{\$\}(.*)$/ // prefix{$}suffix
  * - `/foo/[$]{$foo} - Dynamic route with a static prefix of `$`
  * - `/foo/{$foo}[$]` - Dynamic route with a static suffix of `$`
  */
-function baseParsePathname(pathname: string): ReadonlyArray<Segment> {
+function baseParsePathname(
+  pathname: string,
+  basePathValues?: boolean,
+): ReadonlyArray<Segment> {
   pathname = cleanPath(pathname)
 
   const segments: Array<Segment> = []
@@ -265,8 +274,12 @@ function baseParsePathname(pathname: string): ReadonlyArray<Segment> {
 
   segments.push(
     ...split.map((part): Segment => {
+      // strip tailing underscore for non-nested paths
+      const partToMatch =
+        !basePathValues && part.slice(-1) === '_' ? part.slice(0, -1) : part
+
       // Check for wildcard with curly braces: prefix{$}suffix
-      const wildcardBracesMatch = part.match(WILDCARD_W_CURLY_BRACES_RE)
+      const wildcardBracesMatch = partToMatch.match(WILDCARD_W_CURLY_BRACES_RE)
       if (wildcardBracesMatch) {
         const prefix = wildcardBracesMatch[1]
         const suffix = wildcardBracesMatch[2]
@@ -279,7 +292,7 @@ function baseParsePathname(pathname: string): ReadonlyArray<Segment> {
       }
 
       // Check for optional parameter format: prefix{-$paramName}suffix
-      const optionalParamBracesMatch = part.match(
+      const optionalParamBracesMatch = partToMatch.match(
         OPTIONAL_PARAM_W_CURLY_BRACES_RE,
       )
       if (optionalParamBracesMatch) {
@@ -295,7 +308,7 @@ function baseParsePathname(pathname: string): ReadonlyArray<Segment> {
       }
 
       // Check for the new parameter format: prefix{$paramName}suffix
-      const paramBracesMatch = part.match(PARAM_W_CURLY_BRACES_RE)
+      const paramBracesMatch = partToMatch.match(PARAM_W_CURLY_BRACES_RE)
       if (paramBracesMatch) {
         const prefix = paramBracesMatch[1]
         const paramName = paramBracesMatch[2]
@@ -309,8 +322,8 @@ function baseParsePathname(pathname: string): ReadonlyArray<Segment> {
       }
 
       // Check for bare parameter format: $paramName (without curly braces)
-      if (PARAM_RE.test(part)) {
-        const paramName = part.substring(1)
+      if (PARAM_RE.test(partToMatch)) {
+        const paramName = partToMatch.substring(1)
         return {
           type: SEGMENT_TYPE_PARAM,
           value: '$' + paramName,
@@ -320,7 +333,7 @@ function baseParsePathname(pathname: string): ReadonlyArray<Segment> {
       }
 
       // Check for bare wildcard: $ (without curly braces)
-      if (WILDCARD_RE.test(part)) {
+      if (WILDCARD_RE.test(partToMatch)) {
         return {
           type: SEGMENT_TYPE_WILDCARD,
           value: '$',
@@ -332,12 +345,12 @@ function baseParsePathname(pathname: string): ReadonlyArray<Segment> {
       // Handle regular pathname segment
       return {
         type: SEGMENT_TYPE_PATHNAME,
-        value: part.includes('%25')
-          ? part
+        value: partToMatch.includes('%25')
+          ? partToMatch
               .split('%25')
               .map((segment) => decodeURI(segment))
               .join('%25')
-          : decodeURI(part),
+          : decodeURI(partToMatch),
       }
     }),
   )
@@ -376,7 +389,7 @@ export function interpolatePath({
   decodeCharMap,
   parseCache,
 }: InterpolatePathOptions): InterPolatePathResult {
-  const interpolatedPathSegments = parsePathname(path, parseCache)
+  const interpolatedPathSegments = parseRoutePathSegments(path, parseCache)
 
   function encodeParam(key: string): any {
     const value = params[key]
@@ -403,6 +416,10 @@ export function interpolatePath({
 
       if (segment.type === SEGMENT_TYPE_WILDCARD) {
         usedParams._splat = params._splat
+
+        // TODO: Deprecate *
+        usedParams['*'] = params._splat
+
         const segmentPrefix = segment.prefixSegment || ''
         const segmentSuffix = segment.suffixSegment || ''
 
@@ -491,17 +508,11 @@ function encodePathParam(value: string, decodeCharMap?: Map<string, string>) {
 }
 
 export function matchPathname(
-  basepath: string,
   currentPathname: string,
   matchLocation: Pick<MatchLocation, 'to' | 'fuzzy' | 'caseSensitive'>,
   parseCache?: ParsePathnameCache,
 ): AnyPathParams | undefined {
-  const pathParams = matchByPath(
-    basepath,
-    currentPathname,
-    matchLocation,
-    parseCache,
-  )
+  const pathParams = matchByPath(currentPathname, matchLocation, parseCache)
   // const searchMatched = matchBySearch(location.search, matchLocation)
 
   if (matchLocation.to && !pathParams) {
@@ -511,49 +522,7 @@ export function matchPathname(
   return pathParams ?? {}
 }
 
-export function removeBasepath(
-  basepath: string,
-  pathname: string,
-  caseSensitive: boolean = false,
-) {
-  // normalize basepath and pathname for case-insensitive comparison if needed
-  const normalizedBasepath = caseSensitive ? basepath : basepath.toLowerCase()
-  const normalizedPathname = caseSensitive ? pathname : pathname.toLowerCase()
-
-  switch (true) {
-    // default behaviour is to serve app from the root - pathname
-    // left untouched
-    case normalizedBasepath === '/':
-      return pathname
-
-    // shortcut for removing the basepath if it matches the pathname
-    case normalizedPathname === normalizedBasepath:
-      return ''
-
-    // in case pathname is shorter than basepath - there is
-    // nothing to remove
-    case pathname.length < basepath.length:
-      return pathname
-
-    // avoid matching partial segments - strict equality handled
-    // earlier, otherwise, basepath separated from pathname with
-    // separator, therefore lack of separator means partial
-    // segment match (`/app` should not match `/application`)
-    case normalizedPathname[normalizedBasepath.length] !== '/':
-      return pathname
-
-    // remove the basepath from the pathname if it starts with it
-    case normalizedPathname.startsWith(normalizedBasepath):
-      return pathname.slice(basepath.length)
-
-    // otherwise, return the pathname as is
-    default:
-      return pathname
-  }
-}
-
 export function matchByPath(
-  basepath: string,
   from: string,
   {
     to,
@@ -562,22 +531,15 @@ export function matchByPath(
   }: Pick<MatchLocation, 'to' | 'caseSensitive' | 'fuzzy'>,
   parseCache?: ParsePathnameCache,
 ): Record<string, string> | undefined {
-  // check basepath first
-  if (basepath !== '/' && !from.startsWith(basepath)) {
-    return undefined
-  }
-  // Remove the base path from the pathname
-  from = removeBasepath(basepath, from, caseSensitive)
-  // Default to to $ (wildcard)
-  to = removeBasepath(basepath, `${to ?? '$'}`, caseSensitive)
+  const stringTo = to as string
 
   // Parse the from and to
-  const baseSegments = parsePathname(
+  const baseSegments = parseBasePathSegments(
     from.startsWith('/') ? from : `/${from}`,
     parseCache,
   )
-  const routeSegments = parsePathname(
-    to.startsWith('/') ? to : `/${to}`,
+  const routeSegments = parseRoutePathSegments(
+    stringTo.startsWith('/') ? stringTo : `/${stringTo}`,
     parseCache,
   )
 

package/src/process-route-tree.ts

@@ -0,0 +1,233 @@
+import invariant from 'tiny-invariant'
+import {
+  SEGMENT_TYPE_OPTIONAL_PARAM,
+  SEGMENT_TYPE_PARAM,
+  SEGMENT_TYPE_PATHNAME,
+  parseRoutePathSegments,
+  trimPathLeft,
+  trimPathRight,
+} from './path'
+import type { Segment } from './path'
+import type { RouteLike } from './route'
+
+const SLASH_SCORE = 0.75
+const STATIC_SEGMENT_SCORE = 1
+const REQUIRED_PARAM_BASE_SCORE = 0.5
+const OPTIONAL_PARAM_BASE_SCORE = 0.4
+const WILDCARD_PARAM_BASE_SCORE = 0.25
+const STATIC_AFTER_DYNAMIC_BONUS_SCORE = 0.2
+const BOTH_PRESENCE_BASE_SCORE = 0.05
+const PREFIX_PRESENCE_BASE_SCORE = 0.02
+const SUFFIX_PRESENCE_BASE_SCORE = 0.01
+const PREFIX_LENGTH_SCORE_MULTIPLIER = 0.0002
+const SUFFIX_LENGTH_SCORE_MULTIPLIER = 0.0001
+
+function handleParam(segment: Segment, baseScore: number) {
+  if (segment.prefixSegment && segment.suffixSegment) {
+    return (
+      baseScore +
+      BOTH_PRESENCE_BASE_SCORE +
+      PREFIX_LENGTH_SCORE_MULTIPLIER * segment.prefixSegment.length +
+      SUFFIX_LENGTH_SCORE_MULTIPLIER * segment.suffixSegment.length
+    )
+  }
+
+  if (segment.prefixSegment) {
+    return (
+      baseScore +
+      PREFIX_PRESENCE_BASE_SCORE +
+      PREFIX_LENGTH_SCORE_MULTIPLIER * segment.prefixSegment.length
+    )
+  }
+
+  if (segment.suffixSegment) {
+    return (
+      baseScore +
+      SUFFIX_PRESENCE_BASE_SCORE +
+      SUFFIX_LENGTH_SCORE_MULTIPLIER * segment.suffixSegment.length
+    )
+  }
+
+  return baseScore
+}
+
+function sortRoutes<TRouteLike extends RouteLike>(
+  routes: ReadonlyArray<TRouteLike>,
+): Array<TRouteLike> {
+  const scoredRoutes: Array<{
+    child: TRouteLike
+    trimmed: string
+    parsed: ReadonlyArray<Segment>
+    index: number
+    scores: Array<number>
+    hasStaticAfter: boolean
+    optionalParamCount: number
+  }> = []
+
+  routes.forEach((d, i) => {
+    if (d.isRoot || !d.path) {
+      return
+    }
+
+    const trimmed = trimPathLeft(d.fullPath)
+    let parsed = parseRoutePathSegments(trimmed)
+
+    // Removes the leading slash if it is not the only remaining segment
+    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
+    const scores = parsed.map((segment, index) => {
+      if (segment.value === '/') {
+        return SLASH_SCORE
+      }
+
+      if (segment.type === SEGMENT_TYPE_PATHNAME) {
+        return STATIC_SEGMENT_SCORE
+      }
+
+      let baseScore: number | undefined = undefined
+      if (segment.type === SEGMENT_TYPE_PARAM) {
+        baseScore = REQUIRED_PARAM_BASE_SCORE
+      } else if (segment.type === SEGMENT_TYPE_OPTIONAL_PARAM) {
+        baseScore = OPTIONAL_PARAM_BASE_SCORE
+        optionalParamCount++
+      } else {
+        baseScore = WILDCARD_PARAM_BASE_SCORE
+      }
+
+      // 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 === SEGMENT_TYPE_PATHNAME &&
+          nextSegment.value !== '/'
+        ) {
+          hasStaticAfter = true
+          return handleParam(
+            segment,
+            baseScore + STATIC_AFTER_DYNAMIC_BONUS_SCORE,
+          )
+        }
+      }
+
+      return handleParam(segment, baseScore)
+    })
+
+    scoredRoutes.push({
+      child: d,
+      trimmed,
+      parsed,
+      index: i,
+      scores,
+      optionalParamCount,
+      hasStaticAfter,
+    })
+  })
+
+  const flatRoutes = scoredRoutes
+    .sort((a, b) => {
+      const minLength = Math.min(a.scores.length, b.scores.length)
+
+      // Sort by segment-by-segment score comparison ONLY for the common prefix
+      for (let i = 0; i < minLength; i++) {
+        if (a.scores[i] !== b.scores[i]) {
+          return b.scores[i]! - a.scores[i]!
+        }
+      }
+
+      // If all common segments have equal scores, then consider length and specificity
+      if (a.scores.length !== b.scores.length) {
+        // If different number of optional parameters, fewer optional parameters wins (more specific)
+        // 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)
+        return b.scores.length - a.scores.length
+      }
+
+      // Sort by min available parsed value for alphabetical ordering
+      for (let i = 0; i < minLength; i++) {
+        if (a.parsed[i]!.value !== b.parsed[i]!.value) {
+          return a.parsed[i]!.value > b.parsed[i]!.value ? 1 : -1
+        }
+      }
+
+      // Sort by original index
+      return a.index - b.index
+    })
+    .map((d, i) => {
+      d.child.rank = i
+      return d.child
+    })
+
+  return flatRoutes
+}
+
+export type ProcessRouteTreeResult<TRouteLike extends RouteLike> = {
+  routesById: Record<string, TRouteLike>
+  routesByPath: Record<string, TRouteLike>
+  flatRoutes: Array<TRouteLike>
+}
+
+export function processRouteTree<TRouteLike extends RouteLike>({
+  routeTree,
+  initRoute,
+}: {
+  routeTree: TRouteLike
+  initRoute?: (route: TRouteLike, index: number) => void
+}): ProcessRouteTreeResult<TRouteLike> {
+  const routesById = {} as Record<string, TRouteLike>
+  const routesByPath = {} as Record<string, TRouteLike>
+
+  const recurseRoutes = (childRoutes: Array<TRouteLike>) => {
+    childRoutes.forEach((childRoute, i) => {
+      initRoute?.(childRoute, i)
+
+      const existingRoute = routesById[childRoute.id]
+
+      invariant(
+        !existingRoute,
+        `Duplicate routes found with id: ${String(childRoute.id)}`,
+      )
+
+      routesById[childRoute.id] = childRoute
+
+      if (!childRoute.isRoot && childRoute.path) {
+        const trimmedFullPath = trimPathRight(childRoute.fullPath)
+        if (
+          !routesByPath[trimmedFullPath] ||
+          childRoute.fullPath.endsWith('/')
+        ) {
+          routesByPath[trimmedFullPath] = childRoute
+        }
+      }
+
+      const children = childRoute.children as Array<TRouteLike>
+
+      if (children?.length) {
+        recurseRoutes(children)
+      }
+    })
+  }
+
+  recurseRoutes([routeTree])
+
+  const flatRoutes = sortRoutes(Object.values(routesById))
+
+  return { routesById, routesByPath, flatRoutes }
+}

package/src/redirect.ts

@@ -72,7 +72,7 @@ export function redirect<
     } catch {}
   }
 
-  const headers = new Headers(opts.headers || {})
+  const headers = new Headers(opts.headers)
   if (opts.href && headers.get('Location') === null) {
     headers.set('Location', opts.href)
   }

package/src/rewrite.ts

@@ -0,0 +1,70 @@
+import { joinPaths, trimPath } from './path'
+import type { LocationRewrite } from './router'
+
+export function composeRewrites(rewrites: Array<LocationRewrite>) {
+  return {
+    input: ({ url }) => {
+      for (const rewrite of rewrites) {
+        url = executeRewriteInput(rewrite, url)
+      }
+      return url
+    },
+    output: ({ url }) => {
+      for (let i = rewrites.length - 1; i >= 0; i--) {
+        url = executeRewriteOutput(rewrites[i], url)
+      }
+      return url
+    },
+  } satisfies LocationRewrite
+}
+
+export function rewriteBasepath(opts: {
+  basepath: string
+  caseSensitive?: boolean
+}) {
+  const trimmedBasepath = trimPath(opts.basepath)
+  const regex = new RegExp(
+    `^/${trimmedBasepath}/`,
+    opts.caseSensitive ? '' : 'i',
+  )
+  return {
+    input: ({ url }) => {
+      url.pathname = url.pathname.replace(regex, '/')
+      return url
+    },
+    output: ({ url }) => {
+      url.pathname = joinPaths(['/', trimmedBasepath, url.pathname])
+      return url
+    },
+  } satisfies LocationRewrite
+}
+
+export function executeRewriteInput(
+  rewrite: LocationRewrite | undefined,
+  url: URL,
+): URL {
+  const res = rewrite?.input?.({ url })
+  if (res) {
+    if (typeof res === 'string') {
+      return new URL(res)
+    } else if (res instanceof URL) {
+      return res
+    }
+  }
+  return url
+}
+
+export function executeRewriteOutput(
+  rewrite: LocationRewrite | undefined,
+  url: URL,
+): URL {
+  const res = rewrite?.output?.({ url })
+  if (res) {
+    if (typeof res === 'string') {
+      return new URL(res)
+    } else if (res instanceof URL) {
+      return res
+    }
+  }
+  return url
+}