@kubb/core 5.0.0-alpha.35 → 5.0.0-alpha.38

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { t as __name } from "./chunk--u3MIqq1.js";
-import { $ as getBarrelFiles, A as Plugin, B as ResolveOptionsContext, C as Logger, D as OperationsHook, E as OperationHook, F as PluginParameter, G as ResolverFileParams, H as ResolvePathParams, I as PluginWithLifeCycle, J as UserGroup, K as ResolverPathParams, L as PossibleConfig, M as PluginFactoryOptions, N as PluginLifecycle, O as Output, P as PluginLifecycleHooks, Q as FileMetaBase, R as ResolveBannerContext, S as KubbPluginSetupContext, T as LoggerOptions, U as Resolver, V as ResolvePathOptions, W as ResolverContext, X as UserPlugin, Y as UserLogger, Z as UserPluginWithLifeCycle, _ as Include, _t as createRenderer, a as Adapter, at as KubbHooks, b as KubbBuildEndContext, c as BarrelType, ct as Parser, d as Config, dt as createStorage, et as FunctionParamsAST, f as ConfigInput, ft as formatters, g as Group, gt as RendererFactory, h as GeneratorContext, ht as Renderer, i as defineGenerator, it as Kubb, j as PluginContext, k as Override, l as CLIOptions, lt as defineParser, m as Exclude, mt as logLevel, n as getMode, nt as PluginHooks, o as AdapterFactoryOptions, ot as BuildOutput, p as DevtoolsOptions, pt as linters, q as SchemaHook, r as Generator, rt as definePlugin, s as AdapterSource, st as createKubb, t as PluginDriver, tt as HookStylePlugin, u as CompatibilityPreset, ut as Storage, v as InputData, vt as AsyncEventEmitter, w as LoggerContext, x as KubbBuildStartContext, y as InputPath, z as ResolveNameParams } from "./PluginDriver-D8lWvtUg.js";
+import { $ as FileManager, A as PluginParameter, B as ResolverFileParams, C as Output, D as PluginFactoryOptions, E as PluginContext, F as ResolveOptionsContext, G as UserPlugin, H as SchemaHook, I as ResolvePathOptions, J as Kubb, K as UserPluginWithLifeCycle, L as ResolvePathParams, M as PossibleConfig, N as ResolveBannerContext, O as PluginLifecycle, P as ResolveNameParams, Q as PluginDriver, R as Resolver, S as OperationsHook, T as Plugin, U as UserGroup, V as ResolverPathParams, W as UserLogger, X as BuildOutput, Y as KubbHooks, Z as createKubb, _ as KubbPluginSetupContext, a as CLIOptions, at as Generator, b as LoggerOptions, c as DevtoolsOptions, ct as createStorage, d as Group, dt as createRenderer, et as HookStylePlugin, f as Include, ft as logLevel, g as KubbBuildStartContext, h as KubbBuildEndContext, i as BarrelType, it as defineParser, j as PluginWithLifeCycle, k as PluginLifecycleHooks, l as Exclude, lt as Renderer, m as InputPath, n as AdapterFactoryOptions, nt as definePlugin, o as CompatibilityPreset, ot as defineGenerator, p as InputData, pt as AsyncEventEmitter, q as FileMetaBase, r as AdapterSource, rt as Parser, s as Config, st as Storage, t as Adapter, tt as PluginHooks, u as GeneratorContext, ut as RendererFactory, v as Logger, w as Override, x as OperationHook, y as LoggerContext, z as ResolverContext } from "./types-DUc5lEUp.js";
 import * as ast from "@kubb/ast";
