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

package/src/utils/getBarrelFiles.ts

@@ -1,208 +1,237 @@
+import { extname } from 'node:path'
 import { createExport, createFile } from '@kubb/ast'
-import type { FileNode } from '@kubb/ast'
+import type { ExportNode, FileNode, SourceNode } from '@kubb/ast'
 import { BARREL_FILENAME } from '../constants.ts'
 import type { BarrelType } from '../types.ts'
-import { buildTree, type BuildTree } from './buildTree.ts'
+import { type BuildTree, buildTree } from '@internals/utils'
 
 const SOURCE_EXTENSIONS = new Set(['.ts', '.tsx', '.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: string, filePath: string): string {
-  const relative = filePath.slice(fromDir.length).replace(/^[/\\]/g, '')
-  return `./${relative}`
+  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: BuildTree, 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}`))
+function isBarrelPath(path: string): boolean {
+  return path.endsWith(BARREL_SUFFIX)
+}
 
-  if (leafPaths.length === 0) return []
+function makeBarrel(dirPath: string, exports: Array<ExportNode>): FileNode {
+  return createFile({
+    baseName: BARREL_FILENAME,
+    path: `${dirPath}${BARREL_SUFFIX}`,
+    exports,
+    sources: [],
+    imports: [],
+  })
+}
 
-  const barrelPath = `${treeNode.path}/${BARREL_FILENAME}`
-  const exports: ReturnType<typeof createExport>[] = []
+type LeafContext = {
+  dirPath: string
+  leafPath: string
+  sourceFile: FileNode | undefined
+}
 
-  for (const filePath of leafPaths) {
-    const sourceFile = sourceFiles.find((f) => f.path === filePath)
-    // Skip files whose sources all have isIndexable: false (e.g. internal injected files)
-    if (sourceFile && sourceFile.sources.length > 0 && sourceFile.sources.every((s) => !s.isIndexable)) {
-      continue
-    }
-    exports.push(createExport({ path: toRelativeModulePath(treeNode.path, filePath) }))
+type LeafStrategy = (ctx: LeafContext) => Array<ExportNode>
+
+function hasOnlyNonIndexableSources(sources: ReadonlyArray<SourceNode>): boolean {
+  if (sources.length === 0) return false
+  for (const source of sources) {
+    if (source.isIndexable) return false
   }
+  return true
+}
 
-  if (exports.length === 0) return []
-
-  return [
-    createFile({
-      baseName: BARREL_FILENAME,
-      path: barrelPath,
-      exports,
-      sources: [],
-      imports: [],
-    }),
-  ]
+function partitionIndexableNames(sources: ReadonlyArray<SourceNode>): Map<boolean, Set<string>> {
+  const byTypeOnly = new Map<boolean, Set<string>>([
+    [false, new Set()],
+    [true, new Set()],
+  ])
+  for (const source of sources) {
+    if (!source.isIndexable || !source.name) continue
+    byTypeOnly.get(Boolean(source.isTypeOnly))!.add(source.name)
+  }
+  return byTypeOnly
 }
 
-/**
- * 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: BuildTree, sourceFiles: ReadonlyArray<FileNode>): Array<FileNode> {
-  const leafPaths = collectLeafPaths(treeNode).filter((p) => !p.endsWith(`/${BARREL_FILENAME}`))
+const allStrategy: LeafStrategy = ({ dirPath, leafPath, sourceFile }) => {
+  if (sourceFile && hasOnlyNonIndexableSources(sourceFile.sources)) return []
+  return [createExport({ path: toRelativeModulePath(dirPath, leafPath) })]
+}
 
-  if (leafPaths.length === 0) return []
+const namedStrategy: LeafStrategy = ({ dirPath, leafPath, sourceFile }) => {
+  const modulePath = toRelativeModulePath(dirPath, leafPath)
 
-  const barrelPath = `${treeNode.path}/${BARREL_FILENAME}`
-  const exports: ReturnType<typeof createExport>[] = []
+  if (!sourceFile) return [createExport({ path: modulePath })]
 
-  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 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: Array<ExportNode> = []
+  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 indexableSources = sourceFile.sources.filter((s) => s.isIndexable && s.name)
-    if (indexableSources.length === 0) {
-      // If the file has explicit sources but none are indexable, skip it entirely.
-      // Only fall back to wildcard when there are no sources at all (unknown exports).
-      if (sourceFile.sources.length > 0) continue
-      exports.push(createExport({ path: toRelativeModulePath(treeNode.path, filePath) }))
+const LEAF_STRATEGIES: ReadonlyMap<Exclude<BarrelType, 'propagate'>, LeafStrategy> = new Map([
+  ['all', allStrategy],
+  ['named', namedStrategy],
+])
+
+type LeafWalkParams = {
+  sourceFiles: ReadonlyMap<string, FileNode>
+  strategy: LeafStrategy
+  recursive: boolean
+}
+
+/**
+ * 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 walkAllOrNamed(node: BuildTree, params: LeafWalkParams, isRoot: boolean, out: Array<FileNode>): Array<string> {
+  const subtreeLeaves: Array<string> = []
+
+  for (const child of node.children) {
+    if (child.isFile) {
+      if (!isBarrelPath(child.path)) subtreeLeaves.push(child.path)
       continue
     }
 
-    const valueNames = indexableSources.filter((s) => !s.isTypeOnly).map((s) => s.name as string)
-    const typeNames = indexableSources.filter((s) => s.isTypeOnly).map((s) => s.name as string)
-    const modulePath = toRelativeModulePath(treeNode.path, filePath)
+    const childLeaves = walkAllOrNamed(child, params, false, out)
+    for (const leaf of childLeaves) subtreeLeaves.push(leaf)
+  }
 
-    if (valueNames.length > 0) {
-      exports.push(createExport({ name: valueNames, path: modulePath }))
-    }
-    if (typeNames.length > 0) {
-      exports.push(createExport({ name: typeNames, path: modulePath, isTypeOnly: true }))
-    }
+  // Sub-directory barrels are only emitted when the caller asked for them.
+  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))
   }
 
-  if (exports.length === 0) return []
-
-  return [
-    createFile({
-      baseName: BARREL_FILENAME,
-      path: barrelPath,
-      exports,
-      sources: [],
-      imports: [],
-    }),
-  ]
+  return subtreeLeaves
 }
 
 /**
- * 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.
+ * 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 getBarrelFilesPropagate(treeNode: BuildTree): Array<FileNode> {
-  return collectPropagatedBarrels(treeNode)
-}
-
-function collectPropagatedBarrels(node: BuildTree): Array<FileNode> {
-  const result: Array<FileNode> = []
-  const barrelExports: ReturnType<typeof createExport>[] = []
+function walkPropagate(node: BuildTree, out: Array<FileNode>): void {
+  const exports: Array<ExportNode> = []
 
   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_FILENAME}`
-      barrelExports.push(createExport({ path: toRelativeModulePath(node.path, subBarrelPath) }))
+      if (isBarrelPath(child.path)) continue
+      exports.push(createExport({ path: toRelativeModulePath(node.path, child.path) }))
+      continue
     }
