@tanstack/router-generator 1.52.0 → 1.55.0

package/src/generator.ts

@@ -2,175 +2,26 @@ import path from 'node:path'
 import * as fs from 'node:fs'
 import * as fsp from 'node:fs/promises'
 import * as prettier from 'prettier'
-import { cleanPath, logging, trimPathLeft } from './utils'
+import {
+  determineInitialRoutePath,
+  logging,
+  multiSortBy,
+  removeExt,
+  removeTrailingSlash,
+  removeUnderscores,
+  replaceBackslash,
+  routePathToVariable,
+  trimPathLeft,
+} from './utils'
+import { getRouteNodes as physicalGetRouteNodes } from './filesystem/physical/getRouteNodes'
+import { getRouteNodes as virtualGetRouteNodes } from './filesystem/virtual/getRouteNodes'
+import { rootPathId } from './filesystem/physical/rootPathId'
+import type { GetRouteNodesResult, RouteNode } from './types'
 import type { Config } from './config'
 
 let latestTask = 0
-export const rootPathId = '__root'
 const routeGroupPatternRegex = /\(.+\)/g
 const possiblyNestedRouteGroupPatternRegex = /\([^/]+\)\/?/g
-const disallowedRouteGroupConfiguration = /\(([^)]+)\).(ts|js|tsx|jsx)/
-
-export type RouteNode = {
-  filePath: string
-  fullPath: string
-  variableName: string
-  routePath?: string
-  cleanedPath?: string
-  path?: string
-  isNonPath?: boolean
-  isNonLayout?: boolean
-  isLayout?: boolean
-  isVirtualParentRequired?: boolean
-  isVirtualParentRoute?: boolean
-  isRoute?: boolean
-  isAPIRoute?: boolean
-  isLoader?: boolean
-  isComponent?: boolean
-  isErrorComponent?: boolean
-  isPendingComponent?: boolean
-  isVirtual?: boolean
-  isLazy?: boolean
-  isRoot?: boolean
-  children?: Array<RouteNode>
-  parent?: RouteNode
-}
-
-async function getRouteNodes(config: Config) {
-  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)
-
-          // Remove the index from the route path and
-          // if the route path is empty, use `/'
-
-          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('./')
-
-  return routeNodes
-}
 
 let isFirst = false
 let skipMessage = false
@@ -216,12 +67,18 @@ export async function generator(config: Config) {
     parser: 'typescript',
   }
 
-  const routePathIdPrefix = config.routeFilePrefix ?? ''
-  const beforeRouteNodes = await getRouteNodes(config)
-  const rootRouteNode = beforeRouteNodes.find(
-    (d) => d.routePath === `/${rootPathId}`,
-  )
+  let getRouteNodesResult: GetRouteNodesResult
 
