kubb 5.0.0-beta.80 → 5.0.0-beta.82

package/dist/ast.cjs

@@ -0,0 +1,374 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _kubb_ast = require("@kubb/ast");
+Object.defineProperty(exports, "applyMacros", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.applyMacros;
+	}
+});
+Object.defineProperty(exports, "arrowFunctionDef", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.arrowFunctionDef;
+	}
+});
+Object.defineProperty(exports, "breakDef", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.breakDef;
+	}
+});
+Object.defineProperty(exports, "buildJSDoc", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.buildJSDoc;
+	}
+});
+Object.defineProperty(exports, "buildList", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.buildList;
+	}
+});
+Object.defineProperty(exports, "buildObject", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.buildObject;
+	}
+});
+Object.defineProperty(exports, "childName", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.childName;
+	}
+});
+Object.defineProperty(exports, "collect", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.collect;
+	}
+});
+Object.defineProperty(exports, "collectUsedSchemaNames", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.collectUsedSchemaNames;
+	}
+});
+Object.defineProperty(exports, "composeMacros", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.composeMacros;
+	}
+});
+Object.defineProperty(exports, "constDef", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.constDef;
+	}
+});
+Object.defineProperty(exports, "containsCircularRef", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.containsCircularRef;
+	}
+});
+Object.defineProperty(exports, "contentDef", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.contentDef;
+	}
+});
+Object.defineProperty(exports, "createPrinter", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.createPrinter;
+	}
+});
+Object.defineProperty(exports, "defineDialect", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.defineDialect;
+	}
+});
+Object.defineProperty(exports, "defineMacro", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.defineMacro;
+	}
+});
+Object.defineProperty(exports, "defineNode", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.defineNode;
+	}
+});
+Object.defineProperty(exports, "enumPropName", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.enumPropName;
+	}
+});
+Object.defineProperty(exports, "exportDef", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.exportDef;
+	}
+});
+Object.defineProperty(exports, "extractRefName", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.extractRefName;
+	}
+});
+Object.defineProperty(exports, "extractStringsFromNodes", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.extractStringsFromNodes;
+	}
+});
+Object.defineProperty(exports, "fileDef", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.fileDef;
+	}
+});
+Object.defineProperty(exports, "findCircularSchemas", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.findCircularSchemas;
+	}
+});
+Object.defineProperty(exports, "functionDef", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.functionDef;
+	}
+});
+Object.defineProperty(exports, "getNestedAccessor", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.getNestedAccessor;
+	}
+});
+Object.defineProperty(exports, "importDef", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.importDef;
+	}
+});
+Object.defineProperty(exports, "inputDef", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.inputDef;
+	}
+});
+Object.defineProperty(exports, "isHttpOperationNode", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.isHttpOperationNode;
+	}
+});
+Object.defineProperty(exports, "isStringType", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.isStringType;
+	}
+});
+Object.defineProperty(exports, "isValidVarName", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.isValidVarName;
+	}
+});
+Object.defineProperty(exports, "jsStringEscape", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.jsStringEscape;
+	}
+});
+Object.defineProperty(exports, "jsxDef", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.jsxDef;
+	}
+});
+Object.defineProperty(exports, "lazyGetter", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.lazyGetter;
+	}
+});
+Object.defineProperty(exports, "macroDiscriminatorEnum", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.macroDiscriminatorEnum;
+	}
+});
+Object.defineProperty(exports, "macroEnumName", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.macroEnumName;
+	}
+});
+Object.defineProperty(exports, "macroSimplifyUnion", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.macroSimplifyUnion;
+	}
+});
+Object.defineProperty(exports, "mapSchemaItems", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.mapSchemaItems;
+	}
+});
+Object.defineProperty(exports, "mapSchemaMembers", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.mapSchemaMembers;
+	}
+});
+Object.defineProperty(exports, "mapSchemaProperties", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.mapSchemaProperties;
+	}
+});
+Object.defineProperty(exports, "mergeAdjacentObjectsLazy", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.mergeAdjacentObjectsLazy;
+	}
+});
+Object.defineProperty(exports, "narrowSchema", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.narrowSchema;
+	}
+});
+Object.defineProperty(exports, "nodeDefs", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.nodeDefs;
+	}
+});
+Object.defineProperty(exports, "objectKey", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.objectKey;
+	}
+});
+Object.defineProperty(exports, "operationDef", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.operationDef;
+	}
+});
+Object.defineProperty(exports, "optionality", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.optionality;
+	}
+});
+Object.defineProperty(exports, "outputDef", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.outputDef;
+	}
+});
+Object.defineProperty(exports, "parameterDef", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.parameterDef;
+	}
+});
+Object.defineProperty(exports, "propertyDef", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.propertyDef;
+	}
+});
+Object.defineProperty(exports, "requestBodyDef", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.requestBodyDef;
+	}
+});
+Object.defineProperty(exports, "responseDef", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.responseDef;
+	}
+});
+Object.defineProperty(exports, "schemaDef", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.schemaDef;
+	}
+});
+Object.defineProperty(exports, "schemaTypes", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.schemaTypes;
+	}
+});
+Object.defineProperty(exports, "sourceDef", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.sourceDef;
+	}
+});
+Object.defineProperty(exports, "stringify", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.stringify;
+	}
+});
+Object.defineProperty(exports, "stringifyObject", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.stringifyObject;
+	}
+});
+Object.defineProperty(exports, "syncSchemaRef", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.syncSchemaRef;
+	}
+});
+Object.defineProperty(exports, "textDef", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.textDef;
+	}
+});
+Object.defineProperty(exports, "toRegExpString", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.toRegExpString;
+	}
+});
+Object.defineProperty(exports, "transform", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.transform;
+	}
+});
+Object.defineProperty(exports, "trimQuotes", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.trimQuotes;
+	}
+});
+Object.defineProperty(exports, "typeDef", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.typeDef;
+	}
+});
+Object.defineProperty(exports, "walk", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.walk;
+	}
+});

package/dist/ast.d.ts

@@ -0,0 +1,3 @@
+import { applyMacros, arrowFunctionDef, breakDef, buildJSDoc, buildList, buildObject, childName, collect, collectUsedSchemaNames, composeMacros, constDef, containsCircularRef, contentDef, createPrinter, defineDialect, defineMacro, defineNode, enumPropName, exportDef, extractRefName, extractStringsFromNodes, fileDef, findCircularSchemas, functionDef, getNestedAccessor, importDef, inputDef, isHttpOperationNode, isStringType, isValidVarName, jsStringEscape, jsxDef, lazyGetter, macroDiscriminatorEnum, macroEnumName, macroSimplifyUnion, mapSchemaItems, mapSchemaMembers, mapSchemaProperties, mergeAdjacentObjectsLazy, narrowSchema, nodeDefs, objectKey, operationDef, optionality, outputDef, parameterDef, propertyDef, requestBodyDef, responseDef, schemaDef, schemaTypes, sourceDef, stringify, stringifyObject, syncSchemaRef, textDef, toRegExpString, transform, trimQuotes, typeDef, walk } from "@kubb/ast";
+export type * from "@kubb/ast";
+export { applyMacros, arrowFunctionDef, breakDef, buildJSDoc, buildList, buildObject, childName, collect, collectUsedSchemaNames, composeMacros, constDef, containsCircularRef, contentDef, createPrinter, defineDialect, defineMacro, defineNode, enumPropName, exportDef, extractRefName, extractStringsFromNodes, fileDef, findCircularSchemas, functionDef, getNestedAccessor, importDef, inputDef, isHttpOperationNode, isStringType, isValidVarName, jsStringEscape, jsxDef, lazyGetter, macroDiscriminatorEnum, macroEnumName, macroSimplifyUnion, mapSchemaItems, mapSchemaMembers, mapSchemaProperties, mergeAdjacentObjectsLazy, narrowSchema, nodeDefs, objectKey, operationDef, optionality, outputDef, parameterDef, propertyDef, requestBodyDef, responseDef, schemaDef, schemaTypes, sourceDef, stringify, stringifyObject, syncSchemaRef, textDef, toRegExpString, transform, trimQuotes, typeDef, walk };

