@kubb/plugin-barrel 5.8.0 → 5.8.1

package/dist/index.js

@@ -41,6 +41,15 @@ function isPathInside(path, parent) {
 	return rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
 }
 //#endregion
+//#region kubb-extension.json
+var compatibility = {
+	"kubb": ">=5.8.0",
+	"node": ">=22"
+};
+//#endregion
+//#region package.json
+var version = "5.8.1";
+//#endregion
 //#region src/utils.ts
 const SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
 	".ts",
@@ -50,219 +59,124 @@ const SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
 ]);
 const BARREL_SUFFIX = `/index.ts`;
 /**
-* Builds a directory tree rooted at `rootPath` from a list of absolute file paths.
-* Paths outside `rootPath` are silently ignored. Children are sorted alphabetically
-* by path so consumers (barrel exports, propagated indexes) emit a deterministic order.
-*
-* Both POSIX (`/`) and Windows (`\`) separators are accepted in input paths; emitted node
-* paths are always POSIX-normalized so downstream prefix/lookup operations behave the same
-* across platforms.
-*
-* @example
-* ```ts
-* buildTree('/src/gen/types', [
-*   '/src/gen/types/pet.ts',
-*   '/src/gen/types/pets/listPets.ts',
-* ])
-* ```
+* Orders paths split into segments the way a directory listing sorts them: by name at each level.
 */
