@kubb/middleware-barrel 5.0.0-alpha.55

package/LICENSE

@@ -0,0 +1,14 @@
+Copyright (c) 2026 Stijn Van Hulle
+
+This repository contains software under two licenses:
+
+1. Most of the code in this repository is licensed under the
+   MIT License — see licenses/LICENSE-MIT for the full license text.
+
+2. The following components are licensed under the
+   GNU Affero General Public License v3.0 or later (AGPL-3.0-or-later)
+   — see licenses/LICENSE-AGPL-3.0 for the full license text:
+
+   - packages/agent (published as @kubb/agent)
+
+Each package's own LICENSE file or package.json specifies its applicable license.

package/dist/chunk--u3MIqq1.js

@@ -0,0 +1,8 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", {
+	value,
+	configurable: true
+});
+//#endregion
+export { __name as t };

package/dist/index.cjs

@@ -0,0 +1,279 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#endregion
+let _kubb_core = require("@kubb/core");
+let node_path = require("node:path");
+let _kubb_ast = require("@kubb/ast");
+//#region src/constants.ts
+/**
+* Base file name for barrel files (without extension).
+*/
+const BARREL_BASENAME = "index";
+/**
+* Full file name for barrel files (with extension).
+*/
+const BARREL_FILENAME = "index.ts";
+//#endregion
+//#region src/utils/TreeNode.ts
+/**
+* Builds a `TreeNode` directory tree from a list of absolute file paths.
+*
+* All `filePaths` must be inside `rootPath`. Paths that are outside
+* the root or that equal the root are silently ignored.
+*
+* @example
+* ```ts
+* const tree = buildTree('/src/gen/types', [
+*   '/src/gen/types/pet.ts',
+*   '/src/gen/types/user.ts',
+*   '/src/gen/types/pets/listPets.ts',
+* ])
+* ```
+*/
+function buildTree(rootPath, filePaths) {
+	const root = {
+		path: rootPath,
+		children: [],
+		isFile: false
+	};
+	for (const filePath of filePaths) {
+		if (!filePath.startsWith(rootPath + node_path.posix.sep) && !filePath.startsWith(rootPath + "/")) continue;
+		const parts = filePath.slice(rootPath.length).replace(/^\//g, "").replace(/^\\/g, "").split(/[/\\]/).filter(Boolean);
+		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);
+			if (!child) {
+				child = {
+					path: childPath,
+					children: [],
+					isFile: isLast
+				};
+				current.children.push(child);
+			}
+			current = child;
+		}
+	}
+	return root;
+}
+//#endregion
+//#region src/utils/getBarrelFiles.ts
+/**
+* Derives a relative module specifier (no extension) from an absolute `filePath`
+* relative to an absolute `fromDir`.
+*
+* @example
+* toRelativeModulePath('/src/gen/types', '/src/gen/types/pet.ts') // './pet'
+* toRelativeModulePath('/src/gen/types', '/src/gen/types/tags/tag.ts') // './tags/tag'
+*/
+function toRelativeModulePath(fromDir, filePath) {
+	return `./${filePath.slice(fromDir.length).replace(/^[/\\]/g, "").replace(/\.[^/.]+$/, "")}`;
+}
+/**
+* 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 [];
+	return [(0, _kubb_ast.createFile)({
+		baseName: BARREL_FILENAME,
+		path: `${treeNode.path}/${BARREL_FILENAME}`,
+		exports: leafPaths.map((filePath) => (0, _kubb_ast.createExport)({ path: toRelativeModulePath(treeNode.path, filePath) })),
+		sources: [],
+		imports: []
+	})];
+}
+/**
+* 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 '...'`.
+*/
+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((0, _kubb_ast.createExport)({ path: toRelativeModulePath(treeNode.path, filePath) }));
+			continue;
+		}
+		const indexableSources = sourceFile.sources.filter((s) => s.isIndexable && s.name);
+		if (indexableSources.length === 0) {
+			exports.push((0, _kubb_ast.createExport)({ path: toRelativeModulePath(treeNode.path, filePath) }));
+			continue;
+		}
+		const names = indexableSources.map((s) => s.name);
+		exports.push((0, _kubb_ast.createExport)({
+			name: names,
+			path: toRelativeModulePath(treeNode.path, filePath)
+		}));
+	}
+	if (exports.length === 0) return [];
+	return [(0, _kubb_ast.createFile)({
+		baseName: BARREL_FILENAME,
+		path: barrelPath,
+		exports,
+		sources: [],
+		imports: []
+	})];
+}
+/**
+* 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.
+*
+* Leaf barrels export directly from their files; parent barrels export from their sub-barrel files.
+*/
+function getBarrelFilesPropagate(treeNode) {
+	return collectPropagatedBarrels(treeNode);
+}
+function collectPropagatedBarrels(node) {
+	const result = [];
+	const barrelExports = [];
+	for (const child of node.children) if (child.isFile) {
+		if (!child.path.endsWith(`/index.ts`)) barrelExports.push((0, _kubb_ast.createExport)({ path: toRelativeModulePath(node.path, child.path) }));
+	} else {
+		const subBarrels = collectPropagatedBarrels(child);
+		result.push(...subBarrels);
+		const subBarrelPath = `${child.path}/${BARREL_BASENAME}`;
+		barrelExports.push((0, _kubb_ast.createExport)({ path: toRelativeModulePath(node.path, subBarrelPath) }));
+	}
+	if (barrelExports.length > 0) result.push((0, _kubb_ast.createFile)({
+		baseName: BARREL_FILENAME,
+		path: `${node.path}/${BARREL_FILENAME}`,
+		exports: barrelExports,
+		sources: [],
+		imports: []
+	}));
+	return result;
+}
+/**
+* Collects all leaf (file) paths within a tree node recursively.
+*/
+function collectLeafPaths(node) {
+	if (node.isFile) return [node.path];
+	return node.children.flatMap((c) => collectLeafPaths(c));
+}
+/**
+* Generates barrel `FileNode[]` for a directory rooted at `outputPath`, given the full set of
+* generated source `files`, using the specified `barrelType` strategy.
+*
+* 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.
+*/
+function getBarrelFiles(outputPath, files, barrelType) {
+	const relevantFiles = files.filter((f) => {
+		const normalizedFilePath = f.path.replace(/\\/g, "/");
+		const normalizedOutputPath = outputPath.replace(/\\/g, "/");
+		return normalizedFilePath.startsWith(normalizedOutputPath + "/") && !normalizedFilePath.endsWith(`/index.ts`);
+	});
+	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
+/**
+* Generates barrel files for a single plugin's output directory.
+*
+* The barrel file is placed at `resolve(config.root, plugin.options.output.path)/index.ts`
+* and re-exports all files generated by that plugin, using the given `barrelType` strategy.
+*/
+function generatePerPluginBarrel({ barrelType, plugin, files, config }) {
+	return getBarrelFiles((0, node_path.resolve)(config.root, plugin.options.output.path), files, barrelType);
+}
+//#endregion
+//#region src/utils/generateRootBarrel.ts
+/**
+* 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'`.
+*/
+function generateRootBarrel({ barrelType, files, config }) {
+	return getBarrelFiles((0, node_path.resolve)(config.root, config.output.path), files, barrelType);
+}
+//#endregion
+//#region src/middleware.ts
+/**
+* Barrel-file generation middleware.
+*
+* When added to `config.middleware`, generates an `index.ts` barrel file for each
+* plugin that has `output.barrelType` set (or inherits it from `config.output.barrelType`),
+* as well as a root `index.ts` at `config.output.path` when `config.output.barrelType` is set.
+*
+* 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
+*
+* @example
+* ```ts
+* import { middlewareBarrel } from '@kubb/middleware-barrel'
+*
+* export default defineConfig({
+*   output: { path: 'src/gen', barrelType: 'named' },
+*   plugins: [
+*     pluginTs({ output: { path: 'types', barrelType: 'all' } }),
+*     pluginZod({ output: { path: 'schemas' } }),
+*   ],
+*   middleware: [middlewareBarrel],
+* })
+* ```
+*/
+const middlewareBarrel = (0, _kubb_core.defineMiddleware)({
+	name: "middleware-barrel",
+	install(hooks) {
+		let ctx;
+		hooks.on("kubb:build:start", (buildCtx) => {
+			ctx = buildCtx;
+		});
+		hooks.on("kubb:plugin:end", ({ plugin }) => {
+			if (!ctx) return;
+			const normalizedPlugin = plugin;
+			const pluginOutput = normalizedPlugin.options.output;
+			const rootOutput = ctx.config.output;
+			const barrelType = pluginOutput?.barrelType !== void 0 ? pluginOutput.barrelType : rootOutput.barrelType;
+			if (!barrelType) return;
+			const barrelFiles = generatePerPluginBarrel({
+				barrelType,
+				plugin: normalizedPlugin,
+				files: ctx.files,
+				config: ctx.config
+			});
+			if (barrelFiles.length > 0) ctx.upsertFile(...barrelFiles);
+		});
+		hooks.on("kubb:build:end", () => {
+			if (!ctx) return;
+			const rootBarrelType = ctx.config.output.barrelType;
+			if (!rootBarrelType) return;
+			const rootBarrelFiles = generateRootBarrel({
+				barrelType: rootBarrelType,
+				files: ctx.files,
+				config: ctx.config
+			});
+			if (rootBarrelFiles.length > 0) ctx.upsertFile(...rootBarrelFiles);
+		});
+	}
+});
+//#endregion
+exports.middlewareBarrel = middlewareBarrel;
+
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["posix"],"sources":["../src/constants.ts","../src/utils/TreeNode.ts","../src/utils/getBarrelFiles.ts","../src/utils/generatePerPluginBarrel.ts","../src/utils/generateRootBarrel.ts","../src/middleware.ts"],"sourcesContent":["/**\n * Base file name for barrel files (without extension).\n */\nexport const BARREL_BASENAME = 'index' as const\n\n/**\n * Full file name for barrel files (with extension).\n */\nexport const BARREL_FILENAME = 'index.ts' as const\n","import { posix } from 'node:path'\n\n/**\n * A node in a directory tree used to compute barrel file exports.\n *\n * Each `TreeNode` represents either a directory or a file entry.\n * Directory nodes have `children`; file nodes have an empty `children` array.\n */\nexport type TreeNode = {\n  /**\n   * Absolute path of the directory (root of this subtree) or file.\n   */\n  path: string\n  /**\n   * Child nodes (sub-directories and files) within this directory.\n   */\n  children: Array<TreeNode>\n  /**\n   * `true` when this node represents a file (leaf node).\n   */\n  isFile: boolean\n}\n\n/**\n * Builds a `TreeNode` directory tree from a list of absolute file paths.\n *\n * All `filePaths` must be inside `rootPath`. Paths that are outside\n * the root or that equal the root are silently ignored.\n *\n * @example\n * ```ts\n * const tree = buildTree('/src/gen/types', [\n *   '/src/gen/types/pet.ts',\n *   '/src/gen/types/user.ts',\n *   '/src/gen/types/pets/listPets.ts',\n * ])\n * ```\n */\nexport function buildTree(rootPath: string, filePaths: ReadonlyArray<string>): TreeNode {\n  const root: TreeNode = { path: rootPath, children: [], isFile: false }\n\n  for (const filePath of filePaths) {\n    // Only include files inside rootPath\n    if (!filePath.startsWith(rootPath + posix.sep) && !filePath.startsWith(rootPath + '/')) {\n      continue\n    }\n\n    const relative = filePath.slice(rootPath.length).replace(/^\\//g, '').replace(/^\\\\/g, '')\n    const parts = relative.split(/[/\\\\]/).filter(Boolean)\n\n    let current = root\n    for (let i = 0; i < parts.length; i++) {\n      const isLast = i === parts.length - 1\n      const part = parts[i]!\n      const childPath = `${current.path}/${part}`\n\n      let child = current.children.find((c) => c.path === childPath)\n      if (!child) {\n        child = { path: childPath, children: [], isFile: isLast }\n        current.children.push(child)\n      }\n      current = child\n    }\n  }\n\n  return root\n}\n","import { createExport, createFile } from '@kubb/ast'\nimport type { FileNode } from '@kubb/ast'\nimport { BARREL_BASENAME, BARREL_FILENAME } from '../constants.ts'\nimport type { BarrelType } from '../types.ts'\nimport { buildTree, type TreeNode } from './TreeNode.ts'\n\n/**\n * Derives a relative module specifier (no extension) from an absolute `filePath`\n * relative to an absolute `fromDir`.\n *\n * @example\n * toRelativeModulePath('/src/gen/types', '/src/gen/types/pet.ts') // './pet'\n * toRelativeModulePath('/src/gen/types', '/src/gen/types/tags/tag.ts') // './tags/tag'\n */\nfunction toRelativeModulePath(fromDir: string, filePath: string): string {\n  const relative = filePath.slice(fromDir.length).replace(/^[/\\\\]/g, '')\n  // Strip extension\n  const withoutExt = relative.replace(/\\.[^/.]+$/, '')\n  return `./${withoutExt}`\n}\n\n/**\n * Generates barrel `FileNode[]` for a given directory tree node using the `'all'` strategy:\n * each leaf file gets a `export * from './relPath'` in the barrel of its nearest ancestor directory.\n *\n * Only a single barrel file (at `treeNode.path`) is generated — sub-directory files are referenced\n * with their full relative path from `treeNode.path`.\n */\nfunction getBarrelFilesAll(treeNode: TreeNode, _sourceFiles: ReadonlyArray<FileNode>): Array<FileNode> {\n  // Collect all source file paths under this node (excluding barrel files themselves)\n  const leafPaths = collectLeafPaths(treeNode).filter((p) => !p.endsWith(`/${BARREL_FILENAME}`))\n\n  if (leafPaths.length === 0) return []\n\n  const barrelPath = `${treeNode.path}/${BARREL_FILENAME}`\n  const exports = leafPaths.map((filePath) =>\n    createExport({\n      path: toRelativeModulePath(treeNode.path, filePath),\n    }),\n  )\n\n  return [\n    createFile({\n      baseName: BARREL_FILENAME,\n      path: barrelPath,\n      exports,\n      sources: [],\n      imports: [],\n    }),\n  ]\n}\n\n/**\n * Generates barrel `FileNode[]` for a given directory tree node using the `'named'` strategy:\n * each indexable source in each leaf file gets an individual named `export { name } from '...'`.\n */\nfunction getBarrelFilesNamed(treeNode: TreeNode, sourceFiles: ReadonlyArray<FileNode>): Array<FileNode> {\n  const leafPaths = collectLeafPaths(treeNode).filter((p) => !p.endsWith(`/${BARREL_FILENAME}`))\n\n  if (leafPaths.length === 0) return []\n\n  const barrelPath = `${treeNode.path}/${BARREL_FILENAME}`\n  const exports: ReturnType<typeof createExport>[] = []\n\n  for (const filePath of leafPaths) {\n    const sourceFile = sourceFiles.find((f) => f.path === filePath)\n    if (!sourceFile) {\n      // Fall back to wildcard if the source file is not in our set\n      exports.push(createExport({ path: toRelativeModulePath(treeNode.path, filePath) }))\n      continue\n    }\n\n    const indexableSources = sourceFile.sources.filter((s) => s.isIndexable && s.name)\n    if (indexableSources.length === 0) {\n      // No named exports: fall back to wildcard\n      exports.push(createExport({ path: toRelativeModulePath(treeNode.path, filePath) }))\n      continue\n    }\n\n    const names = indexableSources.map((s) => s.name as string)\n    exports.push(\n      createExport({\n        name: names,\n        path: toRelativeModulePath(treeNode.path, filePath),\n      }),\n    )\n  }\n\n  if (exports.length === 0) return []\n\n  return [\n    createFile({\n      baseName: BARREL_FILENAME,\n      path: barrelPath,\n      exports,\n      sources: [],\n      imports: [],\n    }),\n  ]\n}\n\n/**\n * Generates barrel `FileNode[]` for a given directory tree node using the `'propagate'` strategy:\n * like `'all'` but also generates intermediate barrel files for every sub-directory, so that\n * consumers can import from any depth.\n *\n * Leaf barrels export directly from their files; parent barrels export from their sub-barrel files.\n */\nfunction getBarrelFilesPropagate(treeNode: TreeNode): Array<FileNode> {\n  return collectPropagatedBarrels(treeNode)\n}\n\nfunction collectPropagatedBarrels(node: TreeNode): Array<FileNode> {\n  const result: Array<FileNode> = []\n  const barrelExports: ReturnType<typeof createExport>[] = []\n\n  for (const child of node.children) {\n    if (child.isFile) {\n      if (!child.path.endsWith(`/${BARREL_FILENAME}`)) {\n        barrelExports.push(createExport({ path: toRelativeModulePath(node.path, child.path) }))\n      }\n    } else {\n      // Recurse into sub-directory\n      const subBarrels = collectPropagatedBarrels(child)\n      result.push(...subBarrels)\n\n      // Export the sub-directory's barrel (not individual files)\n      const subBarrelPath = `${child.path}/${BARREL_BASENAME}`\n      barrelExports.push(createExport({ path: toRelativeModulePath(node.path, subBarrelPath) }))\n    }\n  }\n\n  if (barrelExports.length > 0) {\n    result.push(\n      createFile({\n        baseName: BARREL_FILENAME,\n        path: `${node.path}/${BARREL_FILENAME}`,\n        exports: barrelExports,\n        sources: [],\n        imports: [],\n      }),\n    )\n  }\n\n  return result\n}\n\n/**\n * Collects all leaf (file) paths within a tree node recursively.\n */\nfunction collectLeafPaths(node: TreeNode): Array<string> {\n  if (node.isFile) return [node.path]\n  return node.children.flatMap((c) => collectLeafPaths(c))\n}\n\n/**\n * Generates barrel `FileNode[]` for a directory rooted at `outputPath`, given the full set of\n * generated source `files`, using the specified `barrelType` strategy.\n *\n * Files not located inside `outputPath` are excluded automatically.\n *\n * @param outputPath Absolute path to the output directory.\n * @param files All generated files (across all plugins).\n * @param barrelType Barrel generation strategy.\n */\nexport function getBarrelFiles(outputPath: string, files: ReadonlyArray<FileNode>, barrelType: BarrelType): Array<FileNode> {\n  // Only include files that live inside this outputPath\n  const relevantFiles = files.filter((f) => {\n    const normalizedFilePath = f.path.replace(/\\\\/g, '/')\n    const normalizedOutputPath = outputPath.replace(/\\\\/g, '/')\n    return normalizedFilePath.startsWith(normalizedOutputPath + '/') && !normalizedFilePath.endsWith(`/${BARREL_FILENAME}`)\n  })\n\n  if (relevantFiles.length === 0) return []\n\n  const tree = buildTree(outputPath, relevantFiles.map((f) => f.path))\n\n  switch (barrelType) {\n    case 'all':\n      return getBarrelFilesAll(tree, relevantFiles)\n    case 'named':\n      return getBarrelFilesNamed(tree, relevantFiles)\n    case 'propagate':\n      return getBarrelFilesPropagate(tree)\n    default:\n      return []\n  }\n}\n","import { resolve } from 'node:path'\nimport type { FileNode } from '@kubb/ast'\nimport type { Config, NormalizedPlugin } from '@kubb/core'\nimport type { BarrelType } from '../types.ts'\nimport { getBarrelFiles } from './getBarrelFiles.ts'\n\nexport type GeneratePerPluginBarrelParams = {\n  barrelType: BarrelType\n  plugin: NormalizedPlugin\n  files: ReadonlyArray<FileNode>\n  config: Config\n}\n\n/**\n * Generates barrel files for a single plugin's output directory.\n *\n * The barrel file is placed at `resolve(config.root, plugin.options.output.path)/index.ts`\n * and re-exports all files generated by that plugin, using the given `barrelType` strategy.\n */\nexport function generatePerPluginBarrel({ barrelType, plugin, files, config }: GeneratePerPluginBarrelParams): Array<FileNode> {\n  const outputPath = resolve(config.root, plugin.options.output.path)\n  return getBarrelFiles(outputPath, files, barrelType)\n}\n","import { resolve } from 'node:path'\nimport type { FileNode } from '@kubb/ast'\nimport type { Config } from '@kubb/core'\nimport type { BarrelType } from '../types.ts'\nimport { getBarrelFiles } from './getBarrelFiles.ts'\n\nexport type GenerateRootBarrelParams = {\n  barrelType: BarrelType\n  files: ReadonlyArray<FileNode>\n  config: Config\n}\n\n/**\n * Generates a root barrel file at `resolve(config.root, config.output.path)/index.ts`.\n *\n * The root barrel re-exports from all files across all plugins that are located\n * inside the root output directory, using the given `barrelType` strategy.\n *\n * In practice this re-exports the per-plugin barrels when `barrelType = 'propagate'`,\n * or all individual files when `barrelType = 'all'` or `'named'`.\n */\nexport function generateRootBarrel({ barrelType, files, config }: GenerateRootBarrelParams): Array<FileNode> {\n  const outputPath = resolve(config.root, config.output.path)\n  return getBarrelFiles(outputPath, files, barrelType)\n}\n","import { defineMiddleware } from '@kubb/core'\nimport type { KubbBuildStartContext, NormalizedPlugin } from '@kubb/core'\nimport './types.ts'\nimport type { BarrelType } from './types.ts'\nimport { generatePerPluginBarrel } from './utils/generatePerPluginBarrel.ts'\nimport { generateRootBarrel } from './utils/generateRootBarrel.ts'\n\n/**\n * Barrel-file generation middleware.\n *\n * When added to `config.middleware`, generates an `index.ts` barrel file for each\n * plugin that has `output.barrelType` set (or inherits it from `config.output.barrelType`),\n * as well as a root `index.ts` at `config.output.path` when `config.output.barrelType` is set.\n *\n * The `barrelType` option controls the re-export style:\n * - `'all'`       — `export * from '...'` for each generated file\n * - `'named'`     — `export { name1, name2 } from '...'` using each file's indexable sources\n * - `'propagate'` — like `'all'` with intermediate barrel files for sub-directories\n *\n * @example\n * ```ts\n * import { middlewareBarrel } from '@kubb/middleware-barrel'\n *\n * export default defineConfig({\n *   output: { path: 'src/gen', barrelType: 'named' },\n *   plugins: [\n *     pluginTs({ output: { path: 'types', barrelType: 'all' } }),\n *     pluginZod({ output: { path: 'schemas' } }),\n *   ],\n *   middleware: [middlewareBarrel],\n * })\n * ```\n */\nexport const middlewareBarrel = defineMiddleware({\n  name: 'middleware-barrel',\n\n  install(hooks) {\n    let ctx: KubbBuildStartContext\n\n    hooks.on('kubb:build:start', (buildCtx) => {\n      ctx = buildCtx\n    })\n\n    hooks.on('kubb:plugin:end', ({ plugin }) => {\n      if (!ctx) return\n\n      // At runtime the plugin in kubb:plugin:end is always a NormalizedPlugin;\n      // KubbPluginEndContext types it as Plugin for public API simplicity.\n      const normalizedPlugin = plugin as NormalizedPlugin\n      const pluginOutput = normalizedPlugin.options.output as { barrelType?: BarrelType | false } | undefined\n      const rootOutput = ctx.config.output as { barrelType?: BarrelType | false }\n      const barrelType = pluginOutput?.barrelType !== undefined ? pluginOutput.barrelType : rootOutput.barrelType\n\n      if (!barrelType) return\n\n      const barrelFiles = generatePerPluginBarrel({\n        barrelType,\n        plugin: normalizedPlugin,\n        files: ctx.files,\n        config: ctx.config,\n      })\n\n      if (barrelFiles.length > 0) {\n        ctx.upsertFile(...barrelFiles)\n      }\n    })\n\n    hooks.on('kubb:build:end', () => {\n      if (!ctx) return\n\n      const rootOutput = ctx.config.output as { barrelType?: BarrelType | false }\n      const rootBarrelType = rootOutput.barrelType\n\n      if (!rootBarrelType) return\n\n      const rootBarrelFiles = generateRootBarrel({\n        barrelType: rootBarrelType,\n        files: ctx.files,\n        config: ctx.config,\n      })\n\n      if (rootBarrelFiles.length > 0) {\n        ctx.upsertFile(...rootBarrelFiles)\n      }\n    })\n  },\n})\n"],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,79 @@
+import { t as __name } from "./chunk--u3MIqq1.js";
+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.
+ */
+type BarrelType = 'all' | 'named' | 'propagate';
+declare global {
+  namespace Kubb {
+    interface PluginOptionsRegistry {
+      output: {
+        /**
+         * Controls which barrel file (index.ts) is generated for this plugin's output directory.
+         *
+         * - `'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.
+         *
+         * When omitted, the root `config.output.barrelType` is used as the default.
+         */
+        barrelType?: BarrelType | false;
+      };
+    }
+    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.
+         *
+         * Individual plugins can override this via their own `output.barrelType`.
+         */
+        barrelType?: BarrelType | false;
+      };
+    }
+  }
+}
+//#endregion
+//#region src/middleware.d.ts
+/**
+ * Barrel-file generation middleware.
+ *
+ * When added to `config.middleware`, generates an `index.ts` barrel file for each
+ * plugin that has `output.barrelType` set (or inherits it from `config.output.barrelType`),
+ * as well as a root `index.ts` at `config.output.path` when `config.output.barrelType` is set.
+ *
+ * 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
+ *
+ * @example
+ * ```ts
+ * import { middlewareBarrel } from '@kubb/middleware-barrel'
+ *
+ * export default defineConfig({
+ *   output: { path: 'src/gen', barrelType: 'named' },
+ *   plugins: [
+ *     pluginTs({ output: { path: 'types', barrelType: 'all' } }),
+ *     pluginZod({ output: { path: 'schemas' } }),
+ *   ],
+ *   middleware: [middlewareBarrel],
+ * })
+ * ```
+ */
+declare const middlewareBarrel: _$_kubb_core0.Middleware;
+//#endregion
+export { middlewareBarrel };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,278 @@
+import "./chunk--u3MIqq1.js";
+import { defineMiddleware } from "@kubb/core";
+import { posix, resolve } from "node:path";
+import { createExport, createFile } from "@kubb/ast";
+//#region src/constants.ts
+/**
+* Base file name for barrel files (without extension).
+*/
+const BARREL_BASENAME = "index";
+/**
+* Full file name for barrel files (with extension).
+*/
+const BARREL_FILENAME = "index.ts";
+//#endregion
+//#region src/utils/TreeNode.ts
+/**
+* Builds a `TreeNode` directory tree from a list of absolute file paths.
+*
+* All `filePaths` must be inside `rootPath`. Paths that are outside
+* the root or that equal the root are silently ignored.
+*
+* @example
+* ```ts
+* const tree = buildTree('/src/gen/types', [
+*   '/src/gen/types/pet.ts',
+*   '/src/gen/types/user.ts',
+*   '/src/gen/types/pets/listPets.ts',
+* ])
+* ```
+*/
+function buildTree(rootPath, filePaths) {
+	const root = {
+		path: rootPath,
+		children: [],
+		isFile: false
+	};
+	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);
+		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);
+			if (!child) {
+				child = {
+					path: childPath,
+					children: [],
+					isFile: isLast
+				};
+				current.children.push(child);
+			}
+			current = child;
+		}
+	}
+	return root;
+}
+//#endregion
+//#region src/utils/getBarrelFiles.ts
+/**
+* Derives a relative module specifier (no extension) from an absolute `filePath`
+* relative to an absolute `fromDir`.
+*
+* @example
+* toRelativeModulePath('/src/gen/types', '/src/gen/types/pet.ts') // './pet'
+* toRelativeModulePath('/src/gen/types', '/src/gen/types/tags/tag.ts') // './tags/tag'
+*/
+function toRelativeModulePath(fromDir, filePath) {
+	return `./${filePath.slice(fromDir.length).replace(/^[/\\]/g, "").replace(/\.[^/.]+$/, "")}`;
+}
+/**
+* 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 [];
+	return [createFile({
+		baseName: BARREL_FILENAME,
+		path: `${treeNode.path}/${BARREL_FILENAME}`,
+		exports: leafPaths.map((filePath) => createExport({ path: toRelativeModulePath(treeNode.path, filePath) })),
+		sources: [],
+		imports: []
+	})];
+}
+/**
+* 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 '...'`.
+*/
+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) }));
+			continue;
+		}
+		const indexableSources = sourceFile.sources.filter((s) => s.isIndexable && s.name);
+		if (indexableSources.length === 0) {
+			exports.push(createExport({ path: toRelativeModulePath(treeNode.path, filePath) }));
+			continue;
+		}
+		const names = indexableSources.map((s) => s.name);
+		exports.push(createExport({
+			name: names,
+			path: toRelativeModulePath(treeNode.path, filePath)
+		}));
+	}
+	if (exports.length === 0) return [];
+	return [createFile({
+		baseName: BARREL_FILENAME,
+		path: barrelPath,
+		exports,
+		sources: [],
+		imports: []
+	})];
+}
+/**
+* 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.
+*
+* Leaf barrels export directly from their files; parent barrels export from their sub-barrel files.
+*/
+function getBarrelFilesPropagate(treeNode) {
+	return collectPropagatedBarrels(treeNode);
+}
+function collectPropagatedBarrels(node) {
+	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_BASENAME}`;
+		barrelExports.push(createExport({ path: toRelativeModulePath(node.path, subBarrelPath) }));
+	}
+	if (barrelExports.length > 0) result.push(createFile({
+		baseName: BARREL_FILENAME,
+		path: `${node.path}/${BARREL_FILENAME}`,
+		exports: barrelExports,
+		sources: [],
+		imports: []
+	}));
+	return result;
+}
+/**
+* Collects all leaf (file) paths within a tree node recursively.
+*/
+function collectLeafPaths(node) {
+	if (node.isFile) return [node.path];
+	return node.children.flatMap((c) => collectLeafPaths(c));
+}
+/**
+* Generates barrel `FileNode[]` for a directory rooted at `outputPath`, given the full set of
+* generated source `files`, using the specified `barrelType` strategy.
+*
+* 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.
+*/
+function getBarrelFiles(outputPath, files, barrelType) {
+	const relevantFiles = files.filter((f) => {
+		const normalizedFilePath = f.path.replace(/\\/g, "/");
+		const normalizedOutputPath = outputPath.replace(/\\/g, "/");
+		return normalizedFilePath.startsWith(normalizedOutputPath + "/") && !normalizedFilePath.endsWith(`/index.ts`);
+	});
+	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
+/**
+* Generates barrel files for a single plugin's output directory.
+*
+* The barrel file is placed at `resolve(config.root, plugin.options.output.path)/index.ts`
+* and re-exports all files generated by that plugin, using the given `barrelType` strategy.
+*/
+function generatePerPluginBarrel({ barrelType, plugin, files, config }) {
+	return getBarrelFiles(resolve(config.root, plugin.options.output.path), files, barrelType);
+}
+//#endregion
+//#region src/utils/generateRootBarrel.ts
+/**
+* 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'`.
+*/
+function generateRootBarrel({ barrelType, files, config }) {
+	return getBarrelFiles(resolve(config.root, config.output.path), files, barrelType);
+}
+//#endregion
+//#region src/middleware.ts
+/**
+* Barrel-file generation middleware.
+*
+* When added to `config.middleware`, generates an `index.ts` barrel file for each
+* plugin that has `output.barrelType` set (or inherits it from `config.output.barrelType`),
+* as well as a root `index.ts` at `config.output.path` when `config.output.barrelType` is set.
+*
+* 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
+*
+* @example
+* ```ts
+* import { middlewareBarrel } from '@kubb/middleware-barrel'
+*
+* export default defineConfig({
+*   output: { path: 'src/gen', barrelType: 'named' },
+*   plugins: [
+*     pluginTs({ output: { path: 'types', barrelType: 'all' } }),
+*     pluginZod({ output: { path: 'schemas' } }),
+*   ],
+*   middleware: [middlewareBarrel],
+* })
+* ```
+*/
+const middlewareBarrel = defineMiddleware({
+	name: "middleware-barrel",
+	install(hooks) {
+		let ctx;
+		hooks.on("kubb:build:start", (buildCtx) => {
+			ctx = buildCtx;
+		});
+		hooks.on("kubb:plugin:end", ({ plugin }) => {
+			if (!ctx) return;
+			const normalizedPlugin = plugin;
+			const pluginOutput = normalizedPlugin.options.output;
+			const rootOutput = ctx.config.output;
+			const barrelType = pluginOutput?.barrelType !== void 0 ? pluginOutput.barrelType : rootOutput.barrelType;
+			if (!barrelType) return;
+			const barrelFiles = generatePerPluginBarrel({
+				barrelType,
+				plugin: normalizedPlugin,
+				files: ctx.files,
+				config: ctx.config
+			});
+			if (barrelFiles.length > 0) ctx.upsertFile(...barrelFiles);
+		});
+		hooks.on("kubb:build:end", () => {
+			if (!ctx) return;
+			const rootBarrelType = ctx.config.output.barrelType;
+			if (!rootBarrelType) return;
+			const rootBarrelFiles = generateRootBarrel({
+				barrelType: rootBarrelType,
+				files: ctx.files,
+				config: ctx.config
+			});
+			if (rootBarrelFiles.length > 0) ctx.upsertFile(...rootBarrelFiles);
+		});
+	}
+});
+//#endregion
+export { middlewareBarrel };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/constants.ts","../src/utils/TreeNode.ts","../src/utils/getBarrelFiles.ts","../src/utils/generatePerPluginBarrel.ts","../src/utils/generateRootBarrel.ts","../src/middleware.ts"],"sourcesContent":["/**\n * Base file name for barrel files (without extension).\n */\nexport const BARREL_BASENAME = 'index' as const\n\n/**\n * Full file name for barrel files (with extension).\n */\nexport const BARREL_FILENAME = 'index.ts' as const\n","import { posix } from 'node:path'\n\n/**\n * A node in a directory tree used to compute barrel file exports.\n *\n * Each `TreeNode` represents either a directory or a file entry.\n * Directory nodes have `children`; file nodes have an empty `children` array.\n */\nexport type TreeNode = {\n  /**\n   * Absolute path of the directory (root of this subtree) or file.\n   */\n  path: string\n  /**\n   * Child nodes (sub-directories and files) within this directory.\n   */\n  children: Array<TreeNode>\n  /**\n   * `true` when this node represents a file (leaf node).\n   */\n  isFile: boolean\n}\n\n/**\n * Builds a `TreeNode` directory tree from a list of absolute file paths.\n *\n * All `filePaths` must be inside `rootPath`. Paths that are outside\n * the root or that equal the root are silently ignored.\n *\n * @example\n * ```ts\n * const tree = buildTree('/src/gen/types', [\n *   '/src/gen/types/pet.ts',\n *   '/src/gen/types/user.ts',\n *   '/src/gen/types/pets/listPets.ts',\n * ])\n * ```\n */\nexport function buildTree(rootPath: string, filePaths: ReadonlyArray<string>): TreeNode {\n  const root: TreeNode = { path: rootPath, children: [], isFile: false }\n\n  for (const filePath of filePaths) {\n    // Only include files inside rootPath\n    if (!filePath.startsWith(rootPath + posix.sep) && !filePath.startsWith(rootPath + '/')) {\n      continue\n    }\n\n    const relative = filePath.slice(rootPath.length).replace(/^\\//g, '').replace(/^\\\\/g, '')\n    const parts = relative.split(/[/\\\\]/).filter(Boolean)\n\n    let current = root\n    for (let i = 0; i < parts.length; i++) {\n      const isLast = i === parts.length - 1\n      const part = parts[i]!\n      const childPath = `${current.path}/${part}`\n\n      let child = current.children.find((c) => c.path === childPath)\n      if (!child) {\n        child = { path: childPath, children: [], isFile: isLast }\n        current.children.push(child)\n      }\n      current = child\n    }\n  }\n\n  return root\n}\n","import { createExport, createFile } from '@kubb/ast'\nimport type { FileNode } from '@kubb/ast'\nimport { BARREL_BASENAME, BARREL_FILENAME } from '../constants.ts'\nimport type { BarrelType } from '../types.ts'\nimport { buildTree, type TreeNode } from './TreeNode.ts'\n\n/**\n * Derives a relative module specifier (no extension) from an absolute `filePath`\n * relative to an absolute `fromDir`.\n *\n * @example\n * toRelativeModulePath('/src/gen/types', '/src/gen/types/pet.ts') // './pet'\n * toRelativeModulePath('/src/gen/types', '/src/gen/types/tags/tag.ts') // './tags/tag'\n */\nfunction toRelativeModulePath(fromDir: string, filePath: string): string {\n  const relative = filePath.slice(fromDir.length).replace(/^[/\\\\]/g, '')\n  // Strip extension\n  const withoutExt = relative.replace(/\\.[^/.]+$/, '')\n  return `./${withoutExt}`\n}\n\n/**\n * Generates barrel `FileNode[]` for a given directory tree node using the `'all'` strategy:\n * each leaf file gets a `export * from './relPath'` in the barrel of its nearest ancestor directory.\n *\n * Only a single barrel file (at `treeNode.path`) is generated — sub-directory files are referenced\n * with their full relative path from `treeNode.path`.\n */\nfunction getBarrelFilesAll(treeNode: TreeNode, _sourceFiles: ReadonlyArray<FileNode>): Array<FileNode> {\n  // Collect all source file paths under this node (excluding barrel files themselves)\n  const leafPaths = collectLeafPaths(treeNode).filter((p) => !p.endsWith(`/${BARREL_FILENAME}`))\n\n  if (leafPaths.length === 0) return []\n\n  const barrelPath = `${treeNode.path}/${BARREL_FILENAME}`\n  const exports = leafPaths.map((filePath) =>\n    createExport({\n      path: toRelativeModulePath(treeNode.path, filePath),\n    }),\n  )\n\n  return [\n    createFile({\n      baseName: BARREL_FILENAME,\n      path: barrelPath,\n      exports,\n      sources: [],\n      imports: [],\n    }),\n  ]\n}\n\n/**\n * Generates barrel `FileNode[]` for a given directory tree node using the `'named'` strategy:\n * each indexable source in each leaf file gets an individual named `export { name } from '...'`.\n */\nfunction getBarrelFilesNamed(treeNode: TreeNode, sourceFiles: ReadonlyArray<FileNode>): Array<FileNode> {\n  const leafPaths = collectLeafPaths(treeNode).filter((p) => !p.endsWith(`/${BARREL_FILENAME}`))\n\n  if (leafPaths.length === 0) return []\n\n  const barrelPath = `${treeNode.path}/${BARREL_FILENAME}`\n  const exports: ReturnType<typeof createExport>[] = []\n\n  for (const filePath of leafPaths) {\n    const sourceFile = sourceFiles.find((f) => f.path === filePath)\n    if (!sourceFile) {\n      // Fall back to wildcard if the source file is not in our set\n      exports.push(createExport({ path: toRelativeModulePath(treeNode.path, filePath) }))\n      continue\n    }\n\n    const indexableSources = sourceFile.sources.filter((s) => s.isIndexable && s.name)\n    if (indexableSources.length === 0) {\n      // No named exports: fall back to wildcard\n      exports.push(createExport({ path: toRelativeModulePath(treeNode.path, filePath) }))\n      continue\n    }\n\n    const names = indexableSources.map((s) => s.name as string)\n    exports.push(\n      createExport({\n        name: names,\n        path: toRelativeModulePath(treeNode.path, filePath),\n      }),\n    )\n  }\n\n  if (exports.length === 0) return []\n\n  return [\n    createFile({\n      baseName: BARREL_FILENAME,\n      path: barrelPath,\n      exports,\n      sources: [],\n      imports: [],\n    }),\n  ]\n}\n\n/**\n * Generates barrel `FileNode[]` for a given directory tree node using the `'propagate'` strategy:\n * like `'all'` but also generates intermediate barrel files for every sub-directory, so that\n * consumers can import from any depth.\n *\n * Leaf barrels export directly from their files; parent barrels export from their sub-barrel files.\n */\nfunction getBarrelFilesPropagate(treeNode: TreeNode): Array<FileNode> {\n  return collectPropagatedBarrels(treeNode)\n}\n\nfunction collectPropagatedBarrels(node: TreeNode): Array<FileNode> {\n  const result: Array<FileNode> = []\n  const barrelExports: ReturnType<typeof createExport>[] = []\n\n  for (const child of node.children) {\n    if (child.isFile) {\n      if (!child.path.endsWith(`/${BARREL_FILENAME}`)) {\n        barrelExports.push(createExport({ path: toRelativeModulePath(node.path, child.path) }))\n      }\n    } else {\n      // Recurse into sub-directory\n      const subBarrels = collectPropagatedBarrels(child)\n      result.push(...subBarrels)\n\n      // Export the sub-directory's barrel (not individual files)\n      const subBarrelPath = `${child.path}/${BARREL_BASENAME}`\n      barrelExports.push(createExport({ path: toRelativeModulePath(node.path, subBarrelPath) }))\n    }\n  }\n\n  if (barrelExports.length > 0) {\n    result.push(\n      createFile({\n        baseName: BARREL_FILENAME,\n        path: `${node.path}/${BARREL_FILENAME}`,\n        exports: barrelExports,\n        sources: [],\n        imports: [],\n      }),\n    )\n  }\n\n  return result\n}\n\n/**\n * Collects all leaf (file) paths within a tree node recursively.\n */\nfunction collectLeafPaths(node: TreeNode): Array<string> {\n  if (node.isFile) return [node.path]\n  return node.children.flatMap((c) => collectLeafPaths(c))\n}\n\n/**\n * Generates barrel `FileNode[]` for a directory rooted at `outputPath`, given the full set of\n * generated source `files`, using the specified `barrelType` strategy.\n *\n * Files not located inside `outputPath` are excluded automatically.\n *\n * @param outputPath Absolute path to the output directory.\n * @param files All generated files (across all plugins).\n * @param barrelType Barrel generation strategy.\n */\nexport function getBarrelFiles(outputPath: string, files: ReadonlyArray<FileNode>, barrelType: BarrelType): Array<FileNode> {\n  // Only include files that live inside this outputPath\n  const relevantFiles = files.filter((f) => {\n    const normalizedFilePath = f.path.replace(/\\\\/g, '/')\n    const normalizedOutputPath = outputPath.replace(/\\\\/g, '/')\n    return normalizedFilePath.startsWith(normalizedOutputPath + '/') && !normalizedFilePath.endsWith(`/${BARREL_FILENAME}`)\n  })\n\n  if (relevantFiles.length === 0) return []\n\n  const tree = buildTree(outputPath, relevantFiles.map((f) => f.path))\n\n  switch (barrelType) {\n    case 'all':\n      return getBarrelFilesAll(tree, relevantFiles)\n    case 'named':\n      return getBarrelFilesNamed(tree, relevantFiles)\n    case 'propagate':\n      return getBarrelFilesPropagate(tree)\n    default:\n      return []\n  }\n}\n","import { resolve } from 'node:path'\nimport type { FileNode } from '@kubb/ast'\nimport type { Config, NormalizedPlugin } from '@kubb/core'\nimport type { BarrelType } from '../types.ts'\nimport { getBarrelFiles } from './getBarrelFiles.ts'\n\nexport type GeneratePerPluginBarrelParams = {\n  barrelType: BarrelType\n  plugin: NormalizedPlugin\n  files: ReadonlyArray<FileNode>\n  config: Config\n}\n\n/**\n * Generates barrel files for a single plugin's output directory.\n *\n * The barrel file is placed at `resolve(config.root, plugin.options.output.path)/index.ts`\n * and re-exports all files generated by that plugin, using the given `barrelType` strategy.\n */\nexport function generatePerPluginBarrel({ barrelType, plugin, files, config }: GeneratePerPluginBarrelParams): Array<FileNode> {\n  const outputPath = resolve(config.root, plugin.options.output.path)\n  return getBarrelFiles(outputPath, files, barrelType)\n}\n","import { resolve } from 'node:path'\nimport type { FileNode } from '@kubb/ast'\nimport type { Config } from '@kubb/core'\nimport type { BarrelType } from '../types.ts'\nimport { getBarrelFiles } from './getBarrelFiles.ts'\n\nexport type GenerateRootBarrelParams = {\n  barrelType: BarrelType\n  files: ReadonlyArray<FileNode>\n  config: Config\n}\n\n/**\n * Generates a root barrel file at `resolve(config.root, config.output.path)/index.ts`.\n *\n * The root barrel re-exports from all files across all plugins that are located\n * inside the root output directory, using the given `barrelType` strategy.\n *\n * In practice this re-exports the per-plugin barrels when `barrelType = 'propagate'`,\n * or all individual files when `barrelType = 'all'` or `'named'`.\n */\nexport function generateRootBarrel({ barrelType, files, config }: GenerateRootBarrelParams): Array<FileNode> {\n  const outputPath = resolve(config.root, config.output.path)\n  return getBarrelFiles(outputPath, files, barrelType)\n}\n","import { defineMiddleware } from '@kubb/core'\nimport type { KubbBuildStartContext, NormalizedPlugin } from '@kubb/core'\nimport './types.ts'\nimport type { BarrelType } from './types.ts'\nimport { generatePerPluginBarrel } from './utils/generatePerPluginBarrel.ts'\nimport { generateRootBarrel } from './utils/generateRootBarrel.ts'\n\n/**\n * Barrel-file generation middleware.\n *\n * When added to `config.middleware`, generates an `index.ts` barrel file for each\n * plugin that has `output.barrelType` set (or inherits it from `config.output.barrelType`),\n * as well as a root `index.ts` at `config.output.path` when `config.output.barrelType` is set.\n *\n * The `barrelType` option controls the re-export style:\n * - `'all'`       — `export * from '...'` for each generated file\n * - `'named'`     — `export { name1, name2 } from '...'` using each file's indexable sources\n * - `'propagate'` — like `'all'` with intermediate barrel files for sub-directories\n *\n * @example\n * ```ts\n * import { middlewareBarrel } from '@kubb/middleware-barrel'\n *\n * export default defineConfig({\n *   output: { path: 'src/gen', barrelType: 'named' },\n *   plugins: [\n *     pluginTs({ output: { path: 'types', barrelType: 'all' } }),\n *     pluginZod({ output: { path: 'schemas' } }),\n *   ],\n *   middleware: [middlewareBarrel],\n * })\n * ```\n */\nexport const middlewareBarrel = defineMiddleware({\n  name: 'middleware-barrel',\n\n  install(hooks) {\n    let ctx: KubbBuildStartContext\n\n    hooks.on('kubb:build:start', (buildCtx) => {\n      ctx = buildCtx\n    })\n\n    hooks.on('kubb:plugin:end', ({ plugin }) => {\n      if (!ctx) return\n\n      // At runtime the plugin in kubb:plugin:end is always a NormalizedPlugin;\n      // KubbPluginEndContext types it as Plugin for public API simplicity.\n      const normalizedPlugin = plugin as NormalizedPlugin\n      const pluginOutput = normalizedPlugin.options.output as { barrelType?: BarrelType | false } | undefined\n      const rootOutput = ctx.config.output as { barrelType?: BarrelType | false }\n      const barrelType = pluginOutput?.barrelType !== undefined ? pluginOutput.barrelType : rootOutput.barrelType\n\n      if (!barrelType) return\n\n      const barrelFiles = generatePerPluginBarrel({\n        barrelType,\n        plugin: normalizedPlugin,\n        files: ctx.files,\n        config: ctx.config,\n      })\n\n      if (barrelFiles.length > 0) {\n        ctx.upsertFile(...barrelFiles)\n      }\n    })\n\n    hooks.on('kubb:build:end', () => {\n      if (!ctx) return\n\n      const rootOutput = ctx.config.output as { barrelType?: BarrelType | false }\n      const rootBarrelType = rootOutput.barrelType\n\n      if (!rootBarrelType) return\n\n      const rootBarrelFiles = generateRootBarrel({\n        barrelType: rootBarrelType,\n        files: ctx.files,\n        config: ctx.config,\n      })\n\n      if (rootBarrelFiles.length > 0) {\n        ctx.upsertFile(...rootBarrelFiles)\n      }\n    })\n  },\n})\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@kubb/middleware-barrel",
+  "version": "5.0.0-alpha.55",
+  "description": "Barrel-file generation middleware for Kubb. Generates index.ts barrel files for each plugin's output directory and a root index.ts after all plugins have run.",
+  "keywords": [
+    "barrel",
+    "code-generator",
+    "codegen",
+    "kubb",
+    "middleware",
+    "openapi",
+    "typescript"
+  ],
+  "license": "MIT",
+  "author": "stijnvanhulle",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kubb-labs/kubb.git",
+    "directory": "packages/middleware-barrel"
+  },
+  "files": [
+    "src",
+    "dist",
+    "*.d.ts",
+    "*.d.cts",
+    "!/**/**.test.**",
+    "!/**/__tests__/**",
+    "!/**/__snapshots__/**"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "peerDependencies": {
+    "@kubb/core": "5.0.0-alpha.55"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "clean": "npx rimraf ./dist",
+    "lint": "oxlint .",
+    "lint:fix": "oxlint --fix .",
+    "release": "pnpm publish --no-git-check",
+    "start": "tsdown --watch",
+    "test": "vitest --passWithNoTests",
+    "typecheck": "tsc -p ./tsconfig.json --noEmit --emitDeclarationOnly false"
+  }
+}

package/src/constants.ts

@@ -0,0 +1,9 @@
+/**
+ * Base file name for barrel files (without extension).
+ */
+export const BARREL_BASENAME = 'index' as const
+
+/**
+ * Full file name for barrel files (with extension).
+ */
+export const BARREL_FILENAME = 'index.ts' as const

package/src/index.ts

@@ -0,0 +1 @@
+export { middlewareBarrel } from './middleware.ts'

package/src/middleware.ts

@@ -0,0 +1,87 @@
+import { defineMiddleware } from '@kubb/core'
+import type { KubbBuildStartContext, NormalizedPlugin } from '@kubb/core'
+import './types.ts'
+import type { BarrelType } from './types.ts'
+import { generatePerPluginBarrel } from './utils/generatePerPluginBarrel.ts'
+import { generateRootBarrel } from './utils/generateRootBarrel.ts'
+
+/**
+ * Barrel-file generation middleware.
+ *
+ * When added to `config.middleware`, generates an `index.ts` barrel file for each
+ * plugin that has `output.barrelType` set (or inherits it from `config.output.barrelType`),
+ * as well as a root `index.ts` at `config.output.path` when `config.output.barrelType` is set.
+ *
+ * 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
+ *
+ * @example
+ * ```ts
+ * import { middlewareBarrel } from '@kubb/middleware-barrel'
+ *
+ * export default defineConfig({
+ *   output: { path: 'src/gen', barrelType: 'named' },
+ *   plugins: [
+ *     pluginTs({ output: { path: 'types', barrelType: 'all' } }),
+ *     pluginZod({ output: { path: 'schemas' } }),
+ *   ],
+ *   middleware: [middlewareBarrel],
+ * })
+ * ```
+ */
+export const middlewareBarrel = defineMiddleware({
+  name: 'middleware-barrel',
+
+  install(hooks) {
+    let ctx: KubbBuildStartContext
+
+    hooks.on('kubb:build:start', (buildCtx) => {
+      ctx = buildCtx
+    })
+
+    hooks.on('kubb:plugin:end', ({ plugin }) => {
+      if (!ctx) return
+
+      // At runtime the plugin in kubb:plugin:end is always a NormalizedPlugin;
+      // KubbPluginEndContext types it as Plugin for public API simplicity.
+      const normalizedPlugin = plugin as NormalizedPlugin
+      const pluginOutput = normalizedPlugin.options.output as { barrelType?: BarrelType | false } | undefined
+      const rootOutput = ctx.config.output as { barrelType?: BarrelType | false }
+      const barrelType = pluginOutput?.barrelType !== undefined ? pluginOutput.barrelType : rootOutput.barrelType
+
+      if (!barrelType) return
+
+      const barrelFiles = generatePerPluginBarrel({
+        barrelType,
+        plugin: normalizedPlugin,
+        files: ctx.files,
+        config: ctx.config,
+      })
+
+      if (barrelFiles.length > 0) {
+        ctx.upsertFile(...barrelFiles)
+      }
+    })
+
+    hooks.on('kubb:build:end', () => {
+      if (!ctx) return
+
+      const rootOutput = ctx.config.output as { barrelType?: BarrelType | false }
+      const rootBarrelType = rootOutput.barrelType
+
+      if (!rootBarrelType) return
+
+      const rootBarrelFiles = generateRootBarrel({
+        barrelType: rootBarrelType,
+        files: ctx.files,
+        config: ctx.config,
+      })
+
+      if (rootBarrelFiles.length > 0) {
+        ctx.upsertFile(...rootBarrelFiles)
+      }
+    })
+  },
+})

package/src/types.ts

@@ -0,0 +1,44 @@
+/**
+ * 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.
+ */
+export type BarrelType = 'all' | 'named' | 'propagate'
+
+declare global {
+  namespace Kubb {
+    interface PluginOptionsRegistry {
+      output: {
+        /**
+         * Controls which barrel file (index.ts) is generated for this plugin's output directory.
+         *
+         * - `'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.
+         *
+         * When omitted, the root `config.output.barrelType` is used as the default.
+         */
+        barrelType?: BarrelType | false
+      }
+    }
+    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.
+         *
+         * Individual plugins can override this via their own `output.barrelType`.
+         */
+        barrelType?: BarrelType | false
+      }
+    }
+  }
+}

