@tanstack/router-generator 1.141.4 → 1.141.5

package/src/generator.ts

@@ -38,7 +38,6 @@ import {
   removeUnderscores,
   replaceBackslash,
   resetRegex,
-  routePathToVariable,
   trimPathLeft,
 } from './utils'
 import { fillTemplate, getTargetTemplate } from './template'
@@ -409,6 +408,7 @@ export class Generator {
       routeTree: [],
       routeNodes: [],
       routePiecesByPath: {},
+      routeNodesByPath: new Map(),
     }
 
     for (const node of routeFileResult) {
@@ -651,7 +651,10 @@ export class Generator {
           `const ${node.variableName}Route = ${node.variableName}RouteImport.update({
             ${[
               `id: '${node.path}'`,
-              !node.isNonPath ? `path: '${node.cleanedPath}'` : undefined,
+              !node.isNonPath ||
+              (node._fsRouteType === 'pathless_layout' && node.cleanedPath)
+                ? `path: '${node.cleanedPath}'`
+                : undefined,
               `getParentRoute: () => ${findParent(node)}`,
             ]
               .filter(Boolean)
@@ -1351,27 +1354,13 @@ ${acc.routeTree.map((child) => `${child.variableName}Route: typeof ${getResolved
 
     resetRegex(this.routeGroupPatternRegex)
 
-    let parentRoute = hasParentRoute(
+    const parentRoute = hasParentRoute(
       acc.routeNodes,
       node,
       node.routePath,
       node.originalRoutePath,
     )
 
-    // if the parent route is a virtual parent route, we need to find the real parent route
-    if (parentRoute?.isVirtualParentRoute && parentRoute.children?.length) {
-      // only if this sub-parent route returns a valid parent route, we use it, if not leave it as it
-      const possibleParentRoute = hasParentRoute(
-        parentRoute.children,
-        node,
-        node.routePath,
-        node.originalRoutePath,
-      )
-      if (possibleParentRoute) {
-        parentRoute = possibleParentRoute
-      }
-    }
-
     if (parentRoute) node.parent = parentRoute
 
     node.path = determineNodePath(node)
@@ -1419,23 +1408,13 @@ ${acc.routeTree.map((child) => `${child.variableName}Route: typeof ${getResolved
       acc.routePiecesByPath[node.routePath!] =
         acc.routePiecesByPath[node.routePath!] || {}
 
-      acc.routePiecesByPath[node.routePath!]![
+      const pieceKey =
         node._fsRouteType === 'lazy'
           ? 'lazy'
-          : node._fsRouteType === 'loader'
-            ? 'loader'
-            : node._fsRouteType === 'errorComponent'
-              ? 'errorComponent'
-              : node._fsRouteType === 'notFoundComponent'
-                ? 'notFoundComponent'
-                : node._fsRouteType === 'pendingComponent'
-                  ? 'pendingComponent'
-                  : 'component'
-      ] = node
-
-      const anchorRoute = acc.routeNodes.find(
-        (d) => d.routePath === node.routePath,
-      )
+          : (node._fsRouteType as keyof (typeof acc.routePiecesByPath)[string])
+      acc.routePiecesByPath[node.routePath!]![pieceKey] = node
+
+      const anchorRoute = acc.routeNodesByPath.get(node.routePath!)
 
       // Don't create virtual routes for root route component pieces - the root route is handled separately
       if (!anchorRoute && node.routePath !== `/${rootPathId}`) {
@@ -1452,66 +1431,45 @@ ${acc.routeTree.map((child) => `${child.variableName}Route: typeof ${getResolved
       return
     }
 
-    const cleanedPathIsEmpty = (node.cleanedPath || '').length === 0
-    const nonPathRoute =
-      node._fsRouteType === 'pathless_layout' && node.isNonPath
-
-    node.isVirtualParentRequired =
-      node._fsRouteType === 'pathless_layout' || nonPathRoute
-        ? !cleanedPathIsEmpty
-        : false
-
-    if (!node.isVirtual && node.isVirtualParentRequired) {
-      const parentRoutePath = removeLastSegmentFromPath(node.routePath) || '/'
-      const parentVariableName = routePathToVariable(parentRoutePath)
-
-      const anchorRoute = acc.routeNodes.find(
-        (d) => d.routePath === parentRoutePath,
-      )
-
-      if (!anchorRoute) {
-        const parentNode: RouteNode = {
-          ...node,
-          path: removeLastSegmentFromPath(node.path) || '/',
-          filePath: removeLastSegmentFromPath(node.filePath) || '/',
-          fullPath: removeLastSegmentFromPath(node.fullPath) || '/',
-          routePath: parentRoutePath,
-          variableName: parentVariableName,
-          isVirtual: true,
-          _fsRouteType: 'layout', // layout since this route will wrap other routes
-          isVirtualParentRoute: true,
-          isVirtualParentRequired: false,
-        }
-
-        parentNode.children = parentNode.children ?? []
-        parentNode.children.push(node)
-
-        node.parent = parentNode
-
-        if (node._fsRouteType === 'pathless_layout') {
-          // since `node.path` is used as the `id` on the route definition, we need to update it
-          node.path = determineNodePath(node)
+    const isPathlessLayoutWithPath =
+      node._fsRouteType === 'pathless_layout' &&
+      node.cleanedPath &&
+      node.cleanedPath.length > 0
+
+    // Special handling: pathless layouts with path need to find real ancestor
+    if (!node.isVirtual && isPathlessLayoutWithPath) {
+      const immediateParentPath =
+        removeLastSegmentFromPath(node.routePath) || '/'
+      let searchPath = immediateParentPath
+
+      // Find nearest real (non-virtual, non-index) parent
+      while (searchPath) {
+        const candidate = acc.routeNodesByPath.get(searchPath)
+        if (candidate && !candidate.isVirtual && candidate.path !== '/') {
+          node.parent = candidate
+          node.path = node.routePath
+          node.cleanedPath = removeGroups(
+            removeUnderscores(removeLayoutSegments(immediateParentPath)) ?? '',
+          )
+          break
         }
-
-        this.handleNode(parentNode, acc, config)
-      } else {
-        anchorRoute.children = anchorRoute.children ?? []
-        anchorRoute.children.push(node)
-
-        node.parent = anchorRoute
+        if (searchPath === '/') break
+        searchPath = removeLastSegmentFromPath(searchPath) || '/'
       }
     }
 
+    // Add to parent's children or to root
     if (node.parent) {
-      if (!node.isVirtualParentRequired) {
-        node.parent.children = node.parent.children ?? []
-        node.parent.children.push(node)
-      }
+      node.parent.children = node.parent.children ?? []
+      node.parent.children.push(node)
     } else {
       acc.routeTree.push(node)
     }
 
     acc.routeNodes.push(node)
+    if (node.routePath && !node.isVirtual) {
+      acc.routeNodesByPath.set(node.routePath, node)
+    }
   }
 
   // only process files that are relevant for the route tree generation

package/src/types.ts

@@ -8,7 +8,6 @@ export type RouteNode = {
   cleanedPath?: string
   path?: string
   isNonPath?: boolean
-  isVirtualParentRequired?: boolean
   isVirtualParentRoute?: boolean
   isVirtual?: boolean
   children?: Array<RouteNode>
@@ -58,6 +57,8 @@ export type HandleNodeAccumulator = {
   routeTree: Array<RouteNode>
   routePiecesByPath: Record<string, RouteSubNode>
   routeNodes: Array<RouteNode>
+  /** O(1) lookup by routePath - avoids O(n) .find() on every node */
+  routeNodesByPath: Map<string, RouteNode>
 }
 
 export type GetRoutesByFileMapResultValue = { routePath: string }

package/src/utils.ts

@@ -711,11 +711,7 @@ export const findParent = (node: RouteNode | undefined): string => {
     return `rootRouteImport`
   }
   if (node.parent) {
-    if (node.isVirtualParentRequired) {
-      return `${node.parent.variableName}Route`
-    } else {
-      return `${node.parent.variableName}Route`
-    }
+    return `${node.parent.variableName}Route`
   }
   return findParent(node.parent)
 }