@kubb/core 4.5.1 → 4.5.3

package/dist/getBarrelFiles-D7p4n7Ug.js

@@ -0,0 +1,962 @@
+import { t as EventEmitter } from "./EventEmitter-IlDflnd2.js";
+import { g as trim, m as camelCase, v as isValidVarName, y as transformReservedWord } from "./transformers-BaV4FwQd.js";
+import path, { join, normalize, relative } from "node:path";
+
+//#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(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(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";
+}
+
+//#endregion
+//#region src/utils/uniqueName.ts
+function getUniqueName(originalName, data) {
+	let used = data[originalName] || 0;
+	if (used) {
+		data[originalName] = ++used;
+		originalName += used;
+	}
+	data[originalName] = 1;
+	return originalName;
+}
+function setUniqueName(originalName, data) {
+	let used = data[originalName] || 0;
+	if (used) {
+		data[originalName] = ++used;
+		return originalName;
+	}
+	data[originalName] = 1;
+	return originalName;
+}
+
+//#endregion
+//#region src/PluginManager.ts
+function getMode(fileOrFolder) {
+	if (!fileOrFolder) return "split";
+	return path.extname(fileOrFolder) ? "single" : "split";
+}
+var PluginManager = class {
+	events = new EventEmitter();
+	config;
+	executed = [];
+	logger;
+	options;
+	#plugins = /* @__PURE__ */ new Set();
+	#usedPluginNames = {};
+	#promiseManager;
+	constructor(config, options) {
+		this.config = config;
+		this.options = options;
+		this.logger = options.logger;
+		this.#promiseManager = new PromiseManager({ nullCheck: (state) => !!state?.result });
+		[...config.plugins || []].forEach((plugin) => {
+			const parsedPlugin = this.#parse(plugin);
+			this.#plugins.add(parsedPlugin);
+		});
+		return this;
+	}
+	getContext(plugin) {
+		const plugins = [...this.#plugins];
+		const baseContext = {
+			fabric: this.options.fabric,
+			config: this.config,
+			plugin,
+			logger: this.options.logger,
+			pluginManager: this,
+			mode: getMode(path.resolve(this.config.root, this.config.output.path)),
+			addFile: async (...files) => {
+				await this.options.fabric.addFile(...files);
+			}
+		};
+		let mergedExtras = {};
+		for (const p of plugins) if (typeof p.inject === "function") {
+			const result = p.inject.bind(baseContext)(baseContext);
+			if (result && typeof result === "object") mergedExtras = {
+				...mergedExtras,
+				...result
+			};
+		}
+		return {
+			...baseContext,
+			...mergedExtras
+		};
+	}
+	get plugins() {
+		return this.#getSortedPlugins();
+	}
+	getFile({ name, mode, extname, pluginKey, options }) {
+		const baseName = `${name}${extname}`;
+		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) => {
+		const root = path.resolve(this.config.root, this.config.output.path);
+		const defaultPath = path.resolve(root, params.baseName);
+		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) || defaultPath;
+		}
+		return this.hookFirstSync({
+			hookName: "resolvePath",
+			parameters: [
+				params.baseName,
+				params.mode,
+				params.options
+			],
+			message: `Resolving path '${params.baseName}'`
+		})?.result || defaultPath;
+	};
+	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 = 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];
+		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));
+				if (missingPlugins.length > 0) throw new ValidationPluginError(`The plugin '${plugin.name}' has a pre set that references missing plugins for '${missingPlugins.join(", ")}'`);
+			}
+			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 context = this.getContext(plugin);
+					const result = await Promise.resolve(hook.apply(context, 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 context = this.getContext(plugin);
+				const fn = hook.apply(context, 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) {
+		const usedPluginNames = this.#usedPluginNames;
+		setUniqueName(plugin.name, usedPluginNames);
+		return {
+			install() {},
+			...plugin,
+			key: [plugin.name, usedPluginNames[plugin.name]].filter(Boolean)
+		};
+	}
+};
+
+//#endregion
+//#region src/utils/URLPath.ts
+var URLPath = class {
+	path;
+	#options;
+	constructor(path$1, options = {}) {
+		this.path = path$1;
+		this.#options = options;
+		return this;
+	}
+	/**
+	* Convert Swagger path to URLPath(syntax of Express)
+	* @example /pet/{petId} => /pet/:petId
+	*/
+	get URL() {
+		return this.toURLPath();
+	}
+	get isURL() {
+		try {
+			if (new URL(this.path)?.href) return true;
+		} catch (_error) {
+			return false;
+		}
+		return false;
+	}
+	/**
+	* Convert Swagger path to template literals/ template strings(camelcase)
+	* @example /pet/{petId} => `/pet/${petId}`
+	* @example /account/monetary-accountID => `/account/${monetaryAccountId}`
+	* @example /account/userID => `/account/${userId}`
+	*/
+	get template() {
+		return this.toTemplateString();
+	}
+	get object() {
+		return this.toObject();
+	}
+	get params() {
+		return this.getParams();
+	}
+	toObject({ type = "path", replacer, stringify } = {}) {
+		const object = {
+			url: type === "path" ? this.toURLPath() : this.toTemplateString({ replacer }),
+			params: this.getParams()
+		};
+		if (stringify) {
+			if (type === "template") return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
+			if (object.params) return `{ url: '${object.url}', params: ${JSON.stringify(object.params).replaceAll("'", "").replaceAll(`"`, "")} }`;
+			return `{ url: '${object.url}' }`;
+		}
+		return object;
+	}
+	/**
+	* Convert Swagger path to template literals/ template strings(camelcase)
+	* @example /pet/{petId} => `/pet/${petId}`
+	* @example /account/monetary-accountID => `/account/${monetaryAccountId}`
+	* @example /account/userID => `/account/${userId}`
+	*/
+	toTemplateString({ prefix = "", replacer } = {}) {
+		const found = this.path.match(/{(\w|-)*}/g);
+		let newPath = this.path.replaceAll("{", "${");
+		if (found) newPath = found.reduce((prev, path$1) => {
+			const pathWithoutBrackets = path$1.replaceAll("{", "").replaceAll("}", "");
+			let param = isValidVarName(pathWithoutBrackets) ? pathWithoutBrackets : camelCase(pathWithoutBrackets);
+			if (this.#options.casing === "camelcase") param = camelCase(param);
+			return prev.replace(path$1, `\${${replacer ? replacer(param) : param}}`);
+		}, this.path);
+		return `\`${prefix}${newPath}\``;
+	}
+	getParams(replacer) {
+		const found = this.path.match(/{(\w|-)*}/g);
+		if (!found) return;
+		const params = {};
+		found.forEach((item) => {
+			item = item.replaceAll("{", "").replaceAll("}", "");
+			let param = isValidVarName(item) ? item : camelCase(item);
+			if (this.#options.casing === "camelcase") param = camelCase(param);
+			const key = replacer ? replacer(param) : param;
+			params[key] = key;
+		}, this.path);
+		return params;
+	}
+	/**
+	* Convert Swagger path to URLPath(syntax of Express)
+	* @example /pet/{petId} => /pet/:petId
+	*/
+	toURLPath() {
+		return this.path.replaceAll("{", ":").replaceAll("}", "");
+	}
+};
+
+//#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/utils/getBarrelFiles.ts
+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
+		};
+	});
+}
+
+//#endregion
+export { getUniqueName as a, Queue as c, getMode as i, getRelativePath as l, URLPath as n, setUniqueName as o, PluginManager as r, PromiseManager as s, getBarrelFiles as t };
+//# sourceMappingURL=getBarrelFiles-D7p4n7Ug.js.map