-function buildTree(rootPath, filePaths) {
-	const normalizedRoot = toPosixPath(rootPath);
-	const root = {
-		path: normalizedRoot,
-		children: [],
-		isFile: false
-	};
-	const childIndex = /* @__PURE__ */ new WeakMap();
-	childIndex.set(root, /* @__PURE__ */ new Map());
-	const rootPrefix = `${normalizedRoot}/`;
-	for (const filePath of filePaths) {
-		const normalized = toPosixPath(filePath);
-		if (!normalized.startsWith(rootPrefix)) continue;
-		const parts = normalized.slice(rootPrefix.length).split("/");
-		let current = root;
-		const lastIndex = parts.length - 1;
-		for (const [i, part] of parts.entries()) {
-			if (!part) continue;
-			const isLast = i === lastIndex;
-			const siblings = childIndex.get(current);
-			let child = siblings.get(part);
-			if (!child) {
-				child = {
-					path: `${current.path}/${part}`,
-					children: [],
-					isFile: isLast
-				};
-				current.children.push(child);
-				siblings.set(part, child);
-				if (!isLast) childIndex.set(child, /* @__PURE__ */ new Map());
-			}
-			current = child;
-		}
-	}
-	sortTree(root);
-	return root;
+function compareSegments(a, b) {
+	const index = a.findIndex((segment, i) => segment !== b[i]);
+	if (index === -1) return a.length - b.length;
+	if (index >= b.length) return 1;
+	return a[index] < b[index] ? -1 : 1;
 }
-function sortTree(node) {
-	if (node.children.length === 0) return;
-	node.children.sort(compareByPath);
-	for (const child of node.children) if (!child.isFile) sortTree(child);
-}
-function compareByPath(a, b) {
-	return a.path < b.path ? -1 : a.path > b.path ? 1 : 0;
-}
-function toRelativeModulePath({ fromDir, filePath }) {
+function toRelativeModulePath(fromDir, filePath) {
 	return `./${posix.relative(fromDir, filePath)}`;
 }
-function isBarrelPath(path) {
-	return path.endsWith(BARREL_SUFFIX);
-}
-function makeBarrel({ dirPath, exports, sourceFiles, reportedCollisions }) {
-	const names = /* @__PURE__ */ new Map();
-	const uniqueExports = [];
-	for (const item of exports) {
+/**
+* Builds the `index.ts` for `dirPath`. Keeps the first export of each name and reports later duplicates once per build.
+*/
+function makeBarrel(dirPath, exports, { sourceFiles, reportedCollisions }) {
+	const owners = /* @__PURE__ */ new Map();
+	const uniqueExports = exports.flatMap((item) => {
 		const itemPath = posix.join(dirPath, item.path);
-		const itemNames = Array.isArray(item.name) ? item.name : item.name ? [item.name] : sourceFiles.get(itemPath)?.sources.flatMap((source) => source.name ? [source.name] : []);
-		const uniqueNames = [];
-		for (const name of itemNames ?? []) {
-			const first = names.get(name);
+		const uniqueNames = (item.name == null ? sourceFiles.get(itemPath)?.sources.flatMap((source) => source.name || []) ?? [] : [item.name].flat()).filter((name) => {
+			const first = owners.get(name);
 			if (!first) {
-				names.set(name, item.path);
-				uniqueNames.push(name);
-				continue;
+				owners.set(name, item.path);
+				return true;
 			}
 			const key = [
 				name,
 				posix.join(dirPath, first),
 				itemPath
 			].join("\0");
-			if (reportedCollisions.has(key)) continue;
-			reportedCollisions.add(key);
-			Diagnostics.report({
-				code: Diagnostics.code.barrelDuplicateExport,
-				severity: "error",
-				message: `"${name}" is exported by both "${first}" and "${item.path}", so "${dirPath}${BARREL_SUFFIX}" cannot re-export both.`,
-				help: "Rename one of the colliding declarations, or configure the plugin resolver to produce distinct names."
-			});
-		}
-		if (!itemNames || item.name == null || uniqueNames.length > 0) uniqueExports.push(item.name == null ? item : ast.factory.createExport({
+			if (!reportedCollisions.has(key)) {
+				reportedCollisions.add(key);
+				Diagnostics.report({
+					code: Diagnostics.code.barrelDuplicateExport,
+					severity: "error",
+					message: `"${name}" is exported by both "${first}" and "${item.path}", so "${dirPath}${BARREL_SUFFIX}" cannot re-export both.`,
+					help: "Rename one of the colliding declarations, or configure the plugin resolver to produce distinct names."
+				});
+			}
+			return false;
+		});
+		if (item.name == null) return [item];
+		return uniqueNames.length > 0 ? [ast.factory.createExport({
 			...item,
 			name: Array.isArray(item.name) ? uniqueNames : uniqueNames[0]
-		}));
-	}
+		})] : [];
+	});
 	return ast.factory.createFile({
 		baseName: "index.ts",
 		path: `${dirPath}${BARREL_SUFFIX}`,
 		exports: uniqueExports
 	});
 }
-function indexableNames({ sources, isTypeOnly }) {
+function indexableNames(sources, isTypeOnly) {
 	const names = sources.flatMap((source) => source.isIndexable && source.name && Boolean(source.isTypeOnly) === isTypeOnly ? [source.name] : []);
 	return [...new Set(names)].sort();
 }
-const allStrategy = ({ dirPath, leafPath, sourceFile }) => {
+/**
+* Re-exports the whole module, unless it has sources and none of them is indexable.
+*/
+const allStrategy = (path, sourceFile) => {
 	const sources = sourceFile?.sources ?? [];
-	if (sources.length > 0 && !sources.some((source) => source.isIndexable)) return [];
-	return [ast.factory.createExport({ path: toRelativeModulePath({
-		fromDir: dirPath,
-		filePath: leafPath
-	}) })];
+	return sources.length > 0 && !sources.some((source) => source.isIndexable) ? [] : [ast.factory.createExport({ path })];
 };
-const namedStrategy = ({ dirPath, leafPath, sourceFile }) => {
-	const modulePath = toRelativeModulePath({
-		fromDir: dirPath,
-		filePath: leafPath
-	});
-	if (!sourceFile) return [ast.factory.createExport({ path: modulePath })];
-	const valueNames = indexableNames({
-		sources: sourceFile.sources,
-		isTypeOnly: false
-	});
-	const typeNames = indexableNames({
-		sources: sourceFile.sources,
-		isTypeOnly: true
-	});
-	if (valueNames.length === 0 && typeNames.length === 0) {
-		if (sourceFile.sources.length > 0) return [];
-		return [ast.factory.createExport({ path: modulePath })];
-	}
-	const exports = [];
-	if (valueNames.length > 0) exports.push(ast.factory.createExport({
+/**
+* Re-exports the indexable names, values and types separately, or the whole module when it has no sources.
+*/
+const namedStrategy = (path, sourceFile) => {
+	if (!sourceFile?.sources.length) return [ast.factory.createExport({ path })];
+	const valueNames = indexableNames(sourceFile.sources, false);
+	const typeNames = indexableNames(sourceFile.sources, true);
+	return [...valueNames.length > 0 ? [ast.factory.createExport({
 		name: valueNames,
-		path: modulePath
-	}));
-	if (typeNames.length > 0) exports.push(ast.factory.createExport({
+		path
+	})] : [], ...typeNames.length > 0 ? [ast.factory.createExport({
 		name: typeNames,
-		path: modulePath,
+		path,
 		isTypeOnly: true
-	}));
-	return exports;
+	})] : []];
 };
 /**
-* Post-order walk that yields a barrel per visited directory.
-* Returns the list of leaf file paths collected in this subtree (used by the parent call).
+* Post-order walk that builds a barrel re-exporting every leaf below the visited directory, for
+* the start node and, with `recursive`, every sub-directory. Also returns the subtree's leaf paths.
 */
-function* walkAllOrNamed(node, params, { isRoot, recursive }) {
-	const subtreeLeaves = [];
-	for (const child of node.children) {
-		if (child.isFile) {
-			if (!isBarrelPath(child.path)) subtreeLeaves.push(child.path);
-			continue;
-		}
-		const childLeaves = yield* walkAllOrNamed(child, params, {
-			isRoot: false,
-			recursive
-		});
-		for (const leaf of childLeaves) subtreeLeaves.push(leaf);
-	}
-	if (!isRoot && !recursive) return subtreeLeaves;
-	const exports = subtreeLeaves.flatMap((leafPath) => params.strategy({
-		dirPath: node.path,
-		leafPath,
-		sourceFile: params.sourceFiles.get(leafPath)
-	}));
-	if (exports.length > 0) yield makeBarrel({
-		dirPath: node.path,
-		exports,
-		sourceFiles: params.sourceFiles,
-		reportedCollisions: params.reportedCollisions
+function walkFlat(node, ctx, isRoot = true) {
+	const results = [...node.children.values()].map((child) => child.children ? walkFlat(child, ctx, false) : {
+		barrels: [],
+		leaves: [child.path]
 	});
-	return subtreeLeaves;
+	const barrels = results.flatMap((result) => result.barrels);
+	const leaves = results.flatMap((result) => result.leaves);
+	const exports = isRoot || ctx.recursive ? leaves.flatMap((leaf) => ctx.leafExports(node.path, leaf)) : [];
+	return {
+		barrels: exports.length > 0 ? [...barrels, makeBarrel(node.path, exports, ctx)] : barrels,
+		leaves
+	};
 }
 /**
-* Recursive walk that yields one barrel per directory, re-exporting files and sub-barrels.
+* Recursive walk that builds one barrel per directory, re-exporting files and sub-barrels.
 * Used when nested: true. Leaf files honor the barrel `strategy`, so `named` emits explicit
 * named exports instead of wildcards. Sub-directory barrels are chained with a wildcard
-* re-export, which forwards the names the child barrel already curated. Returns whether this
-* node yielded a barrel, so a parent never re-exports a sub-directory that produced nothing.
+* re-export, which forwards the names the child barrel already curated. A sub-directory that
+* produced no barrel is never re-exported.
 */
-function* walkNested(node, params) {
-	const exports = [];
-	for (const child of node.children) {
-		if (child.isFile) {
-			if (isBarrelPath(child.path)) continue;
-			exports.push(...params.strategy({
-				dirPath: node.path,
-				leafPath: child.path,
-				sourceFile: params.sourceFiles.get(child.path)
-			}));
-			continue;
-		}
-		if (yield* walkNested(child, params)) exports.push(ast.factory.createExport({ path: toRelativeModulePath({
-			fromDir: node.path,
-			filePath: `${child.path}${BARREL_SUFFIX}`
-		}) }));
-	}
-	if (exports.length > 0) {
-		yield makeBarrel({
-			dirPath: node.path,
-			exports,
-			sourceFiles: params.sourceFiles,
-			reportedCollisions: params.reportedCollisions
-		});
-		return true;
-	}
-	return false;
+function walkNested(node, ctx) {
+	const results = [...node.children.values()].map((child) => {
+		if (!child.children) return {
+			barrels: [],
+			exports: ctx.leafExports(node.path, child.path)
+		};
+		const barrels = walkNested(child, ctx);
+		return {
+			barrels,
+			exports: barrels.length > 0 ? [ast.factory.createExport({ path: toRelativeModulePath(node.path, `${child.path}${BARREL_SUFFIX}`) })] : []
+		};
+	});
+	const barrels = results.flatMap((result) => result.barrels);
+	const exports = results.flatMap((result) => result.exports);
+	return exports.length > 0 ? [...barrels, makeBarrel(node.path, exports, ctx)] : barrels;
 }
 /**
 * Indexes `files` once for the directory rooted at `outputPath`: filters to indexable source
@@ -270,62 +184,62 @@ function* walkNested(node, params) {
 * derived from the same root rather than re-filtering and re-building per barrel.
 */
 function buildBarrelIndex(outputPath, files) {
-	const outputPrefix = `${toPosixPath(outputPath)}/`;
-	const sourceFiles = /* @__PURE__ */ new Map();
-	for (const file of files) {
-		const normalized = toPosixPath(file.path);
-		if (!normalized.startsWith(outputPrefix)) continue;
-		if (isBarrelPath(normalized)) continue;
-		if (!SOURCE_EXTENSIONS.has(extname(normalized))) continue;
-		sourceFiles.set(normalized, file);
-	}
+	const tree = {
+		path: toPosixPath(outputPath),
+		children: /* @__PURE__ */ new Map()
+	};
+	const sourceFiles = new Map(files.flatMap((file) => {
+		const filePath = toPosixPath(file.path);
+		return filePath.startsWith(`${tree.path}/`) && !filePath.endsWith(BARREL_SUFFIX) && SOURCE_EXTENSIONS.has(extname(filePath)) ? [[filePath, file]] : [];
+	}));
+	[...sourceFiles.keys()].map((filePath) => filePath.slice(tree.path.length + 1).split("/").filter(Boolean)).sort(compareSegments).forEach((parts) => {
+		parts.reduce((dir, part, i) => {
+			const path = `${dir.path}/${part}`;
+			const child = dir.children.get(part) ?? (i === parts.length - 1 ? { path } : {
+				path,
+				children: /* @__PURE__ */ new Map()
+			});
+			dir.children.set(part, child);
+			return child.children ? child : dir;
+		}, tree);
+	});
 	return {
-		tree: buildTree(outputPath, [...sourceFiles.keys()]),
+		tree,
 		sourceFiles
 	};
 }
 /**
-* Locates the node for `targetPath` within an index tree, walking down through directory nodes
-* only. Returns `undefined` when no file exists at or under `targetPath` (nothing to barrel).
+* Locates the directory node for `targetPath` within an index tree. Returns `undefined` when no
+* file exists under `targetPath` (nothing to barrel).
 */
-function findNode(node, targetPath) {
-	if (node.path === targetPath) return node;
-	if (node.isFile || !targetPath.startsWith(`${node.path}/`)) return void 0;
-	for (const child of node.children) if (!child.isFile && (child.path === targetPath || targetPath.startsWith(`${child.path}/`))) return findNode(child, targetPath);
+function findDirectory(tree, targetPath) {
+	if (targetPath === tree.path) return tree;
+	if (!targetPath.startsWith(`${tree.path}/`)) return void 0;
+	const node = targetPath.slice(tree.path.length + 1).split("/").reduce((current, part) => current?.children?.get(part), tree);
+	return node?.children ? node : void 0;
 }
 /**
-* Yields barrel `ast.FileNode`s for `targetPath` (or the index root), derived from a shared index.
+* Returns the barrel `ast.FileNode`s for `targetPath` (or the index root), derived from a shared index.
 * Locating the subtree is a bounded walk down from the root, so deriving many barrels (one per
 * plugin, plus the root) from one index avoids re-scanning the full file set for each.
 *
 * @example
 * ```ts
 * const index = buildBarrelIndex(outputPath, files)
-* for (const file of getBarrelFiles({ index, targetPath, barrelType })) {
-*   upsertFile(file)
-* }
+* getBarrelFiles({ index, targetPath, barrelType }).forEach((file) => upsertFile(file))
 * ```
 */
-function* getBarrelFiles({ index, targetPath, barrelType, nested = false, recursive = false, reportedCollisions = /* @__PURE__ */ new Set() }) {
-	const node = targetPath ? findNode(index.tree, toPosixPath(targetPath)) : index.tree;
-	if (!node) return;
+function getBarrelFiles({ index, targetPath, barrelType, nested = false, recursive = false, reportedCollisions = /* @__PURE__ */ new Set() }) {
+	const node = targetPath ? findDirectory(index.tree, toPosixPath(targetPath)) : index.tree;
+	if (!node) return [];
 	const strategy = barrelType === "named" ? namedStrategy : allStrategy;
-	if (nested) {
-		yield* walkNested(node, {
-			sourceFiles: index.sourceFiles,
-			strategy,
-			reportedCollisions
-		});
-		return;
-	}
-	yield* walkAllOrNamed(node, {
+	const ctx = {
 		sourceFiles: index.sourceFiles,
-		strategy,
-		reportedCollisions
-	}, {
-		isRoot: true,
-		recursive
-	});
+		reportedCollisions,
+		recursive,
+		leafExports: (dirPath, leafPath) => strategy(toRelativeModulePath(dirPath, leafPath), index.sourceFiles.get(leafPath))
+	};
+	return nested ? walkNested(node, ctx) : walkFlat(node, ctx).barrels;
 }
 //#endregion
 //#region src/plugin.ts
@@ -365,6 +279,7 @@ const pluginBarrelName = "plugin-barrel";
 const states = /* @__PURE__ */ new WeakMap();
 function getState(config) {
 	const state = states.get(config) ?? {
+		excludedPlugins: /* @__PURE__ */ new Set(),
 		excludedTargets: [],
 		pendingBarrels: []
 	};
@@ -405,19 +320,25 @@ function getState(config) {
 * ```
 */
 const pluginBarrel = definePlugin({
-	meta: { name: pluginBarrelName },
+	meta: {
+		name: pluginBarrelName,
+		version,
+		compatibility
+	},
 	enforce: "post",
 	hooks: {
 		"kubb:plugin:end"({ plugin, config }) {
 			if (plugin.name === "plugin-barrel") return;
-			const { excludedTargets, pendingBarrels } = getState(config);
+			const { excludedPlugins, excludedTargets, pendingBarrels } = getState(config);
 			const barrelConfig = plugin.options.output?.barrel ?? config.output.barrel ?? false;
 			const base = path.resolve(config.root, config.output.path);
-			const target = path.resolve(base, plugin.options.output.path);
+			const target = path.resolve(base, plugin.options.output.path ?? ".");
 			if (barrelConfig === false) {
-				excludedTargets.push(target);
+				excludedPlugins.add(plugin.name);
+				if (target !== base && isPathInside(target, base)) excludedTargets.push(target);
 				return;
 			}
+			if (target === base) return;
 			if (plugin.options.output.mode === "file") return;
 			if (!isPathInside(target, base)) throw new Diagnostics.Error({
 				code: Diagnostics.code.pathTraversal,
@@ -434,32 +355,43 @@ const pluginBarrel = definePlugin({
 			});
 		},
 		"kubb:plugins:end"({ files, config, upsertFile }) {
-			const { excludedTargets, pendingBarrels } = getState(config);
+			const { excludedPlugins, excludedTargets, pendingBarrels } = getState(config);
 			const rootBarrelConfig = config.output.barrel ?? false;
 			const outputPath = path.resolve(config.root, config.output.path);
-			const relevantFiles = files.filter((file) => !excludedTargets.some((target) => isPathInside(file.path, target)));
+			const relevantFiles = files.filter((file) => {
+				const owner = file.meta?.pluginName;
+				if (owner) return !excludedPlugins.has(owner);
+				return !excludedTargets.some((target) => isPathInside(file.path, target));
+			});
+			excludedPlugins.clear();
 			excludedTargets.length = 0;
 			const index = buildBarrelIndex(outputPath, relevantFiles);
 			const reportedCollisions = /* @__PURE__ */ new Set();
-			for (const { plugin, target, barrelType, nested } of pendingBarrels) for (const file of getBarrelFiles({
-				index,
-				targetPath: target,
-				barrelType,
-				nested,
-				recursive: true,
-				reportedCollisions
-			})) upsertFile(withBarrelBannerFooter({
-				file,
-				plugin,
-				config
-			}));
+			pendingBarrels.forEach(({ plugin, target, barrelType, nested }) => {
+				getBarrelFiles({
+					index,
+					targetPath: target,
+					barrelType,
+					nested,
+					recursive: true,
+					reportedCollisions
+				}).forEach((file) => {
+					upsertFile(withBarrelBannerFooter({
+						file,
+						plugin,
+						config
+					}));
+				});
+			});
 			pendingBarrels.length = 0;
 			if (rootBarrelConfig === false) return;
-			for (const file of getBarrelFiles({
+			getBarrelFiles({
 				index,
 				barrelType: rootBarrelConfig.type,
 				reportedCollisions
-			})) upsertFile(file);
+			}).forEach((file) => {
+				upsertFile(file);
+			});
 		}
 	}
 });