@tanstack/router-core 1.132.0-alpha.21 → 1.132.0-alpha.25

package/package.json

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

package/src/path.ts

@@ -154,8 +154,8 @@ export function resolvePath({
   trailingSlash = 'never',
   parseCache,
 }: ResolvePathOptions) {
-  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()
@@ -200,14 +200,26 @@ export function resolvePath({
 }
 
 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
 }
@@ -237,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> = []
@@ -259,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]
@@ -273,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) {
@@ -289,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]
@@ -303,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,
@@ -314,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: '$',
@@ -326,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),
       }
     }),
   )
@@ -370,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]
@@ -515,11 +534,11 @@ export function matchByPath(
   const stringTo = to as string
 
   // Parse the from and to
-  const baseSegments = parsePathname(
+  const baseSegments = parseBasePathSegments(
     from.startsWith('/') ? from : `/${from}`,
     parseCache,
   )
-  const routeSegments = parsePathname(
+  const routeSegments = parseRoutePathSegments(
     stringTo.startsWith('/') ? stringTo : `/${stringTo}`,
     parseCache,
   )

package/src/router.ts

@@ -17,7 +17,7 @@ import {
   cleanPath,
   interpolatePath,
   matchPathname,
-  parsePathname,
+  parseRoutePathSegments,
   resolvePath,
   trimPath,
   trimPathLeft,
@@ -2601,7 +2601,7 @@ export function processRouteTree<TRouteLike extends RouteLike>({
     }
 
     const trimmed = trimPathLeft(d.fullPath)
-    let parsed = parsePathname(trimmed)
+    let parsed = parseRoutePathSegments(trimmed)
 
     // Removes the leading slash if it is not the only remaining segment
     let skip = 0