package/src/utils/TreeNode.ts

@@ -0,0 +1,67 @@
+import { posix } from 'node:path'
+
+/**
+ * A node in a directory tree used to compute barrel file exports.
+ *
+ * Each `TreeNode` represents either a directory or a file entry.
+ * Directory nodes have `children`; file nodes have an empty `children` array.
+ */
+export type TreeNode = {
+  /**
+   * Absolute path of the directory (root of this subtree) or file.
+   */
+  path: string
+  /**
+   * Child nodes (sub-directories and files) within this directory.
+   */
+  children: Array<TreeNode>
+  /**
+   * `true` when this node represents a file (leaf node).
+   */
+  isFile: boolean
+}
+
+/**
+ * Builds a `TreeNode` directory tree from a list of absolute file paths.
+ *
+ * All `filePaths` must be inside `rootPath`. Paths that are outside
+ * the root or that equal the root are silently ignored.
+ *
+ * @example
+ * ```ts
+ * const tree = buildTree('/src/gen/types', [
+ *   '/src/gen/types/pet.ts',
+ *   '/src/gen/types/user.ts',
+ *   '/src/gen/types/pets/listPets.ts',
+ * ])
+ * ```
+ */
+export function buildTree(rootPath: string, filePaths: ReadonlyArray<string>): TreeNode {
+  const root: TreeNode = { path: rootPath, children: [], isFile: false }
+
+  for (const filePath of filePaths) {
+    // Only include files inside rootPath
+    if (!filePath.startsWith(rootPath + posix.sep) && !filePath.startsWith(rootPath + '/')) {
+      continue
+    }
+
+    const relative = filePath.slice(rootPath.length).replace(/^\//g, '').replace(/^\\/g, '')
+    const parts = relative.split(/[/\\]/).filter(Boolean)
+
+    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)
+      if (!child) {
+        child = { path: childPath, children: [], isFile: isLast }
+        current.children.push(child)
+      }
+      current = child
+    }
+  }
+
+  return root
+}

