@kubb/core 4.2.0 → 4.2.1

package/dist/index.js

@@ -1,13 +1,15 @@
-import { a as read, c as clean, o as readSync, r as getRelativePath, s as exists } from "./fs-BIPMUfpW.js";
+import { a as read, c as clean, o as readSync, r as getRelativePath, s as exists, t as trimExtName } from "./fs-BIPMUfpW.js";
 import "./write-CxO1CDML.js";
-import { a as EventEmitter, n as createLogger } from "./logger-CsQ2EGpR.js";
-import { a as transformReservedWord, l as trim } from "./transformers-5BubQvcu.js";
-import { b as Queue, c as getDefaultBanner, f as setUniqueName, n as getSource, t as FileManager, u as URLPath, y as pLimit$1 } from "./FileManager-zlhCXf6A.js";
+import { a as EventEmitter, n as createLogger } from "./logger-CDxSrFkR.js";
+import { h as trim, v as transformReservedWord } from "./transformers-DzHGqYO2.js";
+import { r as setUniqueName, t as URLPath } from "./URLPath-BYceu_vY.js";
+import "./casing-BSeq_teY.js";
 import mod from "node:module";
-import path, { join, resolve } from "node:path";
+import path, { extname, join, relative, resolve } from "node:path";
 import pc from "picocolors";
 import { isDeepEqual } from "remeda";
 import g$1 from "node:process";
+import { FileManager } from "@kubb/fabric-core";
 import os from "node:os";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import fs, { promises } from "node:fs";
@@ -52,6 +54,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$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
 /**
@@ -105,10 +229,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) {
@@ -159,6 +279,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 EventEmitter();
 	config;
@@ -664,7 +787,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);
@@ -687,11 +810,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 ${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",
@@ -711,6 +850,223 @@ 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: 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";
+}
+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
 //#region ../../node_modules/.pnpm/p-limit@4.0.0/node_modules/p-limit/index.js
 function pLimit(concurrency) {
@@ -977,5 +1333,5 @@ var PackageManager = class PackageManager {
 };
 
 //#endregion
-export { BaseGenerator, FileManager, PackageManager, PluginManager, PromiseManager, build, build as default, createPlugin, defineConfig, getDefaultBanner, getSource, isInputPath, safeBuild, setup };
+export { BaseGenerator, PackageManager, PluginManager, PromiseManager, build, build as default, createPlugin, defineConfig, getBarrelFiles, getMode, isInputPath, safeBuild, setup };
 //# sourceMappingURL=index.js.map