package/dist/ast.js

@@ -0,0 +1,2 @@
+import { applyMacros, arrowFunctionDef, breakDef, buildJSDoc, buildList, buildObject, childName, collect, collectUsedSchemaNames, composeMacros, constDef, containsCircularRef, contentDef, createPrinter, defineDialect, defineMacro, defineNode, enumPropName, exportDef, extractRefName, extractStringsFromNodes, fileDef, findCircularSchemas, functionDef, getNestedAccessor, importDef, inputDef, isHttpOperationNode, isStringType, isValidVarName, jsStringEscape, jsxDef, lazyGetter, macroDiscriminatorEnum, macroEnumName, macroSimplifyUnion, mapSchemaItems, mapSchemaMembers, mapSchemaProperties, mergeAdjacentObjectsLazy, narrowSchema, nodeDefs, objectKey, operationDef, optionality, outputDef, parameterDef, propertyDef, requestBodyDef, responseDef, schemaDef, schemaTypes, sourceDef, stringify, stringifyObject, syncSchemaRef, textDef, toRegExpString, transform, trimQuotes, typeDef, walk } from "@kubb/ast";
+export { applyMacros, arrowFunctionDef, breakDef, buildJSDoc, buildList, buildObject, childName, collect, collectUsedSchemaNames, composeMacros, constDef, containsCircularRef, contentDef, createPrinter, defineDialect, defineMacro, defineNode, enumPropName, exportDef, extractRefName, extractStringsFromNodes, fileDef, findCircularSchemas, functionDef, getNestedAccessor, importDef, inputDef, isHttpOperationNode, isStringType, isValidVarName, jsStringEscape, jsxDef, lazyGetter, macroDiscriminatorEnum, macroEnumName, macroSimplifyUnion, mapSchemaItems, mapSchemaMembers, mapSchemaProperties, mergeAdjacentObjectsLazy, narrowSchema, nodeDefs, objectKey, operationDef, optionality, outputDef, parameterDef, propertyDef, requestBodyDef, responseDef, schemaDef, schemaTypes, sourceDef, stringify, stringifyObject, syncSchemaRef, textDef, toRegExpString, transform, trimQuotes, typeDef, walk };

package/dist/config.cjs

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

package/dist/config.d.ts

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

package/dist/config.js

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

package/dist/defineConfig-BXme6pNF.cjs

@@ -0,0 +1,117 @@
+//#endregion
+let _kubb_core = require("@kubb/core");
+let _kubb_adapter_oas = require("@kubb/adapter-oas");
+let _kubb_plugin_barrel = require("@kubb/plugin-barrel");
+let _kubb_parser_ts = require("@kubb/parser-ts");
+let _kubb_parser_md = require("@kubb/parser-md");
+//#region ../../internals/utils/src/promise.ts
+/** Returns `true` when `result` is a thenable `Promise`.
+*
+* @example
+* ```ts
+* isPromise(Promise.resolve(1)) // true
+* isPromise(42)                 // false
+* ```
+*/
+function isPromise(result) {
+	return result !== null && result !== void 0 && typeof result["then"] === "function";
+}
+//#endregion
+//#region src/defineConfig.ts
+/**
+* Applies default `root`, adapter, parsers, plugins, `output.barrel`, `output.format`, and `output.lint` to a single user config when not set.
+*
+* - `root` defaults to `process.cwd()`
+* - `adapter` defaults to `adapterOas()`
+* - `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' }` only when `pluginBarrel` is part of `plugins`.
+*   When the user provides a plugins list without `pluginBarrel`, `barrel` is left untouched.
+* - `output.format` defaults to `false`
+* - `output.lint` defaults to `false`
+*/
+function applyDefaults(config) {
+	const plugins = config.plugins?.some((p) => p.name === _kubb_plugin_barrel.pluginBarrelName) ? config.plugins ?? [] : [...config.plugins ?? [], (0, _kubb_plugin_barrel.pluginBarrel)()];
+	const hasBarrelPlugin = plugins.some((p) => p.name === _kubb_plugin_barrel.pluginBarrelName);
+	const output = { ...config.output };
+	if (hasBarrelPlugin && output.barrel === void 0) output.barrel = { type: "named" };
+	if (output.format === void 0) output.format = false;
+	if (output.lint === void 0) output.lint = false;
+	return {
+		...config,
+		root: config.root || process.cwd(),
+		adapter: config.adapter ?? (0, _kubb_adapter_oas.adapterOas)(),
+		parsers: config.parsers?.length ? config.parsers : [
+			_kubb_parser_ts.parserTs,
+			_kubb_parser_ts.parserTsx,
+			_kubb_parser_md.parserMd
+		],
+		reporters: config.reporters?.length ? config.reporters : [
+			_kubb_core.cliReporter,
+			_kubb_core.jsonReporter,
+			_kubb_core.fileReporter
+		],
+		plugins,
+		output
+	};
+}
+function normalizeConfig(config) {
+	if (Array.isArray(config)) return config.map(applyDefaults);
+	return applyDefaults(config);
+}
+/**
+* Defines a Kubb build configuration and fills in defaults for any omitted fields.
+*
+* Defaults applied when omitted:
+* - `adapter` → `adapterOas()` (OpenAPI 2.0/3.0/3.1).
+* - `parsers` → `[parserTs, parserTsx, parserMd]`.
+* - `reporters` → `[cliReporter, jsonReporter, fileReporter]`.
+* - `plugins` → `pluginBarrel()` is appended when not already present.
+* - `output.barrel` → `{ type: 'named' }` only when `pluginBarrel` is
+*   in the plugins list.
+* - `output.format` and `output.lint` → `false`.
+*
+* Accepts a config object, an array of configs, a Promise resolving to one,
+* or a function that receives the parsed CLI options and returns any of the
+* above. The return type is preserved so async/array variants stay typed.
+*
+* @example
+* ```ts
+* import { defineConfig } from 'kubb'
+* import { pluginTs } from '@kubb/plugin-ts'
+*
+* export default defineConfig({
+*   input: { path: './petStore.yaml' },
+*   output: { path: './src/gen' },
+*   plugins: [pluginTs()],
+* })
+* ```
+*
+* @example Function form with CLI options
+* ```ts
+* import { defineConfig } from 'kubb'
+*
+* export default defineConfig(({ input }) => ({
+*   input: { path: input ?? './petStore.yaml' },
+*   output: { path: './src/gen' },
+*   plugins: [],
+* }))
+* ```
+*/
+function defineConfig(config) {
+	if (typeof config === "function") return (async (cli) => {
+		return normalizeConfig(await config(cli));
+	});
+	if (isPromise(config)) return config.then((resolved) => normalizeConfig(resolved));
+	return normalizeConfig(config);
+}
+//#endregion
+Object.defineProperty(exports, "defineConfig", {
+	enumerable: true,
+	get: function() {
+		return defineConfig;
+	}
+});
+
+//# sourceMappingURL=defineConfig-BXme6pNF.cjs.map

