@kubb/core 5.0.0-beta.7 → 5.0.0-beta.70

package/src/FileManager.ts

@@ -1,115 +0,0 @@
-import type { FileNode } from '@kubb/ast'
-import { createFile } from '@kubb/ast'
-
-function mergeFile<TMeta extends object = object>(a: FileNode<TMeta>, b: FileNode<TMeta>): FileNode<TMeta> {
-  return {
-    ...a,
-    // Incoming file (b) takes precedence for banner/footer so that barrel files,
-    // which never carry a banner, can clear banners set by plugin-generated files
-    // at the same path.
-    banner: b.banner,
-    footer: b.footer,
-    sources: [...(a.sources || []), ...(b.sources || [])],
-    imports: [...(a.imports || []), ...(b.imports || [])],
-    exports: [...(a.exports || []), ...(b.exports || [])],
-  }
-}
-
-/**
- * Collapses a list of files so that duplicates sharing the same `path` are merged
- * in arrival order. Keeps the original order of first occurrence.
- */
-function mergeFilesByPath(files: ReadonlyArray<FileNode>): Map<string, FileNode> {
-  const merged = new Map<string, FileNode>()
-  for (const file of files) {
-    const existing = merged.get(file.path)
-    merged.set(file.path, existing ? mergeFile(existing, file) : file)
-  }
-  return merged
-}
-
-/**
- * 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. Incoming files with the same path are merged
-   * (sources/imports/exports concatenated), but existing cache entries are
-   * replaced — use {@link upsert} when you want to merge into the cache too.
-   */
-  add(...files: Array<FileNode>): Array<FileNode> {
-    return this.#store(files, false)
-  }
-
-  /**
-   * Adds or merges one or more files.
-   * If a file with the same path already exists in the cache, its
-   * sources/imports/exports are merged into the incoming file.
-   */
-  upsert(...files: Array<FileNode>): Array<FileNode> {
-    return this.#store(files, true)
-  }
-
-  #store(files: ReadonlyArray<FileNode>, mergeExisting: boolean): Array<FileNode> {
-    const resolvedFiles: Array<FileNode> = []
-    for (const file of mergeFilesByPath(files).values()) {
-      const existing = mergeExisting ? this.#cache.get(file.path) : undefined
-      const resolvedFile = createFile(existing ? mergeFile(existing, file) : file)
-      this.#cache.set(resolvedFile.path, resolvedFile)
-      resolvedFiles.push(resolvedFile)
-    }
-    this.#filesCache = null
-    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).
-   */
-  get files(): Array<FileNode> {
-    if (this.#filesCache) {
-      return this.#filesCache
-    }
-
-    this.#filesCache = [...this.#cache.values()].sort((a, b) => {
-      const lenDiff = a.path.length - b.path.length
-      if (lenDiff !== 0) return lenDiff
-      // Within the same length bucket, index.ts barrel files go last so other
-      // files are always processed before their barrel file.
-      const aIsIndex = a.path.endsWith('/index.ts') || a.path === 'index.ts'
-      const bIsIndex = b.path.endsWith('/index.ts') || b.path === 'index.ts'
-      if (aIsIndex && !bIsIndex) return 1
-      if (!aIsIndex && bIsIndex) return -1
-      return 0
-    })
-    return this.#filesCache
-  }
-}

package/src/FileProcessor.ts