package/src/utils/generatePerPluginBarrel.ts

@@ -0,0 +1,23 @@
+import { resolve } from 'node:path'
+import type { FileNode } from '@kubb/ast'
+import type { Config, NormalizedPlugin } from '@kubb/core'
+import type { BarrelType } from '../types.ts'
+import { getBarrelFiles } from './getBarrelFiles.ts'
+
+export type GeneratePerPluginBarrelParams = {
+  barrelType: BarrelType
+  plugin: NormalizedPlugin
+  files: ReadonlyArray<FileNode>
+  config: Config
+}
+
+/**
+ * Generates barrel files for a single plugin's output directory.
+ *
+ * The barrel file is placed at `resolve(config.root, plugin.options.output.path)/index.ts`
+ * and re-exports all files generated by that plugin, using the given `barrelType` strategy.
+ */
+export function generatePerPluginBarrel({ barrelType, plugin, files, config }: GeneratePerPluginBarrelParams): Array<FileNode> {
+  const outputPath = resolve(config.root, plugin.options.output.path)
+  return getBarrelFiles(outputPath, files, barrelType)
+}

package/src/utils/generateRootBarrel.ts

@@ -0,0 +1,25 @@
+import { resolve } from 'node:path'
+import type { FileNode } from '@kubb/ast'
+import type { Config } from '@kubb/core'
+import type { BarrelType } from '../types.ts'
+import { getBarrelFiles } from './getBarrelFiles.ts'
+
+export type GenerateRootBarrelParams = {
+  barrelType: BarrelType
+  files: ReadonlyArray<FileNode>
+  config: Config
+}
+
+/**
+ * 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'`.
+ */
+export function generateRootBarrel({ barrelType, files, config }: GenerateRootBarrelParams): Array<FileNode> {
+  const outputPath = resolve(config.root, config.output.path)
+  return getBarrelFiles(outputPath, files, barrelType)
+}