package/dist/defineConfig-BXme6pNF.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineConfig-BXme6pNF.cjs","names":["pluginBarrelName","parserTs","parserTsx","parserMd","cliReporter","jsonReporter","fileReporter"],"sources":["../../../internals/utils/src/promise.ts","../src/defineConfig.ts"],"sourcesContent":["/** 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\n/**\n * Container that switches between an eager `Array<T>` and a lazy `AsyncIterable<T>`.\n *\n * `Array<T>` by default. With `Stream` set to `true` it becomes `AsyncIterable<T>`, so large\n * collections can be produced lazily without holding every item in memory. Pairs with\n * {@link arrayToAsyncIterable}, which lifts a plain array into the streaming form.\n *\n * @example\n * ```ts\n * type Eager = Streamable<number> // Array<number>\n * type Lazy = Streamable<number, true> // AsyncIterable<number>\n * ```\n */\nexport type Streamable<T, Stream extends boolean = false> = Stream extends true ? AsyncIterable<T> : Array<T>\n\n/**\n * Wraps a plain array in a reusable `AsyncIterable`.\n * Each `[Symbol.asyncIterator]()` call returns a fresh generator so the\n * iterable can be consumed multiple times (e.g. once per plugin pre-scan).\n *\n * @example\n * ```ts\n * const stream = arrayToAsyncIterable([1, 2, 3])\n * for await (const n of stream) console.log(n) // 1, 2, 3\n * ```\n */\nexport function arrayToAsyncIterable<T>(arr: ReadonlyArray<T>): AsyncIterable<T> {\n  return {\n    [Symbol.asyncIterator]() {\n      return (async function* () {\n        yield* arr\n      })()\n    },\n  }\n}\n","import { isPromise, type PossiblePromise } from '@internals/utils'\nimport { adapterOas } from '@kubb/adapter-oas'\nimport { 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<any> | Array<UserConfig<any>>\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' }` only when `pluginBarrel` is part of `plugins`.\n *   When the user provides a plugins list without `pluginBarrel`, `barrel` is left untouched.\n * - `output.format` defaults to `false`\n * - `output.lint` defaults to `false`\n */\nfunction applyDefaults<TInput>(config: UserConfig<TInput>): UserConfig<TInput> {\n  const alreadyHasBarrel = config.plugins?.some((p) => p.name === pluginBarrelName)\n  const plugins = alreadyHasBarrel ? (config.plugins ?? []) : [...(config.plugins ?? []), pluginBarrel()]\n  const hasBarrelPlugin = plugins.some((p) => p.name === pluginBarrelName)\n\n  const output = { ...config.output }\n  if (hasBarrelPlugin && output.barrel === undefined) {\n    output.barrel = { type: 'named' }\n  }\n  if (output.format === undefined) {\n    output.format = false\n  }\n  if (output.lint === undefined) {\n    output.lint = false\n  }\n\n  return {\n    ...config,\n    root: config.root || process.cwd(),\n    adapter: config.adapter ?? adapterOas(),\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' }` only when `pluginBarrel` is\n *   in the plugins list.\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: { path: './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: { path: 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":";;;;;;;;;;;;;;;AAmBA,SAAgB,UAAa,QAAkD;CAC7E,OAAO,WAAW,QAAQ,WAAW,KAAA,KAAa,OAAQ,OAAmC,YAAY;AAC3G;;;;;;;;;;;;;;;;ACSA,SAAS,cAAsB,QAAgD;CAE7E,MAAM,UADmB,OAAO,SAAS,MAAM,MAAM,EAAE,SAASA,oBAAAA,gBAAgB,IAC5C,OAAO,WAAW,CAAC,IAAK,CAAC,GAAI,OAAO,WAAW,CAAC,IAAA,GAAA,oBAAA,aAAA,CAAiB,CAAC;CACtG,MAAM,kBAAkB,QAAQ,MAAM,MAAM,EAAE,SAASA,oBAAAA,gBAAgB;CAEvE,MAAM,SAAS,EAAE,GAAG,OAAO,OAAO;CAClC,IAAI,mBAAmB,OAAO,WAAW,KAAA,GACvC,OAAO,SAAS,EAAE,MAAM,QAAQ;CAElC,IAAI,OAAO,WAAW,KAAA,GACpB,OAAO,SAAS;CAElB,IAAI,OAAO,SAAS,KAAA,GAClB,OAAO,OAAO;CAGhB,OAAO;EACL,GAAG;EACH,MAAM,OAAO,QAAQ,QAAQ,IAAI;EACjC,SAAS,OAAO,YAAA,GAAA,kBAAA,WAAA,CAAsB;EACtC,SAAS,OAAO,SAAS,SAAS,OAAO,UAAU;GAACC,gBAAAA;GAAUC,gBAAAA;GAAWC,gBAAAA;EAAQ;EACjF,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,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-Bz5OdPiM.d.ts

@@ -0,0 +1,63 @@
+import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
+import { CLIOptions, UserConfig } from "@kubb/core";
+
+//#region ../../internals/utils/src/promise.d.ts
+/** A value that may already be resolved or still pending.
+ *
+ * @example
+ * ```ts
+ * function load(id: string): PossiblePromise<string> {
+ *   return cache.get(id) ?? fetchRemote(id)
+ * }
+ * ```
+ */
+type PossiblePromise<T> = Promise<T> | T;
+//#endregion
+//#region src/defineConfig.d.ts
+type AnyConfigResult = UserConfig<any> | Array<UserConfig<any>>;
+type ConfigInput = AnyConfigResult | Promise<AnyConfigResult> | ((cli: CLIOptions) => PossiblePromise<AnyConfigResult>);
+type NormalizeConfig<TConfig> = TConfig extends Array<UserConfig<infer TInput>> ? Array<UserConfig<TInput>> : TConfig extends UserConfig<infer TInput> ? UserConfig<TInput> : never;
+type DefinedConfig<TConfig extends ConfigInput> = TConfig extends ((cli: CLIOptions) => PossiblePromise<infer TResult>) ? (cli: CLIOptions) => Promise<NormalizeConfig<TResult>> : TConfig extends Promise<infer TResult> ? Promise<NormalizeConfig<TResult>> : NormalizeConfig<TConfig>;
+/**
+ * Defines a Kubb build configuration and fills in defaults for any omitted fields.
+ *
+ * Defaults applied when omitted:
+ * - `adapter` → `adapterOas()` (OpenAPI 2.0/3.0/3.1).
+ * - `parsers` → `[parserTs, parserTsx, parserMd]`.
+ * - `reporters` → `[cliReporter, jsonReporter, fileReporter]`.
+ * - `plugins` → `pluginBarrel()` is appended when not already present.
+ * - `output.barrel` → `{ type: 'named' }` only when `pluginBarrel` is
+ *   in the plugins list.
+ * - `output.format` and `output.lint` → `false`.
+ *
+ * Accepts a config object, an array of configs, a Promise resolving to one,
+ * or a function that receives the parsed CLI options and returns any of the
+ * above. The return type is preserved so async/array variants stay typed.
+ *
+ * @example
+ * ```ts
+ * import { defineConfig } from 'kubb'
+ * import { pluginTs } from '@kubb/plugin-ts'
+ *
+ * export default defineConfig({
+ *   input: { path: './petStore.yaml' },
+ *   output: { path: './src/gen' },
+ *   plugins: [pluginTs()],
+ * })
+ * ```
+ *
+ * @example Function form with CLI options
+ * ```ts
+ * import { defineConfig } from 'kubb'
+ *
+ * export default defineConfig(({ input }) => ({
+ *   input: { path: input ?? './petStore.yaml' },
+ *   output: { path: './src/gen' },
+ *   plugins: [],
+ * }))
+ * ```
+ */
+declare function defineConfig<TConfig extends ConfigInput>(config: TConfig): DefinedConfig<TConfig>;
+//#endregion
+export { defineConfig as t };
+//# sourceMappingURL=defineConfig-Bz5OdPiM.d.ts.map

package/dist/defineConfig-D01AIFC1.js

@@ -0,0 +1,112 @@
+import "./rolldown-runtime-C0LytTxp.js";
+import { cliReporter, fileReporter, jsonReporter } from "@kubb/core";
+import { adapterOas } from "@kubb/adapter-oas";
+import { pluginBarrel, pluginBarrelName } from "@kubb/plugin-barrel";
+import { parserTs, parserTsx } from "@kubb/parser-ts";
+import { parserMd } from "@kubb/parser-md";
+//#region ../../internals/utils/src/promise.ts
+/** Returns `true` when `result` is a thenable `Promise`.
+*
+* @example
+* ```ts
+* isPromise(Promise.resolve(1)) // true
+* isPromise(42)                 // false
+* ```
+*/
+function isPromise(result) {
+	return result !== null && result !== void 0 && typeof result["then"] === "function";
+}
+//#endregion
+//#region src/defineConfig.ts
+/**
+* Applies default `root`, adapter, parsers, plugins, `output.barrel`, `output.format`, and `output.lint` to a single user config when not set.
+*
+* - `root` defaults to `process.cwd()`
+* - `adapter` defaults to `adapterOas()`
+* - `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' }` only when `pluginBarrel` is part of `plugins`.
+*   When the user provides a plugins list without `pluginBarrel`, `barrel` is left untouched.
+* - `output.format` defaults to `false`
+* - `output.lint` defaults to `false`
+*/
+function applyDefaults(config) {
+	const plugins = config.plugins?.some((p) => p.name === pluginBarrelName) ? config.plugins ?? [] : [...config.plugins ?? [], pluginBarrel()];
+	const hasBarrelPlugin = plugins.some((p) => p.name === pluginBarrelName);
+	const output = { ...config.output };
+	if (hasBarrelPlugin && output.barrel === void 0) output.barrel = { type: "named" };
+	if (output.format === void 0) output.format = false;
+	if (output.lint === void 0) output.lint = false;
+	return {
+		...config,
+		root: config.root || process.cwd(),
+		adapter: config.adapter ?? adapterOas(),
+		parsers: config.parsers?.length ? config.parsers : [
+			parserTs,
+			parserTsx,
+			parserMd
+		],
+		reporters: config.reporters?.length ? config.reporters : [
+			cliReporter,
+			jsonReporter,
+			fileReporter
+		],
+		plugins,
+		output
+	};
+}
+function normalizeConfig(config) {
+	if (Array.isArray(config)) return config.map(applyDefaults);
+	return applyDefaults(config);
+}
+/**
+* Defines a Kubb build configuration and fills in defaults for any omitted fields.
+*
+* Defaults applied when omitted:
+* - `adapter` → `adapterOas()` (OpenAPI 2.0/3.0/3.1).
+* - `parsers` → `[parserTs, parserTsx, parserMd]`.
+* - `reporters` → `[cliReporter, jsonReporter, fileReporter]`.
+* - `plugins` → `pluginBarrel()` is appended when not already present.
+* - `output.barrel` → `{ type: 'named' }` only when `pluginBarrel` is
+*   in the plugins list.
+* - `output.format` and `output.lint` → `false`.
+*
+* Accepts a config object, an array of configs, a Promise resolving to one,
+* or a function that receives the parsed CLI options and returns any of the
+* above. The return type is preserved so async/array variants stay typed.
+*
+* @example
+* ```ts
+* import { defineConfig } from 'kubb'
+* import { pluginTs } from '@kubb/plugin-ts'
+*
+* export default defineConfig({
+*   input: { path: './petStore.yaml' },
+*   output: { path: './src/gen' },
+*   plugins: [pluginTs()],
+* })
+* ```
+*
+* @example Function form with CLI options
+* ```ts
+* import { defineConfig } from 'kubb'
+*
+* export default defineConfig(({ input }) => ({
+*   input: { path: input ?? './petStore.yaml' },
+*   output: { path: './src/gen' },
+*   plugins: [],
+* }))
+* ```
+*/
+function defineConfig(config) {
+	if (typeof config === "function") return (async (cli) => {
+		return normalizeConfig(await config(cli));
+	});
+	if (isPromise(config)) return config.then((resolved) => normalizeConfig(resolved));
+	return normalizeConfig(config);
+}
+//#endregion
+export { defineConfig as t };
+
+//# sourceMappingURL=defineConfig-D01AIFC1.js.map

