@kubb/middleware-barrel 5.0.0-beta.75 → 5.0.0-beta.8

package/src/types.ts

@@ -1,14 +1,54 @@
 /**
- * Barrel re-export style for generated `index.ts` files.
+ * Barrel export strategy.
  *
  * - `'all'` — generates `export * from '...'` for every file
  * - `'named'` — generates `export { name1, name2 } from '...'` using each file's named exports
- * - `'propagate'` — generates intermediate barrel files for every sub-directory so consumers can import from any depth
  */
-export type BarrelType = 'all' | 'named' | 'propagate'
+export type BarrelType = 'all' | 'named'
 
 /**
- * Barrel re-export style for the root barrel at `config.output.path/index.ts`.
- * `'propagate'` is only available at the per-plugin level.
+ * Barrel configuration at the root config level.
+ *
+ * @example
+ * ```ts
+ * barrel: { type: 'named' }  // default
+ * barrel: { type: 'all' }
+ * barrel: false  // disable barrel generation
+ * ```
+ */
+export type BarrelConfig = {
+  /**
+   * Export strategy for the root barrel file.
+   * - `'all'` — wildcard exports: `export * from './file'`
+   * - `'named'` — explicit exports: `export { x, y } from './file'`
+   */
+  type: BarrelType
+}
+
+/**
+ * Barrel configuration at the plugin level.
+ * Supports nested barrel generation in subdirectories.
+ *
+ * @example
+ * ```ts
+ * barrel: { type: 'named' }  // single barrel with named exports
+ * barrel: { type: 'all', nested: true }  // hierarchical barrels with wildcard exports
+ * barrel: { type: 'named', nested: true }  // hierarchical barrels with named exports
+ * barrel: false  // disable barrel generation
+ * ```
  */
-export type RootBarrelType = Exclude<BarrelType, 'propagate'>
+export type PluginBarrelConfig = {
+  /**
+   * Export strategy for the plugin's barrel files.
+   * - `'all'` — wildcard exports: `export * from './file'`
+   * - `'named'` — explicit exports: `export { x, y } from './file'`
+   */
+  type: BarrelType
+  /**
+   * Generate an `index.ts` in every sub-directory, each re-exporting only what's directly inside it.
+   * Creates a hierarchical barrel structure instead of flat exports from the root.
+   *
+   * @default false
+   */
+  nested?: boolean
+}

package/src/{utils/getBarrelFiles.ts → utils.ts}

@@ -1,12 +1,12 @@
-import { extname } from 'node:path'
+import { extname, resolve } from 'node:path'
 import { createExport, createFile } from '@kubb/ast'
 import type { ExportNode, FileNode, SourceNode } from '@kubb/ast'
-import { BARREL_FILENAME } from '../constants.ts'
-import type { BarrelType } from '../types.ts'
+import type { Config, NormalizedPlugin } from '@kubb/core'
 import { type BuildTree, buildTree, toPosixPath } from '@internals/utils'
+import type { BarrelType } from './types.ts'
 
 const SOURCE_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx'])
