@tanstack/router-generator 1.121.0-alpha.26 → 1.121.0-alpha.28

package/src/transform/transform.ts

@@ -56,35 +56,69 @@ export async function transform({
     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)
+  }
+
   const program: types.namedTypes.Program = ast.program
   // first pass: find registered exports
   for (const n of program.body) {
-    if (
-      registeredExports.size > 0 &&
-      n.type === 'ExportNamedDeclaration' &&
-      n.declaration?.type === 'VariableDeclaration'
-    ) {
-      const decl = n.declaration.declarations[0]
-      if (
-        decl &&
-        decl.type === 'VariableDeclarator' &&
-        decl.id.type === 'Identifier'
-      ) {
-        const plugin = registeredExports.get(decl.id.name)
-        if (plugin) {
-          const pluginAppliedChanges = plugin.onExportFound({
-            decl,
-            ctx: { ...ctx, preferredQuote },
-          })
-
-          if (pluginAppliedChanges) {
-            appliedChanges = true
+    if (registeredExports.size > 0 && 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]
+        if (
+          decl &&
+          decl.type === 'VariableDeclarator' &&
+          decl.id.type === 'Identifier'
+        ) {
+          const plugin = registeredExports.get(decl.id.name)
+          if (plugin) {
+            onExportFound(decl, decl.id.name, plugin)
+          }
+        }
+      }
+      // this is an export without a declaration, e.g. `export { Route }`
+      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) {
+              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) {
+                if (
+                  decl.type === 'VariableDeclaration' &&
+                  decl.declarations[0]
+                ) {
+                  const variable = decl.declarations[0]
+                  if (
+                    variable.type === 'VariableDeclarator' &&
+                    variable.id.type === 'Identifier' &&
+                    variable.id.name === variableName
+                  ) {
+                    onExportFound(variable, spec.exported.name, plugin)
+                    break
+                  }
+                }
+              }
+            }
           }
-
-          // export is handled, remove it from the registered exports
-          registeredExports.delete(decl.id.name)
-          // store the export so we can later return it once the file is transformed
-          foundExports.push(decl.id.name)
         }
       }
     }
