@tanstack/router-generator 1.102.5 → 1.104.0

package/src/generator.ts

@@ -1,9 +1,9 @@
 import path from 'node:path'
 import * as fs from 'node:fs'
 import * as fsp from 'node:fs/promises'
-import * as prettier from 'prettier'
 import {
   determineInitialRoutePath,
+  format,
   logging,
   multiSortBy,
   removeExt,
@@ -76,12 +76,6 @@ export async function generator(config: Config, root: string) {
 
   const TYPES_DISABLED = config.disableTypes
 
-  const prettierOptions: prettier.Options = {
-    semi: config.semicolons,
-    singleQuote: config.quoteStyle === 'single',
-    parser: 'typescript',
-  }
-
   let getRouteNodesResult: GetRouteNodesResult
 
   if (config.virtualRouteConfig) {
@@ -138,17 +132,22 @@ export async function generator(config: Config, root: string) {
 
     if (!routeCode) {
       const _rootTemplate = ROUTE_TEMPLATE.rootRoute
-      const replaced = fillTemplate(_rootTemplate.template(), {
+      const replaced = await fillTemplate(config, _rootTemplate.template(), {
         tsrImports: _rootTemplate.imports.tsrImports(),
         tsrPath: rootPathId,
         tsrExportStart: _rootTemplate.imports.tsrExportStart(),
         tsrExportEnd: _rootTemplate.imports.tsrExportEnd(),
       })
 
-      logger.log(`🟡 Creating ${node.fullPath}`)
-      fs.writeFileSync(
+      await writeIfDifferent(
         node.fullPath,
-        await prettier.format(replaced, prettierOptions),
+        '', // Empty string because the file doesn't exist yet
+        replaced,
+        {
+          beforeWrite: () => {
+            logger.log(`🟡 Creating ${node.fullPath}`)
+          },
+        },
       )
     }
   }
@@ -208,7 +207,8 @@ export async function generator(config: Config, root: string) {
         if (node.isLazy) {
           // 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 = fillTemplate(
+          replaced = await fillTemplate(
+            config,
             (config.customScaffolding?.lazyRouteTemplate ||
               config.customScaffolding?.routeTemplate) ??
               tLazyRouteTemplate.template(),
@@ -227,7 +227,8 @@ export async function generator(config: Config, root: string) {
             !node.isPendingComponent &&
             !node.isLoader)
         ) {
-          replaced = fillTemplate(
+          replaced = await fillTemplate(
+            config,
             config.customScaffolding?.routeTemplate ??
               tRouteTemplate.template(),
             {
@@ -260,17 +261,11 @@ export async function generator(config: Config, root: string) {
           )
       }
 
-      await writeIfDifferent(
-        node.fullPath,
-        prettierOptions,
-        routeCode,
-        replaced,
-        {
-          beforeWrite: () => {
-            logger.log(`🟡 Updating ${node.fullPath}`)
-          },
+      await writeIfDifferent(node.fullPath, routeCode, replaced, {
+        beforeWrite: () => {
+          logger.log(`🟡 Updating ${node.fullPath}`)
         },
-      )
+      })
     }
 
     if (
@@ -390,7 +385,8 @@ export async function generator(config: Config, root: string) {
     const escapedRoutePath = node.routePath?.replaceAll('$', '$$') ?? ''
 
     if (!routeCode) {
-      const replaced = fillTemplate(
+      const replaced = await fillTemplate(
+        config,
         config.customScaffolding?.apiTemplate ?? defaultAPIRouteTemplate,
         {
           tsrImports:
@@ -401,15 +397,19 @@ export async function generator(config: Config, root: string) {
         },
       )
 
-      logger.log(`🟡 Creating ${node.fullPath}`)
-      fs.writeFileSync(
+      await writeIfDifferent(
         node.fullPath,
-        await prettier.format(replaced, prettierOptions),
+        '', // Empty string because the file doesn't exist yet
+        replaced,
+        {
+          beforeWrite: () => {
+            logger.log(`🟡 Creating ${node.fullPath}`)
+          },
+        },
       )
     } else {
       await writeIfDifferent(
         node.fullPath,
-        prettierOptions,
         routeCode,
         routeCode.replace(
           /(createAPIFileRoute\(\s*['"])([^\s]*)(['"],?\s*\))/g,
@@ -748,9 +748,8 @@ export async function generator(config: Config, root: string) {
   // Write the route tree file, if it has changed
   const routeTreeWriteResult = await writeIfDifferent(
     path.resolve(config.generatedRouteTree),
-    prettierOptions,
-    existingRouteTreeContent,
-    routeConfigFileContent,
+    await format(existingRouteTreeContent, config),
+    await format(routeConfigFileContent, config),
     {
       beforeWrite: () => {
         logger.log(`🟡 Updating ${config.generatedRouteTree}`)

package/src/template.ts

@@ -1,15 +1,18 @@
+import { format } from './utils'
 import type { Config } from './config'
 
 type TemplateTag = 'tsrImports' | 'tsrPath' | 'tsrExportStart' | 'tsrExportEnd'
 
 export function fillTemplate(
+  config: Config,
   template: string,
   values: Record<TemplateTag, string>,
 ) {
-  return template.replace(
+  const replaced = template.replace(
     /%%(\w+)%%/g,
     (_, key) => values[key as TemplateTag] || '',
   )
+  return format(replaced, config)
 }
 
 type TargetTemplate = {

package/src/utils.ts

@@ -1,5 +1,6 @@
 import * as fs from 'node:fs'
 import * as prettier from 'prettier'
+import type { Config } from './config'
 
 export function multiSortBy<T>(
   arr: Array<T>,
@@ -123,7 +124,6 @@ export function removeExt(d: string, keepExtension: boolean = false) {
  * This function writes to a file if the content is different.
  *
  * @param filepath The path to the file
- * @param prettierOptions Prettier options
  * @param content Original content
  * @param incomingContent New content
  * @param callbacks Callbacks to run before and after writing
@@ -131,26 +131,35 @@ export function removeExt(d: string, keepExtension: boolean = false) {
  */
 export async function writeIfDifferent(
   filepath: string,
-  prettierOptions: prettier.Options,
   content: string,
   incomingContent: string,
   callbacks?: { beforeWrite?: () => void; afterWrite?: () => void },
 ): Promise<boolean> {
-  const [formattedContent, updatedContent] = await Promise.all([
-    prettier.format(content, prettierOptions),
-    prettier.format(incomingContent, prettierOptions),
-  ])
-
-  if (formattedContent !== updatedContent) {
+  if (content !== incomingContent) {
     callbacks?.beforeWrite?.()
-    fs.writeFileSync(filepath, updatedContent)
+    fs.writeFileSync(filepath, incomingContent)
     callbacks?.afterWrite?.()
     return true
   }
-
   return false
 }
 
+/**
+ * This function formats the source code using the default formatter (Prettier).
+ *
+ * @param source The content to format
+ * @param config The configuration object
+ * @returns The formatted content
+ */
+export async function format(source: string, config: Config): Promise<string> {
+  const prettierOptions: prettier.Config = {
+    semi: config.semicolons,
+    singleQuote: config.quoteStyle === 'single',
+    parser: 'typescript',
+  }
+  return prettier.format(source, prettierOptions)
+}
+
 /**
  * This function resets the regex index to 0 so that it can be reused
  * without having to create a new regex object or worry about the last