@kubb/core 4.2.0 → 4.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/core",
-  "version": "4.2.0",
+  "version": "4.2.1",
   "description": "Core functionality for Kubb's plugin-based code generation system, providing the foundation for transforming OpenAPI specifications.",
   "keywords": [
     "typescript",
@@ -87,7 +87,7 @@
     "!/**/__tests__/**"
   ],
   "dependencies": {
-    "@kubb/fabric-core": "^0.1.0",
+    "@kubb/fabric-core": "0.0.0-canary-20251021185909",
     "@kubb/parser-ts": "^4.1.4",
     "camelcase": "^8.0.0",
     "find-up": "^7.0.0",
@@ -100,7 +100,7 @@
     "remeda": "^2.32.0",
     "seedrandom": "^3.0.5",
     "semver": "^7.7.3",
-    "@kubb/react": "4.2.0"
+    "@kubb/react": "4.2.1"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",

package/src/FileManager.ts

@@ -1,26 +1,14 @@
-import { extname, join, relative } from 'node:path'
-
-import { orderBy } from 'natural-orderby'
-import pLimit from 'p-limit'
-import { isDeepEqual, uniqueBy } from 'remeda'
-
+import { extname, join } from 'node:path'
 import { BarrelManager } from './BarrelManager.ts'
-
 import type { KubbFile } from './fs/index.ts'
-import { trimExtName, write } from './fs/index.ts'
-import type { ResolvedFile } from './fs/types.ts'
+import { trimExtName } from './fs/index.ts'
 import type { Logger } from './logger.ts'
-import type { BarrelType, Config, Plugin } from './types.ts'
-import { createFile, getFileParser } from './utils'
-import { Cache } from './utils/Cache.ts'
-import type { GreaterThan } from './utils/types.ts'
+import type { BarrelType, Plugin } from './types.ts'
 
 export type FileMetaBase = {
   pluginKey?: Plugin['key']
 }
 
-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
   /**
@@ -42,307 +30,51 @@ type AddIndexesProps = {
   meta?: FileMetaBase
 }
 
-type WriteFilesProps = {
-  root: Config['root']
-  extension?: Record<KubbFile.Extname, KubbFile.Extname | ''>
-  logger?: Logger
-  dryRun?: boolean
-}
-
-export class FileManager {
-  #cache = new Cache<KubbFile.ResolvedFile>()
-  #limit = pLimit(100)
-
-  constructor() {
-    return this
-  }
-
-  async add<T extends Array<KubbFile.File> = Array<KubbFile.File>>(...files: T): AddResult<T> {
-    const resolvedFiles: KubbFile.ResolvedFile[] = []
-
-    const mergedFiles = new Map<string, KubbFile.File>()
-
-    files.forEach((file) => {
-      const existing = mergedFiles.get(file.path)
-      if (existing) {
-        mergedFiles.set(file.path, mergeFile(existing, file))
-      } else {
-        mergedFiles.set(file.path, file)
-      }
-    })
-
-    for (const file of mergedFiles.values()) {
-      const existing = await this.#cache.get(file.path)
-
-      const merged = existing ? mergeFile(existing, file) : file
-      const resolvedFile = createFile(merged)
-
-      await this.#cache.set(resolvedFile.path, resolvedFile)
-      await this.#cache.flush()
-
-      resolvedFiles.push(resolvedFile)
-    }
-
-    if (files.length > 1) {
-      return resolvedFiles as unknown as AddResult<T>
-    }
-
-    return resolvedFiles[0] as unknown as AddResult<T>
-  }
-
-  async getByPath(path: KubbFile.Path): Promise<KubbFile.ResolvedFile | null> {
-    return this.#cache.get(path)
-  }
-
-  async deleteByPath(path: KubbFile.Path): Promise<void> {
-    await this.#cache.delete(path)
+export function getMode(path: string | undefined | null): KubbFile.Mode {
+  if (!path) {
+    return 'split'
   }
+  return extname(path) ? 'single' : 'split'
+}
 
-  async clear(): Promise<void> {
-    await this.#cache.clear()
+export async function getBarrelFiles(
+  files: Array<KubbFile.ResolvedFile>,
+  { type, meta = {}, root, output, logger }: AddIndexesProps,
+): Promise<KubbFile.File[]> {
+  if (!type || type === 'propagate') {
+    return []
   }
 
-  async getFiles(): Promise<Array<KubbFile.ResolvedFile>> {
-    const cachedKeys = await this.#cache.keys()
+  const barrelManager = new BarrelManager({ logger })
 
-    // order by path length and if file is a barrel file
-    const keys = orderBy(cachedKeys, [(v) => v.length, (v) => trimExtName(v).endsWith('index')])
+  const pathToBuildFrom = join(root, output.path)
 
-    const filesTasks = keys.map((key) =>
-      this.#limit(async () => {
-        const file = await this.#cache.get(key)
-        return file as KubbFile.ResolvedFile
-      }),
-    )
+  if (trimExtName(pathToBuildFrom).endsWith('index')) {
+    logger?.emit('warning', 'Output has the same fileName as the barrelFiles, please disable barrel generation')
 
-    const files = await Promise.all(filesTasks)
-
-    return files.filter(Boolean)
+    return []
   }
 
-  async processFiles({ dryRun, root, extension, logger }: WriteFilesProps): Promise<Array<KubbFile.ResolvedFile>> {
-    const files = await this.getFiles()
-
-    logger?.emit('progress_start', { id: 'files', size: files.length, message: 'Writing files ...' })
-
-    const promises = files.map((file) => {
-      return this.#limit(async () => {
-        const message = file ? `Writing ${relative(root, file.path)}` : ''
-        const extname = extension?.[file.extname] || undefined
+  const barrelFiles = barrelManager.getFiles({ files, root: pathToBuildFrom, meta })
 
-        if (!dryRun) {
-          const source = await getSource(file, { logger, extname })
-          await write(file.path, source, { sanity: false })
-        }
-
-        logger?.emit('progressed', { id: 'files', message })
-      })
-    })
-
-    await Promise.all(promises)
-
-    logger?.emit('progress_stop', { id: 'files' })
-
-    return files
-  }
-  async getBarrelFiles({ type, meta = {}, root, output, logger }: AddIndexesProps): Promise<KubbFile.File[]> {
-    if (!type || type === 'propagate') {
-      return []
-    }
-
-    const barrelManager = new BarrelManager({ logger })
-    const files = await this.getFiles()
-
-    const pathToBuildFrom = join(root, output.path)
-
-    if (trimExtName(pathToBuildFrom).endsWith('index')) {
-      logger?.emit('warning', 'Output has the same fileName as the barrelFiles, please disable barrel generation')
-
-      return []
-    }
-
-    const barrelFiles = barrelManager.getFiles({ files, root: pathToBuildFrom, meta })
-
-    if (type === 'all') {
-      return barrelFiles.map((file) => {
-        return {
-          ...file,
-          exports: file.exports?.map((exportItem) => {
-            return {
-              ...exportItem,
-              name: undefined,
-            }
-          }),
-        }
-      })
-    }
-
-    return barrelFiles.map((indexFile) => {
+  if (type === 'all') {
+    return barrelFiles.map((file) => {
       return {
-        ...indexFile,
-        meta,
+        ...file,
+        exports: file.exports?.map((exportItem) => {
+          return {
+            ...exportItem,
+            name: undefined,
+          }
+        }),
       }
     })
   }
 
-  // statics
-  static getMode(path: string | undefined | null): KubbFile.Mode {
-    if (!path) {
-      return 'split'
+  return barrelFiles.map((indexFile) => {
+    return {
+      ...indexFile,
+      meta,
     }
-    return extname(path) ? 'single' : 'split'
-  }
-}
-
-type GetSourceOptions = {
-  extname?: KubbFile.Extname
-  logger?: Logger
-}
-
-export async function getSource<TMeta extends FileMetaBase = FileMetaBase>(
-  file: ResolvedFile<TMeta>,
-  { logger, extname }: GetSourceOptions = {},
-): Promise<string> {
-  const parser = await getFileParser(file.extname)
-
-  return parser.print(file, { logger, extname })
-}
-
-function mergeFile<TMeta extends FileMetaBase = FileMetaBase>(a: KubbFile.File<TMeta>, b: KubbFile.File<TMeta>): KubbFile.File<TMeta> {
-  return {
-    ...a,
-    sources: [...(a.sources || []), ...(b.sources || [])],
-    imports: [...(a.imports || []), ...(b.imports || [])],
-    exports: [...(a.exports || []), ...(b.exports || [])],
-  }
-}
-
-export function combineSources(sources: Array<KubbFile.Source>): Array<KubbFile.Source> {
-  return uniqueBy(sources, (obj) => [obj.name, obj.isExportable, obj.isTypeOnly] as const)
-}
-
-export function combineExports(exports: Array<KubbFile.Export>): Array<KubbFile.Export> {
-  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)
-      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 uniquePrev = prev.findLast(
-        (imp) => imp.path === curr.path && isDeepEqual(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly && imp.asAlias === curr.asAlias,
-      )
-
-      // 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
-      }
-
-      if (!prevByPath) {
-        return [
-          ...prev,
-          {
-            ...curr,
-            name: Array.isArray(name) ? [...new Set(name)] : 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])]
-
-        return prev
-      }
-
-      return [...prev, curr]
-    },
-    [] as Array<KubbFile.Export>,
-  )
-}
-
-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),
-  ]).reduce(
-    (prev, curr) => {
-      let name = Array.isArray(curr.name) ? [...new Set(curr.name)] : curr.name
-
-      const hasImportInSource = (importName: string) => {
-        if (!source) {
-          return true
-        }
-
-        const checker = (name?: string) => {
-          return name && source.includes(name)
-        }
-
-        return checker(importName) || exports.some(({ name }) => (Array.isArray(name) ? name.some(checker) : checker(name)))
-      }
-
-      if (curr.path === curr.root) {
-        // root and path are the same file, remove the "./" import
-        return prev
-      }
-
-      // merge all names and check if the importName is being used in the generated source and if not filter those imports out
-      if (Array.isArray(name)) {
-        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)
-
-      if (prevByPathNameAndIsTypeOnly) {
-        // we already have an export that has the same path but uses `isTypeOnly` (import type ...)
-        return prev
-      }
-
-      // already unique enough or name is empty
-      if (uniquePrev || (Array.isArray(name) && !name.length)) {
-        return prev
-      }
-
-      // new item, append name
-      if (!prevByPath) {
-        return [
-          ...prev,
-          {
-            ...curr,
-            name,
-          },
-        ]
-      }
-
-      // 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
-      }
-
-      // no import was found in the source, ignore import
-      if (!Array.isArray(name) && name && !hasImportInSource(name)) {
-        return prev
-      }
-
-      return [...prev, curr]
-    },
-    [] as Array<KubbFile.Import>,
-  )
+  })
 }

package/src/PluginManager.ts

@@ -1,15 +1,11 @@
-import { FileManager } from './FileManager.ts'
-import { isPromiseRejectedResult } from './PromiseManager.ts'
-import { PromiseManager } from './PromiseManager.ts'
+import { FileManager } from '@kubb/fabric-core'
 import { ValidationPluginError } from './errors.ts'
-import { pluginCore } from './plugin.ts'
-import { transformReservedWord } from './transformers/transformReservedWord.ts'
-import { EventEmitter } from './utils/EventEmitter.ts'
-import { setUniqueName } from './utils/uniqueName.ts'
-
 import type { KubbFile } from './fs/index.ts'
 import type { Logger } from './logger.ts'
+import { isPromiseRejectedResult, PromiseManager } from './PromiseManager.ts'
 import type { PluginCore } from './plugin.ts'
+import { pluginCore } from './plugin.ts'
+import { transformReservedWord } from './transformers/transformReservedWord.ts'
 import { trim } from './transformers/trim.ts'
 import type {
   Config,
@@ -25,6 +21,8 @@ import type {
   UserPlugin,
   UserPluginWithLifeCycle,
 } from './types.ts'
+import { EventEmitter } from './utils/EventEmitter.ts'
+import { setUniqueName } from './utils/uniqueName.ts'
 
 type RequiredPluginLifecycle = Required<PluginLifecycle>
 
@@ -72,6 +70,9 @@ type GetFileProps<TOptions = object> = {
 
 export class PluginManager {
   readonly plugins = new Set<Plugin<GetPluginFactoryOptions<any>>>()
+  /**
+   * @deprecated do not use from pluginManager
+   */
   readonly fileManager: FileManager
   readonly events: EventEmitter<Events> = new EventEmitter()
 

package/src/__snapshots__/barrel.json

@@ -10,7 +10,7 @@
         "isIndexable": true
       }
     ],
