@tanstack/router-generator 1.52.0 → 1.55.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/router-generator",
-  "version": "1.52.0",
+  "version": "1.55.0",
   "description": "Modern and scalable routing for React applications",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -50,7 +50,8 @@
   },
   "dependencies": {
     "prettier": "^3.3.3",
-    "zod": "^3.23.8"
+    "zod": "^3.23.8",
+    "@tanstack/virtual-file-routes": "^1.52.5"
   },
   "scripts": {}
 }

package/src/config.ts

@@ -1,8 +1,10 @@
 import path from 'node:path'
 import { existsSync, readFileSync } from 'node:fs'
 import { z } from 'zod'
+import { virtualRootRouteSchema } from './filesystem/virtual/config'
 
 export const configSchema = z.object({
+  virtualRouteConfig: virtualRootRouteSchema.optional(),
   routeFilePrefix: z.string().optional(),
   routeFileIgnorePrefix: z.string().optional().default('-'),
   routeFileIgnorePattern: z.string().optional(),

package/src/filesystem/physical/getRouteNodes.ts

@@ -0,0 +1,151 @@
+import path from 'node:path'
+import * as fsp from 'node:fs/promises'
+import {
+  determineInitialRoutePath,
+  logging,
+  removeExt,
+  removeTrailingSlash,
+  replaceBackslash,
+  routePathToVariable,
+} from '../../utils'
+import { rootPathId } from './rootPathId'
+import type { GetRouteNodesResult, RouteNode } from '../../types'
+import type { Config } from '../../config'
+
+const disallowedRouteGroupConfiguration = /\(([^)]+)\).(ts|js|tsx|jsx)/
+
+export async function getRouteNodes(
+  config: Config,
+): Promise<GetRouteNodesResult> {
+  const { routeFilePrefix, routeFileIgnorePrefix, routeFileIgnorePattern } =
+    config
+  const logger = logging({ disabled: config.disableLogging })
+  const routeFileIgnoreRegExp = new RegExp(routeFileIgnorePattern ?? '', 'g')
+
+  const routeNodes: Array<RouteNode> = []
+
+  async function recurse(dir: string) {
+    const fullDir = path.resolve(config.routesDirectory, dir)
+    let dirList = await fsp.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) => {
+        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 = determineInitialRoutePath(filePathNoExt)
+
+          if (routeFilePrefix) {
+            routePath = routePath.replaceAll(routeFilePrefix, '')
+          }
+
+          if (disallowedRouteGroupConfiguration.test(dirent.name)) {
+            const errorMessage = `A route configuration for a route group was found at \`${filePath}\`. This is not supported. Did you mean to use a layout/pathless route instead?`
+            logger.error(`ERROR: ${errorMessage}`)
+            throw new Error(errorMessage)
+          }
+
+          const variableName = routePathToVariable(routePath)
+
+          const isLazy = routePath.endsWith('/lazy')
+
+          if (isLazy) {
+            routePath = routePath.replace(/\/lazy$/, '')
+          }
+
+          const isRoute = routePath.endsWith(`/${config.routeToken}`)
+          const isComponent = routePath.endsWith('/component')
+          const isErrorComponent = routePath.endsWith('/errorComponent')
+          const isPendingComponent = routePath.endsWith('/pendingComponent')
+          const isLoader = routePath.endsWith('/loader')
+          const isAPIRoute = routePath.startsWith(
+            `${removeTrailingSlash(config.apiBase)}/`,
+          )
+
+          const segments = routePath.split('/')
+          const lastRouteSegment = segments[segments.length - 1]
+          const isLayout =
+            (lastRouteSegment !== config.indexToken &&
+              lastRouteSegment !== config.routeToken &&
+              lastRouteSegment?.startsWith('_')) ||
+            false
+
+          ;(
+            [
+              [isComponent, 'component'],
+              [isErrorComponent, 'errorComponent'],
+              [isPendingComponent, 'pendingComponent'],
+              [isLoader, 'loader'],
+            ] as const
+          ).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.replace(
+            new RegExp(
+              `/(component|errorComponent|pendingComponent|loader|${config.routeToken}|lazy)$`,
+            ),
+            '',
+          )
+
+          if (routePath === config.indexToken) {
+            routePath = '/'
+          }
+
+          routePath =
+            routePath.replace(new RegExp(`/${config.indexToken}$`), '/') || '/'
+
+          routeNodes.push({
+            filePath,
+            fullPath,
+            routePath,
+            variableName,
+            isRoute,
+            isComponent,
+            isErrorComponent,
+            isPendingComponent,
+            isLoader,
+            isLazy,
+            isLayout,
+            isAPIRoute,
+          })
+        }
+      }),
+    )
+
+    return routeNodes
+  }
+
+  await recurse('./')
+
+  const rootRouteNode = routeNodes.find((d) => d.routePath === `/${rootPathId}`)
+  return { rootRouteNode, routeNodes }
+}

package/src/filesystem/physical/rootPathId.ts

@@ -0,0 +1 @@
+export const rootPathId = '__root'

