kubb 5.0.0-beta.98 → 5.0.0

package/dist/astro.cjs

@@ -1,4 +1,4 @@
-const require_rolldown_runtime = require("./rolldown-runtime-Bx3C2hgW.cjs");
+const require_rolldown_runtime = require("./rolldown-runtime-qbf5tadS.cjs");
 let unplugin_kubb_astro = require("unplugin-kubb/astro");
 unplugin_kubb_astro = require_rolldown_runtime.__toESM(unplugin_kubb_astro, 1);
 module.exports = unplugin_kubb_astro.default;

package/dist/config.cjs

@@ -1,3 +1,3 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_defineConfig = require("./defineConfig-CzY_scM2.cjs");
+const require_defineConfig = require("./defineConfig-CvrLxRW7.cjs");
 exports.defineConfig = require_defineConfig.defineConfig;

package/dist/config.d.ts

@@ -1,3 +1,3 @@
-import { t as defineConfig } from "./defineConfig-DwxZtGhf.js";
+import { t as defineConfig } from "./defineConfig-CIEuNKbF.js";
 import { BarrelType } from "@kubb/plugin-barrel";
 export { type BarrelType, defineConfig };

package/dist/config.js

@@ -1,2 +1,2 @@
-import { t as defineConfig } from "./defineConfig-BCzzAVwJ.js";
+import { t as defineConfig } from "./defineConfig-CmqVIEF_.js";
 export { defineConfig };

package/dist/{defineConfig-DwxZtGhf.d.ts → defineConfig-CIEuNKbF.d.ts}

