@kubb/core 4.5.0 → 4.5.2

package/dist/index.cjs

@@ -1,8 +1,9 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 const require_chunk = require('./chunk-CUT6urMc.cjs');
-const require_logger = require('./logger-BIzTtBYJ.cjs');
-const require_transformers = require('./transformers-DWLXDYKb.cjs');
-const require_URLPath = require('./URLPath-Dir2mxRT.cjs');
+const require_getBarrelFiles = require('./getBarrelFiles-o9ETjpTV.cjs');
+const require_logger = require('./logger-CLbtdL9m.cjs');
+require('./EventEmitter-3-rxpjGN.cjs');
+require('./transformers-BpnIvSiH.cjs');
 let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);
 let __kubb_react_fabric = require("@kubb/react-fabric");
@@ -62,748 +63,81 @@ var BaseGenerator = class {
 //#endregion
 //#region src/config.ts
 /**
-* Type helper to make it easier to use vite.config.ts accepts a direct UserConfig object, or a function that returns it. The function receives a ConfigEnv object.
+* Helper for defining a Kubb configuration.
+*
+* Accepts either:
+* - A config object or array of configs
+* - A function returning the config(s), optionally async,
+*   receiving the CLI options as argument
+*
+* @example
+* export default defineConfig(({ logLevel }) => ({
+*   root: 'src',
+*   plugins: [myPlugin()],
+* }))
 */
-function defineConfig(options) {
-	return options;
+function defineConfig(config) {
+	return config;
 }
-function isInputPath(result) {
-	return !!result && "path" in result?.input;
+/**
+* Type guard to check if a given config has an `input.path`.
+*/
+function isInputPath(config) {
+	return typeof config?.input === "object" && config.input !== null && "path" in config.input;
 }
 
 //#endregion
 //#region src/fs/clean.ts
-async function clean(path$3) {
-	return fs_extra.default.remove(path$3);
+async function clean(path$2) {
+	return fs_extra.default.remove(path$2);
 }
 
 //#endregion
 //#region src/fs/exists.ts
 const reader$1 = (0, js_runtime.switcher)({
-	node: async (path$3) => {
-		return fs_extra.default.pathExists(path$3);
+	node: async (path$2) => {
+		return fs_extra.default.pathExists(path$2);
 	},
-	bun: async (path$3) => {
-		return Bun.file(path$3).exists();
+	bun: async (path$2) => {
+		return Bun.file(path$2).exists();
 	}
 }, "node");
 const syncReader$1 = (0, js_runtime.switcher)({
-	node: (path$3) => {
-		return fs_extra.default.pathExistsSync(path$3);
+	node: (path$2) => {
+		return fs_extra.default.pathExistsSync(path$2);
 	},
 	bun: () => {
 		throw new Error("Bun cannot read sync");
 	}
 }, "node");
-async function exists(path$3) {
-	return reader$1(path$3);
+async function exists(path$2) {
+	return reader$1(path$2);
 }
 
 //#endregion
 //#region src/fs/read.ts
 const reader = (0, js_runtime.switcher)({
-	node: async (path$3) => {
-		return fs_extra.default.readFile(path$3, { encoding: "utf8" });
+	node: async (path$2) => {
+		return fs_extra.default.readFile(path$2, { encoding: "utf8" });
 	},
-	bun: async (path$3) => {
-		return Bun.file(path$3).text();
+	bun: async (path$2) => {
+		return Bun.file(path$2).text();
 	}
 }, "node");
 const syncReader = (0, js_runtime.switcher)({
-	node: (path$3) => {
-		return fs_extra.default.readFileSync(path$3, { encoding: "utf8" });
+	node: (path$2) => {
+		return fs_extra.default.readFileSync(path$2, { encoding: "utf8" });
 	},
 	bun: () => {
 		throw new Error("Bun cannot read sync");
 	}
 }, "node");
-async function read(path$3) {
-	return reader(path$3);
-}
-function readSync(path$3) {
-	return syncReader(path$3);
-}
-
-//#endregion
-//#region src/fs/utils.ts
-function slash(path$3, platform = "linux") {
-	const isWindowsPath = /^\\\\\?\\/.test(path$3);
-	const normalizedPath = (0, node_path.normalize)(path$3);
-	if (["linux", "mac"].includes(platform) && !isWindowsPath) return normalizedPath.replaceAll(/\\/g, "/").replace("../", "");
-	return normalizedPath.replaceAll(/\\/g, "/").replace("../", "");
-}
-function getRelativePath(rootDir, filePath, platform = "linux") {
-	if (!rootDir || !filePath) throw new Error(`Root and file should be filled in when retrieving the relativePath, ${rootDir || ""} ${filePath || ""}`);
-	const slashedPath = slash((0, node_path.relative)(rootDir, filePath), platform);
-	if (slashedPath.startsWith("../")) return slashedPath;
-	return `./${slashedPath}`;
-}
-
-//#endregion
-//#region src/errors.ts
-var ValidationPluginError = class extends Error {};
-
-//#endregion
-//#region ../../node_modules/.pnpm/yocto-queue@1.2.1/node_modules/yocto-queue/index.js
-var Node = class {
-	value;
-	next;
-	constructor(value) {
-		this.value = value;
-	}
-};
-var Queue = class {
-	#head;
-	#tail;
-	#size;
-	constructor() {
-		this.clear();
-	}
-	enqueue(value) {
-		const node = new Node(value);
-		if (this.#head) {
-			this.#tail.next = node;
-			this.#tail = node;
-		} else {
-			this.#head = node;
-			this.#tail = node;
-		}
-		this.#size++;
-	}
-	dequeue() {
-		const current = this.#head;
-		if (!current) return;
-		this.#head = this.#head.next;
-		this.#size--;
-		return current.value;
-	}
-	peek() {
-		if (!this.#head) return;
-		return this.#head.value;
-	}
-	clear() {
-		this.#head = void 0;
-		this.#tail = void 0;
-		this.#size = 0;
-	}
-	get size() {
-		return this.#size;
-	}
-	*[Symbol.iterator]() {
-		let current = this.#head;
-		while (current) {
-			yield current.value;
-			current = current.next;
-		}
-	}
-	*drain() {
-		while (this.#head) yield this.dequeue();
-	}
-};
-
-//#endregion
-//#region ../../node_modules/.pnpm/p-limit@7.2.0/node_modules/p-limit/index.js
-function pLimit$1(concurrency) {
-	validateConcurrency(concurrency);
-	const queue = new Queue();
-	let activeCount = 0;
-	const resumeNext = () => {
-		if (activeCount < concurrency && queue.size > 0) {
-			activeCount++;
-			queue.dequeue()();
-		}
-	};
-	const next = () => {
-		activeCount--;
-		resumeNext();
-	};
-	const run = async (function_, resolve$1, arguments_) => {
-		const result = (async () => function_(...arguments_))();
-		resolve$1(result);
-		try {
-			await result;
-		} catch {}
-		next();
-	};
-	const enqueue = (function_, resolve$1, arguments_) => {
-		new Promise((internalResolve) => {
-			queue.enqueue(internalResolve);
-		}).then(run.bind(void 0, function_, resolve$1, arguments_));
-		if (activeCount < concurrency) resumeNext();
-	};
-	const generator = (function_, ...arguments_) => new Promise((resolve$1) => {
-		enqueue(function_, resolve$1, arguments_);
-	});
-	Object.defineProperties(generator, {
-		activeCount: { get: () => activeCount },
-		pendingCount: { get: () => queue.size },
-		clearQueue: { value() {
-			queue.clear();
-		} },
-		concurrency: {
-			get: () => concurrency,
-			set(newConcurrency) {
-				validateConcurrency(newConcurrency);
-				concurrency = newConcurrency;
-				queueMicrotask(() => {
-					while (activeCount < concurrency && queue.size > 0) resumeNext();
-				});
-			}
-		},
-		map: { async value(iterable, function_) {
-			const promises = Array.from(iterable, (value, index) => this(function_, value, index));
-			return Promise.all(promises);
-		} }
-	});
-	return generator;
-}
-function validateConcurrency(concurrency) {
-	if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) throw new TypeError("Expected `concurrency` to be a number from 1 and up");
-}
-
-//#endregion
-//#region src/utils/executeStrategies.ts
-/**
-* Chains promises
-*/
-function hookSeq(promises) {
-	return promises.filter(Boolean).reduce((promise, func) => {
-		if (typeof func !== "function") throw new Error("HookSeq needs a function that returns a promise `() => Promise<unknown>`");
-		return promise.then((state) => {
-			const calledFunc = func(state);
-			if (calledFunc) return calledFunc.then(Array.prototype.concat.bind(state));
-		});
-	}, Promise.resolve([]));
-}
-/**
-* Chains promises, first non-null result stops and returns
-*/
-function hookFirst(promises, nullCheck = (state) => state !== null) {
-	let promise = Promise.resolve(null);
-	for (const func of promises.filter(Boolean)) promise = promise.then((state) => {
-		if (nullCheck(state)) return state;
-		return func(state);
-	});
-	return promise;
-}
-/**
-* Runs an array of promise functions with optional concurrency limit.
-*/
-function hookParallel(promises, concurrency = Number.POSITIVE_INFINITY) {
-	const limit = pLimit$1(concurrency);
-	const tasks = promises.filter(Boolean).map((promise) => limit(() => promise()));
-	return Promise.allSettled(tasks);
-}
-
-//#endregion
-//#region src/PromiseManager.ts
-var PromiseManager = class {
-	#options = {};
-	constructor(options = {}) {
-		this.#options = options;
-		return this;
-	}
-	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";
+async function read(path$2) {
+	return reader(path$2);
 }
-
-//#endregion
-//#region src/plugin.ts
-function createPlugin(factory) {
-	return (options = {}) => {
-		return factory(options);
-	};
+function readSync(path$2) {
+	return syncReader(path$2);
 }
-const pluginCore = createPlugin((options) => {
-	const { fabric, pluginManager, resolvePath, resolveName, logger } = options;
-	return {
-		name: "core",
-		options,
-		key: ["core"],
-		context() {
-			return {
-				get fabric() {
-					return fabric;
-				},
-				get config() {
-					return options.config;
-				},
-				get plugins() {
-					return options.getPlugins();
-				},
-				get plugin() {
-					return options.plugin;
-				},
-				logger,
-				get fileManager() {
-					return fabric.context.fileManager;
-				},
-				pluginManager,
-				async addFile(...files) {
-					const resolvedFiles = await fabric.context.fileManager.add(...files);
-					if (!Array.isArray(resolvedFiles)) return [resolvedFiles];
-					return resolvedFiles;
-				},
-				resolvePath,
-				resolveName
-			};
-		},
-		resolvePath(baseName) {
-			const root = node_path.default.resolve(options.config.root, options.config.output.path);
-			return node_path.default.resolve(root, baseName);
-		},
-		resolveName(name) {
-			return name;
-		}
-	};
-});
-
-//#endregion
-//#region src/PluginManager.ts
-var PluginManager = class {
-	plugins = /* @__PURE__ */ new Set();
-	events = new require_logger.EventEmitter();
-	config;
-	executed = [];
-	logger;
-	options;
-	#core;
-	#usedPluginNames = {};
-	#promiseManager;
-	constructor(config, options) {
-		this.config = config;
-		this.options = options;
-		this.logger = options.logger;
-		this.#promiseManager = new PromiseManager({ nullCheck: (state) => !!state?.result });
-		const core = pluginCore({
-			fabric: options.fabric,
-			config,
-			logger: this.logger,
-			pluginManager: this,
-			resolvePath: this.resolvePath.bind(this),
-			resolveName: this.resolveName.bind(this),
-			getPlugins: this.#getSortedPlugins.bind(this)
-		});
-		this.#core = this.#parse(core, this, core.context.call(null));
-		[this.#core, ...config.plugins || []].forEach((plugin) => {
-			const parsedPlugin = this.#parse(plugin, this, this.#core.context);
-			this.plugins.add(parsedPlugin);
-		});
-		return this;
-	}
-	getFile({ name, mode, extname: extname$1, pluginKey, options }) {
-		const baseName = `${name}${extname$1}`;
-		const path$3 = this.resolvePath({
-			baseName,
-			mode,
-			pluginKey,
-			options
-		});
-		if (!path$3) throw new Error(`Filepath should be defined for resolvedName "${name}" and pluginKey [${JSON.stringify(pluginKey)}]`);
-		return {
-			path: path$3,
-			baseName,
-			meta: { pluginKey },
-			sources: []
-		};
-	}
-	resolvePath = (params) => {
-		if (params.pluginKey) {
-			const paths = this.hookForPluginSync({
-				pluginKey: params.pluginKey,
-				hookName: "resolvePath",
-				parameters: [
-					params.baseName,
-					params.mode,
-					params.options
-				],
-				message: `Resolving path '${params.baseName}'`
-			});
-			if (paths && paths?.length > 1) this.logger.emit("debug", {
-				date: /* @__PURE__ */ new Date(),
-				logs: [`Cannot return a path where the 'pluginKey' ${params.pluginKey ? JSON.stringify(params.pluginKey) : "\""} is not unique enough\n\nPaths: ${JSON.stringify(paths, void 0, 2)}\n\nFalling back on the first item.\n`]
-			});
-			return paths?.at(0);
-		}
-		return this.hookFirstSync({
-			hookName: "resolvePath",
-			parameters: [
-				params.baseName,
-				params.mode,
-				params.options
-			],
-			message: `Resolving path '${params.baseName}'`
-		}).result;
-	};
-	resolveName = (params) => {
-		if (params.pluginKey) {
-			const names = this.hookForPluginSync({
-				pluginKey: params.pluginKey,
-				hookName: "resolveName",
-				parameters: [require_transformers.trim(params.name), params.type],
-				message: `Resolving name '${params.name}' and type '${params.type}'`
-			});
-			if (names && names?.length > 1) this.logger.emit("debug", {
-				date: /* @__PURE__ */ new Date(),
-				logs: [`Cannot return a name where the 'pluginKey' ${params.pluginKey ? JSON.stringify(params.pluginKey) : "\""} is not unique enough\n\nNames: ${JSON.stringify(names, void 0, 2)}\n\nFalling back on the first item.\n`]
-			});
-			return require_transformers.transformReservedWord(names?.at(0) || params.name);
-		}
-		const name = this.hookFirstSync({
-			hookName: "resolveName",
-			parameters: [require_transformers.trim(params.name), params.type],
-			message: `Resolving name '${params.name}' and type '${params.type}'`
-		}).result;
-		return require_transformers.transformReservedWord(name);
-	};
-	/**
-	* Instead of calling `pluginManager.events.on` you can use `pluginManager.on`. This one also has better types.
-	*/
-	on(eventName, handler) {
-		this.events.on(eventName, handler);
-	}
-	/**
-	* Run a specific hookName for plugin x.
-	*/
-	async hookForPlugin({ pluginKey, hookName, parameters, message }) {
-		const plugins = this.getPluginsByKey(hookName, pluginKey);
-		this.logger.emit("progress_start", {
-			id: hookName,
-			size: plugins.length,
-			message: "Running plugins..."
-		});
-		const items = [];
-		for (const plugin of plugins) {
-			const result = await this.#execute({
-				strategy: "hookFirst",
-				hookName,
-				parameters,
-				plugin,
-				message
-			});
-			if (result !== void 0 && result !== null) items.push(result);
-		}
-		this.logger.emit("progress_stop", { id: hookName });
-		return items;
-	}
-	/**
-	* Run a specific hookName for plugin x.
-	*/
-	hookForPluginSync({ pluginKey, hookName, parameters, message }) {
-		return this.getPluginsByKey(hookName, pluginKey).map((plugin) => {
-			return this.#executeSync({
-				strategy: "hookFirst",
-				hookName,
-				parameters,
-				plugin,
-				message
-			});
-		}).filter(Boolean);
-	}
-	/**
-	* First non-null result stops and will return it's value.
-	*/
-	async hookFirst({ hookName, parameters, skipped, message }) {
-		const plugins = this.#getSortedPlugins(hookName).filter((plugin) => {
-			return skipped ? skipped.has(plugin) : true;
-		});
-		this.logger.emit("progress_start", {
-			id: hookName,
-			size: plugins.length
-		});
-		const promises = plugins.map((plugin) => {
-			return async () => {
-				const value = await this.#execute({
-					strategy: "hookFirst",
-					hookName,
-					parameters,
-					plugin,
-					message
-				});
-				return Promise.resolve({
-					plugin,
-					result: value
-				});
-			};
-		});
-		const result = await this.#promiseManager.run("first", promises);
-		this.logger.emit("progress_stop", { id: hookName });
-		return result;
-	}
-	/**
-	* First non-null result stops and will return it's value.
-	*/
-	hookFirstSync({ hookName, parameters, skipped, message }) {
-		let parseResult = null;
-		const plugins = this.#getSortedPlugins(hookName).filter((plugin) => {
-			return skipped ? skipped.has(plugin) : true;
-		});
-		for (const plugin of plugins) {
-			parseResult = {
-				result: this.#executeSync({
-					strategy: "hookFirst",
-					hookName,
-					parameters,
-					plugin,
-					message
-				}),
-				plugin
-			};
-			if (parseResult?.result != null) break;
-		}
-		return parseResult;
-	}
-	/**
-	* Run all plugins in parallel(order will be based on `this.plugin` and if `pre` or `post` is set).
-	*/
-	async hookParallel({ hookName, parameters, message }) {
-		const plugins = this.#getSortedPlugins(hookName);
-		this.logger.emit("progress_start", {
-			id: hookName,
-			size: plugins.length
-		});
-		const promises = plugins.map((plugin) => {
-			return () => this.#execute({
-				strategy: "hookParallel",
-				hookName,
-				parameters,
-				plugin,
-				message
-			});
-		});
-		const results = await this.#promiseManager.run("parallel", promises, { concurrency: this.options.concurrency });
-		results.forEach((result, index) => {
-			if (isPromiseRejectedResult(result)) {
-				const plugin = this.#getSortedPlugins(hookName)[index];
-				this.#catcher(result.reason, plugin, hookName);
-			}
-		});
-		this.logger.emit("progress_stop", { id: hookName });
-		return results.filter((result) => result.status === "fulfilled").map((result) => result.value);
-	}
-	/**
-	* Chains plugins
-	*/
-	async hookSeq({ hookName, parameters, message }) {
-		const plugins = this.#getSortedPlugins(hookName);
-		this.logger.emit("progress_start", {
-			id: hookName,
-			size: plugins.length
-		});
-		const promises = plugins.map((plugin) => {
-			return () => this.#execute({
-				strategy: "hookSeq",
-				hookName,
-				parameters,
-				plugin,
-				message
-			});
-		});
-		await this.#promiseManager.run("seq", promises);
-		this.logger.emit("progress_stop", { id: hookName });
-	}
-	#getSortedPlugins(hookName) {
-		const plugins = [...this.plugins].filter((plugin) => plugin.name !== "core");
-		if (hookName) return plugins.filter((plugin) => hookName in plugin);
-		return plugins.map((plugin) => {
-			if (plugin.pre) {
-				if (!plugin.pre.every((pluginName) => plugins.find((pluginToFind) => pluginToFind.name === pluginName))) throw new ValidationPluginError(`This plugin has a pre set that is not valid(${JSON.stringify(plugin.pre, void 0, 2)})`);
-			}
-			return plugin;
-		}).sort((a, b) => {
-			if (b.pre?.includes(a.name)) return 1;
-			if (b.post?.includes(a.name)) return -1;
-			return 0;
-		});
-	}
-	getPluginByKey(pluginKey) {
-		const plugins = [...this.plugins];
-		const [searchPluginName] = pluginKey;
-		return plugins.find((item) => {
-			const [name] = item.key;
-			return name === searchPluginName;
-		});
-	}
-	getPluginsByKey(hookName, pluginKey) {
-		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;
-		});
-		if (!pluginByPluginName?.length) {
-			const corePlugin = plugins.find((plugin) => plugin.name === "core" && hookName in plugin);
-			if (corePlugin) this.logger.emit("debug", {
-				date: /* @__PURE__ */ new Date(),
-				logs: [`No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, falling back on the '@kubb/core' plugin`]
-			});
-			else this.logger.emit("debug", {
-				date: /* @__PURE__ */ new Date(),
-				logs: [`No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, no fallback found in the '@kubb/core' plugin`]
-			});
-			return corePlugin ? [corePlugin] : [];
-		}
-		return pluginByPluginName;
-	}
-	#addExecutedToCallStack(executer) {
-		if (executer) {
-			this.events.emit("executed", executer);
-			this.executed.push(executer);
-			this.logger.emit("progressed", {
-				id: executer.hookName,
-				message: `${executer.plugin.name}: ${executer.message}`
-			});
-		}
-	}
-	/**
-	* Run an async plugin hook and return the result.
-	* @param hookName Name of the plugin hook. Must be either in `PluginHooks` or `OutputPluginValueHooks`.
-	* @param args Arguments passed to the plugin hook.
-	* @param plugin The actual pluginObject to run.
-	*/
-	#execute({ strategy, hookName, parameters, plugin, message }) {
-		const hook = plugin[hookName];
-		let output;
-		if (!hook) return null;
-		this.events.emit("executing", {
-			strategy,
-			hookName,
-			parameters,
-			plugin,
-			message
-		});
-		return (async () => {
-			try {
-				if (typeof hook === "function") {
-					const result = await Promise.resolve(hook.apply({
-						...this.#core.context,
-						plugin
-					}, parameters));
-					output = result;
-					this.#addExecutedToCallStack({
-						parameters,
-						output,
-						strategy,
-						hookName,
-						plugin,
-						message
-					});
-					return result;
-				}
-				output = hook;
-				this.#addExecutedToCallStack({
-					parameters,
-					output,
-					strategy,
-					hookName,
-					plugin,
-					message
-				});
-				return hook;
-			} catch (e) {
-				this.#catcher(e, plugin, hookName);
-				return null;
-			}
-		})();
-	}
-	/**
-	* Run a sync plugin hook and return the result.
-	* @param hookName Name of the plugin hook. Must be in `PluginHooks`.
-	* @param args Arguments passed to the plugin hook.
-	* @param plugin The acutal plugin
-	* @param replaceContext When passed, the plugin context can be overridden.
-	*/
-	#executeSync({ strategy, hookName, parameters, plugin, message }) {
-		const hook = plugin[hookName];
-		let output;
-		if (!hook) return null;
-		this.events.emit("executing", {
-			strategy,
-			hookName,
-			parameters,
-			plugin,
-			message
-		});
-		try {
-			if (typeof hook === "function") {
-				const fn = hook.apply({
-					...this.#core.context,
-					plugin
-				}, parameters);
-				output = fn;
-				this.#addExecutedToCallStack({
-					parameters,
-					output,
-					strategy,
-					hookName,
-					plugin,
-					message
-				});
-				return fn;
-			}
-			output = hook;
-			this.#addExecutedToCallStack({
-				parameters,
-				output,
-				strategy,
-				hookName,
-				plugin,
-				message
-			});
-			return hook;
-		} catch (e) {
-			this.#catcher(e, plugin, hookName);
-			return null;
-		}
-	}
-	#catcher(cause, plugin, hookName) {
-		const text = `${cause.message} (plugin: ${plugin?.name || "unknown"}, hook: ${hookName || "unknown"})`;
-		this.logger.emit("error", text, cause);
-		this.events.emit("error", cause);
-	}
-	#parse(plugin, pluginManager, context) {
-		const usedPluginNames = pluginManager.#usedPluginNames;
-		require_URLPath.setUniqueName(plugin.name, usedPluginNames);
-		const key = [plugin.name, usedPluginNames[plugin.name]].filter(Boolean);
-		if (plugin.context && typeof plugin.context === "function") return {
-			...plugin,
-			key,
-			context: plugin.context.call(context)
-		};
-		return {
-			...plugin,
-			key
-		};
-	}
-	static getDependedPlugins(plugins, dependedPluginNames) {
-		let pluginNames = [];
-		if (typeof dependedPluginNames === "string") pluginNames = [dependedPluginNames];
-		else pluginNames = dependedPluginNames;
-		return pluginNames.map((pluginName) => {
-			const plugin = plugins.find((plugin$1) => plugin$1.name === pluginName);
-			if (!plugin) throw new ValidationPluginError(`This plugin depends on the ${pluginName} plugin.`);
-			return plugin;
-		});
-	}
-	static get hooks() {
-		return [
-			"buildStart",
-			"resolvePath",
-			"resolveName",
-			"buildEnd"
-		];
-	}
-};
 
 //#endregion
 //#region src/build.ts