@@ -1,86 +0,0 @@
-import type { CodeNode, FileNode } from '@kubb/ast'
-import { extractStringsFromNodes } from '@kubb/ast'
-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) => extractStringsFromNodes(item.nodes as Array<CodeNode>))
-    .filter(Boolean)
-    .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.
- *
- * @internal
- */
-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,300 +0,0 @@
-import type { AsyncEventEmitter } from '@internals/utils'
-import type { OperationNode, SchemaNode } from '@kubb/ast'
-import type { BuildOutput } from './createKubb.ts'
-import type { PluginDriver } from './PluginDriver.ts'
-import type {
-  Config,
-  GeneratorContext,
-  KubbBuildEndContext,
-  KubbBuildStartContext,
-  KubbConfigEndContext,
-  KubbDebugContext,
-  KubbErrorContext,
-  KubbFileProcessingUpdateContext,
-  KubbFilesProcessingEndContext,
-  KubbFilesProcessingStartContext,
-  KubbGenerationEndContext,
-  KubbGenerationStartContext,
-  KubbGenerationSummaryContext,
-  KubbHookEndContext,
-  KubbHookStartContext,
-  KubbInfoContext,
-  KubbLifecycleStartContext,
-  KubbPluginEndContext,
-  KubbPluginSetupContext,
-  KubbPluginStartContext,
-  KubbPluginsEndContext,
-  KubbSuccessContext,
-  KubbVersionNewContext,
-  KubbWarnContext,
-} from './types'
-
-/**
- * Kubb code generation instance returned by {@link createKubb}.
- *
- * Use this when orchestrating multiple builds, inspecting plugin timings, or integrating Kubb into a larger toolchain.
- * For a single one-off build, chain directly: `await createKubb(config).build()`.
- */
-export type Kubb = {
-  /**
-   * Shared event emitter for lifecycle and status events. Attach listeners before calling `setup()` or `build()`.
-   */
-  readonly hooks: AsyncEventEmitter<KubbHooks>
-  /**
-   * Generated source code keyed by absolute file path. Available after `build()` or `safeBuild()` completes.
-   */
-  readonly sources: Map<string, string>
-  /**
-   * Plugin driver managing all plugins. Available after `setup()` completes.
-   */
-  readonly driver: PluginDriver | undefined
-  /**
-   * Resolved configuration with defaults applied. Available after `setup()` completes.
-   */
-  readonly config: Config | undefined
-  /**
-   * Resolves config and initializes the driver. `build()` calls this automatically.
-   */
-  setup(): Promise<void>
-  /**
-   * Runs the full pipeline and throws on any plugin error. Automatically calls `setup()` if needed.
-   */
-  build(): Promise<BuildOutput>
-  /**
-   * Runs the full pipeline and captures errors in `BuildOutput` instead of throwing. Automatically calls `setup()` if needed.
-   */
-  safeBuild(): Promise<BuildOutput>
-}
-
-/**
- * Lifecycle events emitted during Kubb code generation.
- * Use these for logging, progress tracking, and custom integrations.
- *
- * @example
- * ```typescript
- * import type { AsyncEventEmitter } from '@internals/utils'
- * import type { KubbHooks } from '@kubb/core'
- *
- * const hooks: AsyncEventEmitter<KubbHooks> = new AsyncEventEmitter()
- *
- * hooks.on('kubb:lifecycle:start', () => {
- *   console.log('Starting Kubb generation')
- * })
- *
- * hooks.on('kubb:plugin:end', ({ plugin, duration }) => {
- *   console.log(`Plugin ${plugin.name} completed in ${duration}ms`)
- * })
- * ```
- */
-export interface KubbHooks {
-  /**
-   * Fires at the start of the Kubb lifecycle, before code generation begins.
-   */
-  'kubb:lifecycle:start': [ctx: KubbLifecycleStartContext]
-  /**
-   * Fires at the end of the Kubb lifecycle, after all code generation completes.
-   */
-  'kubb:lifecycle:end': []
-
-  /**
-   * Fires when configuration loading starts.
-   */
-  'kubb:config:start': []
-  /**
-   * Fires when configuration loading completes.
-   */
-  'kubb:config:end': [ctx: KubbConfigEndContext]
-
-  /**
-   * Fires when code generation starts.
-   */
-  'kubb:generation:start': [ctx: KubbGenerationStartContext]
-  /**
-   * Fires when code generation completes.
-   */
-  'kubb:generation:end': [ctx: KubbGenerationEndContext]
-  /**
-   * Fires with a generation summary including summary lines, title, and success status.
-   */
-  'kubb:generation:summary': [ctx: KubbGenerationSummaryContext]
-
-  /**
-   * Fires when code formatting starts (e.g., Biome or Prettier).
-   */
-  'kubb:format:start': []
-  /**
-   * Fires when code formatting completes.
-   */
-  'kubb:format:end': []
-
-  /**
-   * Fires when linting starts.
-   */
-  'kubb:lint:start': []
-  /**
-   * Fires when linting completes.
-   */
-  'kubb:lint:end': []
-
-  /**
-   * Fires when plugin hooks execution starts.
-   */
-  'kubb:hooks:start': []
-  /**
-   * Fires when plugin hooks execution completes.
-   */
-  'kubb:hooks:end': []
-
-  /**
-   * Fires when a single hook executes (e.g., format or lint). The callback is invoked when the command finishes.
-   */
-  'kubb:hook:start': [ctx: KubbHookStartContext]
-  /**
-   * Fires when a single hook execution completes.
-   */
-  'kubb:hook:end': [ctx: KubbHookEndContext]
-
-  /**
-   * Fires when a new Kubb version is available.
-   */
-  'kubb:version:new': [ctx: KubbVersionNewContext]
-
-  /**
-   * Informational message event.
-   */
-  'kubb:info': [ctx: KubbInfoContext]
-  /**
-   * Error event, fired when an error occurs during generation.
-   */
-  'kubb:error': [ctx: KubbErrorContext]
-  /**
-   * Success message event.
-   */
-  'kubb:success': [ctx: KubbSuccessContext]
-  /**
-   * Warning message event.
-   */
-  'kubb:warn': [ctx: KubbWarnContext]
-  /**
-   * Debug event for detailed logging with timestamp and optional filename.
-   */
-  'kubb:debug': [ctx: KubbDebugContext]
-
-  /**
-   * Fires when file processing starts with the list of files to process.
-   */
-  'kubb:files:processing:start': [ctx: KubbFilesProcessingStartContext]
-  /**
-   * Fires for each file with progress updates: processed count, total, percentage, and file details.
-   */
-  'kubb:file:processing:update': [ctx: KubbFileProcessingUpdateContext]
-  /**
-   * Fires when file processing completes with the list of processed files.
-   */
-  'kubb:files:processing:end': [ctx: KubbFilesProcessingEndContext]
-
-  /**
-   * Fires when a plugin starts execution.
-   */
-  'kubb:plugin:start': [ctx: KubbPluginStartContext]
-  /**
-   * Fires when a plugin completes execution. Duration measured in milliseconds.
-   */
-  'kubb:plugin:end': [ctx: KubbPluginEndContext]
-
-  /**
-   * Fires once before plugins execute — allowing plugins to register generators, configure resolvers/transformers/renderers, or inject files.
-   */
-  'kubb:plugin:setup': [ctx: KubbPluginSetupContext]
-  /**
-   * Fires before the plugin execution loop begins. The adapter has already parsed the source and `inputNode` is available.
-   */
-  'kubb:build:start': [ctx: KubbBuildStartContext]
-  /**
-   * Fires after all plugins run and per-plugin barrels generate, but before files write to disk.
-   * Use this to inject final files that must persist in the same write pass as plugin output.
-   */
-  'kubb:plugins:end': [ctx: KubbPluginsEndContext]
-  /**
-   * Fires after all files write to disk.
-   */
-  'kubb:build:end': [ctx: KubbBuildEndContext]
-
-  /**
-   * Fires for each schema node during AST traversal. Generator listeners respond to this.
-   */
-  'kubb:generate:schema': [node: SchemaNode, ctx: GeneratorContext]
-  /**
-   * Fires for each operation node during AST traversal. Generator listeners respond to this.
-   */
-  'kubb:generate:operation': [node: OperationNode, ctx: GeneratorContext]
-  /**
-   * Fires once after all operations traverse with the full collected array. Batch generator listeners respond to this.
-   */
-  'kubb:generate:operations': [nodes: Array<OperationNode>, ctx: GeneratorContext]
-}
-
-declare global {
-  namespace Kubb {
-    /**
-     * Registry that maps plugin names to their `PluginFactoryOptions`.
-     * Augment this interface in each plugin's `types.ts` to enable automatic
-     * typing for `getPlugin` and `requirePlugin`.
-     *
-     * @example
-     * ```ts
-     * // packages/plugin-ts/src/types.ts
-     * declare global {
-     *   namespace Kubb {
-     *     interface PluginRegistry {
-     *       'plugin-ts': PluginTs
-     *     }
-     *   }
-     * }
-     * ```
-     */
-    interface PluginRegistry {}
-
-    /**
-     * Extension point for root `Config['output']` options.
-     * Augment the `output` key in middleware or plugin packages to add extra fields
-     * to the global output configuration without touching core types.
-     *
-     * @example
-     * ```ts
-     * // packages/middleware-barrel/src/types.ts
-     * declare global {
-     *   namespace Kubb {
-     *     interface ConfigOptionsRegistry {
-     *       output: {
-     *         barrel?: import('./types.ts').BarrelConfig | false
-     *       }
-     *     }
-     *   }
-     * }
-     * ```
-     */
-    interface ConfigOptionsRegistry {}
-
-    /**
-     * Extension point for per-plugin `Output` options.
-     * Augment the `output` key in middleware or plugin packages to add extra fields
-     * to the per-plugin output configuration without touching core types.
-     *
-     * @example
-     * ```ts
-     * // packages/middleware-barrel/src/types.ts
-     * declare global {
-     *   namespace Kubb {
-     *     interface PluginOptionsRegistry {
-     *       output: {
-     *         barrel?: import('./types.ts').PluginBarrelConfig | false
-     *       }
-     *     }
-     *   }
-     * }
-     * ```
-     */
-    interface PluginOptionsRegistry {}
-  }
-}