@tanstack/router-cli 0.0.1-beta.69 → 1.0.1

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2021 Tanner Linsley
+Copyright (c) 2021-present Tanner Linsley
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/bin/tsr.js

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
 
-require('../build/cjs/index')
+require('../build/cjs/index.js')

package/build/cjs/config.js

@@ -1,5 +1,5 @@
 /**
- * router-cli
+ * @tanstack/router-cli/src/index.ts
  *
  * Copyright (c) TanStack
  *
@@ -10,19 +10,23 @@
  */
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var path = require('path');
 var fs = require('fs-extra');
+var zod = require('zod');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
-var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
-
-const configFilePathJson = path__default["default"].resolve(process.cwd(), 'tsr.config.json');
+const configSchema = zod.z.object({
+  routeFilePrefix: zod.z.string().optional(),
+  routeFileIgnorePrefix: zod.z.string().optional(),
+  routesDirectory: zod.z.string(),
+  generatedRouteTree: zod.z.string()
+});
+const configFilePathJson = path.resolve(process.cwd(), 'tsr.config.json');
 async function getConfig() {
-  return fs__default["default"].readJson(configFilePathJson);
+  const config = await fs.readJson(configFilePathJson);
+  return {
+    routeFileIgnorePrefix: '-',
+    ...configSchema.parse(config)
+  };
 }
 
 exports.getConfig = getConfig;

package/build/cjs/config.js.map