+
+    walkPropagate(child, out)
+    exports.push(createExport({ path: toRelativeModulePath(node.path, `${child.path}${BARREL_SUFFIX}`) }))
   }
 
-  if (barrelExports.length > 0) {
-    result.push(
-      createFile({
-        baseName: BARREL_FILENAME,
-        path: `${node.path}/${BARREL_FILENAME}`,
-        exports: barrelExports,
-        sources: [],
-        imports: [],
-      }),
-    )
+  if (exports.length > 0) {
+    out.push(makeBarrel(node.path, exports))
   }
+}
 
-  return result
+type IndexedFiles = {
+  /**
+   * `path → FileNode` lookup limited to files that participate in barrel generation.
+   */
+  sourceFiles: ReadonlyMap<string, FileNode>
+  /**
+   * Original (un-normalized) paths of `sourceFiles`, in input order — used as input for {@link buildTree}.
+   */
+  paths: ReadonlyArray<string>
 }
 
-/**
- * Collects all leaf (file) paths within a tree node recursively.
- */
-function collectLeafPaths(node: BuildTree): Array<string> {
-  if (node.isFile) return [node.path]
-  return node.children.flatMap((c) => collectLeafPaths(c))
+function indexRelevantFiles(files: ReadonlyArray<FileNode>, outputPath: string): IndexedFiles {
+  const outputPrefix = `${outputPath.replaceAll('\\', '/')}/`
+  const sourceFiles = new Map<string, FileNode>()
+  const paths: Array<string> = []
+
+  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 }
+}
+
+export type GetBarrelFilesParams = {
+  /**
+   * Absolute path to the directory the barrel(s) should be rooted at.
+   * Files outside this directory are ignored.
+   */
+  outputPath: string
+  /**
+   * Full set of generated files across all plugins.
+   * Used both to discover what to re-export and to read each file's indexable sources.
+   */
+  files: ReadonlyArray<FileNode>
+  /**
+   * Re-export style used in the generated barrel(s).
+   */
+  barrelType: BarrelType
+  /**
+   * When `true`, also generate a barrel for each sub-directory of `outputPath`.
+   * Used by per-plugin barrels so that grouped output (e.g. `petController/`) gets its own `index.ts`.
+   *
+   * Has no effect for `barrelType: 'propagate'`, which always recurses by design.
+   *
+   * @default false
+   */
+  recursive?: boolean
 }
 
 /**
- * Generates barrel `FileNode[]` for a directory rooted at `outputPath`, given the full set of
- * generated source `files`, using the specified `barrelType` strategy.
+ * Generates barrel `FileNode`s for the directory rooted at `outputPath`.
  *
- * 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.
+ * Files outside `outputPath`, existing barrel files, and non-source extensions are filtered out
+ * before the tree is built.
  */
