@kubb/core/dist/getBarrelFiles-DqGGy0LT.js

Core functionality for Kubb's plugin-based code generation system, providing the foundation for transforming OpenAPI specifications.

import { t as __name } from "./chunk-iVr_oF3V.js";
import { n as getRelativePath } from "./fs--foJTbRT.js";
import { b as isValidVarName, m as camelCase, v as trim, x as transformReservedWord } from "./transformers-CqOjKLQD.js";
import path, { join } from "node:path";
import { performance } from "node:perf_hooks";
import { EventEmitter } from "node:events";

//#region src/errors.ts
var ValidationPluginError = class extends Error {};
var BuildError = class extends Error {
	cause;
	errors;
	constructor(message, options) {
		super(message, { cause: options.cause });
		this.name = "BuildError";
		this.cause = options.cause;
		this.errors = options.errors;
	}
};

//#endregion
//#region ../../node_modules/.pnpm/yocto-queue@1.2.2/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--;
		if (!this.#head) this.#tail = void 0;
		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 {
	config;
	options;
	#plugins = /* @__PURE__ */ new Set();
	#usedPluginNames = {};
	#promiseManager;
	constructor(config, options) {
		this.config = config;
		this.options = options;
		this.#promiseManager = new PromiseManager({ nullCheck: (state) => !!state?.result });
		[...config.plugins || []].forEach((plugin) => {
			const parsedPlugin = this.#parse(plugin);
			this.#plugins.add(parsedPlugin);
		});
		return this;
	}
	get events() {
		return this.options.events;
	}
	getContext(plugin) {
		const plugins = [...this.#plugins];
		const baseContext = {
			fabric: this.options.fabric,
			config: this.config,
			plugin,
			events: this.options.events,
			pluginManager: this,
			mode: getMode(path.resolve(this.config.root, this.config.output.path)),
			addFile: async (...files) => {
				await this.options.fabric.addFile(...files);
			},
			upsertFile: async (...files) => {
				await this.options.fabric.upsertFile(...files);
			}
		};
		const mergedExtras = {};
		for (const p of plugins) if (typeof p.inject === "function") {
			const result = p.inject.bind(baseContext)(baseContext);
			if (result && typeof result === "object") Object.assign(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: [],
			imports: [],
			exports: []
		};
	}
	resolvePath = (params) => {
		const root = path.resolve(this.config.root, this.config.output.path);
		const defaultPath = path.resolve(root, params.baseName);
		if (params.pluginKey) return this.hookForPluginSync({
			pluginKey: params.pluginKey,
			hookName: "resolvePath",
			parameters: [
				params.baseName,
				params.mode,
				params.options
			]
		})?.at(0) || defaultPath;
		return this.hookFirstSync({
			hookName: "resolvePath",
			parameters: [
				params.baseName,
				params.mode,
				params.options
			]
		})?.result || defaultPath;
	};
	resolveName = (params) => {
		if (params.pluginKey) {
			const names = this.hookForPluginSync({
				pluginKey: params.pluginKey,
				hookName: "resolveName",
				parameters: [trim(params.name), params.type]
			});
			return transformReservedWord([...new Set(names)].at(0) || params.name);
		}
		const name = this.hookFirstSync({
			hookName: "resolveName",
			parameters: [trim(params.name), params.type]
		}).result;
		return transformReservedWord(name);
	};
	/**
	* Run a specific hookName for plugin x.
	*/
	async hookForPlugin({ pluginKey, hookName, parameters }) {
		const plugins = this.getPluginsByKey(hookName, pluginKey);
		this.events.emit("plugins:hook:progress:start", {
			hookName,
			plugins
		});
		const items = [];
		for (const plugin of plugins) {
			const result = await this.#execute({
				strategy: "hookFirst",
				hookName,
				parameters,
				plugin
			});
			if (result !== void 0 && result !== null) items.push(result);
		}
		this.events.emit("plugins:hook:progress:end", { hookName });
		return items;
	}
	/**
	* Run a specific hookName for plugin x.
	*/
	hookForPluginSync({ pluginKey, hookName, parameters }) {
		return this.getPluginsByKey(hookName, pluginKey).map((plugin) => {
			return this.#executeSync({
				strategy: "hookFirst",
				hookName,
				parameters,
				plugin
			});
		}).filter(Boolean);
	}
	/**
	* First non-null result stops and will return it's value.
	*/
	async hookFirst({ hookName, parameters, skipped }) {
		const plugins = this.#getSortedPlugins(hookName).filter((plugin) => {
			return skipped ? skipped.has(plugin) : true;
		});
		this.events.emit("plugins:hook:progress:start", {
			hookName,
			plugins
		});
		const promises = plugins.map((plugin) => {
			return async () => {
				const value = await this.#execute({
					strategy: "hookFirst",
					hookName,
					parameters,
					plugin
				});
				return Promise.resolve({
					plugin,
					result: value
				});
			};
		});
		const result = await this.#promiseManager.run("first", promises);
		this.events.emit("plugins:hook:progress:end", { hookName });
		return result;
	}
	/**
	* First non-null result stops and will return it's value.
	*/
	hookFirstSync({ hookName, parameters, skipped }) {
		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
				}),
				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 }) {
		const plugins = this.#getSortedPlugins(hookName);
		this.events.emit("plugins:hook:progress:start", {
			hookName,
			plugins
		});
		const promises = plugins.map((plugin) => {
			return () => this.#execute({
				strategy: "hookParallel",
				hookName,
				parameters,
				plugin
			});
		});
		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];
				if (plugin) this.events.emit("error", result.reason, {
					plugin,
					hookName,
					strategy: "hookParallel",
					duration: 0,
					parameters
				});
			}
		});
		this.events.emit("plugins:hook:progress:end", { hookName });
		return results.reduce((acc, result) => {
			if (result.status === "fulfilled") acc.push(result.value);
			return acc;
		}, []);
	}
	/**
	* Chains plugins
	*/
	async hookSeq({ hookName, parameters }) {
		const plugins = this.#getSortedPlugins(hookName);
		this.events.emit("plugins:hook:progress:start", {
			hookName,
			plugins
		});
		const promises = plugins.map((plugin) => {
			return () => this.#execute({
				strategy: "hookSeq",
				hookName,
				parameters,
				plugin
			});
		});
		await this.#promiseManager.run("seq", promises);
		this.events.emit("plugins:hook:progress:end", { hookName });
	}
	#getSortedPlugins(hookName) {
		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);
			return corePlugin ? [corePlugin] : [];
		}
		return pluginByPluginName;
	}
	/**
	* 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 }) {
		const hook = plugin[hookName];
		let output;
		if (!hook) return null;
		this.events.emit("plugins:hook:processing:start", {
			strategy,
			hookName,
			parameters,
			plugin
		});
		const startTime = performance.now();
		return (async () => {
			try {
				if (typeof hook === "function") {
					const context = this.getContext(plugin);
					const result = await Promise.resolve(hook.apply(context, parameters));
					output = result;
					this.events.emit("plugins:hook:processing:end", {
						duration: Math.round(performance.now() - startTime),
						parameters,
						output,
						strategy,
						hookName,
						plugin
					});
					return result;
				}
				output = hook;
				this.events.emit("plugins:hook:processing:end", {
					duration: Math.round(performance.now() - startTime),
					parameters,
					output,
					strategy,
					hookName,
					plugin
				});
				return hook;
			} catch (error) {
				this.events.emit("error", error, {
					plugin,
					hookName,
					strategy,
					duration: Math.round(performance.now() - startTime)
				});
				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 }) {
		const hook = plugin[hookName];
		let output;
		if (!hook) return null;
		this.events.emit("plugins:hook:processing:start", {
			strategy,
			hookName,
			parameters,
			plugin
		});
		const startTime = performance.now();
		try {
			if (typeof hook === "function") {
				const context = this.getContext(plugin);
				const fn = hook.apply(context, parameters);
				output = fn;
				this.events.emit("plugins:hook:processing:end", {
					duration: Math.round(performance.now() - startTime),
					parameters,
					output,
					strategy,
					hookName,
					plugin
				});
				return fn;
			}
			output = hook;
			this.events.emit("plugins:hook:processing:end", {
				duration: Math.round(performance.now() - startTime),
				parameters,
				output,
				strategy,
				hookName,
				plugin
			});
			return hook;
		} catch (error) {
			this.events.emit("error", error, {
				plugin,
				hookName,
				strategy,
				duration: Math.round(performance.now() - startTime)
			});
			return null;
		}
	}
	#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/AsyncEventEmitter.ts
var AsyncEventEmitter = class {
	constructor(maxListener = 100) {
		this.#emitter.setMaxListeners(maxListener);
	}
	#emitter = new EventEmitter();
	async emit(eventName, ...eventArgs) {
		const listeners = this.#emitter.listeners(eventName);
		if (listeners.length === 0) return;
		await Promise.all(listeners.map(async (listener) => {
			try {
				return await listener(...eventArgs);
			} catch (err) {
				const causedError = err;
				throw new Error(`Error in async listener for "${eventName}" with eventArgs "${eventArgs}"`, { cause: causedError });
			}
		}));
	}
	on(eventName, handler) {
		this.#emitter.on(eventName, handler);
	}
	onOnce(eventName, handler) {
		const wrapper = (...args) => {
			this.off(eventName, wrapper);
			handler(...args);
		};
		this.on(eventName, wrapper);
	}
	off(eventName, handler) {
		this.#emitter.off(eventName, handler);
	}
	removeAll() {
		this.#emitter.removeAllListeners();
	}
};

//#endregion
//#region src/utils/formatHrtime.ts
/**
* Calculates elapsed time in milliseconds from a high-resolution start time.
* Rounds to 2 decimal places to provide sub-millisecond precision without noise.
*/
function getElapsedMs(hrStart) {
	const [seconds, nanoseconds] = process.hrtime(hrStart);
	const ms = seconds * 1e3 + nanoseconds / 1e6;
	return Math.round(ms * 100) / 100;
}
/**
* Converts a millisecond duration into a human-readable string.
* Adjusts units (ms, s, m s) based on the magnitude of the duration.
*/
function formatMs(ms) {
	if (ms >= 6e4) return `${Math.floor(ms / 6e4)}m ${(ms % 6e4 / 1e3).toFixed(1)}s`;
	if (ms >= 1e3) return `${(ms / 1e3).toFixed(2)}s`;
	return `${Math.round(ms).toFixed(0)}ms`;
}
/**
* Convenience helper to get and format elapsed time in one step.
*/
function formatHrtime(hrStart) {
	return formatMs(getElapsedMs(hrStart));
}