-    "id": "f8e2d98f76d6e33f21aa686d674544b5c7d6fa3e",
+    "id": "24be171099f802b26a7c97f02b0017ea44a6f9147e7fbe8c3ad6bc45283d4903",
     "name": "test",
     "extname": ".ts",
     "imports": [],
@@ -51,7 +51,7 @@
         "isIndexable": false
       }
     ],
-    "id": "feabc02536bd6630458e734990f7e2a21a55c469",
+    "id": "be25f3f85c5b85e95514080872ba0bca69acd8e1cec464b632945e79fed1d5b6",
     "name": "index",
     "extname": ".ts",
     "imports": [],
@@ -68,7 +68,7 @@
         "isIndexable": true
       }
     ],
-    "id": "4b588b3e31d5ea58e60ceedfcf54b9292fbf6986",
+    "id": "2605e7687b17f9a3fbc22bb108d789832b4d51be66f9250e1b08baffec006a71",
     "name": "hello",
     "extname": ".ts",
     "imports": [],
@@ -86,7 +86,7 @@
         "isIndexable": true
       }
     ],
-    "id": "53fb0d18b280dd7edc4a2bc5bbf71ea203680f70",
+    "id": "9522fa0378a8d8ecb5a5c54aac78b9a8644518860de49cf71ced4e6fe9c6e940",
     "name": "world",
     "extname": ".ts",
     "imports": [],