@@ -290,7 +324,7 @@ async function fixTransformedOutputText({
   originalCode: string
   transformedCode: string
   sourceMap: RawSourceMap
-  preferredQuote: '"' | "'" | '`'
+  preferredQuote: '"' | "'"
 }) {
   const originalLines = originalCode.split('\n')
   const transformedLines = transformedCode.split('\n')
@@ -302,11 +336,10 @@ async function fixTransformedOutputText({
   const fixedLines = transformedLines.map((line, i) => {
     const transformedLineNum = i + 1
 
-    let mapped = null
-    let origLineText = null
+    let origLineText: string | undefined = undefined
 
     for (let col = 0; col < line.length; col++) {
-      mapped = consumer.originalPositionFor({
+      const mapped = consumer.originalPositionFor({
         line: transformedLineNum,
         column: col,
       })
@@ -316,7 +349,7 @@ async function fixTransformedOutputText({
       }
     }
 
-    if (origLineText != null) {
+    if (origLineText !== undefined) {
       if (origLineText === line) {
         return origLineText
       }
@@ -409,10 +442,9 @@ function detectSemicolonUsage(code: string) {
   return withSemis > total / 2
 }
 
-export function detectPreferredQuoteStyle(ast: types.ASTNode): "'" | '"' | '`' {
+export function detectPreferredQuoteStyle(ast: types.ASTNode): "'" | '"' {
   let single = 0
   let double = 0
-  let backtick = 0
 
   visit(ast, {
     visitStringLiteral(path) {
@@ -423,17 +455,10 @@ export function detectPreferredQuoteStyle(ast: types.ASTNode): "'" | '"' | '`' {
       }
       return false
     },
-    visitTemplateLiteral(path) {
-      if (path.parent.type !== 'JSXAttribute') {
-        backtick++
-      }
-      return false
-    },
   })
 
-  return single >= double && single >= backtick
-    ? "'"
-    : double >= single && double >= backtick
-      ? '"'
-      : '`'
+  if (single >= double) {
+    return "'"
+  }
+  return '"'
 }

package/src/transform/types.ts

@@ -46,5 +46,5 @@ export interface TransformContext {
   routeId: string
   lazy: boolean
   verboseFileRoutes: boolean
-  preferredQuote?: '"' | "'" | '`'
+  preferredQuote?: '"' | "'"
 }

package/src/transform/utils.ts

@@ -5,7 +5,7 @@ const b = types.builders
 export function ensureStringArgument(
   callExpression: types.namedTypes.CallExpression,
   value: string,
-  preferredQuote?: "'" | '"' | '`',
+  preferredQuote?: "'" | '"',
 ) {
   const argument = callExpression.arguments[0]
   if (!argument) {

package/src/types.ts

@@ -18,6 +18,7 @@ export type RouteNode = {
 export interface GetRouteNodesResult {
   rootRouteNode?: RouteNode
   routeNodes: Array<RouteNode>
+  physicalDirectories: Array<string>
 }
 
 export type FsRouteType =
@@ -54,3 +55,9 @@ export type HandleNodeAccumulator = {
   routePiecesByPath: Record<string, RouteSubNode>
   routeNodes: Array<RouteNode>
 }
+
+export type GetRoutesByFileMapResultValue = { routePath: string }
+export type GetRoutesByFileMapResult = Map<
+  string,
+  GetRoutesByFileMapResultValue
+>

package/src/utils.ts

@@ -466,47 +466,61 @@ export function buildRouteTreeConfig(
   disableTypes: boolean,
   depth = 1,
 ): Array<string> {
-  const children = nodes.map((node) => {
-    if (node._fsRouteType === '__root') {
-      return
-    }
+  const children = nodes
+    .filter((n) => n.exports?.includes(exportName))
+    .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,
+          exportName,
+          disableTypes,
+          depth + 1,
+        )
 
-      const childrenDeclaration = disableTypes
-        ? ''
-        : `interface ${route}${exportName}Children {
-  ${node.children.map((child) => `${child.variableName}${exportName}: typeof ${getResolvedRouteNodeVariableName(child, exportName)}`).join(',')}
+        const childrenDeclaration = disableTypes
+          ? ''
+          : `interface ${route}${exportName}Children {
+  ${node.children
+    .filter((n) => n.exports?.includes(exportName))
+    .map(
+      (child) =>
+        `${child.variableName}${exportName}: typeof ${getResolvedRouteNodeVariableName(child, exportName)}`,
+    )
+    .join(',')}
 }`
 
-      const children = `const ${route}${exportName}Children${disableTypes ? '' : `: ${route}${exportName}Children`} = {
-  ${node.children.map((child) => `${child.variableName}${exportName}: ${getResolvedRouteNodeVariableName(child, exportName)}`).join(',')}
+        const children = `const ${route}${exportName}Children${disableTypes ? '' : `: ${route}${exportName}Children`} = {
+  ${node.children
+    .filter((n) => n.exports?.includes(exportName))
+    .map(
+      (child) =>
+        `${child.variableName}${exportName}: ${getResolvedRouteNodeVariableName(child, exportName)}`,
+    )
+    .join(',')}
 }`
 
-      const routeWithChildren = `const ${route}${exportName}WithChildren = ${route}${exportName}._addFileChildren(${route}${exportName}Children)`
+        const routeWithChildren = `const ${route}${exportName}WithChildren = ${route}${exportName}._addFileChildren(${route}${exportName}Children)`
 
-      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)
 }
@@ -583,3 +597,37 @@ export const findParent = (
   }
   return findParent(node.parent, exportName)
 }
+
+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 parent = findParent(routeNode, opts.exportName)
+
+        return `'${filePathId}': {
+          id: '${filePathId}'
+          path: '${inferPath(routeNode)}'
+          fullPath: '${inferFullPath(routeNode)}'
+          preLoaderRoute: ${preloaderRoute}
+          parentRoute: typeof ${parent}
+        }`
+      })
+      .join('\n')}
+  }
+}`
+}