@@ -811,7 +145,7 @@ async function setup(options) {
 	const { config: userConfig, logger = require_logger.createLogger() } = options;
 	if (Array.isArray(userConfig.input)) console.warn(picocolors.default.yellow("This feature is still under development — use with caution"));
 	try {
-		if (isInputPath(userConfig) && !new require_URLPath.URLPath(userConfig.input.path).isURL) await exists(userConfig.input.path);
+		if (isInputPath(userConfig) && !new require_getBarrelFiles.URLPath(userConfig.input.path).isURL) await exists(userConfig.input.path);
 	} catch (e) {
 		if (isInputPath(userConfig)) throw new Error(`Cannot read file/URL defined in \`input.path\` or set with \`kubb generate PATH\` in the CLI of your Kubb config ${userConfig.input.path}`, { cause: e });
 	}
@@ -836,7 +170,7 @@ async function setup(options) {
 	fabric.use(__kubb_react_fabric_parsers.typescriptParser);
 	return {
 		fabric,
-		pluginManager: new PluginManager(definedConfig, {
+		pluginManager: new require_getBarrelFiles.PluginManager(definedConfig, {
 			fabric,
 			logger,
 			concurrency: 5
@@ -844,9 +178,10 @@ async function setup(options) {
 	};
 }
 async function build(options, overrides) {
-	const { fabric, files, pluginManager, error } = await safeBuild(options, overrides);
+	const { fabric, files, pluginManager, failedPlugins, error } = await safeBuild(options, overrides);
 	if (error) throw error;
 	return {
+		failedPlugins,
 		fabric,
 		files,
 		pluginManager,
@@ -855,13 +190,21 @@ async function build(options, overrides) {
 }
 async function safeBuild(options, overrides) {
 	const { fabric, pluginManager } = overrides ? overrides : await setup(options);
+	const failedPlugins = /* @__PURE__ */ new Set();
 	const config = pluginManager.config;
 	try {
-		await pluginManager.hookParallel({
-			hookName: "buildStart",
-			parameters: [config],
-			message: "buildStart"
-		});
+		for (const plugin of pluginManager.plugins) {
+			const context = pluginManager.getContext(plugin);
+			const installer = plugin.install.bind(context);
+			try {
+				await installer(context);
+			} catch (e) {
+				failedPlugins.add({
+					plugin,
+					error: e
+				});
+			}
+		}
 		if (config.output.barrelType) {
 			const rootPath = (0, node_path.resolve)((0, node_path.resolve)(config.root), config.output.path, "index.ts");
 			const rootFile = {
@@ -880,7 +223,7 @@ async function safeBuild(options, overrides) {
 						if (!pluginOptions || pluginOptions?.output?.barrelType === false) return;
 						return {
 							name: config.output.barrelType === "all" ? void 0 : [source.name],
-							path: getRelativePath(rootPath, file.path),
+							path: require_getBarrelFiles.getRelativePath(rootPath, file.path),
 							isTypeOnly: config.output.barrelType === "all" ? containsOnlyTypes : source.isTypeOnly
 						};
 					}).filter(Boolean);
@@ -890,14 +233,14 @@ async function safeBuild(options, overrides) {
 			};
 			await fabric.addFile(rootFile);
 		}
-		fabric.context.events.on("process:start", ({ files: files$1 }) => {
+		fabric.context.on("process:start", ({ files: files$1 }) => {
 			pluginManager.logger.emit("progress_start", {
 				id: "files",
 				size: files$1.length,
 				message: "Writing files ..."
 			});
 		});
-		fabric.context.events.on("process:progress", async ({ file, source }) => {
+		fabric.context.on("process:progress", async ({ file, source }) => {
 			const message = file ? `Writing ${(0, node_path.relative)(config.root, file.path)}` : "";
 			pluginManager.logger.emit("progressed", {
 				id: "files",
@@ -905,22 +248,20 @@ async function safeBuild(options, overrides) {
 			});
 			if (source) await require_logger.write(file.path, source, { sanity: false });
 		});
-		fabric.context.events.on("process:end", () => {
+		fabric.context.on("process:end", () => {
 			pluginManager.logger.emit("progress_stop", { id: "files" });
 		});
 		const files = [...fabric.files];
 		await fabric.write({ extension: config.output.extension });
-		await pluginManager.hookParallel({
-			hookName: "buildEnd",
-			message: `Build stopped for ${config.name}`
-		});
 		return {
+			failedPlugins,
 			fabric,
 			files,
 			pluginManager
 		};
 	} catch (e) {
 		return {
+			failedPlugins,
 			fabric,
 			files: [],
 			pluginManager,
@@ -930,230 +271,19 @@ async function safeBuild(options, overrides) {
 }
 
 //#endregion
-//#region src/utils/TreeNode.ts
-var TreeNode = class TreeNode {
-	data;
-	parent;
-	children = [];
-	#cachedLeaves = void 0;
-	constructor(data, parent) {
-		this.data = data;
-		this.parent = parent;
-		return this;
-	}
-	addChild(data) {
-		const child = new TreeNode(data, this);
-		if (!this.children) this.children = [];
-		this.children.push(child);
-		return child;
-	}
-	get root() {
-		if (!this.parent) return this;
-		return this.parent.root;
-	}
-	get leaves() {
-		if (!this.children || this.children.length === 0) return [this];
-		if (this.#cachedLeaves) return this.#cachedLeaves;
-		const leaves = [];
-		if (this.children) for (let i = 0, { length } = this.children; i < length; i++) leaves.push.apply(leaves, this.children[i].leaves);
-		this.#cachedLeaves = leaves;
-		return leaves;
-	}
-	forEach(callback) {
-		if (typeof callback !== "function") throw new TypeError("forEach() callback must be a function");
-		callback(this);
-		if (this.children) for (let i = 0, { length } = this.children; i < length; i++) this.children[i]?.forEach(callback);
-		return this;
-	}
-	findDeep(predicate) {
-		if (typeof predicate !== "function") throw new TypeError("find() predicate must be a function");
-		return this.leaves.find(predicate);
-	}
-	forEachDeep(callback) {
-		if (typeof callback !== "function") throw new TypeError("forEach() callback must be a function");
-		this.leaves.forEach(callback);
-	}
-	filterDeep(callback) {
-		if (typeof callback !== "function") throw new TypeError("filter() callback must be a function");
-		return this.leaves.filter(callback);
-	}
-	mapDeep(callback) {
-		if (typeof callback !== "function") throw new TypeError("map() callback must be a function");
-		return this.leaves.map(callback);
-	}
-	static build(files, root) {
-		try {
-			const filteredTree = buildDirectoryTree(files, root);
-			if (!filteredTree) return null;
-			const treeNode = new TreeNode({
-				name: filteredTree.name,
-				path: filteredTree.path,
-				file: filteredTree.file,
-				type: getMode(filteredTree.path)
-			});
-			const recurse = (node, item) => {
-				const subNode = node.addChild({
-					name: item.name,
-					path: item.path,
-					file: item.file,
-					type: getMode(item.path)
-				});
-				if (item.children?.length) item.children?.forEach((child) => {
-					recurse(subNode, child);
-				});
-			};
-			filteredTree.children?.forEach((child) => {
-				recurse(treeNode, child);
-			});
-			return treeNode;
-		} catch (e) {
-			throw new Error("Something went wrong with creating barrel files with the TreeNode class", { cause: e });
-		}
-	}
-};
-const normalizePath = (p) => p.replace(/\\/g, "/");
-function buildDirectoryTree(files, rootFolder = "") {
-	const normalizedRootFolder = normalizePath(rootFolder);
-	const rootPrefix = normalizedRootFolder.endsWith("/") ? normalizedRootFolder : `${normalizedRootFolder}/`;
-	const filteredFiles = files.filter((file) => {
-		const normalizedFilePath = normalizePath(file.path);
-		return rootFolder ? normalizedFilePath.startsWith(rootPrefix) && !normalizedFilePath.endsWith(".json") : !normalizedFilePath.endsWith(".json");
-	});
-	if (filteredFiles.length === 0) return null;
-	const root = {
-		name: rootFolder || "",
-		path: rootFolder || "",
-		children: []
-	};
-	filteredFiles.forEach((file) => {
-		const parts = file.path.slice(rootFolder.length).split("/");
-		let currentLevel = root.children;
-		let currentPath = rootFolder;
-		parts.forEach((part, index) => {
-			if (index !== 0) currentPath += `/${part}`;
-			else currentPath += `${part}`;
-			let existingNode = currentLevel.find((node) => node.name === part);
-			if (!existingNode) {
-				if (index === parts.length - 1) existingNode = {
-					name: part,
-					file,
-					path: currentPath
-				};
-				else existingNode = {
-					name: part,
-					path: currentPath,
-					children: []
-				};
-				currentLevel.push(existingNode);
-			}
-			if (!existingNode.file) currentLevel = existingNode.children;
-		});
-	});
-	return root;
-}
-
-//#endregion
-//#region src/BarrelManager.ts
-var BarrelManager = class {
-	#options;
-	constructor(options = {}) {
-		this.#options = options;
-		return this;
-	}
-	getFiles({ files: generatedFiles, root }) {
-		const { logger } = this.#options;
-		const cachedFiles = /* @__PURE__ */ new Map();
-		TreeNode.build(generatedFiles, root)?.forEach((treeNode) => {
-			if (!treeNode || !treeNode.children || !treeNode.parent?.data.path) return;
-			const barrelFile = {
-				path: (0, node_path.join)(treeNode.parent?.data.path, "index.ts"),
-				baseName: "index.ts",
-				exports: [],
-				sources: []
-			};
-			const previousBarrelFile = cachedFiles.get(barrelFile.path);
-			treeNode.leaves.forEach((item) => {
-				if (!item.data.name) return;
-				const sources = item.data.file?.sources || [];
-				if (!sources.some((source) => source.isIndexable)) logger?.emit("warning", `No isIndexable source found(source should have a name and isIndexable):\nFile: ${JSON.stringify(item.data.file, void 0, 2)}`);
-				sources.forEach((source) => {
-					if (!item.data.file?.path || !source.isIndexable || !source.name) return;
-					if (previousBarrelFile?.sources.some((item$1) => item$1.name === source.name && item$1.isTypeOnly === source.isTypeOnly)) return;
-					if (!barrelFile.exports) barrelFile.exports = [];
-					if (!!treeNode.parent?.data.path?.split?.("/")?.length) barrelFile.exports.push({
-						name: [source.name],
-						path: getRelativePath(treeNode.parent?.data.path, item.data.path),
-						isTypeOnly: source.isTypeOnly
-					});
-					else barrelFile.exports.push({
-						name: [source.name],
-						path: `./${item.data.file.baseName}`,
-						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/FileManager.ts
-function getMode(path$3) {
-	if (!path$3) return "split";
-	return (0, node_path.extname)(path$3) ? "single" : "split";
-}
-function trimExtName(text) {
-	return text.replace(/\.[^/.]+$/, "");
-}
-async function getBarrelFiles(files, { type, meta = {}, root, output, logger }) {
-	if (!type || type === "propagate") return [];
-	const barrelManager = new BarrelManager({ logger });
-	const pathToBuildFrom = (0, node_path.join)(root, output.path);
-	if (trimExtName(pathToBuildFrom).endsWith("index")) {
-		logger?.emit("warning", "Output has the same fileName as the barrelFiles, please disable barrel generation");
-		return [];
-	}
-	const barrelFiles = barrelManager.getFiles({
-		files,
-		root: pathToBuildFrom,
-		meta
-	});
-	if (type === "all") return barrelFiles.map((file) => {
-		return {
-			...file,
-			exports: file.exports?.map((exportItem) => {
-				return {
-					...exportItem,
-					name: void 0
-				};
-			})
-		};
-	});
-	return barrelFiles.map((indexFile) => {
-		return {
-			...indexFile,
-			meta
-		};
-	});
+//#region src/definePlugin.ts
+/**
+* Wraps a plugin builder to make the options parameter optional.
+*/
+function definePlugin(build$1) {
+	return (options) => build$1(options ?? {});
 }
 
 //#endregion
 //#region ../../node_modules/.pnpm/p-limit@4.0.0/node_modules/p-limit/index.js
 function pLimit(concurrency) {
 	if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) throw new TypeError("Expected `concurrency` to be a number from 1 and up");
-	const queue = new Queue();
+	const queue = new require_getBarrelFiles.Queue();
 	let activeCount = 0;
 	const next = () => {
 		activeCount--;
@@ -1344,14 +474,14 @@ var PackageManager = class PackageManager {
 		if (!this.#SLASHES.has(directory[directory.length - 1])) return `${directory}/`;
 		return directory;
 	}
-	getLocation(path$3) {
-		let location = path$3;
-		if (this.#cwd) location = node_module.default.createRequire(this.normalizeDirectory(this.#cwd)).resolve(path$3);
+	getLocation(path$2) {
+		let location = path$2;
+		if (this.#cwd) location = node_module.default.createRequire(this.normalizeDirectory(this.#cwd)).resolve(path$2);
 		return location;
 	}
-	async import(path$3) {
+	async import(path$2) {
 		try {
-			let location = this.getLocation(path$3);
+			let location = this.getLocation(path$2);
 			if (node_os.default.platform() === "win32") location = (0, node_url.pathToFileURL)(location).href;
 			const module$1 = await import(location);
 			return module$1?.default ?? module$1;
@@ -1417,14 +547,14 @@ var PackageManager = class PackageManager {
 //#endregion
 exports.BaseGenerator = BaseGenerator;
 exports.PackageManager = PackageManager;
-exports.PluginManager = PluginManager;
-exports.PromiseManager = PromiseManager;
+exports.PluginManager = require_getBarrelFiles.PluginManager;
+exports.PromiseManager = require_getBarrelFiles.PromiseManager;
 exports.build = build;
-exports.createPlugin = createPlugin;
 exports.default = build;
 exports.defineConfig = defineConfig;
-exports.getBarrelFiles = getBarrelFiles;
-exports.getMode = getMode;
+exports.definePlugin = definePlugin;
+exports.getBarrelFiles = require_getBarrelFiles.getBarrelFiles;
+exports.getMode = require_getBarrelFiles.getMode;
 exports.isInputPath = isInputPath;
 exports.safeBuild = safeBuild;
 exports.setup = setup;