@tanstack/router-generator 1.132.0-alpha.9 → 1.132.0

package/dist/esm/generator.js

@@ -2,15 +2,14 @@ import path from "node:path";
 import * as fsp from "node:fs/promises";
 import { existsSync, mkdirSync } from "node:fs";
 import crypto from "node:crypto";
-import { deepEqual, rootRouteId } from "@tanstack/router-core";
+import { rootRouteId } from "@tanstack/router-core";
 import { logging } from "./logger.js";
 import { getRouteNodes as getRouteNodes$1, isVirtualConfigFile } from "./filesystem/physical/getRouteNodes.js";
 import { getRouteNodes } from "./filesystem/virtual/getRouteNodes.js";
 import { rootPathId } from "./filesystem/physical/rootPathId.js";
-import { multiSortBy, format, mergeImportDeclarations, buildImportString, replaceBackslash, removeExt, checkFileExists, resetRegex, hasParentRoute, determineNodePath, trimPathLeft, removeGroups, removeUnderscores, removeLayoutSegments, removeLastSegmentFromPath, routePathToVariable, buildRouteTreeConfig, findParent, createRouteNodesByFullPath, createRouteNodesByTo, createRouteNodesById, getResolvedRouteNodeVariableName, buildFileRoutesByPathInterface, lowerCaseFirstChar, isRouteNodeValidForAugmentation } from "./utils.js";
+import { multiSortBy, format, getImportForRouteNode, isRouteNodeValidForAugmentation, buildRouteTreeConfig, findParent, replaceBackslash, removeExt, createRouteNodesByFullPath, createRouteNodesByTo, createRouteNodesById, getResolvedRouteNodeVariableName, buildFileRoutesByPathInterface, checkRouteFullPathUniqueness, mergeImportDeclarations, buildImportString, checkFileExists, resetRegex, hasParentRoute, determineNodePath, trimPathLeft, removeGroups, removeUnderscores, removeLayoutSegments, removeLastSegmentFromPath, routePathToVariable, getImportPath } from "./utils.js";
 import { getTargetTemplate, fillTemplate } from "./template.js";
 import { transform } from "./transform/transform.js";