package/dist/defineConfig-D01AIFC1.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineConfig-D01AIFC1.js","names":[],"sources":["../../../internals/utils/src/promise.ts","../src/defineConfig.ts"],"sourcesContent":["/** 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\n/**\n * Container that switches between an eager `Array<T>` and a lazy `AsyncIterable<T>`.\n *\n * `Array<T>` by default. With `Stream` set to `true` it becomes `AsyncIterable<T>`, so large\n * collections can be produced lazily without holding every item in memory. Pairs with\n * {@link arrayToAsyncIterable}, which lifts a plain array into the streaming form.\n *\n * @example\n * ```ts\n * type Eager = Streamable<number> // Array<number>\n * type Lazy = Streamable<number, true> // AsyncIterable<number>\n * ```\n */\nexport type Streamable<T, Stream extends boolean = false> = Stream extends true ? AsyncIterable<T> : Array<T>\n\n/**\n * Wraps a plain array in a reusable `AsyncIterable`.\n * Each `[Symbol.asyncIterator]()` call returns a fresh generator so the\n * iterable can be consumed multiple times (e.g. once per plugin pre-scan).\n *\n * @example\n * ```ts\n * const stream = arrayToAsyncIterable([1, 2, 3])\n * for await (const n of stream) console.log(n) // 1, 2, 3\n * ```\n */\nexport function arrayToAsyncIterable<T>(arr: ReadonlyArray<T>): AsyncIterable<T> {\n  return {\n    [Symbol.asyncIterator]() {\n      return (async function* () {\n        yield* arr\n      })()\n    },\n  }\n}\n","import { isPromise, type PossiblePromise } from '@internals/utils'\nimport { adapterOas } from '@kubb/adapter-oas'\nimport { 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<any> | Array<UserConfig<any>>\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' }` only when `pluginBarrel` is part of `plugins`.\n *   When the user provides a plugins list without `pluginBarrel`, `barrel` is left untouched.\n * - `output.format` defaults to `false`\n * - `output.lint` defaults to `false`\n */\nfunction applyDefaults<TInput>(config: UserConfig<TInput>): UserConfig<TInput> {\n  const alreadyHasBarrel = config.plugins?.some((p) => p.name === pluginBarrelName)\n  const plugins = alreadyHasBarrel ? (config.plugins ?? []) : [...(config.plugins ?? []), pluginBarrel()]\n  const hasBarrelPlugin = plugins.some((p) => p.name === pluginBarrelName)\n\n  const output = { ...config.output }\n  if (hasBarrelPlugin && output.barrel === undefined) {\n    output.barrel = { type: 'named' }\n  }\n  if (output.format === undefined) {\n    output.format = false\n  }\n  if (output.lint === undefined) {\n    output.lint = false\n  }\n\n  return {\n    ...config,\n    root: config.root || process.cwd(),\n    adapter: config.adapter ?? adapterOas(),\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' }` only when `pluginBarrel` is\n *   in the plugins list.\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: { path: './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: { path: 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":";;;;;;;;;;;;;;;AAmBA,SAAgB,UAAa,QAAkD;CAC7E,OAAO,WAAW,QAAQ,WAAW,KAAA,KAAa,OAAQ,OAAmC,YAAY;AAC3G;;;;;;;;;;;;;;;;ACSA,SAAS,cAAsB,QAAgD;CAE7E,MAAM,UADmB,OAAO,SAAS,MAAM,MAAM,EAAE,SAAS,gBAAgB,IAC5C,OAAO,WAAW,CAAC,IAAK,CAAC,GAAI,OAAO,WAAW,CAAC,GAAI,aAAa,CAAC;CACtG,MAAM,kBAAkB,QAAQ,MAAM,MAAM,EAAE,SAAS,gBAAgB;CAEvE,MAAM,SAAS,EAAE,GAAG,OAAO,OAAO;CAClC,IAAI,mBAAmB,OAAO,WAAW,KAAA,GACvC,OAAO,SAAS,EAAE,MAAM,QAAQ;CAElC,IAAI,OAAO,WAAW,KAAA,GACpB,OAAO,SAAS;CAElB,IAAI,OAAO,SAAS,KAAA,GAClB,OAAO,OAAO;CAGhB,OAAO;EACL,GAAG;EACH,MAAM,OAAO,QAAQ,QAAQ,IAAI;EACjC,SAAS,OAAO,WAAW,WAAW;EACtC,SAAS,OAAO,SAAS,SAAS,OAAO,UAAU;GAAC;GAAU;GAAW;EAAQ;EACjF,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,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/index.cjs

@@ -1,113 +1,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-//#endregion
-let _kubb_adapter_oas = require("@kubb/adapter-oas");
+const require_defineConfig = require("./defineConfig-BXme6pNF.cjs");
 let _kubb_core = require("@kubb/core");
-let _kubb_plugin_barrel = require("@kubb/plugin-barrel");
-let _kubb_parser_ts = require("@kubb/parser-ts");
-let _kubb_parser_md = require("@kubb/parser-md");
-//#region ../../internals/utils/src/promise.ts
-/** Returns `true` when `result` is a thenable `Promise`.
-*
-* @example
-* ```ts
-* isPromise(Promise.resolve(1)) // true
-* isPromise(42)                 // false
-* ```
-*/
-function isPromise(result) {
-	return result !== null && result !== void 0 && typeof result["then"] === "function";
-}
-//#endregion
-//#region src/defineConfig.ts
-/**
-* Applies default `root`, adapter, parsers, plugins, `output.barrel`, `output.format`, and `output.lint` to a single user config when not set.
-*
-* - `root` defaults to `process.cwd()`
-* - `adapter` defaults to `adapterOas()`
-* - `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' }` only when `pluginBarrel` is part of `plugins`.
-*   When the user provides a plugins list without `pluginBarrel`, `barrel` is left untouched.
-* - `output.format` defaults to `false`
-* - `output.lint` defaults to `false`
-*/
-function applyDefaults(config) {
-	const plugins = config.plugins?.some((p) => p.name === _kubb_plugin_barrel.pluginBarrelName) ? config.plugins ?? [] : [...config.plugins ?? [], (0, _kubb_plugin_barrel.pluginBarrel)()];
-	const hasBarrelPlugin = plugins.some((p) => p.name === _kubb_plugin_barrel.pluginBarrelName);
-	const output = { ...config.output };
-	if (hasBarrelPlugin && output.barrel === void 0) output.barrel = { type: "named" };
-	if (output.format === void 0) output.format = false;
-	if (output.lint === void 0) output.lint = false;
-	return {
-		...config,
-		root: config.root || process.cwd(),
-		adapter: config.adapter ?? (0, _kubb_adapter_oas.adapterOas)(),
-		parsers: config.parsers?.length ? config.parsers : [
-			_kubb_parser_ts.parserTs,
-			_kubb_parser_ts.parserTsx,
-			_kubb_parser_md.parserMd
-		],
-		reporters: config.reporters?.length ? config.reporters : [
-			_kubb_core.cliReporter,
-			_kubb_core.jsonReporter,
-			_kubb_core.fileReporter
-		],
-		plugins,
-		output
-	};
-}
-function normalizeConfig(config) {
-	if (Array.isArray(config)) return config.map(applyDefaults);
-	return applyDefaults(config);
-}
-/**
-* Defines a Kubb build configuration and fills in defaults for any omitted fields.
-*
-* Defaults applied when omitted:
-* - `adapter` → `adapterOas()` (OpenAPI 2.0/3.0/3.1).
-* - `parsers` → `[parserTs, parserTsx, parserMd]`.
-* - `reporters` → `[cliReporter, jsonReporter, fileReporter]`.
-* - `plugins` → `pluginBarrel()` is appended when not already present.
-* - `output.barrel` → `{ type: 'named' }` only when `pluginBarrel` is
-*   in the plugins list.
-* - `output.format` and `output.lint` → `false`.
-*
-* Accepts a config object, an array of configs, a Promise resolving to one,
-* or a function that receives the parsed CLI options and returns any of the
-* above. The return type is preserved so async/array variants stay typed.
-*
-* @example
-* ```ts
-* import { defineConfig } from 'kubb'
-* import { pluginTs } from '@kubb/plugin-ts'
-*
-* export default defineConfig({
-*   input: { path: './petStore.yaml' },
-*   output: { path: './src/gen' },
-*   plugins: [pluginTs()],
-* })
-* ```
-*
-* @example Function form with CLI options
-* ```ts
-* import { defineConfig } from 'kubb'
-*
-* export default defineConfig(({ input }) => ({
-*   input: { path: input ?? './petStore.yaml' },
-*   output: { path: './src/gen' },
-*   plugins: [],
-* }))
-* ```
-*/
-function defineConfig(config) {
-	if (typeof config === "function") return (async (cli) => {
-		return normalizeConfig(await config(cli));
-	});
-	if (isPromise(config)) return config.then((resolved) => normalizeConfig(resolved));
-	return normalizeConfig(config);
-}
-//#endregion
-exports.defineConfig = defineConfig;
-
-//# sourceMappingURL=index.cjs.map
+Object.defineProperty(exports, "createKubb", {
+	enumerable: true,
+	get: function() {
+		return _kubb_core.createKubb;
+	}
+});
+exports.defineConfig = require_defineConfig.defineConfig;