-import { FileNode, InputNode, Node, composeTransformers, definePrinter } from "@kubb/ast";
+import { FileNode, InputNode, Node } from "@kubb/ast";
 
 //#region ../../internals/utils/src/urlPath.d.ts
 type URLObject = {
@@ -33,7 +33,7 @@ type ObjectOptions = {
  * Supported identifier casing strategies for path parameters.
  */
 type PathCasing = 'camelcase';
-type Options$1 = {
+type Options = {
   /**
    * Casing strategy applied to path parameter names.
    * @default undefined (original identifier preserved)
@@ -54,7 +54,7 @@ declare class URLPath {
    * The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`.
    */
   path: string;
-  constructor(path: string, options?: Options$1);
+  constructor(path: string, options?: Options);
   /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`.
    *
    * @example
@@ -161,32 +161,6 @@ type AdapterBuilder<T extends AdapterFactoryOptions> = (options: T['options']) =
  */
 declare function createAdapter<T extends AdapterFactoryOptions = AdapterFactoryOptions>(build: AdapterBuilder<T>): (options?: T['options']) => Adapter<T>;
 //#endregion
-//#region src/createPlugin.d.ts
-/**
- * Builder type for a {@link UserPluginWithLifeCycle} — takes options and returns the plugin instance.
- */
-type PluginBuilder<T extends PluginFactoryOptions = PluginFactoryOptions> = (options: T['options']) => UserPluginWithLifeCycle<T>;
-/**
- * Creates a plugin factory. Call the returned function with optional options to get the plugin instance.
- *
- * @example
- * ```ts
- * export const myPlugin = createPlugin<MyPlugin>((options) => {
- *   return {
- *     name: 'my-plugin',
- *     get options() { return options },
- *     resolvePath(baseName) { ... },
- *     resolveName(name, type) { ... },
- *   }
- * })
- *
- * // instantiate
- * const plugin = myPlugin({ output: { path: 'src/gen' } })
- * ```
- * @deprecated use definePlugin instead
- */
-declare function createPlugin<T extends PluginFactoryOptions = PluginFactoryOptions>(build: PluginBuilder<T>): (options?: T['options']) => UserPluginWithLifeCycle<T>;
-//#endregion
 //#region src/defineLogger.d.ts
 /**
  * Wraps a logger definition into a typed {@link Logger}.
@@ -236,177 +210,6 @@ type ResolverBuilder<T extends PluginFactoryOptions> = () => Omit<T['resolver'],
  * // → { enumType: 'enum' } when operationId matches
  * ```
  */
-declare function defaultResolveOptions<TOptions>(node: Node, {
-  options,
-  exclude,
-  include,
-  override
-}: ResolveOptionsContext<TOptions>): TOptions | null;
-/**
- * Default path resolver used by `defineResolver`.
- *
- * - Returns the output directory in `single` mode.
- * - Resolves into a tag- or path-based subdirectory when `group` and a `tag`/`path` value are provided.
- * - Falls back to a flat `output/baseName` path otherwise.
- *
- * A custom `group.name` function overrides the default subdirectory naming.
- * For `tag` groups the default is `${camelCase(tag)}Controller`.
- * For `path` groups the default is the first path segment after `/`.
- *
- * @example Flat output
- * ```ts
- * defaultResolvePath({ baseName: 'petTypes.ts' }, { root: '/src', output: { path: 'types' } })
- * // → '/src/types/petTypes.ts'
- * ```
- *
- * @example Tag-based grouping
- * ```ts
- * defaultResolvePath(
- *   { baseName: 'petTypes.ts', tag: 'pets' },
- *   { root: '/src', output: { path: 'types' }, group: { type: 'tag' } },
- * )
- * // → '/src/types/petsController/petTypes.ts'
- * ```
- *
- * @example Path-based grouping
- * ```ts
- * defaultResolvePath(
- *   { baseName: 'petTypes.ts', path: '/pets/list' },
- *   { root: '/src', output: { path: 'types' }, group: { type: 'path' } },
- * )
- * // → '/src/types/pets/petTypes.ts'
- * ```
- *
- * @example Single-file mode
- * ```ts
- * defaultResolvePath(
- *   { baseName: 'petTypes.ts', pathMode: 'single' },
- *   { root: '/src', output: { path: 'types' } },
- * )
- * // → '/src/types'
- * ```
- */
-declare function defaultResolvePath({
-  baseName,
-  pathMode,
-  tag,
-  path: groupPath
-}: ResolverPathParams, {
-  root,
-  output,
-  group
-}: ResolverContext): string;
-/**
- * Default file resolver used by `defineResolver`.
- *
- * Resolves a `FileNode` by combining name resolution (`resolver.default`) with
- * path resolution (`resolver.resolvePath`). The resolved file always has empty
- * `sources`, `imports`, and `exports` arrays — consumers populate those separately.
- *
- * In `single` mode the name is omitted and the file sits directly in the output directory.
- *
- * @example Resolve a schema file
- * ```ts
- * const file = defaultResolveFile.call(resolver,
- *   { name: 'pet', extname: '.ts' },
- *   { root: '/src', output: { path: 'types' } },
- * )
- * // → { baseName: 'pet.ts', path: '/src/types/pet.ts', sources: [], ... }
- * ```
- *
- * @example Resolve an operation file with tag grouping
- * ```ts
- * const file = defaultResolveFile.call(resolver,
- *   { name: 'listPets', extname: '.ts', tag: 'pets' },
- *   { root: '/src', output: { path: 'types' }, group: { type: 'tag' } },
- * )
- * // → { baseName: 'listPets.ts', path: '/src/types/petsController/listPets.ts', ... }
- * ```
- */
-declare function defaultResolveFile(this: Resolver, {
-  name,
-  extname,
-  tag,
-  path: groupPath
-}: ResolverFileParams, context: ResolverContext): FileNode;
-/**
- * Generates the default "Generated by Kubb" banner from config and optional node metadata.
- */
-declare function buildDefaultBanner({
-  title,
-  description,
-  version,
-  config
-}: {
-  title?: string;
-  description?: string;
-  version?: string;
-  config: Config;
-}): string;
-/**
- * Default banner resolver — returns the banner string for a generated file.
- *
- * A user-supplied `output.banner` overrides the default Kubb "Generated by Kubb" notice.
- * When no `output.banner` is set, the Kubb notice is used (including `title` and `version`
- * from the OAS spec when a `node` is provided).
- *
- * - When `output.banner` is a function and `node` is provided, returns `output.banner(node)`.
- * - When `output.banner` is a function and `node` is absent, falls back to the Kubb notice.
- * - When `output.banner` is a string, returns it directly.
- * - When `config.output.defaultBanner` is `false`, returns `undefined`.
- * - Otherwise returns the Kubb "Generated by Kubb" notice.
- *
- * @example String banner overrides default
- * ```ts
- * defaultResolveBanner(undefined, { output: { banner: '// my banner' }, config })
- * // → '// my banner'
- * ```
- *
- * @example Function banner with node
- * ```ts
- * defaultResolveBanner(inputNode, { output: { banner: (node) => `// v${node.version}` }, config })
- * // → '// v3.0.0'
- * ```
- *
- * @example No user banner — Kubb notice with OAS metadata
- * ```ts
- * defaultResolveBanner(inputNode, { config })
- * // → '/** Generated by Kubb ... Title: Pet Store ... *\/'
- * ```
- *
- * @example Disabled default banner
- * ```ts
- * defaultResolveBanner(undefined, { config: { output: { defaultBanner: false }, ...config } })
- * // → undefined
- * ```
- */
-declare function defaultResolveBanner(node: InputNode | undefined, {
-  output,
-  config
-}: ResolveBannerContext): string | undefined;
-/**
- * Default footer resolver — returns the footer string for a generated file.
- *
- * - When `output.footer` is a function and `node` is provided, calls it with the node.
- * - When `output.footer` is a function and `node` is absent, returns `undefined`.
- * - When `output.footer` is a string, returns it directly.
- * - Otherwise returns `undefined`.
- *
- * @example String footer
- * ```ts
- * defaultResolveFooter(undefined, { output: { footer: '// end of file' }, config })
- * // → '// end of file'
- * ```
- *
- * @example Function footer with node
- * ```ts
- * defaultResolveFooter(inputNode, { output: { footer: (node) => `// ${node.title}` }, config })
- * // → '// Pet Store'
- * ```
- */
-declare function defaultResolveFooter(node: InputNode | undefined, {
-  output
-}: ResolveBannerContext): string | undefined;
 /**
  * Defines a resolver for a plugin, injecting built-in defaults for name casing,
  * include/exclude/override filtering, path resolution, and file construction.
@@ -455,6 +258,46 @@ declare function defaultResolveFooter(node: InputNode | undefined, {
  */
 declare function defineResolver<T extends PluginFactoryOptions>(build: ResolverBuilder<T>): T['resolver'];
 //#endregion
+//#region src/FileProcessor.d.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;
+};
+/**
+ * Converts a single file to a string using the registered parsers.
+ * Falls back to joining source values when no matching parser is found.
+ */
+declare class FileProcessor {
+  #private;
+  parse(file: FileNode, {
+    parsers,
+    extension
+  }?: ParseOptions): Promise<string>;
+  run(files: Array<FileNode>, {
+    parsers,
+    mode,
+    extension,
+    onStart,
+    onEnd,
+    onUpdate
+  }?: RunOptions): Promise<Array<FileNode>>;
+}
+//#endregion
 //#region src/storages/fsStorage.d.ts
 /**
  * Built-in filesystem storage driver.
@@ -501,126 +344,11 @@ declare const fsStorage: (options?: Record<string, never> | undefined) => Storag
  */
 declare const memoryStorage: (options?: Record<string, never> | undefined) => Storage;
 //#endregion
-//#region src/utils/formatters.d.ts
-type Formatter = keyof typeof formatters;
-/**
- * Detects the first available code formatter on the current system.
- *
- * - Checks in preference order: `biome`, `oxfmt`, `prettier`.
- * - Returns `null` when none are found.
- *
- * @example
- * ```ts
- * const formatter = await detectFormatter()
- * if (formatter) {
- *   console.log(`Using ${formatter} for formatting`)
- * }
- * ```
- */
-declare function detectFormatter(): Promise<Formatter | null>;
-//#endregion
-//#region src/utils/getFunctionParams.d.ts
-type Param = {
-  /**
-   * Controls how path parameters are emitted in the function signature.
-   * - `'object'` groups them as a single destructured parameter.
-   * - `'inline'` spreads them as individual comma-separated parameters.
-   * - `'inlineSpread'` emits a single rest parameter.
-   *
-   * @default 'inline'
-   * @internal
-   */
-  mode?: 'object' | 'inline' | 'inlineSpread';
-  type?: 'string' | 'number' | (string & {});
-  optional?: boolean;
-  /**
-   * Default value expression for the parameter.
-   *
-   * @example Assignment syntax
-   * `test = "default"`
-   */
-  default?: string;
-  /**
-   * Used for no TypeScript (with mode object).
-   *
-   * @example Value syntax
-   * `test: "default"`
-   */
-  value?: string;
-  children?: Params;
-};
-type Params = Record<string, Param | undefined>;
-type Options = {
-  type: 'constructor' | 'call' | 'object' | 'objectValue';
-  transformName?: (name: string) => string;
-  transformType?: (type: string) => string;
-};
-declare function getFunctionParams(params: Params, options: Options): string;
-/**
- * @deprecated use @kubb/ast
- */
-declare function createFunctionParams(params: Params): Params;
-/**
- * @deprecated use @kubb/ast
- */
-declare class FunctionParams {
-  #private;
-  static factory(params: Params): FunctionParams;
-  constructor(params: Params);
-  get params(): Params;
-  get flatParams(): Params;
-  toCall({
-    transformName,
-    transformType
-  }?: Pick<Options, 'transformName' | 'transformType'>): string;
-  toObject(): string;
-  toObjectValue(): string;
-  toConstructor(): string;
-}
-//#endregion
 //#region src/utils/isInputPath.d.ts
 /**
  * Type guard to check if a given config has an `input.path`.
  */
 declare function isInputPath(config: Config | undefined): config is Config<InputPath>;
 //#endregion
-//#region src/utils/linters.d.ts
-type Linter = keyof typeof linters;
-/**
- * Detects the first available linter on the current system.
- *
- * - Checks in preference order: `biome`, `oxlint`, `eslint`.
- * - Returns `null` when none are found.
- *
- * @example
- * ```ts
- * const linter = await detectLinter()
- * if (linter) {
- *   console.log(`Using ${linter} for linting`)
- * }
- * ```
- */
-declare function detectLinter(): Promise<Linter | null>;
-//#endregion
-//#region src/utils/packageJSON.d.ts
-type DependencyName = string;
-type DependencyVersion = string;
-/**
- * Returns `true` when the nearest `package.json` declares a dependency that
- * satisfies the given semver range.
- *
- * - Searches both `dependencies` and `devDependencies`.
- * - Accepts a string package name or a `RegExp` to match scoped/pattern packages.
- * - Uses `semver.satisfies` for range comparison; returns `false` when the
- *   version string cannot be coerced into a valid semver.
- *
- * @example
- * ```ts
- * satisfiesDependency('react', '>=18')          // true when react@18.x is installed
- * satisfiesDependency(/^@tanstack\//, '>=5')    // true when any @tanstack/* >=5 is found
- * ```
- */
-declare function satisfiesDependency(dependency: DependencyName | RegExp, version: DependencyVersion, cwd?: string): boolean;
-//#endregion
-export { Adapter, AdapterFactoryOptions, AdapterSource, AsyncEventEmitter, BarrelType, BuildOutput, CLIOptions, CompatibilityPreset, Config, ConfigInput, DevtoolsOptions, Exclude, FileMetaBase, FunctionParams, type FunctionParamsAST, Generator, GeneratorContext, Group, HookStylePlugin, Include, InputData, InputPath, Kubb, KubbBuildEndContext, KubbBuildStartContext, KubbHooks, KubbPluginSetupContext, Logger, LoggerContext, LoggerOptions, OperationHook, OperationsHook, Output, Override, type Param, type Params, Parser, Plugin, PluginContext, PluginDriver, PluginFactoryOptions, PluginHooks, PluginLifecycle, PluginLifecycleHooks, PluginParameter, PluginWithLifeCycle, PossibleConfig, Renderer, RendererFactory, ResolveBannerContext, ResolveNameParams, ResolveOptionsContext, ResolvePathOptions, ResolvePathParams, Resolver, ResolverContext, ResolverFileParams, ResolverPathParams, SchemaHook, Storage, URLPath, UserGroup, UserLogger, UserPlugin, UserPluginWithLifeCycle, ast, buildDefaultBanner, composeTransformers, createAdapter, createFunctionParams, createKubb, createPlugin, createRenderer, createStorage, defaultResolveBanner, defaultResolveFile, defaultResolveFooter, defaultResolveOptions, defaultResolvePath, defineGenerator, defineLogger, defineParser, definePlugin, definePrinter, defineResolver, detectFormatter, detectLinter, formatters, fsStorage, getBarrelFiles, getFunctionParams, getMode, isInputPath, linters, logLevel, memoryStorage, satisfiesDependency };
+export { Adapter, AdapterFactoryOptions, AdapterSource, AsyncEventEmitter, BarrelType, BuildOutput, CLIOptions, CompatibilityPreset, Config, DevtoolsOptions, Exclude, FileManager, FileMetaBase, FileProcessor, Generator, GeneratorContext, Group, HookStylePlugin, Include, InputData, InputPath, Kubb, KubbBuildEndContext, KubbBuildStartContext, KubbHooks, KubbPluginSetupContext, Logger, LoggerContext, LoggerOptions, OperationHook, OperationsHook, Output, Override, Parser, Plugin, PluginContext, PluginDriver, PluginFactoryOptions, PluginHooks, PluginLifecycle, PluginLifecycleHooks, PluginParameter, PluginWithLifeCycle, PossibleConfig, Renderer, RendererFactory, ResolveBannerContext, ResolveNameParams, ResolveOptionsContext, ResolvePathOptions, ResolvePathParams, Resolver, ResolverContext, ResolverFileParams, ResolverPathParams, SchemaHook, Storage, URLPath, UserGroup, UserLogger, UserPlugin, UserPluginWithLifeCycle, ast, createAdapter, createKubb, createRenderer, createStorage, defineGenerator, defineLogger, defineParser, definePlugin, defineResolver, fsStorage, isInputPath, logLevel, memoryStorage };
 //# sourceMappingURL=index.d.ts.map