@kubb/core 5.0.0-beta.9 → 5.0.0-beta.93

package/dist/index.d.ts

@@ -1,185 +1,140 @@
-import { t as __name } from "./chunk--u3MIqq1.js";
-import { $ as ResolverPathParams, A as isInputPath, B as KubbPluginSetupContext, C as KubbPluginsEndContext, D as PossibleConfig, E as KubbWarnContext, F as FileManager, G as Plugin, H as NormalizedPlugin, I as Exclude, J as ResolveBannerContext, K as PluginFactoryOptions, L as Group, M as GeneratorContext, N as defineGenerator, O as UserConfig, P as PluginDriver, Q as ResolverFileParams, R as Include, S as KubbLifecycleStartContext, T as KubbVersionNewContext, U as Output, V as KubbPluginStartContext, W as Override, X as Resolver, Y as ResolveOptionsContext, Z as ResolverContext, _ as KubbGenerationSummaryContext, _t as AdapterFactoryOptions, a as InputPath, at as Logger, b as KubbHooks, bt as logLevel, c as KubbBuildStartContext, ct as UserLogger, d as KubbErrorContext, dt as Storage, et as defineResolver, f as KubbFileProcessingUpdateContext, ft as createStorage, g as KubbGenerationStartContext, gt as Adapter, h as KubbGenerationEndContext, ht as createRenderer, i as InputData, it as defineMiddleware, j as Generator, k as createKubb, l as KubbConfigEndContext, lt as defineLogger, m as KubbFilesProcessingStartContext, mt as RendererFactory, n as CLIOptions, nt as defineParser, o as Kubb, ot as LoggerContext, p as KubbFilesProcessingEndContext, pt as Renderer, q as definePlugin, r as Config, rt as Middleware, s as KubbBuildEndContext, st as LoggerOptions, t as BuildOutput, tt as Parser, u as KubbDebugContext, ut as DevtoolsOptions, v as KubbHookEndContext, vt as AdapterSource, w as KubbSuccessContext, x as KubbInfoContext, xt as AsyncEventEmitter, y as KubbHookStartContext, yt as createAdapter, z as KubbPluginEndContext } from "./createKubb-ALdb8lmq.js";
-import * as ast from "@kubb/ast";
-import { FileNode } from "@kubb/ast";
+import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
+import { $ as ResolveBannerContext, A as Generator, At as ProblemCode, B as Include, C as KubbWarnContext, Ct as Diagnostic, D as CreateKubbOptions, Dt as DiagnosticSeverity, E as UserConfig, Et as DiagnosticLocation, F as Parser, Ft as Adapter, G as Output, H as KubbPluginSetupContext, I as defineParser, It as AdapterFactoryOptions, J as Override, K as OutputMode, L as Exclude, Lt as AdapterSource, M as defineGenerator, Mt as SerializedDiagnostic, N as KubbDriver, Nt as UpdateDiagnostic, O as Kubb, Ot as Diagnostics, P as FileManagerHooks, Pt as Hookable, Q as BannerMeta, R as Filter, Rt as createAdapter, S as KubbSuccessContext, St as logLevel, T as PostGenerateCommand, Tt as DiagnosticKind, U as KubbPluginStartContext, V as KubbPluginEndContext, W as NormalizedPlugin, X as PluginFactoryOptions, Y as Plugin, Z as definePlugin, _ as KubbHookStartContext, _t as Reporter, a as KubbBuildEndContext, at as ResolverDefault, b as KubbLifecycleStartContext, bt as UserReporter, c as KubbErrorContext, ct as ResolverFilePathParams, d as KubbFilesProcessingStartContext, dt as Renderer, et as ResolveBannerFile, f as KubbFilesProcessingUpdateContext, ft as RendererFactory, g as KubbHookLineContext, gt as GenerationResult, h as KubbHookEndContext, ht as createStorage, i as Input, it as Resolver, j as GeneratorContext, jt as ProblemDiagnostic, k as createKubb, kt as PerformanceDiagnostic, l as KubbFileProcessingUpdate, lt as ResolverPatch, m as KubbGenerationStartContext, mt as Storage, n as CLIOptions, nt as ResolveOptionsContext, o as KubbBuildStartContext, ot as ResolverFile, p as KubbGenerationEndContext, pt as createRenderer, q as OutputOptions, r as Config, rt as ResolvePathOptions, s as KubbDiagnosticContext, st as ResolverFileParams, t as BuildOutput, tt as ResolveFileOptions, u as KubbFilesProcessingEndContext, ut as ResolverPathParams, v as KubbHooks, vt as ReporterContext, w as PossibleConfig, wt as DiagnosticDoc, x as KubbPluginsEndContext, xt as createReporter, y as KubbInfoContext, yt as ReporterName, z as Group } from "./types-BLFyAJLZ.js";
 
