@kubb/core 4.36.1 → 5.0.0-alpha.10

package/dist/index.js

@@ -1,11 +1,10 @@
 import "./chunk--u3MIqq1.js";
-import mod from "node:module";
+import { definePrinter, isOperationNode, isSchemaNode } from "@kubb/ast";
+import path, { basename, dirname, extname, join, posix, relative, resolve } from "node:path";
 import { EventEmitter } from "node:events";
 import { parseArgs, styleText } from "node:util";
 import { readFileSync } from "node:fs";
 import { access, mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
-import path, { dirname, join, posix, relative, resolve } from "node:path";
-import { definePrinter } from "@kubb/ast";
 import { createFabric } from "@kubb/react-fabric";
 import { typescriptParser } from "@kubb/react-fabric/parsers";
 import { fsPlugin } from "@kubb/react-fabric/plugins";
@@ -13,11 +12,9 @@ import { performance } from "node:perf_hooks";
 import { deflateSync } from "fflate";
 import { x } from "tinyexec";
 import { version } from "node:process";
-import os from "node:os";
-import { pathToFileURL } from "node:url";
+import { sortBy } from "remeda";
 import * as pkg from "empathic/package";
 import { coerce, satisfies } from "semver";
-import { sortBy } from "remeda";
 //#region ../../internals/utils/dist/index.js
 /** Thrown when a plugin's configuration or input fails validation. */
 var ValidationPluginError = class extends Error {};
@@ -134,6 +131,21 @@ function camelCase(text, { isFile, prefix = "", suffix = "" } = {}) {
 	} : {}));
 	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
 }
