@tanstack/router-generator 1.167.1 → 1.167.3

package/src/generator.ts

@@ -17,6 +17,8 @@ import {
   buildRouteTreeConfig,
   checkFileExists,
   checkRouteFullPathUniqueness,
+  countRoutePathSegments,
+  countSlashSeparatedParts,
   createRouteNodesByFullPath,
   createRouteNodesById,
   createRouteNodesByTo,
@@ -33,9 +35,8 @@ import {
   removeExt,
   removeGroups,
   removeLastSegmentFromPath,
-  removeLayoutSegmentsWithEscape,
+  removeLayoutSegmentsAndUnderscoresWithEscape,
   removeTrailingSlash,
-  removeUnderscoresWithEscape,
   replaceBackslash,
   trimPathLeft,
 } from './utils'
@@ -51,6 +52,7 @@ import type {
   HandleNodeAccumulator,
   ImportDeclaration,
   RouteNode,
+  RoutePathSegmentMetadata,
 } from './types'
 import type { Config } from './config'
 import type { Logger } from './logger'
@@ -70,6 +72,32 @@ interface fs {
   chown: (filePath: string, uid: number, gid: number) => Promise<void>
 }
 
+function getRoutePathSegmentMetadataForPath(
+  node: RouteNode,
+  routePath: string,
+  parentRoutePath?: string,
+): Array<RoutePathSegmentMetadata | undefined> | undefined {
+  if (!node._routePathSegmentMetadata) return undefined
+
+  const segments = routePath.split('/')
+  const result = new Array<RoutePathSegmentMetadata | undefined>(
+    segments.length,
+  )
+  const parentSegmentCount = countRoutePathSegments(parentRoutePath)
+  let hasMetadata = false
+  let segmentCount = 0
+
+  for (let i = 0; i < segments.length; i++) {
+    if (!segments[i]) continue
+    const sourceIndex = parentSegmentCount + segmentCount + 1
+    result[i] = node._routePathSegmentMetadata[sourceIndex]
+    hasMetadata ||= !!result[i]
+    segmentCount++
+  }
+
+  return hasMetadata ? result : undefined
+}
+
 const DefaultFileSystem: fs = {
   stat: async (filePath) => {
     const res = await fsp.stat(filePath, { bigint: true })
@@ -392,7 +420,10 @@ export class Generator {
 
     const preRouteNodes = multiSortBy(beforeRouteNodes, [
       (d) => (d.routePath === '/' ? -1 : 1),
-      (d) => d.routePath?.split('/').length,
+      (d) =>
+        d.routePath === undefined
+          ? undefined
+          : countSlashSeparatedParts(d.routePath),
       (d) => (d.filePath.match(this.indexTokenFilenameRegex) ? 1 : -1),
       (d) => (d.filePath.match(Generator.componentPieceRegex) ? 1 : -1),
       (d) => (d.filePath.match(this.routeTokenFilenameRegex) ? -1 : 1),
@@ -587,7 +618,10 @@ export class Generator {
 
     const sortedRouteNodes = multiSortBy(acc.routeNodes, [
       (d) => (d.routePath?.includes(`/${rootPathId}`) ? -1 : 1),
-      (d) => d.routePath?.split('/').length,
+      (d) =>
+        d.routePath === undefined
+          ? undefined
+          : countSlashSeparatedParts(d.routePath),
       (d) => {
         const segments = d.routePath?.split('/').filter(Boolean) ?? []
         const last = segments[segments.length - 1] ?? ''
@@ -1430,29 +1464,39 @@ ${acc.routeTree.map((child) => `${child.variableName}Route: typeof ${getResolved
     node.path = determineNodePath(node)
 
     const trimmedPath = trimPathLeft(node.path ?? '')
-    const trimmedOriginalPath = trimPathLeft(
-      node.originalRoutePath?.replace(
-        node.parent?.originalRoutePath ?? '',
-        '',
-      ) ?? '',
+    const originalPath =
+      node.originalRoutePath && node.parent?.originalRoutePath
+        ? node.originalRoutePath.replace(node.parent.originalRoutePath, '') ||
+          '/'
+        : node.originalRoutePath
+    const routePathSegmentMetadata = getRoutePathSegmentMetadataForPath(
+      node,
+      node.path ?? '/',
+      node.parent?.routePath,
     )
+    const trimmedOriginalPath = trimPathLeft(originalPath ?? '')
 
     const split = trimmedPath.split('/')
+    const pathSplit = (node.path ?? '').split('/')
     const originalSplit = trimmedOriginalPath.split('/')
     const lastRouteSegment = split[split.length - 1] ?? trimmedPath
     const lastOriginalSegment =
       originalSplit[originalSplit.length - 1] ?? trimmedOriginalPath
+    const lastRouteSegmentMetadata =
+      routePathSegmentMetadata?.[pathSplit.length - 1]
 
     // A segment is non-path if it starts with underscore AND the underscore is not escaped
     node.isNonPath =
-      isSegmentPathless(lastRouteSegment, lastOriginalSegment) ||
+      (!lastRouteSegmentMetadata?.literalLeadingUnderscore &&
+        isSegmentPathless(lastRouteSegment, lastOriginalSegment)) ||
       split.every((part) => this.routeGroupPatternRegex.test(part))
 
-    // Use escape-aware functions to compute cleanedPath
+    // Use a single pass so layout removal does not desync escaped underscore checks.
     node.cleanedPath = removeGroups(
-      removeUnderscoresWithEscape(
-        removeLayoutSegmentsWithEscape(node.path, node.originalRoutePath),
-        node.originalRoutePath,
+      removeLayoutSegmentsAndUnderscoresWithEscape(
+        node.path,
+        originalPath,
+        routePathSegmentMetadata,
       ),
     )
 
@@ -1530,13 +1574,17 @@ ${acc.routeTree.map((child) => `${child.variableName}Route: typeof ${getResolved
               candidate.originalRoutePath ?? '',
               '',
             ) || '/'
+          const routePathSegmentMetadataRelativeToParent =
+            getRoutePathSegmentMetadataForPath(
+              node,
+              pathRelativeToParent,
+              candidate.routePath,
+            )
           node.cleanedPath = removeGroups(
-            removeUnderscoresWithEscape(
-              removeLayoutSegmentsWithEscape(
-                pathRelativeToParent,
-                originalPathRelativeToParent,
-              ),
+            removeLayoutSegmentsAndUnderscoresWithEscape(
+              pathRelativeToParent,
               originalPathRelativeToParent,
+              routePathSegmentMetadataRelativeToParent,
             ),
           )
           break

package/src/types.ts

@@ -1,3 +1,8 @@
+export type RoutePathSegmentMetadata = {
+  literalLeadingUnderscore?: boolean
+  literalTrailingUnderscore?: boolean
+}
+
 export type RouteNode = {
   filePath: string
   fullPath: string
@@ -20,6 +25,8 @@ export type RouteNode = {
    * (e.g., when the parent is a virtual file-less route that gets filtered out).
    */
   _virtualParentRoutePath?: string
+  /** Internal routePath segment metadata for escaped or explicit literal syntax. */
+  _routePathSegmentMetadata?: Array<RoutePathSegmentMetadata | undefined>
 }
 
 export interface GetRouteNodesResult {

package/src/utils.ts

@@ -4,7 +4,11 @@ import path from 'node:path'
 import * as prettier from 'prettier'
 import { rootPathId } from './filesystem/physical/rootPathId'
 import type { Config, TokenMatcher } from './config'
-import type { ImportDeclaration, RouteNode } from './types'
+import type {
+  ImportDeclaration,
+  RouteNode,
+  RoutePathSegmentMetadata,
+} from './types'
 
 /**
  * Prefix map for O(1) parent route lookups.
@@ -244,6 +248,169 @@ export function hasEscapedTrailingUnderscore(originalSegment: string): boolean {
   )
 }
 
+export function countRoutePathSegments(routePath?: string): number {
+  const path = routePath ?? ''
+  let count = 0
+  let inSegment = false
+
+  for (let i = 0; i < path.length; i++) {
+    if (path[i] === '/') {
+      inSegment = false
+      continue
+    }
+
+    if (!inSegment) {
+      count++
+      inSegment = true
+    }
+  }
+
+  return count
+}
+
+export function countSlashSeparatedParts(path: string): number {
+  let count = 1
+
+  for (let i = 0; i < path.length; i++) {
+    if (path[i] === '/') count++
+  }
+
+  return count
+}
+
+export function hasRoutePathSegmentMetadata(
+  metadata: RoutePathSegmentMetadata | undefined,
+): metadata is RoutePathSegmentMetadata {
+  return !!(
+    metadata?.literalLeadingUnderscore || metadata?.literalTrailingUnderscore
+  )
+}
+
+function mergeRoutePathSegmentMetadata(
+  current: RoutePathSegmentMetadata | undefined,
+  incoming: RoutePathSegmentMetadata | undefined,
+): RoutePathSegmentMetadata | undefined {
+  const hasCurrent = hasRoutePathSegmentMetadata(current)
+  const hasIncoming = hasRoutePathSegmentMetadata(incoming)
+
+  if (!hasCurrent) return hasIncoming ? incoming : undefined
+  if (!hasIncoming) return current
+
+  return {
+    literalLeadingUnderscore:
+      current.literalLeadingUnderscore || incoming.literalLeadingUnderscore,
+    literalTrailingUnderscore:
+      current.literalTrailingUnderscore || incoming.literalTrailingUnderscore,
+  }
+}
+
+export function createRoutePathSegmentMetadata(
+  routePath: string = '/',
+  originalPath?: string,
+): Array<RoutePathSegmentMetadata | undefined> | undefined {
+  if (!originalPath) return undefined
+
+  const routeSegments = routePath.split('/')
+  const originalSegments = originalPath.split('/')
+  const metadata = new Array<RoutePathSegmentMetadata | undefined>(
+    routeSegments.length,
+  )
+  let hasMetadata = false
+
+  for (let i = 0; i < routeSegments.length; i++) {
+    const segment = routeSegments[i]!
+    const originalSegment = originalSegments[i] || ''
+    const literalLeadingUnderscore =
+      segment.startsWith('_') && hasEscapedLeadingUnderscore(originalSegment)
+    const literalTrailingUnderscore =
+      segment.endsWith('_') && hasEscapedTrailingUnderscore(originalSegment)
+
+    if (!literalLeadingUnderscore && !literalTrailingUnderscore) continue
+
+    hasMetadata = true
+    metadata[i] = {
+      literalLeadingUnderscore: literalLeadingUnderscore || undefined,
+      literalTrailingUnderscore: literalTrailingUnderscore || undefined,
+    }
+  }
+
+  return hasMetadata ? metadata : undefined
+}
+
+export function createLiteralRoutePathSegmentMetadata(
+  routePath: string,
+  parent?: RouteNode,
+  literalNewSegments = false,
+): Array<RoutePathSegmentMetadata | undefined> | undefined {
+  const routeSegments = routePath.split('/')
+  const metadata = new Array<RoutePathSegmentMetadata | undefined>(
+    routeSegments.length,
+  )
+  const parentDepth = countRoutePathSegments(parent?.routePath)
+  let hasMetadata = false
+  let depth = 0
+
+  for (let i = 0; i < routeSegments.length; i++) {
+    const segment = routeSegments[i]
+    metadata[i] = parent?._routePathSegmentMetadata?.[i]
+    hasMetadata ||= hasRoutePathSegmentMetadata(metadata[i])
+
+    if (!segment) continue
+
+    if (literalNewSegments && depth >= parentDepth) {
+      const literalLeadingUnderscore = segment.startsWith('_')
+      const literalTrailingUnderscore = segment.endsWith('_')
+
+      if (literalLeadingUnderscore || literalTrailingUnderscore) {
+        metadata[i] = mergeRoutePathSegmentMetadata(metadata[i], {
+          literalLeadingUnderscore: literalLeadingUnderscore || undefined,
+          literalTrailingUnderscore: literalTrailingUnderscore || undefined,
+        })
+        hasMetadata = true
+      }
+    }
+
+    depth++
+  }
+
+  return hasMetadata ? metadata : undefined
+}
+
+export function joinRoutePathSegmentMetadata(
+  routePath: string,
+  prefixPath: string,
+  prefixMetadata: Array<RoutePathSegmentMetadata | undefined> | undefined,
+  childMetadata: Array<RoutePathSegmentMetadata | undefined> | undefined,
+): Array<RoutePathSegmentMetadata | undefined> | undefined {
+  const metadata = new Array<RoutePathSegmentMetadata | undefined>(
+    countSlashSeparatedParts(routePath),
+  )
+  let hasMetadata = false
+
+  if (prefixMetadata) {
+    for (let i = 0; i < prefixMetadata.length && i < metadata.length; i++) {
+      metadata[i] = prefixMetadata[i]
+      hasMetadata ||= hasRoutePathSegmentMetadata(metadata[i])
+    }
+  }
+
+  const offset = countRoutePathSegments(prefixPath)
+  if (childMetadata) {
+    for (let i = 1; i < childMetadata.length; i++) {
+      const targetIndex = offset + i
+      if (targetIndex >= metadata.length) break
+
+      metadata[targetIndex] = mergeRoutePathSegmentMetadata(
+        metadata[targetIndex],
+        childMetadata[i],
+      )
+      hasMetadata ||= hasRoutePathSegmentMetadata(metadata[targetIndex])
+    }
+  }
+
+  return hasMetadata ? metadata : undefined
+}
+
 const backslashRegex = /\\/g
 
 export function replaceBackslash(s: string) {
@@ -314,6 +481,23 @@ export function removeUnderscores(s?: string) {
     .replace(underscoreSlashRegex, '/')
 }
 
+function removeUnderscoresFromSegment(
+  segment: string,
+  metadata?: RoutePathSegmentMetadata,
+): string {
+  let result = segment
+
+  if (result.startsWith('_') && !metadata?.literalLeadingUnderscore) {
+    result = result.slice(1)
+  }
+
+  if (result.endsWith('_') && !metadata?.literalTrailingUnderscore) {
+    result = result.slice(0, -1)
+  }
+
+  return result
+}
+
 /**
  * Removes underscores from a path, but preserves underscores that were escaped
  * in the original path (indicated by [_] syntax).
@@ -330,30 +514,50 @@ export function removeUnderscoresWithEscape(
   if (!originalPath) return removeUnderscores(routePath) ?? ''
 
   const routeSegments = routePath.split('/')
-  const originalSegments = originalPath.split('/')
+  const metadata = createRoutePathSegmentMetadata(routePath, originalPath)
+  const newSegments = new Array<string>(routeSegments.length)
 
-  const newSegments = routeSegments.map((segment, i) => {
-    const originalSegment = originalSegments[i] || ''
+  for (let i = 0; i < routeSegments.length; i++) {
+    newSegments[i] = removeUnderscoresFromSegment(
+      routeSegments[i]!,
+      metadata?.[i],
+    )
+  }
 
-    // Check if leading underscore is escaped
-    const leadingEscaped = hasEscapedLeadingUnderscore(originalSegment)
-    // Check if trailing underscore is escaped
-    const trailingEscaped = hasEscapedTrailingUnderscore(originalSegment)
+  return newSegments.join('/')
+}
 
-    let result = segment
+export function removeLayoutSegmentsAndUnderscoresWithEscape(
+  routePath: string = '/',
+  originalPath?: string,
+  routePathSegmentMetadata?: Array<RoutePathSegmentMetadata | undefined>,
+): string {
+  if (!originalPath) {
+    return removeUnderscores(removeLayoutSegments(routePath)) ?? ''
+  }
 
-    // Remove leading underscore only if not escaped
-    if (result.startsWith('_') && !leadingEscaped) {
-      result = result.slice(1)
-    }
+  const metadata =
+    routePathSegmentMetadata ??
+    createRoutePathSegmentMetadata(routePath, originalPath)
+
+  const routeSegments = routePath.split('/')
+  const originalSegments = originalPath.split('/')
+  const newSegments: Array<string> = []
 
-    // Remove trailing underscore only if not escaped
-    if (result.endsWith('_') && !trailingEscaped) {
-      result = result.slice(0, -1)
+  for (let i = 0; i < routeSegments.length; i++) {
+    const segment = routeSegments[i]!
+    const originalSegment = originalSegments[i] || ''
+    const segmentMetadata = metadata?.[i]
+
+    if (
+      !segmentMetadata?.literalLeadingUnderscore &&
+      isSegmentPathless(segment, originalSegment)
+    ) {
+      continue
     }
 
-    return result
-  })
+    newSegments.push(removeUnderscoresFromSegment(segment, segmentMetadata))
+  }
 
   return newSegments.join('/')
 }
@@ -686,12 +890,10 @@ const inferPath = (routeNode: RouteNode): string => {
  */
 export const inferFullPath = (routeNode: RouteNode): string => {
   const fullPath = removeGroups(
-    removeUnderscoresWithEscape(
-      removeLayoutSegmentsWithEscape(
-        routeNode.routePath,
-        routeNode.originalRoutePath,
-      ),
+    removeLayoutSegmentsAndUnderscoresWithEscape(
+      routeNode.routePath,
       routeNode.originalRoutePath,
+      routeNode._routePathSegmentMetadata,
     ),
   )