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

package/dist/cjs/generator.cjs

@@ -12,7 +12,6 @@ const rootPathId = require("./filesystem/physical/rootPathId.cjs");
 const utils = require("./utils.cjs");
 const template = require("./template.cjs");
 const transform = require("./transform/transform.cjs");
-const defaultGeneratorPlugin = require("./plugin/default-generator-plugin.cjs");
 function _interopNamespaceDefault(e) {
   const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
   if (e) {
@@ -68,15 +67,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.defaultGeneratorPlugin()];
-    this.pluginsWithTransform = [];
-    this.transformPlugins = [];
-    this.routeGroupPatternRegex = /\(.+\)/g;
+    this.plugins = [];
     this.physicalDirectories = [];
     this.config = opts.config;
     this.logger = logger.logging({ disabled: this.config.disableLogging });
@@ -86,17 +82,9 @@ class Generator {
     this.targetTemplate = template.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(
@@ -155,12 +143,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));
@@ -207,7 +190,7 @@ Add the file in: "${this.config.routesDirectory}/${rootPathId.rootPathId}.${this
       throw new Error(errorMessage);
     }
     this.physicalDirectories = physicalDirectories;
-    writeRouteTreeFile = await this.handleRootNode(rootRouteNode);
+    await this.handleRootNode(rootRouteNode);
     const preRouteNodes = utils.multiSortBy(beforeRouteNodes, [
       (d) => d.routePath === "/" ? -1 : 1,
       (d) => d.routePath?.split("/").length,
@@ -230,20 +213,23 @@ Add the file in: "${this.config.routesDirectory}/${rootPathId.rootPathId}.${this
     }
     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") {
@@ -274,10 +260,14 @@ Add the file in: "${this.config.routesDirectory}/${rootPathId.rootPathId}.${this
       }
     }
     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;
+          }
         }
       }
     }
@@ -285,11 +275,12 @@ Add the file in: "${this.config.routesDirectory}/${rootPathId.rootPathId}.${this
       this.swapCaches();
       return;
     }
-    let routeTreeContent = this.buildRouteTreeFileContent(
+    const buildResult = this.buildRouteTree({
       rootRouteNode,
-      preRouteNodes,
+      acc,
       routeFileResult
-    );
+    });
+    let routeTreeContent = buildResult.routeTreeContent;
     routeTreeContent = this.config.enableRouteTreeFormatting ? await utils.format(routeTreeContent, this.config) : routeTreeContent;
     let newMtimeMs;
     if (this.routeTreeFileCache) {
@@ -321,281 +312,258 @@ Add the file in: "${this.config.routesDirectory}/${rootPathId.rootPathId}.${this
         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 = utils.multiSortBy(acc.routeNodes, [
+      (d) => d.routePath?.includes(`/${rootPathId.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) => utils.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) => utils.isRouteNodeValidForAugmentation(d) && d._fsRouteType !== "lazy"
+      )) {
+        typeImport.specifiers.push({ imported: "CreateFileRoute" });
       }
-      const sortedRouteNodes = utils.multiSortBy(acc.routeNodes, [
-        (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({
-        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 && utils.isRouteNodeValidForAugmentation(node)
+      )) {
+        typeImport.specifiers.push({ imported: "CreateLazyFileRoute" });
       }
-      const imports = plugin.imports({
-        sortedRouteNodes,
-        acc,
-        generator: this,
-        rootRouteNode
-      });
-      const routeTreeConfig = utils.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 = utils.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: () => ${utils.findParent(node, exportName)}`
-            ].filter(Boolean).join(",")}
-          }${this.config.disableTypes ? "" : "as any"})`,
-            loaderNode ? `.updateLoader({ loader: lazyFn(() => import('./${utils.replaceBackslash(
-              utils.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: () => ${utils.findParent(node)}`
+          ].filter(Boolean).join(",")}
+          }${config.disableTypes ? "" : "as any"})`,
+          loaderNode ? `.updateLoader({ loader: lazyFn(() => import('./${utils.replaceBackslash(
+            utils.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('./${utils.replaceBackslash(
-                utils.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('./${utils.replaceBackslash(
+            ["component", componentNode],
+            ["errorComponent", errorComponentNode],
+            ["pendingComponent", pendingComponentNode]
+          ].filter((d) => d[1]).map((d) => {
+            return `${d[0]}: lazyRouteComponent(() => import('./${utils.replaceBackslash(
               utils.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('./${utils.replaceBackslash(
+            utils.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 {
 ${[...utils.createRouteNodesByFullPath(acc.routeNodes).entries()].filter(([fullPath]) => fullPath).map(([fullPath, routeNode]) => {
-            return `'${fullPath}': typeof ${utils.getResolvedRouteNodeVariableName(routeNode, exportName)}`;
-          })}
+          return `'${fullPath}': typeof ${utils.getResolvedRouteNodeVariableName(routeNode)}`;
+        })}
 }`,
-          `export interface File${exportName}sByTo {
+        `export interface FileRoutesByTo {
 ${[...utils.createRouteNodesByTo(acc.routeNodes).entries()].filter(([to]) => to).map(([to, routeNode]) => {
-            return `'${to}': typeof ${utils.getResolvedRouteNodeVariableName(routeNode, exportName)}`;
-          })}
+          return `'${to}': typeof ${utils.getResolvedRouteNodeVariableName(routeNode)}`;
+        })}
 }`,
-          `export interface File${exportName}sById {
-'${routerCore.rootRouteId}': typeof root${exportName}Import,
+        `export interface FileRoutesById {
+'${routerCore.rootRouteId}': typeof rootRouteImport,
 ${[...utils.createRouteNodesById(acc.routeNodes).entries()].map(([id, routeNode]) => {
-            return `'${id}': typeof ${utils.getResolvedRouteNodeVariableName(routeNode, exportName)}`;
-          })}
+          return `'${id}': typeof ${utils.getResolvedRouteNodeVariableName(routeNode)}`;
+        })}
 }`,
-          `export interface File${exportName}Types {
-file${exportName}sByFullPath: File${exportName}sByFullPath
+        `export interface FileRouteTypes {
+fileRoutesByFullPath: FileRoutesByFullPath
 fullPaths: ${acc.routeNodes.length > 0 ? [...utils.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 ? [...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
+fileRoutesById: FileRoutesById
 }`,
-          `export interface Root${exportName}Children {
-${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${utils.getResolvedRouteNodeVariableName(child, exportName)}`).join(",")}
+        `export interface RootRouteChildren {
+${acc.routeTree.map((child) => `${child.variableName}Route: typeof ${utils.getResolvedRouteNodeVariableName(child)}`).join(",")}
 }`
-        ].join("\n");
-        fileRoutesByPathInterfacePerPlugin = utils.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 = utils.buildFileRoutesByPathInterface({
+        module: this.targetTemplate.fullPkg,
+        interfaceName: "FileRoutesByPath",
+        routeNodes: sortedRouteNodes
+      });
+    }
+    const routeTree = [
+      `const rootRouteChildren${config.disableTypes ? "" : `: RootRouteChildren`} = {
   ${acc.routeTree.map(
-            (child) => `${child.variableName}${exportName}: ${utils.getResolvedRouteNodeVariableName(child, exportName)}`
-          ).join(",")}
+        (child) => `${child.variableName}Route: ${utils.getResolvedRouteNodeVariableName(child)}`
+      ).join(",")}
 }`,
-          `export const ${utils.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 = utils.mergeImportDeclarations(
-      routeTrees.flatMap((d) => d.imports)
+      `export const routeTree = rootRouteImport._addFileChildren(rootRouteChildren)${config.disableTypes ? "" : `._addFileTypes<FileRouteTypes>()`}`
+    ].join("\n");
+    utils.checkRouteFullPathUniqueness(
+      sortedRouteNodes.filter(
+        (d) => d.children === void 0 && "lazy" !== d._fsRouteType
+      ),
+      config
     );
-    if (this.config.disableTypes) {
+    let mergedImports = utils.mergeImportDeclarations(imports);
+    if (config.disableTypes) {
       mergedImports = mergedImports.filter((d) => d.importKind !== "type");
     }
     const importStatements = mergedImports.map(utils.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 (!utils.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 './${utils.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 = utils.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"),
       utils.mergeImportDeclarations(routeImports).map(utils.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 utils.replaceBackslash(
-      utils.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`);
@@ -603,13 +571,15 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${uti
     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 template.fillTemplate(
@@ -622,7 +592,6 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${uti
             tsrExportEnd: tLazyRouteTemplate.imports.tsrExportEnd()
           }
         );
-        updatedCacheEntry.exports = ["Route"];
       } else if (
         // Creating a new normal route file
         ["layout", "static"].some(
@@ -645,31 +614,37 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${uti
             tsrExportEnd: tRouteTemplate.imports.tsrExportEnd()
           }
         );
-        updatedCacheEntry.exports = ["Route"];
       } else {
         return null;
       }
