@kubb/core 5.0.0-beta.75 → 5.0.0-beta.76

package/dist/index.d.ts

@@ -1,18 +1,35 @@
-import { t as __name } from "./chunk--u3MIqq1.js";
-import { $ as defineParser, A as KubbPluginStartContext, B as Override, C as KubbGenerationSummaryContext, D as KubbLifecycleStartContext, E as KubbInfoContext, F as Logger, G as ResolveOptionsContext, H as PossibleConfig, I as LoggerContext, J as ResolverFileParams, K as Resolver, L as LoggerOptions, M as KubbSuccessContext, N as KubbVersionNewContext, O as KubbPluginEndContext, P as KubbWarnContext, Q as Parser, R as NormalizedPlugin, S as KubbGenerationStartContext, T as KubbHookStartContext, U as ResolveBannerContext, V as PluginFactoryOptions, W as ResolveNameParams, X as UserConfig, Y as ResolverPathParams, Z as UserLogger, _ as KubbErrorContext, _t as logLevel, a as Config, at as createKubb, b as KubbFilesProcessingStartContext, c as GeneratorContext, ct as Plugin, d as InputData, dt as defineGenerator, et as Middleware, f as InputPath, ft as Storage, g as KubbDebugContext, gt as createRenderer, h as KubbConfigEndContext, ht as RendererFactory, i as CLIOptions, it as BuildOutput, j as KubbPluginsEndContext, k as KubbPluginSetupContext, l as Group, lt as definePlugin, m as KubbBuildStartContext, mt as Renderer, n as AdapterFactoryOptions, nt as Kubb, o as DevtoolsOptions, ot as PluginDriver, p as KubbBuildEndContext, pt as createStorage, q as ResolverContext, r as AdapterSource, rt as KubbHooks, s as Exclude, st as FileManager, t as Adapter, tt as defineMiddleware, u as Include, ut as Generator, v as KubbFileProcessingUpdateContext, vt as AsyncEventEmitter, w as KubbHookEndContext, x as KubbGenerationEndContext, y as KubbFilesProcessingEndContext, z as Output } from "./types-CuNocrbJ.js";
-import * as ast from "@kubb/ast";
-import { FileNode, InputNode, Node } from "@kubb/ast";
+import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
+import { $ as KubbPluginSetupContext, A as KubbHookStartContext, At as Adapter, B as ParsedFile, C as KubbFilesProcessingEndContext, Ct as GenerationResult, D as KubbGenerationStartContext, Dt as UserReporter, E as KubbGenerationEndContext, Et as ReporterName, F as KubbSuccessContext, G as Generator, H as createKubb, I as KubbWarnContext, J as KubbDriver, K as GeneratorContext, L as PossibleConfig, M as KubbInfoContext, Mt as AdapterSource, N as KubbLifecycleStartContext, Nt as createAdapter, O as KubbHookEndContext, Ot as createReporter, P as KubbPluginsEndContext, Pt as AsyncEventEmitter, Q as KubbPluginEndContext, R as UserConfig, S as KubbFileProcessingUpdate, St as createStorage, T as KubbFilesProcessingUpdateContext, Tt as ReporterContext, U as Parser, V as Kubb, W as defineParser, X as Group, Y as Exclude, Z as Include, _ as InputPath, _t as defineResolver, a as DiagnosticLocation, at as Override, b as KubbDiagnosticContext, bt as createRenderer, c as PerformanceDiagnostic, ct as definePlugin, d as SerializedDiagnostic, dt as ResolveBannerFile, et as KubbPluginStartContext, f as UpdateDiagnostic, ft as ResolveOptionsContext, g as InputData, gt as ResolverPathParams, h as Config, ht as ResolverFileParams, i as DiagnosticKind, it as OutputOptions, j as KubbHooks, jt as AdapterFactoryOptions, k as KubbHookLineContext, kt as logLevel, l as ProblemCode, lt as BannerMeta, m as CLIOptions, mt as ResolverContext, n as DiagnosticByCode, nt as Output, o as DiagnosticSeverity, ot as Plugin, p as BuildOutput, pt as Resolver, q as defineGenerator, r as DiagnosticDoc, rt as OutputMode, s as Diagnostics, st as PluginFactoryOptions, t as Diagnostic, tt as NormalizedPlugin, u as ProblemDiagnostic, ut as ResolveBannerContext, v as KubbBuildEndContext, vt as Renderer, w as KubbFilesProcessingStartContext, wt as Reporter, x as KubbErrorContext, xt as Storage, y as KubbBuildStartContext, yt as RendererFactory, z as FileProcessorHooks } from "./diagnostics-CQYd4UQZ.js";
+import { ast } from "@kubb/ast";
 
