@kubb/core 4.5.1 → 4.5.3

package/dist/index.js

@@ -1,8 +1,9 @@
-import { a as EventEmitter, n as createLogger, o as write } from "./logger-Bxe022ug.js";
-import { g as trim, y as transformReservedWord } from "./transformers-CeNW0G32.js";
-import { r as setUniqueName, t as URLPath } from "./URLPath-DbWtfVa1.js";
+import { c as Queue, i as getMode, l as getRelativePath, n as URLPath, r as PluginManager, s as PromiseManager, t as getBarrelFiles } from "./getBarrelFiles-D7p4n7Ug.js";
+import { a as write, n as createLogger } from "./logger-BGuor9Uu.js";
+import "./EventEmitter-IlDflnd2.js";
+import "./transformers-BaV4FwQd.js";
 import mod from "node:module";
-import path, { extname, join, normalize, relative, resolve } from "node:path";
+import path, { join, relative, resolve } from "node:path";
 import { createFabric } from "@kubb/react-fabric";
 import { typescriptParser } from "@kubb/react-fabric/parsers";
 import { fsPlugin } from "@kubb/react-fabric/plugins";
@@ -46,13 +47,27 @@ 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
@@ -108,687 +123,6 @@ function readSync(path$1) {
 	return syncReader(path$1);
 }
 
-//#endregion
-//#region src/fs/utils.ts
-function slash(path$1, platform = "linux") {
-	const isWindowsPath = /^\\\\\?\\/.test(path$1);
-	const normalizedPath = normalize(path$1);
-	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(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$1 = Array.from(iterable, (value, index) => this(function_, value, index));
-			return Promise.all(promises$1);
-		} }
-	});
-	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$1) {
-	return promises$1.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$1, nullCheck = (state) => state !== null) {
-	let promise = Promise.resolve(null);
-	for (const func of promises$1.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$1, concurrency = Number.POSITIVE_INFINITY) {
-	const limit = pLimit$1(concurrency);
-	const tasks = promises$1.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$1, { concurrency = Number.POSITIVE_INFINITY } = {}) {
-		if (strategy === "seq") return hookSeq(promises$1);
-		if (strategy === "first") return hookFirst(promises$1, this.#options.nullCheck);
-		if (strategy === "parallel") return hookParallel(promises$1, concurrency);
-		throw new Error(`${strategy} not implemented`);
-	}
-};
-function isPromiseRejectedResult(result) {
-	return result.status === "rejected";
-}
-
-//#endregion
-//#region src/plugin.ts
-function createPlugin(factory) {
-	return (options = {}) => {
-		return factory(options);
-	};
-}
-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 = path.resolve(options.config.root, options.config.output.path);
-			return path.resolve(root, baseName);
-		},
-		resolveName(name) {
-			return name;
-		}
-	};
-});
-
-//#endregion
-//#region src/PluginManager.ts
-var PluginManager = class {
-	plugins = /* @__PURE__ */ new Set();
-	events = new 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$1 = this.resolvePath({
-			baseName,
-			mode,
-			pluginKey,
-			options
-		});
-		if (!path$1) throw new Error(`Filepath should be defined for resolvedName "${name}" and pluginKey [${JSON.stringify(pluginKey)}]`);
-		return {
-			path: path$1,
-			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: [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 transformReservedWord(names?.at(0) || params.name);
-		}
-		const name = this.hookFirstSync({
-			hookName: "resolveName",
-			parameters: [trim(params.name), params.type],
-			message: `Resolving name '${params.name}' and type '${params.type}'`
-		}).result;
-		return 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$1 = 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$1);
-		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$1 = plugins.map((plugin) => {
-			return () => this.#execute({
-				strategy: "hookParallel",
-				hookName,
-				parameters,
-				plugin,
-				message
-			});
-		});
-		const results = await this.#promiseManager.run("parallel", promises$1, { 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$1 = plugins.map((plugin) => {
-			return () => this.#execute({
-				strategy: "hookSeq",
-				hookName,
-				parameters,
-				plugin,
-				message
-			});
-		});
-		await this.#promiseManager.run("seq", promises$1);
-		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;
-		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
 async function setup(options) {
@@ -828,9 +162,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,
@@ -839,13 +174,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 = resolve(resolve(config.root), config.output.path, "index.ts");
 			const rootFile = {
@@ -874,14 +217,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 ${relative(config.root, file.path)}` : "";
 			pluginManager.logger.emit("progressed", {
 				id: "files",
@@ -889,22 +232,20 @@ async function safeBuild(options, overrides) {
 			});
 			if (source) await 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,
@@ -914,223 +255,12 @@ 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: 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$1) {
-	if (!path$1) return "split";
-	return extname(path$1) ? "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 = 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
@@ -1399,5 +529,5 @@ var PackageManager = class PackageManager {
 };
 
 //#endregion
-export { BaseGenerator, PackageManager, PluginManager, PromiseManager, build, build as default, createPlugin, defineConfig, getBarrelFiles, getMode, isInputPath, safeBuild, setup };
+export { BaseGenerator, PackageManager, PluginManager, PromiseManager, build, build as default, defineConfig, definePlugin, getBarrelFiles, getMode, isInputPath, safeBuild, setup };
 //# sourceMappingURL=index.js.map