@@ -138,7 +138,7 @@
         "path": "./sub/world.ts"
       }
     ],
-    "id": "c67967bd2363dd9637437671f6fe1ed146debdbf",
+    "id": "216ca4d733d9d347d0ef4ec8865f8209e6ebab829cde4bbfef25e7a40e839b9f",
     "name": "index",
     "extname": ".ts",
     "imports": [],

package/src/build.ts

@@ -1,4 +1,4 @@
-import { join, resolve } from 'node:path'
+import { join, relative, resolve } from 'node:path'
 import pc from 'picocolors'
 import { isDeepEqual } from 'remeda'
 import { isInputPath } from './config.ts'
@@ -91,6 +91,7 @@ export async function build(options: BuildOptions): Promise<BuildOutput> {
 
 export async function safeBuild(options: BuildOptions): Promise<BuildOutput> {
   const pluginManager = await setup(options)
+
   const config = pluginManager.config
 
   try {
@@ -117,7 +118,7 @@ export async function safeBuild(options: BuildOptions): Promise<BuildOutput> {
       const rootPath = resolve(root, config.output.path, 'index.ts')
 
       //TODO find clean method without loading all files
-      const files = await pluginManager.fileManager.getFiles()
+      const files = await pluginManager.fileManager.files
 
       const barrelFiles = files.filter((file) => {
         return file.sources.some((source) => source.isIndexable)
@@ -163,11 +164,24 @@ export async function safeBuild(options: BuildOptions): Promise<BuildOutput> {
       await pluginManager.fileManager.add(rootFile)
     }
 
-    const files = await pluginManager.fileManager.processFiles({
-      root: config.root,
+    pluginManager.fileManager.processor.on('start', ({ files }) => {
+      pluginManager.logger.emit('progress_start', { id: 'files', size: files.length, message: 'Writing files ...' })
+    })
+
+    pluginManager.fileManager.processor.on('file:start', ({ file }) => {
+      const message = file ? `Writing ${relative(config.root, file.path)}` : ''
+      pluginManager.logger.emit('progressed', { id: 'files', message })
+    })
+
+    pluginManager.fileManager.processor.on('file:finish', () => {})
+
+    pluginManager.fileManager.processor.on('finish', () => {
+      pluginManager.logger.emit('progress_stop', { id: 'files' })
+    })
+
+    const files = await pluginManager.fileManager.write({
       extension: config.output.extension,
       dryRun: !config.output.write,
-      logger: pluginManager.logger,
     })
 
     await pluginManager.hookParallel({ hookName: 'buildEnd', message: `Build stopped for ${config.name}` })

package/src/index.ts

@@ -2,10 +2,9 @@ export { BaseGenerator } from './BaseGenerator.ts'
 export { build, build as default, safeBuild, setup } from './build.ts'
 export { defineConfig, isInputPath } from './config.ts'
 export type { FileMetaBase } from './FileManager.ts'
-export { FileManager, getSource } from './FileManager.ts'
+export { getBarrelFiles, getMode } from './FileManager.ts'
 export { PackageManager } from './PackageManager.ts'
 export { PluginManager } from './PluginManager.ts'
 export { PromiseManager } from './PromiseManager.ts'
 export { createPlugin } from './plugin.ts'
 export type * from './types.ts'
-export { getDefaultBanner } from './utils'

package/src/mocks/index.ts

@@ -1,12 +1,11 @@
 import path from 'node:path'
+import { createFile, FileProcessor } from '@kubb/fabric-core'
 import { format } from '../../mocks/format.ts'
-import { getSource } from '../FileManager'
 import type { File, ResolvedFile } from '../fs/types.ts'
 import type { Logger } from '../logger'
 import type { PluginManager } from '../PluginManager.ts'
 import { camelCase, pascalCase } from '../transformers/casing.ts'
 import type { Plugin } from '../types.ts'
-import { createFile } from '../utils'
 
 export const mockedLogger = {
   emit(_type, _message) {},
@@ -67,8 +66,10 @@ export async function matchFiles(files: Array<ResolvedFile | File> | undefined,
     return undefined
   }
 
+  const fileProcessor = new FileProcessor()
+
   for await (const file of files) {
-    const source = await getSource(createFile(file), { logger: mockedLogger })
+    const source = await fileProcessor.parse(createFile(file))
     let code = source
     if (!file.baseName.endsWith('.json')) {
       code = await format(source)

package/src/plugin.ts

@@ -1,6 +1,6 @@
 import path from 'node:path'
 
-import type { FileManager } from './FileManager.ts'
+import type { FileManager } from '@kubb/fabric-core'
 import type { PluginManager } from './PluginManager.ts'
 import type { Plugin, PluginContext, PluginFactoryOptions, UserPluginWithLifeCycle } from './types.ts'
 

package/src/types.ts

@@ -1,4 +1,4 @@
-import type { FileManager } from './FileManager.ts'
+import type { FileManager } from '@kubb/fabric-core'
 import type { KubbFile } from './fs/index.ts'
 import type { Logger } from './logger.ts'
 import type { PluginManager } from './PluginManager.ts'
@@ -300,6 +300,9 @@ export type ResolveNameParams = {
 
 export type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
   config: Config
+  /**
+   * @deprecated
+   */
   fileManager: FileManager
   pluginManager: PluginManager
   addFile: (...file: Array<KubbFile.File>) => Promise<Array<KubbFile.ResolvedFile>>

package/src/utils/TreeNode.ts

@@ -1,4 +1,4 @@
-import { FileManager } from '../FileManager.ts'
+import { getMode } from '../FileManager.ts'
 import type { KubbFile } from '../fs/index.ts'
 
 type BarrelData = {
@@ -124,7 +124,7 @@ export class TreeNode {
         name: filteredTree.name,
         path: filteredTree.path,
         file: filteredTree.file,
-        type: FileManager.getMode(filteredTree.path),
+        type: getMode(filteredTree.path),
       })
 
       const recurse = (node: typeof treeNode, item: DirectoryTree) => {
@@ -132,7 +132,7 @@ export class TreeNode {
           name: item.name,
           path: item.path,
           file: item.file,
-          type: FileManager.getMode(item.path),
+          type: getMode(item.path),
         })
 
         if (item.children?.length) {

package/src/utils/index.ts

@@ -1,3 +1,4 @@
+export { Cache } from './Cache.ts'
 export type { FunctionParamsAST } from './FunctionParams.ts'
 export { FunctionParams } from './FunctionParams.ts'
 export {
@@ -7,9 +8,6 @@ export {
 } from './promise.ts'
 export { renderTemplate } from './renderTemplate.ts'
 export { timeout } from './timeout.ts'
-export { getUniqueName, setUniqueName } from './uniqueName.ts'
 export type { URLObject } from './URLPath.ts'
 export { URLPath } from './URLPath.ts'
-export { getFileParser, createFileImport, createFileExport, createFile, createFileParser, getDefaultBanner } from './parser.ts'
-export type { ParserModule } from './parser.ts'
-export { Cache } from './Cache.ts'
+export { getUniqueName, setUniqueName } from './uniqueName.ts'