@tanstack/router-generator 1.121.0-alpha.27 → 1.121.0-alpha.28

package/src/generator.ts

@@ -1,13 +1,17 @@
 import path from 'node:path'
 import * as fsp from 'node:fs/promises'
-import { mkdtempSync } from 'node:fs'
+import { mkdirSync } 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 {
+  buildFileRoutesByPathInterface,
   buildImportString,
   buildRouteTreeConfig,
   checkFileExists,
@@ -19,8 +23,6 @@ import {
   format,
   getResolvedRouteNodeVariableName,
   hasParentRoute,
-  inferFullPath,
-  inferPath,
   isRouteNodeValidForAugmentation,
   lowerCaseFirstChar,
   mergeImportDeclarations,
@@ -46,6 +48,7 @@ import type { TargetTemplate } from './template'
 import type {
   FsRouteType,
   GetRouteNodesResult,
+  GetRoutesByFileMapResult,
   HandleNodeAccumulator,
   ImportDeclaration,
   RouteNode,
@@ -55,8 +58,9 @@ import type { Logger } from './logger'
 import type { TransformPlugin } from './transform/types'
 
 interface fs {
-  stat: (filePath: string) => Promise<{ mtimeMs: bigint }>
-  mkdtempSync: (prefix: string) => string
+  stat: (
+    filePath: string,
+  ) => Promise<{ mtimeMs: bigint; mode: number; uid: number; gid: number }>
   rename: (oldPath: string, newPath: string) => Promise<void>
   writeFile: (filePath: string, content: string) => Promise<void>
   readFile: (
@@ -64,11 +68,20 @@ interface fs {
   ) => Promise<
     { stat: { mtimeMs: bigint }; fileContent: string } | 'file-not-existing'
   >
+  chmod: (filePath: string, mode: number) => Promise<void>
+  chown: (filePath: string, uid: number, gid: number) => Promise<void>
 }
 
 const DefaultFileSystem: fs = {
-  stat: (filePath) => fsp.stat(filePath, { bigint: true }),
-  mkdtempSync: mkdtempSync,
+  stat: async (filePath) => {
+    const res = await fsp.stat(filePath, { bigint: true })
+    return {
+      mtimeMs: res.mtimeMs,
+      mode: Number(res.mode),
+      uid: Number(res.uid),
+      gid: Number(res.gid),
+    }
+  },
   rename: (oldPath, newPath) => fsp.rename(oldPath, newPath),
   writeFile: (filePath, content) => fsp.writeFile(filePath, content),
   readFile: async (filePath: string) => {
@@ -87,6 +100,8 @@ const DefaultFileSystem: fs = {
       throw e
     }
   },
+  chmod: (filePath, mode) => fsp.chmod(filePath, mode),
+  chown: (filePath, uid, gid) => fsp.chown(filePath, uid, gid),
 }
 
 interface Rerun {
@@ -135,6 +150,7 @@ interface GeneratorCacheEntry {
 
 interface RouteNodeCacheEntry extends GeneratorCacheEntry {
   exports: Array<string>
+  routeId: string
 }
 
 type GeneratorRouteNodeCache = Map</** filePath **/ string, RouteNodeCacheEntry>
@@ -160,7 +176,7 @@ export class Generator {
 
   private root: string
   private routesDirectoryPath: string
-  private tmpDir: string
+  private sessionId?: string
   private fs: fs
   private logger: Logger
   private generatedRouteTreePath: string
@@ -171,15 +187,13 @@ 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
     this.logger = logging({ disabled: this.config.disableLogging })
     this.root = opts.root
     this.fs = opts.fs || DefaultFileSystem
-    this.tmpDir = this.fs.mkdtempSync(
-      path.join(this.config.tmpDir, 'router-generator-'),
-    )
     this.generatedRouteTreePath = path.resolve(this.config.generatedRouteTree)
     this.targetTemplate = getTargetTemplate(this.config)
 
@@ -204,17 +218,22 @@ export class Generator {
       : path.resolve(this.root, this.config.routesDirectory)
   }
 
+  public getRoutesByFileMap(): GetRoutesByFileMapResult {
+    return new Map(
+      [...this.routeNodeCache.entries()].map(([filePath, cacheEntry]) => [
+        filePath,
+        { routePath: cacheEntry.routeId },
+      ]),
+    )
+  }
+
   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
@@ -234,7 +253,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 {
@@ -292,7 +311,7 @@ export class Generator {
   }
 
   private async generatorInternal() {
-    let writeRouteTreeFile = false as boolean
+    let writeRouteTreeFile: boolean | 'force' = false
 
     let getRouteNodesResult: GetRouteNodesResult
 
@@ -302,7 +321,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) {
@@ -310,6 +333,7 @@ export class Generator {
       }
       throw new Error(errorMessage)
     }
+    this.physicalDirectories = physicalDirectories
 
     writeRouteTreeFile = await this.handleRootNode(rootRouteNode)
 
@@ -376,9 +400,40 @@ export class Generator {
         }
       }
       writeRouteTreeFile = true
+    } else {
+      const routeTreeFileChange = await this.didFileChangeComparedToCache(
+        { path: this.generatedRouteTreePath },
+        this.routeTreeFileCache,
+      )
+      if (routeTreeFileChange.result !== false) {
+        writeRouteTreeFile = 'force'
+        if (routeTreeFileChange.result === true) {
+          const routeTreeFile = await this.fs.readFile(
+            this.generatedRouteTreePath,
+          )
+          if (routeTreeFile !== 'file-not-existing') {
+            this.routeTreeFileCache = {
+              fileContent: routeTreeFile.fileContent,
+              mtimeMs: routeTreeFile.stat.mtimeMs,
+            }
+          }
+        }
+      }
     }
 
     if (!writeRouteTreeFile) {
+      // only needs to be done if no other changes have been detected yet
+      // compare shadowCache and cache to identify deleted routes
+      for (const fullPath of this.routeNodeCache.keys()) {
+        if (!this.routeNodeShadowCache.has(fullPath)) {
+          writeRouteTreeFile = true
+          break
+        }
+      }
+    }
+
+    if (!writeRouteTreeFile) {
+      this.swapCaches()
       return
     }
 
@@ -393,7 +448,10 @@ export class Generator {
 
     let newMtimeMs: bigint | undefined
     if (this.routeTreeFileCache) {
-      if (this.routeTreeFileCache.fileContent === routeTreeContent) {
+      if (
+        writeRouteTreeFile !== 'force' &&
+        this.routeTreeFileCache.fileContent === routeTreeContent
+      ) {
         // existing route tree file is already up-to-date, don't write it
         // we should only get here in the initial run when the route cache is not filled yet
       } else {
@@ -425,7 +483,10 @@ export class Generator {
       }
     }
 
-    // now that we have finished this run, we can finally swap the caches
+    this.swapCaches()
+  }
+
+  private swapCaches() {
     this.routeNodeCache = this.routeNodeShadowCache
     this.routeNodeShadowCache = new Map()
   }
@@ -602,16 +663,18 @@ export class Generator {
       if (!this.config.disableTypes && hasMatchingRouteFiles) {
         fileRoutesByFullPathPerPlugin = [
           `export interface File${exportName}sByFullPath {
-${[...createRouteNodesByFullPath(acc.routeNodes).entries()].map(
-  ([fullPath, routeNode]) => {
+${[...createRouteNodesByFullPath(acc.routeNodes).entries()]
+  .filter(([fullPath]) => fullPath)
+  .map(([fullPath, routeNode]) => {
     return `'${fullPath}': typeof ${getResolvedRouteNodeVariableName(routeNode, exportName)}`
-  },
-)}
+  })}
 }`,
           `export interface File${exportName}sByTo {
-${[...createRouteNodesByTo(acc.routeNodes).entries()].map(([to, routeNode]) => {
-  return `'${to}': typeof ${getResolvedRouteNodeVariableName(routeNode, exportName)}`
-})}
+${[...createRouteNodesByTo(acc.routeNodes).entries()]
+  .filter(([to]) => to)
+  .map(([to, routeNode]) => {
+    return `'${to}': typeof ${getResolvedRouteNodeVariableName(routeNode, exportName)}`
+  })}
 }`,
           `export interface File${exportName}sById {
 '${rootRouteId}': typeof root${exportName}Import,
@@ -621,9 +684,23 @@ ${[...createRouteNodesById(acc.routeNodes).entries()].map(([id, routeNode]) => {
 }`,
           `export interface File${exportName}Types {
 file${exportName}sByFullPath: File${exportName}sByFullPath
-fullPaths: ${acc.routeNodes.length > 0 ? [...createRouteNodesByFullPath(acc.routeNodes).keys()].map((fullPath) => `'${fullPath}'`).join('|') : 'never'}
+fullPaths: ${
+            acc.routeNodes.length > 0
+              ? [...createRouteNodesByFullPath(acc.routeNodes).keys()]
+                  .filter((fullPath) => fullPath)
+                  .map((fullPath) => `'${fullPath}'`)
+                  .join('|')
+              : 'never'
+          }
 file${exportName}sByTo: File${exportName}sByTo
-to: ${acc.routeNodes.length > 0 ? [...createRouteNodesByTo(acc.routeNodes).keys()].map((to) => `'${to}'`).join('|') : 'never'}
+to: ${
+            acc.routeNodes.length > 0
+              ? [...createRouteNodesByTo(acc.routeNodes).keys()]
+                  .filter((to) => to)
+                  .map((to) => `'${to}'`)
+                  .join('|')
+              : 'never'
+          }
 id: ${[`'${rootRouteId}'`, ...[...createRouteNodesById(acc.routeNodes).keys()].map((id) => `'${id}'`)].join('|')}
 file${exportName}sById: File${exportName}sById
 }`,
@@ -634,7 +711,13 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${get
 
         fileRoutesByPathInterfacePerPlugin = buildFileRoutesByPathInterface({
           ...plugin.moduleAugmentation({ generator: this }),
-          routeNodes: preRouteNodes,
+          routeNodes:
+            this.config.verboseFileRoutes !== false
+              ? sortedRouteNodes
+              : [
+                  ...routeFileResult.map(({ node }) => node),
+                  ...sortedRouteNodes.filter((d) => d.isVirtual),
+                ],
           exportName,
         })
       }
@@ -784,6 +867,7 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${get
       fileContent: existingRouteFile.fileContent,
       mtimeMs: existingRouteFile.stat.mtimeMs,
       exports: [],
+      routeId: node.routePath ?? '$$TSR_NO_ROUTE_PATH_ASSIGNED$$',
     }
 
     const escapedRoutePath = node.routePath?.replaceAll('$', '$$') ?? ''
@@ -804,7 +888,7 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${get
             tLazyRouteTemplate.template(),
           {
             tsrImports: tLazyRouteTemplate.imports.tsrImports(),
-            tsrPath: escapedRoutePath.replaceAll(/\{(.+)\}/gm, '$1'),
+            tsrPath: escapedRoutePath.replaceAll(/\{(.+?)\}/gm, '$1'),
             tsrExportStart:
               tLazyRouteTemplate.imports.tsrExportStart(escapedRoutePath),
             tsrExportEnd: tLazyRouteTemplate.imports.tsrExportEnd(),
@@ -832,7 +916,7 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${get
             tRouteTemplate.template(),
           {
             tsrImports: tRouteTemplate.imports.tsrImports(),
-            tsrPath: escapedRoutePath.replaceAll(/\{(.+)\}/gm, '$1'),
+            tsrPath: escapedRoutePath.replaceAll(/\{(.+?)\}/gm, '$1'),
             tsrExportStart:
               tRouteTemplate.imports.tsrExportStart(escapedRoutePath),
             tsrExportEnd: tRouteTemplate.imports.tsrExportEnd(),
@@ -956,6 +1040,31 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${get
           event: { type: 'update', path: opts.filePath },
         })
       }
+      const newFileState = await this.fs.stat(tmpPath)
+      if (newFileState.mode !== beforeStat.mode) {
+        await this.fs.chmod(tmpPath, beforeStat.mode)
+      }
+      if (
+        newFileState.uid !== beforeStat.uid ||
+        newFileState.gid !== beforeStat.gid
+      ) {
+        try {
+          await this.fs.chown(tmpPath, beforeStat.uid, beforeStat.gid)
+        } catch (err) {
+          if (
+            typeof err === 'object' &&
+            err !== null &&
+            'code' in err &&
+            (err as any).code === 'EPERM'
+          ) {
+            console.warn(
+              `[safeFileWrite] chown failed: ${(err as any).message}`,
+            )
+          } else {
+            throw err
+          }
+        }
+      }
     } else {
       if (await checkFileExists(opts.filePath)) {
         throw rerun({
@@ -975,7 +1084,13 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${get
   private getTempFileName(filePath: string) {
     const absPath = path.resolve(filePath)
     const hash = crypto.createHash('md5').update(absPath).digest('hex')
-    return path.join(this.tmpDir, hash)
+    // lazy initialize sessionId to only create tmpDir when it is first needed
+    if (!this.sessionId) {
+      // ensure the directory exists
+      mkdirSync(this.config.tmpDir, { recursive: true })
+      this.sessionId = crypto.randomBytes(4).toString('hex')
+    }
+    return path.join(this.config.tmpDir, `${this.sessionId}-${hash}`)
   }
 
   private async isRouteFileCacheFresh(node: RouteNode): Promise<
@@ -1063,6 +1178,7 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${get
       fileContent: rootNodeFile.fileContent,
       mtimeMs: rootNodeFile.stat.mtimeMs,
       exports: [],
+      routeId: node.routePath ?? '$$TSR_NO_ROOT_ROUTE_PATH_ASSIGNED$$',
     }
 
     // scaffold the root route
@@ -1095,6 +1211,8 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${get
     const rootRouteExports: Array<string> = []
     for (const plugin of this.pluginsWithTransform) {
       const exportName = plugin.transformPlugin.exportName
+      // TODO we need to parse instead of just string match
+      // otherwise a commented out export will still be detected
       if (rootNodeFile.fileContent.includes(`export const ${exportName}`)) {
         rootRouteExports.push(exportName)
       }
@@ -1143,7 +1261,7 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${get
 
     node.isNonPath =
       lastRouteSegment.startsWith('_') ||
-      this.routeGroupPatternRegex.test(lastRouteSegment)
+      split.every((part) => this.routeGroupPatternRegex.test(part))
 
     node.cleanedPath = removeGroups(
       removeUnderscores(removeLayoutSegments(node.path)) ?? '',
@@ -1254,38 +1372,42 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${get
 
     acc.routeNodes.push(node)
   }
-}
 
-export function buildFileRoutesByPathInterface(opts: {
-  routeNodes: Array<RouteNode>
-  module: string
-  interfaceName: string
-  exportName: string
-}): string {
-  return `declare module '${opts.module}' {
-  interface ${opts.interfaceName} {
-    ${opts.routeNodes
-      .map((routeNode) => {
-        const filePathId = routeNode.routePath
-        let preloaderRoute = ''
-
-        if (routeNode.exports?.includes(opts.exportName)) {
-          preloaderRoute = `typeof ${routeNode.variableName}${opts.exportName}Import`
-        } else {
-          preloaderRoute = 'unknown'
-        }
+  // 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
+    }
 
-        const parent = findParent(routeNode, opts.exportName)
+    // files inside the routes folder
+    if (filePath.startsWith(this.routesDirectoryPath)) {
+      return true
+    }
 
-        return `'${filePathId}': {
-          id: '${filePathId}'
-          path: '${inferPath(routeNode)}'
-          fullPath: '${inferFullPath(routeNode)}'
-          preLoaderRoute: ${preloaderRoute}
-          parentRoute: typeof ${parent}
-        }`
-      })
-      .join('\n')}
+    // 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/index.ts

@@ -37,6 +37,8 @@ export {
 export type {
   RouteNode,
   GetRouteNodesResult,
+  GetRoutesByFileMapResult,
+  GetRoutesByFileMapResultValue,
   ImportDeclaration,
   ImportSpecifier,
 } from './types'

package/src/plugin/default-generator-plugin.ts

@@ -6,6 +6,7 @@ import {
 import type { ImportDeclaration } from '../types'
 import type { GeneratorPluginWithTransform } from './types'
 
+const EXPORT_NAME = 'Route'
 export function defaultGeneratorPlugin(): GeneratorPluginWithTransform {
   return {
     name: 'default',
@@ -47,6 +48,16 @@ export function defaultGeneratorPlugin(): GeneratorPluginWithTransform {
           imports.push(typeImport)
         }
       }
+      const hasMatchingRouteFiles = opts.acc.routeNodes.length > 0
+      if (hasMatchingRouteFiles) {
+        // needs a virtual root route
+        if (!opts.rootRouteNode.exports?.includes(EXPORT_NAME)) {
+          imports.push({
+            specifiers: [{ imported: 'createRootRoute' }],
+            source: opts.generator.targetTemplate.fullPkg,
+          })
+        }
+      }
       return imports
     },
     moduleAugmentation: ({ generator }) => ({
@@ -54,7 +65,9 @@ export function defaultGeneratorPlugin(): GeneratorPluginWithTransform {
       interfaceName: 'FileRoutesByPath',
     }),
     onRouteTreesChanged: ({ routeTrees, generator }) => {
-      const routeTree = routeTrees.find((tree) => tree.exportName === 'Route')
+      const routeTree = routeTrees.find(
+        (tree) => tree.exportName === EXPORT_NAME,
+      )
       if (!routeTree) {
         throw new Error(
           'No route tree found with export name "Route". Please ensure your routes are correctly defined.',
@@ -65,7 +78,7 @@ export function defaultGeneratorPlugin(): GeneratorPluginWithTransform {
           (d) =>
             d.children === undefined &&
             'lazy' !== d._fsRouteType &&
-            d.exports?.includes('Route'),
+            d.exports?.includes(EXPORT_NAME),
         ),
         generator.config,
       )
@@ -83,7 +96,7 @@ export function defaultGeneratorPlugin(): GeneratorPluginWithTransform {
         `
       }
     },
-    createRootRouteCode: () => `createRooRoute()`,
+    createRootRouteCode: () => `createRootRoute()`,
     createVirtualRouteCode: ({ node }) =>
       `createFileRoute('${node.routePath}')()`,
     config: ({ sortedRouteNodes }) => {

package/src/transform/default-transform-plugin.ts

@@ -4,9 +4,10 @@ import type { TransformImportsConfig, TransformPlugin } from './types'
 
 const b = types.builders
 
+const EXPORT_NAME = 'Route'
 export const defaultTransformPlugin: TransformPlugin = {
   name: 'default-transform',
-  exportName: 'Route',
+  exportName: EXPORT_NAME,
   imports: (ctx) => {
     const imports: TransformImportsConfig = {}
     const targetModule = `@tanstack/${ctx.target}-router`
@@ -87,7 +88,9 @@ export const defaultTransformPlugin: TransformPlugin = {
         }
       }
       if (identifier === undefined) {
-        throw new Error(`expected identifier to be present`)
+        throw new Error(
+          `expected identifier to be present in ${ctx.routeId} for export ${EXPORT_NAME}`,
+        )
       }
       if (identifier.name === 'createFileRoute' && ctx.lazy) {
         identifier.name = 'createLazyFileRoute'

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 =
@@ -54,3 +55,9 @@ export type HandleNodeAccumulator = {
   routePiecesByPath: Record<string, RouteSubNode>
   routeNodes: Array<RouteNode>
 }
+
+export type GetRoutesByFileMapResultValue = { routePath: string }
+export type GetRoutesByFileMapResult = Map<
+  string,
+  GetRoutesByFileMapResultValue
+>