@@ -1 +1 @@
-{"version":3,"file":"config.js","sources":["../../src/config.ts"],"sourcesContent":["import path from 'path'\nimport fs from 'fs-extra'\n\nexport type Config = {\n  rootDirectory: string\n  sourceDirectory: string\n  routesDirectory: string\n  routeGenDirectory: string\n}\n\nconst configFilePathJson = path.resolve(process.cwd(), 'tsr.config.json')\n\nexport async function getConfig() {\n  return fs.readJson(configFilePathJson)\n}\n"],"names":["configFilePathJson","path","resolve","process","cwd","getConfig","fs","readJson"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAUA,MAAMA,kBAAkB,GAAGC,wBAAI,CAACC,OAAO,CAACC,OAAO,CAACC,GAAG,EAAE,EAAE,iBAAiB,CAAC,CAAA;AAElE,eAAeC,SAAS,GAAG;AAChC,EAAA,OAAOC,sBAAE,CAACC,QAAQ,CAACP,kBAAkB,CAAC,CAAA;AACxC;;;;"}
+{"version":3,"file":"config.js","sources":["../../src/config.ts"],"sourcesContent":["import path from 'path'\nimport fs from 'fs-extra'\nimport { z } from 'zod'\n\nconst configSchema = z.object({\n  routeFilePrefix: z.string().optional(),\n  routeFileIgnorePrefix: z.string().optional(),\n  routesDirectory: z.string(),\n  generatedRouteTree: z.string(),\n})\n\nexport type Config = z.infer<typeof configSchema>\n\nconst configFilePathJson = path.resolve(process.cwd(), 'tsr.config.json')\n\nexport async function getConfig(): Promise<Config> {\n  const config = (await fs.readJson(configFilePathJson)) as unknown as Config\n\n  return { routeFileIgnorePrefix: '-', ...configSchema.parse(config) }\n}\n"],"names":["configSchema","z","object","routeFilePrefix","string","optional","routeFileIgnorePrefix","routesDirectory","generatedRouteTree","configFilePathJson","path","resolve","process","cwd","getConfig","config","fs","readJson","parse"],"mappings":";;;;;;;;;;;;;;;;AAIA,MAAMA,YAAY,GAAGC,KAAC,CAACC,MAAM,CAAC;EAC5BC,eAAe,EAAEF,KAAC,CAACG,MAAM,EAAE,CAACC,QAAQ,EAAE;EACtCC,qBAAqB,EAAEL,KAAC,CAACG,MAAM,EAAE,CAACC,QAAQ,EAAE;AAC5CE,EAAAA,eAAe,EAAEN,KAAC,CAACG,MAAM,EAAE;AAC3BI,EAAAA,kBAAkB,EAAEP,KAAC,CAACG,MAAM,EAAC;AAC/B,CAAC,CAAC,CAAA;AAIF,MAAMK,kBAAkB,GAAGC,IAAI,CAACC,OAAO,CAACC,OAAO,CAACC,GAAG,EAAE,EAAE,iBAAiB,CAAC,CAAA;AAElE,eAAeC,SAASA,GAAoB;EACjD,MAAMC,MAAM,GAAI,MAAMC,EAAE,CAACC,QAAQ,CAACR,kBAAkB,CAAuB,CAAA;EAE3E,OAAO;AAAEH,IAAAA,qBAAqB,EAAE,GAAG;AAAE,IAAA,GAAGN,YAAY,CAACkB,KAAK,CAACH,MAAM,CAAA;GAAG,CAAA;AACtE;;;;"}

package/build/cjs/generate.js

@@ -1,5 +1,5 @@
 /**
- * router-cli
+ * @tanstack/router-cli/src/index.ts
  *
  * Copyright (c) TanStack
  *
@@ -10,8 +10,6 @@
  */
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var generator = require('./generator.js');
 
 async function generate(config) {

package/build/cjs/generate.js.map

@@ -1 +1 @@
-{"version":3,"file":"generate.js","sources":["../../src/generate.ts"],"sourcesContent":["import { generator } from './generator'\nimport { Config } from './config'\n\nexport async function generate(config: Config) {\n  try {\n    await generator(config)\n    process.exit(0)\n  } catch (err) {\n    console.error(err)\n    process.exit(1)\n  }\n}\n"],"names":["generate","config","generator","process","exit","err","console","error"],"mappings":";;;;;;;;;;;;;;;;AAGO,eAAeA,QAAQ,CAACC,MAAc,EAAE;EAC7C,IAAI;IACF,MAAMC,mBAAS,CAACD,MAAM,CAAC,CAAA;AACvBE,IAAAA,OAAO,CAACC,IAAI,CAAC,CAAC,CAAC,CAAA;GAChB,CAAC,OAAOC,GAAG,EAAE;AACZC,IAAAA,OAAO,CAACC,KAAK,CAACF,GAAG,CAAC,CAAA;AAClBF,IAAAA,OAAO,CAACC,IAAI,CAAC,CAAC,CAAC,CAAA;AACjB,GAAA;AACF;;;;"}
+{"version":3,"file":"generate.js","sources":["../../src/generate.ts"],"sourcesContent":["import { generator } from './generator'\nimport { Config } from './config'\n\nexport async function generate(config: Config) {\n  try {\n    await generator(config)\n    process.exit(0)\n  } catch (err) {\n    console.error(err)\n    process.exit(1)\n  }\n}\n"],"names":["generate","config","generator","process","exit","err","console","error"],"mappings":";;;;;;;;;;;;;;AAGO,eAAeA,QAAQA,CAACC,MAAc,EAAE;EAC7C,IAAI;IACF,MAAMC,mBAAS,CAACD,MAAM,CAAC,CAAA;AACvBE,IAAAA,OAAO,CAACC,IAAI,CAAC,CAAC,CAAC,CAAA;GAChB,CAAC,OAAOC,GAAG,EAAE;AACZC,IAAAA,OAAO,CAACC,KAAK,CAACF,GAAG,CAAC,CAAA;AAClBF,IAAAA,OAAO,CAACC,IAAI,CAAC,CAAC,CAAC,CAAA;AACjB,GAAA;AACF;;;;"}

package/build/cjs/generator.js

@@ -1,5 +1,5 @@
 /**
- * router-cli
+ * @tanstack/router-cli/src/index.ts
  *
  * Copyright (c) TanStack
  *
@@ -10,34 +10,92 @@
  */
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var klaw = require('klaw');
-var through2 = require('through2');
 var path = require('path');
 var fs = require('fs-extra');
-var crypto = require('crypto');
-var transformCode = require('./transformCode.js');
+var prettier = require('prettier');
+var reactRouter = require('@tanstack/react-router');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
 
-var klaw__default = /*#__PURE__*/_interopDefaultLegacy(klaw);
-var through2__default = /*#__PURE__*/_interopDefaultLegacy(through2);
-var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
-var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
-var crypto__default = /*#__PURE__*/_interopDefaultLegacy(crypto);
+var prettier__namespace = /*#__PURE__*/_interopNamespaceDefault(prettier);
 
 let latestTask = 0;
-const rootRouteName = '__root';
-const rootRouteClientName = '__root.client';
-let nodeCache = undefined;
+const rootPathId = '__root';
+const fileRouteRegex = /new\s+FileRoute\(([^)]*)\)/g;
+async function getRouteNodes(config) {
+  const {
+    routeFilePrefix,
+    routeFileIgnorePrefix
+  } = config;
+  let routeNodes = [];
+  async function recurse(dir) {
+    const fullDir = path.resolve(config.routesDirectory, dir);
+    let dirList = await fs.readdir(fullDir);
+    dirList = dirList.filter(d => {
+      if (d.startsWith('.') || routeFileIgnorePrefix && d.startsWith(routeFileIgnorePrefix)) {
+        return false;
+      }
+      if (routeFilePrefix) {
+        return d.startsWith(routeFilePrefix);
+      }
+      return true;
+    });
+    await Promise.all(dirList.map(async fileName => {
+      const fullPath = path.join(fullDir, fileName);
+      const relativePath = path.join(dir, fileName);
+      const stat = await fs.stat(fullPath);
+      if (stat.isDirectory()) {
+        await recurse(relativePath);
+      } else {
+        const filePath = path.join(dir, fileName);
+        const filePathNoExt = removeExt(filePath);
+        let routePath = replaceBackslash(reactRouter.cleanPath(`/${filePathNoExt.split('.').join('/')}`)) ?? '';
+        const variableName = fileToVariable(routePath);
+
+        // Remove the index from the route path and
+        // if the route path is empty, use `/'
+        if (routePath === 'index') {
+          routePath = '/';
+        } else if (routePath.endsWith('/index')) {
+          routePath = routePath.replace(/\/index$/, '/');
+        }
+        routeNodes.push({
+          filePath,
+          fullPath,
+          routePath,
+          variableName
+        });
+      }
+    }));
+    return routeNodes;
+  }
+  await recurse('./');
+  return routeNodes;
+}
+let first = false;
+let skipMessage = false;
 async function generator(config) {
   console.log();
-  let first = false;
-  if (!nodeCache) {
-    first = true;
+  if (!first) {
     console.log('🔄 Generating routes...');
-    nodeCache = [];
+    first = true;
+  } else if (skipMessage) {
+    skipMessage = false;
   } else {
     console.log('♻️  Regenerating routes...');
   }
@@ -45,243 +103,125 @@ async function generator(config) {
   latestTask = taskId;
   const checkLatest = () => {
     if (latestTask !== taskId) {
-      console.log(`- Skipping since file changes were made while generating.`);
+      skipMessage = true;
       return false;
     }
     return true;
   };
   const start = Date.now();
-  let routeConfigImports = [];
-  let routeConfigClientImports = [];
-  let nodesChanged = false;
-  const fileQueue = [];
-  const queueWriteFile = (filename, content) => {
-    fileQueue.push([filename, content]);
-  };
-  async function reparent(dir) {
-    let dirList;
-    try {
-      dirList = await fs__default["default"].readdir(dir);
-    } catch (err) {
-      console.log();
-      console.error('TSR: Error reading the config.routesDirectory. Does it exist?');
-      console.log();
-      throw err;
+  const routePathIdPrefix = config.routeFilePrefix ?? '';
+  let routeNodes = await getRouteNodes(config);
+  routeNodes = multiSortBy(routeNodes, [d => d.routePath === '/' ? -1 : 1, d => d.routePath?.split('/').length, d => d.routePath?.endsWith('/') ? -1 : 1, d => d.routePath]).filter(d => d.routePath !== `/${routePathIdPrefix + rootPathId}`);
+  const routeTree = [];
+
+  // Loop over the flat list of routeNodes and
+  // build up a tree based on the routeNodes' routePath
+  routeNodes.forEach(node => {
+    // routeNodes.forEach((existingNode) => {
+    //   if (
+    //     node.routePath?.startsWith(`${existingNode?.routePath ?? ''}/`)
+    //     // node.routePath.length > existingNode.routePath!.length
+    //   ) {
+    //     node.parent = existingNode
+    //   }
+    // })
+    const parentRoute = hasParentRoute(routeNodes, node.routePath);
+    if (parentRoute) node.parent = parentRoute;
+    node.path = node.parent ? node.routePath?.replace(node.parent.routePath, '') || '/' : node.routePath;
+    const trimmedPath = reactRouter.trimPathLeft(node.path ?? '');
+    const split = trimmedPath?.split('/') ?? [];
+    let first = split[0] ?? trimmedPath ?? '';
+    node.isNonPath = first.startsWith('_');
+    node.isNonLayout = first.endsWith('_');
+    node.cleanedPath = removeUnderscores(node.path) ?? '';
+    if (node.parent) {
+      node.parent.children = node.parent.children ?? [];
+      node.parent.children.push(node);
+    } else {
+      routeTree.push(node);
     }
-    const dirListCombo = multiSortBy(await Promise.all(dirList.map(async filename => {
-      const fullPath = path__default["default"].resolve(dir, filename);
-      const stat = await fs__default["default"].lstat(fullPath);
-      const ext = path__default["default"].extname(filename);
-      const clientFilename = filename.replace(ext, `.client${ext}`);
-      const pathFromRoutes = path__default["default"].relative(config.routesDirectory, fullPath);
-      const genPath = path__default["default"].resolve(config.routeGenDirectory, pathFromRoutes);
-      const genPathNoExt = removeExt(genPath);
-      const genDir = path__default["default"].resolve(genPath, '..');
-      const fileNameNoExt = removeExt(filename);
-      return {
-        filename,
-        clientFilename,
-        fileNameNoExt,
-        fullPath,
-        fullDir: dir,
-        genPath,
-        genDir,
-        genPathNoExt,
-        variable: fileToVariable(removeExt(pathFromRoutes)),
-        isDirectory: stat.isDirectory(),
-        isIndex: fileNameNoExt === 'index'
-      };
-    })), [d => d.fileNameNoExt === 'index' ? -1 : 1, d => d.fileNameNoExt, d => d.isDirectory ? 1 : -1]);
-    const reparented = [];
-    dirListCombo.forEach(async (d, i) => {
-      if (d.isDirectory) {
-        const parent = reparented.find(dd => !dd.isDirectory && dd.fileNameNoExt === d.filename);
-        if (parent) {
-          parent.childRoutesDir = d.fullPath;
-        } else {
-          reparented.push(d);
-        }
-      } else {
-        reparented.push(d);
-      }
-    });
-    return Promise.all(reparented.map(async d => {
-      if (d.childRoutesDir) {
-        const children = await reparent(d.childRoutesDir);
-        d = {
-          ...d,
-          children
-        };
-        children.forEach(child => child.parent = d);
-        return d;
-      }
-      return d;
-    }));
-  }
-  const reparented = await reparent(config.routesDirectory);
+  });
   async function buildRouteConfig(nodes, depth = 1) {
-    const children = nodes.map(async n => {
-      let node = nodeCache.find(d => d.fullPath === n.fullPath);
-      if (node) {
-        node.new = false;
-      } else {
-        node = n;
-        nodeCache.push(node);
-        if (!first) {
-          node.new = true;
-        }
-      }
-      node.version = latestTask;
-      if (node.fileNameNoExt === '__root') {
-        node.isRoot = true;
-      }
-      const routeCode = await fs__default["default"].readFile(node.fullPath, 'utf-8');
-      const hashSum = crypto__default["default"].createHash('sha256');
-      hashSum.update(routeCode);
-      const hash = hashSum.digest('hex');
-      node.changed = node.hash !== hash;
-      if (node.changed) {
-        nodesChanged = true;
-        node.hash = hash;
-        try {
-          // Ensure the boilerplate for the route exists
-          const code = await transformCode.ensureBoilerplate(node, routeCode);
-          if (code) {
-            await fs__default["default"].writeFile(node.fullPath, code);
-          }
-          let imports = [];
-          if (!node.isRoot) {
-            // Generate the isolated files
-            const transforms = await Promise.all(transformCode.isolatedProperties.map(async key => {
-              let exported = false;
-              let exports = [];
-              const transformed = await transformCode.isolateOptionToExport(node, routeCode, {
-                isolate: key
-              });
-              if (transformed) {
-                exports = await transformCode.detectExports(transformed);
-                if (exports.includes(key)) {
-                  exported = true;
-                }
-              }
-              return {
-                key,
-                exported,
-                code: transformed
-              };
-            }));
-            imports = transforms.filter(({
-              exported
-            }) => exported);
-            node.importedFiles = await Promise.all(imports.map(({
-              key,
-              code
-            }) => {
-              const importFilename = `${node.genPathNoExt}-${key}.tsx`;
-              queueWriteFile(importFilename, code);
-              return importFilename;
-            }));
-          }
-          const routeConfigCode = await transformCode.generateRouteConfig(node, routeCode, imports, false);
-          const clientRouteConfigCode = await transformCode.generateRouteConfig(node, routeCode, imports, true);
-          queueWriteFile(node.genPath, routeConfigCode);
-          queueWriteFile(path__default["default"].resolve(node.genDir, node.clientFilename), clientRouteConfigCode);
-        } catch (err) {
-          node.hash = '';
-        }
-      }
-      routeConfigImports.push(`import { route as ${node.variable}Route } from './${removeExt(path__default["default"].relative(config.routeGenDirectory, node.genPath).replace(/\\/gi, '/'))}'`);
-      routeConfigClientImports.push(`import { route as ${node.variable}Route } from './${removeExt(path__default["default"].relative(config.routeGenDirectory, path__default["default"].resolve(node.genDir, node.clientFilename)).replace(/\\/gi, '/'))}'`);
+    const children = nodes.map(async node => {
+      const routeCode = await fs.readFile(node.fullPath, 'utf-8');
+
+      // Ensure the boilerplate for the route exists
       if (node.isRoot) {
-        return undefined;
+        return;
+      }
+
+      // Ensure that new FileRoute(anything?) is replace with FileRoute(${node.routePath})
+      // routePath can contain $ characters, which have special meaning when used in replace
+      // so we have to escape it by turning all $ into $$. But since we do it through a replace call
+      // we have to double escape it into $$$$. For more information, see
+      // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement
+      const escapedRoutePath = node.routePath?.replaceAll('$', '$$$$') ?? '';
+      const replaced = routeCode.replace(fileRouteRegex, `new FileRoute('${escapedRoutePath}')`);
+      if (replaced !== routeCode) {
+        await fs.writeFile(node.fullPath, replaced);
       }
-      const route = `${node.variable}Route`;
+      const route = `${node.variableName}Route`;
       if (node.children?.length) {
         const childConfigs = await buildRouteConfig(node.children, depth + 1);
-        return `${route}.addChildren([\n${spaces(depth * 4)}${childConfigs}\n${spaces(depth * 2)}])`;
+        return `${route}.addChildren([${spaces(depth * 4)}${childConfigs}])`;
       }
       return route;
     });
-    return (await Promise.all(children)).filter(Boolean).join(`,\n${spaces(depth * 2)}`);
+    return (await Promise.all(children)).filter(Boolean).join(`,`);
   }
-  const routeConfigChildrenText = await buildRouteConfig(reparented);
-  routeConfigImports = multiSortBy(routeConfigImports, [d => d.includes('__root') ? -1 : 1, d => d.split('/').length, d => d.endsWith("index'") ? -1 : 1, d => d]);
-  routeConfigClientImports = multiSortBy(routeConfigClientImports, [d => d.includes('__root') ? -1 : 1, d => d.split('/').length, d => d.endsWith("index.client'") ? -1 : 1, d => d]);
-  const routeConfig = `export const routeTree = rootRoute.addChildren([\n  ${routeConfigChildrenText}\n])\nexport type __GeneratedRouteConfig = typeof routeTree`;
-  const routeConfigClient = `export const routeTreeClient = rootRoute.addChildren([\n  ${routeConfigChildrenText}\n]) as __GeneratedRouteConfig`;
-  const routeConfigFileContent = [routeConfigImports.join('\n'), routeConfig].join('\n\n');
-  const routeConfigClientFileContent = [`import type { __GeneratedRouteConfig } from './routeTree'`, routeConfigClientImports.join('\n'), routeConfigClient].join('\n\n');
-  if (nodesChanged) {
-    queueWriteFile(path__default["default"].resolve(config.routeGenDirectory, 'routeTree.ts'), routeConfigFileContent);
-    queueWriteFile(path__default["default"].resolve(config.routeGenDirectory, 'routeTree.client.ts'), routeConfigClientFileContent);
+  const routeConfigChildrenText = await buildRouteConfig(routeTree);
+  const routeImports = [`import { Route as rootRoute } from './${sanitize(path.relative(path.dirname(config.generatedRouteTree), path.resolve(config.routesDirectory, routePathIdPrefix + rootPathId)))}'`, ...multiSortBy(routeNodes, [d => d.routePath?.includes(`/${routePathIdPrefix + rootPathId}`) ? -1 : 1, d => d.routePath?.split('/').length, d => d.routePath?.endsWith("index'") ? -1 : 1, d => d]).map(node => {
+    return `import { Route as ${node.variableName}Route } from './${sanitize(removeExt(path.relative(path.dirname(config.generatedRouteTree), path.resolve(config.routesDirectory, node.filePath))))}'`;
+  })].join('\n');
+  const routeTypes = `declare module '@tanstack/react-router' {
+  interface FileRoutesByPath {
+    ${routeNodes.map(routeNode => {
+    return `'${routeNode.routePath}': {
+          parentRoute: typeof ${routeNode.parent?.variableName ?? 'root'}Route
+        }`;
+  }).join('\n')}
   }
-
-  // Do all of our file system manipulation at the end
-  await fs__default["default"].mkdir(config.routeGenDirectory, {
-    recursive: true
-  });
-  if (!checkLatest()) return;
-  await Promise.all(fileQueue.map(async ([filename, content]) => {
-    await fs__default["default"].ensureDir(path__default["default"].dirname(filename));
-    const exists = await fs__default["default"].pathExists(filename);
-    let current = '';
-    if (exists) {
-      current = await fs__default["default"].readFile(filename, 'utf-8');
-    }
-    if (current !== content) {
-      await fs__default["default"].writeFile(filename, content);
-    }
-  }));
-  if (!checkLatest()) return;
-  const allFiles = await getAllFiles(config.routeGenDirectory);
-  if (!checkLatest()) return;
-  const removedNodes = [];
-  nodeCache = nodeCache.filter(d => {
-    if (d.version !== latestTask) {
-      removedNodes.push(d);
-      return false;
-    }
-    return true;
+}`;
+  const routeOptions = routeNodes.map(routeNode => {
+    return `Object.assign(${routeNode.variableName ?? 'root'}Route.options, {
+        ${[routeNode.isNonPath ? `id: '${routeNode.cleanedPath}'` : `path: '${routeNode.cleanedPath}'`, `getParentRoute: () => ${routeNode.parent?.variableName ?? 'root'}Route`
+    // `\n// ${JSON.stringify(
+    //   {
+    //     ...routeNode,
+    //     parent: undefined,
+    //     children: undefined,
+    //     fullPath: undefined,
+    //     variableName: undefined,
+    //   },
+    //   null,
+    //   2,
+    // )
+    //   .split('\n')
+    //   .join('\n// ')}`,
+    ].filter(Boolean).join(',')}
+      })`;
+  }).join('\n\n');
+  const routeConfig = `export const routeTree = rootRoute.addChildren([${routeConfigChildrenText}])`;
+  const routeConfigFileContent = await prettier__namespace.format([routeImports, routeTypes, routeOptions, routeConfig].join('\n\n'), {
+    semi: false,
+    parser: 'typescript'
   });
-  const newNodes = nodeCache.filter(d => d.new);
-  const updatedNodes = nodeCache.filter(d => !d.new && d.changed);
-  const unusedFiles = allFiles.filter(d => {
-    if (d === path__default["default"].resolve(config.routeGenDirectory, 'routeTree.ts') || d === path__default["default"].resolve(config.routeGenDirectory, 'routeTree.client.ts')) {
-      return false;
+  const routeTreeContent = await fs.readFile(path.resolve(config.generatedRouteTree), 'utf-8').catch(err => {
+    if (err.code === 'ENOENT') {
+      return undefined;
     }
-    let node = nodeCache.find(n => n.genPath === d || path__default["default"].resolve(n.genDir, n.clientFilename) === d || n.importedFiles?.includes(d));
-    return !node;
+    throw err;
   });
-  await Promise.all(unusedFiles.map(d => {
-    fs__default["default"].remove(d);
-  }));
-  console.log(`🌲 Processed ${nodeCache.length} routes in ${Date.now() - start}ms`);
-  if (newNodes.length || updatedNodes.length || removedNodes.length) {
-    if (newNodes.length) {
-      console.log(`🥳 Added ${newNodes.length} new routes`);
-    }
-    if (updatedNodes.length) {
-      console.log(`✅ Updated ${updatedNodes.length} routes`);
-    }
-    if (removedNodes.length) {
-      console.log(`🗑 Removed ${removedNodes.length} unused routes`);
-    }
-  } else {
-    console.log(`🎉 No changes were found. Carry on!`);
+  if (!checkLatest()) return;
+  if (routeTreeContent !== routeConfigFileContent) {
+    await fs.ensureDir(path.dirname(path.resolve(config.generatedRouteTree)));
+    if (!checkLatest()) return;
+    await fs.writeFile(path.resolve(config.generatedRouteTree), routeConfigFileContent);
   }
-}
-function getAllFiles(dir) {
-  return new Promise((resolve, reject) => {
-    const excludeDirFilter = through2__default["default"].obj(function (item, enc, next) {
-      if (!item.stats.isDirectory()) this.push(item);
-      next();
-    });
-    const items = [];
-    klaw__default["default"](dir).pipe(excludeDirFilter).on('data', item => items.push(item.path)).on('error', err => reject(err)).on('end', () => resolve(items));
-  });
+  console.log(`🌲 Processed ${routeNodes.length} routes in ${Date.now() - start}ms`);
 }
 function fileToVariable(d) {
-  return d.split('/').map((d, i) => i > 0 ? capitalize(d) : d).join('').replace(/([^a-zA-Z0-9]|[\.])/gm, '');
+  return removeUnderscores(d)?.replace(/\$/g, '')?.split(/[/-]/g).map((d, i) => i > 0 ? capitalize(d) : d).join('').replace(/([^a-zA-Z0-9]|[\.])/gm, '') ?? '';
 }
 function removeExt(d) {
   return d.substring(0, d.lastIndexOf('.')) || d;
@@ -314,10 +254,36 @@ function capitalize(s) {
   if (typeof s !== 'string') return '';
   return s.charAt(0).toUpperCase() + s.slice(1);
 }
+function sanitize(s) {
+  return replaceBackslash(s?.replace(/\\index/gi, ''));
+}
+function removeUnderscores(s) {
+  return s?.replace(/(^_|_$)/, '').replace(/(\/_|_\/)/, '/');
+}
+function replaceBackslash(s) {
+  return s?.replace(/\\/gi, '/');
+}
+function hasParentRoute(routes, routeToCheck) {
+  if (!routeToCheck || routeToCheck === '/') {
+    return null;
+  }
+  const sortedNodes = multiSortBy(routes, [d => d.routePath.length * -1, d => d.variableName]).filter(d => d.routePath !== `/${rootPathId}`);
+  for (const route of sortedNodes) {
+    if (route.routePath === '/') continue;
+    if (routeToCheck.startsWith(`${route.routePath}/`) && route.routePath !== routeToCheck) {
+      return route;
+    }
+  }
+  const segments = routeToCheck.split('/');
+  segments.pop(); // Remove the last segment
+  const parentRoute = segments.join('/');
+  return hasParentRoute(routes, parentRoute);
+}
 
+exports.fileRouteRegex = fileRouteRegex;
 exports.generator = generator;
+exports.hasParentRoute = hasParentRoute;
 exports.multiSortBy = multiSortBy;
 exports.removeExt = removeExt;
-exports.rootRouteClientName = rootRouteClientName;
-exports.rootRouteName = rootRouteName;
+exports.rootPathId = rootPathId;
 //# sourceMappingURL=generator.js.map