refactor(router-generator): reduce use of boolean to identify file-system routes (#3626)

Author: SeanCassiere

packages/router-generator/src/filesystem/physical/getRouteNodes.ts

@@ -15,7 +15,7 @@ import type {
   VirtualRootRoute,
   VirtualRouteSubtreeConfig,
 } from '@tanstack/virtual-file-routes'
-import type { GetRouteNodesResult, RouteNode } from '../../types'
+import type { FsRouteType, GetRouteNodesResult, RouteNode } from '../../types'
 import type { Config } from '../../config'
 
 const disallowedRouteGroupConfiguration = /\(([^)]+)\).(ts|js|tsx|jsx)/
@@ -119,33 +119,29 @@ export async function getRouteNodes(
             throw new Error(errorMessage)
           }
 
-          const variableName = routePathToVariable(routePath)
+          const meta = getRouteMeta(routePath, config)
+          const variableName = meta.variableName
+          let routeType: FsRouteType = meta.fsRouteType
 
-          const isLazy = routePath.endsWith('/lazy')
-
-          if (isLazy) {
+          if (routeType === 'lazy') {
             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 isLayout = determineRouteIsLayout(routePath, config)
+          // this check needs to happen after the lazy route has been cleaned up
+          // since the routePath is used to determine if a route is pathless
+          if (isValidPathlessLayoutRoute(routePath, routeType, config)) {
+            routeType = 'pathless_layout'
+          }
 
           ;(
             [
-              [isComponent, 'component'],
-              [isErrorComponent, 'errorComponent'],
-              [isPendingComponent, 'pendingComponent'],
-              [isLoader, 'loader'],
-            ] as const
-          ).forEach(([isType, type]) => {
-            if (isType) {
+              ['component', 'component'],
+              ['errorComponent', 'errorComponent'],
+              ['pendingComponent', 'pendingComponent'],
+              ['loader', 'loader'],
+            ] satisfies Array<[FsRouteType, string]>
+          ).forEach(([matcher, type]) => {
+            if (routeType === matcher) {
               logger.warn(
                 `WARNING: The \`.${type}.tsx\` suffix used for the ${filePath} file is deprecated. Use the new \`.lazy.tsx\` suffix instead.`,
               )
@@ -171,14 +167,7 @@ export async function getRouteNodes(
             fullPath,
             routePath,
             variableName,
-            isRoute,
-            isComponent,
-            isErrorComponent,
-            isPendingComponent,
-            isLoader,
-            isLazy,
-            isLayout,
-            isAPIRoute,
+            _fsRouteType: routeType,
           })
         }
       }),
@@ -190,16 +179,84 @@ export async function getRouteNodes(
   await recurse('./')
 
   const rootRouteNode = routeNodes.find((d) => d.routePath === `/${rootPathId}`)
+  if (rootRouteNode) {
+    rootRouteNode._fsRouteType = '__root'
+  }
+
   return { rootRouteNode, routeNodes }
 }
 
 /**
- * Used to determine if a route is a layout route
+ * Determines the metadata for a given route path based on the provided configuration.
+ *
+ * @param routePath - The determined initial routePath.
+ * @param config - The user configuration object.
+ * @returns An object containing the type of the route and the variable name derived from the route path.
+ */
+export function getRouteMeta(
+  routePath: string,
+  config: Config,
+): {
+  // `__root` is can be more easily determined by filtering down to routePath === /${rootPathId}
+  // `pathless` is needs to determined after `lazy` has been cleaned up from the routePath
+  fsRouteType: Extract<
+    FsRouteType,
+    | 'static'
+    | 'layout'
+    | 'api'
+    | 'lazy'
+    | 'loader'
+    | 'component'
+    | 'pendingComponent'
+    | 'errorComponent'
+  >
+  variableName: string
+} {
+  let fsRouteType: FsRouteType = 'static'
+
+  if (routePath.endsWith(`/${config.routeToken}`)) {
+    // layout routes, i.e `/foo/route.tsx` or `/foo/_layout/route.tsx`
+    fsRouteType = 'layout'
+  } else if (routePath.startsWith(`${removeTrailingSlash(config.apiBase)}/`)) {
+    // api routes, i.e. `/api/foo.ts`
+    fsRouteType = 'api'
+  } else if (routePath.endsWith('/lazy')) {
+    // lazy routes, i.e. `/foo.lazy.tsx`
+    fsRouteType = 'lazy'
+  } else if (routePath.endsWith('/loader')) {
+    // loader routes, i.e. `/foo.loader.tsx`
+    fsRouteType = 'loader'
+  } else if (routePath.endsWith('/component')) {
+    // component routes, i.e. `/foo.component.tsx`
+    fsRouteType = 'component'
+  } else if (routePath.endsWith('/pendingComponent')) {
+    // pending component routes, i.e. `/foo.pendingComponent.tsx`
+    fsRouteType = 'pendingComponent'
+  } else if (routePath.endsWith('/errorComponent')) {
+    // error component routes, i.e. `/foo.errorComponent.tsx`
+    fsRouteType = 'errorComponent'
+  }
+
+  const variableName = routePathToVariable(routePath)
+
+  return { fsRouteType, variableName }
+}
+
+/**
+ * Used to validate if a route is a pathless layout route
  * @param normalizedRoutePath Normalized route path, i.e `/foo/_layout/route.tsx` and `/foo._layout.route.tsx` to `/foo/_layout/route`
  * @param config The `router-generator` configuration object
- * @returns Boolean indicating if the route is a layout route
+ * @returns Boolean indicating if the route is a pathless layout route
  */
-function determineRouteIsLayout(normalizedRoutePath: string, config: Config) {
+function isValidPathlessLayoutRoute(
+  normalizedRoutePath: string,
+  routeType: FsRouteType,
+  config: Config,
+): boolean {
+  if (routeType === 'lazy') {
+    return false
+  }
+
   const segments = normalizedRoutePath.split('/').filter(Boolean)
 
   if (segments.length === 0) {

packages/router-generator/src/filesystem/virtual/getRouteNodes.ts

@@ -6,6 +6,7 @@ import {
   routePathToVariable,
 } from '../../utils'
 import { getRouteNodes as getRouteNodesPhysical } from '../physical/getRouteNodes'
+import { rootPathId } from '../physical/rootPathId'
 import { virtualRootRouteSchema } from './config'
 import { loadConfigFile } from './loadConfigFile'
 import type {
@@ -64,8 +65,8 @@ export async function getRouteNodes(
     filePath: virtualRouteConfig.file,
     fullPath: join(fullDir, virtualRouteConfig.file),
     variableName: 'rootRoute',
-    routePath: '/',
-    isRoot: true,
+    routePath: `/${rootPathId}`,
+    _fsRouteType: '__root',
   })
 
   const rootRouteNode = allNodes[0]
@@ -150,7 +151,7 @@ export async function getRouteNodesRecursive(
         return { filePath, variableName, fullPath }
       }
       const parentRoutePath = removeTrailingSlash(parent?.routePath ?? '/')
-      const isLayout = node.type === 'layout'
+
       switch (node.type) {
         case 'index': {
           const { filePath, variableName, fullPath } = getFile(node.file)
@@ -160,7 +161,7 @@ export async function getRouteNodesRecursive(
             fullPath,
             variableName,
             routePath,
-            isLayout,
+            _fsRouteType: 'static',
           } satisfies RouteNode
         }
 
@@ -176,16 +177,16 @@ export async function getRouteNodesRecursive(
               fullPath,
               variableName,
               routePath,
-              isLayout,
+              _fsRouteType: 'static',
             }
           } else {
             routeNode = {
               filePath: '',
               fullPath: '',
               variableName: routePathToVariable(routePath),
               routePath,
-              isLayout,
               isVirtual: true,
+              _fsRouteType: 'static',
             }
           }
 
@@ -198,6 +199,9 @@ export async function getRouteNodesRecursive(
               routeNode,
             )
             routeNode.children = children
+
+            // If the route has children, it should be a layout
+            routeNode._fsRouteType = 'layout'
           }
           return routeNode
         }
@@ -216,10 +220,10 @@ export async function getRouteNodesRecursive(
 
           const routeNode: RouteNode = {
             fullPath,
-            isLayout,
             filePath,
             variableName,
             routePath,
+            _fsRouteType: 'pathless_layout',
           }
 
           if (node.children !== undefined) {