package/dist/index.d.ts

@@ -1,64 +1,4 @@
-import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
-import { CLIOptions, UserConfig } from "@kubb/core";
+import { t as defineConfig } from "./defineConfig-Bz5OdPiM.js";
+import { BuildOutput, Config, CreateKubbOptions, Kubb, UserConfig, createKubb } from "@kubb/core";
 import { BarrelType } from "@kubb/plugin-barrel";
-
-//#region ../../internals/utils/src/promise.d.ts
-/** A value that may already be resolved or still pending.
- *
- * @example
- * ```ts
- * function load(id: string): PossiblePromise<string> {
- *   return cache.get(id) ?? fetchRemote(id)
- * }
- * ```
- */
-type PossiblePromise<T> = Promise<T> | T;
-//#endregion
-//#region src/defineConfig.d.ts
-type AnyConfigResult = UserConfig<any> | Array<UserConfig<any>>;
-type ConfigInput = AnyConfigResult | Promise<AnyConfigResult> | ((cli: CLIOptions) => PossiblePromise<AnyConfigResult>);
-type NormalizeConfig<TConfig> = TConfig extends Array<UserConfig<infer TInput>> ? Array<UserConfig<TInput>> : TConfig extends UserConfig<infer TInput> ? UserConfig<TInput> : never;
-type DefinedConfig<TConfig extends ConfigInput> = TConfig extends ((cli: CLIOptions) => PossiblePromise<infer TResult>) ? (cli: CLIOptions) => Promise<NormalizeConfig<TResult>> : TConfig extends Promise<infer TResult> ? Promise<NormalizeConfig<TResult>> : NormalizeConfig<TConfig>;
-/**
- * Defines a Kubb build configuration and fills in defaults for any omitted fields.
- *
- * Defaults applied when omitted:
- * - `adapter` → `adapterOas()` (OpenAPI 2.0/3.0/3.1).
- * - `parsers` → `[parserTs, parserTsx, parserMd]`.
- * - `reporters` → `[cliReporter, jsonReporter, fileReporter]`.
- * - `plugins` → `pluginBarrel()` is appended when not already present.
- * - `output.barrel` → `{ type: 'named' }` only when `pluginBarrel` is
- *   in the plugins list.
- * - `output.format` and `output.lint` → `false`.
- *
- * Accepts a config object, an array of configs, a Promise resolving to one,
- * or a function that receives the parsed CLI options and returns any of the
- * above. The return type is preserved so async/array variants stay typed.
- *
- * @example
- * ```ts
- * import { defineConfig } from 'kubb'
- * import { pluginTs } from '@kubb/plugin-ts'
- *
- * export default defineConfig({
- *   input: { path: './petStore.yaml' },
- *   output: { path: './src/gen' },
- *   plugins: [pluginTs()],
- * })
- * ```
- *
- * @example Function form with CLI options
- * ```ts
- * import { defineConfig } from 'kubb'
- *
- * export default defineConfig(({ input }) => ({
- *   input: { path: input ?? './petStore.yaml' },
- *   output: { path: './src/gen' },
- *   plugins: [],
- * }))
- * ```
- */
-declare function defineConfig<TConfig extends ConfigInput>(config: TConfig): DefinedConfig<TConfig>;
-//#endregion
-export { type BarrelType, defineConfig };
-//# sourceMappingURL=index.d.ts.map
+export { type BarrelType, type BuildOutput, type Config, type CreateKubbOptions, type Kubb, type UserConfig, createKubb, defineConfig };

