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

package/dist/cjs/generator.cjs

@@ -31,8 +31,15 @@ function _interopNamespaceDefault(e) {
 }
 const fsp__namespace = /* @__PURE__ */ _interopNamespaceDefault(fsp);
 const DefaultFileSystem = {
-  stat: (filePath) => fsp__namespace.stat(filePath, { bigint: true }),
-  mkdtempSync: node_fs.mkdtempSync,
+  stat: async (filePath) => {
+    const res = await fsp__namespace.stat(filePath, { bigint: true });
+    return {
+      mtimeMs: res.mtimeMs,
+      mode: Number(res.mode),
+      uid: Number(res.uid),
+      gid: Number(res.gid)
+    };
+  },
   rename: (oldPath, newPath) => fsp__namespace.rename(oldPath, newPath),
   writeFile: (filePath, content) => fsp__namespace.writeFile(filePath, content),
   readFile: async (filePath) => {
@@ -50,7 +57,9 @@ const DefaultFileSystem = {
       }
       throw e;
     }
-  }
+  },
+  chmod: (filePath, mode) => fsp__namespace.chmod(filePath, mode),
+  chown: (filePath, uid, gid) => fsp__namespace.chown(filePath, uid, gid)
 };
 function rerun(opts) {
   const { event, ...rest } = opts;
@@ -68,13 +77,11 @@ class Generator {
     this.pluginsWithTransform = [];
     this.transformPlugins = [];
     this.routeGroupPatternRegex = /\(.+\)/g;
+    this.physicalDirectories = [];
     this.config = opts.config;
     this.logger = 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, "tanstack-router-")
-    );
     this.generatedRouteTreePath = path.resolve(this.config.generatedRouteTree);
     this.targetTemplate = template.getTargetTemplate(this.config);
     this.routesDirectoryPath = this.getRoutesDirectoryPath();