//#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 childIndex = 0, { length } = this.children; childIndex < length; childIndex++) leaves.push.apply(leaves, this.children[childIndex].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 childIndex = 0, { length } = this.children; childIndex < length; childIndex++) this.children[childIndex]?.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 (error) {
			throw new Error("Something went wrong with creating barrel files with the TreeNode class", { cause: error });
		}
	}
};
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
/** biome-ignore-all lint/suspicious/useIterableCallbackReturn: not needed */
var BarrelManager = class {
	constructor(_options = {}) {
		return this;
	}
	getFiles({ files: generatedFiles, root }) {
		const cachedFiles = /* @__PURE__ */ new Map();
		TreeNode.build(generatedFiles, root)?.forEach((treeNode) => {
			if (!treeNode || !treeNode.children || !treeNode.parent?.data.path) return;
			const barrelFile = {
				path: join(treeNode.parent?.data.path, "index.ts"),
				baseName: "index.ts",
				exports: [],
				imports: [],
				sources: []
			};
			const previousBarrelFile = cachedFiles.get(barrelFile.path);
			treeNode.leaves.forEach((item) => {
				if (!item.data.name) return;
				(item.data.file?.sources || []).forEach((source) => {
					if (!item.data.file?.path || !source.isIndexable || !source.name) return;
					if (previousBarrelFile?.sources.some((item$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 }) {
	if (!type || type === "propagate") return [];
	const barrelManager = new BarrelManager({});
	const pathToBuildFrom = join(root, output.path);
	if (trimExtName(pathToBuildFrom).endsWith("index")) return [];
	const barrelFiles = barrelManager.getFiles({
		files,
		root: pathToBuildFrom,
		meta
	});
	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 { getElapsedMs as a, getMode as c, PromiseManager as d, Queue as f, formatMs as i, getUniqueName as l, URLPath as n, AsyncEventEmitter as o, BuildError as p, formatHrtime as r, PluginManager as s, getBarrelFiles as t, setUniqueName as u };
//# sourceMappingURL=getBarrelFiles-DqGGy0LT.js.map