package/dist/index.js

@@ -1,112 +1,3 @@
-import "./rolldown-runtime-C0LytTxp.js";
-import { adapterOas } from "@kubb/adapter-oas";
-import { cliReporter, fileReporter, jsonReporter } from "@kubb/core";
-import { pluginBarrel, pluginBarrelName } from "@kubb/plugin-barrel";
-import { parserTs, parserTsx } from "@kubb/parser-ts";
-import { parserMd } from "@kubb/parser-md";
-//#region ../../internals/utils/src/promise.ts
-/** Returns `true` when `result` is a thenable `Promise`.
-*
-* @example
-* ```ts
-* isPromise(Promise.resolve(1)) // true
-* isPromise(42)                 // false
-* ```
-*/
-function isPromise(result) {
-	return result !== null && result !== void 0 && typeof result["then"] === "function";
-}
-//#endregion
-//#region src/defineConfig.ts
-/**
-* Applies default `root`, adapter, parsers, plugins, `output.barrel`, `output.format`, and `output.lint` to a single user config when not set.
-*
-* - `root` defaults to `process.cwd()`
-* - `adapter` defaults to `adapterOas()`
-* - `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' }` only when `pluginBarrel` is part of `plugins`.
-*   When the user provides a plugins list without `pluginBarrel`, `barrel` is left untouched.
-* - `output.format` defaults to `false`
-* - `output.lint` defaults to `false`
-*/
-function applyDefaults(config) {
-	const plugins = config.plugins?.some((p) => p.name === pluginBarrelName) ? config.plugins ?? [] : [...config.plugins ?? [], pluginBarrel()];
-	const hasBarrelPlugin = plugins.some((p) => p.name === pluginBarrelName);
-	const output = { ...config.output };
-	if (hasBarrelPlugin && output.barrel === void 0) output.barrel = { type: "named" };
-	if (output.format === void 0) output.format = false;
-	if (output.lint === void 0) output.lint = false;
-	return {
-		...config,
-		root: config.root || process.cwd(),
-		adapter: config.adapter ?? adapterOas(),
-		parsers: config.parsers?.length ? config.parsers : [
-			parserTs,
-			parserTsx,
-			parserMd
-		],
-		reporters: config.reporters?.length ? config.reporters : [
-			cliReporter,
-			jsonReporter,
-			fileReporter
-		],
-		plugins,
-		output
-	};
-}
-function normalizeConfig(config) {
-	if (Array.isArray(config)) return config.map(applyDefaults);
-	return applyDefaults(config);
-}
-/**
-* Defines a Kubb build configuration and fills in defaults for any omitted fields.
-*
-* Defaults applied when omitted:
-* - `adapter` → `adapterOas()` (OpenAPI 2.0/3.0/3.1).
-* - `parsers` → `[parserTs, parserTsx, parserMd]`.
-* - `reporters` → `[cliReporter, jsonReporter, fileReporter]`.
-* - `plugins` → `pluginBarrel()` is appended when not already present.
-* - `output.barrel` → `{ type: 'named' }` only when `pluginBarrel` is
-*   in the plugins list.
-* - `output.format` and `output.lint` → `false`.
-*
-* Accepts a config object, an array of configs, a Promise resolving to one,
-* or a function that receives the parsed CLI options and returns any of the
-* above. The return type is preserved so async/array variants stay typed.
-*
-* @example
-* ```ts
-* import { defineConfig } from 'kubb'
-* import { pluginTs } from '@kubb/plugin-ts'
-*
-* export default defineConfig({
-*   input: { path: './petStore.yaml' },
-*   output: { path: './src/gen' },
-*   plugins: [pluginTs()],
-* })
-* ```
-*
-* @example Function form with CLI options
-* ```ts
-* import { defineConfig } from 'kubb'
-*
-* export default defineConfig(({ input }) => ({
-*   input: { path: input ?? './petStore.yaml' },
-*   output: { path: './src/gen' },
-*   plugins: [],
-* }))
-* ```
-*/
-function defineConfig(config) {
-	if (typeof config === "function") return (async (cli) => {
-		return normalizeConfig(await config(cli));
-	});
-	if (isPromise(config)) return config.then((resolved) => normalizeConfig(resolved));
-	return normalizeConfig(config);
-}
-//#endregion
-export { defineConfig };
-
-//# sourceMappingURL=index.js.map
+import { t as defineConfig } from "./defineConfig-D01AIFC1.js";
+import { createKubb } from "@kubb/core";
+export { createKubb, defineConfig };

package/dist/jsx/jsx-dev-runtime.cjs

@@ -0,0 +1,9 @@
+var _kubb_renderer_jsx_jsx_dev_runtime = require("@kubb/renderer-jsx/jsx-dev-runtime");
+Object.keys(_kubb_renderer_jsx_jsx_dev_runtime).forEach(function(k) {
+	if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function() {
+			return _kubb_renderer_jsx_jsx_dev_runtime[k];
+		}
+	});
+});

package/dist/jsx/jsx-dev-runtime.d.ts

@@ -0,0 +1 @@
+export * from "@kubb/renderer-jsx/jsx-dev-runtime";

package/dist/jsx/jsx-dev-runtime.js