-import { defaultGeneratorPlugin } from "./plugin/default-generator-plugin.js";
 const DefaultFileSystem = {
   stat: async (filePath) => {
     const res = await fsp.stat(filePath, { bigint: true });
@@ -49,15 +48,12 @@ function rerun(opts) {
 function isRerun(result) {
   return typeof result === "object" && result !== null && "rerun" in result && result.rerun === true;
 }
-class Generator {
+const _Generator = class _Generator {
   constructor(opts) {
     this.routeNodeCache = /* @__PURE__ */ new Map();
     this.routeNodeShadowCache = /* @__PURE__ */ new Map();
     this.fileEventQueue = [];
-    this.plugins = [defaultGeneratorPlugin()];
-    this.pluginsWithTransform = [];
-    this.transformPlugins = [];
-    this.routeGroupPatternRegex = /\(.+\)/g;
+    this.plugins = [];
     this.physicalDirectories = [];
     this.config = opts.config;
     this.logger = logging({ disabled: this.config.disableLogging });
@@ -67,17 +63,9 @@ class Generator {
     this.targetTemplate = getTargetTemplate(this.config);
     this.routesDirectoryPath = this.getRoutesDirectoryPath();
     this.plugins.push(...opts.config.plugins || []);
-    this.plugins.forEach((plugin) => {
-      if ("transformPlugin" in plugin) {
-        if (this.pluginsWithTransform.find((p) => p.name === plugin.name)) {
-          throw new Error(
-            `Plugin with name "${plugin.name}" is already registered for export ${plugin.transformPlugin.exportName}!`
-          );
-        }
-        this.pluginsWithTransform.push(plugin);
-        this.transformPlugins.push(plugin.transformPlugin);
-      }
-    });
+    for (const plugin of this.plugins) {
+      plugin.init?.({ generator: this });
+    }
   }
   getGeneratedRouteTreePath() {
     const generatedRouteTreePath = path.isAbsolute(
@@ -136,12 +124,7 @@ class Generator {
           break;
         }
         try {
-          const start = performance.now();
           await this.generatorInternal();
-          const end = performance.now();
-          this.logger.info(
-            `Generated route tree in ${Math.round(end - start)}ms`
-          );
         } catch (err) {
           const errArray = !Array.isArray(err) ? [err] : err;
           const recoverableErrors = errArray.filter((e) => isRerun(e));
@@ -188,7 +171,7 @@ Add the file in: "${this.config.routesDirectory}/${rootPathId}.${this.config.dis
       throw new Error(errorMessage);
     }
     this.physicalDirectories = physicalDirectories;
-    writeRouteTreeFile = await this.handleRootNode(rootRouteNode);
+    await this.handleRootNode(rootRouteNode);
     const preRouteNodes = multiSortBy(beforeRouteNodes, [
       (d) => d.routePath === "/" ? -1 : 1,
       (d) => d.routePath?.split("/").length,
@@ -211,20 +194,23 @@ Add the file in: "${this.config.routesDirectory}/${rootPathId}.${this.config.dis
     }
     const routeFileResult = routeFileAllResult.flatMap((result) => {
       if (result.status === "fulfilled" && result.value !== null) {
-        return result.value;
+        if (result.value.shouldWriteTree) {
+          writeRouteTreeFile = true;
+        }
+        return result.value.node;
       }
       return [];
     });
-    routeFileResult.forEach((result) => {
-      if (!result.node.exports?.length) {
-        this.logger.warn(
-          `Route file "${result.cacheEntry.fileContent}" does not export any route piece. This is likely a mistake.`
-        );
-      }
-    });
-    if (routeFileResult.find((r) => r.shouldWriteTree)) {
-      writeRouteTreeFile = true;
+    routeFileResult.forEach((r) => r.children = void 0);
+    const acc = {
+      routeTree: [],
+      routeNodes: [],
+      routePiecesByPath: {}
+    };
+    for (const node of routeFileResult) {
+      _Generator.handleNode(node, acc);
     }
+    this.crawlingResult = { rootRouteNode, routeFileResult, acc };
     if (!this.routeTreeFileCache) {
       const routeTreeFile = await this.fs.readFile(this.generatedRouteTreePath);
       if (routeTreeFile !== "file-not-existing") {
@@ -255,10 +241,14 @@ Add the file in: "${this.config.routesDirectory}/${rootPathId}.${this.config.dis
       }
     }
     if (!writeRouteTreeFile) {
-      for (const fullPath of this.routeNodeCache.keys()) {
-        if (!this.routeNodeShadowCache.has(fullPath)) {
-          writeRouteTreeFile = true;
-          break;
+      if (this.routeNodeCache.size !== this.routeNodeShadowCache.size) {
+        writeRouteTreeFile = true;
+      } else {
+        for (const fullPath of this.routeNodeCache.keys()) {
+          if (!this.routeNodeShadowCache.has(fullPath)) {
+            writeRouteTreeFile = true;
+            break;
+          }
         }
       }
     }
@@ -266,11 +256,12 @@ Add the file in: "${this.config.routesDirectory}/${rootPathId}.${this.config.dis
       this.swapCaches();
       return;
     }
-    let routeTreeContent = this.buildRouteTreeFileContent(
+    const buildResult = this.buildRouteTree({
       rootRouteNode,
-      preRouteNodes,
+      acc,
       routeFileResult
-    );
+    });
+    let routeTreeContent = buildResult.routeTreeContent;
     routeTreeContent = this.config.enableRouteTreeFormatting ? await format(routeTreeContent, this.config) : routeTreeContent;
     let newMtimeMs;
     if (this.routeTreeFileCache) {
@@ -302,281 +293,258 @@ Add the file in: "${this.config.routesDirectory}/${rootPathId}.${this.config.dis
         mtimeMs: newMtimeMs
       };
     }
+    this.plugins.map((plugin) => {
+      return plugin.onRouteTreeChanged?.({
+        routeTree: buildResult.routeTree,
+        routeNodes: buildResult.routeNodes,
+        acc,
+        rootRouteNode
+      });
+    });
     this.swapCaches();
   }
   swapCaches() {
     this.routeNodeCache = this.routeNodeShadowCache;
     this.routeNodeShadowCache = /* @__PURE__ */ new Map();
   }
-  buildRouteTreeFileContent(rootRouteNode, preRouteNodes, routeFileResult) {
-    const getImportForRouteNode = (node, exportName) => {
-      if (node.exports?.includes(exportName)) {
-        return {
-          source: `./${this.getImportPath(node)}`,
-          specifiers: [
-            {
-              imported: exportName,
-              local: `${node.variableName}${exportName}Import`
-            }
-          ]
-        };
-      }
-      return void 0;
-    };
-    const buildRouteTreeForExport = (plugin) => {
-      const exportName = plugin.transformPlugin.exportName;
-      const acc = {
-        routeTree: [],
-        routeNodes: [],
-        routePiecesByPath: {}
+  buildRouteTree(opts) {
+    const config = { ...this.config, ...opts.config || {} };
+    const { rootRouteNode, acc } = opts;
+    const sortedRouteNodes = multiSortBy(acc.routeNodes, [
+      (d) => d.routePath?.includes(`/${rootPathId}`) ? -1 : 1,
+      (d) => d.routePath?.split("/").length,
+      (d) => d.routePath?.endsWith(config.indexToken) ? -1 : 1,
+      (d) => d
+    ]);
+    const routeImports = sortedRouteNodes.filter((d) => !d.isVirtual).flatMap(
+      (node) => getImportForRouteNode(
+        node,
+        config,
+        this.generatedRouteTreePath,
+        this.root
+      )
+    );
+    const virtualRouteNodes = sortedRouteNodes.filter((d) => d.isVirtual).map((node) => {
+      return `const ${node.variableName}RouteImport = createFileRoute('${node.routePath}')()`;
+    });
+    const imports = [];
+    if (acc.routeNodes.some((n) => n.isVirtual)) {
+      imports.push({
+        specifiers: [{ imported: "createFileRoute" }],
+        source: this.targetTemplate.fullPkg
+      });
+    }
+    if (config.verboseFileRoutes === false) {
+      const typeImport = {
+        specifiers: [],
+        source: this.targetTemplate.fullPkg,
+        importKind: "type"
       };
-      for (const node of preRouteNodes) {
-        if (node.exports?.includes(plugin.transformPlugin.exportName)) {
-          this.handleNode(node, acc);
-        }
+      if (sortedRouteNodes.some(
+        (d) => isRouteNodeValidForAugmentation(d) && d._fsRouteType !== "lazy"
+      )) {
+        typeImport.specifiers.push({ imported: "CreateFileRoute" });
       }
-      const sortedRouteNodes = multiSortBy(acc.routeNodes, [
-        (d) => d.routePath?.includes(`/${rootPathId}`) ? -1 : 1,
-        (d) => d.routePath?.split("/").length,
-        (d) => d.routePath?.endsWith(this.config.indexToken) ? -1 : 1,
-        (d) => d
-      ]);
-      const pluginConfig = plugin.config({
-        generator: this,
-        rootRouteNode,
-        sortedRouteNodes
-      });
-      const routeImports2 = sortedRouteNodes.filter((d) => !d.isVirtual).flatMap((node) => getImportForRouteNode(node, 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 (!rootRouteNode.exports?.includes(exportName) && pluginConfig.virtualRootRoute) {
-        virtualRouteNodes.unshift(
-          `const ${rootRouteNode.variableName}${exportName}Import = ${plugin.createRootRouteCode()}`
-        );
+      if (sortedRouteNodes.some(
+        (node) => acc.routePiecesByPath[node.routePath]?.lazy && isRouteNodeValidForAugmentation(node)
+      )) {
+        typeImport.specifiers.push({ imported: "CreateLazyFileRoute" });
       }
-      const imports = plugin.imports({
-        sortedRouteNodes,
-        acc,
-        generator: this,
-        rootRouteNode
-      });
-      const routeTreeConfig = buildRouteTreeConfig(
-        acc.routeTree,
-        exportName,
-        this.config.disableTypes
-      );
-      const createUpdateRoutes = sortedRouteNodes.map((node) => {
-        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({
+      if (typeImport.specifiers.length > 0) {
+        typeImport.specifiers.push({ imported: "FileRoutesByPath" });
+        imports.push(typeImport);
+      }
+    }
+    const routeTreeConfig = buildRouteTreeConfig(
+      acc.routeTree,
+      config.disableTypes
+    );
+    const createUpdateRoutes = sortedRouteNodes.map((node) => {
+      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}Route = ${node.variableName}RouteImport.update({
             ${[
-              `id: '${node.path}'`,
-              !node.isNonPath ? `path: '${node.cleanedPath}'` : void 0,
-              `getParentRoute: () => ${findParent(node, exportName)}`
-            ].filter(Boolean).join(",")}
-          }${this.config.disableTypes ? "" : "as any"})`,
-            loaderNode ? `.updateLoader({ loader: lazyFn(() => import('./${replaceBackslash(
-              removeExt(
-                path.relative(
-                  path.dirname(this.config.generatedRouteTree),
-                  path.resolve(
-                    this.config.routesDirectory,
-                    loaderNode.filePath
-                  )
-                ),
-                this.config.addExtensions
-              )
-            )}'), 'loader') })` : "",
-            componentNode || errorComponentNode || pendingComponentNode ? `.update({
+            `id: '${node.path}'`,
+            !node.isNonPath ? `path: '${node.cleanedPath}'` : void 0,
+            `getParentRoute: () => ${findParent(node)}`
+          ].filter(Boolean).join(",")}
+          }${config.disableTypes ? "" : "as any"})`,
+          loaderNode ? `.updateLoader({ loader: lazyFn(() => import('./${replaceBackslash(
+            removeExt(
+              path.relative(
+                path.dirname(config.generatedRouteTree),
+                path.resolve(config.routesDirectory, loaderNode.filePath)
+              ),
+              config.addExtensions
+            )
+          )}'), 'loader') })` : "",
+          componentNode || errorComponentNode || pendingComponentNode ? `.update({
                 ${[
-              ["component", componentNode],
-              ["errorComponent", errorComponentNode],
-              ["pendingComponent", pendingComponentNode]
-            ].filter((d) => d[1]).map((d) => {
-              return `${d[0]}: lazyRouteComponent(() => import('./${replaceBackslash(
-                removeExt(
-                  path.relative(
-                    path.dirname(this.config.generatedRouteTree),
-                    path.resolve(
-                      this.config.routesDirectory,
-                      d[1].filePath
-                    )
-                  ),
-                  this.config.addExtensions
-                )
-              )}'), '${d[0]}')`;
-            }).join("\n,")}
-              })` : "",
-            lazyComponentNode ? `.lazy(() => import('./${replaceBackslash(
+            ["component", componentNode],
+            ["errorComponent", errorComponentNode],
+            ["pendingComponent", pendingComponentNode]
+          ].filter((d) => d[1]).map((d) => {
+            return `${d[0]}: lazyRouteComponent(() => import('./${replaceBackslash(
               removeExt(
                 path.relative(
-                  path.dirname(this.config.generatedRouteTree),
-                  path.resolve(
-                    this.config.routesDirectory,
-                    lazyComponentNode.filePath
-                  )
+                  path.dirname(config.generatedRouteTree),
+                  path.resolve(config.routesDirectory, d[1].filePath)
                 ),
-                this.config.addExtensions
+                config.addExtensions
               )
-            )}').then((d) => d.${exportName}))` : ""
-          ].join("")
-        ].join("\n\n");
-      });
-      let fileRoutesByPathInterfacePerPlugin = "";
-      let fileRoutesByFullPathPerPlugin = "";
-      if (!this.config.disableTypes && hasMatchingRouteFiles) {
-        fileRoutesByFullPathPerPlugin = [
-          `export interface File${exportName}sByFullPath {
+            )}'), '${d[0]}')`;
+          }).join("\n,")}
+              })` : "",
+          lazyComponentNode ? `.lazy(() => import('./${replaceBackslash(
+            removeExt(
+              path.relative(
+                path.dirname(config.generatedRouteTree),
+                path.resolve(
+                  config.routesDirectory,
+                  lazyComponentNode.filePath
+                )
+              ),
+              config.addExtensions
+            )
+          )}').then((d) => d.Route))` : ""
+        ].join("")
+      ].join("\n\n");
+    });
+    let fileRoutesByPathInterface = "";
+    let fileRoutesByFullPath = "";
+    if (!config.disableTypes) {
+      fileRoutesByFullPath = [
+        `export interface FileRoutesByFullPath {
 ${[...createRouteNodesByFullPath(acc.routeNodes).entries()].filter(([fullPath]) => fullPath).map(([fullPath, routeNode]) => {
-            return `'${fullPath}': typeof ${getResolvedRouteNodeVariableName(routeNode, exportName)}`;
-          })}
+          return `'${fullPath}': typeof ${getResolvedRouteNodeVariableName(routeNode)}`;
+        })}
 }`,
-          `export interface File${exportName}sByTo {
+        `export interface FileRoutesByTo {
 ${[...createRouteNodesByTo(acc.routeNodes).entries()].filter(([to]) => to).map(([to, routeNode]) => {
-            return `'${to}': typeof ${getResolvedRouteNodeVariableName(routeNode, exportName)}`;
-          })}
+          return `'${to}': typeof ${getResolvedRouteNodeVariableName(routeNode)}`;
+        })}
 }`,
-          `export interface File${exportName}sById {
-'${rootRouteId}': typeof root${exportName}Import,
+        `export interface FileRoutesById {
+'${rootRouteId}': typeof rootRouteImport,
 ${[...createRouteNodesById(acc.routeNodes).entries()].map(([id, routeNode]) => {
-            return `'${id}': typeof ${getResolvedRouteNodeVariableName(routeNode, exportName)}`;
-          })}
+          return `'${id}': typeof ${getResolvedRouteNodeVariableName(routeNode)}`;
+        })}
 }`,
-          `export interface File${exportName}Types {
-file${exportName}sByFullPath: File${exportName}sByFullPath
+        `export interface FileRouteTypes {
+fileRoutesByFullPath: FileRoutesByFullPath
 fullPaths: ${acc.routeNodes.length > 0 ? [...createRouteNodesByFullPath(acc.routeNodes).keys()].filter((fullPath) => fullPath).map((fullPath) => `'${fullPath}'`).join("|") : "never"}
-file${exportName}sByTo: File${exportName}sByTo
+fileRoutesByTo: FileRoutesByTo
 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
+fileRoutesById: FileRoutesById
 }`,
-          `export interface Root${exportName}Children {
-${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${getResolvedRouteNodeVariableName(child, exportName)}`).join(",")}
+        `export interface RootRouteChildren {
+${acc.routeTree.map((child) => `${child.variableName}Route: typeof ${getResolvedRouteNodeVariableName(child)}`).join(",")}
 }`
-        ].join("\n");
-        fileRoutesByPathInterfacePerPlugin = buildFileRoutesByPathInterface({
-          ...plugin.moduleAugmentation({ generator: this }),
-          routeNodes: this.config.verboseFileRoutes !== false ? sortedRouteNodes : [
-            ...routeFileResult.map(({ node }) => node),
-            ...sortedRouteNodes.filter((d) => d.isVirtual)
-          ],
-          exportName
-        });
-      }
-      let routeTree = "";
-      if (hasMatchingRouteFiles) {
-        routeTree = [
-          `const root${exportName}Children${this.config.disableTypes ? "" : `: Root${exportName}Children`} = {
+      ].join("\n");
+      fileRoutesByPathInterface = buildFileRoutesByPathInterface({
+        module: this.targetTemplate.fullPkg,
+        interfaceName: "FileRoutesByPath",
+        routeNodes: sortedRouteNodes
+      });
+    }
+    const routeTree = [
+      `const rootRouteChildren${config.disableTypes ? "" : `: RootRouteChildren`} = {
   ${acc.routeTree.map(
-            (child) => `${child.variableName}${exportName}: ${getResolvedRouteNodeVariableName(child, exportName)}`
-          ).join(",")}
+        (child) => `${child.variableName}Route: ${getResolvedRouteNodeVariableName(child)}`
+      ).join(",")}
 }`,
-          `export const ${lowerCaseFirstChar(exportName)}Tree = root${exportName}Import._addFileChildren(root${exportName}Children)${this.config.disableTypes ? "" : `._addFileTypes<File${exportName}Types>()`}`
-        ].join("\n");
-      }
-      return {
-        routeImports: routeImports2,
-        sortedRouteNodes,
-        acc,
-        virtualRouteNodes,
-        routeTreeConfig,
-        routeTree,
-        imports,
-        createUpdateRoutes,
-        fileRoutesByFullPathPerPlugin,
-        fileRoutesByPathInterfacePerPlugin
-      };
-    };
-    const routeTrees = this.pluginsWithTransform.map((plugin) => ({
-      exportName: plugin.transformPlugin.exportName,
-      ...buildRouteTreeForExport(plugin)
-    }));
-    this.plugins.map((plugin) => {
-      return plugin.onRouteTreesChanged?.({
-        routeTrees,
-        rootRouteNode,
-        generator: this
-      });
-    });
-    let mergedImports = mergeImportDeclarations(
-      routeTrees.flatMap((d) => d.imports)
+      `export const routeTree = rootRouteImport._addFileChildren(rootRouteChildren)${config.disableTypes ? "" : `._addFileTypes<FileRouteTypes>()`}`
+    ].join("\n");
+    checkRouteFullPathUniqueness(
+      sortedRouteNodes.filter(
+        (d) => d.children === void 0 && "lazy" !== d._fsRouteType
+      ),
+      config
     );
-    if (this.config.disableTypes) {
+    let mergedImports = mergeImportDeclarations(imports);
+    if (config.disableTypes) {
       mergedImports = mergedImports.filter((d) => d.importKind !== "type");
     }
     const importStatements = mergedImports.map(buildImportString);
     let moduleAugmentation = "";
-    if (this.config.verboseFileRoutes === false && !this.config.disableTypes) {
-      moduleAugmentation = routeFileResult.map(({ node }) => {
+    if (config.verboseFileRoutes === false && !config.disableTypes) {
+      moduleAugmentation = opts.routeFileResult.map((node) => {
         const getModuleDeclaration = (routeNode) => {
           if (!isRouteNodeValidForAugmentation(routeNode)) {
             return "";
           }
-          const moduleAugmentation2 = this.pluginsWithTransform.map((plugin) => {
-            return plugin.routeModuleAugmentation({
-              routeNode
-            });
-          }).filter(Boolean).join("\n");
-          return `declare module './${this.getImportPath(routeNode)}' {
+          let moduleAugmentation2 = "";
+          if (routeNode._fsRouteType === "lazy") {
+            moduleAugmentation2 = `const createLazyFileRoute: CreateLazyFileRoute<FileRoutesByPath['${routeNode.routePath}']['preLoaderRoute']>`;
+          } else {
+            moduleAugmentation2 = `const createFileRoute: CreateFileRoute<'${routeNode.routePath}',
+                  FileRoutesByPath['${routeNode.routePath}']['parentRoute'],
+                  FileRoutesByPath['${routeNode.routePath}']['id'],
+                  FileRoutesByPath['${routeNode.routePath}']['path'],
+                  FileRoutesByPath['${routeNode.routePath}']['fullPath']
+                >
+              `;
+          }
+          return `declare module './${getImportPath(routeNode, config, this.generatedRouteTreePath)}' {
                       ${moduleAugmentation2}
                     }`;
         };
         return getModuleDeclaration(node);
       }).join("\n");
     }
-    const routeImports = routeTrees.flatMap((t) => t.routeImports);
-    const rootRouteImports = this.pluginsWithTransform.flatMap(
-      (p) => getImportForRouteNode(rootRouteNode, p.transformPlugin.exportName) ?? []
+    const rootRouteImport = getImportForRouteNode(
+      rootRouteNode,
+      config,
+      this.generatedRouteTreePath,
+      this.root
     );
-    if (rootRouteImports.length > 0) {
-      routeImports.unshift(...rootRouteImports);
+    routeImports.unshift(rootRouteImport);
+    let footer = [];
+    if (config.routeTreeFileFooter) {
+      if (Array.isArray(config.routeTreeFileFooter)) {
+        footer = config.routeTreeFileFooter;
+      } else {
+        footer = config.routeTreeFileFooter();
+      }
     }
     const routeTreeContent = [
-      ...this.config.routeTreeFileHeader,
+      ...config.routeTreeFileHeader,
       `// This file was automatically generated by TanStack Router.
 // You should NOT make any changes in this file as it will be overwritten.
 // Additionally, you should also exclude this file from your linter and/or formatter to prevent it from being checked or modified.`,
       [...importStatements].join("\n"),
       mergeImportDeclarations(routeImports).map(buildImportString).join("\n"),
-      routeTrees.flatMap((t) => t.virtualRouteNodes).join("\n"),
-      routeTrees.flatMap((t) => t.createUpdateRoutes).join("\n"),
-      routeTrees.map((t) => t.fileRoutesByFullPathPerPlugin).join("\n"),
-      routeTrees.map((t) => t.fileRoutesByPathInterfacePerPlugin).join("\n"),
+      virtualRouteNodes.join("\n"),
+      createUpdateRoutes.join("\n"),
+      fileRoutesByFullPath,
+      fileRoutesByPathInterface,
       moduleAugmentation,
-      routeTrees.flatMap((t) => t.routeTreeConfig).join("\n"),
-      routeTrees.map((t) => t.routeTree).join("\n"),
-      ...this.config.routeTreeFileFooter
+      routeTreeConfig.join("\n"),
+      routeTree,
+      ...footer
     ].filter(Boolean).join("\n\n");
-    return routeTreeContent;
-  }
-  getImportPath(node) {
-    return replaceBackslash(
-      removeExt(
-        path.relative(
-          path.dirname(this.config.generatedRouteTree),
-          path.resolve(this.config.routesDirectory, node.filePath)
-        ),
-        this.config.addExtensions
-      )
-    );
+    return {
+      routeTreeContent,
+      routeTree: acc.routeTree,
+      routeNodes: acc.routeNodes
+    };
   }
   async processRouteNodeFile(node) {
     const result = await this.isRouteFileCacheFresh(node);
     if (result.status === "fresh") {
-      node.exports = result.cacheEntry.exports;
       return {
-        node,
-        shouldWriteTree: result.exportsChanged,
+        node: result.cacheEntry.node,
+        shouldWriteTree: false,
         cacheEntry: result.cacheEntry
       };
     }
+    const previousCacheEntry = result.cacheEntry;
     const existingRouteFile = await this.fs.readFile(node.fullPath);
     if (existingRouteFile === "file-not-existing") {
       throw new Error(`⚠️ File ${node.fullPath} does not exist`);
@@ -584,13 +552,15 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${get
     const updatedCacheEntry = {
       fileContent: existingRouteFile.fileContent,
       mtimeMs: existingRouteFile.stat.mtimeMs,
-      exports: [],
-      routeId: node.routePath ?? "$$TSR_NO_ROUTE_PATH_ASSIGNED$$"
+      routeId: node.routePath ?? "$$TSR_NO_ROUTE_PATH_ASSIGNED$$",
+      node
     };
     const escapedRoutePath = node.routePath?.replaceAll("$", "$$") ?? "";
     let shouldWriteRouteFile = false;
+    let shouldWriteTree = false;
     if (!existingRouteFile.fileContent) {
       shouldWriteRouteFile = true;
+      shouldWriteTree = true;
       if (node._fsRouteType === "lazy") {
         const tLazyRouteTemplate = this.targetTemplate.lazyRoute;
         updatedCacheEntry.fileContent = await fillTemplate(
@@ -603,7 +573,6 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${get
             tsrExportEnd: tLazyRouteTemplate.imports.tsrExportEnd()
           }
         );
-        updatedCacheEntry.exports = ["Route"];
       } else if (
         // Creating a new normal route file
         ["layout", "static"].some(
@@ -626,31 +595,37 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${get
             tsrExportEnd: tRouteTemplate.imports.tsrExportEnd()
           }
         );
-        updatedCacheEntry.exports = ["Route"];
       } else {
         return null;
       }
-    } else {
-      const transformResult = await transform({
-        source: updatedCacheEntry.fileContent,
-        ctx: {
-          target: this.config.target,
-          routeId: escapedRoutePath,
-          lazy: node._fsRouteType === "lazy",
-          verboseFileRoutes: !(this.config.verboseFileRoutes === false)
-        },
-        plugins: this.transformPlugins
-      });
-      if (transformResult.result === "error") {
-        throw new Error(
-          `Error transforming route file ${node.fullPath}: ${transformResult.error}`
-        );
-      }
-      updatedCacheEntry.exports = transformResult.exports;
-      if (transformResult.result === "modified") {
-        updatedCacheEntry.fileContent = transformResult.output;
-        shouldWriteRouteFile = true;
-      }
+    }
+    const transformResult = await transform({
+      source: updatedCacheEntry.fileContent,
+      ctx: {
+        target: this.config.target,
+        routeId: escapedRoutePath,
+        lazy: node._fsRouteType === "lazy",
+        verboseFileRoutes: !(this.config.verboseFileRoutes === false)
+      },
+      node
+    });
+    if (transformResult.result === "no-route-export") {
+      this.logger.warn(
+        `Route file "${node.fullPath}" does not contain any route piece. This is likely a mistake.`
+      );
+      return null;
+    }
+    if (transformResult.result === "error") {
+      throw new Error(
+        `Error transforming route file ${node.fullPath}: ${transformResult.error}`
+      );
+    }
+    if (transformResult.result === "modified") {
+      updatedCacheEntry.fileContent = transformResult.output;
+      shouldWriteRouteFile = true;
+    }
+    for (const plugin of this.plugins) {
+      plugin.afterTransform?.({ node, prevNode: previousCacheEntry?.node });
     }
     if (shouldWriteRouteFile) {
       const stats = await this.safeFileWrite({
@@ -664,11 +639,6 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${get
       updatedCacheEntry.mtimeMs = stats.mtimeMs;
     }
     this.routeNodeShadowCache.set(node.fullPath, updatedCacheEntry);
-    node.exports = updatedCacheEntry.exports;
-    const shouldWriteTree = !deepEqual(
-      result.cacheEntry?.exports,
-      updatedCacheEntry.exports
-    );
     return {
       node,
       shouldWriteTree,
@@ -752,7 +722,6 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${get
       this.routeNodeShadowCache.set(node.fullPath, fileChangedCache.cacheEntry);
       return {
         status: "fresh",
-        exportsChanged: false,
         cacheEntry: fileChangedCache.cacheEntry
       };
     }
@@ -769,19 +738,8 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${get
     }
     if (shadowCacheFileChange.result === false) {
       if (fileChangedCache.result === true) {
-        if (deepEqual(
-          fileChangedCache.cacheEntry.exports,
-          shadowCacheFileChange.cacheEntry.exports
-        )) {
-          return {
-            status: "fresh",
-            exportsChanged: false,
-            cacheEntry: shadowCacheFileChange.cacheEntry
-          };
-        }
         return {
           status: "fresh",
-          exportsChanged: true,
           cacheEntry: shadowCacheFileChange.cacheEntry
         };
       }
@@ -796,9 +754,7 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${get
   async handleRootNode(node) {
     const result = await this.isRouteFileCacheFresh(node);
     if (result.status === "fresh") {
-      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") {
@@ -807,8 +763,8 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${get
     const updatedCacheEntry = {
       fileContent: rootNodeFile.fileContent,
       mtimeMs: rootNodeFile.stat.mtimeMs,
-      exports: [],
-      routeId: node.routePath ?? "$$TSR_NO_ROOT_ROUTE_PATH_ASSIGNED$$"
+      routeId: node.routePath ?? "$$TSR_NO_ROOT_ROUTE_PATH_ASSIGNED$$",
+      node
     };
     if (!rootNodeFile.fileContent) {
       const rootTemplate = this.targetTemplate.rootRoute;
@@ -834,23 +790,13 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${get
       updatedCacheEntry.fileContent = rootRouteContent;
       updatedCacheEntry.mtimeMs = stats.mtimeMs;
     }
-    const rootRouteExports = [];
-    for (const plugin of this.pluginsWithTransform) {
-      const exportName = plugin.transformPlugin.exportName;
-      if (rootNodeFile.fileContent.includes(`export const ${exportName}`)) {
-        rootRouteExports.push(exportName);
-      }
-    }
-    updatedCacheEntry.exports = rootRouteExports;
-    node.exports = rootRouteExports;
     this.routeNodeShadowCache.set(node.fullPath, updatedCacheEntry);
-    const shouldWriteTree = !deepEqual(
-      result.cacheEntry?.exports,
-      rootRouteExports
-    );
-    return shouldWriteTree;
   }
-  handleNode(node, acc) {
+  async getCrawlingResult() {
+    await this.runPromise;
+    return this.crawlingResult;
+  }
+  static handleNode(node, acc) {
     resetRegex(this.routeGroupPatternRegex);
     let parentRoute = hasParentRoute(acc.routeNodes, node, node.routePath);
     if (parentRoute?.isVirtualParentRoute && parentRoute.children?.length) {
@@ -964,7 +910,9 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${get
     }
     return false;
   }
-}
+};
+_Generator.routeGroupPatternRegex = /\(.+\)/g;
+let Generator = _Generator;
 export {
   Generator
 };