@kubb/core 5.0.0-alpha.31 → 5.0.0-alpha.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/core",
-  "version": "5.0.0-alpha.31",
+  "version": "5.0.0-alpha.32",
   "description": "Core functionality for Kubb's plugin-based code generation system, providing the foundation for transforming OpenAPI specifications.",
   "keywords": [
     "typescript",
@@ -64,14 +64,13 @@
     }
   ],
   "dependencies": {
-    "@kubb/fabric-core": "0.15.1",
     "@kubb/react-fabric": "0.15.1",
     "empathic": "^2.0.0",
     "fflate": "^0.8.2",
     "remeda": "^2.33.7",
     "semver": "^7.7.4",
     "tinyexec": "^1.0.4",
-    "@kubb/ast": "5.0.0-alpha.31"
+    "@kubb/ast": "5.0.0-alpha.32"
   },
   "devDependencies": {
     "@types/semver": "^7.7.1",
@@ -79,7 +78,6 @@
     "@internals/utils": "0.0.0"
   },
   "peerDependencies": {
-    "@kubb/fabric-core": "0.14.0",
     "@kubb/react-fabric": "0.14.0"
   },
   "engines": {

package/src/FileManager.ts

@@ -0,0 +1,131 @@
+import { trimExtName } from '@internals/utils'
+import { createFile } from '@kubb/ast'
+import type { FileNode } from '@kubb/ast/types'
+
+function mergeFile<TMeta extends object = object>(a: FileNode<TMeta>, b: FileNode<TMeta>): FileNode<TMeta> {
+  return {
+    ...a,
+    sources: [...(a.sources || []), ...(b.sources || [])],
+    imports: [...(a.imports || []), ...(b.imports || [])],
+    exports: [...(a.exports || []), ...(b.exports || [])],
+  }
+}
+
+/**
+ * In-memory file store for generated files.
+ *
+ * Files with the same `path` are merged — sources, imports, and exports are concatenated.
+ * The `files` getter returns all stored files sorted by path length (shortest first).
+ *
+ * @example
+ * ```ts
+ * import { FileManager } from '@kubb/core'
+ *
+ * const manager = new FileManager()
+ * manager.upsert(myFile)
+ * console.log(manager.files) // all stored files
+ * ```
+ */
+export class FileManager {
+  readonly #cache = new Map<string, FileNode>()
+  #filesCache: Array<FileNode> | null = null
+
+  /**
+   * Adds one or more files. Files with the same path are merged — sources, imports,
+   * and exports from all calls with the same path are concatenated together.
+   */
+  add(...files: Array<FileNode>): Array<FileNode> {
+    const resolvedFiles: Array<FileNode> = []
+    const mergedFiles = new Map<string, FileNode>()
+
+    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 resolvedFile = createFile(file)
+      this.#cache.set(resolvedFile.path, resolvedFile)
+      this.#filesCache = null
+      resolvedFiles.push(resolvedFile)
+    }
+
+    return resolvedFiles
+  }
+
+  /**
+   * Adds or merges one or more files.
+   * If a file with the same path already exists, its sources/imports/exports are merged together.
+   */
+  upsert(...files: Array<FileNode>): Array<FileNode> {
+    const resolvedFiles: Array<FileNode> = []
+    const mergedFiles = new Map<string, FileNode>()
+
+    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 = this.#cache.get(file.path)
+      const merged = existing ? mergeFile(existing, file) : file
+      const resolvedFile = createFile(merged)
+      this.#cache.set(resolvedFile.path, resolvedFile)
+      this.#filesCache = null
+      resolvedFiles.push(resolvedFile)
+    }
+
+    return resolvedFiles
+  }
+
+  getByPath(path: string): FileNode | null {
+    return this.#cache.get(path) ?? null
+  }
+
+  deleteByPath(path: string): void {
+    this.#cache.delete(path)
+    this.#filesCache = null
+  }
+
+  clear(): void {
+    this.#cache.clear()
+    this.#filesCache = null
+  }
+
+  /**
+   * All stored files, sorted by path length (shorter paths first).
+   * Barrel/index files (e.g. index.ts) are sorted last within each length bucket.
+   */
+  get files(): Array<FileNode> {
+    if (this.#filesCache) {
+      return this.#filesCache
+    }
+
+    const keys = [...this.#cache.keys()].sort((a, b) => {
+      if (a.length !== b.length) return a.length - b.length
+      const aIsIndex = trimExtName(a).endsWith('index')
+      const bIsIndex = trimExtName(b).endsWith('index')
+      if (aIsIndex !== bIsIndex) return aIsIndex ? 1 : -1
+      return 0
+    })
+
+    const files: Array<FileNode> = []
+    for (const key of keys) {
+      const file = this.#cache.get(key)
+      if (file) {
+        files.push(file)
+      }
+    }
+
+    this.#filesCache = files
+    return files
+  }
+}