@@ -0,0 +1,2 @@
+export * from "@kubb/renderer-jsx/jsx-dev-runtime";
+export {};

package/dist/jsx/jsx-runtime.cjs

@@ -0,0 +1,9 @@
+var _kubb_renderer_jsx_jsx_runtime = require("@kubb/renderer-jsx/jsx-runtime");
+Object.keys(_kubb_renderer_jsx_jsx_runtime).forEach(function(k) {
+	if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function() {
+			return _kubb_renderer_jsx_jsx_runtime[k];
+		}
+	});
+});

package/dist/jsx/jsx-runtime.d.ts

@@ -0,0 +1 @@
+export * from "@kubb/renderer-jsx/jsx-runtime";

package/dist/jsx/jsx-runtime.js

@@ -0,0 +1,2 @@
+export * from "@kubb/renderer-jsx/jsx-runtime";
+export {};

package/dist/jsx.cjs

@@ -0,0 +1,18 @@
+var _kubb_renderer_jsx = require("@kubb/renderer-jsx");
+Object.keys(_kubb_renderer_jsx).forEach(function(k) {
+	if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function() {
+			return _kubb_renderer_jsx[k];
+		}
+	});
+});
+var _kubb_renderer_jsx_types = require("@kubb/renderer-jsx/types");
+Object.keys(_kubb_renderer_jsx_types).forEach(function(k) {
+	if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function() {
+			return _kubb_renderer_jsx_types[k];
+		}
+	});
+});

package/dist/jsx.d.ts

@@ -0,0 +1,2 @@
+export * from "@kubb/renderer-jsx";
+export * from "@kubb/renderer-jsx/types";

package/dist/jsx.js

@@ -0,0 +1,3 @@
+export * from "@kubb/renderer-jsx";
+export * from "@kubb/renderer-jsx/types";
+export {};

package/dist/kit/testing.cjs

@@ -0,0 +1,9 @@
+var _kubb_kit_testing = require("@kubb/kit/testing");
+Object.keys(_kubb_kit_testing).forEach(function(k) {
+	if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function() {
+			return _kubb_kit_testing[k];
+		}
+	});
+});

package/dist/kit/testing.d.ts

@@ -0,0 +1 @@
+export * from "@kubb/kit/testing";

package/dist/kit/testing.js

@@ -0,0 +1,2 @@
+export * from "@kubb/kit/testing";
+export {};

package/dist/kit.cjs

@@ -0,0 +1,9 @@
+var _kubb_kit = require("@kubb/kit");
+Object.keys(_kubb_kit).forEach(function(k) {
+	if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function() {
+			return _kubb_kit[k];
+		}
+	});
+});

package/dist/kit.d.ts

@@ -0,0 +1 @@
+export * from "@kubb/kit";

package/dist/kit.js

@@ -0,0 +1,2 @@
+export * from "@kubb/kit";
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kubb",
-  "version": "5.0.0-beta.80",
+  "version": "5.0.0-beta.82",
   "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",
@@ -42,6 +42,34 @@
       "import": "./dist/index.js",
       "require": "./dist/index.cjs"
     },
