refactor: revert renaming pad util, add and use TreeNode.isNamed() method, minor optimizations

Author: Anoesj

src/codegen/generateDTS.ts

@@ -1,4 +1,4 @@
-import { ts, indent } from '../utils'
+import { ts, pad } from '../utils'
 
 /**
  * Removes empty lines and indent by two spaces to match the rest of the file.
@@ -10,7 +10,7 @@ function normalizeLines(code: string) {
       // FIXME: the code should be cleaned up by the codegen functions. Removing empty lines here
       // reduces readability of the route file info map.
       .filter((line) => line.length !== 0)
-      .map((line) => indent(2, line))
+      .map((line) => pad(2, line))
       .join('\n')
   )
 }

src/codegen/generateRouteFileInfoMap.ts

@@ -79,8 +79,12 @@ function generateRouteFileInfoLines(
 
   const routeNames = [node, ...node.getChildrenDeepSorted()]
     // an unnamed route cannot be accessed in types
-    .filter((node): node is TreeNode & { name: string } => !!node.name)
-    .map((node) => node.name)
+    .reduce<string[]>((acc, node) => {
+      if (node.isNamed()) {
+        acc.push(node.name)
+      }
+      return acc
+    }, [])
 
   // Most of the time we only have one view, but with named views we can have multiple.
   const currentRouteInfo =

src/codegen/generateRouteMap.ts

@@ -1,6 +1,6 @@
-import type { TreeNode } from '../core/tree'
+import type { TreeNode, TreeNodeNamed } from '../core/tree'
 import { generateRouteParams } from './generateRouteParams'
-import { indent, formatMultilineUnion, stringToStringType } from '../utils'
+import { pad, formatMultilineUnion, stringToStringType } from '../utils'
 
 export function generateRouteNamedMap(node: TreeNode): string {
   if (node.isRoot()) {
@@ -11,19 +11,22 @@ ${node.getChildrenSorted().map(generateRouteNamedMap).join('')}}`
   return (
     // if the node has a filePath, it's a component, it has a routeName and it should be referenced in the RouteNamedMap
     // otherwise it should be skipped to avoid navigating to a route that doesn't render anything
-    (node.value.components.size > 0 && node.name
-      ? indent(2, `'${node.name}': ${generateRouteRecordInfo(node)},\n`)
+    (node.value.components.size && node.isNamed()
+      ? pad(
+          2,
+          `${stringToStringType(node.name)}: ${generateRouteRecordInfo(node)},\n`
+        )
       : '') +
     (node.children.size > 0
       ? node.getChildrenSorted().map(generateRouteNamedMap).join('\n')
       : '')
   )
 }
 
-export function generateRouteRecordInfo(node: TreeNode) {
+export function generateRouteRecordInfo(node: TreeNodeNamed): string {
   const typeParams = [
-    `'${node.name}'`,
-    `'${node.fullPath}'`,
+    stringToStringType(node.name),
+    stringToStringType(node.fullPath),
     generateRouteParams(node, true),
     generateRouteParams(node, false),
   ]
@@ -33,11 +36,12 @@ export function generateRouteRecordInfo(node: TreeNode) {
       ? // TODO: remove Array.from() once Node 20 support is dropped
         Array.from(node.getChildrenDeep())
           // skip routes that are not added to the types
-          .filter(
-            (childRoute): childRoute is TreeNode & { name: string } =>
-              childRoute.value.components.size > 0 && !!childRoute.name
-          )
-          .map((childRoute) => childRoute.name)
+          .reduce<string[]>((acc, childRoute) => {
+            if (childRoute.value.components.size && childRoute.isNamed()) {
+              acc.push(childRoute.name)
+            }
+            return acc
+          }, [])
           .sort()
       : []
 
@@ -46,6 +50,6 @@ export function generateRouteRecordInfo(node: TreeNode) {
   )
 
   return `RouteRecordInfo<
-${typeParams.map((line) => indent(4, line)).join(',\n')}
+${typeParams.map((line) => pad(4, line)).join(',\n')}
   >`
 }

src/codegen/generateRouteRecords.ts

@@ -2,6 +2,7 @@ import { getLang } from '@vue-macros/common'
 import type { TreeNode } from '../core/tree'
 import { ImportsMap } from '../core/utils'
 import { type ResolvedOptions } from '../options'
+import { pad, stringToStringType } from '../utils'
 
 /**
  * Generate the route records for the given node.
@@ -48,8 +49,8 @@ ${node
     }
   }
 
-  const startIndent = ' '.repeat(indent * 2)
-  const indentStr = ' '.repeat((indent + 1) * 2)
+  const startIndent = pad(indent * 2)
+  const indentStr = pad((indent + 1) * 2)
 
   // TODO: should meta be defined a different way to allow preserving imports?
   // const meta = node.value.overrides.meta
@@ -62,10 +63,11 @@ ${node
 ${indentStr}path: '${node.path}',
 ${indentStr}${
     node.value.components.size
-      ? node.name
-        ? `name: '${node.name}',`
+      ? node.isNamed()
+        ? `name: ${stringToStringType(node.name)},`
         : `/* no name */`
-      : `/* internal name: '${node.name}' */`
+      : // node.name can still be false and we don't want that to result in string literal 'false'
+        `/* internal name: ${typeof node.name === 'string' ? stringToStringType(node.name) : node.name} */`
   }
 ${
   // component

src/core/tree.spec.ts

@@ -394,12 +394,14 @@ describe('Tree', () => {
       name: 'custom',
     })
     expect(node.name).toBe('custom')
+    expect(node.isNamed()).toBe(true)
 
     node = tree.insert('auth/login', 'auth/login.vue')
     node.value.setOverride('', {
       name: 'custom-child',
     })
     expect(node.name).toBe('custom-child')
+    expect(node.isNamed()).toBe(true)
   })
 
   it('allows empty name to remove route from route map', () => {
@@ -408,21 +410,38 @@ describe('Tree', () => {
 
     // Before setting empty name, it should use the default name
     expect(node.name).toBe('/some-route')
+    expect(node.isNamed()).toBe(true)
 
     // Set empty name
     node.value.setOverride('', {
       name: '',
     })
     expect(node.name).toBe('')
+    expect(node.isNamed()).toBe(false)
+
+    // Set false name
+    node.value.setOverride('', {
+      name: false,
+    })
+    expect(node.name).toBe(false)
+    expect(node.isNamed()).toBe(false)
 
     // Test with nested route
     node = tree.insert('nested/child', 'nested/child.vue')
     expect(node.name).toBe('/nested/child')
+    expect(node.isNamed()).toBe(true)
 
     node.value.setOverride('', {
       name: '',
     })
     expect(node.name).toBe('')
+    expect(node.isNamed()).toBe(false)
+
+    node.value.setOverride('', {
+      name: false,
+    })
+    expect(node.name).toBe(false)
+    expect(node.isNamed()).toBe(false)
   })
 
   it('allows a custom path', () => {

src/core/tree.ts

@@ -12,6 +12,10 @@ export interface TreeNodeOptions extends ResolvedOptions {
   treeNodeOptions?: TreeNodeValueOptions
 }
 
+export type TreeNodeNamed = TreeNode & {
+  name: Extract<TreeNode['name'], string>
+}
+
 export class TreeNode {
   /**
    * value of the node
@@ -290,6 +294,10 @@ export class TreeNode {
     )
   }
 
+  isNamed(): this is TreeNodeNamed {
+    return !!this.name
+  }
+
   toString(): string {
     return `${this.value}${
       // either we have multiple names

src/utils/index.ts

@@ -21,7 +21,7 @@ export const ts = String.raw
  * @param str The string to pad, none if omitted.
  * @returns The padded string.
  */
-export function indent(spaces: number, str = ''): string {
+export function pad(spaces: number, str = ''): string {
   return `${' '.repeat(spaces)}${str}`
 }
 
@@ -34,7 +34,7 @@ export function indent(spaces: number, str = ''): string {
 export function formatMultilineUnion(items: string[], spaces: number): string {
   return (items.length ? items : ['never'])
     .map((s) => `| ${s}`)
-    .join(`\n${indent(spaces)}`)
+    .join(`\n${pad(spaces)}`)
 }
 
 /**