@tanstack/router-generator 1.121.2 → 1.121.7

package/src/filesystem/virtual/getRouteNodes.ts

@@ -53,7 +53,6 @@ export async function getRouteNodes(
     throw new Error(`virtualRouteConfig is undefined`)
   }
   let virtualRouteConfig: VirtualRootRoute
-  let children: Array<RouteNode> = []
   if (typeof tsrConfig.virtualRouteConfig === 'string') {
     virtualRouteConfig = await getVirtualRouteConfigFromFileExport(
       tsrConfig,
@@ -62,7 +61,7 @@ export async function getRouteNodes(
   } else {
     virtualRouteConfig = tsrConfig.virtualRouteConfig
   }
-  children = await getRouteNodesRecursive(
+  const { children, physicalDirectories } = await getRouteNodesRecursive(
     tsrConfig,
     root,
     fullDir,
@@ -80,7 +79,7 @@ export async function getRouteNodes(
   const rootRouteNode = allNodes[0]
   const routeNodes = allNodes.slice(1)
 
-  return { rootRouteNode, routeNodes }
+  return { rootRouteNode, routeNodes, physicalDirectories }
 }
 
 /**
@@ -135,20 +134,22 @@ export async function getRouteNodesRecursive(
   fullDir: string,
   nodes?: Array<VirtualRouteNode>,
   parent?: RouteNode,
-): Promise<Array<RouteNode>> {
+): Promise<{ children: Array<RouteNode>; physicalDirectories: Array<string> }> {
   if (nodes === undefined) {
-    return []
+    return { children: [], physicalDirectories: [] }
   }
+  const allPhysicalDirectories: Array<string> = []
   const children = await Promise.all(
     nodes.map(async (node) => {
       if (node.type === 'physical') {
-        const { routeNodes } = await getRouteNodesPhysical(
+        const { routeNodes, physicalDirectories } = await getRouteNodesPhysical(
           {
             ...tsrConfig,
             routesDirectory: resolve(fullDir, node.directory),
           },
           root,
         )
+        allPhysicalDirectories.push(node.directory)
         routeNodes.forEach((subtreeNode) => {
           subtreeNode.variableName = routePathToVariable(
             `${node.pathPrefix}/${removeExt(subtreeNode.filePath)}`,
@@ -206,14 +207,16 @@ export async function getRouteNodesRecursive(
           }
 
           if (node.children !== undefined) {
-            const children = await getRouteNodesRecursive(
-              tsrConfig,
-              root,
-              fullDir,
-              node.children,
-              routeNode,
-            )
+            const { children, physicalDirectories } =
+              await getRouteNodesRecursive(
+                tsrConfig,
+                root,
+                fullDir,
+                node.children,
+                routeNode,
+              )
             routeNode.children = children
+            allPhysicalDirectories.push(...physicalDirectories)
 
             // If the route has children, it should be a layout
             routeNode._fsRouteType = 'layout'
@@ -242,19 +245,24 @@ export async function getRouteNodesRecursive(
           }
 
           if (node.children !== undefined) {
-            const children = await getRouteNodesRecursive(
-              tsrConfig,
-              root,
-              fullDir,
-              node.children,
-              routeNode,
-            )
+            const { children, physicalDirectories } =
+              await getRouteNodesRecursive(
+                tsrConfig,
+                root,
+                fullDir,
+                node.children,
+                routeNode,
+              )
             routeNode.children = children
+            allPhysicalDirectories.push(...physicalDirectories)
           }
           return routeNode
         }
       }
     }),
   )
-  return children.flat()
+  return {
+    children: children.flat(),
+    physicalDirectories: allPhysicalDirectories,
+  }
 }

package/src/generator.ts

@@ -4,7 +4,10 @@ import { mkdtempSync } from 'node:fs'
 import crypto from 'node:crypto'
 import { deepEqual, rootRouteId } from '@tanstack/router-core'
 import { logging } from './logger'
-import { getRouteNodes as physicalGetRouteNodes } from './filesystem/physical/getRouteNodes'
+import {
+  isVirtualConfigFile,
+  getRouteNodes as physicalGetRouteNodes,
+} from './filesystem/physical/getRouteNodes'
 import { getRouteNodes as virtualGetRouteNodes } from './filesystem/virtual/getRouteNodes'
 import { rootPathId } from './filesystem/physical/rootPathId'
 import {
@@ -170,6 +173,7 @@ export class Generator {
   // this is just a cache for the transform plugins since we need them for each route file that is to be processed
   private transformPlugins: Array<TransformPlugin> = []
   private routeGroupPatternRegex = /\(.+\)/g
+  private physicalDirectories: Array<string> = []
 
   constructor(opts: { config: Config; root: string; fs?: fs }) {
     this.config = opts.config
@@ -203,17 +207,17 @@ export class Generator {
       : path.resolve(this.root, this.config.routesDirectory)
   }
 
+  public getRouteFileList(): Set<string> {
+    return new Set(this.routeNodeCache.keys())
+  }
+
   public async run(event?: GeneratorEvent): Promise<void> {
-    // we are only interested in FileEvents that affect either the generated route tree or files inside the routes folder
-    if (event && event.type !== 'rerun') {
-      if (
-        !(
-          event.path === this.generatedRouteTreePath ||
-          event.path.startsWith(this.routesDirectoryPath)
-        )
-      ) {
-        return
-      }
+    if (
+      event &&
+      event.type !== 'rerun' &&
+      !this.isFileRelevantForRouteTreeGeneration(event.path)
+    ) {
+      return
     }
     this.fileEventQueue.push(event ?? { type: 'rerun' })
     // only allow a single run at a time
@@ -233,7 +237,7 @@ export class Generator {
           await Promise.all(
             tempQueue.map(async (e) => {
               if (e.type === 'update') {
-                let cacheEntry
+                let cacheEntry: GeneratorCacheEntry | undefined
                 if (e.path === this.generatedRouteTreePath) {
                   cacheEntry = this.routeTreeFileCache
                 } else {
@@ -301,7 +305,11 @@ export class Generator {
       getRouteNodesResult = await physicalGetRouteNodes(this.config, this.root)
     }
 
-    const { rootRouteNode, routeNodes: beforeRouteNodes } = getRouteNodesResult
+    const {
+      rootRouteNode,
+      routeNodes: beforeRouteNodes,
+      physicalDirectories,
+    } = getRouteNodesResult
     if (rootRouteNode === undefined) {
       let errorMessage = `rootRouteNode must not be undefined. Make sure you've added your root route into the route-tree.`
       if (!this.config.virtualRouteConfig) {
@@ -309,6 +317,7 @@ export class Generator {
       }
       throw new Error(errorMessage)
     }
+    this.physicalDirectories = physicalDirectories
 
     writeRouteTreeFile = await this.handleRootNode(rootRouteNode)
 
@@ -1292,4 +1301,42 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${get
 
     acc.routeNodes.push(node)
   }
+
+  // only process files that are relevant for the route tree generation
+  private isFileRelevantForRouteTreeGeneration(filePath: string): boolean {
+    // the generated route tree file
+    if (filePath === this.generatedRouteTreePath) {
+      return true
+    }
+
+    // files inside the routes folder
+    if (filePath.startsWith(this.routesDirectoryPath)) {
+      return true
+    }
+
+    // the virtual route config file passed into `virtualRouteConfig`
+    if (
+      typeof this.config.virtualRouteConfig === 'string' &&
+      filePath === this.config.virtualRouteConfig
+    ) {
+      return true
+    }
+
+    // this covers all files that are mounted via `virtualRouteConfig` or any `__virtual.ts` files
+    if (this.routeNodeCache.has(filePath)) {
+      return true
+    }
+
+    // virtual config files such as`__virtual.ts`
+    if (isVirtualConfigFile(path.basename(filePath))) {
+      return true
+    }
+
+    // route files inside directories mounted via `physical()` inside a virtual route config
+    if (this.physicalDirectories.some((dir) => filePath.startsWith(dir))) {
+      return true
+    }
+
+    return false
+  }
 }

package/src/transform/transform.ts

@@ -56,35 +56,69 @@ export async function transform({
     registeredExports.set(exportName, plugin)
   }
 
+  function onExportFound(
+    decl: types.namedTypes.VariableDeclarator,
+    exportName: string,
+    plugin: TransformPlugin,
+  ) {
+    const pluginAppliedChanges = plugin.onExportFound({
+      decl,
+      ctx: { ...ctx, preferredQuote },
+    })
+    if (pluginAppliedChanges) {
+      appliedChanges = true
+    }
+
+    // export is handled, remove it from the registered exports
+    registeredExports.delete(exportName)
+    // store the export so we can later return it once the file is transformed
+    foundExports.push(exportName)
+  }
+
   const program: types.namedTypes.Program = ast.program
   // first pass: find registered exports
   for (const n of program.body) {
-    if (
-      registeredExports.size > 0 &&
-      n.type === 'ExportNamedDeclaration' &&
-      n.declaration?.type === 'VariableDeclaration'
-    ) {
-      const decl = n.declaration.declarations[0]
-      if (
-        decl &&
-        decl.type === 'VariableDeclarator' &&
-        decl.id.type === 'Identifier'
-      ) {
-        const plugin = registeredExports.get(decl.id.name)
-        if (plugin) {
-          const pluginAppliedChanges = plugin.onExportFound({
-            decl,
-            ctx: { ...ctx, preferredQuote },
-          })
-
-          if (pluginAppliedChanges) {
-            appliedChanges = true
+    if (registeredExports.size > 0 && n.type === 'ExportNamedDeclaration') {
+      // direct export of a variable declaration, e.g. `export const Route = createFileRoute('/path')`
+      if (n.declaration?.type === 'VariableDeclaration') {
+        const decl = n.declaration.declarations[0]
+        if (
+          decl &&
+          decl.type === 'VariableDeclarator' &&
+          decl.id.type === 'Identifier'
+        ) {
+          const plugin = registeredExports.get(decl.id.name)
+          if (plugin) {
+            onExportFound(decl, decl.id.name, plugin)
+          }
+        }
+      }
+      // this is an export without a declaration, e.g. `export { Route }`
+      else if (n.declaration === null && n.specifiers) {
+        for (const spec of n.specifiers) {
+          if (typeof spec.exported.name === 'string') {
+            const plugin = registeredExports.get(spec.exported.name)
+            if (plugin) {
+              const variableName = spec.local?.name || spec.exported.name
+              // find the matching variable declaration by iterating over the top-level declarations
+              for (const decl of program.body) {
+                if (
+                  decl.type === 'VariableDeclaration' &&
+                  decl.declarations[0]
+                ) {
+                  const variable = decl.declarations[0]
+                  if (
+                    variable.type === 'VariableDeclarator' &&
+                    variable.id.type === 'Identifier' &&
+                    variable.id.name === variableName
+                  ) {
+                    onExportFound(variable, spec.exported.name, plugin)
+                    break
+                  }
+                }
+              }
+            }
           }
-
-          // export is handled, remove it from the registered exports
-          registeredExports.delete(decl.id.name)
-          // store the export so we can later return it once the file is transformed
-          foundExports.push(decl.id.name)
         }
       }
     }

package/src/types.ts

@@ -18,6 +18,7 @@ export type RouteNode = {
 export interface GetRouteNodesResult {
   rootRouteNode?: RouteNode
   routeNodes: Array<RouteNode>
+  physicalDirectories: Array<string>
 }
 
 export type FsRouteType =