@tanstack/router-generator 1.20.0 → 1.20.3-alpha.1

package/dist/cjs/generator.cjs

@@ -1,10 +1,13 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const path = require("path");
-const fs = require("fs");
-const fsp = require("fs/promises");
-const prettier = require("prettier");
+const path = require("node:path");
+const fs = require("node:fs");
+const fsp = require("node:fs/promises");
 const utils = require("./utils.cjs");
+const getRouteNodes$1 = require("./filesystem/physical/getRouteNodes.cjs");
+const getRouteNodes = require("./filesystem/virtual/getRouteNodes.cjs");
+const rootPathId = require("./filesystem/physical/rootPathId.cjs");
+const template = require("./template.cjs");
 function _interopNamespaceDefault(e) {
   const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
   if (e) {
@@ -23,105 +26,19 @@ function _interopNamespaceDefault(e) {
 }
 const fs__namespace = /* @__PURE__ */ _interopNamespaceDefault(fs);
 const fsp__namespace = /* @__PURE__ */ _interopNamespaceDefault(fsp);
-const prettier__namespace = /* @__PURE__ */ _interopNamespaceDefault(prettier);
+const rootRouteId = "__root__";
 let latestTask = 0;
-const rootPathId = "__root";
 const routeGroupPatternRegex = /\(.+\)/g;
-async function getRouteNodes(config) {
-  const { routeFilePrefix, routeFileIgnorePrefix, routeFileIgnorePattern } = config;
-  const logger = utils.logging({ disabled: config.disableLogging });
-  const routeFileIgnoreRegExp = new RegExp(routeFileIgnorePattern ?? "", "g");
-  let routeNodes = [];
-  async function recurse(dir) {
-    const fullDir = path.resolve(config.routesDirectory, dir);
-    let dirList = await fsp__namespace.readdir(fullDir, { withFileTypes: true });
-    dirList = dirList.filter((d) => {
-      if (d.name.startsWith(".") || routeFileIgnorePrefix && d.name.startsWith(routeFileIgnorePrefix)) {
-        return false;
-      }
-      if (routeFilePrefix) {
-        return d.name.startsWith(routeFilePrefix);
-      }
-      if (routeFileIgnorePattern) {
-        return !d.name.match(routeFileIgnoreRegExp);
-      }
-      return true;
-    });
-    await Promise.all(
-      dirList.map(async (dirent) => {
-        var _a;
-        const fullPath = path.join(fullDir, dirent.name);
-        const relativePath = path.join(dir, dirent.name);
-        if (dirent.isDirectory()) {
-          await recurse(relativePath);
-        } else if (fullPath.match(/\.(tsx|ts|jsx|js)$/)) {
-          const filePath = replaceBackslash(path.join(dir, dirent.name));
-          const filePathNoExt = removeExt(filePath);
-          let routePath = utils.cleanPath(`/${filePathNoExt.split(".").join("/")}`) || "";
-          if (routeFilePrefix) {
-            routePath = routePath.replaceAll(routeFilePrefix, "");
-          }
-          const variableName = routePathToVariable(routePath);
-          let isLazy = routePath == null ? void 0 : routePath.endsWith("/lazy");
-          if (isLazy) {
-            routePath = routePath == null ? void 0 : routePath.replace(/\/lazy$/, "");
-          }
-          let isRoute = routePath == null ? void 0 : routePath.endsWith("/route");
-          let isComponent = routePath == null ? void 0 : routePath.endsWith("/component");
-          let isErrorComponent = routePath == null ? void 0 : routePath.endsWith("/errorComponent");
-          let isPendingComponent = routePath == null ? void 0 : routePath.endsWith("/pendingComponent");
-          let isLoader = routePath == null ? void 0 : routePath.endsWith("/loader");
-          const segments = (routePath ?? "").split("/");
-          let isLayout = ((_a = segments[segments.length - 1]) == null ? void 0 : _a.startsWith("_")) || false;
-          [
-            [isComponent, "component"],
-            [isErrorComponent, "errorComponent"],
-            [isPendingComponent, "pendingComponent"],
-            [isLoader, "loader"]
-          ].forEach(([isType, type]) => {
-            if (isType) {
-              logger.warn(
-                `WARNING: The \`.${type}.tsx\` suffix used for the ${filePath} file is deprecated. Use the new \`.lazy.tsx\` suffix instead.`
-              );
-            }
-          });
-          routePath = routePath == null ? void 0 : routePath.replace(
-            /\/(component|errorComponent|pendingComponent|loader|route|lazy)$/,
-            ""
-          );
-          if (routePath === "index") {
-            routePath = "/";
-          }
-          routePath = routePath.replace(/\/index$/, "/") || "/";
-          routeNodes.push({
-            filePath,
-            fullPath,
-            routePath,
-            variableName,
-            isRoute,
-            isComponent,
-            isErrorComponent,
-            isPendingComponent,
-            isLoader,
-            isLazy,
-            isLayout
-          });
-        }
-      })
-    );
-    return routeNodes;
-  }
-  await recurse("./");
-  return routeNodes;
-}
-let first = false;
+const possiblyNestedRouteGroupPatternRegex = /\([^/]+\)\/?/g;
+let isFirst = false;
 let skipMessage = false;
-async function generator(config) {
+async function generator(config, root) {
+  const ROUTE_TEMPLATE = template.getTargetTemplate(config.target);
   const logger = utils.logging({ disabled: config.disableLogging });
   logger.log("");
-  if (!first) {
+  if (!isFirst) {
     logger.log("♻️  Generating routes...");
-    first = true;
+    isFirst = true;
   } else if (skipMessage) {
     skipMessage = false;
   } else {
@@ -137,42 +54,73 @@ async function generator(config) {
     return true;
   };
   const start = Date.now();
-  const routePathIdPrefix = config.routeFilePrefix ?? "";
-  const beforeRouteNodes = await getRouteNodes(config);
-  const rootRouteNode = beforeRouteNodes.find(
-    (d) => d.routePath === `/${rootPathId}`
-  );
-  const preRouteNodes = multiSortBy(beforeRouteNodes, [
+  const TYPES_DISABLED = config.disableTypes;
+  let getRouteNodesResult;
+  if (config.virtualRouteConfig) {
+    getRouteNodesResult = await getRouteNodes.getRouteNodes(config, root);
+  } else {
+    getRouteNodesResult = await getRouteNodes$1.getRouteNodes(config, root);
+  }
+  const { rootRouteNode, routeNodes: beforeRouteNodes } = 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 (!config.virtualRouteConfig) {
+      errorMessage += `
+Make sure that you add a "${rootPathId.rootPathId}.${config.disableTypes ? "js" : "tsx"}" file to your routes directory.
+Add the file in: "${config.routesDirectory}/${rootPathId.rootPathId}.${config.disableTypes ? "js" : "tsx"}"`;
+    }
+    throw new Error(errorMessage);
+  }
+  const preRouteNodes = utils.multiSortBy(beforeRouteNodes, [
     (d) => d.routePath === "/" ? -1 : 1,
     (d) => {
       var _a;
       return (_a = d.routePath) == null ? void 0 : _a.split("/").length;
     },
-    (d) => {
-      var _a;
-      return ((_a = d.filePath) == null ? void 0 : _a.match(/[./]index[.]/)) ? 1 : -1;
-    },
-    (d) => {
-      var _a;
-      return ((_a = d.filePath) == null ? void 0 : _a.match(
-        /[./](component|errorComponent|pendingComponent|loader|lazy)[.]/
-      )) ? 1 : -1;
-    },
-    (d) => {
-      var _a;
-      return ((_a = d.filePath) == null ? void 0 : _a.match(/[./]route[.]/)) ? -1 : 1;
-    },
+    (d) => d.filePath.match(new RegExp(`[./]${config.indexToken}[.]`)) ? 1 : -1,
+    (d) => d.filePath.match(
+      /[./](component|errorComponent|pendingComponent|loader|lazy)[.]/
+    ) ? 1 : -1,
+    (d) => d.filePath.match(new RegExp(`[./]${config.routeToken}[.]`)) ? -1 : 1,
     (d) => {
       var _a;
       return ((_a = d.routePath) == null ? void 0 : _a.endsWith("/")) ? -1 : 1;
     },
     (d) => d.routePath
-  ]).filter((d) => ![`/${rootPathId}`].includes(d.routePath || ""));
+  ]).filter((d) => ![`/${rootPathId.rootPathId}`].includes(d.routePath || ""));
   const routeTree = [];
   const routePiecesByPath = {};
-  let routeNodes = [];
+  const routeNodes = [];
+  const handleRootNode = async (node) => {
+    if (!node) {
+      return;
+    }
+    const routeCode = fs__namespace.readFileSync(node.fullPath, "utf-8");
+    if (!routeCode) {
+      const _rootTemplate = ROUTE_TEMPLATE.rootRoute;
+      const replaced = await template.fillTemplate(config, _rootTemplate.template(), {
+        tsrImports: _rootTemplate.imports.tsrImports(),
+        tsrPath: rootPathId.rootPathId,
+        tsrExportStart: _rootTemplate.imports.tsrExportStart(),
+        tsrExportEnd: _rootTemplate.imports.tsrExportEnd()
+      });
+      await utils.writeIfDifferent(
+        node.fullPath,
+        "",
+        // Empty string because the file doesn't exist yet
+        replaced,
+        {
+          beforeWrite: () => {
+            logger.log(`🟡 Creating ${node.fullPath}`);
+          }
+        }
+      );
+    }
+  };
+  await handleRootNode(rootRouteNode);
   const handleNode = async (node) => {
-    var _a, _b;
+    var _a, _b, _c, _d, _e;
+    utils.resetRegex(routeGroupPatternRegex);
     let parentRoute = hasParentRoute(routeNodes, node, node.routePath);
     if ((parentRoute == null ? void 0 : parentRoute.isVirtualParentRoute) && ((_a = parentRoute.children) == null ? void 0 : _a.length)) {
       const possibleParentRoute = hasParentRoute(
@@ -184,79 +132,158 @@ async function generator(config) {
         parentRoute = possibleParentRoute;
       }
     }
-    if (parentRoute)
-      node.parent = parentRoute;
+    if (parentRoute) node.parent = parentRoute;
     node.path = determineNodePath(node);
     const trimmedPath = utils.trimPathLeft(node.path ?? "");
-    const split = (trimmedPath == null ? void 0 : trimmedPath.split("/")) ?? [];
-    let first2 = split[0] ?? trimmedPath ?? "";
-    const lastRouteSegment = split[split.length - 1] ?? trimmedPath ?? "";
-    node.isNonPath = lastRouteSegment.startsWith("_");
-    node.isNonLayout = first2.endsWith("_");
+    const split = trimmedPath.split("/");
+    const lastRouteSegment = split[split.length - 1] ?? trimmedPath;
+    node.isNonPath = lastRouteSegment.startsWith("_") || routeGroupPatternRegex.test(lastRouteSegment);
     node.cleanedPath = removeGroups(
-      removeUnderscores(removeLayoutSegments(node.path)) ?? ""
+      utils.removeUnderscores(removeLayoutSegments(node.path)) ?? ""
     );
-    if (!node.isVirtualParentRoute) {
+    if (!node.isVirtualParentRoute && !node.isVirtual) {
       const routeCode = fs__namespace.readFileSync(node.fullPath, "utf-8");
-      const escapedRoutePath = removeTrailingUnderscores(
-        ((_b = node.routePath) == null ? void 0 : _b.replaceAll("$", "$$")) ?? ""
-      );
+      const escapedRoutePath = ((_b = node.routePath) == null ? void 0 : _b.replaceAll("$", "$$")) ?? "";
       let replaced = routeCode;
+      const tRouteTemplate = ROUTE_TEMPLATE.route;
+      const tLazyRouteTemplate = ROUTE_TEMPLATE.lazyRoute;
       if (!routeCode) {
-        if (node.isLazy) {
-          replaced = [
-            `import { createLazyFileRoute } from '@tanstack/react-router'`,
-            `export const Route = createLazyFileRoute('${escapedRoutePath}')({
-  component: () => <div>Hello ${escapedRoutePath}!</div>
-})`
-          ].join("\n\n");
-        } else if (node.isRoute || !node.isComponent && !node.isErrorComponent && !node.isPendingComponent && !node.isLoader) {
-          replaced = [
-            `import { createFileRoute } from '@tanstack/react-router'`,
-            `export const Route = createFileRoute('${escapedRoutePath}')({
-  component: () => <div>Hello ${escapedRoutePath}!</div>
-})`
-          ].join("\n\n");
+        if (node._fsRouteType === "lazy") {
+          replaced = await template.fillTemplate(
+            config,
+            (((_c = config.customScaffolding) == null ? void 0 : _c.lazyRouteTemplate) || ((_d = config.customScaffolding) == null ? void 0 : _d.routeTemplate)) ?? tLazyRouteTemplate.template(),
+            {
+              tsrImports: tLazyRouteTemplate.imports.tsrImports(),
+              tsrPath: escapedRoutePath.replaceAll(/\{(.+)\}/gm, "$1"),
+              tsrExportStart: tLazyRouteTemplate.imports.tsrExportStart(escapedRoutePath),
+              tsrExportEnd: tLazyRouteTemplate.imports.tsrExportEnd()
+            }
+          );
+        } else if (
+          // Creating a new normal route file
+          ["layout", "static"].some(
+            (d) => d === node._fsRouteType
+          ) || [
+            "component",
+            "pendingComponent",
+            "errorComponent",
+            "loader"
+          ].every((d) => d !== node._fsRouteType)
+        ) {
+          replaced = await template.fillTemplate(
+            config,
+            ((_e = config.customScaffolding) == null ? void 0 : _e.routeTemplate) ?? tRouteTemplate.template(),
+            {
+              tsrImports: tRouteTemplate.imports.tsrImports(),
+              tsrPath: escapedRoutePath.replaceAll(/\{(.+)\}/gm, "$1"),
+              tsrExportStart: tRouteTemplate.imports.tsrExportStart(escapedRoutePath),
+              tsrExportEnd: tRouteTemplate.imports.tsrExportEnd()
+            }
+          );
         }
+      } else if (config.verboseFileRoutes === false) {
+        if (!routeCode.split("\n").some((line) => line.trim().startsWith("export const Route"))) {
+          return;
+        }
+        replaced = routeCode.replace(
+          /(FileRoute\(\s*['"])([^\s]*)(['"],?\s*\))/g,
+          (_, p1, __, p3) => `${p1}${escapedRoutePath}${p3}`
+        ).replace(
+          new RegExp(
+            `(import\\s*\\{)(.*)(create(Lazy)?FileRoute)(.*)(\\}\\s*from\\s*['"]@tanstack\\/${ROUTE_TEMPLATE.subPkg}['"])`,
+            "gs"
+          ),
+          (_, p1, p2, ___, ____, p5, p6) => {
+            const beforeCreateFileRoute = () => {
+              if (!p2) return "";
+              let trimmed = p2.trim();
+              if (trimmed.endsWith(",")) {
+                trimmed = trimmed.slice(0, -1);
+              }
+              return trimmed;
+            };
+            const afterCreateFileRoute = () => {
+              if (!p5) return "";
+              let trimmed = p5.trim();
+              if (trimmed.startsWith(",")) {
+                trimmed = trimmed.slice(1);
+              }
+              return trimmed;
+            };
+            const newImport = () => {
+              const before = beforeCreateFileRoute();
+              const after = afterCreateFileRoute();
+              if (!before) return after;
+              if (!after) return before;
+              return `${before},${after}`;
+            };
+            const middle = newImport();
+            if (middle === "") return "";
+            return `${p1} ${newImport()} ${p6}`;
+          }
+        ).replace(
+          /create(Lazy)?FileRoute(\(\s*['"])([^\s]*)(['"],?\s*\))/g,
+          (_, __, p2, ___, p4) => `${node._fsRouteType === "lazy" ? "createLazyFileRoute" : "createFileRoute"}`
+        );
       } else {
         replaced = routeCode.replace(
           /(FileRoute\(\s*['"])([^\s]*)(['"],?\s*\))/g,
-          (match, p1, p2, p3) => `${p1}${escapedRoutePath}${p3}`
+          (_, p1, __, p3) => `${p1}${escapedRoutePath}${p3}`
+        ).replace(
+          /((FileRoute)(\s*)(\({))/g,
+          (_, __, p2, p3, p4) => `${p2}('${escapedRoutePath}')${p3}${p4}`
         ).replace(
-          /(createFileRoute\(\s*['"])([^\s]*)(['"],?\s*\))/g,
-          (match, p1, p2, p3) => `${p1}${escapedRoutePath}${p3}`
+          new RegExp(
+            `(import\\s*\\{.*)(create(Lazy)?FileRoute)(.*\\}\\s*from\\s*['"]@tanstack\\/${ROUTE_TEMPLATE.subPkg}['"])`,
+            "gs"
+          ),
+          (_, p1, __, ___, p4) => `${p1}${node._fsRouteType === "lazy" ? "createLazyFileRoute" : "createFileRoute"}${p4}`
         ).replace(
-          /(createLazyFileRoute\(\s*['"])([^\s]*)(['"],?\s*\))/g,
-          (match, p1, p2, p3) => `${p1}${escapedRoutePath}${p3}`
+          /create(Lazy)?FileRoute(\(\s*['"])([^\s]*)(['"],?\s*\))/g,
+          (_, __, p2, ___, p4) => `${node._fsRouteType === "lazy" ? "createLazyFileRoute" : "createFileRoute"}${p2}${escapedRoutePath}${p4}`
         );
+        const regex = new RegExp(
+          `(import\\s*\\{.*)(create(Lazy)?FileRoute)(.*\\}\\s*from\\s*['"]@tanstack\\/${ROUTE_TEMPLATE.subPkg}['"])`,
+          "gm"
+        );
+        if (!replaced.match(regex)) {
+          replaced = [
+            `import { ${node._fsRouteType === "lazy" ? "createLazyFileRoute" : "createFileRoute"} } from '@tanstack/${ROUTE_TEMPLATE.subPkg}'`,
+            ...replaced.split("\n")
+          ].join("\n");
+        }
       }
-      if (replaced !== routeCode) {
-        logger.log(`🟡 Updating ${node.fullPath}`);
-        await fsp__namespace.writeFile(node.fullPath, replaced);
-      }
+      await utils.writeIfDifferent(node.fullPath, routeCode, replaced, {
+        beforeWrite: () => {
+          logger.log(`🟡 Updating ${node.fullPath}`);
+        }
+      });
     }
-    if (!node.isVirtual && (node.isLoader || node.isComponent || node.isErrorComponent || node.isPendingComponent || node.isLazy)) {
+    if (!node.isVirtual && [
+      "lazy",
+      "loader",
+      "component",
+      "pendingComponent",
+      "errorComponent"
+    ].some((d) => d === node._fsRouteType)) {
       routePiecesByPath[node.routePath] = routePiecesByPath[node.routePath] || {};
-      routePiecesByPath[node.routePath][node.isLazy ? "lazy" : node.isLoader ? "loader" : node.isErrorComponent ? "errorComponent" : node.isPendingComponent ? "pendingComponent" : "component"] = node;
+      routePiecesByPath[node.routePath][node._fsRouteType === "lazy" ? "lazy" : node._fsRouteType === "loader" ? "loader" : node._fsRouteType === "errorComponent" ? "errorComponent" : node._fsRouteType === "pendingComponent" ? "pendingComponent" : "component"] = node;
       const anchorRoute = routeNodes.find((d) => d.routePath === node.routePath);
       if (!anchorRoute) {
         await handleNode({
           ...node,
           isVirtual: true,
-          isLazy: false,
-          isLoader: false,
-          isComponent: false,
-          isErrorComponent: false,
-          isPendingComponent: false
+          _fsRouteType: "static"
         });
       }
       return;
     }
     const cleanedPathIsEmpty = (node.cleanedPath || "").length === 0;
-    node.isVirtualParentRequired = node.isLayout ? !cleanedPathIsEmpty : false;
+    const nonPathRoute = node._fsRouteType === "pathless_layout" && node.isNonPath;
+    node.isVirtualParentRequired = node._fsRouteType === "pathless_layout" || nonPathRoute ? !cleanedPathIsEmpty : false;
     if (!node.isVirtual && node.isVirtualParentRequired) {
       const parentRoutePath = removeLastSegmentFromPath(node.routePath) || "/";
-      const parentVariableName = routePathToVariable(parentRoutePath);
+      const parentVariableName = utils.routePathToVariable(parentRoutePath);
       const anchorRoute = routeNodes.find(
         (d) => d.routePath === parentRoutePath
       );
@@ -269,14 +296,15 @@ async function generator(config) {
           routePath: parentRoutePath,
           variableName: parentVariableName,
           isVirtual: true,
-          isLayout: false,
+          _fsRouteType: "layout",
+          // layout since this route will wrap other routes
           isVirtualParentRoute: true,
           isVirtualParentRequired: false
         };
         parentNode.children = parentNode.children ?? [];
         parentNode.children.push(node);
         node.parent = parentNode;
-        if (node.isLayout) {
+        if (node._fsRouteType === "pathless_layout") {
           node.path = determineNodePath(node);
         }
         await handleNode(parentNode);
@@ -299,29 +327,47 @@ async function generator(config) {
   for (const node of preRouteNodes) {
     await handleNode(node);
   }
-  function buildRouteConfig(nodes, depth = 1) {
+  checkRouteFullPathUniqueness(
+    preRouteNodes.filter(
+      (d) => d.children === void 0 && "lazy" !== d._fsRouteType
+    ),
+    config
+  );
+  function buildRouteTreeConfig(nodes, depth = 1) {
     const children = nodes.map((node) => {
       var _a, _b;
-      if (node.isRoot) {
+      if (node._fsRouteType === "__root") {
         return;
       }
-      if (node.isLayout && !((_a = node.children) == null ? void 0 : _a.length)) {
+      if (node._fsRouteType === "pathless_layout" && !((_a = node.children) == null ? void 0 : _a.length)) {
         return;
       }
       const route = `${node.variableName}Route`;
       if ((_b = node.children) == null ? void 0 : _b.length) {
-        const childConfigs = buildRouteConfig(node.children, depth + 1);
-        return `${route}.addChildren([${spaces(depth * 4)}${childConfigs}])`;
+        const childConfigs = buildRouteTreeConfig(node.children, depth + 1);
+        const childrenDeclaration = TYPES_DISABLED ? "" : `interface ${route}Children {
+  ${node.children.map((child) => `${child.variableName}Route: typeof ${getResolvedRouteNodeVariableName(child)}`).join(",")}
+}`;
+        const children2 = `const ${route}Children${TYPES_DISABLED ? "" : `: ${route}Children`} = {
+  ${node.children.map((child) => `${child.variableName}Route: ${getResolvedRouteNodeVariableName(child)}`).join(",")}
+}`;
+        const routeWithChildren = `const ${route}WithChildren = ${route}._addFileChildren(${route}Children)`;
+        return [
+          childConfigs,
+          childrenDeclaration,
+          children2,
+          routeWithChildren
+        ].join("\n\n");
       }
-      return route;
+      return void 0;
     });
-    return children.filter(Boolean).join(`,`);
+    return children.filter(Boolean).join("\n\n");
   }
-  const routeConfigChildrenText = buildRouteConfig(routeTree);
-  const sortedRouteNodes = multiSortBy(routeNodes, [
+  const routeConfigChildrenText = buildRouteTreeConfig(routeTree);
+  const sortedRouteNodes = utils.multiSortBy(routeNodes, [
     (d) => {
       var _a;
-      return ((_a = d.routePath) == null ? void 0 : _a.includes(`/${rootPathId}`)) ? -1 : 1;
+      return ((_a = d.routePath) == null ? void 0 : _a.includes(`/${rootPathId.rootPathId}`)) ? -1 : 1;
     },
     (d) => {
       var _a;
@@ -329,10 +375,25 @@ async function generator(config) {
     },
     (d) => {
       var _a;
-      return ((_a = d.routePath) == null ? void 0 : _a.endsWith("index'")) ? -1 : 1;
+      return ((_a = d.routePath) == null ? void 0 : _a.endsWith(config.indexToken)) ? -1 : 1;
     },
     (d) => d
   ]);
+  const typeImports = Object.entries({
+    // Used for augmentation of regular routes
+    CreateFileRoute: config.verboseFileRoutes === false && sortedRouteNodes.some(
+      (d) => isRouteNodeValidForAugmentation(d) && d._fsRouteType !== "lazy"
+    ),
+    // Used for augmentation of lazy (`.lazy`) routes
+    CreateLazyFileRoute: config.verboseFileRoutes === false && sortedRouteNodes.some(
+      (node) => {
+        var _a;
+        return ((_a = routePiecesByPath[node.routePath]) == null ? void 0 : _a.lazy) && isRouteNodeValidForAugmentation(node);
+      }
+    ),
+    // Used in the process of augmenting the routes
+    FileRoutesByPath: config.verboseFileRoutes === false && sortedRouteNodes.some((d) => isRouteNodeValidForAugmentation(d))
+  }).filter((d) => d[1]).map((d) => d[0]).sort((a, b) => a.localeCompare(b));
   const imports = Object.entries({
     createFileRoute: sortedRouteNodes.some((d) => d.isVirtual),
     lazyFn: sortedRouteNodes.some(
@@ -349,43 +410,36 @@ async function generator(config) {
     )
   }).filter((d) => d[1]).map((d) => d[0]);
   const virtualRouteNodes = sortedRouteNodes.filter((d) => d.isVirtual);
-  const rootPathIdExtension = config.addExtensions && rootRouteNode ? path.extname(rootRouteNode.filePath) : "";
+  function getImportPath(node) {
+    return utils.replaceBackslash(
+      utils.removeExt(
+        path.relative(
+          path.dirname(config.generatedRouteTree),
+          path.resolve(config.routesDirectory, node.filePath)
+        ),
+        config.addExtensions
+      )
+    );
+  }
   const routeImports = [
-    "/* prettier-ignore-start */",
-    "/* eslint-disable */",
-    "// @ts-nocheck",
-    "// noinspection JSUnusedGlobalSymbols",
-    "// This file is auto-generated by TanStack Router",
-    imports.length ? `import { ${imports.join(", ")} } from '@tanstack/react-router'
-` : "",
+    ...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.`,
+    [
+      imports.length ? `import { ${imports.join(", ")} } from '${ROUTE_TEMPLATE.fullPkg}'` : "",
+      !TYPES_DISABLED && typeImports.length ? `import type { ${typeImports.join(", ")} } from '${ROUTE_TEMPLATE.fullPkg}'` : ""
+    ].filter(Boolean).join("\n"),
     "// Import Routes",
     [
-      `import { Route as rootRoute } from './${replaceBackslash(
-        path.relative(
-          path.dirname(config.generatedRouteTree),
-          path.resolve(
-            config.routesDirectory,
-            `${routePathIdPrefix}${rootPathId}${rootPathIdExtension}`
-          )
-        )
-      )}'`,
+      `import { Route as rootRoute } from './${getImportPath(rootRouteNode)}'`,
       ...sortedRouteNodes.filter((d) => !d.isVirtual).map((node) => {
-        return `import { Route as ${node.variableName}Import } from './${replaceBackslash(
-          removeExt(
-            path.relative(
-              path.dirname(config.generatedRouteTree),
-              path.resolve(config.routesDirectory, node.filePath)
-            ),
-            config.addExtensions
-          )
-        )}'`;
+        return `import { Route as ${node.variableName}RouteImport } from './${getImportPath(node)}'`;
       })
     ].join("\n"),
     virtualRouteNodes.length ? "// Create Virtual Routes" : "",
     virtualRouteNodes.map((node) => {
-      return `const ${node.variableName}Import = createFileRoute('${removeTrailingUnderscores(
-        node.routePath
-      )}')()`;
+      return `const ${node.variableName}RouteImport = createFileRoute('${node.routePath}')()`;
     }).join("\n"),
     "// Create/Update Routes",
     sortedRouteNodes.map((node) => {
@@ -396,155 +450,221 @@ async function generator(config) {
       const pendingComponentNode = (_d = routePiecesByPath[node.routePath]) == null ? void 0 : _d.pendingComponent;
       const lazyComponentNode = (_e = routePiecesByPath[node.routePath]) == null ? void 0 : _e.lazy;
       return [
-        `const ${node.variableName}Route = ${node.variableName}Import.update({
+        [
+          `const ${node.variableName}Route = ${node.variableName}RouteImport.update({
           ${[
-          node.isNonPath ? `id: '${node.path}'` : `path: '${node.cleanedPath}'`,
-          `getParentRoute: () => ${((_f = node.parent) == null ? void 0 : _f.variableName) ?? "root"}Route`
-        ].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(
+            `id: '${node.path}'`,
+            !node.isNonPath ? `path: '${node.cleanedPath}'` : void 0,
+            `getParentRoute: () => ${((_f = node.parent) == null ? void 0 : _f.variableName) ?? "root"}Route`
+          ].filter(Boolean).join(",")}
+        }${TYPES_DISABLED ? "" : "as any"})`,
+          loaderNode ? `.updateLoader({ loader: lazyFn(() => import('./${utils.replaceBackslash(
+            utils.removeExt(
               path.relative(
                 path.dirname(config.generatedRouteTree),
-                path.resolve(config.routesDirectory, d[1].filePath)
+                path.resolve(config.routesDirectory, loaderNode.filePath)
               ),
               config.addExtensions
             )
-          )}'), '${d[0]}')`;
-        }).join("\n,")}
-            })` : "",
-        lazyComponentNode ? `.lazy(() => import('./${replaceBackslash(
-          removeExt(
-            path.relative(
-              path.dirname(config.generatedRouteTree),
-              path.resolve(
-                config.routesDirectory,
-                lazyComponentNode.filePath
+          )}'), '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(config.generatedRouteTree),
+                  path.resolve(config.routesDirectory, d[1].filePath)
+                ),
+                config.addExtensions
               )
-            ),
-            config.addExtensions
-          )
-        )}').then((d) => d.Route))` : ""
-      ].join("");
+            )}'), '${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");
     }).join("\n\n"),
-    ...config.disableTypes ? [] : [
+    ...TYPES_DISABLED ? [] : [
       "// Populate the FileRoutesByPath interface",
-      `declare module '@tanstack/react-router' {
+      `declare module '${ROUTE_TEMPLATE.fullPkg}' {
   interface FileRoutesByPath {
     ${routeNodes.map((routeNode) => {
-        var _a, _b, _c;
-        return `'${removeTrailingUnderscores(routeNode.routePath)}': {
-          preLoaderRoute: typeof ${routeNode.variableName}Import
-          parentRoute: typeof ${routeNode.isVirtualParentRequired ? `${(_a = routeNode.parent) == null ? void 0 : _a.variableName}Route` : ((_b = routeNode.parent) == null ? void 0 : _b.variableName) ? `${(_c = routeNode.parent) == null ? void 0 : _c.variableName}Import` : "rootRoute"}
+        var _a, _b;
+        const filePathId = routeNode.routePath;
+        return `'${filePathId}': {
+          id: '${filePathId}'
+          path: '${inferPath(routeNode)}'
+          fullPath: '${inferFullPath(routeNode)}'
+          preLoaderRoute: typeof ${routeNode.variableName}RouteImport
+          parentRoute: typeof ${routeNode.isVirtualParentRequired ? `${(_a = routeNode.parent) == null ? void 0 : _a.variableName}Route` : ((_b = routeNode.parent) == null ? void 0 : _b.variableName) ? `${routeNode.parent.variableName}RouteImport` : "rootRoute"}
         }`;
       }).join("\n")}
   }
 }`
     ],
+    ...TYPES_DISABLED ? [] : config.verboseFileRoutes !== false ? [] : [
+      `// Add type-safety to the createFileRoute function across the route tree`,
+      routeNodes.map((routeNode) => {
+        var _a;
+        function getModuleDeclaration(routeNode2) {
+          if (!isRouteNodeValidForAugmentation(routeNode2)) {
+            return "";
+          }
+          return `declare module './${getImportPath(routeNode2)}' {
+                  const ${routeNode2._fsRouteType === "lazy" ? "createLazyFileRoute" : "createFileRoute"}: ${routeNode2._fsRouteType === "lazy" ? `CreateLazyFileRoute<FileRoutesByPath['${routeNode2.routePath}']['preLoaderRoute']>}` : `CreateFileRoute<
+                  '${routeNode2.routePath}',
+                  FileRoutesByPath['${routeNode2.routePath}']['parentRoute'],
+                  FileRoutesByPath['${routeNode2.routePath}']['id'],
+                  FileRoutesByPath['${routeNode2.routePath}']['path'],
+                  FileRoutesByPath['${routeNode2.routePath}']['fullPath']
+                  >
+                  }`}`;
+        }
+        return getModuleDeclaration(routeNode) + getModuleDeclaration(
+          (_a = routePiecesByPath[routeNode.routePath]) == null ? void 0 : _a.lazy
+        );
+      }).join("\n")
+    ],
     "// Create and export the route tree",
-    `export const routeTree = rootRoute.addChildren([${routeConfigChildrenText}])`,
-    "/* prettier-ignore-end */"
+    routeConfigChildrenText,
+    ...TYPES_DISABLED ? [] : [
+      `export interface FileRoutesByFullPath {
+  ${[...createRouteNodesByFullPath(routeNodes).entries()].map(
+        ([fullPath, routeNode]) => {
+          return `'${fullPath}': typeof ${getResolvedRouteNodeVariableName(routeNode)}`;
+        }
+      )}
+}`,
+      `export interface FileRoutesByTo {
+  ${[...createRouteNodesByTo(routeNodes).entries()].map(([to, routeNode]) => {
+        return `'${to}': typeof ${getResolvedRouteNodeVariableName(routeNode)}`;
+      })}
+}`,
+      `export interface FileRoutesById {
+  '${rootRouteId}': typeof rootRoute,
+  ${[...createRouteNodesById(routeNodes).entries()].map(([id, routeNode]) => {
+        return `'${id}': typeof ${getResolvedRouteNodeVariableName(routeNode)}`;
+      })}
+}`,
+      `export interface FileRouteTypes {
+  fileRoutesByFullPath: FileRoutesByFullPath
+  fullPaths: ${routeNodes.length > 0 ? [...createRouteNodesByFullPath(routeNodes).keys()].map((fullPath) => `'${fullPath}'`).join("|") : "never"}
+  fileRoutesByTo: FileRoutesByTo
+  to: ${routeNodes.length > 0 ? [...createRouteNodesByTo(routeNodes).keys()].map((to) => `'${to}'`).join("|") : "never"}
+  id: ${[`'${rootRouteId}'`, ...[...createRouteNodesById(routeNodes).keys()].map((id) => `'${id}'`)].join("|")}
+  fileRoutesById: FileRoutesById
+}`,
+      `export interface RootRouteChildren {
+  ${routeTree.map((child) => `${child.variableName}Route: typeof ${getResolvedRouteNodeVariableName(child)}`).join(",")}
+}`
+    ],
+    `const rootRouteChildren${TYPES_DISABLED ? "" : ": RootRouteChildren"} = {
+  ${routeTree.map((child) => `${child.variableName}Route: ${getResolvedRouteNodeVariableName(child)}`).join(",")}
+}`,
+    `export const routeTree = rootRoute._addFileChildren(rootRouteChildren)${TYPES_DISABLED ? "" : "._addFileTypes<FileRouteTypes>()"}`,
+    ...config.routeTreeFileFooter
   ].filter(Boolean).join("\n\n");
-  const routeConfigFileContent = await prettier__namespace.format(routeImports, {
-    semi: false,
-    singleQuote: config.quoteStyle === "single",
-    parser: "typescript"
-  });
-  const routeTreeContent = await fsp__namespace.readFile(path.resolve(config.generatedRouteTree), "utf-8").catch((err) => {
+  const createRouteManifest = () => {
+    const routesManifest = {
+      [rootRouteId]: {
+        filePath: rootRouteNode.filePath,
+        children: routeTree.map((d) => d.routePath)
+      },
+      ...Object.fromEntries(
+        routeNodes.map((d) => {
+          var _a, _b;
+          const filePathId = d.routePath;
+          return [
+            filePathId,
+            {
+              filePath: d.filePath,
+              parent: ((_a = d.parent) == null ? void 0 : _a.routePath) ? d.parent.routePath : void 0,
+              children: (_b = d.children) == null ? void 0 : _b.map((childRoute) => childRoute.routePath)
+            }
+          ];
+        })
+      )
+    };
+    return JSON.stringify(
+      {
+        routes: routesManifest
+      },
+      null,
+      2
+    );
+  };
+  const includeManifest = ["react", "solid"];
+  const routeConfigFileContent = config.disableManifestGeneration || !includeManifest.includes(config.target) ? routeImports : [
+    routeImports,
+    "\n",
+    "/* ROUTE_MANIFEST_START",
+    createRouteManifest(),
+    "ROUTE_MANIFEST_END */"
+  ].join("\n");
+  if (!checkLatest()) return;
+  const existingRouteTreeContent = await fsp__namespace.readFile(path.resolve(config.generatedRouteTree), "utf-8").catch((err) => {
     if (err.code === "ENOENT") {
-      return void 0;
+      return "";
     }
     throw err;
   });
-  if (!checkLatest())
+  if (!checkLatest()) return;
+  await fsp__namespace.mkdir(path.dirname(path.resolve(config.generatedRouteTree)), {
+    recursive: true
+  });
+  if (!checkLatest()) return;
+  const routeTreeWriteResult = await utils.writeIfDifferent(
+    path.resolve(config.generatedRouteTree),
+    config.enableRouteTreeFormatting ? await utils.format(existingRouteTreeContent, config) : existingRouteTreeContent,
+    config.enableRouteTreeFormatting ? await utils.format(routeConfigFileContent, config) : routeConfigFileContent,
+    {
+      beforeWrite: () => {
+        logger.log(`🟡 Updating ${config.generatedRouteTree}`);
+      }
+    }
+  );
+  if (routeTreeWriteResult && !checkLatest()) {
     return;
-  if (routeTreeContent !== routeConfigFileContent) {
-    await fsp__namespace.mkdir(path.dirname(path.resolve(config.generatedRouteTree)), {
-      recursive: true
-    });
-    if (!checkLatest())
-      return;
-    await fsp__namespace.writeFile(
-      path.resolve(config.generatedRouteTree),
-      routeConfigFileContent
-    );
   }
   logger.log(
     `✅ Processed ${routeNodes.length === 1 ? "route" : "routes"} in ${Date.now() - start}ms`
   );
 }
-function routePathToVariable(d) {
-  var _a, _b, _c, _d;
-  return ((_d = (_c = (_b = (_a = removeUnderscores(d)) == null ? void 0 : _a.replace(/\/\$\//g, "/splat/")) == null ? void 0 : _b.replace(/\$$/g, "splat")) == null ? void 0 : _c.replace(/\$/g, "")) == null ? void 0 : _d.split(/[/-]/g).map((d2, i) => i > 0 ? capitalize(d2) : d2).join("").replace(/([^a-zA-Z0-9]|[\.])/gm, "").replace(/^(\d)/g, "R$1")) ?? "";
-}
-function removeExt(d, keepExtension = false) {
-  return keepExtension ? d : d.substring(0, d.lastIndexOf(".")) || d;
-}
-function spaces(d) {
-  return Array.from({ length: d }).map(() => " ").join("");
-}
-function multiSortBy(arr, accessors = [(d) => d]) {
-  return arr.map((d, i) => [d, i]).sort(([a, ai], [b, bi]) => {
-    for (const accessor of accessors) {
-      const ao = accessor(a);
-      const bo = accessor(b);
-      if (typeof ao === "undefined") {
-        if (typeof bo === "undefined") {
-          continue;
-        }
-        return 1;
-      }
-      if (ao === bo) {
-        continue;
-      }
-      return ao > bo ? 1 : -1;
-    }
-    return ai - bi;
-  }).map(([d]) => d);
-}
-function capitalize(s) {
-  if (typeof s !== "string")
-    return "";
-  return s.charAt(0).toUpperCase() + s.slice(1);
-}
-function removeUnderscores(s) {
-  return s == null ? void 0 : s.replaceAll(/(^_|_$)/gi, "").replaceAll(/(\/_|_\/)/gi, "/");
-}
-function removeTrailingUnderscores(s) {
-  return s == null ? void 0 : s.replaceAll(/(_$)/gi, "").replaceAll(/(_\/)/gi, "/");
-}
-function replaceBackslash(s) {
-  return s.replaceAll(/\\/gi, "/");
-}
 function removeGroups(s) {
-  return s.replaceAll(routeGroupPatternRegex, "").replaceAll("//", "/");
+  return s.replace(possiblyNestedRouteGroupPatternRegex, "");
+}
+function isRouteNodeValidForAugmentation(routeNode) {
+  if (!routeNode || routeNode.isVirtual) {
+    return false;
+  }
+  return true;
 }
 function determineNodePath(node) {
   var _a;
-  return node.path = node.parent ? ((_a = node.routePath) == null ? void 0 : _a.replace(node.parent.routePath, "")) || "/" : node.routePath;
+  return node.path = node.parent ? ((_a = node.routePath) == null ? void 0 : _a.replace(node.parent.routePath ?? "", "")) || "/" : node.routePath;
 }
-function removeLastSegmentFromPath(path2 = "/") {
-  const segments = path2.split("/");
+function removeLastSegmentFromPath(routePath = "/") {
+  const segments = routePath.split("/");
   segments.pop();
   return segments.join("/");
 }
-function removeLayoutSegments(path2 = "/") {
-  const segments = path2.split("/");
+function removeLayoutSegments(routePath = "/") {
+  const segments = routePath.split("/");
   const newSegments = segments.filter((segment) => !segment.startsWith("_"));
   return newSegments.join("/");
 }
@@ -552,13 +672,12 @@ function hasParentRoute(routes, node, routePathToCheck) {
   if (!routePathToCheck || routePathToCheck === "/") {
     return null;
   }
-  const sortedNodes = multiSortBy(routes, [
+  const sortedNodes = utils.multiSortBy(routes, [
     (d) => d.routePath.length * -1,
     (d) => d.variableName
-  ]).filter((d) => d.routePath !== `/${rootPathId}`);
+  ]).filter((d) => d.routePath !== `/${rootPathId.rootPathId}`);
   for (const route of sortedNodes) {
-    if (route.routePath === "/")
-      continue;
+    if (route.routePath === "/") continue;
     if (routePathToCheck.startsWith(`${route.routePath}/`) && route.routePath !== routePathToCheck) {
       return route;
     }
@@ -568,10 +687,79 @@ function hasParentRoute(routes, node, routePathToCheck) {
   const parentRoutePath = segments.join("/");
   return hasParentRoute(routes, node, parentRoutePath);
 }
+const getResolvedRouteNodeVariableName = (routeNode) => {
+  var _a;
+  return ((_a = routeNode.children) == null ? void 0 : _a.length) ? `${routeNode.variableName}RouteWithChildren` : `${routeNode.variableName}Route`;
+};
+const createRouteNodesByFullPath = (routeNodes) => {
+  return new Map(
+    routeNodes.map((routeNode) => [inferFullPath(routeNode), routeNode])
+  );
+};
+const createRouteNodesByTo = (routeNodes) => {
+  return new Map(
+    dedupeBranchesAndIndexRoutes(routeNodes).map((routeNode) => [
+      inferTo(routeNode),
+      routeNode
+    ])
+  );
+};
+const createRouteNodesById = (routeNodes) => {
+  return new Map(
+    routeNodes.map((routeNode) => {
+      const id = routeNode.routePath ?? "";
+      return [id, routeNode];
+    })
+  );
+};
+const inferFullPath = (routeNode) => {
+  const fullPath = removeGroups(
+    utils.removeUnderscores(removeLayoutSegments(routeNode.routePath)) ?? ""
+  );
+  return routeNode.cleanedPath === "/" ? fullPath : fullPath.replace(/\/$/, "");
+};
+const inferPath = (routeNode) => {
+  var _a;
+  return routeNode.cleanedPath === "/" ? routeNode.cleanedPath : ((_a = routeNode.cleanedPath) == null ? void 0 : _a.replace(/\/$/, "")) ?? "";
+};
+const inferTo = (routeNode) => {
+  const fullPath = inferFullPath(routeNode);
+  if (fullPath === "/") return fullPath;
+  return fullPath.replace(/\/$/, "");
+};
+const dedupeBranchesAndIndexRoutes = (routes) => {
+  return routes.filter((route) => {
+    var _a;
+    if ((_a = route.children) == null ? void 0 : _a.find((child) => child.cleanedPath === "/")) return false;
+    return true;
+  });
+};
+function checkUnique(routes, key) {
+  const keys = routes.map((d) => d[key]);
+  const uniqueKeys = new Set(keys);
+  if (keys.length !== uniqueKeys.size) {
+    const duplicateKeys = keys.filter((d, i) => keys.indexOf(d) !== i);
+    const conflictingFiles = routes.filter(
+      (d) => duplicateKeys.includes(d[key])
+    );
+    return conflictingFiles;
+  }
+  return void 0;
+}
+function checkRouteFullPathUniqueness(_routes, config) {
+  const routes = _routes.map((d) => {
+    const inferredFullPath = inferFullPath(d);
+    return { ...d, inferredFullPath };
+  });
+  const conflictingFiles = checkUnique(routes, "inferredFullPath");
+  if (conflictingFiles !== void 0) {
+    const errorMessage = `Conflicting configuration paths were found for the following route${conflictingFiles.length > 1 ? "s" : ""}: ${conflictingFiles.map((p) => `"${p.inferredFullPath}"`).join(", ")}.
+Please ensure each Route has a unique full path.
+Conflicting files: 
+ ${conflictingFiles.map((d) => path.resolve(config.routesDirectory, d.filePath)).join("\n ")}
+`;
+    throw new Error(errorMessage);
+  }
+}
 exports.generator = generator;
-exports.hasParentRoute = hasParentRoute;
-exports.multiSortBy = multiSortBy;
-exports.removeExt = removeExt;
-exports.removeLastSegmentFromPath = removeLastSegmentFromPath;
-exports.rootPathId = rootPathId;
 //# sourceMappingURL=generator.cjs.map