-//#region ../../internals/utils/src/urlPath.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.
-   */
-  params?: Record<string, string>;
-};
-type ObjectOptions = {
-  /**
-   * Controls whether the `url` is rendered as an Express path or a template literal.
-   * @default 'path'
-   */
-  type?: 'path' | 'template';
-  /**
-   * Optional 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;
+//#region src/applyConfigDefaults.d.ts
+type ApplyConfigDefaultsOptions<TOutput> = {
+  defaultAdapter: Adapter;
+  barrelPlugin: Plugin;
+  barrelPluginName: string; /** Output fields to fill in when the user's config leaves them unset. */
+  defaultOutput: Partial<TOutput>;
 };
 /**
- * Supported identifier casing strategies for path parameters.
+ * Fills in the config defaults shared by `defineConfig` and the unplugin factory: the fallback
+ * adapter, `defaultOutput`'s fields, and appending the barrel plugin when it's not already
+ * registered. Both entry points construct their own adapter, barrel plugin, and output defaults
+ * (`barrel` is a `@kubb/plugin-barrel` extension field core doesn't know about) and pass them in,
+ * so `@kubb/core` doesn't need to depend on `@kubb/adapter-oas` or `@kubb/plugin-barrel`.
  */
-type PathCasing = 'camelcase';
-type Options = {
-  /**
-   * Casing strategy applied to path parameter names.
-   * @default undefined (original identifier preserved)
-   */
-  casing?: PathCasing;
+declare function applyConfigDefaults<TOutput extends Config['output'] = Config['output']>(config: {
+  adapter?: Adapter;
+  output: TOutput;
+  plugins?: Array<Plugin>;
+}, {
+  defaultAdapter,
+  barrelPlugin,
+  barrelPluginName,
+  defaultOutput
+}: ApplyConfigDefaultsOptions<TOutput>): {
+  adapter: Adapter;
+  output: TOutput;
+  plugins: Array<Plugin>;
 };
+//#endregion
+//#region src/reporters/cliReporter.d.ts
+/**
+ * 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 const cliReporter: Reporter;
+//#endregion
+//#region src/reporters/fileReporter.d.ts
 /**
- * Parses and transforms an OpenAPI/Swagger path string into various URL formats.
+ * 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']`).
  *
- * @example
- * const p = new URLPath('/pet/{petId}')
- * p.URL      // '/pet/:petId'
- * p.template // '`/pet/${petId}`'
+ * @note It captures the collected diagnostics once a config finishes, not the live
+ * `kubb:info`/`kubb:plugin` hook stream. Color is stripped so the file stays plain text even when
+ * the run is attached to a TTY.
  */
-declare class URLPath {
-  #private;
-  /**
-   * 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://`).
-   *
-   * @example
-   * ```ts
-   * new URLPath('https://petstore.swagger.io/v2/pet').isURL // true
-   * new URLPath('/pet/{petId}').isURL                       // false
-   * ```
-   */
-  get isURL(): boolean;
-  /**
-   * Converts the OpenAPI path to a TypeScript template literal string.
-   *
-   * @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.
-   *
-   * @example
-   * ```ts
-   * new URLPath('/pet/{petId}').object
-   * // { url: '/pet/:petId', params: { petId: 'petId' } }
-   * ```
-   */
-  get object(): URLObject | string;
-  /** Returns a map of path parameter names, or `undefined` when the path has no parameters.
-   *
-   * @example
-   * ```ts
-   * new URLPath('/pet/{petId}').params // { petId: 'petId' }
-   * new URLPath('/pet').params         // undefined
-   * ```
-   */
-  get params(): Record<string, string> | undefined;
-  toObject({
-    type,
-    replacer,
-    stringify
-  }?: 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;
-}
+declare const fileReporter: Reporter;
 //#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;
-};
+//#region src/reporters/jsonReporter.d.ts
+/**
+ * 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.
+ */
+declare const jsonReporter: Reporter;
+//#endregion
+//#region src/createResolver.d.ts
+/**
+ * The plugin-specific resolver fields handed to `createResolver`. `name` and `file` fall
+ * back to the built-ins when omitted. Every method reaches sibling helpers through `this`,
+ * which `ThisType` types as the full resolver.
+ */
+type ResolverOptions<T extends PluginFactoryOptions> = Omit<T['resolver'], keyof Resolver> & {
+  pluginName: T['name'];
+  name?: T['resolver']['name'];
+  file?: ResolverFile;
+} & ThisType<T['resolver']>;
+/**
+ * Defines a plugin resolver, the object that decides what every generated symbol and file
+ * path is called. Override the top-level `name` and `file` to set the plugin's conventions,
+ * and add your own naming helpers, top-level (`typeName`, …) or grouped in namespaces
+ * (`query`, `schema`, …). Every method reaches sibling helpers and the built-in machinery
+ * through `this.name`, `this.file`, and `this.default`.
+ *
+ * @example Custom identifier casing
+ * ```ts
+ * export const resolverTs = createResolver<PluginTs>({
+ *   pluginName: 'plugin-ts',
+ *   name(name) {
+ *     return ensureValidVarName(pascalCase(name))
+ *   },
+ * })
+ * ```
+ *
+ * @example Rename generated files with `file.baseName`
+ * ```ts
+ * export const resolverFaker = createResolver<PluginFaker>({
+ *   pluginName: 'plugin-faker',
+ *   name(name) {
+ *     return camelCase(name, { prefix: 'create' })
+ *   },
+ *   file: {
+ *     baseName({ name, extname }) {
+ *       return `${camelCase(name, { prefix: 'create' })}${extname}`
+ *     },
+ *   },
+ * })
+ * ```
+ *
+ * @example Own the full path with `file.path`
+ * ```ts
+ * export const resolverFaker = createResolver<PluginFaker>({
+ *   pluginName: 'plugin-faker',
+ *   file: {
+ *     path({ baseName, output }) {
+ *       return `${output.path}/mocks/${baseName}`
+ *     },
+ *   },
+ * })
+ * ```
+ */
+declare function createResolver<T extends PluginFactoryOptions>(options: ResolverOptions<T>): T['resolver'];
+//#endregion
+//#region src/input.d.ts
+/**
+ * What an `input` value points at, once Kubb has looked at it.
+ *
+ * - `file` is a local file path, absolute or relative to the config file.
+ * - `url` is a remote document to fetch.
+ * - `inline` is OpenAPI content held in the string itself (JSON or YAML).
+ * - `object` is an already-parsed spec.
+ */
+type InputKind = 'file' | 'url' | 'inline' | 'object';
 /**
- * Converts a single file to a string using the registered parsers.
- * Falls back to joining source values when no matching parser is found.
+ * Classifies an `input` value so callers branch on it once instead of repeating the checks.
  *
- * @internal
+ * A non-string is a parsed spec (`object`). A string is `inline` when it holds OpenAPI content,
+ * meaning it starts with `{` or `[`, spans multiple lines, or opens with a YAML `openapi:` or
+ * `swagger:` key. Otherwise a string is a `url` when it parses as one, or a `file` path.
  */
-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 function getInputKind(input: NonNullable<Input>): InputKind;
 //#endregion
 //#region src/storages/fsStorage.d.ts
 /**
@@ -189,11 +144,13 @@ 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
+ * - concurrent `setItem` calls are capped at {@link WRITE_CONCURRENCY} in flight, so a caller
+ *   can fire every file's write without pacing itself
  *
  * @example
  * ```ts
@@ -201,7 +158,7 @@ declare class FileProcessor {
  * import { defineConfig } from 'kubb'
  *
  * export default defineConfig({
- *   input:  { path: './petStore.yaml' },
+ *   input:  './petStore.yaml',
  *   output: { path: './src/gen' },
  *   storage: fsStorage(),
  * })
@@ -223,7 +180,7 @@ declare const fsStorage: (options?: Record<string, never> | undefined) => Storag
  * import { defineConfig } from 'kubb'
  *
  * export default defineConfig({
- *   input:  { path: './petStore.yaml' },
+ *   input:  './petStore.yaml',
  *   output: { path: './src/gen' },
  *   storage: memoryStorage(),
  * })
@@ -231,5 +188,5 @@ declare const fsStorage: (options?: Record<string, never> | undefined) => Storag
  */
 declare const memoryStorage: (options?: Record<string, never> | undefined) => Storage;
 //#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, 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, type BannerMeta, BuildOutput, CLIOptions, Config, type CreateKubbOptions, type Diagnostic, type DiagnosticDoc, type DiagnosticKind, type DiagnosticLocation, type DiagnosticSeverity, Diagnostics, type Exclude, type FileManagerHooks, type Filter, type GenerationResult, type Generator, type GeneratorContext, type Group, Hookable, type Include, Input, type InputKind, 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 Parser, type PerformanceDiagnostic, type Plugin, type PluginFactoryOptions, PossibleConfig, PostGenerateCommand, type ProblemCode, type ProblemDiagnostic, type Renderer, type RendererFactory, type Reporter, type ReporterContext, type ReporterName, type ResolveBannerContext, type ResolveBannerFile, type ResolveFileOptions, type ResolveOptionsContext, type ResolvePathOptions, Resolver, type ResolverDefault, type ResolverFile, type ResolverFileParams, type ResolverFilePathParams, type ResolverPatch, type ResolverPathParams, type SerializedDiagnostic, type Storage, type UpdateDiagnostic, UserConfig, type UserReporter, applyConfigDefaults, cliReporter, createAdapter, createKubb, createRenderer, createReporter, createResolver, createStorage, defineGenerator, defineParser, definePlugin, fileReporter, fsStorage, getInputKind, jsonReporter, logLevel, memoryStorage };
 //# sourceMappingURL=index.d.ts.map