@@ -94,11 +101,17 @@ class Generator {
   getRoutesDirectoryPath() {
     return path.isAbsolute(this.config.routesDirectory) ? this.config.routesDirectory : path.resolve(this.root, this.config.routesDirectory);
   }
+  getRoutesByFileMap() {
+    return new Map(
+      [...this.routeNodeCache.entries()].map(([filePath, cacheEntry]) => [
+        filePath,
+        { routePath: cacheEntry.routeId }
+      ])
+    );
+  }
   async run(event) {
-    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" });
     if (this.runPromise) {
@@ -169,7 +182,11 @@ class Generator {
     } else {
       getRouteNodesResult = await getRouteNodes$1.getRouteNodes(this.config, this.root);
     }
-    const { rootRouteNode, routeNodes: beforeRouteNodes } = getRouteNodesResult;
+    const {
+      rootRouteNode,
+      routeNodes: beforeRouteNodes,
+      physicalDirectories
+    } = getRouteNodesResult;
     if (rootRouteNode === void 0) {
       let errorMessage = `rootRouteNode must not be undefined. Make sure you've added your root route into the route-tree.`;
       if (!this.config.virtualRouteConfig) {
@@ -179,22 +196,17 @@ Add the file in: "${this.config.routesDirectory}/${rootPathId.rootPathId}.${this
       }
       throw new Error(errorMessage);
     }
+    this.physicalDirectories = physicalDirectories;
     writeRouteTreeFile = await this.handleRootNode(rootRouteNode);
     const preRouteNodes = utils.multiSortBy(beforeRouteNodes, [
       (d) => d.routePath === "/" ? -1 : 1,
-      (d) => {
-        var _a;
-        return (_a = d.routePath) == null ? void 0 : _a.split("/").length;
-      },
+      (d) => d.routePath?.split("/").length,
       (d) => d.filePath.match(new RegExp(`[./]${this.config.indexToken}[.]`)) ? 1 : -1,
       (d) => d.filePath.match(
         /[./](component|errorComponent|pendingComponent|loader|lazy)[.]/
       ) ? 1 : -1,
       (d) => d.filePath.match(new RegExp(`[./]${this.config.routeToken}[.]`)) ? -1 : 1,
-      (d) => {
-        var _a;
-        return ((_a = d.routePath) == null ? void 0 : _a.endsWith("/")) ? -1 : 1;
-      },
+      (d) => d.routePath?.endsWith("/") ? -1 : 1,
       (d) => d.routePath
     ]).filter((d) => ![`/${rootPathId.rootPathId}`].includes(d.routePath || ""));
     const routeFileAllResult = await Promise.allSettled(
@@ -213,8 +225,7 @@ Add the file in: "${this.config.routesDirectory}/${rootPathId.rootPathId}.${this
       return [];
     });
     routeFileResult.forEach((result) => {
-      var _a;
-      if (!((_a = result.node.exports) == null ? void 0 : _a.length)) {
+      if (!result.node.exports?.length) {
         this.logger.warn(
           `Route file "${result.cacheEntry.fileContent}" does not export any route piece. This is likely a mistake.`
         );
@@ -232,8 +243,36 @@ Add the file in: "${this.config.routesDirectory}/${rootPathId.rootPathId}.${this
         };
       }
       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) {
+      for (const fullPath of this.routeNodeCache.keys()) {
+        if (!this.routeNodeShadowCache.has(fullPath)) {
+          writeRouteTreeFile = true;
+          break;
+        }
+      }
+    }
+    if (!writeRouteTreeFile) {
+      this.swapCaches();
       return;
     }
     let routeTreeContent = this.buildRouteTreeFileContent(
@@ -244,7 +283,7 @@ Add the file in: "${this.config.routesDirectory}/${rootPathId.rootPathId}.${this
     routeTreeContent = this.config.enableRouteTreeFormatting ? await utils.format(routeTreeContent, this.config) : routeTreeContent;
     let newMtimeMs;
     if (this.routeTreeFileCache) {
-      if (this.routeTreeFileCache.fileContent === routeTreeContent) ;
+      if (writeRouteTreeFile !== "force" && this.routeTreeFileCache.fileContent === routeTreeContent) ;
       else {
         const newRouteTreeFileStat = await this.safeFileWrite({
           filePath: this.generatedRouteTreePath,
@@ -272,13 +311,15 @@ Add the file in: "${this.config.routesDirectory}/${rootPathId.rootPathId}.${this
         mtimeMs: newMtimeMs
       };
     }
+    this.swapCaches();
+  }
+  swapCaches() {
     this.routeNodeCache = this.routeNodeShadowCache;
     this.routeNodeShadowCache = /* @__PURE__ */ new Map();
   }
   buildRouteTreeFileContent(rootRouteNode, preRouteNodes, routeFileResult) {
     const getImportForRouteNode = (node, exportName) => {
-      var _a;
-      if ((_a = node.exports) == null ? void 0 : _a.includes(exportName)) {
+      if (node.exports?.includes(exportName)) {
         return {
           source: `./${this.getImportPath(node)}`,
           specifiers: [
@@ -292,7 +333,6 @@ Add the file in: "${this.config.routesDirectory}/${rootPathId.rootPathId}.${this
       return void 0;
     };
     const buildRouteTreeForExport = (plugin) => {
-      var _a, _b, _c;
       const exportName = plugin.transformPlugin.exportName;
       const acc = {
         routeTree: [],
@@ -300,23 +340,14 @@ Add the file in: "${this.config.routesDirectory}/${rootPathId.rootPathId}.${this
         routePiecesByPath: {}
       };
       for (const node of preRouteNodes) {
-        if ((_a = node.exports) == null ? void 0 : _a.includes(plugin.transformPlugin.exportName)) {
+        if (node.exports?.includes(plugin.transformPlugin.exportName)) {
           this.handleNode(node, acc);
         }
       }
       const sortedRouteNodes = utils.multiSortBy(acc.routeNodes, [
-        (d) => {
-          var _a2;
-          return ((_a2 = d.routePath) == null ? void 0 : _a2.includes(`/${rootPathId.rootPathId}`)) ? -1 : 1;
-        },
-        (d) => {
-          var _a2;
-          return (_a2 = d.routePath) == null ? void 0 : _a2.split("/").length;
-        },
-        (d) => {
-          var _a2;
-          return ((_a2 = d.routePath) == null ? void 0 : _a2.endsWith(this.config.indexToken)) ? -1 : 1;
-        },
+        (d) => d.routePath?.includes(`/${rootPathId.rootPathId}`) ? -1 : 1,
+        (d) => d.routePath?.split("/").length,
+        (d) => d.routePath?.endsWith(this.config.indexToken) ? -1 : 1,
         (d) => d
       ]);
       const pluginConfig = plugin.config({
@@ -325,11 +356,11 @@ Add the file in: "${this.config.routesDirectory}/${rootPathId.rootPathId}.${this
         sortedRouteNodes
       });
       const routeImports2 = sortedRouteNodes.filter((d) => !d.isVirtual).flatMap((node) => getImportForRouteNode(node, exportName) ?? []);
-      const hasMatchingRouteFiles = acc.routeNodes.length > 0 || ((_b = rootRouteNode.exports) == null ? void 0 : _b.includes(exportName));
+      const hasMatchingRouteFiles = acc.routeNodes.length > 0 || rootRouteNode.exports?.includes(exportName);
       const virtualRouteNodes = sortedRouteNodes.filter((d) => d.isVirtual).map((node) => {
         return `const ${node.variableName}${exportName}Import = ${plugin.createVirtualRouteCode({ node })}`;
       });
-      if (!((_c = rootRouteNode.exports) == null ? void 0 : _c.includes(exportName)) && pluginConfig.virtualRootRoute) {
+      if (!rootRouteNode.exports?.includes(exportName) && pluginConfig.virtualRootRoute) {
         virtualRouteNodes.unshift(
           `const ${rootRouteNode.variableName}${exportName}Import = ${plugin.createRootRouteCode()}`
         );
@@ -346,12 +377,11 @@ Add the file in: "${this.config.routesDirectory}/${rootPathId.rootPathId}.${this
         this.config.disableTypes
       );
       const createUpdateRoutes = sortedRouteNodes.map((node) => {
-        var _a2, _b2, _c2, _d, _e;
-        const loaderNode = (_a2 = acc.routePiecesByPath[node.routePath]) == null ? void 0 : _a2.loader;
-        const componentNode = (_b2 = acc.routePiecesByPath[node.routePath]) == null ? void 0 : _b2.component;
-        const errorComponentNode = (_c2 = acc.routePiecesByPath[node.routePath]) == null ? void 0 : _c2.errorComponent;
-        const pendingComponentNode = (_d = acc.routePiecesByPath[node.routePath]) == null ? void 0 : _d.pendingComponent;
-        const lazyComponentNode = (_e = acc.routePiecesByPath[node.routePath]) == null ? void 0 : _e.lazy;
+        const loaderNode = acc.routePiecesByPath[node.routePath]?.loader;
+        const componentNode = acc.routePiecesByPath[node.routePath]?.component;
+        const errorComponentNode = acc.routePiecesByPath[node.routePath]?.errorComponent;
+        const pendingComponentNode = acc.routePiecesByPath[node.routePath]?.pendingComponent;
+        const lazyComponentNode = acc.routePiecesByPath[node.routePath]?.lazy;
         return [
           [
             `const ${node.variableName}${exportName} = ${node.variableName}${exportName}Import.update({
@@ -413,14 +443,12 @@ Add the file in: "${this.config.routesDirectory}/${rootPathId.rootPathId}.${this
       if (!this.config.disableTypes && hasMatchingRouteFiles) {
         fileRoutesByFullPathPerPlugin = [
           `export interface File${exportName}sByFullPath {
-${[...utils.createRouteNodesByFullPath(acc.routeNodes).entries()].map(
-            ([fullPath, routeNode]) => {
-              return `'${fullPath}': typeof ${utils.getResolvedRouteNodeVariableName(routeNode, exportName)}`;
-            }
-          )}
+${[...utils.createRouteNodesByFullPath(acc.routeNodes).entries()].filter(([fullPath]) => fullPath).map(([fullPath, routeNode]) => {
+            return `'${fullPath}': typeof ${utils.getResolvedRouteNodeVariableName(routeNode, exportName)}`;
+          })}
 }`,
           `export interface File${exportName}sByTo {
-${[...utils.createRouteNodesByTo(acc.routeNodes).entries()].map(([to, routeNode]) => {
+${[...utils.createRouteNodesByTo(acc.routeNodes).entries()].filter(([to]) => to).map(([to, routeNode]) => {
             return `'${to}': typeof ${utils.getResolvedRouteNodeVariableName(routeNode, exportName)}`;
           })}
 }`,
@@ -432,9 +460,9 @@ ${[...utils.createRouteNodesById(acc.routeNodes).entries()].map(([id, routeNode]
 }`,
           `export interface File${exportName}Types {
 file${exportName}sByFullPath: File${exportName}sByFullPath
-fullPaths: ${acc.routeNodes.length > 0 ? [...utils.createRouteNodesByFullPath(acc.routeNodes).keys()].map((fullPath) => `'${fullPath}'`).join("|") : "never"}
+fullPaths: ${acc.routeNodes.length > 0 ? [...utils.createRouteNodesByFullPath(acc.routeNodes).keys()].filter((fullPath) => fullPath).map((fullPath) => `'${fullPath}'`).join("|") : "never"}
 file${exportName}sByTo: File${exportName}sByTo
-to: ${acc.routeNodes.length > 0 ? [...utils.createRouteNodesByTo(acc.routeNodes).keys()].map((to) => `'${to}'`).join("|") : "never"}
+to: ${acc.routeNodes.length > 0 ? [...utils.createRouteNodesByTo(acc.routeNodes).keys()].filter((to) => to).map((to) => `'${to}'`).join("|") : "never"}
 id: ${[`'${routerCore.rootRouteId}'`, ...[...utils.createRouteNodesById(acc.routeNodes).keys()].map((id) => `'${id}'`)].join("|")}
 file${exportName}sById: File${exportName}sById
 }`,
@@ -442,9 +470,12 @@ file${exportName}sById: File${exportName}sById
 ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${utils.getResolvedRouteNodeVariableName(child, exportName)}`).join(",")}
 }`
         ].join("\n");
-        fileRoutesByPathInterfacePerPlugin = buildFileRoutesByPathInterface({
+        fileRoutesByPathInterfacePerPlugin = utils.buildFileRoutesByPathInterface({
           ...plugin.moduleAugmentation({ generator: this }),
-          routeNodes: preRouteNodes,
+          routeNodes: this.config.verboseFileRoutes !== false ? sortedRouteNodes : [
+            ...routeFileResult.map(({ node }) => node),
+            ...sortedRouteNodes.filter((d) => d.isVirtual)
+          ],
           exportName
         });
       }
@@ -477,8 +508,7 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${uti
       ...buildRouteTreeForExport(plugin)
     }));
     this.plugins.map((plugin) => {
-      var _a;
-      return (_a = plugin.onRouteTreesChanged) == null ? void 0 : _a.call(plugin, {
+      return plugin.onRouteTreesChanged?.({
         routeTrees,
         rootRouteNode,
         generator: this
@@ -547,7 +577,6 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${uti
     );
   }
   async processRouteNodeFile(node) {
-    var _a, _b, _c, _d, _e;
     const result = await this.isRouteFileCacheFresh(node);
     if (result.status === "fresh") {
       node.exports = result.cacheEntry.exports;
@@ -564,9 +593,10 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${uti
     const updatedCacheEntry = {
       fileContent: existingRouteFile.fileContent,
       mtimeMs: existingRouteFile.stat.mtimeMs,
-      exports: []
+      exports: [],
+      routeId: node.routePath ?? "$$TSR_NO_ROUTE_PATH_ASSIGNED$$"
     };
-    const escapedRoutePath = ((_a = node.routePath) == null ? void 0 : _a.replaceAll("$", "$$")) ?? "";
+    const escapedRoutePath = node.routePath?.replaceAll("$", "$$") ?? "";
     let shouldWriteRouteFile = false;
     if (!existingRouteFile.fileContent) {
       shouldWriteRouteFile = true;
@@ -574,10 +604,10 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${uti
         const tLazyRouteTemplate = this.targetTemplate.lazyRoute;
         updatedCacheEntry.fileContent = await template.fillTemplate(
           this.config,
-          (((_b = this.config.customScaffolding) == null ? void 0 : _b.lazyRouteTemplate) || ((_c = this.config.customScaffolding) == null ? void 0 : _c.routeTemplate)) ?? tLazyRouteTemplate.template(),
+          (this.config.customScaffolding?.lazyRouteTemplate || this.config.customScaffolding?.routeTemplate) ?? 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()
           }
@@ -597,10 +627,10 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${uti
         const tRouteTemplate = this.targetTemplate.route;
         updatedCacheEntry.fileContent = await template.fillTemplate(
           this.config,
-          ((_d = this.config.customScaffolding) == null ? void 0 : _d.routeTemplate) ?? tRouteTemplate.template(),
+          this.config.customScaffolding?.routeTemplate ?? 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()
           }
@@ -645,7 +675,7 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${uti
     this.routeNodeShadowCache.set(node.fullPath, updatedCacheEntry);
     node.exports = updatedCacheEntry.exports;
     const shouldWriteTree = !routerCore.deepEqual(
-      (_e = result.cacheEntry) == null ? void 0 : _e.exports,
+      result.cacheEntry?.exports,
       updatedCacheEntry.exports
     );
     return {
@@ -684,6 +714,23 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${uti
           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.code === "EPERM") {
+            console.warn(
+              `[safeFileWrite] chown failed: ${err.message}`
+            );
+          } else {
+            throw err;
+          }
+        }
+      }
     } else {
       if (await utils.checkFileExists(opts.filePath)) {
         throw rerun({
@@ -699,7 +746,11 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${uti
   getTempFileName(filePath) {
     const absPath = path.resolve(filePath);
     const hash = crypto.createHash("md5").update(absPath).digest("hex");
-    return path.join(this.tmpDir, hash);
+    if (!this.sessionId) {
+      node_fs.mkdirSync(this.config.tmpDir, { recursive: true });
+      this.sessionId = crypto.randomBytes(4).toString("hex");
+    }
+    return path.join(this.config.tmpDir, `${this.sessionId}-${hash}`);
   }
   async isRouteFileCacheFresh(node) {
     const fileChangedCache = await this.didRouteFileChangeComparedToCache(
@@ -752,10 +803,11 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${uti
     return { status: "stale", cacheEntry: fileChangedCache.cacheEntry };
   }
   async handleRootNode(node) {
-    var _a;
     const result = await this.isRouteFileCacheFresh(node);
     if (result.status === "fresh") {
-      return false;
+      node.exports = result.cacheEntry.exports;
+      this.routeNodeShadowCache.set(node.fullPath, result.cacheEntry);
+      return result.exportsChanged;
     }
     const rootNodeFile = await this.fs.readFile(node.fullPath);
     if (rootNodeFile === "file-not-existing") {
@@ -764,7 +816,8 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${uti
     const updatedCacheEntry = {
       fileContent: rootNodeFile.fileContent,
       mtimeMs: rootNodeFile.stat.mtimeMs,
-      exports: []
+      exports: [],
+      routeId: node.routePath ?? "$$TSR_NO_ROOT_ROUTE_PATH_ASSIGNED$$"
     };
     if (!rootNodeFile.fileContent) {
       const rootTemplate = this.targetTemplate.rootRoute;
@@ -801,16 +854,15 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${uti
     node.exports = rootRouteExports;
     this.routeNodeShadowCache.set(node.fullPath, updatedCacheEntry);
     const shouldWriteTree = !routerCore.deepEqual(
-      (_a = result.cacheEntry) == null ? void 0 : _a.exports,
+      result.cacheEntry?.exports,
       rootRouteExports
     );
     return shouldWriteTree;
   }
   handleNode(node, acc) {
-    var _a;
     utils.resetRegex(this.routeGroupPatternRegex);
     let parentRoute = utils.hasParentRoute(acc.routeNodes, node, node.routePath);
-    if ((parentRoute == null ? void 0 : parentRoute.isVirtualParentRoute) && ((_a = parentRoute.children) == null ? void 0 : _a.length)) {
+    if (parentRoute?.isVirtualParentRoute && parentRoute.children?.length) {
       const possibleParentRoute = utils.hasParentRoute(
         parentRoute.children,
         node,
@@ -825,7 +877,7 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${uti
     const trimmedPath = utils.trimPathLeft(node.path ?? "");
     const split = trimmedPath.split("/");
     const lastRouteSegment = split[split.length - 1] ?? trimmedPath;
-    node.isNonPath = lastRouteSegment.startsWith("_") || this.routeGroupPatternRegex.test(lastRouteSegment);
+    node.isNonPath = lastRouteSegment.startsWith("_") || split.every((part) => this.routeGroupPatternRegex.test(part));
     node.cleanedPath = utils.removeGroups(
       utils.removeUnderscores(utils.removeLayoutSegments(node.path)) ?? ""
     );
@@ -899,31 +951,28 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${uti
     }
     acc.routeNodes.push(node);
   }
-}
-function buildFileRoutesByPathInterface(opts) {
-  return `declare module '${opts.module}' {
-  interface ${opts.interfaceName} {
-    ${opts.routeNodes.map((routeNode) => {
-    var _a;
-    const filePathId = routeNode.routePath;
-    let preloaderRoute = "";
-    if ((_a = routeNode.exports) == null ? void 0 : _a.includes(opts.exportName)) {
-      preloaderRoute = `typeof ${routeNode.variableName}${opts.exportName}Import`;
-    } else {
-      preloaderRoute = "unknown";
-    }
-    const parent = utils.findParent(routeNode, opts.exportName);
-    return `'${filePathId}': {
-          id: '${filePathId}'
-          path: '${utils.inferPath(routeNode)}'
-          fullPath: '${utils.inferFullPath(routeNode)}'
-          preLoaderRoute: ${preloaderRoute}
-          parentRoute: typeof ${parent}
-        }`;
-  }).join("\n")}
+  // only process files that are relevant for the route tree generation
+  isFileRelevantForRouteTreeGeneration(filePath) {
+    if (filePath === this.generatedRouteTreePath) {
+      return true;
+    }
+    if (filePath.startsWith(this.routesDirectoryPath)) {
+      return true;
+    }
+    if (typeof this.config.virtualRouteConfig === "string" && filePath === this.config.virtualRouteConfig) {
+      return true;
+    }
+    if (this.routeNodeCache.has(filePath)) {
+      return true;
+    }
+    if (getRouteNodes$1.isVirtualConfigFile(path.basename(filePath))) {
+      return true;
+    }
+    if (this.physicalDirectories.some((dir) => filePath.startsWith(dir))) {
+      return true;
+    }
+    return false;
   }
-}`;
 }
 exports.Generator = Generator;
-exports.buildFileRoutesByPathInterface = buildFileRoutesByPathInterface;
 //# sourceMappingURL=generator.cjs.map