@kubb/middleware-barrel 5.0.0-alpha.62 → 5.0.0-alpha.64

package/dist/index.d.ts

@@ -3,12 +3,11 @@ import * as _$_kubb_core0 from "@kubb/core";
 
 //#region src/types.d.ts
 /**
- * The barrel type controls the style of re-exports generated in barrel files.
- *
- * - `'all'`       — `export * from '...'` (re-export everything)
- * - `'named'`     — `export { name1, name2 } from '...'` (named re-exports only)
- * - `'propagate'` — like `'all'` but also generates intermediate barrel files for
- *                   every sub-directory so that consumers can import from any depth.
+ * Re-export style used when generating barrel `index.ts` files.
+ * - `'all'` emits `export * from '...'` for every file.
+ * - `'named'` emits `export { name1, name2 } from '...'` from each file's indexable sources.
+ * - `'propagate'` behaves like `'all'` and also generates an intermediate barrel for every
+ *   sub-directory so consumers can import from any depth.
  */
 type BarrelType = 'all' | 'named' | 'propagate';
 //#endregion
@@ -18,14 +17,13 @@ declare global {
     interface PluginOptionsRegistry {
       output: {
         /**
-         * Controls which barrel file (index.ts) is generated for this plugin's output directory.
+         * Re-export style for this plugin's barrel file.
+         * Set to `false` to disable barrel generation for this plugin entirely; doing so also
+         * excludes the plugin's files from the root barrel.
          *
-         * - `'all'`       — `export * from '...'` for every generated file.
-         * - `'named'`     — `export { … } from '...'` using the file's named exports.
-         * - `'propagate'` — like `'all'` but also generates intermediate barrel files.
-         * - `false`       — disable barrel generation for this plugin.
+         * Falls back to `config.output.barrelType` when omitted.
          *
-         * When omitted, the root `config.output.barrelType` is used as the default.
+         * @default 'named'
          */
         barrelType?: BarrelType | false;
       };
@@ -33,14 +31,11 @@ declare global {
     interface ConfigOptionsRegistry {
       output: {
         /**
-         * Controls the root barrel file (index.ts) generated at `config.output.path`.
-         *
-         * - `'all'`       — `export * from '...'` for every plugin's barrel.
-         * - `'named'`     — `export { … } from '...'` using the barrel's named exports.
-         * - `'propagate'` — like `'all'` but also generates intermediate barrel files.
-         * - `false`       — disable root barrel generation.
+         * Re-export style for the root barrel file at `config.output.path/index.ts`.
+         * Set to `false` to disable root barrel generation. Individual plugins can override
+         * this via their own `output.barrelType`.
          *
-         * Individual plugins can override this via their own `output.barrelType`.
+         * @default 'named'
          */
         barrelType?: BarrelType | false;
       };
@@ -48,20 +43,16 @@ declare global {
   }
 }
 /**
- * Barrel-file generation middleware.
- *
- * When added to `config.middleware`, generates an `index.ts` barrel file for each
- * plugin. When `output.barrelType` is omitted on a plugin it inherits from `config.output.barrelType`,
- * and when that is also omitted both default to `'all'`. Set `barrelType: false` to disable
- * barrel generation for a specific plugin or for the root entirely.
+ * Generates `index.ts` barrel files for each plugin's output directory and one root barrel
+ * at `config.output.path/index.ts`.
  *
- * The `barrelType` option controls the re-export style:
- * - `'all'`       — `export * from '...'` for each generated file
- * - `'named'`     — `export { name1, name2 } from '...'` using each file's indexable sources
- * - `'propagate'` — like `'all'` with intermediate barrel files for sub-directories
+ * Plugins inherit `output.barrelType` from `config.output.barrelType` (which itself defaults to `'named'`).
+ * Setting `barrelType: false` on a plugin disables its barrel and excludes the plugin's files from the
+ * root barrel as well.
  *
  * @example
  * ```ts
+ * import { defineConfig } from '@kubb/core'
  * import { middlewareBarrel } from '@kubb/middleware-barrel'
  *
  * export default defineConfig({

package/dist/index.js

@@ -1,6 +1,6 @@
 import "./chunk--u3MIqq1.js";
 import { defineMiddleware } from "@kubb/core";
-import { posix, resolve } from "node:path";
+import { extname, resolve } from "node:path";
 import { createExport, createFile } from "@kubb/ast";
 //#region src/constants.ts
 /**
@@ -8,18 +8,18 @@ import { createExport, createFile } from "@kubb/ast";
 */
 const BARREL_FILENAME = "index.ts";
 //#endregion
-//#region src/utils/buildTree.ts
+//#region ../../internals/utils/src/buildTree.ts
 /**
-* Builds a `TreeNode` directory tree from a list of absolute file paths.
+* 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.
 *
-* All `filePaths` must be inside `rootPath`. Paths that are outside
-* the root or that equal the root are silently ignored.
+* Both POSIX (`/`) and Windows (`\`) separators are accepted in input paths.
 *
 * @example
 * ```ts
-* const tree = buildTree('/src/gen/types', [
+* buildTree('/src/gen/types', [
 *   '/src/gen/types/pet.ts',
-*   '/src/gen/types/user.ts',
 *   '/src/gen/types/pets/listPets.ts',
 * ])
 * ```
@@ -30,28 +30,45 @@ function buildTree(rootPath, filePaths) {
 		children: [],
 		isFile: false
 	};
+	const childIndex = /* @__PURE__ */ new Map();
+	childIndex.set(root, /* @__PURE__ */ new Map());
+	const rootPrefix = `${rootPath.replaceAll("\\", "/")}/`;
 	for (const filePath of filePaths) {
-		if (!filePath.startsWith(rootPath + posix.sep) && !filePath.startsWith(rootPath + "/")) continue;
-		const parts = filePath.slice(rootPath.length).replace(/^\//g, "").replace(/^\\/g, "").split(/[/\\]/).filter(Boolean);
+		const normalized = filePath.replaceAll("\\", "/");
+		if (!normalized.startsWith(rootPrefix)) continue;
+		const parts = normalized.slice(rootPrefix.length).split("/");
+		if (parts.length === 0) continue;
 		let current = root;
-		for (let i = 0; i < parts.length; i++) {
-			const isLast = i === parts.length - 1;
-			const part = parts[i];
-			const childPath = `${current.path}/${part}`;
-			let child = current.children.find((c) => c.path === childPath);
+		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: childPath,
+					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 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;
+}
 //#endregion
 //#region src/utils/getBarrelFiles.ts
 const SOURCE_EXTENSIONS = new Set([
@@ -60,199 +77,236 @@ const SOURCE_EXTENSIONS = new Set([
 	".js",
 	".jsx"
 ]);
+const BARREL_SUFFIX = `/${BARREL_FILENAME}`;
 /**
-* Derives a relative module specifier from an absolute `filePath` relative to an absolute `fromDir`.
-* The source extension is preserved so that `@kubb/parser-ts` can apply the `extNames` mapping
-* (e.g. `.ts` → `.js` for ESM output).
+* Derives a relative module specifier from `filePath` relative to `fromDir`.
+* The source extension is preserved so `@kubb/parser-ts` can apply its `extNames` mapping.
 *
 * @example
+* ```ts
 * toRelativeModulePath('/src/gen/types', '/src/gen/types/pet.ts') // './pet.ts'
 * toRelativeModulePath('/src/gen/types', '/src/gen/types/tags/tag.ts') // './tags/tag.ts'
+* ```
 */
 function toRelativeModulePath(fromDir, filePath) {
-	return `./${filePath.slice(fromDir.length).replace(/^[/\\]/g, "")}`;
+	return `./${filePath.slice(fromDir.length + 1)}`;
 }
-/**
-* Generates barrel `FileNode[]` for a given directory tree node using the `'all'` strategy:
-* each leaf file gets a `export * from './relPath'` in the barrel of its nearest ancestor directory.
-*
-* Only a single barrel file (at `treeNode.path`) is generated — sub-directory files are referenced
-* with their full relative path from `treeNode.path`.
-*/
-function getBarrelFilesAll(treeNode, sourceFiles) {
-	const leafPaths = collectLeafPaths(treeNode).filter((p) => !p.endsWith(`/${BARREL_FILENAME}`));
-	if (leafPaths.length === 0) return [];
-	const barrelPath = `${treeNode.path}/${BARREL_FILENAME}`;
-	const exports = [];
-	for (const filePath of leafPaths) {
-		const sourceFile = sourceFiles.find((f) => f.path === filePath);
-		if (sourceFile && sourceFile.sources.length > 0 && sourceFile.sources.every((s) => !s.isIndexable)) continue;
-		exports.push(createExport({ path: toRelativeModulePath(treeNode.path, filePath) }));
-	}
-	if (exports.length === 0) return [];
-	return [createFile({
+function isBarrelPath(path) {
+	return path.endsWith(BARREL_SUFFIX);
+}
+function makeBarrel(dirPath, exports) {
+	return createFile({
 		baseName: BARREL_FILENAME,
-		path: barrelPath,
+		path: `${dirPath}${BARREL_SUFFIX}`,
 		exports,
 		sources: [],
 		imports: []
-	})];
+	});
+}
+function hasOnlyNonIndexableSources(sources) {
+	if (sources.length === 0) return false;
+	for (const source of sources) if (source.isIndexable) return false;
+	return true;
 }
+function partitionIndexableNames(sources) {
+	const byTypeOnly = new Map([[false, /* @__PURE__ */ new Set()], [true, /* @__PURE__ */ new Set()]]);
+	for (const source of sources) {
+		if (!source.isIndexable || !source.name) continue;
+		byTypeOnly.get(Boolean(source.isTypeOnly)).add(source.name);
+	}
+	return byTypeOnly;
+}
+const allStrategy = ({ dirPath, leafPath, sourceFile }) => {
+	if (sourceFile && hasOnlyNonIndexableSources(sourceFile.sources)) return [];
+	return [createExport({ path: toRelativeModulePath(dirPath, leafPath) })];
+};
+const namedStrategy = ({ dirPath, leafPath, sourceFile }) => {
+	const modulePath = toRelativeModulePath(dirPath, leafPath);
+	if (!sourceFile) return [createExport({ path: modulePath })];
+	const namesByTypeOnly = partitionIndexableNames(sourceFile.sources);
+	const valueNames = namesByTypeOnly.get(false);
+	const typeNames = namesByTypeOnly.get(true);
+	if (valueNames.size === 0 && typeNames.size === 0) {
+		if (sourceFile.sources.length > 0) return [];
+		return [createExport({ path: modulePath })];
+	}
+	const exports = [];
+	if (valueNames.size > 0) exports.push(createExport({
+		name: [...valueNames],
+		path: modulePath
+	}));
+	if (typeNames.size > 0) exports.push(createExport({
+		name: [...typeNames],
+		path: modulePath,
+		isTypeOnly: true
+	}));
+	return exports;
+};
+const LEAF_STRATEGIES = new Map([["all", allStrategy], ["named", namedStrategy]]);
 /**
-* Generates barrel `FileNode[]` for a given directory tree node using the `'named'` strategy:
-* each indexable source in each leaf file gets an individual named `export { name } from '...'`.
+* Single-pass post-order traversal that emits a barrel for each visited directory and
+* returns its leaf paths so parents don't have to re-walk the subtree.
 */
-function getBarrelFilesNamed(treeNode, sourceFiles) {
-	const leafPaths = collectLeafPaths(treeNode).filter((p) => !p.endsWith(`/${BARREL_FILENAME}`));
-	if (leafPaths.length === 0) return [];
-	const barrelPath = `${treeNode.path}/${BARREL_FILENAME}`;
-	const exports = [];
-	for (const filePath of leafPaths) {
-		const sourceFile = sourceFiles.find((f) => f.path === filePath);
-		if (!sourceFile) {
-			exports.push(createExport({ path: toRelativeModulePath(treeNode.path, filePath) }));
+function walkAllOrNamed(node, params, isRoot, out) {
+	const subtreeLeaves = [];
+	for (const child of node.children) {
+		if (child.isFile) {
+			if (!isBarrelPath(child.path)) subtreeLeaves.push(child.path);
 			continue;
 		}
-		const indexableSources = sourceFile.sources.filter((s) => s.isIndexable && s.name);
-		if (indexableSources.length === 0) {
-			if (sourceFile.sources.length > 0) continue;
-			exports.push(createExport({ path: toRelativeModulePath(treeNode.path, filePath) }));
+		const childLeaves = walkAllOrNamed(child, params, false, out);
+		for (const leaf of childLeaves) subtreeLeaves.push(leaf);
+	}
+	if (!isRoot && !params.recursive) return subtreeLeaves;
+	const exports = subtreeLeaves.flatMap((leafPath) => params.strategy({
+		dirPath: node.path,
+		leafPath,
+		sourceFile: params.sourceFiles.get(leafPath)
+	}));
+	if (exports.length > 0) out.push(makeBarrel(node.path, exports));
+	return subtreeLeaves;
+}
+/**
+* Emits one barrel per directory: every direct child file is re-exported and every
+* sub-directory is re-exported via its own barrel (recursive by design).
+*/
+function walkPropagate(node, out) {
+	const exports = [];
+	for (const child of node.children) {
+		if (child.isFile) {
+			if (isBarrelPath(child.path)) continue;
+			exports.push(createExport({ path: toRelativeModulePath(node.path, child.path) }));
 			continue;
 		}
-		const valueNames = indexableSources.filter((s) => !s.isTypeOnly).map((s) => s.name);
-		const typeNames = indexableSources.filter((s) => s.isTypeOnly).map((s) => s.name);
-		const modulePath = toRelativeModulePath(treeNode.path, filePath);
-		if (valueNames.length > 0) exports.push(createExport({
-			name: valueNames,
-			path: modulePath
-		}));
-		if (typeNames.length > 0) exports.push(createExport({
-			name: typeNames,
-			path: modulePath,
-			isTypeOnly: true
-		}));
+		walkPropagate(child, out);
+		exports.push(createExport({ path: toRelativeModulePath(node.path, `${child.path}${BARREL_SUFFIX}`) }));
 	}
-	if (exports.length === 0) return [];
-	return [createFile({
-		baseName: BARREL_FILENAME,
-		path: barrelPath,
-		exports,
-		sources: [],
-		imports: []
-	})];
+	if (exports.length > 0) out.push(makeBarrel(node.path, exports));
+}
+function indexRelevantFiles(files, outputPath) {
+	const outputPrefix = `${outputPath.replaceAll("\\", "/")}/`;
+	const sourceFiles = /* @__PURE__ */ new Map();
+	const paths = [];
+	for (const file of files) {
+		const normalized = file.path.replaceAll("\\", "/");
+		if (!normalized.startsWith(outputPrefix)) continue;
+		if (isBarrelPath(normalized)) continue;
+		if (!SOURCE_EXTENSIONS.has(extname(normalized))) continue;
+		sourceFiles.set(file.path, file);
+		paths.push(file.path);
+	}
+	return {
+		sourceFiles,
+		paths
+	};
 }
 /**
-* Generates barrel `FileNode[]` for a given directory tree node using the `'propagate'` strategy:
-* like `'all'` but also generates intermediate barrel files for every sub-directory, so that
-* consumers can import from any depth.
+* Generates barrel `FileNode`s for the directory rooted at `outputPath`.
 *
-* Leaf barrels export directly from their files; parent barrels export from their sub-barrel files.
+* Files outside `outputPath`, existing barrel files, and non-source extensions are filtered out
+* before the tree is built.
 */
-function getBarrelFilesPropagate(treeNode) {
-	return collectPropagatedBarrels(treeNode);
-}
-function collectPropagatedBarrels(node) {
+function getBarrelFiles({ outputPath, files, barrelType, recursive = false }) {
+	const { sourceFiles, paths } = indexRelevantFiles(files, outputPath);
+	if (paths.length === 0) return [];
+	const tree = buildTree(outputPath, paths);
 	const result = [];
-	const barrelExports = [];
-	for (const child of node.children) if (child.isFile) {
-		if (!child.path.endsWith(`/index.ts`)) barrelExports.push(createExport({ path: toRelativeModulePath(node.path, child.path) }));
-	} else {
-		const subBarrels = collectPropagatedBarrels(child);
-		result.push(...subBarrels);
-		const subBarrelPath = `${child.path}/${BARREL_FILENAME}`;
-		barrelExports.push(createExport({ path: toRelativeModulePath(node.path, subBarrelPath) }));
+	if (barrelType === "propagate") {
+		walkPropagate(tree, result);
+		return result;
 	}
-	if (barrelExports.length > 0) result.push(createFile({
-		baseName: BARREL_FILENAME,
-		path: `${node.path}/${BARREL_FILENAME}`,
-		exports: barrelExports,
-		sources: [],
-		imports: []
-	}));
+	const strategy = LEAF_STRATEGIES.get(barrelType);
+	if (!strategy) return result;
+	walkAllOrNamed(tree, {
+		sourceFiles,
+		strategy,
+		recursive
+	}, true, result);
 	return result;
 }
+//#endregion
+//#region src/utils/generatePerPluginBarrel.ts
 /**
-* Collects all leaf (file) paths within a tree node recursively.
+* Generates barrel files for a single plugin's output directory.
+*
+* The barrel is placed at `<config.root>/<config.output.path>/<plugin.options.output.path>/index.ts`.
+* When the plugin uses `group`, additional sub-directory barrels are generated so that grouped
+* output (e.g. `petController/index.ts`) gets its own re-export entry point.
 */
-function collectLeafPaths(node) {
-	if (node.isFile) return [node.path];
-	return node.children.flatMap((c) => collectLeafPaths(c));
+function generatePerPluginBarrel({ barrelType, plugin, files, config }) {
+	return getBarrelFiles({
+		outputPath: resolve(config.root, config.output.path, plugin.options.output.path),
+		files,
+		barrelType,
+		recursive: true
+	});
 }
+//#endregion
+//#region src/utils/generateRootBarrel.ts
 /**
-* Generates barrel `FileNode[]` for a directory rooted at `outputPath`, given the full set of
-* generated source `files`, using the specified `barrelType` strategy.
+* Generates the root barrel file at `<config.root>/<config.output.path>/index.ts`.
 *
-* Files not located inside `outputPath` are excluded automatically.
-*
-* @param outputPath Absolute path to the output directory.
-* @param files All generated files (across all plugins).
-* @param barrelType Barrel generation strategy.
+* Unlike `generatePerPluginBarrel`, this does not recurse into sub-directories — each
+* plugin is responsible for its own per-plugin barrels.
 */
-function getBarrelFiles(outputPath, files, barrelType) {
-	const relevantFiles = files.filter((f) => {
-		const normalizedFilePath = f.path.replace(/\\/g, "/");
-		const normalizedOutputPath = outputPath.replace(/\\/g, "/");
-		if (!normalizedFilePath.startsWith(normalizedOutputPath + "/")) return false;
-		if (normalizedFilePath.endsWith(`/index.ts`)) return false;
-		const dotIndex = normalizedFilePath.lastIndexOf(".");
-		const ext = dotIndex === -1 ? "" : normalizedFilePath.slice(dotIndex);
-		return SOURCE_EXTENSIONS.has(ext);
+function generateRootBarrel({ barrelType, files, config }) {
+	return getBarrelFiles({
+		outputPath: resolve(config.root, config.output.path),
+		files,
+		barrelType
 	});
-	if (relevantFiles.length === 0) return [];
-	const tree = buildTree(outputPath, relevantFiles.map((f) => f.path));
-	switch (barrelType) {
-		case "all": return getBarrelFilesAll(tree, relevantFiles);
-		case "named": return getBarrelFilesNamed(tree, relevantFiles);
-		case "propagate": return getBarrelFilesPropagate(tree);
-		default: return [];
-	}
 }
 //#endregion
-//#region src/utils/generatePerPluginBarrel.ts
+//#region src/utils/excludedPaths.ts
 /**
-* Generates barrel files for a single plugin's output directory.
+* Returns the absolute output directory of `plugin` with a trailing separator,
+* suitable for prefix-based exclusion checks via {@link isExcludedPath}.
 *
-* The barrel file is placed at `resolve(config.root, config.output.path, plugin.options.output.path)/index.ts`
-* and re-exports all files generated by that plugin, using the given `barrelType` strategy.
+* The trailing `/` ensures `startsWith` does not match unrelated siblings
+* (e.g. `/foo/bar` vs `/foo/barbaz/x.ts`).
+*/
+function getPluginOutputPrefix(plugin, config) {
+	return `${resolve(config.root, config.output.path, plugin.options.output.path)}/`;
+}
+/**
+* Returns `true` when `filePath` lies under any of the directory prefixes in `prefixes`.
+* Prefixes must already include a trailing separator (see {@link getPluginOutputPrefix}).
 *
-* Note: `plugin.options.output.path` is relative to `config.output.path`, not to `config.root`.
-* Files generated by plugins land at `config.root + config.output.path + plugin.output.path`,
-* so the barrel directory must be resolved with all three segments.
+* Uses Node 22 iterator helpers (`Iterator.prototype.some`) to avoid materializing the set.
 */
-function generatePerPluginBarrel({ barrelType, plugin, files, config }) {
-	return getBarrelFiles(resolve(config.root, config.output.path, plugin.options.output.path), files, barrelType);
+function isExcludedPath(filePath, prefixes) {
+	return prefixes.values().some((prefix) => filePath.startsWith(prefix));
 }
 //#endregion
-//#region src/utils/generateRootBarrel.ts
+//#region src/utils/resolveBarrelType.ts
+const DEFAULT_BARREL_TYPE = "named";
 /**
-* Generates a root barrel file at `resolve(config.root, config.output.path)/index.ts`.
-*
-* The root barrel re-exports from all files across all plugins that are located
-* inside the root output directory, using the given `barrelType` strategy.
-*
-* In practice this re-exports the per-plugin barrels when `barrelType = 'propagate'`,
-* or all individual files when `barrelType = 'all'` or `'named'`.
+* Resolves the effective barrel style for a single plugin: explicit plugin option →
+* root config option → `'named'` default. Returns `false` when barrel generation is disabled.
 */
-function generateRootBarrel({ barrelType, files, config }) {
-	return getBarrelFiles(resolve(config.root, config.output.path), files, barrelType);
+function resolvePluginBarrelType(plugin, config) {
+	return plugin.options.output?.barrelType ?? config.output.barrelType ?? DEFAULT_BARREL_TYPE;
+}
+/**
+* Resolves the effective barrel style for the root `index.ts`: root config option → `'named'` default.
+* Returns `false` when the root barrel is disabled.
+*/
+function resolveRootBarrelType(config) {
+	return config.output.barrelType ?? DEFAULT_BARREL_TYPE;
 }
 //#endregion
 //#region src/middleware.ts
 /**
-* Barrel-file generation middleware.
-*
-* When added to `config.middleware`, generates an `index.ts` barrel file for each
-* plugin. When `output.barrelType` is omitted on a plugin it inherits from `config.output.barrelType`,
-* and when that is also omitted both default to `'all'`. Set `barrelType: false` to disable
-* barrel generation for a specific plugin or for the root entirely.
+* Generates `index.ts` barrel files for each plugin's output directory and one root barrel
+* at `config.output.path/index.ts`.
 *
-* The `barrelType` option controls the re-export style:
-* - `'all'`       — `export * from '...'` for each generated file
-* - `'named'`     — `export { name1, name2 } from '...'` using each file's indexable sources
-* - `'propagate'` — like `'all'` with intermediate barrel files for sub-directories
+* Plugins inherit `output.barrelType` from `config.output.barrelType` (which itself defaults to `'named'`).
+* Setting `barrelType: false` on a plugin disables its barrel and excludes the plugin's files from the
+* root barrel as well.
 *
 * @example
 * ```ts
+* import { defineConfig } from '@kubb/core'
 * import { middlewareBarrel } from '@kubb/middleware-barrel'
 *
 * export default defineConfig({
@@ -269,15 +323,15 @@ const middlewareBarrel = defineMiddleware({
 	name: "middleware-barrel",
 	install(hooks) {
 		let ctx;
-		const excludedPaths = /* @__PURE__ */ new Set();
+		const excludedPrefixes = /* @__PURE__ */ new Set();
 		hooks.on("kubb:build:start", (buildCtx) => {
 			ctx = buildCtx;
 		});
 		hooks.on("kubb:plugin:end", ({ plugin }) => {
 			if (!ctx) return;
-			const barrelType = plugin.options.output?.barrelType ?? ctx.config.output.barrelType ?? "all";
+			const barrelType = resolvePluginBarrelType(plugin, ctx.config);
 			if (!barrelType) {
-				excludedPaths.add(resolve(ctx.config.root, ctx.config.output.path, plugin.options.output.path));
+				excludedPrefixes.add(getPluginOutputPrefix(plugin, ctx.config));
 				return;
 			}
 			const barrelFiles = generatePerPluginBarrel({
@@ -289,11 +343,11 @@ const middlewareBarrel = defineMiddleware({
 			if (barrelFiles.length > 0) ctx.upsertFile(...barrelFiles);
 		});
 		hooks.on("kubb:plugins:end", ({ files, config, upsertFile }) => {
-			const rootBarrelType = config.output.barrelType ?? "all";
+			const rootBarrelType = resolveRootBarrelType(config);
 			if (!rootBarrelType) return;
 			const rootBarrelFiles = generateRootBarrel({
 				barrelType: rootBarrelType,
-				files: excludedPaths.size > 0 ? files.filter((f) => ![...excludedPaths].some((excluded) => f.path.startsWith(excluded + "/"))) : files,
+				files: excludedPrefixes.size === 0 ? files : files.filter((f) => !isExcludedPath(f.path, excludedPrefixes)),
 				config
 			});
 			if (rootBarrelFiles.length > 0) upsertFile(...rootBarrelFiles);