+/**
+* Converts `text` to PascalCase.
+* When `isFile` is `true`, the last dot-separated segment is PascalCased and earlier segments are camelCased.
+*
+* @example
+* pascalCase('hello-world')                  // 'HelloWorld'
+* pascalCase('pet.petId', { isFile: true })  // 'pet/PetId'
+*/
+function pascalCase(text, { isFile, prefix = "", suffix = "" } = {}) {
+	if (isFile) return applyToFileParts(text, (part, isLast) => isLast ? pascalCase(part, {
+		prefix,
+		suffix
+	}) : camelCase(part));
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
+}
 /** Returns a `CLIAdapter` with type inference. Pass a different adapter to `createCLI` to swap the CLI engine. */
 function defineCLIAdapter(adapter) {
 	return adapter;
@@ -383,14 +395,6 @@ async function exists(path) {
 	if (typeof Bun !== "undefined") return Bun.file(path).exists();
 	return access(path).then(() => true, () => false);
 }
-/**
-* Reads the file at `path` as a UTF-8 string.
-* Uses `Bun.file().text()` when running under Bun, `fs.readFile` otherwise.
-*/
-async function read(path) {
-	if (typeof Bun !== "undefined") return Bun.file(path).text();
-	return readFile(path, { encoding: "utf8" });
-}
 /** Synchronous counterpart of `read`. */
 function readSync(path) {
 	return readFileSync(path, { encoding: "utf8" });
@@ -445,11 +449,15 @@ function setUniqueName(originalName, data) {
 	data[originalName] = 1;
 	return originalName;
 }
+/** Type guard for a rejected `Promise.allSettled` result with a typed `reason`. */
+function isPromiseRejectedResult(result) {
+	return result.status === "rejected";
+}
 /**
 * JavaScript and Java reserved words.
 * @link https://github.com/jonschlinkert/reserved/blob/master/index.js
 */
-const reservedWords = [
+const reservedWords = new Set([
 	"abstract",
 	"arguments",
 	"boolean",
@@ -531,14 +539,14 @@ const reservedWords = [
 	"toString",
 	"undefined",
 	"valueOf"
-];
+]);
 /**
 * Prefixes a word with `_` when it is a reserved JavaScript/Java identifier
 * or starts with a digit.
 */
 function transformReservedWord(word) {
 	const firstChar = word.charCodeAt(0);
-	if (word && (reservedWords.includes(word) || firstChar >= 48 && firstChar <= 57)) return `_${word}`;
+	if (word && (reservedWords.has(word) || firstChar >= 48 && firstChar <= 57)) return `_${word}`;
 	return word;
 }
 /**
@@ -670,7 +678,6 @@ const DEFAULT_STUDIO_URL = "https://studio.kubb.dev";
 const BARREL_FILENAME = "index.ts";
 const DEFAULT_BANNER = "simple";
 const DEFAULT_EXTENSION = { ".ts": ".ts" };
-const PATH_SEPARATORS = ["/", "\\"];
 const logLevel = {
 	silent: Number.NEGATIVE_INFINITY,
 	error: 0,
@@ -931,29 +938,13 @@ function hookParallel(promises, concurrency = Number.POSITIVE_INFINITY) {
 	return Promise.allSettled(tasks);
 }
 //#endregion
-//#region src/PromiseManager.ts
-var PromiseManager = class {
-	#options = {};
-	constructor(options = {}) {
-		this.#options = options;
-	}
-	run(strategy, promises, { concurrency = Number.POSITIVE_INFINITY } = {}) {
-		if (strategy === "seq") return hookSeq(promises);
-		if (strategy === "first") return hookFirst(promises, this.#options.nullCheck);
-		if (strategy === "parallel") return hookParallel(promises, concurrency);
-		throw new Error(`${strategy} not implemented`);
-	}
-};
-function isPromiseRejectedResult(result) {
-	return result.status === "rejected";
-}
-//#endregion
-//#region src/PluginManager.ts
+//#region src/PluginDriver.ts
 function getMode(fileOrFolder) {
 	if (!fileOrFolder) return "split";
-	return path.extname(fileOrFolder) ? "single" : "split";
+	return extname(fileOrFolder) ? "single" : "split";
 }
-var PluginManager = class {
+const hookFirstNullCheck = (state) => !!state?.result;
+var PluginDriver = class {
 	config;
 	options;
 	/**
@@ -961,14 +952,13 @@ var PluginManager = class {
 	* the build pipeline after the adapter's `parse()` resolves.
 	*/
 	rootNode = void 0;
+	adapter = void 0;
 	#studioIsOpen = false;
 	#plugins = /* @__PURE__ */ new Set();
 	#usedPluginNames = {};
-	#promiseManager;
 	constructor(config, options) {
 		this.config = config;
 		this.options = options;
-		this.#promiseManager = new PromiseManager({ nullCheck: (state) => !!state?.result });
 		[...config.plugins || []].forEach((plugin) => {
 			const parsedPlugin = this.#parse(plugin);
 			this.#plugins.add(parsedPlugin);
@@ -979,14 +969,14 @@ var PluginManager = class {
 	}
 	getContext(plugin) {
 		const plugins = [...this.#plugins];
-		const pluginManager = this;
+		const driver = this;
 		const baseContext = {
 			fabric: this.options.fabric,
 			config: this.config,
 			plugin,
 			events: this.options.events,
-			pluginManager: this,
-			mode: getMode(path.resolve(this.config.root, this.config.output.path)),
+			driver: this,
+			mode: getMode(resolve(this.config.root, this.config.output.path)),
 			addFile: async (...files) => {
 				await this.options.fabric.addFile(...files);
 			},
@@ -994,15 +984,18 @@ var PluginManager = class {
 				await this.options.fabric.upsertFile(...files);
 			},
 			get rootNode() {
-				return pluginManager.rootNode;
+				return driver.rootNode;
+			},
+			get adapter() {
+				return driver.adapter;
 			},
 			openInStudio(options) {
-				if (typeof pluginManager.config.devtools !== "object") throw new Error("Devtools must be an object");
-				if (!pluginManager.rootNode) throw new Error("RootNode is not defined, make sure you have set the parser in kubb.config.ts");
-				if (pluginManager.#studioIsOpen) return;
-				pluginManager.#studioIsOpen = true;
-				const studioUrl = pluginManager.config.devtools?.studioUrl ?? "https://studio.kubb.dev";
-				return openInStudio(pluginManager.rootNode, studioUrl, options);
+				if (!driver.config.devtools || driver.#studioIsOpen) return;
+				if (typeof driver.config.devtools !== "object") throw new Error("Devtools must be an object");
+				if (!driver.rootNode || !driver.adapter) throw new Error("adapter is not defined, make sure you have set the parser in kubb.config.ts");
+				driver.#studioIsOpen = true;
+				const studioUrl = driver.config.devtools?.studioUrl ?? "https://studio.kubb.dev";
+				return openInStudio(driver.rootNode, studioUrl, options);
 			}
 		};
 		const mergedExtras = {};
@@ -1018,29 +1011,32 @@ var PluginManager = class {
 	get plugins() {
 		return this.#getSortedPlugins();
 	}
-	getFile({ name, mode, extname, pluginKey, options }) {
-		const baseName = `${name}${extname}`;
+	getFile({ name, mode, extname, pluginName, options }) {
+		const resolvedName = mode ? mode === "single" ? "" : this.resolveName({
+			name,
+			pluginName,
+			type: "file"
+		}) : name;
 		const path = this.resolvePath({
-			baseName,
+			baseName: `${resolvedName}${extname}`,
 			mode,
-			pluginKey,
+			pluginName,
 			options
 		});
-		if (!path) throw new Error(`Filepath should be defined for resolvedName "${name}" and pluginKey [${JSON.stringify(pluginKey)}]`);
+		if (!path) throw new Error(`Filepath should be defined for resolvedName "${resolvedName}" and pluginName "${pluginName}"`);
 		return {
 			path,
-			baseName,
-			meta: { pluginKey },
+			baseName: basename(path),
+			meta: { pluginName },
 			sources: [],
 			imports: [],
 			exports: []
 		};
 	}
 	resolvePath = (params) => {
-		const root = path.resolve(this.config.root, this.config.output.path);
-		const defaultPath = path.resolve(root, params.baseName);
-		if (params.pluginKey) return this.hookForPluginSync({
-			pluginKey: params.pluginKey,
+		const defaultPath = resolve(resolve(this.config.root, this.config.output.path), params.baseName);
+		if (params.pluginName) return this.hookForPluginSync({
+			pluginName: params.pluginName,
 			hookName: "resolvePath",
 			parameters: [
 				params.baseName,
@@ -1058,9 +1054,9 @@ var PluginManager = class {
 		})?.result || defaultPath;
 	};
 	resolveName = (params) => {
-		if (params.pluginKey) {
+		if (params.pluginName) {
 			const names = this.hookForPluginSync({
-				pluginKey: params.pluginKey,
+				pluginName: params.pluginName,
 				hookName: "resolveName",
 				parameters: [params.name.trim(), params.type]
 			});
@@ -1075,8 +1071,8 @@ var PluginManager = class {
 	/**
 	* Run a specific hookName for plugin x.
 	*/
-	async hookForPlugin({ pluginKey, hookName, parameters }) {
-		const plugins = this.getPluginsByKey(hookName, pluginKey);
+	async hookForPlugin({ pluginName, hookName, parameters }) {
+		const plugins = this.getPluginsByName(hookName, pluginName);
 		this.events.emit("plugins:hook:progress:start", {
 			hookName,
 			plugins
@@ -1097,8 +1093,8 @@ var PluginManager = class {
 	/**
 	* Run a specific hookName for plugin x.
 	*/
-	hookForPluginSync({ pluginKey, hookName, parameters }) {
-		return this.getPluginsByKey(hookName, pluginKey).map((plugin) => {
+	hookForPluginSync({ pluginName, hookName, parameters }) {
+		return this.getPluginsByName(hookName, pluginName).map((plugin) => {
 			return this.#executeSync({
 				strategy: "hookFirst",
 				hookName,
@@ -1118,7 +1114,7 @@ var PluginManager = class {
 			hookName,
 			plugins
 		});
-		const promises = plugins.map((plugin) => {
+		const result = await hookFirst(plugins.map((plugin) => {
 			return async () => {
 				const value = await this.#execute({
 					strategy: "hookFirst",
@@ -1131,8 +1127,7 @@ var PluginManager = class {
 					result: value
 				});
 			};
-		});
-		const result = await this.#promiseManager.run("first", promises);
+		}), hookFirstNullCheck);
 		this.events.emit("plugins:hook:progress:end", { hookName });
 		return result;
 	}
@@ -1168,7 +1163,7 @@ var PluginManager = class {
 			plugins
 		});
 		const pluginStartTimes = /* @__PURE__ */ new Map();
-		const promises = plugins.map((plugin) => {
+		const results = await hookParallel(plugins.map((plugin) => {
 			return () => {
 				pluginStartTimes.set(plugin, performance.now());
 				return this.#execute({
@@ -1178,8 +1173,7 @@ var PluginManager = class {
 					plugin
 				});
 			};
-		});
-		const results = await this.#promiseManager.run("parallel", promises, { concurrency: this.options.concurrency });
+		}), this.options.concurrency);
 		results.forEach((result, index) => {
 			if (isPromiseRejectedResult(result)) {
 				const plugin = this.#getSortedPlugins(hookName)[index];
@@ -1210,15 +1204,14 @@ var PluginManager = class {
 			hookName,
 			plugins
 		});
-		const promises = plugins.map((plugin) => {
+		await hookSeq(plugins.map((plugin) => {
 			return () => this.#execute({
 				strategy: "hookSeq",
 				hookName,
 				parameters,
 				plugin
 			});
-		});
-		await this.#promiseManager.run("seq", promises);
+		}));
 		this.events.emit("plugins:hook:progress:end", { hookName });
 	}
 	#getSortedPlugins(hookName) {
@@ -1226,7 +1219,8 @@ var PluginManager = class {
 		if (hookName) return plugins.filter((plugin) => hookName in plugin);
 		return plugins.map((plugin) => {
 			if (plugin.pre) {
-				const missingPlugins = plugin.pre.filter((pluginName) => !plugins.find((pluginToFind) => pluginToFind.name === pluginName));
+				let missingPlugins = plugin.pre.filter((pluginName) => !plugins.find((pluginToFind) => pluginToFind.name === pluginName));
+				if (missingPlugins.includes("plugin-oas") && this.adapter) missingPlugins = missingPlugins.filter((pluginName) => pluginName !== "plugin-oas");
 				if (missingPlugins.length > 0) throw new ValidationPluginError(`The plugin '${plugin.name}' has a pre set that references missing plugins for '${missingPlugins.join(", ")}'`);
 			}
 			return plugin;
@@ -1236,24 +1230,12 @@ var PluginManager = class {
 			return 0;
 		});
 	}
-	getPluginByKey(pluginKey) {
-		const plugins = [...this.#plugins];
-		const [searchPluginName] = pluginKey;
-		return plugins.find((item) => {
-			const [name] = item.key;
-			return name === searchPluginName;
-		});
+	getPluginByName(pluginName) {
+		return [...this.#plugins].find((item) => item.name === pluginName);
 	}
-	getPluginsByKey(hookName, pluginKey) {
+	getPluginsByName(hookName, pluginName) {
 		const plugins = [...this.plugins];
-		const [searchPluginName, searchIdentifier] = pluginKey;
-		const pluginByPluginName = plugins.filter((plugin) => hookName in plugin).filter((item) => {
-			const [name, identifier] = item.key;
-			const identifierCheck = identifier?.toString() === searchIdentifier?.toString();
-			const nameCheck = name === searchPluginName;
-			if (searchIdentifier) return identifierCheck && nameCheck;
-			return nameCheck;
-		});
+		const pluginByPluginName = plugins.filter((plugin) => hookName in plugin).filter((item) => item.name === pluginName);
 		if (!pluginByPluginName?.length) {
 			const corePlugin = plugins.find((plugin) => plugin.name === "core" && hookName in plugin);
 			return corePlugin ? [corePlugin] : [];
@@ -1350,28 +1332,20 @@ var PluginManager = class {
 		const usedPluginNames = this.#usedPluginNames;
 		setUniqueName(plugin.name, usedPluginNames);
 		const usageCount = usedPluginNames[plugin.name];
-		if (usageCount && usageCount > 1) this.events.emit("warn", `Multiple instances of plugin "${plugin.name}" detected. This behavior is deprecated and will be removed in v5.`, `Plugin key: [${plugin.name}, ${usageCount}]`);
+		if (usageCount && usageCount > 1) throw new ValidationPluginError(`Duplicate plugin "${plugin.name}" detected. Each plugin can only be used once. Use a different configuration instead of adding multiple instances of the same plugin.`);
 		return {
 			install() {},
-			...plugin,
-			key: [plugin.name, usedPluginNames[plugin.name]].filter(Boolean)
+			...plugin
 		};
 	}
 };
 //#endregion
-//#region src/defineStorage.ts
+//#region src/createStorage.ts
 /**
-* Wraps a storage builder so the `options` argument is optional, following the
-* same factory pattern as `definePlugin`, `defineLogger`, and `defineAdapter`.
-*
-* The builder receives the resolved options object and must return a
-* `DefineStorage`-compatible object that includes a `name` string.
+* Creates a storage factory. Call the returned function with optional options to get the storage instance.
 *
 * @example
-* ```ts
-* import { defineStorage } from '@kubb/core'
-*
-* export const memoryStorage = defineStorage((_options) => {
+* export const memoryStorage = createStorage(() => {
 *   const store = new Map<string, string>()
 *   return {
 *     name: 'memory',
@@ -1379,13 +1353,15 @@ var PluginManager = class {
 *     async getItem(key) { return store.get(key) ?? null },
 *     async setItem(key, value) { store.set(key, value) },
 *     async removeItem(key) { store.delete(key) },
-*     async getKeys() { return [...store.keys()] },
-*     async clear() { store.clear() },
+*     async getKeys(base) {
+*       const keys = [...store.keys()]
+*       return base ? keys.filter((k) => k.startsWith(base)) : keys
+*     },
+*     async clear(base) { if (!base) store.clear() },
 *   }
 * })
-* ```
 */
-function defineStorage(build) {
+function createStorage(build) {
 	return (options) => build(options ?? {});
 }
 //#endregion
@@ -1413,7 +1389,7 @@ function defineStorage(build) {
 * })
 * ```
 */
-const fsStorage = defineStorage(() => ({
+const fsStorage = createStorage(() => ({
 	name: "fs",
 	async hasItem(key) {
 		try {
@@ -1461,7 +1437,7 @@ const fsStorage = defineStorage(() => ({
 }));
 //#endregion
 //#region package.json
-var version$1 = "4.36.1";
+var version$1 = "5.0.0-alpha.10";
 //#endregion
 //#region src/utils/diagnostics.ts
 /**
@@ -1575,7 +1551,7 @@ async function setup(options) {
 			`  • Barrel type: ${definedConfig.output.barrelType || "none"}`
 		]
 	});
-	const pluginManager = new PluginManager(definedConfig, {
+	const pluginDriver = new PluginDriver(definedConfig, {
 		fabric,
 		events,
 		concurrency: 15
@@ -1586,25 +1562,26 @@ async function setup(options) {
 			date: /* @__PURE__ */ new Date(),
 			logs: [`Running adapter: ${definedConfig.adapter.name}`]
 		});
-		pluginManager.rootNode = await definedConfig.adapter.parse(source);
+		pluginDriver.adapter = definedConfig.adapter;
+		pluginDriver.rootNode = await definedConfig.adapter.parse(source);
 		await events.emit("debug", {
 			date: /* @__PURE__ */ new Date(),
 			logs: [
 				`✓ Adapter '${definedConfig.adapter.name}' resolved RootNode`,
-				`  • Schemas: ${pluginManager.rootNode.schemas.length}`,
-				`  • Operations: ${pluginManager.rootNode.operations.length}`
+				`  • Schemas: ${pluginDriver.rootNode.schemas.length}`,
+				`  • Operations: ${pluginDriver.rootNode.operations.length}`
 			]
 		});
 	}
 	return {
 		events,
 		fabric,
-		pluginManager,
+		driver: pluginDriver,
 		sources
 	};
 }
 async function build(options, overrides) {
-	const { fabric, files, pluginManager, failedPlugins, pluginTimings, error, sources } = await safeBuild(options, overrides);
+	const { fabric, files, driver, failedPlugins, pluginTimings, error, sources } = await safeBuild(options, overrides);
 	if (error) throw error;
 	if (failedPlugins.size > 0) {
 		const errors = [...failedPlugins].map(({ error }) => error);
@@ -1614,20 +1591,20 @@ async function build(options, overrides) {
 		failedPlugins,
 		fabric,
 		files,
-		pluginManager,
+		driver,
 		pluginTimings,
 		error: void 0,
 		sources
 	};
 }
 async function safeBuild(options, overrides) {
-	const { fabric, pluginManager, events, sources } = overrides ? overrides : await setup(options);
+	const { fabric, driver, events, sources } = overrides ? overrides : await setup(options);
 	const failedPlugins = /* @__PURE__ */ new Set();
 	const pluginTimings = /* @__PURE__ */ new Map();
-	const config = pluginManager.config;
+	const config = driver.config;
 	try {
-		for (const plugin of pluginManager.plugins) {
-			const context = pluginManager.getContext(plugin);
+		for (const plugin of driver.plugins) {
+			const context = driver.getContext(plugin);
 			const hrStart = process.hrtime();
 			const installer = plugin.install.bind(context);
 			try {
@@ -1635,7 +1612,7 @@ async function safeBuild(options, overrides) {
 				await events.emit("plugin:start", plugin);
 				await events.emit("debug", {
 					date: timestamp,
-					logs: ["Installing plugin...", `  • Plugin Key: [${plugin.key.join(", ")}]`]
+					logs: ["Installing plugin...", `  • Plugin Name: ${plugin.name}`]
 				});
 				await installer(context);
 				const duration = getElapsedMs(hrStart);
@@ -1661,7 +1638,7 @@ async function safeBuild(options, overrides) {
 					date: errorTimestamp,
 					logs: [
 						"✗ Plugin installation failed",
-						`  • Plugin Key: ${JSON.stringify(plugin.key)}`,
+						`  • Plugin Name: ${plugin.name}`,
 						`  • Error: ${error.constructor.name} - ${error.message}`,
 						"  • Stack Trace:",
 						error.stack || "No stack trace available"
@@ -1700,7 +1677,7 @@ async function safeBuild(options, overrides) {
 					rootDir,
 					existingExports: new Set(existingBarrel?.exports?.flatMap((e) => Array.isArray(e.name) ? e.name : [e.name]).filter((n) => Boolean(n)) ?? []),
 					config,
-					pluginManager
+					driver
 				}),
 				sources: [],
 				imports: [],
@@ -1718,7 +1695,7 @@ async function safeBuild(options, overrides) {
 			failedPlugins,
 			fabric,
 			files,
-			pluginManager,
+			driver,
 			pluginTimings,
 			sources
 		};
@@ -1727,22 +1704,22 @@ async function safeBuild(options, overrides) {
 			failedPlugins,
 			fabric,
 			files: [],
-			pluginManager,
+			driver,
 			pluginTimings,
 			error,
 			sources
 		};
 	}
 }
-function buildBarrelExports({ barrelFiles, rootDir, existingExports, config, pluginManager }) {
-	const pluginKeyMap = /* @__PURE__ */ new Map();
-	for (const plugin of pluginManager.plugins) pluginKeyMap.set(JSON.stringify(plugin.key), plugin);
+function buildBarrelExports({ barrelFiles, rootDir, existingExports, config, driver }) {
+	const pluginNameMap = /* @__PURE__ */ new Map();
+	for (const plugin of driver.plugins) pluginNameMap.set(plugin.name, plugin);
 	return barrelFiles.flatMap((file) => {
 		const containsOnlyTypes = file.sources?.every((source) => source.isTypeOnly);
 		return (file.sources ?? []).flatMap((source) => {
 			if (!file.path || !source.isIndexable) return [];
 			const meta = file.meta;
-			const pluginOptions = (meta?.pluginKey ? pluginKeyMap.get(JSON.stringify(meta.pluginKey)) : void 0)?.options;
+			const pluginOptions = (meta?.pluginName ? pluginNameMap.get(meta.pluginName) : void 0)?.options;
 			if (!pluginOptions || pluginOptions.output?.barrelType === false) return [];
 			const exportName = config.output.barrelType === "all" ? void 0 : source.name ? [source.name] : void 0;
 			if (exportName?.some((n) => existingExports.has(n))) return [];
@@ -1773,121 +1750,178 @@ function inputToAdapterSource(config) {
 	};
 }
 //#endregion
-//#region src/defineAdapter.ts
+//#region src/createAdapter.ts
 /**
-* Wraps an adapter builder to make the options parameter optional.
+* Creates an adapter factory. Call the returned function with optional options to get the adapter instance.
 *
 * @example
-* ```ts
-* export const adapterOas = defineAdapter<OasAdapter>((options) => {
-*   const { validate = true, dateType = 'string' } = options
+* export const myAdapter = createAdapter<MyAdapter>((options) => {
 *   return {
-*     name: adapterOasName,
-*     options: { validate, dateType, ... },
-*     parse(source) { ... },
+*     name: 'my-adapter',
+*     options,
+*     async parse(source) { ... },
 *   }
 * })
-* ```
+*
+* // instantiate
+* const adapter = myAdapter({ validate: true })
 */
-function defineAdapter(build) {
+function createAdapter(build) {
 	return (options) => build(options ?? {});
 }
 //#endregion
+//#region src/createPlugin.ts
+/**
+* Creates a plugin factory. Call the returned function with optional options to get the plugin instance.
+*
+* @example
+* export const myPlugin = createPlugin<MyPlugin>((options) => {
+*   return {
+*     name: 'my-plugin',
+*     options,
+*     resolvePath(baseName) { ... },
+*     resolveName(name, type) { ... },
+*   }
+* })
+*
+* // instantiate
+* const plugin = myPlugin({ output: { path: 'src/gen' } })
+*/
+function createPlugin(build) {
+	return (options) => build(options ?? {});
+}
+//#endregion
+//#region src/defineGenerator.ts
+function defineGenerator(generator) {
+	if (generator.type === "react") return {
+		version: "2",
+		Operations() {
+			return null;
+		},
+		Operation() {
+			return null;
+		},
+		Schema() {
+			return null;
+		},
+		...generator
+	};
+	return {
+		version: "2",
+		async operations() {
+			return [];
+		},
+		async operation() {
+			return [];
+		},
+		async schema() {
+			return [];
+		},
+		...generator
+	};
+}
+//#endregion
 //#region src/defineLogger.ts
+/**
+* Wraps a logger definition into a typed {@link Logger}.
+*
+* @example
+* export const myLogger = defineLogger({
+*   name: 'my-logger',
+*   install(context, options) {
+*     context.on('info', (message) => console.log('ℹ', message))
+*     context.on('error', (error) => console.error('✗', error.message))
+*   },
+* })
+*/
 function defineLogger(logger) {
-	return { ...logger };
+	return logger;
 }
 //#endregion
-//#region src/definePlugin.ts
+//#region src/defineResolver.ts
 /**
-* Wraps a plugin builder to make the options parameter optional.
+* Checks if an operation matches a pattern for a given filter type (`tag`, `operationId`, `path`, `method`).
 */
-function definePlugin(build) {
-	return (options) => build(options ?? {});
+function matchesOperationPattern(node, type, pattern) {
+	switch (type) {
+		case "tag": return node.tags.some((tag) => !!tag.match(pattern));
+		case "operationId": return !!node.operationId.match(pattern);
+		case "path": return !!node.path.match(pattern);
+		case "method": return !!node.method.toLowerCase().match(pattern);
+		default: return false;
+	}
 }
-//#endregion
-//#region src/PackageManager.ts
-var PackageManager = class PackageManager {
-	static #cache = {};
-	#cwd;
-	constructor(workspace) {
-		if (workspace) this.#cwd = workspace;
-	}
-	set workspace(workspace) {
-		this.#cwd = workspace;
-	}
-	get workspace() {
-		return this.#cwd;
-	}
-	normalizeDirectory(directory) {
-		const lastChar = directory[directory.length - 1];
-		if (lastChar && !PATH_SEPARATORS.includes(lastChar)) return `${directory}/`;
-		return directory;
-	}
-	getLocation(path) {
-		let location = path;
-		if (this.#cwd) location = mod.createRequire(this.normalizeDirectory(this.#cwd)).resolve(path);
-		return location;
-	}
-	async import(path) {
-		let location = this.getLocation(path);
-		if (os.platform() === "win32") location = pathToFileURL(location).href;
-		const module = await import(location);
-		return module?.default ?? module;
-	}
-	async getPackageJSON() {
-		const pkgPath = pkg.up({ cwd: this.#cwd });
-		if (!pkgPath) return;
-		const json = await read(pkgPath);
-		return JSON.parse(json);
-	}
-	getPackageJSONSync() {
-		const pkgPath = pkg.up({ cwd: this.#cwd });
-		if (!pkgPath) return;
-		const json = readSync(pkgPath);
-		return JSON.parse(json);
-	}
-	static setVersion(dependency, version) {
-		PackageManager.#cache[dependency] = version;
-	}
-	#match(packageJSON, dependency) {
-		const dependencies = {
-			...packageJSON.dependencies || {},
-			...packageJSON.devDependencies || {}
+/**
+* Checks if a schema matches a pattern for a given filter type (`schemaName`).
+* Returns `null` when the filter type doesn't apply to schemas.
+*/
+function matchesSchemaPattern(node, type, pattern) {
+	switch (type) {
+		case "schemaName": return node.name ? !!node.name.match(pattern) : false;
+		default: return null;
+	}
+}
+/**
+* Default name resolver — `camelCase` for most types, `PascalCase` for `type`.
+*/
+function defaultResolver(name, type) {
+	let resolvedName = camelCase(name);
+	if (type === "file" || type === "function") resolvedName = camelCase(name, { isFile: type === "file" });
+	if (type === "type") resolvedName = pascalCase(name);
+	return resolvedName;
+}
+/**
+* Default option resolver — applies include/exclude filters and merges any matching override options.
+* Returns `null` when the node is filtered out.
+*/
+function defaultResolveOptions(node, { options, exclude = [], include, override = [] }) {
+	if (isOperationNode(node)) {
+		if (exclude.some(({ type, pattern }) => matchesOperationPattern(node, type, pattern))) return null;
+		if (include && !include.some(({ type, pattern }) => matchesOperationPattern(node, type, pattern))) return null;
+		const overrideOptions = override.find(({ type, pattern }) => matchesOperationPattern(node, type, pattern))?.options;
+		return {
+			...options,
+			...overrideOptions
 		};
-		if (typeof dependency === "string" && dependencies[dependency]) return dependencies[dependency];
-		const matchedDependency = Object.keys(dependencies).find((dep) => dep.match(dependency));
-		return matchedDependency ? dependencies[matchedDependency] : void 0;
-	}
-	async getVersion(dependency) {
-		if (typeof dependency === "string" && PackageManager.#cache[dependency]) return PackageManager.#cache[dependency];
-		const packageJSON = await this.getPackageJSON();
-		if (!packageJSON) return;
-		return this.#match(packageJSON, dependency);
-	}
-	getVersionSync(dependency) {
-		if (typeof dependency === "string" && PackageManager.#cache[dependency]) return PackageManager.#cache[dependency];
-		const packageJSON = this.getPackageJSONSync();
-		if (!packageJSON) return;
-		return this.#match(packageJSON, dependency);
-	}
-	async isValid(dependency, version) {
-		const packageVersion = await this.getVersion(dependency);
-		if (!packageVersion) return false;
-		if (packageVersion === version) return true;
-		const semVer = coerce(packageVersion);
-		if (!semVer) return false;
-		return satisfies(semVer, version);
-	}
-	isValidSync(dependency, version) {
-		const packageVersion = this.getVersionSync(dependency);
-		if (!packageVersion) return false;
-		if (packageVersion === version) return true;
-		const semVer = coerce(packageVersion);
-		if (!semVer) return false;
-		return satisfies(semVer, version);
 	}
-};
+	if (isSchemaNode(node)) {
+		if (exclude.some(({ type, pattern }) => matchesSchemaPattern(node, type, pattern) === true)) return null;
+		if (include) {
+			const applicable = include.map(({ type, pattern }) => matchesSchemaPattern(node, type, pattern)).filter((r) => r !== null);
+			if (applicable.length > 0 && !applicable.includes(true)) return null;
+		}
+		const overrideOptions = override.find(({ type, pattern }) => matchesSchemaPattern(node, type, pattern) === true)?.options;
+		return {
+			...options,
+			...overrideOptions
+		};
+	}
+	return options;
+}
+/**
+* Defines a resolver for a plugin, with built-in defaults for name casing and include/exclude/override filtering.
+* Override `default` or `resolveOptions` in the builder to customize the behavior.
+*
+* @example
+* export const resolver = defineResolver<PluginTs>(() => ({
+*   resolveName(name) {
+*     return this.default(name, 'function')
+*   },
+*   resolveTypedName(name) {
+*     return this.default(name, 'type')
+*   },
+*   resolveParamName(node, param) {
+*     return this.resolveName(`${node.operationId} ${param.in} ${param.name}`)
+*   },
+* }))
+*/
+function defineResolver(build) {
+	return {
+		default: defaultResolver,
+		resolveOptions: defaultResolveOptions,
+		...build()
+	};
+}
 //#endregion
 //#region src/storages/memoryStorage.ts
 /**
@@ -1907,7 +1941,7 @@ var PackageManager = class PackageManager {
 * })
 * ```
 */
-const memoryStorage = defineStorage(() => {
+const memoryStorage = createStorage(() => {
 	const store = /* @__PURE__ */ new Map();
 	return {
 		name: "memory",
@@ -1939,7 +1973,7 @@ const memoryStorage = defineStorage(() => {
 //#endregion
 //#region src/utils/FunctionParams.ts
 /**
-* @deprecated
+* @deprecated use ast package instead
 */
 var FunctionParams = class FunctionParams {
 	#items = [];
@@ -2053,11 +2087,12 @@ async function isFormatterAvailable(formatter) {
 * ```
 */
 async function detectFormatter() {
-	for (const formatter of [
+	const formatterNames = new Set([
 		"biome",
 		"oxfmt",
 		"prettier"
-	]) if (await isFormatterAvailable(formatter)) return formatter;
+	]);
+	for (const formatter of formatterNames) if (await isFormatterAvailable(formatter)) return formatter;
 }
 //#endregion
 //#region src/utils/TreeNode.ts
@@ -2180,50 +2215,46 @@ function buildDirectoryTree(files, rootFolder = "") {
 	return root;
 }
 //#endregion
-//#region src/BarrelManager.ts
+//#region src/utils/getBarrelFiles.ts
 /** biome-ignore-all lint/suspicious/useIterableCallbackReturn: not needed */
-var BarrelManager = class {
-	getFiles({ files: generatedFiles, root }) {
-		const cachedFiles = /* @__PURE__ */ new Map();
-		TreeNode.build(generatedFiles, root)?.forEach((treeNode) => {
-			if (!treeNode || !treeNode.children || !treeNode.parent?.data.path) return;
-			const barrelFile = {
-				path: join(treeNode.parent?.data.path, "index.ts"),
-				baseName: "index.ts",
-				exports: [],
-				imports: [],
-				sources: []
-			};
-			const previousBarrelFile = cachedFiles.get(barrelFile.path);
-			treeNode.leaves.forEach((item) => {
-				if (!item.data.name) return;
-				(item.data.file?.sources || []).forEach((source) => {
-					if (!item.data.file?.path || !source.isIndexable || !source.name) return;
-					if (previousBarrelFile?.sources.some((item) => item.name === source.name && item.isTypeOnly === source.isTypeOnly)) return;
-					barrelFile.exports.push({
-						name: [source.name],
-						path: getRelativePath(treeNode.parent?.data.path, item.data.path),
-						isTypeOnly: source.isTypeOnly
-					});
-					barrelFile.sources.push({
-						name: source.name,
-						isTypeOnly: source.isTypeOnly,
-						value: "",
-						isExportable: false,
-						isIndexable: false
-					});
+function getBarrelFilesByRoot(root, files) {
+	const cachedFiles = /* @__PURE__ */ new Map();
+	TreeNode.build(files, root)?.forEach((treeNode) => {
+		if (!treeNode || !treeNode.children || !treeNode.parent?.data.path) return;
+		const barrelFile = {
+			path: join(treeNode.parent?.data.path, "index.ts"),
+			baseName: "index.ts",
+			exports: [],
+			imports: [],
+			sources: []
+		};
+		const previousBarrelFile = cachedFiles.get(barrelFile.path);
+		treeNode.leaves.forEach((item) => {
+			if (!item.data.name) return;
+			(item.data.file?.sources || []).forEach((source) => {
+				if (!item.data.file?.path || !source.isIndexable || !source.name) return;
+				if (previousBarrelFile?.sources.some((item) => item.name === source.name && item.isTypeOnly === source.isTypeOnly)) return;
+				barrelFile.exports.push({
+					name: [source.name],
+					path: getRelativePath(treeNode.parent?.data.path, item.data.path),
+					isTypeOnly: source.isTypeOnly
+				});
+				barrelFile.sources.push({
+					name: source.name,
+					isTypeOnly: source.isTypeOnly,
+					value: "",
+					isExportable: false,
+					isIndexable: false
 				});
 			});
-			if (previousBarrelFile) {
-				previousBarrelFile.sources.push(...barrelFile.sources);
-				previousBarrelFile.exports?.push(...barrelFile.exports || []);
-			} else cachedFiles.set(barrelFile.path, barrelFile);
 		});
-		return [...cachedFiles.values()];
-	}
-};
-//#endregion
-//#region src/utils/getBarrelFiles.ts
+		if (previousBarrelFile) {
+			previousBarrelFile.sources.push(...barrelFile.sources);
+			previousBarrelFile.exports?.push(...barrelFile.exports || []);
+		} else cachedFiles.set(barrelFile.path, barrelFile);
+	});
+	return [...cachedFiles.values()];
+}
 function trimExtName(text) {
 	const dotIndex = text.lastIndexOf(".");
 	if (dotIndex > 0 && !text.includes("/", dotIndex)) return text.slice(0, dotIndex);
@@ -2231,14 +2262,9 @@ function trimExtName(text) {
 }
 async function getBarrelFiles(files, { type, meta = {}, root, output }) {
 	if (!type || type === "propagate") return [];
-	const barrelManager = new BarrelManager();
 	const pathToBuildFrom = join(root, output.path);
 	if (trimExtName(pathToBuildFrom).endsWith("index")) return [];
-	const barrelFiles = barrelManager.getFiles({
-		files,
-		root: pathToBuildFrom,
-		meta
-	});
+	const barrelFiles = getBarrelFilesByRoot(pathToBuildFrom, files);
 	if (type === "all") return barrelFiles.map((file) => {
 		return {
 			...file,
@@ -2258,35 +2284,13 @@ async function getBarrelFiles(files, { type, meta = {}, root, output }) {
 	});
 }
 //#endregion
-//#region src/utils/getPlugins.ts
-function isJSONPlugins(plugins) {
-	return Array.isArray(plugins) && plugins.some((plugin) => Array.isArray(plugin) && typeof plugin[0] === "string");
-}
-function isObjectPlugins(plugins) {
-	return plugins instanceof Object && !Array.isArray(plugins);
-}
-function getPlugins(plugins) {
-	if (isObjectPlugins(plugins)) throw new Error("Object plugins are not supported anymore, best to use http://kubb.dev/getting-started/configure#json");
-	if (isJSONPlugins(plugins)) throw new Error("JSON plugins are not supported anymore, best to use http://kubb.dev/getting-started/configure#json");
-	return Promise.resolve(plugins);
-}
-//#endregion
 //#region src/utils/getConfigs.ts
 /**
 * Converting UserConfig to Config Array without a change in the object beside the JSON convert.
 */
 async function getConfigs(config, args) {
-	let userConfigs = await (typeof config === "function" ? Promise.resolve(config(args)) : Promise.resolve(config));
-	if (!Array.isArray(userConfigs)) userConfigs = [userConfigs];
-	const results = [];
-	for (const item of userConfigs) {
-		const plugins = item.plugins ? await getPlugins(item.plugins) : void 0;
-		results.push({
-			...item,
-			plugins
-		});
-	}
-	return results;
+	const resolved = await (typeof config === "function" ? config(args) : config);
+	return (Array.isArray(resolved) ? resolved : [resolved]).map((item) => ({ ...item }));
 }
 //#endregion
 //#region src/utils/linters.ts
@@ -2299,13 +2303,42 @@ async function isLinterAvailable(linter) {
 	}
 }
 async function detectLinter() {
-	for (const linter of [
+	const linterNames = new Set([
 		"biome",
 		"oxlint",
 		"eslint"
-	]) if (await isLinterAvailable(linter)) return linter;
+	]);
+	for (const linter of linterNames) if (await isLinterAvailable(linter)) return linter;
+}
+//#endregion
+//#region src/utils/packageJSON.ts
+function getPackageJSONSync(cwd) {
+	const pkgPath = pkg.up({ cwd });
+	if (!pkgPath) return;
+	return JSON.parse(readSync(pkgPath));
+}
+function match(packageJSON, dependency) {
+	const dependencies = {
+		...packageJSON.dependencies || {},
+		...packageJSON.devDependencies || {}
+	};
+	if (typeof dependency === "string" && dependencies[dependency]) return dependencies[dependency];
+	const matched = Object.keys(dependencies).find((dep) => dep.match(dependency));
+	return matched ? dependencies[matched] : void 0;
+}
+function getVersionSync(dependency, cwd) {
+	const packageJSON = getPackageJSONSync(cwd);
+	return packageJSON ? match(packageJSON, dependency) : void 0;
+}
+function satisfiesDependency(dependency, version, cwd) {
+	const packageVersion = getVersionSync(dependency, cwd);
+	if (!packageVersion) return false;
+	if (packageVersion === version) return true;
+	const semVer = coerce(packageVersion);
+	if (!semVer) return false;
+	return satisfies(semVer, version);
 }
 //#endregion
-export { AsyncEventEmitter, FunctionParams, PackageManager, PluginManager, PromiseManager, URLPath, build, build as default, defineAdapter, defineConfig, defineLogger, definePlugin, definePrinter, defineStorage, detectFormatter, detectLinter, formatters, fsStorage, getBarrelFiles, getConfigs, getMode, isInputPath, linters, logLevel, memoryStorage, safeBuild, setup };
+export { FunctionParams, PluginDriver, build, build as default, createAdapter, createPlugin, createStorage, defaultResolveOptions, defineConfig, defineGenerator, defineLogger, definePrinter, defineResolver, detectFormatter, detectLinter, formatters, fsStorage, getBarrelFiles, getConfigs, getMode, isInputPath, linters, logLevel, memoryStorage, safeBuild, satisfiesDependency, setup };
 
 //# sourceMappingURL=index.js.map