@tanstack/router-generator 1.132.0-alpha.9 → 1.132.0

package/src/index.ts

@@ -9,11 +9,7 @@ export type { Config, BaseConfig } from './config'
 export { Generator } from './generator'
 export type { FileEventType, FileEvent, GeneratorEvent } from './generator'
 
-export type {
-  GeneratorPluginBase,
-  GeneratorPlugin,
-  GeneratorPluginWithTransform,
-} from './plugin/types'
+export type { GeneratorPlugin } from './plugin/types'
 
 export {
   capitalize,
@@ -31,7 +27,6 @@ export {
   format,
   removeExt,
   checkRouteFullPathUniqueness,
-  hasChildWithExport,
 } from './utils'
 
 export type {
@@ -41,6 +36,7 @@ export type {
   GetRoutesByFileMapResultValue,
   ImportDeclaration,
   ImportSpecifier,
+  HandleNodeAccumulator,
 } from './types'
 
 export { getRouteNodes as physicalGetRouteNodes } from './filesystem/physical/getRouteNodes'
@@ -54,5 +50,4 @@ export type {
   TransformImportsConfig,
   TransformContext,
   TransformOptions,
-  TransformPlugin,
 } from './transform/types'

package/src/plugin/types.ts

@@ -1,51 +1,18 @@
-import type { TransformPlugin } from '../transform/types'
-import type {
-  HandleNodeAccumulator,
-  ImportDeclaration,
-  RouteNode,
-} from '../types'
-
+import type { HandleNodeAccumulator, RouteNode } from '../types'
 import type { Generator } from '../generator'
 
-export type GeneratorPlugin = GeneratorPluginBase | GeneratorPluginWithTransform
-
-export interface GeneratorPluginBase {
+export interface GeneratorPlugin {
   name: string
-  onRouteTreesChanged?: (opts: {
-    routeTrees: Array<{
-      sortedRouteNodes: Array<RouteNode>
-      acc: HandleNodeAccumulator
-      exportName: string
-    }>
+  init?: (opts: { generator: Generator }) => void
+  onRouteTreeChanged?: (opts: {
+    routeTree: Array<RouteNode>
+    routeNodes: Array<RouteNode>
     rootRouteNode: RouteNode
-    generator: Generator
+    acc: HandleNodeAccumulator
   }) => void
-}
 
-export interface GeneratorPluginWithTransform extends GeneratorPluginBase {
-  transformPlugin: TransformPlugin
-  moduleAugmentation: (opts: { generator: Generator }) => {
-    module: string
-    interfaceName: string
-  }
-  imports: (opts: {
-    rootRouteNode: RouteNode
-    sortedRouteNodes: Array<RouteNode>
-    acc: HandleNodeAccumulator
-    generator: Generator
-  }) => Array<ImportDeclaration>
-  routeModuleAugmentation: (opts: {
-    routeNode: RouteNode
-  }) => string | undefined
-  createRootRouteCode: () => string
-  createVirtualRouteCode: (opts: { node: RouteNode }) => string
-  config: (opts: {
-    generator: Generator
-    rootRouteNode: RouteNode
-    sortedRouteNodes: Array<RouteNode>
-  }) => {
-    virtualRootRoute?: boolean
-  }
+  afterTransform?: (opts: {
+    node: RouteNode
+    prevNode: RouteNode | undefined
+  }) => void
 }
-
-export {}

package/src/transform/transform.ts

@@ -2,24 +2,20 @@ import { parseAst } from '@tanstack/router-utils'
 import { parse, print, types, visit } from 'recast'
 import { SourceMapConsumer } from 'source-map'
 import { mergeImportDeclarations } from '../utils'
+import { ensureStringArgument } from './utils'
 import type { ImportDeclaration } from '../types'
 import type { RawSourceMap } from 'source-map'
-import type {
-  TransformOptions,
-  TransformPlugin,
-  TransformResult,
-} from './types'
+import type { TransformOptions, TransformResult } from './types'
 
 const b = types.builders
 
 export async function transform({
   ctx,
   source,
-  plugins,
+  node,
 }: TransformOptions): Promise<TransformResult> {
   let appliedChanges = false as boolean
   let ast: types.namedTypes.File
-  const foundExports: Array<string> = []
   try {
     ast = parse(source, {
       sourceFileName: 'output.ts',
@@ -44,41 +40,77 @@ export async function transform({
 
   const preferredQuote = detectPreferredQuoteStyle(ast)
 
-  const registeredExports = new Map</* export name */ string, TransformPlugin>()
-
-  for (const plugin of plugins ?? []) {
-    const exportName = plugin.exportName
-    if (registeredExports.has(exportName)) {
+  let routeExportHandled = false as boolean
+  function onExportFound(decl: types.namedTypes.VariableDeclarator) {
+    if (decl.init?.type === 'CallExpression') {
+      const callExpression = decl.init
+      const firstArgument = callExpression.arguments[0]
+      if (firstArgument) {
+        if (firstArgument.type === 'ObjectExpression') {
+          const staticProperties = firstArgument.properties.flatMap((p) => {
+            if (p.type === 'ObjectProperty' && p.key.type === 'Identifier') {
+              return p.key.name
+            }
+            return []
+          })
+          node.createFileRouteProps = new Set(staticProperties)
+        }
+      }
+      let identifier: types.namedTypes.Identifier | undefined
+      // `const Route = createFileRoute({ ... })`
+      if (callExpression.callee.type === 'Identifier') {
+        identifier = callExpression.callee
+        if (ctx.verboseFileRoutes) {
+          // we need to add the string literal via another CallExpression
+          callExpression.callee = b.callExpression(identifier, [
+            b.stringLiteral(ctx.routeId),
+          ])
+          appliedChanges = true
+        }
+      }
+      // `const Route = createFileRoute('/path')({ ... })`
+      else if (
+        callExpression.callee.type === 'CallExpression' &&
+        callExpression.callee.callee.type === 'Identifier'
+      ) {
+        identifier = callExpression.callee.callee
+        if (!ctx.verboseFileRoutes) {
+          // we need to remove the route id
+          callExpression.callee = identifier
+          appliedChanges = true
+        } else {
+          // check if the route id is correct
+          appliedChanges = ensureStringArgument(
+            callExpression.callee,
+            ctx.routeId,
+            ctx.preferredQuote,
+          )
+        }
+      }
+      if (identifier === undefined) {
+        throw new Error(
+          `expected identifier to be present in ${ctx.routeId} for export "Route"`,
+        )
+      }
+      if (identifier.name === 'createFileRoute' && ctx.lazy) {
+        identifier.name = 'createLazyFileRoute'
+        appliedChanges = true
+      } else if (identifier.name === 'createLazyFileRoute' && !ctx.lazy) {
+        identifier.name = 'createFileRoute'
+        appliedChanges = true
+      }
+    } else {
       throw new Error(
-        `Export ${exportName} is already registered by plugin ${registeredExports.get(exportName)?.name}`,
+        `expected "Route" export to be initialized by a CallExpression`,
       )
     }
-    registeredExports.set(exportName, plugin)
-  }
-
-  function onExportFound(
-    decl: types.namedTypes.VariableDeclarator,
-    exportName: string,
-    plugin: TransformPlugin,
-  ) {
-    const pluginAppliedChanges = plugin.onExportFound({
-      decl,
-      ctx: { ...ctx, preferredQuote },
-    })
-    if (pluginAppliedChanges) {
-      appliedChanges = true
-    }
-
-    // export is handled, remove it from the registered exports
-    registeredExports.delete(exportName)
-    // store the export so we can later return it once the file is transformed
-    foundExports.push(exportName)
+    routeExportHandled = true
   }
 
   const program: types.namedTypes.Program = ast.program
-  // first pass: find registered exports
+  // first pass: find Route export
   for (const n of program.body) {
-    if (registeredExports.size > 0 && n.type === 'ExportNamedDeclaration') {
+    if (n.type === 'ExportNamedDeclaration') {
       // direct export of a variable declaration, e.g. `export const Route = createFileRoute('/path')`
       if (n.declaration?.type === 'VariableDeclaration') {
         const decl = n.declaration.declarations[0]
@@ -87,9 +119,8 @@ export async function transform({
           decl.type === 'VariableDeclarator' &&
           decl.id.type === 'Identifier'
         ) {
-          const plugin = registeredExports.get(decl.id.name)
-          if (plugin) {
-            onExportFound(decl, decl.id.name, plugin)
+          if (decl.id.name === 'Route') {
+            onExportFound(decl)
           }
         }
       }
@@ -97,8 +128,7 @@ export async function transform({
       else if (n.declaration === null && n.specifiers) {
         for (const spec of n.specifiers) {
           if (typeof spec.exported.name === 'string') {
-            const plugin = registeredExports.get(spec.exported.name)
-            if (plugin) {
+            if (spec.exported.name === 'Route') {
               const variableName = spec.local?.name || spec.exported.name
               // find the matching variable declaration by iterating over the top-level declarations
               for (const decl of program.body) {
@@ -112,7 +142,7 @@ export async function transform({
                     variable.id.type === 'Identifier' &&
                     variable.id.name === variableName
                   ) {
-                    onExportFound(variable, spec.exported.name, plugin)
+                    onExportFound(variable)
                     break
                   }
                 }
@@ -122,6 +152,15 @@ export async function transform({
         }
       }
     }
+    if (routeExportHandled) {
+      break
+    }
+  }
+
+  if (!routeExportHandled) {
+    return {
+      result: 'no-route-export',
+    }
   }
 
   const imports: {
@@ -132,16 +171,44 @@ export async function transform({
     banned: [],
   }
 
-  for (const plugin of plugins ?? []) {
-    const exportName = plugin.exportName
-    if (foundExports.includes(exportName)) {
-      const pluginImports = plugin.imports(ctx)
-      if (pluginImports.required) {
-        imports.required.push(...pluginImports.required)
-      }
-      if (pluginImports.banned) {
-        imports.banned.push(...pluginImports.banned)
-      }
+  const targetModule = `@tanstack/${ctx.target}-router`
+  if (ctx.verboseFileRoutes === false) {
+    imports.banned = [
+      {
+        source: targetModule,
+        specifiers: [
+          { imported: 'createLazyFileRoute' },
+          { imported: 'createFileRoute' },
+        ],
+      },
+    ]
+  } else {
+    if (ctx.lazy) {
+      imports.required = [
+        {
+          source: targetModule,
+          specifiers: [{ imported: 'createLazyFileRoute' }],
+        },
+      ]
+      imports.banned = [
+        {
+          source: targetModule,
+          specifiers: [{ imported: 'createFileRoute' }],
+        },
+      ]
+    } else {
+      imports.required = [
+        {
+          source: targetModule,
+          specifiers: [{ imported: 'createFileRoute' }],
+        },
+      ]
+      imports.banned = [
+        {
+          source: targetModule,
+          specifiers: [{ imported: 'createLazyFileRoute' }],
+        },
+      ]
     }
   }
 
@@ -289,7 +356,6 @@ export async function transform({
 
   if (!appliedChanges) {
     return {
-      exports: foundExports,
       result: 'not-modified',
     }
   }
@@ -310,7 +376,6 @@ export async function transform({
   }
   return {
     result: 'modified',
-    exports: foundExports,
     output: transformedCode,
   }
 }

package/src/transform/types.ts

@@ -1,22 +1,22 @@
-import type { ImportDeclaration } from '../types'
-import type { types } from 'recast'
+import type { ImportDeclaration, RouteNode } from '../types'
 import type { Config } from '../config'
 
 export interface TransformOptions {
   source: string
   ctx: TransformContext
-  plugins?: Array<TransformPlugin>
+  node: RouteNode
 }
 
 export type TransformResult =
+  | {
+      result: 'no-route-export'
+    }
   | {
       result: 'not-modified'
-      exports: Array<string>
     }
   | {
       result: 'modified'
       output: string
-      exports: Array<string>
     }
   | {
       result: 'error'
@@ -27,19 +27,6 @@ export interface TransformImportsConfig {
   banned?: Array<ImportDeclaration>
   required?: Array<ImportDeclaration>
 }
-export interface TransformPlugin {
-  name: string
-  exportName: string
-  imports: (ctx: TransformContext) => TransformImportsConfig
-  /**
-   * Called after the export is found in the AST.
-   * @returns true if the plugin modified the AST, false otherwise
-   */
-  onExportFound: (opts: {
-    decl: types.namedTypes.VariableDeclarator
-    ctx: TransformContext
-  }) => boolean
-}
 
 export interface TransformContext {
   target: Config['target']

package/src/types.ts

@@ -12,7 +12,7 @@ export type RouteNode = {
   isVirtual?: boolean
   children?: Array<RouteNode>
   parent?: RouteNode
-  exports?: Array<string>
+  createFileRouteProps?: Set<string>
 }
 
 export interface GetRouteNodesResult {

package/src/utils.ts

@@ -320,11 +320,10 @@ export function hasParentRoute(
  */
 export const getResolvedRouteNodeVariableName = (
   routeNode: RouteNode,
-  variableNameSuffix: string,
 ): string => {
   return routeNode.children?.length
-    ? `${routeNode.variableName}${variableNameSuffix}WithChildren`
-    : `${routeNode.variableName}${variableNameSuffix}`
+    ? `${routeNode.variableName}RouteWithChildren`
+    : `${routeNode.variableName}Route`
 }
 
 /**
@@ -463,65 +462,59 @@ Conflicting files: \n ${conflictingFiles.map((d) => path.resolve(config.routesDi
 
 export function buildRouteTreeConfig(
   nodes: Array<RouteNode>,
-  exportName: string,
   disableTypes: boolean,
   depth = 1,
 ): Array<string> {
-  const children = nodes
-    .filter((n) => n.exports?.includes(exportName))
-    .map((node) => {
-      if (node._fsRouteType === '__root') {
-        return
-      }
+  const children = nodes.map((node) => {
+    if (node._fsRouteType === '__root') {
+      return
+    }
 
-      if (node._fsRouteType === 'pathless_layout' && !node.children?.length) {
-        return
-      }
+    if (node._fsRouteType === 'pathless_layout' && !node.children?.length) {
+      return
+    }
 
-      const route = `${node.variableName}`
+    const route = `${node.variableName}`
 
-      if (node.children?.length) {
-        const childConfigs = buildRouteTreeConfig(
-          node.children,
-          exportName,
-          disableTypes,
-          depth + 1,
-        )
+    if (node.children?.length) {
+      const childConfigs = buildRouteTreeConfig(
+        node.children,
+        disableTypes,
+        depth + 1,
+      )
 
-        const childrenDeclaration = disableTypes
-          ? ''
-          : `interface ${route}${exportName}Children {
+      const childrenDeclaration = disableTypes
+        ? ''
+        : `interface ${route}RouteChildren {
   ${node.children
-    .filter((n) => n.exports?.includes(exportName))
     .map(
       (child) =>
-        `${child.variableName}${exportName}: typeof ${getResolvedRouteNodeVariableName(child, exportName)}`,
+        `${child.variableName}Route: typeof ${getResolvedRouteNodeVariableName(child)}`,
     )
     .join(',')}
 }`
 
-        const children = `const ${route}${exportName}Children${disableTypes ? '' : `: ${route}${exportName}Children`} = {
+      const children = `const ${route}RouteChildren${disableTypes ? '' : `: ${route}RouteChildren`} = {
   ${node.children
-    .filter((n) => n.exports?.includes(exportName))
     .map(
       (child) =>
-        `${child.variableName}${exportName}: ${getResolvedRouteNodeVariableName(child, exportName)}`,
+        `${child.variableName}Route: ${getResolvedRouteNodeVariableName(child)}`,
     )
     .join(',')}
 }`
 
-        const routeWithChildren = `const ${route}${exportName}WithChildren = ${route}${exportName}._addFileChildren(${route}${exportName}Children)`
+      const routeWithChildren = `const ${route}RouteWithChildren = ${route}Route._addFileChildren(${route}RouteChildren)`
 
-        return [
-          childConfigs.join('\n'),
-          childrenDeclaration,
-          children,
-          routeWithChildren,
-        ].join('\n\n')
-      }
+      return [
+        childConfigs.join('\n'),
+        childrenDeclaration,
+        children,
+        routeWithChildren,
+      ].join('\n\n')
+    }
 
-      return undefined
-    })
+    return undefined
+  })
 
   return children.filter((x) => x !== undefined)
 }
@@ -570,55 +563,33 @@ export function mergeImportDeclarations(
   return Object.values(merged)
 }
 
-export function hasChildWithExport(
-  node: RouteNode,
-  exportName: string,
-): boolean {
-  return (
-    node.children?.some((child) => hasChildWithExport(child, exportName)) ??
-    false
-  )
-}
-
-export const findParent = (
-  node: RouteNode | undefined,
-  exportName: string,
-): string => {
+export const findParent = (node: RouteNode | undefined): string => {
   if (!node) {
-    return `root${exportName}Import`
+    return `rootRouteImport`
   }
   if (node.parent) {
-    if (node.parent.exports?.includes(exportName)) {
-      if (node.isVirtualParentRequired) {
-        return `${node.parent.variableName}${exportName}`
-      } else {
-        return `${node.parent.variableName}${exportName}`
-      }
+    if (node.isVirtualParentRequired) {
+      return `${node.parent.variableName}Route`
+    } else {
+      return `${node.parent.variableName}Route`
     }
   }
-  return findParent(node.parent, exportName)
+  return findParent(node.parent)
 }
 
 export function buildFileRoutesByPathInterface(opts: {
   routeNodes: Array<RouteNode>
   module: string
   interfaceName: string
-  exportName: string
 }): string {
   return `declare module '${opts.module}' {
   interface ${opts.interfaceName} {
     ${opts.routeNodes
       .map((routeNode) => {
         const filePathId = routeNode.routePath
-        let preloaderRoute = ''
-
-        if (routeNode.exports?.includes(opts.exportName)) {
-          preloaderRoute = `typeof ${routeNode.variableName}${opts.exportName}Import`
-        } else {
-          preloaderRoute = 'unknown'
-        }
+        const preloaderRoute = `typeof ${routeNode.variableName}RouteImport`
 
-        const parent = findParent(routeNode, opts.exportName)
+        const parent = findParent(routeNode)
 
         return `'${filePathId}': {
           id: '${filePathId}'
@@ -632,3 +603,47 @@ export function buildFileRoutesByPathInterface(opts: {
   }
 }`
 }
+
+export function getImportPath(
+  node: RouteNode,
+  config: Config,
+  generatedRouteTreePath: string,
+): string {
+  return replaceBackslash(
+    removeExt(
+      path.relative(
+        path.dirname(generatedRouteTreePath),
+        path.resolve(config.routesDirectory, node.filePath),
+      ),
+      config.addExtensions,
+    ),
+  )
+}
+
+export function getImportForRouteNode(
+  node: RouteNode,
+  config: Config,
+  generatedRouteTreePath: string,
+  root: string,
+): ImportDeclaration {
+  let source = ''
+  if (config.importRoutesUsingAbsolutePaths) {
+    source = replaceBackslash(
+      removeExt(
+        path.resolve(root, config.routesDirectory, node.filePath),
+        config.addExtensions,
+      ),
+    )
+  } else {
+    source = `./${getImportPath(node, config, generatedRouteTreePath)}`
+  }
+  return {
+    source,
+    specifiers: [
+      {
+        imported: 'Route',
+        local: `${node.variableName}RouteImport`,
+      },
+    ],
+  } satisfies ImportDeclaration
+}