@kubb/fabric-core 0.2.18 → 0.3.0

package/src/parsers/typescriptParser.ts

@@ -6,29 +6,11 @@ import { createParser } from './createParser.ts'
 
 const { factory } = ts
 
-type PrintOptions = {
-  source?: string
-  baseName?: string
-  scriptKind?: ts.ScriptKind
-}
-
-/**
- * Escaped new lines in code with block comments so they can be restored by {@link restoreNewLines}
- */
-const escapeNewLines = (code: string) => code.replace(/\n\n/g, '\n/* :newline: */')
-
-/**
- * Reverses {@link escapeNewLines} and restores new lines
- */
-const restoreNewLines = (code: string) => code.replace(/\/\* :newline: \*\//g, '\n')
-
 /**
  * Convert AST TypeScript/TSX nodes to a string based on the TypeScript printer.
- * Ensures consistent output across environments.
- * Also works as a formatter when `source` is provided without `elements`.
  */
-export function print(elements: Array<ts.Node> = [], { source = '', baseName = 'print.tsx', scriptKind = ts.ScriptKind.TSX }: PrintOptions = {}): string {
-  const sourceFile = ts.createSourceFile(baseName, escapeNewLines(source), ts.ScriptTarget.ES2022, true, scriptKind)
+export function print(...elements: Array<ts.Node>): string {
+  const sourceFile = ts.createSourceFile('print.tsx', '', ts.ScriptTarget.ES2022, true, ts.ScriptKind.TSX)
 
   const printer = ts.createPrinter({
     omitTrailingSemicolon: true,
@@ -37,18 +19,9 @@ export function print(elements: Array<ts.Node> = [], { source = '', baseName = '
     noEmitHelpers: true,
   })
 
-  let output: string
+  const output = printer.printList(ts.ListFormat.MultiLine, factory.createNodeArray(elements), sourceFile)
 
-  if (elements.length > 0) {
-    // Print only provided nodes
-    const nodes = elements.filter(Boolean).sort((a, b) => (a.pos ?? 0) - (b.pos ?? 0))
-    output = printer.printList(ts.ListFormat.MultiLine, factory.createNodeArray(nodes), sourceFile)
-  } else {
-    // Format the whole file
-    output = printer.printFile(sourceFile)
-  }
-
-  return restoreNewLines(output).replace(/\r\n/g, '\n')
+  return output.replace(/\r\n/g, '\n')
 }
 
 export function createImport({
@@ -153,36 +126,46 @@ export const typescriptParser = createParser({
   extNames: ['.ts', '.js'],
   install() {},
   async parse(file, options = { extname: '.ts' }) {
-    const source = file.sources.map((item) => item.value).join('\n\n')
+    const sourceParts: Array<string> = []
+    for (const item of file.sources) {
+      if (item.value) {
+        sourceParts.push(item.value)
+      }
+    }
+    const source = sourceParts.join('\n\n')
 
-    const importNodes = file.imports
-      .map((item) => {
-        const importPath = item.root ? getRelativePath(item.root, item.path) : item.path
-        const hasExtname = !!path.extname(importPath)
+    const importNodes: Array<ts.ImportDeclaration> = []
+    for (const item of file.imports) {
+      const importPath = item.root ? getRelativePath(item.root, item.path) : item.path
+      const hasExtname = !!path.extname(importPath)
 
-        return createImport({
+      importNodes.push(
+        createImport({
           name: item.name,
           path: options.extname && hasExtname ? `${trimExtName(importPath)}${options.extname}` : item.root ? trimExtName(importPath) : importPath,
           isTypeOnly: item.isTypeOnly,
-        })
-      })
-      .filter(Boolean)
-
-    const exportNodes = file.exports
-      .map((item) => {
-        const exportPath = item.path
+        }),
+      )
+    }
 
-        const hasExtname = !!path.extname(exportPath)
+    const exportNodes: Array<ts.ExportDeclaration> = []
+    for (const item of file.exports) {
+      const exportPath = item.path
+      const hasExtname = !!path.extname(exportPath)
 
-        return createExport({
+      exportNodes.push(
+        createExport({
           name: item.name,
           path: options.extname && hasExtname ? `${trimExtName(item.path)}${options.extname}` : trimExtName(item.path),
           isTypeOnly: item.isTypeOnly,
           asAlias: item.asAlias,
-        })
-      })
-      .filter(Boolean)
+        }),
+      )
+    }
 
-    return [file.banner, print([...importNodes, ...exportNodes]), source, file.footer].join('\n')
+    const parts = [file.banner, print(...importNodes, ...exportNodes), source, file.footer].filter(
+      (segment): segment is string => segment != null,
+    )
+    return parts.join('\n')
   },
 })

package/src/plugins/barrelPlugin.ts

@@ -50,6 +50,20 @@ export function getBarrelFiles({ files, root, mode }: GetBarrelFilesOptions): Ar
     return []
   }
 
+  const indexableSourcesMap = new Map<KubbFile.File, Array<KubbFile.Source>>()
+
+  for (const file of files) {
+    const indexableSources: Array<KubbFile.Source> = []
+    for (const source of file.sources || []) {
+      if (source.isIndexable && source.name) {
+        indexableSources.push(source)
+      }
+    }
+    if (indexableSources.length > 0) {
+      indexableSourcesMap.set(file, indexableSources)
+    }
+  }
+
   const cachedFiles = new Map<KubbFile.Path, KubbFile.File>()
   const dedupe = new Map<KubbFile.Path, Set<string>>()
 
@@ -82,41 +96,40 @@ export function getBarrelFiles({ files, root, mode }: GetBarrelFilesOptions): Ar
 
     const seen = dedupe.get(barrelPath)!
 
-    // Collect all leaves under the current directory node
-    node.leaves.forEach((leaf) => {
+    for (const leaf of node.leaves) {
       const file = leaf.data.file
-      if (!file) {
-        return
+      if (!file || !file.path) {
+        continue
       }
 
-      const sources = file.sources || []
-      sources.forEach((source) => {
-        if (!file.path || !source.isIndexable || !source.name) {
-          return
-        }
+      const indexableSources = indexableSourcesMap.get(file)
+      if (!indexableSources) {
+        continue
+      }
 
+      for (const source of indexableSources) {
         const key = `${source.name}|${source.isTypeOnly ? '1' : '0'}`
         if (seen.has(key)) {
-          return
+          continue
         }
         seen.add(key)
 
         // Always compute relative path from the parent directory to the file path
         barrelFile!.exports!.push({
-          name: [source.name],
+          name: [source.name!],
           path: getRelativePath(parentPath, file.path),
           isTypeOnly: source.isTypeOnly,
         })
 
         barrelFile!.sources.push({
-          name: source.name,
+          name: source.name!,
           isTypeOnly: source.isTypeOnly,
           value: '', // TODO use parser to generate import
           isExportable: mode === 'all' || mode === 'named',
           isIndexable: mode === 'all' || mode === 'named',
         })
-      })
-    })
+      }
+    }
   })
 
   const result = [...cachedFiles.values()]
@@ -162,32 +175,46 @@ export const barrelPlugin = createPlugin<Options, ExtendOptions>({
 
         const rootPath = path.resolve(root, 'index.ts')
 
-        const barrelFiles = ctx.files.filter((file) => {
-          return file.sources.some((source) => source.isIndexable)
-        })
+        const barrelFiles: Array<KubbFile.ResolvedFile> = []
+        for (const file of ctx.files) {
+          for (const source of file.sources) {
+            if (source.isIndexable) {
+              barrelFiles.push(file)
+
+              break
+            }
+          }
+        }
+
+        const fileTypeCache = new Map<KubbFile.ResolvedFile, boolean>()
+        for (const file of barrelFiles) {
+          fileTypeCache.set(
+            file,
+            file.sources.every((source) => source.isTypeOnly),
+          )
+        }
+
+        const exports: Array<KubbFile.Export> = []
+        for (const file of barrelFiles) {
+          const containsOnlyTypes = fileTypeCache.get(file) ?? false
+
+          for (const source of file.sources) {
+            if (!file.path || !source.isIndexable) {
+              continue
+            }
+
+            exports.push({
+              name: mode === 'all' ? undefined : [source.name],
+              path: getRelativePath(rootPath, file.path),
+              isTypeOnly: mode === 'all' ? containsOnlyTypes : source.isTypeOnly,
+            } as KubbFile.Export)
+          }
+        }
 
         const entryFile = createFile({
           path: rootPath,
           baseName: 'index.ts',
-          exports: barrelFiles
-            .flatMap((file) => {
-              const containsOnlyTypes = file.sources.every((source) => source.isTypeOnly)
-
-              return file.sources
-                ?.map((source) => {
-                  if (!file.path || !source.isIndexable) {
-                    return undefined
-                  }
-
-                  return {
-                    name: mode === 'all' ? undefined : [source.name],
-                    path: getRelativePath(rootPath, file.path),
-                    isTypeOnly: mode === 'all' ? containsOnlyTypes : source.isTypeOnly,
-                  } as KubbFile.Export
-                })
-                .filter(Boolean)
-            })
-            .filter(Boolean),
+          exports,
           sources: [],
         })
 

package/src/utils/TreeNode.ts

@@ -15,6 +15,7 @@ export class TreeNode<TData = unknown> {
   data: TData
   parent?: TreeNode<TData>
   children: Array<TreeNode<TData>> = []
+  #childrenMap = new Map<string, TreeNode<TData>>()
   #cachedLeaves?: Array<TreeNode<TData>>
 
   constructor(data: TData, parent?: TreeNode<TData>) {
@@ -25,20 +26,35 @@ export class TreeNode<TData = unknown> {
   addChild(data: TData): TreeNode<TData> {
     const child = new TreeNode(data, this)
     this.children.push(child)
+    // Update Map if data has a name property (for BarrelData)
+    if (typeof data === 'object' && data !== null && 'name' in data) {
+      this.#childrenMap.set((data as { name: string }).name, child)
+    }
     this.#cachedLeaves = undefined // invalidate cached leaves
     return child
   }
 
+  getChildByName(name: string): TreeNode<TData> | undefined {
+    return this.#childrenMap.get(name)
+  }
+
   get leaves(): Array<TreeNode<TData>> {
     if (this.#cachedLeaves) return this.#cachedLeaves
     if (this.children.length === 0) return [this]
 
-    const stack: Array<TreeNode<TData>> = [...this.children]
     const result: Array<TreeNode<TData>> = []
+    const stack: Array<TreeNode<TData>> = [...this.children]
+    const visited = new Set<TreeNode<TData>>()
 
-    for (const node of stack) {
-      if (node.children.length) {
-        for (const child of node.children) stack.push(child)
+    while (stack.length > 0) {
+      const node = stack.pop()!
+      if (visited.has(node)) {
+        continue
+      }
+      visited.add(node)
+
+      if (node.children.length > 0) {
+        stack.push(...node.children)
       } else {
         result.push(node)
       }
@@ -51,12 +67,15 @@ export class TreeNode<TData = unknown> {
   forEach(callback: (node: TreeNode<TData>) => void): this {
     const stack: Array<TreeNode<TData>> = [this]
 
-    for (const node of stack) {
+    for (let i = 0; i < stack.length; i++) {
+      const node = stack[i]!
       callback(node)
-      if (node.children.length) {
-        for (const child of node.children) stack.push(child)
+
+      if (node.children.length > 0) {
+        stack.push(...node.children)
       }
     }
+
     return this
   }
 
@@ -71,19 +90,28 @@ export class TreeNode<TData = unknown> {
     const nodes: Array<{ id: string; label: string }> = []
     const edges: Array<{ from: string; to: string }> = []
 
-    root.forEach((node) => {
+    const stack: Array<TreeNode<BarrelData>> = [root]
+
+    for (let i = 0; i < stack.length; i++) {
+      const node = stack[i]!
+
       nodes.push({
         id: node.data.path,
         label: node.data.name,
       })
 
-      for (const child of node.children) {
-        edges.push({
-          from: node.data.path,
-          to: child.data.path,
-        })
+      const children = node.children
+      if (children.length > 0) {
+        for (let j = 0, len = children.length; j < len; j++) {
+          const child = children[j]!
+          edges.push({
+            from: node.data.path,
+            to: child.data.path,
+          })
+          stack.push(child)
+        }
       }
-    })
+    }
 
     return { nodes, edges }
   }
@@ -93,11 +121,15 @@ export class TreeNode<TData = unknown> {
     const normalizedRoot = normalizePath(rootFolder)
     const rootPrefix = normalizedRoot.endsWith('/') ? normalizedRoot : `${normalizedRoot}/`
 
-    const filteredFiles = files.filter((file) => {
-      const filePath = normalizePath(file.path)
-
-      return !filePath.endsWith('.json') && (!rootFolder || filePath.startsWith(rootPrefix))
-    })
+    const normalizedPaths = new Map<KubbFile.File, string>()
+    const filteredFiles: Array<KubbFile.File> = []
+    for (const file of files) {
+      const filePath = normalizedPaths.get(file) ?? normalizePath(file.path)
+      normalizedPaths.set(file, filePath)
+      if (!filePath.endsWith('.json') && (!rootFolder || filePath.startsWith(rootPrefix))) {
+        filteredFiles.push(file)
+      }
+    }
 
     if (filteredFiles.length === 0) {
       return null
@@ -110,7 +142,8 @@ export class TreeNode<TData = unknown> {
     })
 
     for (const file of filteredFiles) {
-      const relPath = normalizePath(file.path).slice(rootPrefix.length)
+      const filePath = normalizedPaths.get(file)!
+      const relPath = filePath.slice(rootPrefix.length)
       const parts = relPath.split('/')
 
       let current = treeNode
@@ -120,13 +153,7 @@ export class TreeNode<TData = unknown> {
         const isLast = index === parts.length - 1
         currentPath += (currentPath.endsWith('/') ? '' : '/') + part
 
-        let next: TreeNode<BarrelData> | undefined
-        for (const child of current.children) {
-          if ((child.data as BarrelData).name === part) {
-            next = child
-            break
-          }
-        }
+        let next = current.getChildByName(part)
 
         if (!next) {
           next = current.addChild({