package/src/FileProcessor.ts

@@ -0,0 +1,83 @@
+import type { FileNode } from '@kubb/ast/types'
+import pLimit from 'p-limit'
+import { PARALLEL_CONCURRENCY_LIMIT } from './constants.ts'
+import type { Parser } from './defineParser.ts'
+
+type ParseOptions = {
+  parsers?: Map<FileNode['extname'], Parser>
+  extension?: Record<FileNode['extname'], FileNode['extname'] | ''>
+}
+
+type RunOptions = ParseOptions & {
+  /**
+   * @default 'sequential'
+   */
+  mode?: 'sequential' | 'parallel'
+  onStart?: (files: Array<FileNode>) => Promise<void> | void
+  onEnd?: (files: Array<FileNode>) => Promise<void> | void
+  onUpdate?: (params: { file: FileNode; source?: string; processed: number; total: number; percentage: number }) => Promise<void> | void
+}
+
+function joinSources(file: FileNode): string {
+  return file.sources
+    .map((item) => item.value)
+    .filter((value): value is string => value != null)
+    .join('\n\n')
+}
+
+/**
+ * Converts a single file to a string using the registered parsers.
+ * Falls back to joining source values when no matching parser is found.
+ */
+export class FileProcessor {
+  readonly #limit = pLimit(PARALLEL_CONCURRENCY_LIMIT)
+
+  async parse(file: FileNode, { parsers, extension }: ParseOptions = {}): Promise<string> {
+    const parseExtName = extension?.[file.extname] || undefined
+
+    if (!parsers || !file.extname) {
+      return joinSources(file)
+    }
+
+    const parser = parsers.get(file.extname)
+
+    if (!parser) {
+      return joinSources(file)
+    }
+
+    return parser.parse(file, { extname: parseExtName })
+  }
+
+  async run(files: Array<FileNode>, { parsers, mode = 'sequential', extension, onStart, onEnd, onUpdate }: RunOptions = {}): Promise<Array<FileNode>> {
+    await onStart?.(files)
+
+    const total = files.length
+    let processed = 0
+
+    const processOne = async (file: FileNode) => {
+      const source = await this.parse(file, { extension, parsers })
+      const currentProcessed = ++processed
+      const percentage = (currentProcessed / total) * 100
+
+      await onUpdate?.({
+        file,
+        source,
+        processed: currentProcessed,
+        percentage,
+        total,
+      })
+    }
+
+    if (mode === 'sequential') {
+      for (const file of files) {
+        await processOne(file)
+      }
+    } else {
+      await Promise.all(files.map((file) => this.#limit(() => processOne(file))))
+    }
+
+    await onEnd?.(files)
+
+    return files
+  }
+}

package/src/Kubb.ts

@@ -1,4 +1,4 @@
-import type * as KubbFile from './KubbFile.ts'
+import type { FileNode } from '@kubb/ast/types'
 import type { Strategy } from './PluginDriver.ts'
 import type { Config, Plugin, PluginLifecycleHooks } from './types'
 
@@ -76,7 +76,7 @@ export interface KubbEvents {
   /**
    * Emitted when code generation phase completes.
    */
-  'generation:end': [config: Config, files: Array<KubbFile.ResolvedFile>, sources: Map<KubbFile.Path, string>]
+  'generation:end': [config: Config, files: Array<FileNode>, sources: Map<string, string>]
   /**
    * Emitted with a summary of the generation results.
    * Contains summary lines, title, and success status.
@@ -160,7 +160,7 @@ export interface KubbEvents {
    * Emitted when file processing starts.
    * Contains the list of files to be processed.
    */
-  'files:processing:start': [files: Array<KubbFile.ResolvedFile>]
+  'files:processing:start': [files: Array<FileNode>]
   /**
    * Emitted for each file being processed, providing progress updates.
    * Contains processed count, total count, percentage, and file details.
@@ -186,7 +186,7 @@ export interface KubbEvents {
       /**
        * The file being processed.
        */
-      file: KubbFile.ResolvedFile
+      file: FileNode
       /**
        * Kubb configuration (not present in Fabric).
        * Provides access to the current config during file processing.
@@ -198,7 +198,7 @@ export interface KubbEvents {
    * Emitted when file processing completes.
    * Contains the list of processed files.
    */
-  'files:processing:end': [files: Array<KubbFile.ResolvedFile>]
+  'files:processing:end': [files: Array<FileNode>]
 
   /**
    * Emitted when a plugin starts executing.

package/src/PluginDriver.ts

@@ -2,11 +2,11 @@ import { basename, extname, resolve } from 'node:path'
 import { performance } from 'node:perf_hooks'
 import type { AsyncEventEmitter } from '@internals/utils'
 import { isPromiseRejectedResult, transformReservedWord } from '@internals/utils'
-import type { RootNode } from '@kubb/ast/types'
-import type { Fabric as FabricType } from '@kubb/fabric-core/types'
+import { createFile } from '@kubb/ast'
+import type { FileNode, InputNode } from '@kubb/ast/types'
 import { DEFAULT_STUDIO_URL } from './constants.ts'
 import { openInStudio as openInStudioFn } from './devtools.ts'
-import type * as KubbFile from './KubbFile.ts'
+import { FileManager } from './FileManager.ts'
 
 import type {
   Adapter,
@@ -47,7 +47,6 @@ type SafeParseResult<H extends PluginLifecycleHooks, Result = ReturnType<ParseRe
 // inspired by: https://github.com/rollup/rollup/blob/master/src/utils/PluginDriver.ts#
 
 type Options = {
-  fabric: FabricType
   events: AsyncEventEmitter<KubbEvents>
   /**
    * @default Number.POSITIVE_INFINITY
@@ -60,8 +59,8 @@ type Options = {
  */
 export type GetFileOptions<TOptions = object> = {
   name: string
-  mode?: KubbFile.Mode
-  extname: KubbFile.Extname
+  mode?: 'single' | 'split'
+  extname: FileNode['extname']
   pluginName: string
   options?: TOptions
 }
@@ -75,7 +74,7 @@ export type GetFileOptions<TOptions = object> = {
  * getMode('src/gen/types')     // 'split'
  * ```
  */
-export function getMode(fileOrFolder: string | undefined | null): KubbFile.Mode {
+export function getMode(fileOrFolder: string | undefined | null): 'single' | 'split' {
   if (!fileOrFolder) {
     return 'split'
   }
@@ -89,13 +88,20 @@ export class PluginDriver {
   readonly options: Options
 
   /**
-   * The universal `@kubb/ast` `RootNode` produced by the adapter, set by
+   * The universal `@kubb/ast` `InputNode` produced by the adapter, set by
    * the build pipeline after the adapter's `parse()` resolves.
    */
-  rootNode: RootNode | undefined = undefined
+  inputNode: InputNode | undefined = undefined
   adapter: Adapter | undefined = undefined
   #studioIsOpen = false
 
+  /**
+   * Central file store for all generated files.
+   * Plugins should use `this.addFile()` / `this.upsertFile()` (via their context) to
+   * add files; this property gives direct read/write access when needed.
+   */
+  readonly fileManager = new FileManager()
+
   readonly plugins = new Map<string, Plugin>()
 
   constructor(config: Config, options: Options) {
@@ -127,12 +133,11 @@ export class PluginDriver {
     const driver = this
 
     const baseContext = {
-      fabric: driver.options.fabric,
       config: driver.config,
       get root(): string {
         return resolve(driver.config.root, driver.config.output.path)
       },
-      getMode(output: { path: string }): KubbFile.Mode {
+      getMode(output: { path: string }): 'single' | 'split' {
         return getMode(resolve(driver.config.root, driver.config.output.path, output.path))
       },
       events: driver.options.events,
@@ -140,14 +145,14 @@ export class PluginDriver {
       getPlugin: driver.getPlugin.bind(driver),
       requirePlugin: driver.requirePlugin.bind(driver),
       driver: driver,
-      addFile: async (...files: Array<KubbFile.File>) => {
-        await this.options.fabric.addFile(...files)
+      addFile: async (...files: Array<FileNode>) => {
+        driver.fileManager.add(...files)
       },
-      upsertFile: async (...files: Array<KubbFile.File>) => {
-        await this.options.fabric.upsertFile(...files)
+      upsertFile: async (...files: Array<FileNode>) => {
+        driver.fileManager.upsert(...files)
       },
-      get rootNode(): RootNode | undefined {
-        return driver.rootNode
+      get inputNode(): InputNode | undefined {
+        return driver.inputNode
       },
       get adapter(): Adapter | undefined {
         return driver.adapter
@@ -176,7 +181,7 @@ export class PluginDriver {
           throw new Error('Devtools must be an object')
         }
 
-        if (!driver.rootNode || !driver.adapter) {
+        if (!driver.inputNode || !driver.adapter) {
           throw new Error('adapter is not defined, make sure you have set the parser in kubb.config.ts')
         }
 
@@ -184,7 +189,7 @@ export class PluginDriver {
 
         const studioUrl = driver.config.devtools?.studioUrl ?? DEFAULT_STUDIO_URL
 
-        return openInStudioFn(driver.rootNode, studioUrl, options)
+        return openInStudioFn(driver.inputNode, studioUrl, options)
       },
     } as unknown as PluginContext<TOptions>
 
@@ -207,7 +212,7 @@ export class PluginDriver {
   /**
    * @deprecated use resolvers context instead
    */
-  getFile<TOptions = object>({ name, mode, extname, pluginName, options }: GetFileOptions<TOptions>): KubbFile.File<{ pluginName: string }> {
+  getFile<TOptions = object>({ name, mode, extname, pluginName, options }: GetFileOptions<TOptions>): FileNode<{ pluginName: string }> {
     const resolvedName = mode ? (mode === 'single' ? '' : this.resolveName({ name, pluginName, type: 'file' })) : name
 
     const path = this.resolvePath({
@@ -221,22 +226,22 @@ export class PluginDriver {
       throw new Error(`Filepath should be defined for resolvedName "${resolvedName}" and pluginName "${pluginName}"`)
     }
 
-    return {
+    return createFile<{ pluginName: string }>({
       path,
-      baseName: basename(path) as KubbFile.File['baseName'],
+      baseName: basename(path) as `${string}.${string}`,
       meta: {
         pluginName,
       },
       sources: [],
       imports: [],
       exports: [],
-    }
+    })
   }
 
   /**
    * @deprecated use resolvers context instead
    */
-  resolvePath = <TOptions = object>(params: ResolvePathParams<TOptions>): KubbFile.Path => {
+  resolvePath = <TOptions = object>(params: ResolvePathParams<TOptions>): string => {
     const root = resolve(this.config.root, this.config.output.path)
     const defaultPath = resolve(root, params.baseName)