@@ -25,7 +25,7 @@ type DefinedConfig<TConfig extends ConfigInput> = TConfig extends ((cli: CLIOpti
  * - `parsers` → `[parserTs(), parserTsx(), parserMd()]`.
  * - `reporters` → `[cliReporter, jsonReporter, fileReporter]`.
  * - `plugins` → `pluginBarrel()` is appended when not already present.
- * - `output.barrel` → `{ type: 'named' }` when not set.
+ * - `output.barrel` → `false` when not set.
  * - `output.format` and `output.lint` → `false`.
  *
  * Accepts a config object, an array of configs, a Promise resolving to one,
@@ -58,4 +58,4 @@ type DefinedConfig<TConfig extends ConfigInput> = TConfig extends ((cli: CLIOpti
 declare function defineConfig<TConfig extends ConfigInput>(config: TConfig): DefinedConfig<TConfig>;
 //#endregion
 export { defineConfig as t };
-//# sourceMappingURL=defineConfig-DwxZtGhf.d.ts.map
+//# sourceMappingURL=defineConfig-CIEuNKbF.d.ts.map

package/dist/{defineConfig-BCzzAVwJ.js → defineConfig-CmqVIEF_.js}

@@ -26,7 +26,7 @@ function isPromise(result) {
 * - `parsers` defaults to `[parserTs(), parserTsx(), parserMd()]`
 * - `reporters` defaults to `[cliReporter, jsonReporter, fileReporter]`
 * - `plugins` gets `pluginBarrel()` appended when none is already present
-* - `output.barrel` defaults to `{ type: 'named' }` when not set (`pluginBarrel` is always present after the step above)
+* - `output.barrel` defaults to `false` when not set (`pluginBarrel` is always present after the step above, but generates nothing until configured)
 * - `output.format` defaults to `false`
 * - `output.lint` defaults to `false`
 */
@@ -36,7 +36,7 @@ function applyDefaults(config) {
 		barrelPlugin: pluginBarrel(),
 		barrelPluginName: pluginBarrelName,
 		defaultOutput: {
-			barrel: { type: "named" },
+			barrel: false,
 			format: false,
 			lint: false
 		}
@@ -71,7 +71,7 @@ function normalizeConfig(config) {
 * - `parsers` → `[parserTs(), parserTsx(), parserMd()]`.
 * - `reporters` → `[cliReporter, jsonReporter, fileReporter]`.
 * - `plugins` → `pluginBarrel()` is appended when not already present.
-* - `output.barrel` → `{ type: 'named' }` when not set.
+* - `output.barrel` → `false` when not set.
 * - `output.format` and `output.lint` → `false`.
 *
 * Accepts a config object, an array of configs, a Promise resolving to one,
@@ -111,4 +111,4 @@ function defineConfig(config) {
 //#endregion
 export { defineConfig as t };
 
-//# sourceMappingURL=defineConfig-BCzzAVwJ.js.map
+//# sourceMappingURL=defineConfig-CmqVIEF_.js.map

package/dist/defineConfig-CmqVIEF_.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineConfig-CmqVIEF_.js","names":[],"sources":["../../../internals/utils/src/promise.ts","../src/defineConfig.ts"],"sourcesContent":["import { toError } from './errors.ts'\n\n/** A value that may already be resolved or still pending.\n *\n * @example\n * ```ts\n * function load(id: string): PossiblePromise<string> {\n *   return cache.get(id) ?? fetchRemote(id)\n * }\n * ```\n */\nexport type PossiblePromise<T> = Promise<T> | T\n\n/** Returns `true` when `result` is a thenable `Promise`.\n *\n * @example\n * ```ts\n * isPromise(Promise.resolve(1)) // true\n * isPromise(42)                 // false\n * ```\n */\nexport function isPromise<T>(result: PossiblePromise<T>): result is Promise<T> {\n  return result !== null && result !== undefined && typeof (result as Record<string, unknown>)['then'] === 'function'\n}\n\ntype Store<TKey, TValue> = {\n  has(key: TKey): boolean\n  get(key: TKey): TValue | undefined\n  set(key: TKey, value: TValue): unknown\n}\n\n/**\n * Wraps `factory` with a keyed cache backed by the provided store.\n *\n * Pass a `WeakMap` for object keys (results are GC-eligible when the key is\n * collected) or a `Map` for primitive keys. For multi-argument functions,\n * nest two `memoize` calls — the outer keyed by the first argument, the\n * inner (created once per outer miss) keyed by the second.\n *\n * Because the cache is owned by the caller, it can be shared, inspected, or\n * cleared independently of the memoized function.\n *\n * @example Single WeakMap key\n * ```ts\n * const cache = new WeakMap<SchemaNode, Set<string>>()\n * const getRefs = memoize(cache, (node) => collectRefs(node))\n * ```\n *\n * @example Single Map key (primitive)\n * ```ts\n * const cache = new Map<string, Resolver>()\n * const getResolver = memoize(cache, (name) => buildResolver(name))\n * ```\n *\n * @example Two-level (object + primitive)\n * ```ts\n * const outer = new WeakMap<Params[], Map<string, Params[]>>()\n * const fn = memoize(outer, (params) => memoize(new Map(), (key) => transform(params, key)))\n * fn(params)('camelcase')\n * ```\n */\nexport function memoize<TKey, TValue>(store: Store<TKey, TValue>, factory: (key: TKey) => TValue): (key: TKey) => TValue {\n  return (key: TKey): TValue => {\n    if (store.has(key)) return store.get(key)!\n    const value = factory(key)\n    store.set(key, value)\n    return value\n  }\n}\n\ntype SerialRunnerOptions = {\n  /**\n   * The async work to serialize.\n   */\n  run(): Promise<void>\n  /**\n   * Receives errors thrown by `run`, so a failure never rejects the returned trigger.\n   */\n  onError(error: Error): void\n}\n\n/**\n * Wraps `run` so invocations never overlap: a trigger that lands while a run is in flight\n * marks it dirty and runs once more after it finishes, no matter how many triggers arrived.\n * Useful for event-driven reruns (a file watcher, a queue drain) where bursts should\n * coalesce into a single trailing run.\n *\n * @example\n * ```ts\n * const rebuild = createSerialRunner({\n *   run: () => build(),\n *   onError: (error) => log.error(error.message),\n * })\n * watcher.on('change', () => void rebuild())\n * ```\n */\nexport function createSerialRunner({ run, onError }: SerialRunnerOptions): () => Promise<void> {\n  let running = false\n  let dirty = false\n\n  return async (): Promise<void> => {\n    if (running) {\n      dirty = true\n      return\n    }\n    running = true\n    do {\n      dirty = false\n      try {\n        await run()\n      } catch (error) {\n        onError(toError(error))\n      }\n    } while (dirty)\n    running = false\n  }\n}\n\ntype ParallelOptions<TItem> = {\n  /**\n   * Items to work through, handed out in order.\n   */\n  items: ReadonlyArray<TItem>\n  /**\n   * How many items may be in flight at once.\n   */\n  limit: number\n  /**\n   * Runs once per item, with the item's position so a caller can report progress.\n   */\n  run(item: TItem, index: number): Promise<void>\n}\n\n/**\n * Runs `run` over every item with at most `limit` in flight. Workers share one iterator, so each\n * takes the next item the moment it frees up instead of waiting for a batch to drain.\n *\n * @example\n * ```ts\n * await inParallel({ items: files, limit: 50, run: (file) => storage.writeItem(file.path, file.source) })\n * ```\n */\nexport async function inParallel<TItem>({ items, limit, run }: ParallelOptions<TItem>): Promise<void> {\n  const queue = items.entries()\n\n  const worker = async (): Promise<void> => {\n    for (const [index, item] of queue) await run(item, index)\n  }\n\n  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => worker()))\n}\n","import { isPromise, type PossiblePromise } from '@internals/utils'\nimport { adapterOas } from '@kubb/adapter-oas'\nimport { applyConfigDefaults, cliReporter, type CLIOptions, fileReporter, jsonReporter, type UserConfig } from '@kubb/core'\nimport { pluginBarrel, pluginBarrelName } from '@kubb/plugin-barrel'\nimport { parserTs, parserTsx } from '@kubb/parser-ts'\nimport { parserMd } from '@kubb/parser-md'\n\ntype AnyConfigResult = UserConfig<unknown> | Array<UserConfig<unknown>>\ntype ConfigInput = AnyConfigResult | Promise<AnyConfigResult> | ((cli: CLIOptions) => PossiblePromise<AnyConfigResult>)\ntype NormalizeConfig<TConfig> =\n  TConfig extends Array<UserConfig<infer TInput>> ? Array<UserConfig<TInput>> : TConfig extends UserConfig<infer TInput> ? UserConfig<TInput> : never\ntype DefinedConfig<TConfig extends ConfigInput> = TConfig extends (cli: CLIOptions) => PossiblePromise<infer TResult>\n  ? (cli: CLIOptions) => Promise<NormalizeConfig<TResult>>\n  : TConfig extends Promise<infer TResult>\n    ? Promise<NormalizeConfig<TResult>>\n    : NormalizeConfig<TConfig>\n\n/**\n * Applies default `root`, adapter, parsers, plugins, `output.barrel`, `output.format`, and `output.lint` to a single user config when not set.\n *\n * - `root` defaults to `process.cwd()`\n * - `adapter` defaults to `adapterOas()`\n * - `parsers` defaults to `[parserTs(), parserTsx(), parserMd()]`\n * - `reporters` defaults to `[cliReporter, jsonReporter, fileReporter]`\n * - `plugins` gets `pluginBarrel()` appended when none is already present\n * - `output.barrel` defaults to `false` when not set (`pluginBarrel` is always present after the step above, but generates nothing until configured)\n * - `output.format` defaults to `false`\n * - `output.lint` defaults to `false`\n */\nfunction applyDefaults<TInput>(config: UserConfig<TInput>): UserConfig<TInput> {\n  const { adapter, output, plugins } = applyConfigDefaults(config, {\n    defaultAdapter: adapterOas(),\n    barrelPlugin: pluginBarrel(),\n    barrelPluginName: pluginBarrelName,\n    defaultOutput: { barrel: false, format: false, lint: false },\n  })\n\n  return {\n    ...config,\n    root: config.root || process.cwd(),\n    adapter,\n    parsers: config.parsers?.length ? config.parsers : [parserTs(), parserTsx(), parserMd()],\n    reporters: config.reporters?.length ? config.reporters : [cliReporter, jsonReporter, fileReporter],\n    plugins,\n    output,\n  }\n}\n\nfunction normalizeConfig<TInput>(config: UserConfig<TInput> | Array<UserConfig<TInput>>): UserConfig<TInput> | Array<UserConfig<TInput>> {\n  if (Array.isArray(config)) {\n    return config.map(applyDefaults)\n  }\n\n  return applyDefaults(config)\n}\n\n/**\n * Defines a Kubb build configuration and fills in defaults for any omitted fields.\n *\n * Defaults applied when omitted:\n * - `adapter` → `adapterOas()` (OpenAPI 2.0/3.0/3.1).\n * - `parsers` → `[parserTs(), parserTsx(), parserMd()]`.\n * - `reporters` → `[cliReporter, jsonReporter, fileReporter]`.\n * - `plugins` → `pluginBarrel()` is appended when not already present.\n * - `output.barrel` → `false` when not set.\n * - `output.format` and `output.lint` → `false`.\n *\n * Accepts a config object, an array of configs, a Promise resolving to one,\n * or a function that receives the parsed CLI options and returns any of the\n * above. The return type is preserved so async/array variants stay typed.\n *\n * @example\n * ```ts\n * import { defineConfig } from 'kubb'\n * import { pluginTs } from '@kubb/plugin-ts'\n *\n * export default defineConfig({\n *   input: './petStore.yaml',\n *   output: { path: './src/gen' },\n *   plugins: [pluginTs()],\n * })\n * ```\n *\n * @example Function form with CLI options\n * ```ts\n * import { defineConfig } from 'kubb'\n *\n * export default defineConfig(({ input }) => ({\n *   input: input ?? './petStore.yaml',\n *   output: { path: './src/gen' },\n *   plugins: [],\n * }))\n * ```\n */\nexport function defineConfig<TConfig extends ConfigInput>(config: TConfig): DefinedConfig<TConfig> {\n  if (typeof config === 'function') {\n    return (async (cli: CLIOptions) => {\n      return normalizeConfig(await config(cli))\n    }) as DefinedConfig<TConfig>\n  }\n\n  if (isPromise(config)) {\n    return config.then((resolved) => normalizeConfig(resolved)) as DefinedConfig<TConfig>\n  }\n\n  return normalizeConfig(config) as DefinedConfig<TConfig>\n}\n"],"mappings":";;;;;;;;;;;;;;;AAqBA,SAAgB,UAAa,QAAkD;CAC7E,OAAO,WAAW,QAAQ,WAAW,KAAA,KAAa,OAAQ,OAAmC,YAAY;AAC3G;;;;;;;;;;;;;;;ACMA,SAAS,cAAsB,QAAgD;CAC7E,MAAM,EAAE,SAAS,QAAQ,YAAY,oBAAoB,QAAQ;EAC/D,gBAAgB,WAAW;EAC3B,cAAc,aAAa;EAC3B,kBAAkB;EAClB,eAAe;GAAE,QAAQ;GAAO,QAAQ;GAAO,MAAM;EAAM;CAC7D,CAAC;CAED,OAAO;EACL,GAAG;EACH,MAAM,OAAO,QAAQ,QAAQ,IAAI;EACjC;EACA,SAAS,OAAO,SAAS,SAAS,OAAO,UAAU;GAAC,SAAS;GAAG,UAAU;GAAG,SAAS;EAAC;EACvF,WAAW,OAAO,WAAW,SAAS,OAAO,YAAY;GAAC;GAAa;GAAc;EAAY;EACjG;EACA;CACF;AACF;AAEA,SAAS,gBAAwB,QAAwG;CACvI,IAAI,MAAM,QAAQ,MAAM,GACtB,OAAO,OAAO,IAAI,aAAa;CAGjC,OAAO,cAAc,MAAM;AAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,SAAgB,aAA0C,QAAyC;CACjG,IAAI,OAAO,WAAW,YACpB,QAAQ,OAAO,QAAoB;EACjC,OAAO,gBAAgB,MAAM,OAAO,GAAG,CAAC;CAC1C;CAGF,IAAI,UAAU,MAAM,GAClB,OAAO,OAAO,MAAM,aAAa,gBAAgB,QAAQ,CAAC;CAG5D,OAAO,gBAAgB,MAAM;AAC/B"}

package/dist/{defineConfig-CzY_scM2.cjs → defineConfig-CvrLxRW7.cjs}

@@ -1,4 +1,4 @@
-require("./rolldown-runtime-Bx3C2hgW.cjs");
+require("./rolldown-runtime-qbf5tadS.cjs");
 let _kubb_core = require("@kubb/core");
 let _kubb_adapter_oas = require("@kubb/adapter-oas");
 let _kubb_plugin_barrel = require("@kubb/plugin-barrel");
@@ -26,7 +26,7 @@ function isPromise(result) {
 * - `parsers` defaults to `[parserTs(), parserTsx(), parserMd()]`
 * - `reporters` defaults to `[cliReporter, jsonReporter, fileReporter]`
 * - `plugins` gets `pluginBarrel()` appended when none is already present
-* - `output.barrel` defaults to `{ type: 'named' }` when not set (`pluginBarrel` is always present after the step above)
+* - `output.barrel` defaults to `false` when not set (`pluginBarrel` is always present after the step above, but generates nothing until configured)
 * - `output.format` defaults to `false`
 * - `output.lint` defaults to `false`
 */
@@ -36,7 +36,7 @@ function applyDefaults(config) {
 		barrelPlugin: (0, _kubb_plugin_barrel.pluginBarrel)(),
 		barrelPluginName: _kubb_plugin_barrel.pluginBarrelName,
 		defaultOutput: {
-			barrel: { type: "named" },
+			barrel: false,
 			format: false,
 			lint: false
 		}
@@ -71,7 +71,7 @@ function normalizeConfig(config) {
 * - `parsers` → `[parserTs(), parserTsx(), parserMd()]`.
 * - `reporters` → `[cliReporter, jsonReporter, fileReporter]`.
 * - `plugins` → `pluginBarrel()` is appended when not already present.
-* - `output.barrel` → `{ type: 'named' }` when not set.
+* - `output.barrel` → `false` when not set.
 * - `output.format` and `output.lint` → `false`.
 *
 * Accepts a config object, an array of configs, a Promise resolving to one,
@@ -116,4 +116,4 @@ Object.defineProperty(exports, "defineConfig", {
 	}
 });
 
-//# sourceMappingURL=defineConfig-CzY_scM2.cjs.map
+//# sourceMappingURL=defineConfig-CvrLxRW7.cjs.map

package/dist/defineConfig-CvrLxRW7.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineConfig-CvrLxRW7.cjs","names":["applyConfigDefaults","adapterOas","pluginBarrel","pluginBarrelName","parserTs","parserTsx","parserMd","cliReporter","jsonReporter","fileReporter"],"sources":["../../../internals/utils/src/promise.ts","../src/defineConfig.ts"],"sourcesContent":["import { toError } from './errors.ts'\n\n/** A value that may already be resolved or still pending.\n *\n * @example\n * ```ts\n * function load(id: string): PossiblePromise<string> {\n *   return cache.get(id) ?? fetchRemote(id)\n * }\n * ```\n */\nexport type PossiblePromise<T> = Promise<T> | T\n\n/** Returns `true` when `result` is a thenable `Promise`.\n *\n * @example\n * ```ts\n * isPromise(Promise.resolve(1)) // true\n * isPromise(42)                 // false\n * ```\n */\nexport function isPromise<T>(result: PossiblePromise<T>): result is Promise<T> {\n  return result !== null && result !== undefined && typeof (result as Record<string, unknown>)['then'] === 'function'\n}\n\ntype Store<TKey, TValue> = {\n  has(key: TKey): boolean\n  get(key: TKey): TValue | undefined\n  set(key: TKey, value: TValue): unknown\n}\n\n/**\n * Wraps `factory` with a keyed cache backed by the provided store.\n *\n * Pass a `WeakMap` for object keys (results are GC-eligible when the key is\n * collected) or a `Map` for primitive keys. For multi-argument functions,\n * nest two `memoize` calls — the outer keyed by the first argument, the\n * inner (created once per outer miss) keyed by the second.\n *\n * Because the cache is owned by the caller, it can be shared, inspected, or\n * cleared independently of the memoized function.\n *\n * @example Single WeakMap key\n * ```ts\n * const cache = new WeakMap<SchemaNode, Set<string>>()\n * const getRefs = memoize(cache, (node) => collectRefs(node))\n * ```\n *\n * @example Single Map key (primitive)\n * ```ts\n * const cache = new Map<string, Resolver>()\n * const getResolver = memoize(cache, (name) => buildResolver(name))\n * ```\n *\n * @example Two-level (object + primitive)\n * ```ts\n * const outer = new WeakMap<Params[], Map<string, Params[]>>()\n * const fn = memoize(outer, (params) => memoize(new Map(), (key) => transform(params, key)))\n * fn(params)('camelcase')\n * ```\n */\nexport function memoize<TKey, TValue>(store: Store<TKey, TValue>, factory: (key: TKey) => TValue): (key: TKey) => TValue {\n  return (key: TKey): TValue => {\n    if (store.has(key)) return store.get(key)!\n    const value = factory(key)\n    store.set(key, value)\n    return value\n  }\n}\n\ntype SerialRunnerOptions = {\n  /**\n   * The async work to serialize.\n   */\n  run(): Promise<void>\n  /**\n   * Receives errors thrown by `run`, so a failure never rejects the returned trigger.\n   */\n  onError(error: Error): void\n}\n\n/**\n * Wraps `run` so invocations never overlap: a trigger that lands while a run is in flight\n * marks it dirty and runs once more after it finishes, no matter how many triggers arrived.\n * Useful for event-driven reruns (a file watcher, a queue drain) where bursts should\n * coalesce into a single trailing run.\n *\n * @example\n * ```ts\n * const rebuild = createSerialRunner({\n *   run: () => build(),\n *   onError: (error) => log.error(error.message),\n * })\n * watcher.on('change', () => void rebuild())\n * ```\n */\nexport function createSerialRunner({ run, onError }: SerialRunnerOptions): () => Promise<void> {\n  let running = false\n  let dirty = false\n\n  return async (): Promise<void> => {\n    if (running) {\n      dirty = true\n      return\n    }\n    running = true\n    do {\n      dirty = false\n      try {\n        await run()\n      } catch (error) {\n        onError(toError(error))\n      }\n    } while (dirty)\n    running = false\n  }\n}\n\ntype ParallelOptions<TItem> = {\n  /**\n   * Items to work through, handed out in order.\n   */\n  items: ReadonlyArray<TItem>\n  /**\n   * How many items may be in flight at once.\n   */\n  limit: number\n  /**\n   * Runs once per item, with the item's position so a caller can report progress.\n   */\n  run(item: TItem, index: number): Promise<void>\n}\n\n/**\n * Runs `run` over every item with at most `limit` in flight. Workers share one iterator, so each\n * takes the next item the moment it frees up instead of waiting for a batch to drain.\n *\n * @example\n * ```ts\n * await inParallel({ items: files, limit: 50, run: (file) => storage.writeItem(file.path, file.source) })\n * ```\n */\nexport async function inParallel<TItem>({ items, limit, run }: ParallelOptions<TItem>): Promise<void> {\n  const queue = items.entries()\n\n  const worker = async (): Promise<void> => {\n    for (const [index, item] of queue) await run(item, index)\n  }\n\n  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => worker()))\n}\n","import { isPromise, type PossiblePromise } from '@internals/utils'\nimport { adapterOas } from '@kubb/adapter-oas'\nimport { applyConfigDefaults, cliReporter, type CLIOptions, fileReporter, jsonReporter, type UserConfig } from '@kubb/core'\nimport { pluginBarrel, pluginBarrelName } from '@kubb/plugin-barrel'\nimport { parserTs, parserTsx } from '@kubb/parser-ts'\nimport { parserMd } from '@kubb/parser-md'\n\ntype AnyConfigResult = UserConfig<unknown> | Array<UserConfig<unknown>>\ntype ConfigInput = AnyConfigResult | Promise<AnyConfigResult> | ((cli: CLIOptions) => PossiblePromise<AnyConfigResult>)\ntype NormalizeConfig<TConfig> =\n  TConfig extends Array<UserConfig<infer TInput>> ? Array<UserConfig<TInput>> : TConfig extends UserConfig<infer TInput> ? UserConfig<TInput> : never\ntype DefinedConfig<TConfig extends ConfigInput> = TConfig extends (cli: CLIOptions) => PossiblePromise<infer TResult>\n  ? (cli: CLIOptions) => Promise<NormalizeConfig<TResult>>\n  : TConfig extends Promise<infer TResult>\n    ? Promise<NormalizeConfig<TResult>>\n    : NormalizeConfig<TConfig>\n\n/**\n * Applies default `root`, adapter, parsers, plugins, `output.barrel`, `output.format`, and `output.lint` to a single user config when not set.\n *\n * - `root` defaults to `process.cwd()`\n * - `adapter` defaults to `adapterOas()`\n * - `parsers` defaults to `[parserTs(), parserTsx(), parserMd()]`\n * - `reporters` defaults to `[cliReporter, jsonReporter, fileReporter]`\n * - `plugins` gets `pluginBarrel()` appended when none is already present\n * - `output.barrel` defaults to `false` when not set (`pluginBarrel` is always present after the step above, but generates nothing until configured)\n * - `output.format` defaults to `false`\n * - `output.lint` defaults to `false`\n */\nfunction applyDefaults<TInput>(config: UserConfig<TInput>): UserConfig<TInput> {\n  const { adapter, output, plugins } = applyConfigDefaults(config, {\n    defaultAdapter: adapterOas(),\n    barrelPlugin: pluginBarrel(),\n    barrelPluginName: pluginBarrelName,\n    defaultOutput: { barrel: false, format: false, lint: false },\n  })\n\n  return {\n    ...config,\n    root: config.root || process.cwd(),\n    adapter,\n    parsers: config.parsers?.length ? config.parsers : [parserTs(), parserTsx(), parserMd()],\n    reporters: config.reporters?.length ? config.reporters : [cliReporter, jsonReporter, fileReporter],\n    plugins,\n    output,\n  }\n}\n\nfunction normalizeConfig<TInput>(config: UserConfig<TInput> | Array<UserConfig<TInput>>): UserConfig<TInput> | Array<UserConfig<TInput>> {\n  if (Array.isArray(config)) {\n    return config.map(applyDefaults)\n  }\n\n  return applyDefaults(config)\n}\n\n/**\n * Defines a Kubb build configuration and fills in defaults for any omitted fields.\n *\n * Defaults applied when omitted:\n * - `adapter` → `adapterOas()` (OpenAPI 2.0/3.0/3.1).\n * - `parsers` → `[parserTs(), parserTsx(), parserMd()]`.\n * - `reporters` → `[cliReporter, jsonReporter, fileReporter]`.\n * - `plugins` → `pluginBarrel()` is appended when not already present.\n * - `output.barrel` → `false` when not set.\n * - `output.format` and `output.lint` → `false`.\n *\n * Accepts a config object, an array of configs, a Promise resolving to one,\n * or a function that receives the parsed CLI options and returns any of the\n * above. The return type is preserved so async/array variants stay typed.\n *\n * @example\n * ```ts\n * import { defineConfig } from 'kubb'\n * import { pluginTs } from '@kubb/plugin-ts'\n *\n * export default defineConfig({\n *   input: './petStore.yaml',\n *   output: { path: './src/gen' },\n *   plugins: [pluginTs()],\n * })\n * ```\n *\n * @example Function form with CLI options\n * ```ts\n * import { defineConfig } from 'kubb'\n *\n * export default defineConfig(({ input }) => ({\n *   input: input ?? './petStore.yaml',\n *   output: { path: './src/gen' },\n *   plugins: [],\n * }))\n * ```\n */\nexport function defineConfig<TConfig extends ConfigInput>(config: TConfig): DefinedConfig<TConfig> {\n  if (typeof config === 'function') {\n    return (async (cli: CLIOptions) => {\n      return normalizeConfig(await config(cli))\n    }) as DefinedConfig<TConfig>\n  }\n\n  if (isPromise(config)) {\n    return config.then((resolved) => normalizeConfig(resolved)) as DefinedConfig<TConfig>\n  }\n\n  return normalizeConfig(config) as DefinedConfig<TConfig>\n}\n"],"mappings":";;;;;;;;;;;;;;;AAqBA,SAAgB,UAAa,QAAkD;CAC7E,OAAO,WAAW,QAAQ,WAAW,KAAA,KAAa,OAAQ,OAAmC,YAAY;AAC3G;;;;;;;;;;;;;;;ACMA,SAAS,cAAsB,QAAgD;CAC7E,MAAM,EAAE,SAAS,QAAQ,aAAA,GAAYA,WAAAA,oBAAAA,CAAoB,QAAQ;EAC/D,iBAAA,GAAgBC,kBAAAA,WAAAA,CAAW;EAC3B,eAAA,GAAcC,oBAAAA,aAAAA,CAAa;EAC3B,kBAAkBC,oBAAAA;EAClB,eAAe;GAAE,QAAQ;GAAO,QAAQ;GAAO,MAAM;EAAM;CAC7D,CAAC;CAED,OAAO;EACL,GAAG;EACH,MAAM,OAAO,QAAQ,QAAQ,IAAI;EACjC;EACA,SAAS,OAAO,SAAS,SAAS,OAAO,UAAU;IAACC,GAAAA,gBAAAA,SAAAA,CAAS;IAAGC,GAAAA,gBAAAA,UAAAA,CAAU;IAAGC,GAAAA,gBAAAA,SAAAA,CAAS;EAAC;EACvF,WAAW,OAAO,WAAW,SAAS,OAAO,YAAY;GAACC,WAAAA;GAAaC,WAAAA;GAAcC,WAAAA;EAAY;EACjG;EACA;CACF;AACF;AAEA,SAAS,gBAAwB,QAAwG;CACvI,IAAI,MAAM,QAAQ,MAAM,GACtB,OAAO,OAAO,IAAI,aAAa;CAGjC,OAAO,cAAc,MAAM;AAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,SAAgB,aAA0C,QAAyC;CACjG,IAAI,OAAO,WAAW,YACpB,QAAQ,OAAO,QAAoB;EACjC,OAAO,gBAAgB,MAAM,OAAO,GAAG,CAAC;CAC1C;CAGF,IAAI,UAAU,MAAM,GAClB,OAAO,OAAO,MAAM,aAAa,gBAAgB,QAAQ,CAAC;CAG5D,OAAO,gBAAgB,MAAM;AAC/B"}

package/dist/esbuild.cjs

@@ -1,4 +1,4 @@
-const require_rolldown_runtime = require("./rolldown-runtime-Bx3C2hgW.cjs");
+const require_rolldown_runtime = require("./rolldown-runtime-qbf5tadS.cjs");
 let unplugin_kubb_esbuild = require("unplugin-kubb/esbuild");
 unplugin_kubb_esbuild = require_rolldown_runtime.__toESM(unplugin_kubb_esbuild, 1);
 module.exports = unplugin_kubb_esbuild.default;

package/dist/farm.cjs

@@ -1,4 +1,4 @@
-const require_rolldown_runtime = require("./rolldown-runtime-Bx3C2hgW.cjs");
+const require_rolldown_runtime = require("./rolldown-runtime-qbf5tadS.cjs");
 let unplugin_kubb_farm = require("unplugin-kubb/farm");
 unplugin_kubb_farm = require_rolldown_runtime.__toESM(unplugin_kubb_farm, 1);
 module.exports = unplugin_kubb_farm.default;

package/dist/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_defineConfig = require("./defineConfig-CzY_scM2.cjs");
+const require_defineConfig = require("./defineConfig-CvrLxRW7.cjs");
 let _kubb_core = require("@kubb/core");
 Object.defineProperty(exports, "createKubb", {
 	enumerable: true,

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { t as defineConfig } from "./defineConfig-DwxZtGhf.js";
+import { t as defineConfig } from "./defineConfig-CIEuNKbF.js";
 import { BuildOutput, Config, CreateKubbOptions, Kubb, UserConfig, createKubb } from "@kubb/core";
 import { BarrelType } from "@kubb/plugin-barrel";
 export { type BarrelType, type BuildOutput, type Config, type CreateKubbOptions, type Kubb, type UserConfig, createKubb, defineConfig };

package/dist/index.js

@@ -1,3 +1,3 @@
-import { t as defineConfig } from "./defineConfig-BCzzAVwJ.js";
+import { t as defineConfig } from "./defineConfig-CmqVIEF_.js";
 import { createKubb } from "@kubb/core";
 export { createKubb, defineConfig };

package/dist/nuxt.cjs

@@ -1,4 +1,4 @@
-const require_rolldown_runtime = require("./rolldown-runtime-Bx3C2hgW.cjs");
+const require_rolldown_runtime = require("./rolldown-runtime-qbf5tadS.cjs");
 let unplugin_kubb_nuxt = require("unplugin-kubb/nuxt");
 unplugin_kubb_nuxt = require_rolldown_runtime.__toESM(unplugin_kubb_nuxt, 1);
 module.exports = unplugin_kubb_nuxt.default;

package/dist/{rolldown-runtime-Bx3C2hgW.cjs → rolldown-runtime-qbf5tadS.cjs}

@@ -19,7 +19,7 @@ var __copyProps = (to, from, except, desc) => {
 	}
 	return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
 	value: mod,
 	enumerable: true
 }) : target, mod));

package/dist/rolldown.cjs

@@ -1,4 +1,4 @@
-const require_rolldown_runtime = require("./rolldown-runtime-Bx3C2hgW.cjs");
+const require_rolldown_runtime = require("./rolldown-runtime-qbf5tadS.cjs");
 let unplugin_kubb_rolldown = require("unplugin-kubb/rolldown");
 unplugin_kubb_rolldown = require_rolldown_runtime.__toESM(unplugin_kubb_rolldown, 1);
 module.exports = unplugin_kubb_rolldown.default;

package/dist/rollup.cjs

@@ -1,4 +1,4 @@
-const require_rolldown_runtime = require("./rolldown-runtime-Bx3C2hgW.cjs");
+const require_rolldown_runtime = require("./rolldown-runtime-qbf5tadS.cjs");
 let unplugin_kubb_rollup = require("unplugin-kubb/rollup");
 unplugin_kubb_rollup = require_rolldown_runtime.__toESM(unplugin_kubb_rollup, 1);
 module.exports = unplugin_kubb_rollup.default;

package/dist/rspack.cjs

@@ -1,4 +1,4 @@
-const require_rolldown_runtime = require("./rolldown-runtime-Bx3C2hgW.cjs");
+const require_rolldown_runtime = require("./rolldown-runtime-qbf5tadS.cjs");
 let unplugin_kubb_rspack = require("unplugin-kubb/rspack");
 unplugin_kubb_rspack = require_rolldown_runtime.__toESM(unplugin_kubb_rspack, 1);
 module.exports = unplugin_kubb_rspack.default;

package/dist/vite.cjs

@@ -1,4 +1,4 @@
-const require_rolldown_runtime = require("./rolldown-runtime-Bx3C2hgW.cjs");
+const require_rolldown_runtime = require("./rolldown-runtime-qbf5tadS.cjs");
 let unplugin_kubb_vite = require("unplugin-kubb/vite");
 unplugin_kubb_vite = require_rolldown_runtime.__toESM(unplugin_kubb_vite, 1);
 module.exports = unplugin_kubb_vite.default;

package/dist/webpack.cjs

@@ -1,4 +1,4 @@
-const require_rolldown_runtime = require("./rolldown-runtime-Bx3C2hgW.cjs");
+const require_rolldown_runtime = require("./rolldown-runtime-qbf5tadS.cjs");
 let unplugin_kubb_webpack = require("unplugin-kubb/webpack");
 unplugin_kubb_webpack = require_rolldown_runtime.__toESM(unplugin_kubb_webpack, 1);
 module.exports = unplugin_kubb_webpack.default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kubb",
-  "version": "5.0.0-beta.98",
+  "version": "5.0.0",
   "description": "The meta framework for code generation. Point Kubb at a schema and it generates types, clients, hooks, validators, mocks, and more.",
   "keywords": [
     "api-client",
@@ -109,29 +109,28 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@kubb/ast": "5.0.0-beta.98",
-    "@kubb/adapter-oas": "5.0.0-beta.98",
-    "@kubb/cli": "5.0.0-beta.98",
-    "@kubb/core": "5.0.0-beta.98",
-    "@kubb/kit": "5.0.0-beta.98",
-    "@kubb/parser-md": "5.0.0-beta.98",
-    "@kubb/mcp": "5.0.0-beta.98",
-    "@kubb/plugin-barrel": "5.0.0-beta.98",
-    "@kubb/parser-ts": "5.0.0-beta.98",
-    "@kubb/renderer-jsx": "5.0.0-beta.98",
-    "unplugin-kubb": "5.0.0-beta.98"
+    "@kubb/adapter-oas": "5.0.0",
+    "@kubb/cli": "5.0.0",
+    "@kubb/core": "5.0.0",
+    "@kubb/kit": "5.0.0",
+    "@kubb/plugin-barrel": "5.0.0",
+    "@kubb/parser-ts": "5.0.0",
+    "@kubb/mcp": "5.0.0",
+    "unplugin-kubb": "5.0.0",
+    "@kubb/renderer-jsx": "5.0.0",
+    "@kubb/parser-md": "5.0.0"
   },
   "devDependencies": {
     "@farmfe/core": "^1.7.11",
-    "@nuxt/kit": "^4.4.8",
-    "@nuxt/schema": "^4.4.8",
-    "esbuild": "^0.28.1",
-    "rolldown": "^1.1.5",
-    "rollup": "^4.62.2",
+    "@nuxt/kit": "^4.5.2",
+    "@nuxt/schema": "^4.5.2",
+    "esbuild": "^0.28.2",
+    "rolldown": "^1.2.4",
+    "rollup": "^4.62.4",
     "typescript": "^6.0.3",
-    "vite": "^8.1.4",
-    "webpack": "^5.108.4",
-    "@internals/utils": "0.0.0"
+    "vite": "^8.2.1",
+    "webpack": "^5.109.2",
+    "@internals/utils": "0.0.1"
   },
   "preferGlobal": true,
   "engines": {

package/dist/defineConfig-BCzzAVwJ.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"defineConfig-BCzzAVwJ.js","names":[],"sources":["../../../internals/utils/src/promise.ts","../src/defineConfig.ts"],"sourcesContent":["import { toError } from './errors.ts'\n\n/** A value that may already be resolved or still pending.\n *\n * @example\n * ```ts\n * function load(id: string): PossiblePromise<string> {\n *   return cache.get(id) ?? fetchRemote(id)\n * }\n * ```\n */\nexport type PossiblePromise<T> = Promise<T> | T\n\n/** Returns `true` when `result` is a thenable `Promise`.\n *\n * @example\n * ```ts\n * isPromise(Promise.resolve(1)) // true\n * isPromise(42)                 // false\n * ```\n */\nexport function isPromise<T>(result: PossiblePromise<T>): result is Promise<T> {\n  return result !== null && result !== undefined && typeof (result as Record<string, unknown>)['then'] === 'function'\n}\n\ntype Store<TKey, TValue> = {\n  has(key: TKey): boolean\n  get(key: TKey): TValue | undefined\n  set(key: TKey, value: TValue): unknown\n}\n\n/**\n * Wraps `factory` with a keyed cache backed by the provided store.\n *\n * Pass a `WeakMap` for object keys (results are GC-eligible when the key is\n * collected) or a `Map` for primitive keys. For multi-argument functions,\n * nest two `memoize` calls — the outer keyed by the first argument, the\n * inner (created once per outer miss) keyed by the second.\n *\n * Because the cache is owned by the caller, it can be shared, inspected, or\n * cleared independently of the memoized function.\n *\n * @example Single WeakMap key\n * ```ts\n * const cache = new WeakMap<SchemaNode, Set<string>>()\n * const getRefs = memoize(cache, (node) => collectRefs(node))\n * ```\n *\n * @example Single Map key (primitive)\n * ```ts\n * const cache = new Map<string, Resolver>()\n * const getResolver = memoize(cache, (name) => buildResolver(name))\n * ```\n *\n * @example Two-level (object + primitive)\n * ```ts\n * const outer = new WeakMap<Params[], Map<string, Params[]>>()\n * const fn = memoize(outer, (params) => memoize(new Map(), (key) => transform(params, key)))\n * fn(params)('camelcase')\n * ```\n */\nexport function memoize<TKey, TValue>(store: Store<TKey, TValue>, factory: (key: TKey) => TValue): (key: TKey) => TValue {\n  return (key: TKey): TValue => {\n    if (store.has(key)) return store.get(key)!\n    const value = factory(key)\n    store.set(key, value)\n    return value\n  }\n}\n\ntype SerialRunnerOptions = {\n  /**\n   * The async work to serialize.\n   */\n  run(): Promise<void>\n  /**\n   * Receives errors thrown by `run`, so a failure never rejects the returned trigger.\n   */\n  onError(error: Error): void\n}\n\n/**\n * Wraps `run` so invocations never overlap: a trigger that lands while a run is in flight\n * marks it dirty and runs once more after it finishes, no matter how many triggers arrived.\n * Useful for event-driven reruns (a file watcher, a queue drain) where bursts should\n * coalesce into a single trailing run.\n *\n * @example\n * ```ts\n * const rebuild = createSerialRunner({\n *   run: () => build(),\n *   onError: (error) => log.error(error.message),\n * })\n * watcher.on('change', () => void rebuild())\n * ```\n */\nexport function createSerialRunner({ run, onError }: SerialRunnerOptions): () => Promise<void> {\n  let running = false\n  let dirty = false\n\n  return async (): Promise<void> => {\n    if (running) {\n      dirty = true\n      return\n    }\n    running = true\n    do {\n      dirty = false\n      try {\n        await run()\n      } catch (error) {\n        onError(toError(error))\n      }\n    } while (dirty)\n    running = false\n  }\n}\n","import { isPromise, type PossiblePromise } from '@internals/utils'\nimport { adapterOas } from '@kubb/adapter-oas'\nimport { applyConfigDefaults, cliReporter, type CLIOptions, fileReporter, jsonReporter, type UserConfig } from '@kubb/core'\nimport { pluginBarrel, pluginBarrelName } from '@kubb/plugin-barrel'\nimport { parserTs, parserTsx } from '@kubb/parser-ts'\nimport { parserMd } from '@kubb/parser-md'\n\ntype AnyConfigResult = UserConfig<unknown> | Array<UserConfig<unknown>>\ntype ConfigInput = AnyConfigResult | Promise<AnyConfigResult> | ((cli: CLIOptions) => PossiblePromise<AnyConfigResult>)\ntype NormalizeConfig<TConfig> =\n  TConfig extends Array<UserConfig<infer TInput>> ? Array<UserConfig<TInput>> : TConfig extends UserConfig<infer TInput> ? UserConfig<TInput> : never\ntype DefinedConfig<TConfig extends ConfigInput> = TConfig extends (cli: CLIOptions) => PossiblePromise<infer TResult>\n  ? (cli: CLIOptions) => Promise<NormalizeConfig<TResult>>\n  : TConfig extends Promise<infer TResult>\n    ? Promise<NormalizeConfig<TResult>>\n    : NormalizeConfig<TConfig>\n\n/**\n * Applies default `root`, adapter, parsers, plugins, `output.barrel`, `output.format`, and `output.lint` to a single user config when not set.\n *\n * - `root` defaults to `process.cwd()`\n * - `adapter` defaults to `adapterOas()`\n * - `parsers` defaults to `[parserTs(), parserTsx(), parserMd()]`\n * - `reporters` defaults to `[cliReporter, jsonReporter, fileReporter]`\n * - `plugins` gets `pluginBarrel()` appended when none is already present\n * - `output.barrel` defaults to `{ type: 'named' }` when not set (`pluginBarrel` is always present after the step above)\n * - `output.format` defaults to `false`\n * - `output.lint` defaults to `false`\n */\nfunction applyDefaults<TInput>(config: UserConfig<TInput>): UserConfig<TInput> {\n  const { adapter, output, plugins } = applyConfigDefaults(config, {\n    defaultAdapter: adapterOas(),\n    barrelPlugin: pluginBarrel(),\n    barrelPluginName: pluginBarrelName,\n    defaultOutput: { barrel: { type: 'named' }, format: false, lint: false },\n  })\n\n  return {\n    ...config,\n    root: config.root || process.cwd(),\n    adapter,\n    parsers: config.parsers?.length ? config.parsers : [parserTs(), parserTsx(), parserMd()],\n    reporters: config.reporters?.length ? config.reporters : [cliReporter, jsonReporter, fileReporter],\n    plugins,\n    output,\n  }\n}\n\nfunction normalizeConfig<TInput>(config: UserConfig<TInput> | Array<UserConfig<TInput>>): UserConfig<TInput> | Array<UserConfig<TInput>> {\n  if (Array.isArray(config)) {\n    return config.map(applyDefaults)\n  }\n\n  return applyDefaults(config)\n}\n\n/**\n * Defines a Kubb build configuration and fills in defaults for any omitted fields.\n *\n * Defaults applied when omitted:\n * - `adapter` → `adapterOas()` (OpenAPI 2.0/3.0/3.1).\n * - `parsers` → `[parserTs(), parserTsx(), parserMd()]`.\n * - `reporters` → `[cliReporter, jsonReporter, fileReporter]`.\n * - `plugins` → `pluginBarrel()` is appended when not already present.\n * - `output.barrel` → `{ type: 'named' }` when not set.\n * - `output.format` and `output.lint` → `false`.\n *\n * Accepts a config object, an array of configs, a Promise resolving to one,\n * or a function that receives the parsed CLI options and returns any of the\n * above. The return type is preserved so async/array variants stay typed.\n *\n * @example\n * ```ts\n * import { defineConfig } from 'kubb'\n * import { pluginTs } from '@kubb/plugin-ts'\n *\n * export default defineConfig({\n *   input: './petStore.yaml',\n *   output: { path: './src/gen' },\n *   plugins: [pluginTs()],\n * })\n * ```\n *\n * @example Function form with CLI options\n * ```ts\n * import { defineConfig } from 'kubb'\n *\n * export default defineConfig(({ input }) => ({\n *   input: input ?? './petStore.yaml',\n *   output: { path: './src/gen' },\n *   plugins: [],\n * }))\n * ```\n */\nexport function defineConfig<TConfig extends ConfigInput>(config: TConfig): DefinedConfig<TConfig> {\n  if (typeof config === 'function') {\n    return (async (cli: CLIOptions) => {\n      return normalizeConfig(await config(cli))\n    }) as DefinedConfig<TConfig>\n  }\n\n  if (isPromise(config)) {\n    return config.then((resolved) => normalizeConfig(resolved)) as DefinedConfig<TConfig>\n  }\n\n  return normalizeConfig(config) as DefinedConfig<TConfig>\n}\n"],"mappings":";;;;;;;;;;;;;;;AAqBA,SAAgB,UAAa,QAAkD;CAC7E,OAAO,WAAW,QAAQ,WAAW,KAAA,KAAa,OAAQ,OAAmC,YAAY;AAC3G;;;;;;;;;;;;;;;ACMA,SAAS,cAAsB,QAAgD;CAC7E,MAAM,EAAE,SAAS,QAAQ,YAAY,oBAAoB,QAAQ;EAC/D,gBAAgB,WAAW;EAC3B,cAAc,aAAa;EAC3B,kBAAkB;EAClB,eAAe;GAAE,QAAQ,EAAE,MAAM,QAAQ;GAAG,QAAQ;GAAO,MAAM;EAAM;CACzE,CAAC;CAED,OAAO;EACL,GAAG;EACH,MAAM,OAAO,QAAQ,QAAQ,IAAI;EACjC;EACA,SAAS,OAAO,SAAS,SAAS,OAAO,UAAU;GAAC,SAAS;GAAG,UAAU;GAAG,SAAS;EAAC;EACvF,WAAW,OAAO,WAAW,SAAS,OAAO,YAAY;GAAC;GAAa;GAAc;EAAY;EACjG;EACA;CACF;AACF;AAEA,SAAS,gBAAwB,QAAwG;CACvI,IAAI,MAAM,QAAQ,MAAM,GACtB,OAAO,OAAO,IAAI,aAAa;CAGjC,OAAO,cAAc,MAAM;AAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,SAAgB,aAA0C,QAAyC;CACjG,IAAI,OAAO,WAAW,YACpB,QAAQ,OAAO,QAAoB;EACjC,OAAO,gBAAgB,MAAM,OAAO,GAAG,CAAC;CAC1C;CAGF,IAAI,UAAU,MAAM,GAClB,OAAO,OAAO,MAAM,aAAa,gBAAgB,QAAQ,CAAC;CAG5D,OAAO,gBAAgB,MAAM;AAC/B"}

package/dist/defineConfig-CzY_scM2.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"defineConfig-CzY_scM2.cjs","names":["pluginBarrelName","cliReporter","jsonReporter","fileReporter"],"sources":["../../../internals/utils/src/promise.ts","../src/defineConfig.ts"],"sourcesContent":["import { toError } from './errors.ts'\n\n/** A value that may already be resolved or still pending.\n *\n * @example\n * ```ts\n * function load(id: string): PossiblePromise<string> {\n *   return cache.get(id) ?? fetchRemote(id)\n * }\n * ```\n */\nexport type PossiblePromise<T> = Promise<T> | T\n\n/** Returns `true` when `result` is a thenable `Promise`.\n *\n * @example\n * ```ts\n * isPromise(Promise.resolve(1)) // true\n * isPromise(42)                 // false\n * ```\n */\nexport function isPromise<T>(result: PossiblePromise<T>): result is Promise<T> {\n  return result !== null && result !== undefined && typeof (result as Record<string, unknown>)['then'] === 'function'\n}\n\ntype Store<TKey, TValue> = {\n  has(key: TKey): boolean\n  get(key: TKey): TValue | undefined\n  set(key: TKey, value: TValue): unknown\n}\n\n/**\n * Wraps `factory` with a keyed cache backed by the provided store.\n *\n * Pass a `WeakMap` for object keys (results are GC-eligible when the key is\n * collected) or a `Map` for primitive keys. For multi-argument functions,\n * nest two `memoize` calls — the outer keyed by the first argument, the\n * inner (created once per outer miss) keyed by the second.\n *\n * Because the cache is owned by the caller, it can be shared, inspected, or\n * cleared independently of the memoized function.\n *\n * @example Single WeakMap key\n * ```ts\n * const cache = new WeakMap<SchemaNode, Set<string>>()\n * const getRefs = memoize(cache, (node) => collectRefs(node))\n * ```\n *\n * @example Single Map key (primitive)\n * ```ts\n * const cache = new Map<string, Resolver>()\n * const getResolver = memoize(cache, (name) => buildResolver(name))\n * ```\n *\n * @example Two-level (object + primitive)\n * ```ts\n * const outer = new WeakMap<Params[], Map<string, Params[]>>()\n * const fn = memoize(outer, (params) => memoize(new Map(), (key) => transform(params, key)))\n * fn(params)('camelcase')\n * ```\n */\nexport function memoize<TKey, TValue>(store: Store<TKey, TValue>, factory: (key: TKey) => TValue): (key: TKey) => TValue {\n  return (key: TKey): TValue => {\n    if (store.has(key)) return store.get(key)!\n    const value = factory(key)\n    store.set(key, value)\n    return value\n  }\n}\n\ntype SerialRunnerOptions = {\n  /**\n   * The async work to serialize.\n   */\n  run(): Promise<void>\n  /**\n   * Receives errors thrown by `run`, so a failure never rejects the returned trigger.\n   */\n  onError(error: Error): void\n}\n\n/**\n * Wraps `run` so invocations never overlap: a trigger that lands while a run is in flight\n * marks it dirty and runs once more after it finishes, no matter how many triggers arrived.\n * Useful for event-driven reruns (a file watcher, a queue drain) where bursts should\n * coalesce into a single trailing run.\n *\n * @example\n * ```ts\n * const rebuild = createSerialRunner({\n *   run: () => build(),\n *   onError: (error) => log.error(error.message),\n * })\n * watcher.on('change', () => void rebuild())\n * ```\n */\nexport function createSerialRunner({ run, onError }: SerialRunnerOptions): () => Promise<void> {\n  let running = false\n  let dirty = false\n\n  return async (): Promise<void> => {\n    if (running) {\n      dirty = true\n      return\n    }\n    running = true\n    do {\n      dirty = false\n      try {\n        await run()\n      } catch (error) {\n        onError(toError(error))\n      }\n    } while (dirty)\n    running = false\n  }\n}\n","import { isPromise, type PossiblePromise } from '@internals/utils'\nimport { adapterOas } from '@kubb/adapter-oas'\nimport { applyConfigDefaults, cliReporter, type CLIOptions, fileReporter, jsonReporter, type UserConfig } from '@kubb/core'\nimport { pluginBarrel, pluginBarrelName } from '@kubb/plugin-barrel'\nimport { parserTs, parserTsx } from '@kubb/parser-ts'\nimport { parserMd } from '@kubb/parser-md'\n\ntype AnyConfigResult = UserConfig<unknown> | Array<UserConfig<unknown>>\ntype ConfigInput = AnyConfigResult | Promise<AnyConfigResult> | ((cli: CLIOptions) => PossiblePromise<AnyConfigResult>)\ntype NormalizeConfig<TConfig> =\n  TConfig extends Array<UserConfig<infer TInput>> ? Array<UserConfig<TInput>> : TConfig extends UserConfig<infer TInput> ? UserConfig<TInput> : never\ntype DefinedConfig<TConfig extends ConfigInput> = TConfig extends (cli: CLIOptions) => PossiblePromise<infer TResult>\n  ? (cli: CLIOptions) => Promise<NormalizeConfig<TResult>>\n  : TConfig extends Promise<infer TResult>\n    ? Promise<NormalizeConfig<TResult>>\n    : NormalizeConfig<TConfig>\n\n/**\n * Applies default `root`, adapter, parsers, plugins, `output.barrel`, `output.format`, and `output.lint` to a single user config when not set.\n *\n * - `root` defaults to `process.cwd()`\n * - `adapter` defaults to `adapterOas()`\n * - `parsers` defaults to `[parserTs(), parserTsx(), parserMd()]`\n * - `reporters` defaults to `[cliReporter, jsonReporter, fileReporter]`\n * - `plugins` gets `pluginBarrel()` appended when none is already present\n * - `output.barrel` defaults to `{ type: 'named' }` when not set (`pluginBarrel` is always present after the step above)\n * - `output.format` defaults to `false`\n * - `output.lint` defaults to `false`\n */\nfunction applyDefaults<TInput>(config: UserConfig<TInput>): UserConfig<TInput> {\n  const { adapter, output, plugins } = applyConfigDefaults(config, {\n    defaultAdapter: adapterOas(),\n    barrelPlugin: pluginBarrel(),\n    barrelPluginName: pluginBarrelName,\n    defaultOutput: { barrel: { type: 'named' }, format: false, lint: false },\n  })\n\n  return {\n    ...config,\n    root: config.root || process.cwd(),\n    adapter,\n    parsers: config.parsers?.length ? config.parsers : [parserTs(), parserTsx(), parserMd()],\n    reporters: config.reporters?.length ? config.reporters : [cliReporter, jsonReporter, fileReporter],\n    plugins,\n    output,\n  }\n}\n\nfunction normalizeConfig<TInput>(config: UserConfig<TInput> | Array<UserConfig<TInput>>): UserConfig<TInput> | Array<UserConfig<TInput>> {\n  if (Array.isArray(config)) {\n    return config.map(applyDefaults)\n  }\n\n  return applyDefaults(config)\n}\n\n/**\n * Defines a Kubb build configuration and fills in defaults for any omitted fields.\n *\n * Defaults applied when omitted:\n * - `adapter` → `adapterOas()` (OpenAPI 2.0/3.0/3.1).\n * - `parsers` → `[parserTs(), parserTsx(), parserMd()]`.\n * - `reporters` → `[cliReporter, jsonReporter, fileReporter]`.\n * - `plugins` → `pluginBarrel()` is appended when not already present.\n * - `output.barrel` → `{ type: 'named' }` when not set.\n * - `output.format` and `output.lint` → `false`.\n *\n * Accepts a config object, an array of configs, a Promise resolving to one,\n * or a function that receives the parsed CLI options and returns any of the\n * above. The return type is preserved so async/array variants stay typed.\n *\n * @example\n * ```ts\n * import { defineConfig } from 'kubb'\n * import { pluginTs } from '@kubb/plugin-ts'\n *\n * export default defineConfig({\n *   input: './petStore.yaml',\n *   output: { path: './src/gen' },\n *   plugins: [pluginTs()],\n * })\n * ```\n *\n * @example Function form with CLI options\n * ```ts\n * import { defineConfig } from 'kubb'\n *\n * export default defineConfig(({ input }) => ({\n *   input: input ?? './petStore.yaml',\n *   output: { path: './src/gen' },\n *   plugins: [],\n * }))\n * ```\n */\nexport function defineConfig<TConfig extends ConfigInput>(config: TConfig): DefinedConfig<TConfig> {\n  if (typeof config === 'function') {\n    return (async (cli: CLIOptions) => {\n      return normalizeConfig(await config(cli))\n    }) as DefinedConfig<TConfig>\n  }\n\n  if (isPromise(config)) {\n    return config.then((resolved) => normalizeConfig(resolved)) as DefinedConfig<TConfig>\n  }\n\n  return normalizeConfig(config) as DefinedConfig<TConfig>\n}\n"],"mappings":";;;;;;;;;;;;;;;AAqBA,SAAgB,UAAa,QAAkD;CAC7E,OAAO,WAAW,QAAQ,WAAW,KAAA,KAAa,OAAQ,OAAmC,YAAY;AAC3G;;;;;;;;;;;;;;;ACMA,SAAS,cAAsB,QAAgD;CAC7E,MAAM,EAAE,SAAS,QAAQ,aAAA,GAAA,WAAA,oBAAA,CAAgC,QAAQ;EAC/D,iBAAA,GAAA,kBAAA,WAAA,CAA2B;EAC3B,eAAA,GAAA,oBAAA,aAAA,CAA2B;EAC3B,kBAAkBA,oBAAAA;EAClB,eAAe;GAAE,QAAQ,EAAE,MAAM,QAAQ;GAAG,QAAQ;GAAO,MAAM;EAAM;CACzE,CAAC;CAED,OAAO;EACL,GAAG;EACH,MAAM,OAAO,QAAQ,QAAQ,IAAI;EACjC;EACA,SAAS,OAAO,SAAS,SAAS,OAAO,UAAU;iCAAU;kCAAa;iCAAY;EAAC;EACvF,WAAW,OAAO,WAAW,SAAS,OAAO,YAAY;GAACC,WAAAA;GAAaC,WAAAA;GAAcC,WAAAA;EAAY;EACjG;EACA;CACF;AACF;AAEA,SAAS,gBAAwB,QAAwG;CACvI,IAAI,MAAM,QAAQ,MAAM,GACtB,OAAO,OAAO,IAAI,aAAa;CAGjC,OAAO,cAAc,MAAM;AAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,SAAgB,aAA0C,QAAyC;CACjG,IAAI,OAAO,WAAW,YACpB,QAAQ,OAAO,QAAoB;EACjC,OAAO,gBAAgB,MAAM,OAAO,GAAG,CAAC;CAC1C;CAGF,IAAI,UAAU,MAAM,GAClB,OAAO,OAAO,MAAM,aAAa,gBAAgB,QAAQ,CAAC;CAG5D,OAAO,gBAAgB,MAAM;AAC/B"}