-export function getBarrelFiles(outputPath: string, files: ReadonlyArray<FileNode>, barrelType: BarrelType): Array<FileNode> {
-  // Only include files that live inside this outputPath and have a recognised source extension
-  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(`/${BARREL_FILENAME}`)) return false
-    const dotIndex = normalizedFilePath.lastIndexOf('.')
-    const ext = dotIndex === -1 ? '' : normalizedFilePath.slice(dotIndex)
-    return SOURCE_EXTENSIONS.has(ext)
-  })
+export function getBarrelFiles({ outputPath, files, barrelType, 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 (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 []
+  if (barrelType === 'propagate') {
+    walkPropagate(tree, result)
+    return result
   }
+
+  const strategy = LEAF_STRATEGIES.get(barrelType)
+  if (!strategy) return result
+
+  walkAllOrNamed(tree, { sourceFiles, strategy, recursive }, true, result)
+  return result
 }

package/src/utils/resolveBarrelType.ts

@@ -0,0 +1,20 @@
+import type { Config, NormalizedPlugin } from '@kubb/core'
+import type { BarrelType } from '../types.ts'
+
+const DEFAULT_BARREL_TYPE: BarrelType = '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.
+ */
+export function resolvePluginBarrelType(plugin: NormalizedPlugin, config: Config): BarrelType | false {
+  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.
+ */
+export function resolveRootBarrelType(config: Config): BarrelType | false {
+  return config.output.barrelType ?? DEFAULT_BARREL_TYPE
+}

package/src/utils/buildTree.ts

@@ -1,67 +0,0 @@
-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 BuildTree = {
-  /**
-   * Absolute path of the directory (root of this subtree) or file.
-   */
-  path: string
-  /**
-   * Child nodes (sub-directories and files) within this directory.
-   */
-  children: Array<BuildTree>
-  /**
-   * `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>): BuildTree {
-  const root: BuildTree = { 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
-}