@tanstack/router-generator 1.112.0 → 1.112.7

package/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,7 +177,7 @@ export async function getRouteNodesRecursive(
               fullPath,
               variableName,
               routePath,
-              isLayout,
+              _fsRouteType: 'static',
             }
           } else {
             routeNode = {
@@ -184,8 +185,8 @@ export async function getRouteNodesRecursive(
               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) {

package/src/generator.ts

@@ -23,7 +23,7 @@ import {
   fillTemplate,
   getTargetTemplate,
 } from './template'
-import type { GetRouteNodesResult, RouteNode } from './types'
+import type { FsRouteType, GetRouteNodesResult, RouteNode } from './types'
 import type { Config } from './config'
 
 export const CONSTANTS = {
@@ -113,6 +113,16 @@ export async function generator(config: Config, root: string) {
   const routeTree: Array<RouteNode> = []
   const routePiecesByPath: Record<string, RouteSubNode> = {}
 
+  // Filtered API Route nodes
+  const onlyAPIRouteNodes = preRouteNodes.filter(
+    (d) => d._fsRouteType === 'api',
+  )
+
+  // Filtered Generator Route nodes
+  const onlyGeneratorRouteNodes = preRouteNodes.filter(
+    (d) => d._fsRouteType !== 'api',
+  )
+
   // Loop over the flat list of routeNodes and
   // build up a tree based on the routeNodes' routePath
   const routeNodes: Array<RouteNode> = []
@@ -204,7 +214,8 @@ export async function generator(config: Config, root: string) {
       const tLazyRouteTemplate = ROUTE_TEMPLATE.lazyRoute
 
       if (!routeCode) {
-        if (node.isLazy) {
+        // Creating a new lazy route file
+        if (node._fsRouteType === 'lazy') {
           // Check by default check if the user has a specific lazy route template
           // If not, check if the user has a route template and use that instead
           replaced = await fillTemplate(
@@ -221,11 +232,18 @@ export async function generator(config: Config, root: string) {
             },
           )
         } else if (
-          node.isRoute ||
-          (!node.isComponent &&
-            !node.isErrorComponent &&
-            !node.isPendingComponent &&
-            !node.isLoader)
+          // Creating a new normal route file
+          (['layout', 'static'] satisfies Array<FsRouteType>).some(
+            (d) => d === node._fsRouteType,
+          ) ||
+          (
+            [
+              'component',
+              'pendingComponent',
+              'errorComponent',
+              'loader',
+            ] satisfies Array<FsRouteType>
+          ).every((d) => d !== node._fsRouteType)
         ) {
           replaced = await fillTemplate(
             config,
@@ -241,6 +259,7 @@ export async function generator(config: Config, root: string) {
           )
         }
       } else {
+        // Update the existing route file
         replaced = routeCode
           .replace(
             /(FileRoute\(\s*['"])([^\s]*)(['"],?\s*\))/g,
@@ -252,12 +271,12 @@ export async function generator(config: Config, root: string) {
               'gs',
             ),
             (_, p1, __, ___, p4) =>
-              `${p1}${node.isLazy ? 'createLazyFileRoute' : 'createFileRoute'}${p4}`,
+              `${p1}${node._fsRouteType === 'lazy' ? 'createLazyFileRoute' : 'createFileRoute'}${p4}`,
           )
           .replace(
             /create(Lazy)?FileRoute(\(\s*['"])([^\s]*)(['"],?\s*\))/g,
             (_, __, p2, ___, p4) =>
-              `${node.isLazy ? 'createLazyFileRoute' : 'createFileRoute'}${p2}${escapedRoutePath}${p4}`,
+              `${node._fsRouteType === 'lazy' ? 'createLazyFileRoute' : 'createFileRoute'}${p2}${escapedRoutePath}${p4}`,
           )
       }
 
@@ -270,23 +289,27 @@ export async function generator(config: Config, root: string) {
 
     if (
       !node.isVirtual &&
-      (node.isLoader ||
-        node.isComponent ||
-        node.isErrorComponent ||
-        node.isPendingComponent ||
-        node.isLazy)
+      (
+        [
+          'lazy',
+          'loader',
+          'component',
+          'pendingComponent',
+          'errorComponent',
+        ] satisfies Array<FsRouteType>
+      ).some((d) => d === node._fsRouteType)
     ) {
       routePiecesByPath[node.routePath!] =
         routePiecesByPath[node.routePath!] || {}
 
       routePiecesByPath[node.routePath!]![
-        node.isLazy
+        node._fsRouteType === 'lazy'
           ? 'lazy'
-          : node.isLoader
+          : node._fsRouteType === 'loader'
             ? 'loader'
-            : node.isErrorComponent
+            : node._fsRouteType === 'errorComponent'
               ? 'errorComponent'
-              : node.isPendingComponent
+              : node._fsRouteType === 'pendingComponent'
                 ? 'pendingComponent'
                 : 'component'
       ] = node
@@ -297,20 +320,21 @@ export async function generator(config: Config, root: string) {
         await handleNode({
           ...node,
           isVirtual: true,
-          isLazy: false,
-          isLoader: false,
-          isComponent: false,
-          isErrorComponent: false,
-          isPendingComponent: false,
+          _fsRouteType: 'static',
         })
       }
       return
     }
 
     const cleanedPathIsEmpty = (node.cleanedPath || '').length === 0
-    const nonPathRoute = node.isRoute && node.isNonPath
+    const nonPathRoute =
+      node._fsRouteType === 'pathless_layout' && node.isNonPath
+
     node.isVirtualParentRequired =
-      node.isLayout || nonPathRoute ? !cleanedPathIsEmpty : false
+      node._fsRouteType === 'pathless_layout' || nonPathRoute
+        ? !cleanedPathIsEmpty
+        : false
+
     if (!node.isVirtual && node.isVirtualParentRequired) {
       const parentRoutePath = removeLastSegmentFromPath(node.routePath) || '/'
       const parentVariableName = routePathToVariable(parentRoutePath)
@@ -320,7 +344,7 @@ export async function generator(config: Config, root: string) {
       )
 
       if (!anchorRoute) {
-        const parentNode = {
+        const parentNode: RouteNode = {
           ...node,
           path: removeLastSegmentFromPath(node.path) || '/',
           filePath: removeLastSegmentFromPath(node.filePath) || '/',
@@ -328,7 +352,7 @@ export async function generator(config: Config, root: string) {
           routePath: parentRoutePath,
           variableName: parentVariableName,
           isVirtual: true,
-          isLayout: false,
+          _fsRouteType: 'layout', // layout since this route will wrap other routes
           isVirtualParentRoute: true,
           isVirtualParentRequired: false,
         }
@@ -338,7 +362,7 @@ export async function generator(config: Config, root: string) {
 
         node.parent = parentNode
 
-        if (node.isLayout) {
+        if (node._fsRouteType === 'pathless_layout') {
           // since `node.path` is used as the `id` on the route definition, we need to update it
           node.path = determineNodePath(node)
         }
@@ -364,18 +388,22 @@ export async function generator(config: Config, root: string) {
     routeNodes.push(node)
   }
 
-  for (const node of preRouteNodes.filter((d) => !d.isAPIRoute)) {
+  for (const node of onlyGeneratorRouteNodes) {
     await handleNode(node)
   }
   checkRouteFullPathUniqueness(
     preRouteNodes.filter(
-      (d) => !d.isAPIRoute && d.children === undefined && d.isLazy !== true,
+      (d) =>
+        d.children === undefined &&
+        (['api', 'lazy'] satisfies Array<FsRouteType>).every(
+          (type) => type !== d._fsRouteType,
+        ),
     ),
     config,
   )
 
   const startAPIRouteNodes: Array<RouteNode> = checkStartAPIRoutes(
-    preRouteNodes.filter((d) => d.isAPIRoute),
+    onlyAPIRouteNodes,
     config,
   )
 
@@ -430,11 +458,11 @@ export async function generator(config: Config, root: string) {
 
   function buildRouteTreeConfig(nodes: Array<RouteNode>, depth = 1): string {
     const children = nodes.map((node) => {
-      if (node.isRoot) {
+      if (node._fsRouteType === '__root') {
         return
       }
 
-      if (node.isLayout && !node.children?.length) {
+      if (node._fsRouteType === 'pathless_layout' && !node.children?.length) {
         return
       }
 

package/src/types.ts

@@ -2,22 +2,14 @@ export type RouteNode = {
   filePath: string
   fullPath: string
   variableName: string
+  _fsRouteType: FsRouteType
   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
 }
@@ -26,3 +18,15 @@ export interface GetRouteNodesResult {
   rootRouteNode?: RouteNode
   routeNodes: Array<RouteNode>
 }
+
+export type FsRouteType =
+  | '__root'
+  | 'static'
+  | 'layout'
+  | 'pathless_layout'
+  | 'lazy'
+  | 'api'
+  | 'loader' // @deprecated
+  | 'component' // @deprecated
+  | 'pendingComponent' // @deprecated
+  | 'errorComponent' // @deprecated