@tanstack/router-generator 1.121.0-alpha.22 → 1.121.0-alpha.27

package/src/index.ts

@@ -6,10 +6,16 @@ export {
 } from './config'
 export type { Config, BaseConfig } from './config'
 
-export { generator } from './generator'
+export { Generator } from './generator'
+export type { FileEventType, FileEvent, GeneratorEvent } from './generator'
+
+export type {
+  GeneratorPluginBase,
+  GeneratorPlugin,
+  GeneratorPluginWithTransform,
+} from './plugin/types'
 
 export {
-  logging,
   capitalize,
   cleanPath,
   trimPathLeft,
@@ -24,11 +30,27 @@ export {
   writeIfDifferent,
   format,
   removeExt,
+  checkRouteFullPathUniqueness,
+  hasChildWithExport,
 } from './utils'
 
-export type { RouteNode, GetRouteNodesResult } from './types'
+export type {
+  RouteNode,
+  GetRouteNodesResult,
+  ImportDeclaration,
+  ImportSpecifier,
+} from './types'
 
 export { getRouteNodes as physicalGetRouteNodes } from './filesystem/physical/getRouteNodes'
 export { getRouteNodes as virtualGetRouteNodes } from './filesystem/virtual/getRouteNodes'
 
 export { rootPathId } from './filesystem/physical/rootPathId'
+
+export { ensureStringArgument } from './transform/utils'
+
+export type {
+  TransformImportsConfig,
+  TransformContext,
+  TransformOptions,
+  TransformPlugin,
+} from './transform/types'

package/src/logger.ts

@@ -0,0 +1,43 @@
+export interface Logger {
+  log: (...args: Array<any>) => void
+  debug: (...args: Array<any>) => void
+  info: (...args: Array<any>) => void
+  warn: (...args: Array<any>) => void
+  error: (...args: Array<any>) => void
+}
+
+export function logging(config: { disabled: boolean }): Logger {
+  function stripEmojis(str: string) {
+    return str.replace(
+      /[\p{Emoji_Presentation}\p{Extended_Pictographic}]/gu,
+      '',
+    )
+  }
+
+  function formatLogArgs(args: Array<any>): Array<any> {
+    if (process.env.CI) {
+      return args.map((arg) =>
+        typeof arg === 'string' ? stripEmojis(arg) : arg,
+      )
+    }
+    return args
+  }
+
+  return {
+    log: (...args: Array<any>) => {
+      if (!config.disabled) console.log(...formatLogArgs(args))
+    },
+    debug: (...args: Array<any>) => {
+      if (!config.disabled) console.debug(...formatLogArgs(args))
+    },
+    info: (...args: Array<any>) => {
+      if (!config.disabled) console.info(...formatLogArgs(args))
+    },
+    warn: (...args: Array<any>) => {
+      if (!config.disabled) console.warn(...formatLogArgs(args))
+    },
+    error: (...args: Array<any>) => {
+      if (!config.disabled) console.error(...formatLogArgs(args))
+    },
+  }
+}

package/src/plugin/default-generator-plugin.ts

@@ -0,0 +1,96 @@
+import { defaultTransformPlugin } from '../transform/default-transform-plugin'
+import {
+  checkRouteFullPathUniqueness,
+  isRouteNodeValidForAugmentation,
+} from '../utils'
+import type { ImportDeclaration } from '../types'
+import type { GeneratorPluginWithTransform } from './types'
+
+export function defaultGeneratorPlugin(): GeneratorPluginWithTransform {
+  return {
+    name: 'default',
+    transformPlugin: defaultTransformPlugin,
+    imports: (opts) => {
+      const imports: Array<ImportDeclaration> = []
+      if (opts.acc.routeNodes.some((n) => n.isVirtual)) {
+        imports.push({
+          specifiers: [{ imported: 'createFileRoute' }],
+          source: opts.generator.targetTemplate.fullPkg,
+        })
+      }
+      if (opts.generator.config.verboseFileRoutes === false) {
+        const typeImport: ImportDeclaration = {
+          specifiers: [],
+          source: opts.generator.targetTemplate.fullPkg,
+          importKind: 'type',
+        }
+        if (
+          opts.sortedRouteNodes.some(
+            (d) =>
+              isRouteNodeValidForAugmentation(d) && d._fsRouteType !== 'lazy',
+          )
+        ) {
+          typeImport.specifiers.push({ imported: 'CreateFileRoute' })
+        }
+        if (
+          opts.sortedRouteNodes.some(
+            (node) =>
+              opts.acc.routePiecesByPath[node.routePath!]?.lazy &&
+              isRouteNodeValidForAugmentation(node),
+          )
+        ) {
+          typeImport.specifiers.push({ imported: 'CreateLazyFileRoute' })
+        }
+
+        if (typeImport.specifiers.length > 0) {
+          typeImport.specifiers.push({ imported: 'FileRoutesByPath' })
+          imports.push(typeImport)
+        }
+      }
+      return imports
+    },
+    moduleAugmentation: ({ generator }) => ({
+      module: generator.targetTemplate.fullPkg,
+      interfaceName: 'FileRoutesByPath',
+    }),
+    onRouteTreesChanged: ({ routeTrees, generator }) => {
+      const routeTree = routeTrees.find((tree) => tree.exportName === 'Route')
+      if (!routeTree) {
+        throw new Error(
+          'No route tree found with export name "Route". Please ensure your routes are correctly defined.',
+        )
+      }
+      checkRouteFullPathUniqueness(
+        routeTree.sortedRouteNodes.filter(
+          (d) =>
+            d.children === undefined &&
+            'lazy' !== d._fsRouteType &&
+            d.exports?.includes('Route'),
+        ),
+        generator.config,
+      )
+    },
+    routeModuleAugmentation: ({ routeNode }) => {
+      if (routeNode._fsRouteType === 'lazy') {
+        return `const createLazyFileRoute: CreateLazyFileRoute<FileRoutesByPath['${routeNode.routePath}']['preLoaderRoute']>`
+      } else {
+        return `const createFileRoute: CreateFileRoute<'${routeNode.routePath}',
+            FileRoutesByPath['${routeNode.routePath}']['parentRoute'],
+            FileRoutesByPath['${routeNode.routePath}']['id'],
+            FileRoutesByPath['${routeNode.routePath}']['path'],
+            FileRoutesByPath['${routeNode.routePath}']['fullPath']
+          >
+        `
+      }
+    },
+    createRootRouteCode: () => `createRooRoute()`,
+    createVirtualRouteCode: ({ node }) =>
+      `createFileRoute('${node.routePath}')()`,
+    config: ({ sortedRouteNodes }) => {
+      const hasMatchingRouteFiles = sortedRouteNodes.length > 0
+      return {
+        virtualRootRoute: hasMatchingRouteFiles,
+      }
+    },
+  }
+}

package/src/plugin/types.ts

@@ -0,0 +1,51 @@
+import type { TransformPlugin } from '../transform/types'
+import type {
+  HandleNodeAccumulator,
+  ImportDeclaration,
+  RouteNode,
+} from '../types'
+
+import type { Generator } from '../generator'
+
+export type GeneratorPlugin = GeneratorPluginBase | GeneratorPluginWithTransform
+
+export interface GeneratorPluginBase {
+  name: string
+  onRouteTreesChanged?: (opts: {
+    routeTrees: Array<{
+      sortedRouteNodes: Array<RouteNode>
+      acc: HandleNodeAccumulator
+      exportName: string
+    }>
+    rootRouteNode: RouteNode
+    generator: Generator
+  }) => 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
+  }
+}
+
+export {}

