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

package/src/config.ts

@@ -1,6 +1,5 @@
 import path from 'node:path'
-import { tmpdir } from 'node:os'
-import { existsSync, mkdirSync, readFileSync } from 'node:fs'
+import { existsSync, readFileSync } from 'node:fs'
 import { z } from 'zod'
 import { virtualRootRouteSchema } from './filesystem/virtual/config'
 import type { GeneratorPlugin } from './plugin/types'
@@ -121,11 +120,13 @@ export function getConfig(
     }
   }
 
-  const resolveTmpDir = (dir: string) => {
+  const resolveTmpDir = (dir: string | Array<string>) => {
+    if (Array.isArray(dir)) {
+      dir = path.join(...dir)
+    }
     if (!path.isAbsolute(dir)) {
       dir = path.resolve(process.cwd(), dir)
     }
-    mkdirSync(dir, { recursive: true })
     return dir
   }
 
@@ -134,7 +135,7 @@ export function getConfig(
   } else if (process.env.TSR_TMP_DIR) {
     config.tmpDir = resolveTmpDir(process.env.TSR_TMP_DIR)
   } else {
-    config.tmpDir = tmpdir()
+    config.tmpDir = resolveTmpDir(['.tanstack', 'tmp'])
   }
 
   validateConfig(config)

package/src/filesystem/physical/getRouteNodes.ts

@@ -19,6 +19,11 @@ import type { Config } from '../../config'
 
 const disallowedRouteGroupConfiguration = /\(([^)]+)\).(ts|js|tsx|jsx)/
 