-//#region ../../internals/utils/src/urlPath.d.ts
+//#region ../../internals/utils/src/url.d.ts
 type URLObject = {
   /**
    * The resolved URL string (Express-style or template literal, depending on context).
    */
   url: string;
   /**
-   * Extracted path parameters as a key-value map, or `undefined` when the path has none.
+   * Extracted path parameters as a key-value map, or `null` when the path has none.
    */
-  params?: Record<string, string>;
+  params: Record<string, string> | null;
+};
+/**
+ * Supported identifier casing strategies for path parameters.
+ */
+type PathCasing = 'camelcase';
+type TemplateOptions = {
+  /**
+   * Literal text prepended inside the template literal, e.g. a base URL.
+   */
+  prefix?: string | null;
+  /**
+   * Transform applied to each extracted parameter name before interpolation.
+   */
+  replacer?: (pathParam: string) => string;
+  /**
+   * Casing strategy applied to path parameter names.
+   */
+  casing?: PathCasing;
 };
 type ObjectOptions = {
   /**
@@ -21,298 +38,90 @@ type ObjectOptions = {
    */
   type?: 'path' | 'template';
   /**
-   * Optional transform applied to each extracted parameter name.
+   * Transform applied to each extracted parameter name.
    */
   replacer?: (pathParam: string) => string;
   /**
    * When `true`, the result is serialized to a string expression instead of a plain object.
    */
   stringify?: boolean;
-};
-/**
- * Supported identifier casing strategies for path parameters.
- */
-type PathCasing = 'camelcase';
-type Options = {
   /**
    * Casing strategy applied to path parameter names.
-   * @default undefined (original identifier preserved)
    */
   casing?: PathCasing;
 };
 /**
- * Parses and transforms an OpenAPI/Swagger path string into various URL formats.
- *
- * @example
- * const p = new URLPath('/pet/{petId}')
- * p.URL      // '/pet/:petId'
- * p.template // '`/pet/${petId}`'
+ * Helpers for OpenAPI/Swagger paths, plus a thin wrapper over the native `URL`.
  */
