@kubb/core 3.0.0-alpha.9 → 3.0.0-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/core",
-  "version": "3.0.0-alpha.9",
+  "version": "3.0.0-beta.2",
   "description": "Generator core",
   "keywords": [
     "typescript",
@@ -77,30 +77,27 @@
   "dependencies": {
     "change-case": "^5.4.4",
     "find-up": "^7.0.0",
-    "natural-orderby": "^3.0.2",
+    "natural-orderby": "^4.0.0",
     "object-hash": "^3.0.0",
     "p-queue": "^8.0.1",
-    "remeda": "^2.11.0",
+    "remeda": "^2.14.0",
     "seedrandom": "^3.0.5",
     "semver": "^7.6.3",
-    "unraw": "^3.0.0",
-    "@kubb/fs": "3.0.0-alpha.9",
-    "@kubb/parser-ts": "3.0.0-alpha.9",
-    "@kubb/types": "3.0.0-alpha.9"
+    "@kubb/fs": "3.0.0-beta.2",
+    "@kubb/parser-ts": "3.0.0-beta.2",
+    "@kubb/types": "3.0.0-beta.2"
   },
   "devDependencies": {
     "@types/object-hash": "^3.0.6",
-    "@types/react": "^18.3.4",
     "@types/seedrandom": "^3.0.8",
     "@types/semver": "^7.5.8",
     "consola": "^3.2.3",
     "prettier": "^3.3.3",
     "tinyrainbow": "^1.2.0",
-    "tsup": "^8.2.4",
-    "typescript": "^5.5.4",
-    "@kubb/config-biome": "3.0.0-alpha.9",
-    "@kubb/config-ts": "3.0.0-alpha.9",
-    "@kubb/config-tsup": "3.0.0-alpha.9"
+    "tsup": "^8.3.0",
+    "typescript": "^5.6.2",
+    "@kubb/config-ts": "3.0.0-beta.2",
+    "@kubb/config-tsup": "3.0.0-beta.2"
   },
   "engines": {
     "node": ">=20"

package/src/BarrelManager.ts

@@ -4,10 +4,10 @@ import { TreeNode } from './utils/TreeNode.ts'
 
 import { getRelativePath } from '@kubb/fs'
 import type * as KubbFile from '@kubb/fs/types'
-import { combineExports, combineSources } from './FileManager.ts'
+import type { FileMetaBase } from './FileManager.ts'
 import type { Logger } from './logger.ts'
 
-export type BarrelManagerOptions = {
+type BarrelManagerOptions = {
   logger?: Logger
 }
 
@@ -20,106 +20,108 @@ export class BarrelManager {
     return this
   }
 
-  getFiles(generatedFiles: KubbFile.File[], root?: string): Array<KubbFile.File> {
+  getFiles({ files: generatedFiles, root, meta }: { files: KubbFile.File[]; root?: string; meta?: FileMetaBase | undefined }): Array<KubbFile.File> {
     const { logger } = this.#options
 
-    const files = new Map<KubbFile.Path, KubbFile.File>()
+    const cachedFiles = new Map<KubbFile.Path, KubbFile.File>()
+
+    logger?.emit('debug', { date: new Date(), logs: [`Start barrel generation for pluginKey ${meta?.pluginKey?.join('.')} and root '${root}'`] })
 
     TreeNode.build(generatedFiles, root)?.forEach((treeNode) => {
       if (!treeNode || !treeNode.children || !treeNode.parent?.data.path) {
         return undefined
       }
 
-      const barrelPath: KubbFile.Path = join(treeNode.parent?.data.path, 'index.ts')
-
+      const barrelFile: KubbFile.File = {
+        path: join(treeNode.parent?.data.path, 'index.ts') as KubbFile.Path,
+        baseName: 'index.ts',
+        exports: [],
+        sources: [],
+      }
+      const previousBarrelFile = cachedFiles.get(barrelFile.path)
       const leaves = treeNode.leaves
 
-      // biome-ignore lint/complexity/useFlatMap: we have a custom map in TreeNode
-      const exports = leaves
-        .map((item) => {
-          if (!item.data.name) {
-            return undefined
-          }
+      leaves.forEach((item) => {
+        if (!item.data.name) {
+          return undefined
+        }
+
+        const sources = item.data.file?.sources || []
 
-          const sources = item.data.file?.sources || []
+        if (!sources.some((source) => source.isIndexable)) {
+          logger?.emit(
+            'warning',
+            `No isIndexable source found(source should have a name and isIndexable):\nFile: ${JSON.stringify(item.data.file, undefined, 2)}`,
+          )
+        }
 
-          if (!sources.some((source) => source.isIndexable)) {
-            logger?.emit(
-              'warning',
-              `No isIndexable source found(source should have a name and isIndexable):\nFile: ${JSON.stringify(item.data.file, undefined, 2)}`,
-            )
+        sources.forEach((source) => {
+          if (!item.data.file?.path || !source.isIndexable || !source.name) {
+            return undefined
           }
+          const alreadyContainInPreviousBarrelFile = previousBarrelFile?.sources.some((item) => item.name === source.name)
 
-          return sources.map((source) => {
-            if (!item.data.file?.path || !source.isIndexable) {
-              return undefined
-            }
+          if (alreadyContainInPreviousBarrelFile) {
+            return undefined
+          }
 
-            // true when we have a subdirectory that also contains barrel files
-            const isSubExport = !!treeNode.parent?.data.path?.split?.('/')?.length
+          if (!barrelFile.exports) {
+            barrelFile.exports = []
+          }
 
-            if (isSubExport) {
-              return {
-                name: [source.name],
-                path: getRelativePath(treeNode.parent?.data.path, item.data.path),
-                isTypeOnly: source.isTypeOnly,
-              } as KubbFile.Export
-            }
+          // true when we have a subdirectory that also contains barrel files
+          const isSubExport = !!treeNode.parent?.data.path?.split?.('/')?.length
 
-            return {
+          if (isSubExport) {
+            barrelFile.exports.push({
+              name: [source.name],
+              path: getRelativePath(treeNode.parent?.data.path, item.data.path),
+              isTypeOnly: source.isTypeOnly,
+            })
+          } else {
+            barrelFile.exports.push({
               name: [source.name],
               path: `./${item.data.file.baseName}`,
               isTypeOnly: source.isTypeOnly,
-            } as KubbFile.Export
-          })
-        })
-        .flat()
-        .filter(Boolean)
-
-      const barrelFile: KubbFile.File = {
-        path: barrelPath,
-        baseName: 'index.ts',
-        exports: exports,
-        sources: exports.flatMap((item) => {
-          if (Array.isArray(item.name)) {
-            return item.name.map((name) => {
-              return {
-                name: name,
-                isTypeOnly: item.isTypeOnly,
-                //TODO use parser to generate import
-                value: '',
-                isExportable: false,
-                isIndexable: false,
-              } as KubbFile.Source
             })
           }
-          return [
-            {
-              name: item.name,
-              isTypeOnly: item.isTypeOnly,
-              //TODO use parser to generate import
-              value: '',
-              isExportable: false,
-              isIndexable: false,
-            } as KubbFile.Source,
-          ]
-        }),
-      }
 
-      const previousBarrelFile = files.get(barrelFile.path)
+          barrelFile.sources.push({
+            name: source.name,
+            isTypeOnly: source.isTypeOnly,
+            //TODO use parser to generate import
+            value: '',
+            isExportable: false,
+            isIndexable: false,
+          })
+        })
+      })
+
+      logger?.emit('debug', {
+        date: new Date(),
+        logs: [
+          `Generating barrelFile '${getRelativePath(root, barrelFile.path)}' for '${getRelativePath(root, treeNode.data?.path)}' with ${barrelFile.sources.length} indexable exports: '${barrelFile.sources?.map((source) => source.name).join(', ')}'`,
+        ],
+      })
+
+      logger?.emit('debug', {
+        date: new Date(),
+        logs: [
+          `Generated barrelFile '${getRelativePath(root, barrelFile.path)}' for '${getRelativePath(root, treeNode.data?.path)}' with exports: '${cachedFiles
+            .get(barrelFile.path)
+            ?.sources?.map((source) => source.name)
+            .join(', ')}'`,
+        ],
+      })
 
       if (previousBarrelFile) {
-        files.set(barrelFile.path, {
-          ...previousBarrelFile,
-          ...barrelFile,
-          exports: combineExports([...(previousBarrelFile.exports || []), ...(barrelFile.exports || [])]),
-          sources: combineSources([...(previousBarrelFile.sources || []), ...(barrelFile.sources || [])]),
-        })
+        previousBarrelFile.sources.push(...barrelFile.sources)
+        previousBarrelFile.exports?.push(...(barrelFile.exports || []))
       } else {
-        files.set(barrelFile.path, barrelFile)
+        cachedFiles.set(barrelFile.path, barrelFile)
       }
     })
 
-    return [...files.values()]
+    return [...cachedFiles.values()]
   }
 }

package/src/FileManager.ts

@@ -13,7 +13,7 @@ import type { ResolvedFile } from '@kubb/fs/types'
 import type { GreaterThan } from '@kubb/types'
 import PQueue from 'p-queue'
 import type { Logger } from './logger.ts'
-import type { Config, Plugin } from './types.ts'
+import type { BarrelType, Config, Plugin } from './types.ts'
 import { createFile, getFileParser } from './utils'
 import { type DirectoryTree, TreeNode, buildDirectoryTree } from './utils/TreeNode.ts'
 
@@ -24,6 +24,7 @@ export type FileMetaBase = {
 type AddResult<T extends Array<KubbFile.File>> = Promise<Awaited<GreaterThan<T['length'], 1> extends true ? Promise<ResolvedFile[]> : Promise<ResolvedFile>>>
 
 type AddIndexesProps = {
+  type: BarrelType | false | undefined
   /**
    * Root based on root and output.path specified in the config
    */
@@ -34,9 +35,6 @@ type AddIndexesProps = {
    */
   output: {
     path: string
-    extName?: KubbFile.Extname
-    exportAs?: string
-    exportType?: 'barrel' | 'barrelNamed' | false
   }
   group?: {
     output: string
@@ -49,31 +47,33 @@ type AddIndexesProps = {
 
 export class FileManager {
   #filesByPath: Map<KubbFile.Path, KubbFile.ResolvedFile> = new Map()
-  #files: Set<KubbFile.ResolvedFile> = new Set()
   constructor() {
     return this
   }
 
   get files(): Array<KubbFile.ResolvedFile> {
-    return Array.from(this.#files)
+    return [...this.#filesByPath.values()]
   }
 
   get orderedFiles(): Array<KubbFile.ResolvedFile> {
-    return orderBy(Array.from(this.#files), [
-      (v) => v?.meta && 'pluginKey' in v.meta && !v.meta.pluginKey,
-      (v) => v.path.length,
-      (v) => trimExtName(v.path).endsWith('index'),
-      (v) => trimExtName(v.baseName),
-      (v) => v.path.split('.').pop(),
-    ])
+    return orderBy(
+      [...this.#filesByPath.values()],
+      [
+        (v) => v?.meta && 'pluginKey' in v.meta && !v.meta.pluginKey,
+        (v) => v.path.length,
+        (v) => trimExtName(v.path).endsWith('index'),
+        (v) => trimExtName(v.baseName),
+        (v) => v.path.split('.').pop(),
+      ],
+    )
   }
 
   get groupedFiles(): DirectoryTree | null {
-    return buildDirectoryTree(Array.from(this.#files))
+    return buildDirectoryTree([...this.#filesByPath.values()])
   }
 
   get treeNode(): TreeNode | null {
-    return TreeNode.build(Array.from(this.#files))
+    return TreeNode.build([...this.#filesByPath.values()])
   }
 
   async add<T extends Array<KubbFile.File> = Array<KubbFile.File>>(...files: T): AddResult<T> {
@@ -98,14 +98,12 @@ export class FileManager {
     const resolvedFile = createFile(file)
 
     this.#filesByPath.set(resolvedFile.path, resolvedFile)
-    this.#files.add(resolvedFile)
 
     return resolvedFile
   }
 
   clear() {
     this.#filesByPath.clear()
-    this.#files.clear()
   }
 
   async #addOrAppend(file: KubbFile.File): Promise<ResolvedFile> {
@@ -113,7 +111,6 @@ export class FileManager {
 
     if (previousFile) {
       this.#filesByPath.delete(previousFile.path)
-      this.#files.delete(previousFile)
 
       return this.#add(mergeFile(previousFile, file))
     }
@@ -121,14 +118,7 @@ export class FileManager {
   }
 
   getCacheById(id: string): KubbFile.File | undefined {
-    let cache: KubbFile.File | undefined
-
-    this.#files.forEach((file) => {
-      if (file.id === id) {
-        cache = file
-      }
-    })
-    return cache
+    return [...this.#filesByPath.values()].find((file) => file.id === id)
   }
 
   getByPath(path: KubbFile.Path): KubbFile.ResolvedFile | undefined {
@@ -142,17 +132,15 @@ export class FileManager {
     }
 
     this.#filesByPath.delete(path)
-    this.#files.delete(cacheItem)
   }
 
-  async getBarrelFiles({ files, meta, root, output, logger }: AddIndexesProps): Promise<KubbFile.File[]> {
-    const { exportType = 'barrelNamed' } = output
-    const barrelManager = new BarrelManager({ logger })
-
-    if (exportType === false) {
+  async getBarrelFiles({ type, files, meta = {}, root, output, logger }: AddIndexesProps): Promise<KubbFile.File[]> {
+    if (!type) {
       return []
     }
 
+    const barrelManager = new BarrelManager({ logger })
+
     const pathToBuildFrom = join(root, output.path)
 
     if (trimExtName(pathToBuildFrom).endsWith('index')) {
@@ -161,9 +149,9 @@ export class FileManager {
       return []
     }
 
-    const barrelFiles = barrelManager.getFiles(files, pathToBuildFrom)
+    const barrelFiles = barrelManager.getFiles({ files, root: pathToBuildFrom, meta })
 
-    if (exportType === 'barrel') {
+    if (type === 'all') {
       return barrelFiles.map((file) => {
         return {
           ...file,
@@ -203,16 +191,21 @@ export class FileManager {
 }
 
 type GetSourceOptions = {
+  extname?: KubbFile.Extname
   logger?: Logger
 }
 
-export async function getSource<TMeta extends FileMetaBase = FileMetaBase>(file: ResolvedFile<TMeta>, { logger }: GetSourceOptions = {}): Promise<string> {
-  const parser = await getFileParser(file.extName)
+export async function getSource<TMeta extends FileMetaBase = FileMetaBase>(
+  file: ResolvedFile<TMeta>,
+  { logger, extname }: GetSourceOptions = {},
+): Promise<string> {
+  const parser = await getFileParser(file.extname)
+  const source = await parser.print(file, { logger, extname })
 
-  return parser.print(file, { logger })
+  return parser.format(source)
 }
 
-export function mergeFile<TMeta extends FileMetaBase = FileMetaBase>(a: KubbFile.File<TMeta>, b: KubbFile.File<TMeta>): KubbFile.File<TMeta> {
+function mergeFile<TMeta extends FileMetaBase = FileMetaBase>(a: KubbFile.File<TMeta>, b: KubbFile.File<TMeta>): KubbFile.File<TMeta> {
   return {
     ...a,
     sources: [...(a.sources || []), ...(b.sources || [])],
@@ -224,7 +217,7 @@ export function mergeFile<TMeta extends FileMetaBase = FileMetaBase>(a: KubbFile
 export function combineSources(sources: Array<KubbFile.Source>): Array<KubbFile.Source> {
   return sources.reduce(
     (prev, curr) => {
-      const prevByName = prev.findLast((imp) => imp.name === curr.name)
+      const prevByName = prev.findLast((imp) => imp.name && imp.name === curr.name)
       const prevByPathAndIsExportable = prev.findLast((imp) => imp.name === curr.name && imp.isExportable)
 
       if (prevByPathAndIsExportable) {
@@ -248,7 +241,13 @@ export function combineSources(sources: Array<KubbFile.Source>): Array<KubbFile.
 }
 
 export function combineExports(exports: Array<KubbFile.Export>): Array<KubbFile.Export> {
-  const combinedExports = exports.reduce(
+  return 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)
@@ -289,18 +288,16 @@ export function combineExports(exports: Array<KubbFile.Export>): Array<KubbFile.
     },
     [] as Array<KubbFile.Export>,
   )
+}
 
-  return orderBy(combinedExports, [
+export function combineImports(imports: Array<KubbFile.Import>, exports: Array<KubbFile.Export>, source?: string): Array<KubbFile.Import> {
+  return 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),
-  ])
-}
-
-export function combineImports(imports: Array<KubbFile.Import>, exports: Array<KubbFile.Export>, source?: string): Array<KubbFile.Import> {
-  const combinedImports = imports.reduce(
+  ]).reduce(
     (prev, curr) => {
       let name = Array.isArray(curr.name) ? [...new Set(curr.name)] : curr.name
 
@@ -309,7 +306,9 @@ export function combineImports(imports: Array<KubbFile.Import>, exports: Array<K
           return true
         }
 
-        const checker = (name?: string) => name && !!source.includes(name)
+        const checker = (name?: string) => {
+          return name && !!source.includes(name)
+        }
 
         return checker(importName) || exports.some(({ name }) => (Array.isArray(name) ? name.some(checker) : checker(name)))
       }
@@ -365,15 +364,8 @@ export function combineImports(imports: Array<KubbFile.Import>, exports: Array<K
     },
     [] as Array<KubbFile.Import>,
   )
-
-  return orderBy(combinedImports, [
-    (v) => !!Array.isArray(v.name),
-    (v) => !v.isTypeOnly,
-    (v) => v.path,
-    (v) => !!v.name,
-    (v) => (Array.isArray(v.name) ? orderBy(v.name) : v.name),
-  ])
 }
+
 type WriteFilesProps = {
   config: Config
   files: Array<KubbFile.ResolvedFile>
@@ -393,22 +385,25 @@ export async function processFiles({ dryRun, config, logger, files }: WriteFiles
   ])
 
   logger.emit('debug', {
+    date: new Date(),
     logs: [JSON.stringify({ files: orderedFiles }, null, 2)],
-    fileName: 'kubb-files.json',
-    override: true,
+    fileName: 'kubb-files.log',
   })
 
   if (!dryRun) {
     const size = orderedFiles.length
 
-    logger.emit('progress_start', { id: 'files', size })
+    logger.emit('progress_start', { id: 'files', size, message: 'Writing files ...' })
     const promises = orderedFiles.map(async (file) => {
       await queue.add(async () => {
-        const source = await getSource(file, { logger })
+        const message = file ? `Writing ${relative(config.root, file.path)}` : ''
+        const extname = config.output.extension?.[file.extname]
+
+        const source = await getSource(file, { logger, extname })
 
         await write(file.path, source, { sanity: false })
 
-        logger.emit('progress', { id: 'files', data: file ? relative(config.root, file.path) : '' })
+        logger.emit('progressed', { id: 'files', message })
       })
     })