package/src/filesystem/virtual/config.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod'
+import type {
+  LayoutRoute,
+  PhysicalSubtree,
+  Route,
+  VirtualRootRoute,
+} from '@tanstack/virtual-file-routes'
+
+const indexRouteSchema = z.object({
+  type: z.literal('index'),
+  file: z.string(),
+})
+
+const layoutRouteSchema: z.ZodType<LayoutRoute> = z.object({
+  type: z.literal('layout'),
+  id: z.string(),
+  file: z.string(),
+  children: z.array(z.lazy(() => virtualRouteNodeSchema)).optional(),
+})
+
+const routeSchema: z.ZodType<Route> = z.object({
+  type: z.literal('route'),
+  file: z.string(),
+  path: z.string(),
+  children: z.array(z.lazy(() => virtualRouteNodeSchema)).optional(),
+})
+
+const physicalSubTreeSchema: z.ZodType<PhysicalSubtree> = z.object({
+  type: z.literal('physical'),
+  directory: z.string(),
+  pathPrefix: z.string(),
+})
+
+const virtualRouteNodeSchema = z.union([
+  indexRouteSchema,
+  layoutRouteSchema,
+  routeSchema,
+  physicalSubTreeSchema,
+])
+
+export const virtualRootRouteSchema: z.ZodType<VirtualRootRoute> = z.object({
+  type: z.literal('root'),
+  file: z.string(),
+  children: z.array(virtualRouteNodeSchema).optional(),
+})

package/src/filesystem/virtual/getRouteNodes.ts

@@ -0,0 +1,141 @@
+import { join, resolve } from 'node:path'
+import {
+  removeExt,
+  removeLeadingSlash,
+  removeTrailingSlash,
+  routePathToVariable,
+} from '../../utils'
+import { getRouteNodes as getRouteNodesPhysical } from '../physical/getRouteNodes'
+import type { VirtualRouteNode } from '@tanstack/virtual-file-routes'
+import type { GetRouteNodesResult, RouteNode } from '../../types'
+import type { Config } from '../../config'
+
+function ensureLeadingUnderScore(id: string) {
+  if (id.startsWith('_')) {
+    return id
+  }
+  return `_${id}`
+}
+
+function flattenTree(node: RouteNode): Array<RouteNode> {
+  const result = [node]
+
+  if (node.children) {
+    for (const child of node.children) {
+      result.push(...flattenTree(child))
+    }
+  }
+  delete node.children
+
+  return result
+}
+
+export async function getRouteNodes(
+  tsrConfig: Config,
+): Promise<GetRouteNodesResult> {
+  const fullDir = resolve(tsrConfig.routesDirectory)
+  if (tsrConfig.virtualRouteConfig === undefined) {
+    throw new Error(`virtualRouteConfig is undefined`)
+  }
+  const children = await getRouteNodesRecursive(
+    tsrConfig,
+    fullDir,
+    tsrConfig.virtualRouteConfig.children,
+  )
+  const allNodes = flattenTree({
+    children,
+    filePath: tsrConfig.virtualRouteConfig.file,
+    fullPath: join(fullDir, tsrConfig.virtualRouteConfig.file),
+    variableName: 'rootRoute',
+    routePath: '/',
+    isRoot: true,
+  })
+
+  const rootRouteNode = allNodes[0]
+  const routeNodes = allNodes.slice(1)
+
+  return { rootRouteNode, routeNodes }
+}
+
+export async function getRouteNodesRecursive(
+  tsrConfig: Config,
+  fullDir: string,
+  nodes?: Array<VirtualRouteNode>,
+  parent?: RouteNode,
+): Promise<Array<RouteNode>> {
+  if (nodes === undefined) {
+    return []
+  }
+  const children = await Promise.all(
+    nodes.map(async (node) => {
+      if (node.type === 'physical') {
+        const { routeNodes } = await getRouteNodesPhysical({
+          ...tsrConfig,
+          routesDirectory: resolve(fullDir, node.directory),
+        })
+        routeNodes.forEach((subtreeNode) => {
+          subtreeNode.variableName = routePathToVariable(
+            `${node.pathPrefix}/${removeExt(subtreeNode.filePath)}`,
+          )
+          subtreeNode.routePath = `${parent?.routePath ?? ''}${node.pathPrefix}${subtreeNode.routePath}`
+          subtreeNode.filePath = `${node.directory}/${subtreeNode.filePath}`
+        })
+        return routeNodes
+      }
+
+      const filePath = node.file
+      const variableName = routePathToVariable(removeExt(filePath))
+      const fullPath = join(fullDir, filePath)
+      const parentRoutePath = removeTrailingSlash(parent?.routePath ?? '/')
+      const isLayout = node.type === 'layout'
+      switch (node.type) {
+        case 'index': {
+          const routePath = `${parentRoutePath}/`
+          return {
+            filePath,
+            fullPath,
+            variableName,
+            routePath,
+            isLayout,
+          } satisfies RouteNode
+        }
+
+        case 'route':
+        case 'layout': {
+          let lastSegment: string
+          if (node.type === 'layout') {
+            if (node.id !== undefined) {
+              node.id = ensureLeadingUnderScore(node.id)
+            } else {
+              node.id = '_layout'
+            }
+            lastSegment = node.id
+          } else {
+            lastSegment = node.path
+          }
+          const routePath = `${parentRoutePath}/${removeLeadingSlash(lastSegment)}`
+
+          const routeNode: RouteNode = {
+            fullPath,
+            isLayout,
+            filePath,
+            variableName,
+            routePath,
+          }
+
+          if (node.children !== undefined) {
+            const children = await getRouteNodesRecursive(
+              tsrConfig,
+              fullDir,
+              node.children,
+              routeNode,
+            )
+            routeNode.children = children
+          }
+          return routeNode
+        }
+      }
+    }),
+  )
+  return children.flat()
+}