-const BARREL_SUFFIX = `/${BARREL_FILENAME}`
+const BARREL_SUFFIX = `/index.ts`
 
 function toRelativeModulePath(fromDir: string, filePath: string): string {
   return `./${filePath.slice(fromDir.length + 1)}`
@@ -18,7 +18,7 @@ function isBarrelPath(path: string): boolean {
 
 function makeBarrel(dirPath: string, exports: Array<ExportNode>): FileNode {
   return createFile({
-    baseName: BARREL_FILENAME,
+    baseName: 'index.ts',
     path: `${dirPath}${BARREL_SUFFIX}`,
     exports,
     sources: [],
@@ -87,7 +87,7 @@ const namedStrategy: LeafStrategy = ({ dirPath, leafPath, sourceFile }) => {
   return exports
 }
 
-const LEAF_STRATEGIES: ReadonlyMap<Exclude<BarrelType, 'propagate'>, LeafStrategy> = new Map([
+const LEAF_STRATEGIES: ReadonlyMap<BarrelType, LeafStrategy> = new Map([
   ['all', allStrategy],
   ['named', namedStrategy],
 ])
@@ -127,8 +127,9 @@ function walkAllOrNamed(node: BuildTree, params: LeafWalkParams, isRoot: boolean
 
 /**
  * Recursive walk that emits one barrel per directory, re-exporting files and sub-barrels.
+ * Used when nested: true.
  */
-function walkPropagate(node: BuildTree, out: Array<FileNode>): void {
+function walkNested(node: BuildTree, out: Array<FileNode>): void {
   const exports: Array<ExportNode> = []
 
   for (const child of node.children) {
@@ -138,7 +139,7 @@ function walkPropagate(node: BuildTree, out: Array<FileNode>): void {
       continue
     }
 
-    walkPropagate(child, out)
+    walkNested(child, out)
     exports.push(createExport({ path: toRelativeModulePath(node.path, `${child.path}${BARREL_SUFFIX}`) }))
   }
 
@@ -181,15 +182,21 @@ type GetBarrelFilesParams = {
    */
   files: ReadonlyArray<FileNode>
   /**
-   * Re-export style used when emitting each barrel.
+   * Export strategy used when emitting each barrel.
    * - `'all'` re-exports the whole module (`export * from './x'`)
    * - `'named'` re-exports only the indexable named symbols
-   * - `'propagate'` emits one barrel per directory and chains sub-barrels
    */
   barrelType: BarrelType
   /**
-   * Also generate a barrel for each sub-directory of `outputPath`.
-   * No effect for `barrelType: 'propagate'`, which always recurses.
+   * Generate an `index.ts` in every sub-directory, each re-exporting only what's directly inside it (hierarchical).
+   * When false, uses flat generation strategy with optional recursive subdirectory barrels.
+   *
+   * @default false
+   */
+  nested?: boolean
+  /**
+   * Also generate a barrel for each sub-directory when nested is false.
+   * No effect when nested is true (always generates hierarchical structure).
    *
    * @default false
    */
@@ -199,15 +206,16 @@ type GetBarrelFilesParams = {
 /**
  * Generates barrel `FileNode`s for the directory rooted at `outputPath`.
  */
-export function getBarrelFiles({ outputPath, files, barrelType, recursive = false }: GetBarrelFilesParams): Array<FileNode> {
+export function getBarrelFiles({ outputPath, files, barrelType, nested = false, recursive = false }: GetBarrelFilesParams): Array<FileNode> {
   const { sourceFiles, paths } = indexRelevantFiles(files, outputPath)
   if (paths.length === 0) return []
 
   const tree = buildTree(outputPath, paths)
   const result: Array<FileNode> = []
 
-  if (barrelType === 'propagate') {
-    walkPropagate(tree, result)
+  // Use nested walk for hierarchical barrel structure
+  if (nested) {
+    walkNested(tree, result)
     return result
   }
 
@@ -217,3 +225,22 @@ export function getBarrelFiles({ outputPath, files, barrelType, recursive = fals
   walkAllOrNamed(tree, { sourceFiles, strategy, recursive }, true, result)
   return result
 }
+
+/**
+ * Builds a POSIX-normalized prefix for a plugin's output directory, with a trailing `/`.
+ *
+ * Used to detect (and later exclude) files generated by plugins that opted out of the root barrel.
+ */
+export function getPluginOutputPrefix(plugin: NormalizedPlugin, config: Config): string {
+  return `${toPosixPath(resolve(config.root, config.output.path, plugin.options.output.path))}/`
+}
+
+/**
+ * Returns `true` when `filePath` lives under any of the given excluded directory prefixes.
+ *
+ * Both sides are POSIX-normalized so Windows backslash paths match correctly.
+ */
+export function isExcludedPath(filePath: string, prefixes: ReadonlySet<string>): boolean {
+  const normalized = toPosixPath(filePath)
+  return prefixes.values().some((prefix) => normalized.startsWith(prefix))
+}

package/src/constants.ts

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

package/src/utils/excludedPaths.ts

@@ -1,22 +0,0 @@
-import { resolve } from 'node:path'
-import type { Config, NormalizedPlugin } from '@kubb/core'
-import { toPosixPath } from '@internals/utils'
-
-/**
- * Builds a POSIX-normalized prefix for a plugin's output directory, with a trailing `/`.
- *
- * Used to detect (and later exclude) files generated by plugins that opted out of the root barrel.
- */
-export function getPluginOutputPrefix(plugin: NormalizedPlugin, config: Config): string {
-  return `${toPosixPath(resolve(config.root, config.output.path, plugin.options.output.path))}/`
-}
-
-/**
- * Returns `true` when `filePath` lives under any of the given excluded directory prefixes.
- *
- * Both sides are POSIX-normalized so Windows backslash paths match correctly.
- */
-export function isExcludedPath(filePath: string, prefixes: ReadonlySet<string>): boolean {
-  const normalized = toPosixPath(filePath)
-  return prefixes.values().some((prefix) => normalized.startsWith(prefix))
-}