+const virtualConfigFileRegExp = /__virtual\.[mc]?[jt]s$/
+export function isVirtualConfigFile(fileName: string): boolean {
+  return virtualConfigFileRegExp.test(fileName)
+}
+
 export async function getRouteNodes(
   config: Pick<
     Config,
@@ -34,10 +39,12 @@ export async function getRouteNodes(
 ): Promise<GetRouteNodesResult> {
   const { routeFilePrefix, routeFileIgnorePrefix, routeFileIgnorePattern } =
     config
+
   const logger = logging({ disabled: config.disableLogging })
   const routeFileIgnoreRegExp = new RegExp(routeFileIgnorePattern ?? '', 'g')
 
   const routeNodes: Array<RouteNode> = []
+  const allPhysicalDirectories: Array<string> = []
 
   async function recurse(dir: string) {
     const fullDir = path.resolve(config.routesDirectory, dir)
@@ -52,6 +59,13 @@ export async function getRouteNodes(
       }
 
       if (routeFilePrefix) {
+        if (routeFileIgnorePattern) {
+          return (
+            d.name.startsWith(routeFilePrefix) &&
+            !d.name.match(routeFileIgnoreRegExp)
+          )
+        }
+
         return d.name.startsWith(routeFilePrefix)
       }
 
@@ -63,7 +77,7 @@ export async function getRouteNodes(
     })
 
     const virtualConfigFile = dirList.find((dirent) => {
-      return dirent.isFile() && dirent.name.match(/__virtual\.[mc]?[jt]s$/)
+      return dirent.isFile() && isVirtualConfigFile(dirent.name)
     })
 
     if (virtualConfigFile !== undefined) {
@@ -81,14 +95,16 @@ export async function getRouteNodes(
         file: '',
         children: virtualRouteSubtreeConfig,
       }
-      const { routeNodes: virtualRouteNodes } = await getRouteNodesVirtual(
-        {
-          ...config,
-          routesDirectory: fullDir,
-          virtualRouteConfig: dummyRoot,
-        },
-        root,
-      )
+      const { routeNodes: virtualRouteNodes, physicalDirectories } =
+        await getRouteNodesVirtual(
+          {
+            ...config,
+            routesDirectory: fullDir,
+            virtualRouteConfig: dummyRoot,
+          },
+          root,
+        )
+      allPhysicalDirectories.push(...physicalDirectories)
       virtualRouteNodes.forEach((node) => {
         const filePath = replaceBackslash(path.join(dir, node.filePath))
         const routePath = `/${dir}${node.routePath}`
@@ -107,7 +123,7 @@ export async function getRouteNodes(
 
     await Promise.all(
       dirList.map(async (dirent) => {
-        const fullPath = path.posix.join(fullDir, dirent.name)
+        const fullPath = replaceBackslash(path.join(fullDir, dirent.name))
         const relativePath = path.posix.join(dir, dirent.name)
 
         if (dirent.isDirectory()) {
@@ -192,7 +208,11 @@ export async function getRouteNodes(
     rootRouteNode.variableName = 'root'
   }
 
-  return { rootRouteNode, routeNodes }
+  return {
+    rootRouteNode,
+    routeNodes,
+    physicalDirectories: allPhysicalDirectories,
+  }
 }
 
 /**

package/src/filesystem/virtual/getRouteNodes.ts

@@ -3,6 +3,7 @@ import {
   removeExt,
   removeLeadingSlash,
   removeTrailingSlash,
+  replaceBackslash,
   routePathToVariable,
 } from '../../utils'
 import { getRouteNodes as getRouteNodesPhysical } from '../physical/getRouteNodes'
@@ -53,7 +54,6 @@ export async function getRouteNodes(
     throw new Error(`virtualRouteConfig is undefined`)
   }
   let virtualRouteConfig: VirtualRootRoute
-  let children: Array<RouteNode> = []
   if (typeof tsrConfig.virtualRouteConfig === 'string') {
     virtualRouteConfig = await getVirtualRouteConfigFromFileExport(
       tsrConfig,
@@ -62,7 +62,7 @@ export async function getRouteNodes(
   } else {
     virtualRouteConfig = tsrConfig.virtualRouteConfig
   }
-  children = await getRouteNodesRecursive(
+  const { children, physicalDirectories } = await getRouteNodesRecursive(
     tsrConfig,
     root,
     fullDir,
@@ -71,7 +71,7 @@ export async function getRouteNodes(
   const allNodes = flattenTree({
     children,
     filePath: virtualRouteConfig.file,
-    fullPath: join(fullDir, virtualRouteConfig.file),
+    fullPath: replaceBackslash(join(fullDir, virtualRouteConfig.file)),
     variableName: 'root',
     routePath: `/${rootPathId}`,
     _fsRouteType: '__root',
@@ -80,7 +80,7 @@ export async function getRouteNodes(
   const rootRouteNode = allNodes[0]
   const routeNodes = allNodes.slice(1)
 
-  return { rootRouteNode, routeNodes }
+  return { rootRouteNode, routeNodes, physicalDirectories }
 }
 
 /**
@@ -135,20 +135,22 @@ export async function getRouteNodesRecursive(
   fullDir: string,
   nodes?: Array<VirtualRouteNode>,
   parent?: RouteNode,
-): Promise<Array<RouteNode>> {
+): Promise<{ children: Array<RouteNode>; physicalDirectories: Array<string> }> {
   if (nodes === undefined) {
-    return []
+    return { children: [], physicalDirectories: [] }
   }
+  const allPhysicalDirectories: Array<string> = []
   const children = await Promise.all(
     nodes.map(async (node) => {
       if (node.type === 'physical') {
-        const { routeNodes } = await getRouteNodesPhysical(
+        const { routeNodes, physicalDirectories } = await getRouteNodesPhysical(
           {
             ...tsrConfig,
             routesDirectory: resolve(fullDir, node.directory),
           },
           root,
         )
+        allPhysicalDirectories.push(node.directory)
         routeNodes.forEach((subtreeNode) => {
           subtreeNode.variableName = routePathToVariable(
             `${node.pathPrefix}/${removeExt(subtreeNode.filePath)}`,
@@ -162,7 +164,7 @@ export async function getRouteNodesRecursive(
       function getFile(file: string) {
         const filePath = file
         const variableName = routePathToVariable(removeExt(filePath))
-        const fullPath = join(fullDir, filePath)
+        const fullPath = replaceBackslash(join(fullDir, filePath))
         return { filePath, variableName, fullPath }
       }
       const parentRoutePath = removeTrailingSlash(parent?.routePath ?? '/')
@@ -206,14 +208,16 @@ export async function getRouteNodesRecursive(
           }
 
           if (node.children !== undefined) {
-            const children = await getRouteNodesRecursive(
-              tsrConfig,
-              root,
-              fullDir,
-              node.children,
-              routeNode,
-            )
+            const { children, physicalDirectories } =
+              await getRouteNodesRecursive(
+                tsrConfig,
+                root,
+                fullDir,
+                node.children,
+                routeNode,
+              )
             routeNode.children = children
+            allPhysicalDirectories.push(...physicalDirectories)
 
             // If the route has children, it should be a layout
             routeNode._fsRouteType = 'layout'
@@ -242,19 +246,24 @@ export async function getRouteNodesRecursive(
           }
 
           if (node.children !== undefined) {
-            const children = await getRouteNodesRecursive(
-              tsrConfig,
-              root,
-              fullDir,
-              node.children,
-              routeNode,
-            )
+            const { children, physicalDirectories } =
+              await getRouteNodesRecursive(
+                tsrConfig,
+                root,
+                fullDir,
+                node.children,
+                routeNode,
+              )
             routeNode.children = children
+            allPhysicalDirectories.push(...physicalDirectories)
           }
           return routeNode
         }
       }
     }),
   )
-  return children.flat()
+  return {
+    children: children.flat(),
+    physicalDirectories: allPhysicalDirectories,
+  }
 }