package/src/utils/getBarrelFiles.ts

@@ -0,0 +1,188 @@
+import { createExport, createFile } from '@kubb/ast'
+import type { FileNode } from '@kubb/ast'
+import { BARREL_BASENAME, BARREL_FILENAME } from '../constants.ts'
+import type { BarrelType } from '../types.ts'
+import { buildTree, type TreeNode } from './TreeNode.ts'
+
+/**
+ * Derives a relative module specifier (no extension) from an absolute `filePath`
+ * relative to an absolute `fromDir`.
+ *
+ * @example
+ * toRelativeModulePath('/src/gen/types', '/src/gen/types/pet.ts') // './pet'
+ * toRelativeModulePath('/src/gen/types', '/src/gen/types/tags/tag.ts') // './tags/tag'
+ */
+function toRelativeModulePath(fromDir: string, filePath: string): string {
+  const relative = filePath.slice(fromDir.length).replace(/^[/\\]/g, '')
+  // Strip extension
+  const withoutExt = relative.replace(/\.[^/.]+$/, '')
+  return `./${withoutExt}`
+}
+
+/**
+ * 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: TreeNode, _sourceFiles: ReadonlyArray<FileNode>): Array<FileNode> {
+  // Collect all source file paths under this node (excluding barrel files themselves)
+  const leafPaths = collectLeafPaths(treeNode).filter((p) => !p.endsWith(`/${BARREL_FILENAME}`))
+
+  if (leafPaths.length === 0) return []
+
+  const barrelPath = `${treeNode.path}/${BARREL_FILENAME}`
+  const exports = leafPaths.map((filePath) =>
+    createExport({
+      path: toRelativeModulePath(treeNode.path, filePath),
+    }),
+  )
+
+  return [
+    createFile({
+      baseName: BARREL_FILENAME,
+      path: barrelPath,
+      exports,
+      sources: [],
+      imports: [],
+    }),
+  ]
+}
+
+/**
+ * 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 '...'`.
+ */
+function getBarrelFilesNamed(treeNode: TreeNode, sourceFiles: ReadonlyArray<FileNode>): Array<FileNode> {
+  const leafPaths = collectLeafPaths(treeNode).filter((p) => !p.endsWith(`/${BARREL_FILENAME}`))
+
+  if (leafPaths.length === 0) return []
+
+  const barrelPath = `${treeNode.path}/${BARREL_FILENAME}`
+  const exports: ReturnType<typeof createExport>[] = []
+
+  for (const filePath of leafPaths) {
+    const sourceFile = sourceFiles.find((f) => f.path === filePath)
+    if (!sourceFile) {
+      // Fall back to wildcard if the source file is not in our set
+      exports.push(createExport({ path: toRelativeModulePath(treeNode.path, filePath) }))
+      continue
+    }
+
+    const indexableSources = sourceFile.sources.filter((s) => s.isIndexable && s.name)
+    if (indexableSources.length === 0) {
+      // No named exports: fall back to wildcard
+      exports.push(createExport({ path: toRelativeModulePath(treeNode.path, filePath) }))
+      continue
+    }
+
+    const names = indexableSources.map((s) => s.name as string)
+    exports.push(
+      createExport({
+        name: names,
+        path: toRelativeModulePath(treeNode.path, filePath),
+      }),
+    )
+  }
+
+  if (exports.length === 0) return []
+
+  return [
+    createFile({
+      baseName: BARREL_FILENAME,
+      path: barrelPath,
+      exports,
+      sources: [],
+      imports: [],
+    }),
+  ]
+}
+
+/**
+ * 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.
+ *
+ * Leaf barrels export directly from their files; parent barrels export from their sub-barrel files.
+ */
+function getBarrelFilesPropagate(treeNode: TreeNode): Array<FileNode> {
+  return collectPropagatedBarrels(treeNode)
+}
+
+function collectPropagatedBarrels(node: TreeNode): Array<FileNode> {
+  const result: Array<FileNode> = []
+  const barrelExports: ReturnType<typeof createExport>[] = []
+
+  for (const child of node.children) {
+    if (child.isFile) {
+      if (!child.path.endsWith(`/${BARREL_FILENAME}`)) {
+        barrelExports.push(createExport({ path: toRelativeModulePath(node.path, child.path) }))
+      }
+    } else {
+      // Recurse into sub-directory
+      const subBarrels = collectPropagatedBarrels(child)
+      result.push(...subBarrels)
+
+      // Export the sub-directory's barrel (not individual files)
+      const subBarrelPath = `${child.path}/${BARREL_BASENAME}`
+      barrelExports.push(createExport({ path: toRelativeModulePath(node.path, subBarrelPath) }))
+    }
+  }
+
+  if (barrelExports.length > 0) {
+    result.push(
+      createFile({
+        baseName: BARREL_FILENAME,
+        path: `${node.path}/${BARREL_FILENAME}`,
+        exports: barrelExports,
+        sources: [],
+        imports: [],
+      }),
+    )
+  }
+
+  return result
+}
+
+/**
+ * Collects all leaf (file) paths within a tree node recursively.
+ */
+function collectLeafPaths(node: TreeNode): Array<string> {
+  if (node.isFile) return [node.path]
+  return node.children.flatMap((c) => collectLeafPaths(c))
+}
+
+/**
+ * Generates barrel `FileNode[]` for a directory rooted at `outputPath`, given the full set of
+ * generated source `files`, using the specified `barrelType` strategy.
+ *
+ * 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.
+ */
+export function getBarrelFiles(outputPath: string, files: ReadonlyArray<FileNode>, barrelType: BarrelType): Array<FileNode> {
+  // Only include files that live inside this outputPath
+  const relevantFiles = files.filter((f) => {
+    const normalizedFilePath = f.path.replace(/\\/g, '/')
+    const normalizedOutputPath = outputPath.replace(/\\/g, '/')
+    return normalizedFilePath.startsWith(normalizedOutputPath + '/') && !normalizedFilePath.endsWith(`/${BARREL_FILENAME}`)
+  })
+
+  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 []
+  }
+}