@kubb/fabric-core 0.2.19 → 0.3.1

package/src/createFile.ts

@@ -1,7 +1,7 @@
 import { createHash } from 'node:crypto'
 import path from 'node:path'
 import { orderBy } from 'natural-orderby'
-import { isDeepEqual, uniqueBy } from 'remeda'
+import { uniqueBy } from 'remeda'
 import type * as KubbFile from './KubbFile.ts'
 import { trimExtName } from './utils/trimExtName.ts'
 
@@ -10,53 +10,78 @@ export function combineSources(sources: Array<KubbFile.Source>): Array<KubbFile.
 }
 
 export function combineExports(exports: Array<KubbFile.Export>): Array<KubbFile.Export> {
-  return orderBy(exports, [
+  const sorted = orderBy(exports, [
     (v) => !!Array.isArray(v.name),
     (v) => !v.isTypeOnly,
     (v) => v.path,
     (v) => !!v.name,
     (v) => (Array.isArray(v.name) ? orderBy(v.name) : v.name),
-  ]).reduce(
-    (prev, curr) => {
-      const name = curr.name
-      const prevByPath = prev.findLast((imp) => imp.path === curr.path)
-      const prevByPathAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && isDeepEqual(imp.name, name) && imp.isTypeOnly)
-
-      if (prevByPathAndIsTypeOnly) {
-        // we already have an export that has the same path but uses `isTypeOnly` (export type ...)
-        return prev
-      }
+  ])
+
+  const prev: Array<KubbFile.Export> = []
+  // Map to track items by path for O(1) lookup
+  const pathMap = new Map<string, KubbFile.Export>()
+  // Map to track unique items by path+name+isTypeOnly+asAlias
+  const uniqueMap = new Map<string, KubbFile.Export>()
+  // Map to track items by path+name where isTypeOnly=true (for type-only check)
+  const pathNameTypeTrueMap = new Map<string, KubbFile.Export>()
+
+  for (const curr of sorted) {
+    const name = curr.name
+    const pathKey = curr.path
+    const prevByPath = pathMap.get(pathKey)
+
+    // Create unique key for path+name+isTypeOnly
+    const nameKey = Array.isArray(name) ? JSON.stringify(name) : name || ''
+    const pathNameTypeKey = `${pathKey}:${nameKey}:${curr.isTypeOnly}`
+    // Check if there's already an item with the same path+name but with isTypeOnly=true
+    const pathNameKey = `${pathKey}:${nameKey}`
+    const prevByPathAndIsTypeOnly = pathNameTypeTrueMap.get(pathNameKey)
+
+    if (prevByPathAndIsTypeOnly) {
+      // we already have an export that has the same path and name but uses `isTypeOnly` (export type ...)
+      continue
+    }
 
-      const uniquePrev = prev.findLast(
-        (imp) => imp.path === curr.path && isDeepEqual(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly && imp.asAlias === curr.asAlias,
-      )
+    // Create unique key for path+name+isTypeOnly+asAlias
+    const uniqueKey = `${pathNameTypeKey}:${curr.asAlias || ''}`
+    const uniquePrev = uniqueMap.get(uniqueKey)
 
-      // we already have an item that was unique enough or name field is empty or prev asAlias is set but current has no changes
-      if (uniquePrev || (Array.isArray(name) && !name.length) || (prevByPath?.asAlias && !curr.asAlias)) {
-        return prev
-      }
+    // we already have an item that was unique enough or name field is empty or prev asAlias is set but current has no changes
+    if (uniquePrev || (Array.isArray(name) && !name.length) || (prevByPath?.asAlias && !curr.asAlias)) {
+      continue
+    }
 
-      if (!prevByPath) {
-        return [
-          ...prev,
-          {
-            ...curr,
-            name: Array.isArray(name) ? [...new Set(name)] : name,
-          },
-        ]
+    if (!prevByPath) {
+      const newItem = {
+        ...curr,
+        name: Array.isArray(name) ? [...new Set(name)] : name,
+      }
+      prev.push(newItem)
+      pathMap.set(pathKey, newItem)
+      uniqueMap.set(uniqueKey, newItem)
+      // Track items with isTypeOnly=true for the type-only check
+      if (newItem.isTypeOnly) {
+        pathNameTypeTrueMap.set(pathNameKey, newItem)
       }
+      continue
+    }
 
-      // merge all names when prev and current both have the same isTypeOnly set
-      if (prevByPath && Array.isArray(prevByPath.name) && Array.isArray(curr.name) && prevByPath.isTypeOnly === curr.isTypeOnly) {
-        prevByPath.name = [...new Set([...prevByPath.name, ...curr.name])]
+    // merge all names when prev and current both have the same isTypeOnly set
+    if (prevByPath && Array.isArray(prevByPath.name) && Array.isArray(curr.name) && prevByPath.isTypeOnly === curr.isTypeOnly) {
+      prevByPath.name = [...new Set([...prevByPath.name, ...curr.name])]
+      continue
+    }
 
-        return prev
-      }
+    prev.push(curr)
+    uniqueMap.set(uniqueKey, curr)
+    // Track items with isTypeOnly=true for the type-only check
+    if (curr.isTypeOnly) {
+      pathNameTypeTrueMap.set(pathNameKey, curr)
+    }
+  }
 
-      return [...prev, curr]
-    },
-    [] as Array<KubbFile.Export>,
-  )
+  return prev
 }
 
 export function combineImports(imports: Array<KubbFile.Import>, exports: Array<KubbFile.Export>, source?: string): Array<KubbFile.Import> {
@@ -96,18 +121,28 @@ export function combineImports(imports: Array<KubbFile.Import>, exports: Array<K
     return isUsed
   }
 
-  return orderBy(imports, [
+  const sorted = orderBy(imports, [
     (v) => !!Array.isArray(v.name),
     (v) => !v.isTypeOnly,
     (v) => v.path,
     (v) => !!v.name,
     (v) => (Array.isArray(v.name) ? orderBy(v.name) : v.name),
-  ]).reduce<Array<KubbFile.Import>>((prev, curr) => {
+  ])
+
+  const prev: Array<KubbFile.Import> = []
+  // Map to track items by path+isTypeOnly for O(1) lookup
+  const pathTypeMap = new Map<string, KubbFile.Import>()
+  // Map to track unique items by path+name+isTypeOnly
+  const uniqueMap = new Map<string, KubbFile.Import>()
+  // Map to track items by path+name where isTypeOnly=true (for type-only check)
+  const pathNameTypeTrueMap = new Map<string, KubbFile.Import>()
+
+  for (const curr of sorted) {
     let name = Array.isArray(curr.name) ? [...new Set(curr.name)] : curr.name
 
     if (curr.path === curr.root) {
       // root and path are the same file, remove the "./" import
-      return prev
+      continue
     }
 
     // merge all names and check if the importName is being used in the generated source and if not filter those imports out
@@ -115,45 +150,63 @@ export function combineImports(imports: Array<KubbFile.Import>, exports: Array<K
       name = name.filter((item) => (typeof item === 'string' ? hasImportInSource(item) : hasImportInSource(item.propertyName)))
     }
 
-    const prevByPath = prev.findLast((imp) => imp.path === curr.path && imp.isTypeOnly === curr.isTypeOnly)
-    const uniquePrev = prev.findLast((imp) => imp.path === curr.path && isDeepEqual(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly)
-    const prevByPathNameAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && isDeepEqual(imp.name, name) && imp.isTypeOnly)
+    const pathTypeKey = `${curr.path}:${curr.isTypeOnly}`
+    const prevByPath = pathTypeMap.get(pathTypeKey)
+
+    // Create key for name comparison
+    const nameKey = Array.isArray(name) ? JSON.stringify(name) : name || ''
+    const pathNameTypeKey = `${curr.path}:${nameKey}:${curr.isTypeOnly}`
+    const uniquePrev = uniqueMap.get(pathNameTypeKey)
+    // Check if there's already an item with the same path+name but with isTypeOnly=true
+    const pathNameKey = `${curr.path}:${nameKey}`
+    const prevByPathNameAndIsTypeOnly = pathNameTypeTrueMap.get(pathNameKey)
 
     if (prevByPathNameAndIsTypeOnly) {
-      // we already have an export that has the same path but uses `isTypeOnly` (import type ...)
-      return prev
+      // we already have an import that has the same path and name but uses `isTypeOnly` (import type ...)
+      continue
     }
 
     // already unique enough or name is empty
     if (uniquePrev || (Array.isArray(name) && !name.length)) {
-      return prev
+      continue
     }
 
     // new item, append name
     if (!prevByPath) {
-      return [
-        ...prev,
-        {
-          ...curr,
-          name,
-        },
-      ]
+      const newItem = {
+        ...curr,
+        name,
+      }
+      prev.push(newItem)
+      pathTypeMap.set(pathTypeKey, newItem)
+      uniqueMap.set(pathNameTypeKey, newItem)
+      // Track items with isTypeOnly=true for the type-only check
+      if (newItem.isTypeOnly) {
+        pathNameTypeTrueMap.set(pathNameKey, newItem)
+      }
+      continue
     }
 
     // merge all names when prev and current both have the same isTypeOnly set
     if (prevByPath && Array.isArray(prevByPath.name) && Array.isArray(name) && prevByPath.isTypeOnly === curr.isTypeOnly) {
       prevByPath.name = [...new Set([...prevByPath.name, ...name])]
-
-      return prev
+      continue
     }
 
     // no import was found in the source, ignore import
     if (!Array.isArray(name) && name && !hasImportInSource(name)) {
-      return prev
+      continue
     }
 
-    return [...prev, curr]
-  }, [])
+    prev.push(curr)
+    uniqueMap.set(pathNameTypeKey, curr)
+    // Track items with isTypeOnly=true for the type-only check
+    if (curr.isTypeOnly) {
+      pathNameTypeTrueMap.set(pathNameKey, curr)
+    }
+  }
+
+  return prev
 }
 
 /**

package/src/defineFabric.ts

@@ -1,6 +1,7 @@
 import { isFunction } from 'remeda'
 import type { Fabric, FabricConfig, FabricContext, FabricEvents, FabricOptions } from './Fabric.ts'
 import { FileManager } from './FileManager.ts'
+import type * as KubbFile from './KubbFile.ts'
 import type { Parser } from './parsers/types.ts'
 import type { Plugin } from './plugins/types.ts'
 import { AsyncEventEmitter } from './utils/AsyncEventEmitter.ts'
@@ -30,7 +31,8 @@ export function defineFabric<T extends FabricOptions>(init?: FabricInitializer<T
   function create(config: FabricConfig<T> = { mode: 'sequential' } as FabricConfig<T>): Fabric<T> {
     const events = new AsyncEventEmitter<FabricEvents>()
     const installedPlugins = new Set<Plugin<any>>()
-    const installedParsers = new Set<Parser<any>>()
+    const installedParsers = new Map<KubbFile.Extname, Parser<any>>()
+    const installedParserNames = new Set<string>()
     const fileManager = new FileManager({ events })
 
     const context: FabricContext<T> = {
@@ -76,10 +78,20 @@ export function defineFabric<T extends FabricOptions>(init?: FabricInitializer<T
         }
 
         if (pluginOrParser.type === 'parser') {
-          if (installedParsers.has(pluginOrParser)) {
+          if (installedParserNames.has(pluginOrParser.name)) {
             console.warn(`Parser "${pluginOrParser.name}" already applied.`)
           } else {
-            installedParsers.add(pluginOrParser)
+            installedParserNames.add(pluginOrParser.name)
+          }
+
+          if (pluginOrParser.extNames) {
+            for (const extName of pluginOrParser.extNames) {
+              const existing = installedParsers.get(extName)
+              if (existing && existing.name !== pluginOrParser.name) {
+                console.warn(`Parser "${pluginOrParser.name}" is overriding parser "${existing.name}" for extension "${extName}".`)
+              }
+              installedParsers.set(extName, pluginOrParser)
+            }
           }
         }
 

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,15 @@ export function print(elements: Array<ts.Node> = [], { source = '', baseName = '
     noEmitHelpers: true,
   })
 
-  let output: string
-
-  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)
+  for (const node of elements) {
+    if (node.kind === ts.SyntaxKind.Unknown) {
+      console.error('⚠️ Unknown node found:', node)
+    }
   }
 
-  return restoreNewLines(output).replace(/\r\n/g, '\n')
+  const output = printer.printList(ts.ListFormat.MultiLine, factory.createNodeArray(elements.filter(Boolean)), sourceFile)
+
+  return output.replace(/\r\n/g, '\n')
 }
 
 export function createImport({
@@ -66,43 +45,38 @@ export function createImport({
 }) {
   const resolvePath = root ? getRelativePath(root, path) : path
 
+  // Namespace or default import
   if (!Array.isArray(name)) {
-    let importPropertyName: ts.Identifier | undefined = factory.createIdentifier(name)
-    let importName: ts.NamedImportBindings | undefined
-
     if (isNameSpace) {
-      importPropertyName = undefined
-      importName = factory.createNamespaceImport(factory.createIdentifier(name))
+      return factory.createImportDeclaration(
+        undefined,
+        factory.createImportClause(isTypeOnly, undefined, factory.createNamespaceImport(factory.createIdentifier(name))),
+        factory.createStringLiteral(resolvePath),
+        undefined,
+      )
     }
 
     return factory.createImportDeclaration(
       undefined,
-      factory.createImportClause(isTypeOnly, importPropertyName, importName),
+      factory.createImportClause(isTypeOnly, factory.createIdentifier(name), undefined),
       factory.createStringLiteral(resolvePath),
       undefined,
     )
   }
 
+  // Named imports
+  const specifiers = name.map((item) => {
+    if (typeof item === 'object') {
+      const { propertyName, name: alias } = item
+      return factory.createImportSpecifier(false, alias ? factory.createIdentifier(propertyName) : undefined, factory.createIdentifier(alias ?? propertyName))
+    }
+
+    return factory.createImportSpecifier(false, undefined, factory.createIdentifier(item))
+  })
+
   return factory.createImportDeclaration(
     undefined,
-    factory.createImportClause(
-      isTypeOnly,
-      undefined,
-      factory.createNamedImports(
-        name.map((item) => {
-          if (typeof item === 'object') {
-            const obj = item as { propertyName: string; name?: string }
-            if (obj.name) {
-              return factory.createImportSpecifier(false, factory.createIdentifier(obj.propertyName), factory.createIdentifier(obj.name))
-            }
-
-            return factory.createImportSpecifier(false, undefined, factory.createIdentifier(obj.propertyName))
-          }
-
-          return factory.createImportSpecifier(false, undefined, factory.createIdentifier(item))
-        }),
-      ),
-    ),
+    factory.createImportClause(isTypeOnly, undefined, factory.createNamedImports(specifiers)),
     factory.createStringLiteral(resolvePath),
     undefined,
   )
@@ -153,36 +127,44 @@ 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: [],
         })