@kubb/core 4.2.0 → 4.2.2

package/dist/{index-BY_kka8d.d.ts → index-BTe91LHd.d.ts}

@@ -141,5 +141,5 @@ type ResolvedFile<TMeta extends object = object> = File<TMeta> & {
 //#region src/fs/index.d.ts
 declare function trimExtName(text: string): string;
 //#endregion
-export { read as _, File as a, clean as b, OptionalPath as c, ResolvedFile as d, ResolvedImport as f, unlink as g, getRelativePath as h, Extname as i, Path as l, write as m, BaseName as n, Import as o, types_d_exports as p, Export as r, Mode as s, trimExtName as t, ResolvedExport as u, readSync as v, exists as y };
-//# sourceMappingURL=index-BY_kka8d.d.ts.map
+export { Mode as a, types_d_exports as c, unlink as d, read as f, clean as h, File as i, write as l, exists as m, BaseName as n, OptionalPath as o, readSync as p, Extname as r, ResolvedFile as s, trimExtName as t, getRelativePath as u };
+//# sourceMappingURL=index-BTe91LHd.d.ts.map

package/dist/{index-Iq8NJRgc.d.cts → index-BmQIxvw0.d.cts}

@@ -140,5 +140,5 @@ type ResolvedFile<TMeta extends object = object> = File<TMeta> & {
 //#region src/fs/index.d.ts
 declare function trimExtName(text: string): string;
 //#endregion
-export { read as _, File as a, clean as b, OptionalPath as c, ResolvedFile as d, ResolvedImport as f, unlink as g, getRelativePath as h, Extname as i, Path as l, write as m, BaseName as n, Import as o, types_d_exports as p, Export as r, Mode as s, trimExtName as t, ResolvedExport as u, readSync as v, exists as y };
-//# sourceMappingURL=index-Iq8NJRgc.d.cts.map
+export { Mode as a, types_d_exports as c, unlink as d, read as f, clean as h, File as i, write as l, exists as m, BaseName as n, OptionalPath as o, readSync as p, Extname as r, ResolvedFile as s, trimExtName as t, getRelativePath as u };
+//# sourceMappingURL=index-BmQIxvw0.d.cts.map

package/dist/index.cjs

@@ -2,9 +2,10 @@ Object.defineProperty(exports, '__esModule', { value: true });
 const require_chunk = require('./chunk-CZg_9w7l.cjs');
 const require_fs = require('./fs-RSVoUw3S.cjs');
 require('./write-BJfM7G1_.cjs');
-const require_logger = require('./logger-S_t55o9n.cjs');
-const require_transformers = require('./transformers-BIx7CVmw.cjs');
-const require_FileManager = require('./FileManager-DlkY9W5A.cjs');
+const require_logger = require('./logger-BXL0YCrv.cjs');
+const require_transformers = require('./transformers-BH0KLJJP.cjs');
+const require_URLPath = require('./URLPath-8WVzHBnA.cjs');
+require('./casing-CP-9GGdK.cjs');
 let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);
 let picocolors = require("picocolors");
@@ -13,6 +14,8 @@ let remeda = require("remeda");
 remeda = require_chunk.__toESM(remeda);
 let node_process = require("node:process");
 node_process = require_chunk.__toESM(node_process);
+let __kubb_fabric_core = require("@kubb/fabric-core");
+__kubb_fabric_core = require_chunk.__toESM(__kubb_fabric_core);
 let node_module = require("node:module");
 node_module = require_chunk.__toESM(node_module);
 let node_os = require("node:os");
@@ -63,6 +66,128 @@ function isInputPath(result) {
 	return !!result && "path" in result?.input;
 }
 
+//#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
 /**
@@ -92,7 +217,7 @@ function hookFirst(promises, nullCheck = (state) => state !== null) {
 * Runs an array of promise functions with optional concurrency limit.
 */
 function hookParallel(promises, concurrency = Number.POSITIVE_INFINITY) {
-	const limit = require_FileManager.pLimit(concurrency);
+	const limit = pLimit$1(concurrency);
 	const tasks = promises.filter(Boolean).map((promise) => limit(() => promise()));
 	return Promise.allSettled(tasks);
 }
@@ -116,10 +241,6 @@ function isPromiseRejectedResult(result) {
 	return result.status === "rejected";
 }
 
-//#endregion
-//#region src/errors.ts
-var ValidationPluginError = class extends Error {};
-
 //#endregion
 //#region src/plugin.ts
 function createPlugin(factory) {
@@ -170,6 +291,9 @@ const pluginCore = createPlugin((options) => {
 //#region src/PluginManager.ts
 var PluginManager = class {
 	plugins = /* @__PURE__ */ new Set();
+	/**
+	* @deprecated do not use from pluginManager
+	*/
 	fileManager;
 	events = new require_logger.EventEmitter();
 	config;
@@ -183,7 +307,7 @@ var PluginManager = class {
 		this.config = config;
 		this.options = options;
 		this.logger = options.logger;
-		this.fileManager = new require_FileManager.FileManager();
+		this.fileManager = new __kubb_fabric_core.FileManager();
 		this.#promiseManager = new PromiseManager({ nullCheck: (state) => !!state?.result });
 		const core = pluginCore({
 			config,
@@ -201,8 +325,8 @@ var PluginManager = class {
 		});
 		return this;
 	}
-	getFile({ name, mode, extname, pluginKey, options }) {
-		const baseName = `${name}${extname}`;
+	getFile({ name, mode, extname: extname$1, pluginKey, options }) {
+		const baseName = `${name}${extname$1}`;
 		const path$3 = this.resolvePath({
 			baseName,
 			mode,
@@ -576,7 +700,7 @@ var PluginManager = class {
 	}
 	#parse(plugin, pluginManager, context) {
 		const usedPluginNames = pluginManager.#usedPluginNames;
-		require_FileManager.setUniqueName(plugin.name, 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,
@@ -615,7 +739,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_FileManager.URLPath(userConfig.input.path).isURL) await require_fs.exists(userConfig.input.path);
+		if (isInputPath(userConfig) && !new require_URLPath.URLPath(userConfig.input.path).isURL) await require_fs.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 });
 	}
@@ -675,7 +799,7 @@ async function safeBuild(options) {
 			const rootFile = {
 				path: rootPath,
 				baseName: "index.ts",
-				exports: (await pluginManager.fileManager.getFiles()).filter((file) => {
+				exports: (await pluginManager.fileManager.files).filter((file) => {
 					return file.sources.some((source) => source.isIndexable);
 				}).flatMap((file) => {
 					const containsOnlyTypes = file.sources?.every((source) => source.isTypeOnly);
@@ -698,11 +822,27 @@ async function safeBuild(options) {
 			};
 			await pluginManager.fileManager.add(rootFile);
 		}
-		const files = await pluginManager.fileManager.processFiles({
-			root: config.root,
+		pluginManager.fileManager.processor.on("start", ({ files: files$1 }) => {
+			pluginManager.logger.emit("progress_start", {
+				id: "files",
+				size: files$1.length,
+				message: "Writing files ..."
+			});
+		});
+		pluginManager.fileManager.processor.on("file:start", ({ file }) => {
+			const message = file ? `Writing ${(0, node_path.relative)(config.root, file.path)}` : "";
+			pluginManager.logger.emit("progressed", {
+				id: "files",
+				message
+			});
+		});
+		pluginManager.fileManager.processor.on("file:finish", () => {});
+		pluginManager.fileManager.processor.on("finish", () => {
+			pluginManager.logger.emit("progress_stop", { id: "files" });
+		});
+		const files = await pluginManager.fileManager.write({
 			extension: config.output.extension,
-			dryRun: !config.output.write,
-			logger: pluginManager.logger
+			dryRun: !config.output.write
 		});
 		await pluginManager.hookParallel({
 			hookName: "buildEnd",
@@ -722,11 +862,228 @@ async function safeBuild(options) {
 	}
 }
 
+//#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: require_fs.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";
+}
+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 (require_fs.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
 //#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 require_FileManager.Queue();
+	const queue = new Queue();
 	let activeCount = 0;
 	const next = () => {
 		activeCount--;
@@ -989,7 +1346,6 @@ var PackageManager = class PackageManager {
 
 //#endregion
 exports.BaseGenerator = BaseGenerator;
-exports.FileManager = require_FileManager.FileManager;
 exports.PackageManager = PackageManager;
 exports.PluginManager = PluginManager;
 exports.PromiseManager = PromiseManager;
@@ -997,8 +1353,8 @@ exports.build = build;
 exports.createPlugin = createPlugin;
 exports.default = build;
 exports.defineConfig = defineConfig;
-exports.getDefaultBanner = require_FileManager.getDefaultBanner;
-exports.getSource = require_FileManager.getSource;
+exports.getBarrelFiles = getBarrelFiles;
+exports.getMode = getMode;
 exports.isInputPath = isInputPath;
 exports.safeBuild = safeBuild;
 exports.setup = setup;