package/src/template.ts

@@ -15,7 +15,7 @@ export function fillTemplate(
   return format(replaced, config)
 }
 
-type TargetTemplate = {
+export type TargetTemplate = {
   fullPkg: string
   subPkg: string
   rootRoute: {
@@ -44,10 +44,9 @@ type TargetTemplate = {
   }
 }
 
-export function getTargetTemplate(target: Config['target']): TargetTemplate {
+export function getTargetTemplate(config: Config): TargetTemplate {
+  const target = config.target
   switch (target) {
-    // TODO: Remove this disabled eslint rule when more target types are added.
-
     case 'react':
       return {
         fullPkg: '@tanstack/react-router',
@@ -77,8 +76,14 @@ export function getTargetTemplate(target: Config['target']): TargetTemplate {
               'function RouteComponent() { return <div>Hello "%%tsrPath%%"!</div> };\n',
             ].join(''),
           imports: {
-            tsrImports: () => '',
-            tsrExportStart: () => `export const Route = createFileRoute(`,
+            tsrImports: () =>
+              config.verboseFileRoutes === false
+                ? ''
+                : "import { createFileRoute } from '@tanstack/react-router';",
+            tsrExportStart: (routePath) =>
+              config.verboseFileRoutes === false
+                ? 'export const Route = createFileRoute('
+                : `export const Route = createFileRoute('${routePath}')(`,
             tsrExportEnd: () => ');',
           },
         },
@@ -92,9 +97,13 @@ export function getTargetTemplate(target: Config['target']): TargetTemplate {
             ].join(''),
           imports: {
             tsrImports: () =>
-              "import { createLazyFileRoute } from '@tanstack/react-router';",
+              config.verboseFileRoutes === false
+                ? ''
+                : "import { createLazyFileRoute } from '@tanstack/react-router';",
             tsrExportStart: (routePath) =>
-              `export const Route = createLazyFileRoute('${routePath}')(`,
+              config.verboseFileRoutes === false
+                ? 'export const Route = createLazyFileRoute('
+                : `export const Route = createLazyFileRoute('${routePath}')(`,
             tsrExportEnd: () => ');',
           },
         },
@@ -128,8 +137,14 @@ export function getTargetTemplate(target: Config['target']): TargetTemplate {
               'function RouteComponent() { return <div>Hello "%%tsrPath%%"!</div> };\n',
             ].join(''),
           imports: {
-            tsrImports: () => '',
-            tsrExportStart: () => `export const Route = createFileRoute(`,
+            tsrImports: () =>
+              config.verboseFileRoutes === false
+                ? ''
+                : "import { createFileRoute } from '@tanstack/solid-router';",
+            tsrExportStart: (routePath) =>
+              config.verboseFileRoutes === false
+                ? 'export const Route = createFileRoute('
+                : `export const Route = createFileRoute('${routePath}')(`,
             tsrExportEnd: () => ');',
           },
         },
@@ -143,9 +158,15 @@ export function getTargetTemplate(target: Config['target']): TargetTemplate {
             ].join(''),
           imports: {
             tsrImports: () =>
-              "import { createLazyFileRoute } from '@tanstack/solid-router';",
+              config.verboseFileRoutes === false
+                ? ''
+                : "import { createLazyFileRoute } from '@tanstack/solid-router';",
+
             tsrExportStart: (routePath) =>
-              `export const Route = createLazyFileRoute('${routePath}')(`,
+              config.verboseFileRoutes === false
+                ? 'export const Route = createLazyFileRoute('
+                : `export const Route = createLazyFileRoute('${routePath}')(`,
+
             tsrExportEnd: () => ');',
           },
         },

package/src/transform/default-transform-plugin.ts

@@ -0,0 +1,103 @@
+import { types } from 'recast'
+import { ensureStringArgument } from './utils'
+import type { TransformImportsConfig, TransformPlugin } from './types'
+
+const b = types.builders
+
+export const defaultTransformPlugin: TransformPlugin = {
+  name: 'default-transform',
+  exportName: 'Route',
+  imports: (ctx) => {
+    const imports: TransformImportsConfig = {}
+    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' }],
+          },
+        ]
+      }
+    }
+    return imports
+  },
+  onExportFound: ({ decl, ctx }) => {
+    let appliedChanges = false
+    if (decl.init?.type === 'CallExpression') {
+      const callExpression = decl.init
+      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`)
+      }
+      if (identifier.name === 'createFileRoute' && ctx.lazy) {
+        identifier.name = 'createLazyFileRoute'
+        appliedChanges = true
+      } else if (identifier.name === 'createLazyFileRoute' && !ctx.lazy) {
+        identifier.name = 'createFileRoute'
+        appliedChanges = true
+      }
+    }
+
+    return appliedChanges
+  },
+}