@tanstack/router-generator 1.141.8 → 1.142.0

package/src/utils.ts

@@ -14,7 +14,6 @@ import type { ImportDeclaration, RouteNode } from './types'
 export class RoutePrefixMap {
   private prefixToRoute: Map<string, RouteNode> = new Map()
   private layoutRoutes: Array<RouteNode> = []
-  private nonNestedRoutes: Array<RouteNode> = []
 
   constructor(routes: Array<RouteNode>) {
     for (const route of routes) {
@@ -23,7 +22,6 @@ export class RoutePrefixMap {
       // Index by exact path for direct lookups
       this.prefixToRoute.set(route.routePath, route)
 
-      // Track layout routes separately for non-nested route handling
       if (
         route._fsRouteType === 'pathless_layout' ||
         route._fsRouteType === 'layout' ||
@@ -31,20 +29,12 @@ export class RoutePrefixMap {
       ) {
         this.layoutRoutes.push(route)
       }
-
-      // Track non-nested routes separately
-      if (route._isExperimentalNonNestedRoute) {
-        this.nonNestedRoutes.push(route)
-      }
     }
 
     // Sort by path length descending for longest-match-first
     this.layoutRoutes.sort(
       (a, b) => (b.routePath?.length ?? 0) - (a.routePath?.length ?? 0),
     )
-    this.nonNestedRoutes.sort(
-      (a, b) => (b.routePath?.length ?? 0) - (a.routePath?.length ?? 0),
-    )
   }
 
   /**
@@ -69,48 +59,6 @@ export class RoutePrefixMap {
     return null
   }
 
-  /**
-   * Find parent for non-nested routes (needs layout route matching).
-   */
-  findParentForNonNested(
-    routePath: string,
-    originalRoutePath: string | undefined,
-    nonNestedSegments: Array<string>,
-  ): RouteNode | null {
-    // First check for other non-nested routes that are prefixes
-    // Use pre-sorted array for longest-match-first
-    for (const route of this.nonNestedRoutes) {
-      if (
-        route.routePath !== routePath &&
-        originalRoutePath?.startsWith(`${route.originalRoutePath}/`)
-      ) {
-        return route
-      }
-    }
-
-    // Then check layout routes
-    for (const route of this.layoutRoutes) {
-      if (route.routePath === '/') continue
-
-      // Skip if this route's original path + underscore matches a non-nested segment
-      if (
-        nonNestedSegments.some((seg) => seg === `${route.originalRoutePath}_`)
-      ) {
-        continue
-      }
-
-      // Check if this layout route is a prefix of the path we're looking for
-      if (
-        routePath.startsWith(`${route.routePath}/`) &&
-        route.routePath !== routePath
-      ) {
-        return route
-      }
-    }
-
-    return null
-  }
-
   /**
    * Check if a route exists at the given path.
    */
@@ -192,55 +140,32 @@ export function removeTrailingSlash(s: string) {
 const BRACKET_CONTENT_RE = /\[(.*?)\]/g
 const SPLIT_REGEX = /(?<!\[)\.(?!\])/g
 
-export function determineInitialRoutePath(
-  routePath: string,
-  config?: Pick<Config, 'experimental' | 'routeToken' | 'indexToken'>,
-) {
-  const DISALLOWED_ESCAPE_CHARS = new Set([
-    '/',
-    '\\',
-    '?',
-    '#',
-    ':',
-    '*',
-    '<',
-    '>',
-    '|',
-    '!',
-    '$',
-    '%',
-  ])
-
+/**
+ * Characters that cannot be escaped in square brackets.
+ * These are characters that would cause issues in URLs or file systems.
+ */
+const DISALLOWED_ESCAPE_CHARS = new Set([
+  '/',
+  '\\',
+  '?',
+  '#',
+  ':',
+  '*',
+  '<',
+  '>',
+  '|',
+  '!',
+  '$',
+  '%',
+])
+
+export function determineInitialRoutePath(routePath: string) {
   const originalRoutePath =
     cleanPath(
       `/${(cleanPath(routePath) || '').split(SPLIT_REGEX).join('/')}`,
     ) || ''
 
-  // check if the route path is a valid non-nested path,
-  // TODO with new major rename to reflect not experimental anymore
-  const isExperimentalNonNestedRoute = isValidNonNestedRoute(
-    originalRoutePath,
-    config,
-  )
-
-  let cleanedRoutePath = routePath
-
-  // we already identified the path as non-nested and can now remove the trailing underscores
-  // we need to do this now before we encounter any escaped trailing underscores
-  // this way we can be sure any remaining trailing underscores should remain
-  // TODO with new major we can remove check and always remove leading underscores
-  if (config?.experimental?.nonNestedRoutes) {
-    // we should leave trailing underscores if the route path is the root path
-    if (originalRoutePath !== `/${rootPathId}`) {
-      // remove trailing underscores on various path segments
-      cleanedRoutePath = removeTrailingUnderscores(
-        originalRoutePath,
-        config.routeToken,
-      )
-    }
-  }
-
-  const parts = cleanedRoutePath.split(SPLIT_REGEX)
+  const parts = routePath.split(SPLIT_REGEX)
 
   // Escape any characters that in square brackets
   // we keep the original path untouched
@@ -275,11 +200,51 @@ export function determineInitialRoutePath(
 
   return {
     routePath: final,
-    isExperimentalNonNestedRoute,
     originalRoutePath,
   }
 }
 
+/**
+ * Checks if a segment is fully escaped (entirely wrapped in brackets with no nested brackets).
+ * E.g., "[index]" -> true, "[_layout]" -> true, "foo[.]bar" -> false, "index" -> false
+ */
+function isFullyEscapedSegment(originalSegment: string): boolean {
+  return (
+    originalSegment.startsWith('[') &&
+    originalSegment.endsWith(']') &&
+    !originalSegment.slice(1, -1).includes('[') &&
+    !originalSegment.slice(1, -1).includes(']')
+  )
+}
+
+/**
+ * Checks if the leading underscore in a segment is escaped.
+ * Returns true if:
+ * - Segment starts with [_] pattern: "[_]layout" -> "_layout"
+ * - Segment is fully escaped and content starts with _: "[_1nd3x]" -> "_1nd3x"
+ */
+export function hasEscapedLeadingUnderscore(originalSegment: string): boolean {
+  // Pattern: [_]something or [_something]
+  return (
+    originalSegment.startsWith('[_]') ||
+    (originalSegment.startsWith('[_') && isFullyEscapedSegment(originalSegment))
+  )
+}
+
+/**
+ * Checks if the trailing underscore in a segment is escaped.
+ * Returns true if:
+ * - Segment ends with [_] pattern: "blog[_]" -> "blog_"
+ * - Segment is fully escaped and content ends with _: "[_r0ut3_]" -> "_r0ut3_"
+ */
+export function hasEscapedTrailingUnderscore(originalSegment: string): boolean {
+  // Pattern: something[_] or [something_]
+  return (
+    originalSegment.endsWith('[_]') ||
+    (originalSegment.endsWith('_]') && isFullyEscapedSegment(originalSegment))
+  )
+}
+
 const backslashRegex = /\\/g
 
 export function replaceBackslash(s: string) {
@@ -350,6 +315,92 @@ export function removeUnderscores(s?: string) {
     .replace(underscoreSlashRegex, '/')
 }
 
+/**
+ * Removes underscores from a path, but preserves underscores that were escaped
+ * in the original path (indicated by [_] syntax).
+ *
+ * @param routePath - The path with brackets removed
+ * @param originalPath - The original path that may contain [_] escape sequences
+ * @returns The path with non-escaped underscores removed
+ */
+export function removeUnderscoresWithEscape(
+  routePath?: string,
+  originalPath?: string,
+): string {
+  if (!routePath) return ''
+  if (!originalPath) return removeUnderscores(routePath) ?? ''
+
+  const routeSegments = routePath.split('/')
+  const originalSegments = originalPath.split('/')
+
+  const newSegments = routeSegments.map((segment, i) => {
+    const originalSegment = originalSegments[i] || ''
+
+    // Check if leading underscore is escaped
+    const leadingEscaped = hasEscapedLeadingUnderscore(originalSegment)
+    // Check if trailing underscore is escaped
+    const trailingEscaped = hasEscapedTrailingUnderscore(originalSegment)
+
+    let result = segment
+
+    // Remove leading underscore only if not escaped
+    if (result.startsWith('_') && !leadingEscaped) {
+      result = result.slice(1)
+    }
+
+    // Remove trailing underscore only if not escaped
+    if (result.endsWith('_') && !trailingEscaped) {
+      result = result.slice(0, -1)
+    }
+
+    return result
+  })
+
+  return newSegments.join('/')
+}
+
+/**
+ * Removes layout segments (segments starting with underscore) from a path,
+ * but preserves segments where the underscore was escaped.
+ *
+ * @param routePath - The path with brackets removed
+ * @param originalPath - The original path that may contain [_] escape sequences
+ * @returns The path with non-escaped layout segments removed
+ */
+export function removeLayoutSegmentsWithEscape(
+  routePath: string = '/',
+  originalPath?: string,
+): string {
+  if (!originalPath) return removeLayoutSegments(routePath)
+
+  const routeSegments = routePath.split('/')
+  const originalSegments = originalPath.split('/')
+
+  // Keep segments that are NOT pathless (i.e., don't start with unescaped underscore)
+  const newSegments = routeSegments.filter((segment, i) => {
+    const originalSegment = originalSegments[i] || ''
+    return !isSegmentPathless(segment, originalSegment)
+  })
+
+  return newSegments.join('/')
+}
+
+/**
+ * Checks if a segment should be treated as a pathless/layout segment.
+ * A segment is pathless if it starts with underscore and the underscore is not escaped.
+ *
+ * @param segment - The segment from routePath (brackets removed)
+ * @param originalSegment - The segment from originalRoutePath (may contain brackets)
+ * @returns true if the segment is pathless (has non-escaped leading underscore)
+ */
+export function isSegmentPathless(
+  segment: string,
+  originalSegment: string,
+): boolean {
+  if (!segment.startsWith('_')) return false
+  return !hasEscapedLeadingUnderscore(originalSegment)
+}
+
 function escapeRegExp(s: string): string {
   return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
 }
@@ -518,30 +569,6 @@ export function removeLastSegmentFromPath(routePath: string = '/'): string {
   return segments.join('/')
 }
 
-const nonNestedSegmentRegex = /_(?=\/|$)/g
-const openBracketRegex = /\[/g
-const closeBracketRegex = /\]/g
-
-/**
- * Extracts non-nested segments from a route path.
- * Used for determining parent routes in non-nested route scenarios.
- */
-export function getNonNestedSegments(routePath: string): Array<string> {
-  nonNestedSegmentRegex.lastIndex = 0
-  const result: Array<string> = []
-  for (const match of routePath.matchAll(nonNestedSegmentRegex)) {
-    const beforeStr = routePath.substring(0, match.index)
-    openBracketRegex.lastIndex = 0
-    closeBracketRegex.lastIndex = 0
-    const openBrackets = beforeStr.match(openBracketRegex)?.length ?? 0
-    const closeBrackets = beforeStr.match(closeBracketRegex)?.length ?? 0
-    if (openBrackets === closeBrackets) {
-      result.push(routePath.substring(0, match.index + 1))
-    }
-  }
-  return result.reverse()
-}
-
 /**
  * Find parent route using RoutePrefixMap for O(k) lookups instead of O(n).
  */
@@ -549,21 +576,11 @@ export function hasParentRoute(
   prefixMap: RoutePrefixMap,
   node: RouteNode,
   routePathToCheck: string | undefined,
-  originalRoutePathToCheck: string | undefined,
 ): RouteNode | null {
   if (!routePathToCheck || routePathToCheck === '/') {
     return null
   }
 
-  if (node._isExperimentalNonNestedRoute && originalRoutePathToCheck) {
-    const nonNestedSegments = getNonNestedSegments(originalRoutePathToCheck)
-    return prefixMap.findParentForNonNested(
-      routePathToCheck,
-      originalRoutePathToCheck,
-      nonNestedSegments,
-    )
-  }
-
   return prefixMap.findParent(routePathToCheck)
 }
 
@@ -606,16 +623,15 @@ export const inferPath = (routeNode: RouteNode): string => {
 /**
  * Infers the full path for use by TS
  */
-export const inferFullPath = (
-  routeNode: RouteNode,
-  config?: Pick<Config, 'experimental' | 'routeToken'>,
-): string => {
-  // with new nonNestedPaths feature we can be sure any remaining trailing underscores are escaped and should remain
-  // TODO with new major we can remove check and only remove leading underscores
+export const inferFullPath = (routeNode: RouteNode): string => {
   const fullPath = removeGroups(
-    (config?.experimental?.nonNestedRoutes
-      ? removeLayoutSegments(routeNode.routePath)
-      : removeUnderscores(removeLayoutSegments(routeNode.routePath))) ?? '',
+    removeUnderscoresWithEscape(
+      removeLayoutSegmentsWithEscape(
+        routeNode.routePath,
+        routeNode.originalRoutePath,
+      ),
+      routeNode.originalRoutePath,
+    ),
   )
 
   return routeNode.cleanedPath === '/' ? fullPath : fullPath.replace(/\/$/, '')
@@ -626,13 +642,9 @@ export const inferFullPath = (
  */
 export const createRouteNodesByFullPath = (
   routeNodes: Array<RouteNode>,
-  config?: Pick<Config, 'experimental' | 'routeToken'>,
 ): Map<string, RouteNode> => {
   return new Map(
-    routeNodes.map((routeNode) => [
-      inferFullPath(routeNode, config),
-      routeNode,
-    ]),
+    routeNodes.map((routeNode) => [inferFullPath(routeNode), routeNode]),
   )
 }
 
@@ -641,11 +653,10 @@ export const createRouteNodesByFullPath = (
  */
 export const createRouteNodesByTo = (
   routeNodes: Array<RouteNode>,
-  config?: Pick<Config, 'experimental' | 'routeToken'>,
 ): Map<string, RouteNode> => {
   return new Map(
     dedupeBranchesAndIndexRoutes(routeNodes).map((routeNode) => [
-      inferTo(routeNode, config),
+      inferTo(routeNode),
       routeNode,
     ]),
   )
@@ -668,11 +679,8 @@ export const createRouteNodesById = (
 /**
  * Infers to path
  */
-export const inferTo = (
-  routeNode: RouteNode,
-  config?: Pick<Config, 'experimental' | 'routeToken'>,
-): string => {
-  const fullPath = inferFullPath(routeNode, config)
+export const inferTo = (routeNode: RouteNode): string => {
+  const fullPath = inferFullPath(routeNode)
 
   if (fullPath === '/') return fullPath
 
@@ -711,7 +719,7 @@ export function checkRouteFullPathUniqueness(
   config: Config,
 ) {
   const routes = _routes.map((d) => {
-    const inferredFullPath = inferFullPath(d, config)
+    const inferredFullPath = inferFullPath(d)
     return { ...d, inferredFullPath }
   })
 
@@ -849,7 +857,7 @@ export function buildFileRoutesByPathInterface(opts: {
   routeNodes: Array<RouteNode>
   module: string
   interfaceName: string
-  config?: Pick<Config, 'experimental' | 'routeToken'>
+  config?: Pick<Config, 'routeToken'>
 }): string {
   return `declare module '${opts.module}' {
   interface ${opts.interfaceName} {
@@ -863,7 +871,7 @@ export function buildFileRoutesByPathInterface(opts: {
         return `'${filePathId}': {
           id: '${filePathId}'
           path: '${inferPath(routeNode)}'
-          fullPath: '${inferFullPath(routeNode, opts.config)}'
+          fullPath: '${inferFullPath(routeNode)}'
           preLoaderRoute: ${preloaderRoute}
           parentRoute: typeof ${parent}
         }`
@@ -916,51 +924,3 @@ export function getImportForRouteNode(
     ],
   } satisfies ImportDeclaration
 }
-
-/**
- * Used to validate if a route is a pathless layout route
- * @param normalizedRoutePath Normalized route path, i.e `/foo/_layout/route.tsx` and `/foo._layout.route.tsx` to `/foo/_layout/route`
- * @param config The `router-generator` configuration object
- * @returns Boolean indicating if the route is a pathless layout route
- */
-export function isValidNonNestedRoute(
-  normalizedRoutePath: string,
-  config?: Pick<Config, 'experimental' | 'routeToken' | 'indexToken'>,
-): boolean {
-  if (!config?.experimental?.nonNestedRoutes) {
-    return false
-  }
-
-  const segments = normalizedRoutePath.split('/').filter(Boolean)
-
-  if (segments.length === 0) {
-    return false
-  }
-
-  const lastRouteSegment = segments[segments.length - 1]!
-
-  // If segment === __root, then exit as false
-  if (lastRouteSegment === rootPathId) {
-    return false
-  }
-
-  if (
-    lastRouteSegment !== config.indexToken &&
-    lastRouteSegment !== config.routeToken &&
-    lastRouteSegment.endsWith('_')
-  ) {
-    return true
-  }
-
-  for (const segment of segments.slice(0, -1).reverse()) {
-    if (segment === config.routeToken) {
-      return false
-    }
-
-    if (segment.endsWith('_')) {
-      return true
-    }
-  }
-
-  return false
-}