-declare class URLPath {
-  #private;
+declare class Url {
   /**
-   * The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`.
-   */
-  path: string;
-  constructor(path: string, options?: Options);
-  /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`.
-   *
-   * @example
-   * ```ts
-   * new URLPath('/pet/{petId}').URL // '/pet/:petId'
-   * ```
-   */
-  get URL(): string;
-  /** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`).
+   * Converts an OpenAPI/Swagger path to Express-style colon syntax.
    *
    * @example
-   * ```ts
-   * new URLPath('https://petstore.swagger.io/v2/pet').isURL // true
-   * new URLPath('/pet/{petId}').isURL                       // false
-   * ```
+   * Url.toPath('/pet/{petId}') // '/pet/:petId'
    */
-  get isURL(): boolean;
+  static toPath(path: string): string;
   /**
-   * Converts the OpenAPI path to a TypeScript template literal string.
+   * Converts an OpenAPI/Swagger path to a TypeScript template literal string.
+   * `prefix` is prepended inside the literal, `replacer` transforms each parameter name,
+   * and `casing` controls parameter identifier casing.
    *
    * @example
-   * new URLPath('/pet/{petId}').template              // '`/pet/${petId}`'
-   * new URLPath('/account/monetary-accountID').template // '`/account/${monetaryAccountId}`'
-   */
-  get template(): string;
-  /** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set.
+   * Url.toTemplateString('/pet/{petId}') // '`/pet/${petId}`'
    *
    * @example
-   * ```ts
-   * new URLPath('/pet/{petId}').object
-   * // { url: '/pet/:petId', params: { petId: 'petId' } }
-   * ```
+   * Url.toTemplateString('/pet/{petId}', { prefix: 'https://api' }) // '`https://api/pet/${petId}`'
    */
-  get object(): URLObject | string;
-  /** Returns a map of path parameter names, or `undefined` when the path has no parameters.
+  static toTemplateString(path: string, {
+    prefix,
+    replacer,
+    casing
+  }?: TemplateOptions): string;
+  /**
+   * Returns the path and its extracted params as a structured `URLObject`, or as a stringified
+   * expression when `stringify` is set.
    *
    * @example
-   * ```ts
-   * new URLPath('/pet/{petId}').params // { petId: 'petId' }
-   * new URLPath('/pet').params         // undefined
-   * ```
+   * Url.toObject('/pet/{petId}')
+   * // { url: '/pet/:petId', params: { petId: 'petId' } }
    */
-  get params(): Record<string, string> | undefined;
-  toObject({
+  static toObject(path: string, {
     type,
     replacer,
-    stringify
+    stringify,
+    casing
   }?: ObjectOptions): URLObject | string;
-  /**
-   * Converts the OpenAPI path to a TypeScript template literal string.
-   * An optional `replacer` can transform each extracted parameter name before interpolation.
-   *
-   * @example
-   * new URLPath('/pet/{petId}').toTemplateString() // '`/pet/${petId}`'
-   */
-  toTemplateString({
-    prefix,
-    replacer
-  }?: {
-    prefix?: string;
-    replacer?: (pathParam: string) => string;
-  }): string;
-  /**
-   * Extracts all `{param}` segments from the path and returns them as a key-value map.
-   * An optional `replacer` transforms each parameter name in both key and value positions.
-   * Returns `undefined` when no path parameters are found.
-   *
-   * @example
-   * ```ts
-   * new URLPath('/pet/{petId}/tag/{tagId}').getParams()
-   * // { petId: 'petId', tagId: 'tagId' }
-   * ```
-   */
-  getParams(replacer?: (pathParam: string) => string): Record<string, string> | undefined;
-  /** Converts the OpenAPI path to Express-style colon syntax.
-   *
-   * @example
-   * ```ts
-   * new URLPath('/pet/{petId}').toURLPath() // '/pet/:petId'
-   * ```
-   */
-  toURLPath(): string;
 }
 //#endregion
-//#region src/createAdapter.d.ts
-type AdapterBuilder<T extends AdapterFactoryOptions> = (options: T['options']) => Adapter<T>;
+//#region src/reporters/cliReporter.d.ts
 /**
- * Factory for implementing custom adapters that translate non-OpenAPI specs into Kubb's AST.
- *
- * Use this to support GraphQL schemas, gRPC definitions, AsyncAPI, or custom domain-specific languages.
- * Built-in adapters include `@kubb/adapter-oas` for OpenAPI and Swagger documents.
- *
- * @note Adapters must parse their input format to Kubb's `InputNode` structure.
- *
- * @example
- * ```ts
- * export const myAdapter = createAdapter<MyAdapter>((options) => {
- *   return {
- *     name: 'my-adapter',
- *     options,
- *     async parse(source) {
- *       // Transform source format to InputNode
- *       return { ... }
- *     },
- *   }
- * })
- *
- * // Instantiate:
- * const adapter = myAdapter({ validate: true })
- * ```
+ * The default `cli` reporter. Renders the {@link Report} for each config as it finishes, independent
+ * of the live logger view. Suppressed at `silent`. The `verbose` level adds the per-plugin timings.
  */
-declare function createAdapter<T extends AdapterFactoryOptions = AdapterFactoryOptions>(build: AdapterBuilder<T>): (options?: T['options']) => Adapter<T>;
+declare const cliReporter: Reporter;
 //#endregion
-//#region src/defineLogger.d.ts
+//#region src/reporters/fileReporter.d.ts
 /**
- * Wraps a logger definition into a typed {@link Logger}.
- *
- * @example
- * ```ts
- * export const myLogger = defineLogger({
- *   name: 'my-logger',
- *   install(context, options) {
- *     context.on('kubb:info', (message) => console.log('ℹ', message))
- *     context.on('kubb:error', (error) => console.error('✗', error.message))
- *   },
- * })
- * ```
+ * The `file` reporter. Writes a config's {@link Report} to `.kubb/kubb-<name>-<timestamp>.log` as a
+ * plain-text document: a `# <name> — <timestamp>` header, a `## Summary` with the same counts the
+ * cli and json reporters expose, a `## Problems` section in the miette block format, and a
+ * `## Timings` section. Selected with `--reporter file` (or `reporters: ['file']`).
+ *
+ * @note It captures the collected diagnostics once a config finishes, not the live
+ * `kubb:info`/`kubb:plugin` event stream. Color is stripped so the file stays plain text even when
+ * the run is attached to a TTY.
  */
-declare function defineLogger<Options extends LoggerOptions = LoggerOptions>(logger: UserLogger<Options>): Logger<Options>;
+declare const fileReporter: Reporter;
 //#endregion
-//#region src/defineResolver.d.ts
-/**
- * Builder type for the plugin-specific resolver fields.
- *
- * `default`, `resolveOptions`, `resolvePath`, `resolveFile`, `resolveBanner`, and `resolveFooter`
- * are optional — built-in fallbacks are injected when omitted.
- *
- * The builder receives `ctx` — a reference to the fully assembled resolver — so methods can
- * call sibling resolver methods without using `this`.  Because `ctx` is captured by the closure
- * and the resolver is populated after the builder runs, `ctx` correctly reflects any overrides
- * that were applied by the builder itself.
- */
-type ResolverBuilder<T extends PluginFactoryOptions> = (ctx: T['resolver']) => Omit<T['resolver'], 'default' | 'resolveOptions' | 'resolvePath' | 'resolveFile' | 'resolveBanner' | 'resolveFooter' | 'name' | 'pluginName'> & Partial<Pick<T['resolver'], 'default' | 'resolveOptions' | 'resolvePath' | 'resolveFile' | 'resolveBanner' | 'resolveFooter'>> & {
-  name: string;
-  pluginName: T['name'];
-};
+//#region src/reporters/jsonReporter.d.ts
 /**
- * Default option resolver — applies include/exclude filters and merges matching override options.
- *
- * Returns `null` when the node is filtered out by an `exclude` rule or not matched by any `include` rule.
- *
- * @example Include/exclude filtering
- * ```ts
- * const options = defaultResolveOptions(operationNode, {
- *   options: { output: 'types' },
- *   exclude: [{ type: 'tag', pattern: 'internal' }],
- * })
- * // → null when node has tag 'internal'
- * ```
- *
- * @example Override merging
- * ```ts
- * const options = defaultResolveOptions(operationNode, {
- *   options: { enumType: 'asConst' },
- *   override: [{ type: 'operationId', pattern: 'listPets', options: { enumType: 'enum' } }],
- * })
- * // → { enumType: 'enum' } when operationId matches
- * ```
+ * The `json` reporter. `report` returns one config's {@link Report}, which {@link createReporter}
+ * buffers, and `drain` writes them as a single pretty-printed JSON array on `kubb:lifecycle:end`.
+ * Buffering keeps a multi-config run one valid JSON document on stdout instead of concatenated
+ * objects that would break `jq .`. The terminal reporter is suppressed while `json` is active so
+ * stdout stays valid JSON.
  */
-/**
- * Defines a resolver for a plugin, injecting built-in defaults for name casing,
- * include/exclude/override filtering, path resolution, and file construction.
- *
- * All four defaults can be overridden by providing them in the builder function:
- * - `default` — name casing strategy (camelCase / PascalCase)
- * - `resolveOptions` — include/exclude/override filtering
- * - `resolvePath` — output path computation
- * - `resolveFile` — full `FileNode` construction
- *
- * The builder receives `ctx` — a reference to the assembled resolver — so methods can
- * call sibling resolver methods using `ctx` instead of `this`.
- *
- * @example Basic resolver with naming helpers
- * ```ts
- * export const resolver = defineResolver<PluginTs>((ctx) => ({
- *   name: 'default',
- *   resolveName(node) {
- *     return ctx.default(node.name, 'function')
- *   },
- *   resolveTypedName(node) {
- *     return ctx.default(node.name, 'type')
- *   },
- * }))
- * ```
- *
- * @example Override resolvePath for a custom output structure
- * ```ts
- * export const resolver = defineResolver<PluginTs>((_ctx) => ({
- *   name: 'custom',
- *   resolvePath({ baseName }, { root, output }) {
- *     return path.resolve(root, output.path, 'generated', baseName)
- *   },
- * }))
- * ```
- *
- * @example Use ctx.default inside a helper
- * ```ts
- * export const resolver = defineResolver<PluginTs>((ctx) => ({
- *   name: 'default',
- *   resolveParamName(node, param) {
- *     return ctx.default(`${node.operationId} ${param.in} ${param.name}`, 'type')
- *   },
- * }))
- * ```
- */
-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.
- *
- * @internal
- */
-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>>;
-}
+declare const jsonReporter: Reporter;
 //#endregion
 //#region src/storages/fsStorage.d.ts
 /**
@@ -322,11 +131,11 @@ declare class FileProcessor {
  * Keys are resolved against `process.cwd()`, so root-relative paths such as
  * `src/gen/api/getPets.ts` are written to the correct location without extra configuration.
  *
- * Internally uses the `write` utility from `@internals/utils`, which:
- * - trims leading/trailing whitespace before writing
- * - skips the write when file content is already identical (deduplication)
- * - creates missing parent directories automatically
- * - supports Bun's native file API when running under Bun
+ * Writes are deduplicated and directory-safe:
+ * - leading and trailing whitespace is trimmed before writing
+ * - the write is skipped when the file content is already identical
+ * - missing parent directories are created automatically
+ * - Bun's native file API is used when running under Bun
  *
  * @example
  * ```ts
@@ -364,12 +173,5 @@ declare const fsStorage: (options?: Record<string, never> | undefined) => Storag
  */
 declare const memoryStorage: (options?: Record<string, never> | undefined) => Storage;
 //#endregion
-//#region src/utils/isInputPath.d.ts
-/**
- * Type guard to check if a given config has an `input.path`.
- */
-declare function isInputPath(config: UserConfig | undefined): config is UserConfig<InputPath>;
-declare function isInputPath(config: Config | undefined): config is Config<InputPath>;
-//#endregion
-export { Adapter, AdapterFactoryOptions, AdapterSource, AsyncEventEmitter, BuildOutput, CLIOptions, Config, DevtoolsOptions, Exclude, FileManager, FileProcessor, Generator, GeneratorContext, Group, Include, InputData, InputPath, Kubb, KubbBuildEndContext, KubbBuildStartContext, KubbConfigEndContext, KubbDebugContext, KubbErrorContext, KubbFileProcessingUpdateContext, KubbFilesProcessingEndContext, KubbFilesProcessingStartContext, KubbGenerationEndContext, KubbGenerationStartContext, KubbGenerationSummaryContext, KubbHookEndContext, KubbHookStartContext, KubbHooks, KubbInfoContext, KubbLifecycleStartContext, KubbPluginEndContext, KubbPluginSetupContext, KubbPluginStartContext, KubbPluginsEndContext, KubbSuccessContext, KubbVersionNewContext, KubbWarnContext, Logger, LoggerContext, LoggerOptions, Middleware, NormalizedPlugin, Output, Override, Parser, Plugin, PluginDriver, PluginFactoryOptions, PossibleConfig, Renderer, RendererFactory, ResolveBannerContext, ResolveNameParams, ResolveOptionsContext, Resolver, ResolverContext, ResolverFileParams, ResolverPathParams, Storage, URLPath, UserConfig, UserLogger, ast, createAdapter, createKubb, createRenderer, createStorage, defineGenerator, defineLogger, defineMiddleware, defineParser, definePlugin, defineResolver, fsStorage, isInputPath, logLevel, memoryStorage };
+export { type Adapter, type AdapterFactoryOptions, type AdapterSource, AsyncEventEmitter, type BannerMeta, BuildOutput, CLIOptions, Config, type Diagnostic, type DiagnosticByCode, type DiagnosticDoc, type DiagnosticKind, type DiagnosticLocation, type DiagnosticSeverity, Diagnostics, type Exclude, type FileProcessorHooks, type GenerationResult, type Generator, type GeneratorContext, type Group, type Include, InputData, InputPath, type Kubb, KubbBuildEndContext, KubbBuildStartContext, KubbDiagnosticContext, KubbDriver, KubbErrorContext, KubbFileProcessingUpdate, KubbFilesProcessingEndContext, KubbFilesProcessingStartContext, KubbFilesProcessingUpdateContext, KubbGenerationEndContext, KubbGenerationStartContext, KubbHookEndContext, KubbHookLineContext, KubbHookStartContext, KubbHooks, KubbInfoContext, KubbLifecycleStartContext, type KubbPluginEndContext, type KubbPluginSetupContext, type KubbPluginStartContext, KubbPluginsEndContext, KubbSuccessContext, KubbWarnContext, type NormalizedPlugin, type Output, type OutputMode, type OutputOptions, type Override, type ParsedFile, type Parser, type PerformanceDiagnostic, type Plugin, type PluginFactoryOptions, PossibleConfig, type ProblemCode, type ProblemDiagnostic, type Renderer, type RendererFactory, type Reporter, type ReporterContext, type ReporterName, type ResolveBannerContext, type ResolveBannerFile, type ResolveOptionsContext, type Resolver, type ResolverContext, type ResolverFileParams, type ResolverPathParams, type SerializedDiagnostic, type Storage, type UpdateDiagnostic, Url, UserConfig, type UserReporter, ast, cliReporter, createAdapter, createKubb, createRenderer, createReporter, createStorage, defineGenerator, defineParser, definePlugin, defineResolver, fileReporter, fsStorage, jsonReporter, logLevel, memoryStorage };
 //# sourceMappingURL=index.d.ts.map