+    "./ast": {
+      "import": "./dist/ast.js",
+      "require": "./dist/ast.cjs"
+    },
+    "./config": {
+      "import": "./dist/config.js",
+      "require": "./dist/config.cjs"
+    },
+    "./jsx": {
+      "import": "./dist/jsx.js",
+      "require": "./dist/jsx.cjs"
+    },
+    "./jsx/jsx-dev-runtime": {
+      "import": "./dist/jsx/jsx-dev-runtime.js",
+      "require": "./dist/jsx/jsx-dev-runtime.cjs"
+    },
+    "./jsx/jsx-runtime": {
+      "import": "./dist/jsx/jsx-runtime.js",
+      "require": "./dist/jsx/jsx-runtime.cjs"
+    },
+    "./kit": {
+      "import": "./dist/kit.js",
+      "require": "./dist/kit.cjs"
+    },
+    "./kit/testing": {
+      "import": "./dist/kit/testing.js",
+      "require": "./dist/kit/testing.cjs"
+    },
     "./package.json": "./package.json"
   },
   "publishConfig": {
@@ -49,14 +77,16 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@kubb/adapter-oas": "5.0.0-beta.80",
-    "@kubb/cli": "5.0.0-beta.80",
-    "@kubb/core": "5.0.0-beta.80",
-    "@kubb/mcp": "5.0.0-beta.80",
-    "@kubb/parser-md": "5.0.0-beta.80",
-    "@kubb/parser-ts": "5.0.0-beta.80",
-    "@kubb/plugin-barrel": "5.0.0-beta.80",
-    "@kubb/renderer-jsx": "5.0.0-beta.80"
+    "@kubb/adapter-oas": "5.0.0-beta.82",
+    "@kubb/cli": "5.0.0-beta.82",
+    "@kubb/core": "5.0.0-beta.82",
+    "@kubb/ast": "5.0.0-beta.82",
+    "@kubb/mcp": "5.0.0-beta.82",
+    "@kubb/kit": "5.0.0-beta.82",
+    "@kubb/parser-ts": "5.0.0-beta.82",
+    "@kubb/parser-md": "5.0.0-beta.82",
+    "@kubb/plugin-barrel": "5.0.0-beta.82",
+    "@kubb/renderer-jsx": "5.0.0-beta.82"
   },
   "devDependencies": {
     "typescript": "^6.0.3",
@@ -71,9 +101,6 @@
     "clean": "node -e \"require('node:fs').rmSync('./dist', {recursive:true,force:true})\"",
     "lint": "oxlint .",
     "lint:fix": "oxlint --fix .",
-    "release": "pnpm publish --no-git-check",
-    "release:canary": "bash ../../.github/canary.sh && node ../../scripts/build.js canary && pnpm publish --no-git-check",
-    "release:stage": "pnpm stage publish --no-git-check",
     "start": "tsdown --watch",
     "test": "vitest --passWithNoTests",
     "typecheck": "tsc -p ./tsconfig.json --noEmit --emitDeclarationOnly false"

package/dist/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.cjs","names":["pluginBarrelName","parserTs","parserTsx","parserMd","cliReporter","jsonReporter","fileReporter"],"sources":["../../../internals/utils/src/promise.ts","../src/defineConfig.ts"],"sourcesContent":["/** 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\n/**\n * Container that switches between an eager `Array<T>` and a lazy `AsyncIterable<T>`.\n *\n * `Array<T>` by default. With `Stream` set to `true` it becomes `AsyncIterable<T>`, so large\n * collections can be produced lazily without holding every item in memory. Pairs with\n * {@link arrayToAsyncIterable}, which lifts a plain array into the streaming form.\n *\n * @example\n * ```ts\n * type Eager = Streamable<number> // Array<number>\n * type Lazy = Streamable<number, true> // AsyncIterable<number>\n * ```\n */\nexport type Streamable<T, Stream extends boolean = false> = Stream extends true ? AsyncIterable<T> : Array<T>\n\n/**\n * Wraps a plain array in a reusable `AsyncIterable`.\n * Each `[Symbol.asyncIterator]()` call returns a fresh generator so the\n * iterable can be consumed multiple times (e.g. once per plugin pre-scan).\n *\n * @example\n * ```ts\n * const stream = arrayToAsyncIterable([1, 2, 3])\n * for await (const n of stream) console.log(n) // 1, 2, 3\n * ```\n */\nexport function arrayToAsyncIterable<T>(arr: ReadonlyArray<T>): AsyncIterable<T> {\n  return {\n    [Symbol.asyncIterator]() {\n      return (async function* () {\n        yield* arr\n      })()\n    },\n  }\n}\n","import { isPromise, type PossiblePromise } from '@internals/utils'\nimport { adapterOas } from '@kubb/adapter-oas'\nimport { 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<any> | Array<UserConfig<any>>\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' }` only when `pluginBarrel` is part of `plugins`.\n *   When the user provides a plugins list without `pluginBarrel`, `barrel` is left untouched.\n * - `output.format` defaults to `false`\n * - `output.lint` defaults to `false`\n */\nfunction applyDefaults<TInput>(config: UserConfig<TInput>): UserConfig<TInput> {\n  const alreadyHasBarrel = config.plugins?.some((p) => p.name === pluginBarrelName)\n  const plugins = alreadyHasBarrel ? (config.plugins ?? []) : [...(config.plugins ?? []), pluginBarrel()]\n  const hasBarrelPlugin = plugins.some((p) => p.name === pluginBarrelName)\n\n  const output = { ...config.output }\n  if (hasBarrelPlugin && output.barrel === undefined) {\n    output.barrel = { type: 'named' }\n  }\n  if (output.format === undefined) {\n    output.format = false\n  }\n  if (output.lint === undefined) {\n    output.lint = false\n  }\n\n  return {\n    ...config,\n    root: config.root || process.cwd(),\n    adapter: config.adapter ?? adapterOas(),\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' }` only when `pluginBarrel` is\n *   in the plugins list.\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: { path: './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: { path: 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":";;;;;;;;;;;;;;;;AAmBA,SAAgB,UAAa,QAAkD;CAC7E,OAAO,WAAW,QAAQ,WAAW,KAAA,KAAa,OAAQ,OAAmC,YAAY;AAC3G;;;;;;;;;;;;;;;;ACSA,SAAS,cAAsB,QAAgD;CAE7E,MAAM,UADmB,OAAO,SAAS,MAAM,MAAM,EAAE,SAASA,oBAAAA,gBAAgB,IAC5C,OAAO,WAAW,CAAC,IAAK,CAAC,GAAI,OAAO,WAAW,CAAC,IAAA,GAAA,oBAAA,aAAA,CAAiB,CAAC;CACtG,MAAM,kBAAkB,QAAQ,MAAM,MAAM,EAAE,SAASA,oBAAAA,gBAAgB;CAEvE,MAAM,SAAS,EAAE,GAAG,OAAO,OAAO;CAClC,IAAI,mBAAmB,OAAO,WAAW,KAAA,GACvC,OAAO,SAAS,EAAE,MAAM,QAAQ;CAElC,IAAI,OAAO,WAAW,KAAA,GACpB,OAAO,SAAS;CAElB,IAAI,OAAO,SAAS,KAAA,GAClB,OAAO,OAAO;CAGhB,OAAO;EACL,GAAG;EACH,MAAM,OAAO,QAAQ,QAAQ,IAAI;EACjC,SAAS,OAAO,YAAA,GAAA,kBAAA,WAAA,CAAsB;EACtC,SAAS,OAAO,SAAS,SAAS,OAAO,UAAU;GAACC,gBAAAA;GAAUC,gBAAAA;GAAWC,gBAAAA;EAAQ;EACjF,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,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/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../../internals/utils/src/promise.ts","../src/defineConfig.ts"],"sourcesContent":["/** 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\n/**\n * Container that switches between an eager `Array<T>` and a lazy `AsyncIterable<T>`.\n *\n * `Array<T>` by default. With `Stream` set to `true` it becomes `AsyncIterable<T>`, so large\n * collections can be produced lazily without holding every item in memory. Pairs with\n * {@link arrayToAsyncIterable}, which lifts a plain array into the streaming form.\n *\n * @example\n * ```ts\n * type Eager = Streamable<number> // Array<number>\n * type Lazy = Streamable<number, true> // AsyncIterable<number>\n * ```\n */\nexport type Streamable<T, Stream extends boolean = false> = Stream extends true ? AsyncIterable<T> : Array<T>\n\n/**\n * Wraps a plain array in a reusable `AsyncIterable`.\n * Each `[Symbol.asyncIterator]()` call returns a fresh generator so the\n * iterable can be consumed multiple times (e.g. once per plugin pre-scan).\n *\n * @example\n * ```ts\n * const stream = arrayToAsyncIterable([1, 2, 3])\n * for await (const n of stream) console.log(n) // 1, 2, 3\n * ```\n */\nexport function arrayToAsyncIterable<T>(arr: ReadonlyArray<T>): AsyncIterable<T> {\n  return {\n    [Symbol.asyncIterator]() {\n      return (async function* () {\n        yield* arr\n      })()\n    },\n  }\n}\n","import { isPromise, type PossiblePromise } from '@internals/utils'\nimport { adapterOas } from '@kubb/adapter-oas'\nimport { 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<any> | Array<UserConfig<any>>\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' }` only when `pluginBarrel` is part of `plugins`.\n *   When the user provides a plugins list without `pluginBarrel`, `barrel` is left untouched.\n * - `output.format` defaults to `false`\n * - `output.lint` defaults to `false`\n */\nfunction applyDefaults<TInput>(config: UserConfig<TInput>): UserConfig<TInput> {\n  const alreadyHasBarrel = config.plugins?.some((p) => p.name === pluginBarrelName)\n  const plugins = alreadyHasBarrel ? (config.plugins ?? []) : [...(config.plugins ?? []), pluginBarrel()]\n  const hasBarrelPlugin = plugins.some((p) => p.name === pluginBarrelName)\n\n  const output = { ...config.output }\n  if (hasBarrelPlugin && output.barrel === undefined) {\n    output.barrel = { type: 'named' }\n  }\n  if (output.format === undefined) {\n    output.format = false\n  }\n  if (output.lint === undefined) {\n    output.lint = false\n  }\n\n  return {\n    ...config,\n    root: config.root || process.cwd(),\n    adapter: config.adapter ?? adapterOas(),\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' }` only when `pluginBarrel` is\n *   in the plugins list.\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: { path: './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: { path: 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":";;;;;;;;;;;;;;;AAmBA,SAAgB,UAAa,QAAkD;CAC7E,OAAO,WAAW,QAAQ,WAAW,KAAA,KAAa,OAAQ,OAAmC,YAAY;AAC3G;;;;;;;;;;;;;;;;ACSA,SAAS,cAAsB,QAAgD;CAE7E,MAAM,UADmB,OAAO,SAAS,MAAM,MAAM,EAAE,SAAS,gBAAgB,IAC5C,OAAO,WAAW,CAAC,IAAK,CAAC,GAAI,OAAO,WAAW,CAAC,GAAI,aAAa,CAAC;CACtG,MAAM,kBAAkB,QAAQ,MAAM,MAAM,EAAE,SAAS,gBAAgB;CAEvE,MAAM,SAAS,EAAE,GAAG,OAAO,OAAO;CAClC,IAAI,mBAAmB,OAAO,WAAW,KAAA,GACvC,OAAO,SAAS,EAAE,MAAM,QAAQ;CAElC,IAAI,OAAO,WAAW,KAAA,GACpB,OAAO,SAAS;CAElB,IAAI,OAAO,SAAS,KAAA,GAClB,OAAO,OAAO;CAGhB,OAAO;EACL,GAAG;EACH,MAAM,OAAO,QAAQ,QAAQ,IAAI;EACjC,SAAS,OAAO,WAAW,WAAW;EACtC,SAAS,OAAO,SAAS,SAAS,OAAO,UAAU;GAAC;GAAU;GAAW;EAAQ;EACjF,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,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"}