+  if (config.virtualRouteConfig) {
+    getRouteNodesResult = await virtualGetRouteNodes(config)
+  } else {
+    getRouteNodesResult = await physicalGetRouteNodes(config)
+  }
+
+  const { rootRouteNode, routeNodes: beforeRouteNodes } = getRouteNodesResult
+  if (rootRouteNode === undefined) {
+    throw new Error(`rootRouteNode must not be undefined`)
+  }
   const preRouteNodes = multiSortBy(beforeRouteNodes, [
     (d) => (d.routePath === '/' ? -1 : 1),
     (d) => d.routePath?.split('/').length,
@@ -307,13 +164,11 @@ export const Route = createRootRoute({
     const trimmedPath = trimPathLeft(node.path ?? '')
 
     const split = trimmedPath.split('/')
-    const first = split[0] ?? trimmedPath
     const lastRouteSegment = split[split.length - 1] ?? trimmedPath
 
     node.isNonPath =
       lastRouteSegment.startsWith('_') ||
       routeGroupPatternRegex.test(lastRouteSegment)
-    node.isNonLayout = first.endsWith('_')
 
     node.cleanedPath = removeGroups(
       removeUnderscores(removeLayoutSegments(node.path)) ?? '',
@@ -571,11 +426,18 @@ export const Route = createAPIFileRoute('${escapedRoutePath}')({
     .map((d) => d[0])
 
   const virtualRouteNodes = sortedRouteNodes.filter((d) => d.isVirtual)
-  const rootPathIdExtension =
-    config.addExtensions && rootRouteNode
-      ? path.extname(rootRouteNode.filePath)
-      : ''
 
+  function getImportPath(node: RouteNode) {
+    return replaceBackslash(
+      removeExt(
+        path.relative(
+          path.dirname(config.generatedRouteTree),
+          path.resolve(config.routesDirectory, node.filePath),
+        ),
+        config.addExtensions,
+      ),
+    )
+  }
   const routeImports = [
     ...config.routeTreeFileHeader,
     '// This file is auto-generated by TanStack Router',
@@ -584,29 +446,13 @@ export const Route = createAPIFileRoute('${escapedRoutePath}')({
       : '',
     '// 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,
-            ),
-          )}'`
+          }Import } from './${getImportPath(node)}'`
         }),
     ].join('\n'),
     virtualRouteNodes.length ? '// Create Virtual Routes' : '',
@@ -704,7 +550,7 @@ export const Route = createAPIFileRoute('${escapedRoutePath}')({
     ${routeNodes
       .map((routeNode) => {
         const [filePathId, routeId] = getFilePathIdAndRouteIdFromPath(
-          routeNode.routePath!,
+          routeNode.routePath,
         )
 
         return `'${filePathId}': {
@@ -735,14 +581,14 @@ export const Route = createAPIFileRoute('${escapedRoutePath}')({
   const createRouteManifest = () => {
     const routesManifest = {
       __root__: {
-        filePath: rootRouteNode?.filePath,
+        filePath: rootRouteNode.filePath,
         children: routeTree.map(
-          (d) => getFilePathIdAndRouteIdFromPath(d.routePath!)[1],
+          (d) => getFilePathIdAndRouteIdFromPath(d.routePath)[1],
         ),
       },
       ...Object.fromEntries(
         routeNodes.map((d) => {
-          const [_, routeId] = getFilePathIdAndRouteIdFromPath(d.routePath!)
+          const [_, routeId] = getFilePathIdAndRouteIdFromPath(d.routePath)
 
           return [
             routeId,
@@ -753,7 +599,7 @@ export const Route = createAPIFileRoute('${escapedRoutePath}')({
                 : undefined,
               children: d.children?.map(
                 (childRoute) =>
-                  getFilePathIdAndRouteIdFromPath(childRoute.routePath!)[1],
+                  getFilePathIdAndRouteIdFromPath(childRoute.routePath)[1],
               ),
             },
           ]
@@ -820,89 +666,20 @@ export const Route = createAPIFileRoute('${escapedRoutePath}')({
   )
 }
 
-function routePathToVariable(routePath: string): string {
-  return (
-    removeUnderscores(routePath)
-      ?.replace(/\/\$\//g, '/splat/')
-      .replace(/\$$/g, 'splat')
-      .replace(/\$/g, '')
-      .split(/[/-]/g)
-      .map((d, i) => (i > 0 ? capitalize(d) : d))
-      .join('')
-      .replace(/([^a-zA-Z0-9]|[.])/gm, '')
-      .replace(/^(\d)/g, 'R$1') ?? ''
-  )
-}
-
-export function removeExt(d: string, keepExtension: boolean = false) {
-  return keepExtension ? d : d.substring(0, d.lastIndexOf('.')) || d
-}
-
 function spaces(d: number): string {
   return Array.from({ length: d })
     .map(() => ' ')
     .join('')
 }
 
-export function multiSortBy<T>(
-  arr: Array<T>,
-  accessors: Array<(item: T) => any> = [(d) => d],
-): Array<T> {
-  return arr
-    .map((d, i) => [d, i] as const)
-    .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: string) {
-  if (typeof s !== 'string') return ''
-  return s.charAt(0).toUpperCase() + s.slice(1)
-}
-
-function removeUnderscores(s?: string) {
-  return s?.replaceAll(/(^_|_$)/gi, '').replaceAll(/(\/_|_\/)/gi, '/')
-}
-
 function removeTrailingUnderscores(s?: string) {
   return s?.replaceAll(/(_$)/gi, '').replaceAll(/(_\/)/gi, '/')
 }
 
-function replaceBackslash(s: string) {
-  return s.replaceAll(/\\/gi, '/')
-}
-
 function removeGroups(s: string) {
   return s.replace(possiblyNestedRouteGroupPatternRegex, '')
 }
 
-function removeTrailingSlash(s: string) {
-  return s.replace(/\/$/, '')
-}
-
-function determineInitialRoutePath(routePath: string) {
-  return cleanPath(`/${routePath.split('.').join('/')}`) || ''
-}
-
 /**
  * The `node.path` is used as the `id` in the route definition.
  * This function checks if the given node has a parent and if so, it determines the correct path for the given node.
@@ -911,7 +688,7 @@ function determineInitialRoutePath(routePath: string) {
  */
 function determineNodePath(node: RouteNode) {
   return (node.path = node.parent
-    ? node.routePath?.replace(node.parent.routePath!, '') || '/'
+    ? node.routePath?.replace(node.parent.routePath ?? '', '') || '/'
     : node.routePath)
 }
 
@@ -995,7 +772,7 @@ export const inferPath = (routeNode: RouteNode): string => {
     : (routeNode.cleanedPath?.replace(/\/$/, '') ?? '')
 }
 
-function getFilePathIdAndRouteIdFromPath(pathname: string) {
+function getFilePathIdAndRouteIdFromPath(pathname?: string) {
   const filePathId = removeTrailingUnderscores(pathname)
   const id = removeGroups(filePathId ?? '')
 

package/src/types.ts

@@ -0,0 +1,28 @@
+export type RouteNode = {
+  filePath: string
+  fullPath: string
+  variableName: string
+  routePath?: string
+  cleanedPath?: string
+  path?: string
+  isNonPath?: boolean
+  isLayout?: boolean
+  isVirtualParentRequired?: boolean
+  isVirtualParentRoute?: boolean
+  isRoute?: boolean
+  isAPIRoute?: boolean
+  isLoader?: boolean
+  isComponent?: boolean
+  isErrorComponent?: boolean
+  isPendingComponent?: boolean
+  isVirtual?: boolean
+  isLazy?: boolean
+  isRoot?: boolean
+  children?: Array<RouteNode>
+  parent?: RouteNode
+}
+
+export interface GetRouteNodesResult {
+  rootRouteNode?: RouteNode
+  routeNodes: Array<RouteNode>
+}

package/src/utils.ts

@@ -1,3 +1,33 @@
+export function multiSortBy<T>(
+  arr: Array<T>,
+  accessors: Array<(item: T) => any> = [(d) => d],
+): Array<T> {
+  return arr
+    .map((d, i) => [d, i] as const)
+    .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)
+}
+
 export function cleanPath(path: string) {
   // remove double slashes
   return path.replace(/\/{2,}/g, '/')
@@ -26,3 +56,46 @@ export function logging(config: { disabled: boolean }) {
     },
   }
 }
+
+export function removeLeadingSlash(path: string): string {
+  return path.replace(/^\//, '')
+}
+
+export function removeTrailingSlash(s: string) {
+  return s.replace(/\/$/, '')
+}
+
+export function determineInitialRoutePath(routePath: string) {
+  return cleanPath(`/${routePath.split('.').join('/')}`) || ''
+}
+
+export function replaceBackslash(s: string) {
+  return s.replaceAll(/\\/gi, '/')
+}
+
+export function routePathToVariable(routePath: string): string {
+  return (
+    removeUnderscores(routePath)
+      ?.replace(/\/\$\//g, '/splat/')
+      .replace(/\$$/g, 'splat')
+      .replace(/\$/g, '')
+      .split(/[/-]/g)
+      .map((d, i) => (i > 0 ? capitalize(d) : d))
+      .join('')
+      .replace(/([^a-zA-Z0-9]|[.])/gm, '')
+      .replace(/^(\d)/g, 'R$1') ?? ''
+  )
+}
+
+export function removeUnderscores(s?: string) {
+  return s?.replaceAll(/(^_|_$)/gi, '').replaceAll(/(\/_|_\/)/gi, '/')
+}
+
+export function capitalize(s: string) {
+  if (typeof s !== 'string') return ''
+  return s.charAt(0).toUpperCase() + s.slice(1)
+}
+
+export function removeExt(d: string, keepExtension: boolean = false) {
+  return keepExtension ? d : d.substring(0, d.lastIndexOf('.')) || d
+}