-    } else {
-      const transformResult = await transform.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.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({
@@ -683,11 +658,6 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${uti
       updatedCacheEntry.mtimeMs = stats.mtimeMs;
     }
     this.routeNodeShadowCache.set(node.fullPath, updatedCacheEntry);
-    node.exports = updatedCacheEntry.exports;
-    const shouldWriteTree = !routerCore.deepEqual(
-      result.cacheEntry?.exports,
-      updatedCacheEntry.exports
-    );
     return {
       node,
       shouldWriteTree,
@@ -771,7 +741,6 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${uti
       this.routeNodeShadowCache.set(node.fullPath, fileChangedCache.cacheEntry);
       return {
         status: "fresh",
-        exportsChanged: false,
         cacheEntry: fileChangedCache.cacheEntry
       };
     }
@@ -788,19 +757,8 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${uti
     }
     if (shadowCacheFileChange.result === false) {
       if (fileChangedCache.result === true) {
-        if (routerCore.deepEqual(
-          fileChangedCache.cacheEntry.exports,
-          shadowCacheFileChange.cacheEntry.exports
-        )) {
-          return {
-            status: "fresh",
-            exportsChanged: false,
-            cacheEntry: shadowCacheFileChange.cacheEntry
-          };
-        }
         return {
           status: "fresh",
-          exportsChanged: true,
           cacheEntry: shadowCacheFileChange.cacheEntry
         };
       }
@@ -815,9 +773,7 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${uti
   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") {
@@ -826,8 +782,8 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${uti
     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;
@@ -853,23 +809,13 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${uti
       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 = !routerCore.deepEqual(
-      result.cacheEntry?.exports,
-      rootRouteExports
-    );
-    return shouldWriteTree;
   }
-  handleNode(node, acc) {
+  async getCrawlingResult() {
+    await this.runPromise;
+    return this.crawlingResult;
+  }
+  static handleNode(node, acc) {
     utils.resetRegex(this.routeGroupPatternRegex);
     let parentRoute = utils.hasParentRoute(acc.routeNodes, node, node.routePath);
     if (parentRoute?.isVirtualParentRoute && parentRoute.children?.length) {
@@ -983,6 +929,8 @@ ${acc.routeTree.map((child) => `${child.variableName}${exportName}: typeof ${uti
     }
     return false;
   }
-}
+};
+_Generator.routeGroupPatternRegex = /\(.+\)/g;
+let Generator = _Generator;
 exports.Generator = Generator;
 //# sourceMappingURL=generator.cjs.map