@kubb/middleware-barrel 5.0.0-alpha.63 → 5.0.0-alpha.65

package/src/utils/getBarrelFiles.ts

@@ -1,10 +1,12 @@
+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 `filePath` relative to `fromDir`.
@@ -17,154 +19,170 @@ const SOURCE_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx'])
  * ```
  */
 function toRelativeModulePath(fromDir: string, filePath: string): string {
-  const relative = filePath.slice(fromDir.length).replace(/^[/\\]/g, '')
-  return `./${relative}`
+  return `./${filePath.slice(fromDir.length + 1)}`
 }
 
-type BarrelFilesParams = {
-  treeNode: BuildTree
-  sourceFiles: ReadonlyArray<FileNode>
-  recursive?: boolean
+function isBarrelPath(path: string): boolean {
+  return path.endsWith(BARREL_SUFFIX)
 }
 
-function getBarrelFilesAll({ treeNode, sourceFiles, recursive = false }: BarrelFilesParams): Array<FileNode> {
-  const leafPaths = collectLeafPaths(treeNode).filter((p) => !p.endsWith(`/${BARREL_FILENAME}`))
+function makeBarrel(dirPath: string, exports: Array<ExportNode>): FileNode {
+  return createFile({
+    baseName: BARREL_FILENAME,
+    path: `${dirPath}${BARREL_SUFFIX}`,
+    exports,
+    sources: [],
+    imports: [],
+  })
+}
 
-  if (leafPaths.length === 0) return []
+type LeafContext = {
+  dirPath: string
+  leafPath: string
+  sourceFile: FileNode | undefined
+}
 
-  const exports: ReturnType<typeof createExport>[] = []
+type LeafStrategy = (ctx: LeafContext) => Array<ExportNode>
 
-  for (const filePath of leafPaths) {
-    const sourceFile = sourceFiles.find((f) => f.path === filePath)
-    if (sourceFile && sourceFile.sources.length > 0 && sourceFile.sources.every((s) => !s.isIndexable)) {
-      continue
-    }
-    exports.push(createExport({ path: toRelativeModulePath(treeNode.path, filePath) }))
+function hasOnlyNonIndexableSources(sources: ReadonlyArray<SourceNode>): boolean {
+  if (sources.length === 0) return false
+  for (const source of sources) {
+    if (source.isIndexable) return false
   }
+  return true
+}
 
-  const result: Array<FileNode> = []
-
-  if (recursive) {
-    for (const child of treeNode.children) {
-      if (!child.isFile) {
-        result.push(...getBarrelFilesAll({ treeNode: child, sourceFiles, recursive: true }))
-      }
-    }
+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
+}
 
-  if (exports.length === 0) return result
+const allStrategy: LeafStrategy = ({ dirPath, leafPath, sourceFile }) => {
+  if (sourceFile && hasOnlyNonIndexableSources(sourceFile.sources)) return []
+  return [createExport({ path: toRelativeModulePath(dirPath, leafPath) })]
+}
 
-  result.push(
-    createFile({
-      baseName: BARREL_FILENAME,
-      path: `${treeNode.path}/${BARREL_FILENAME}`,
-      exports,
-      sources: [],
-      imports: [],
-    }),
-  )
+const namedStrategy: LeafStrategy = ({ dirPath, leafPath, sourceFile }) => {
+  const modulePath = toRelativeModulePath(dirPath, leafPath)
 
-  return result
-}
+  if (!sourceFile) return [createExport({ path: modulePath })]
 
-function getBarrelFilesNamed({ treeNode, sourceFiles, recursive = false }: BarrelFilesParams): Array<FileNode> {
-  const leafPaths = collectLeafPaths(treeNode).filter((p) => !p.endsWith(`/${BARREL_FILENAME}`))
+  const namesByTypeOnly = partitionIndexableNames(sourceFile.sources)
+  const valueNames = namesByTypeOnly.get(false)!
+  const typeNames = namesByTypeOnly.get(true)!
 
-  if (leafPaths.length === 0) return []
+  if (valueNames.size === 0 && typeNames.size === 0) {
+    if (sourceFile.sources.length > 0) return []
+    return [createExport({ path: modulePath })]
+  }
 
-  const exports: ReturnType<typeof createExport>[] = []
+  const exports: Array<ExportNode> = []
+  if (valueNames.size > 0) {
+    exports.push(createExport({ name: [...valueNames].sort(), path: modulePath }))
+  }
+  if (typeNames.size > 0) {
+    exports.push(createExport({ name: [...typeNames].sort(), path: modulePath, isTypeOnly: true }))
+  }
+  return 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 LEAF_STRATEGIES: ReadonlyMap<Exclude<BarrelType, 'propagate'>, LeafStrategy> = new Map([
+  ['all', allStrategy],
+  ['named', namedStrategy],
+])
 
-    const indexableSources = sourceFile.sources.filter((s) => s.isIndexable && s.name)
-    if (indexableSources.length === 0) {
-      if (sourceFile.sources.length > 0) continue
-      exports.push(createExport({ path: toRelativeModulePath(treeNode.path, filePath) }))
-      continue
-    }
+type LeafWalkParams = {
+  sourceFiles: ReadonlyMap<string, FileNode>
+  strategy: LeafStrategy
+  recursive: boolean
+}
 
-    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)
+/**
+ * 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> = []
 
-    if (valueNames.length > 0) {
-      exports.push(createExport({ name: valueNames, path: modulePath }))
-    }
-    if (typeNames.length > 0) {
-      exports.push(createExport({ name: typeNames, path: modulePath, isTypeOnly: true }))
+  for (const child of node.children) {
+    if (child.isFile) {
+      if (!isBarrelPath(child.path)) subtreeLeaves.push(child.path)
+      continue
     }
+
+    const childLeaves = walkAllOrNamed(child, params, false, out)
+    for (const leaf of childLeaves) subtreeLeaves.push(leaf)
   }
 
-  const result: Array<FileNode> = []
+  // Sub-directory barrels are only emitted when the caller asked for them.
+  if (!isRoot && !params.recursive) return subtreeLeaves
 
-  if (recursive) {
-    for (const child of treeNode.children) {
-      if (!child.isFile) {
-        result.push(...getBarrelFilesNamed({ treeNode: child, sourceFiles, recursive: true }))
-      }
-    }
-  }
+  const exports = subtreeLeaves.flatMap((leafPath) => params.strategy({ dirPath: node.path, leafPath, sourceFile: params.sourceFiles.get(leafPath) }))
 
   if (exports.length > 0) {
-    result.push(
-      createFile({
-        baseName: BARREL_FILENAME,
-        path: `${treeNode.path}/${BARREL_FILENAME}`,
-        exports,
-        sources: [],
-        imports: [],
-      }),
-    )
+    out.push(makeBarrel(node.path, exports))
   }
 
-  return result
-}
-
-function getBarrelFilesPropagate({ treeNode }: Pick<BarrelFilesParams, 'treeNode'>): Array<FileNode> {
-  return collectPropagatedBarrels(treeNode)
+  return subtreeLeaves
 }
 
-function collectPropagatedBarrels(node: BuildTree): Array<FileNode> {
-  const result: Array<FileNode> = []
-  const barrelExports: ReturnType<typeof createExport>[] = []
+/**
+ * Emits one barrel per directory: every direct child file is re-exported and every
+ * sub-directory is re-exported via its own barrel (recursive by design).
+ */
+function walkPropagate(node: 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 {
-      const subBarrels = collectPropagatedBarrels(child)
-      result.push(...subBarrels)
-
-      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>
 }
 
-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 = {
@@ -200,31 +218,20 @@ export type GetBarrelFilesParams = {
  * before the tree is built.
  */
 export function getBarrelFiles({ outputPath, files, barrelType, recursive = false }: GetBarrelFilesParams): Array<FileNode> {
-  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)
-  })
+  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({ treeNode: tree, sourceFiles: relevantFiles, recursive })
-    case 'named':
-      return getBarrelFilesNamed({ treeNode: tree, sourceFiles: relevantFiles, recursive })
-    case 'propagate':
-      return getBarrelFilesPropagate({ treeNode: 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,63 +0,0 @@
-import { posix } from 'node:path'
-
-/**
- * A node in the directory tree used to compute barrel file exports.
- * Either represents a directory (with `children`) or a file (`isFile: true`, empty `children`).
- */
-export type BuildTree = {
-  /**
-   * Absolute filesystem path of this directory or file.
-   */
-  path: string
-  /**
-   * Sub-directories and files contained within this directory.
-   * Always empty for file nodes.
-   */
-  children: Array<BuildTree>
-  /**
-   * `true` when this node represents a file (leaf), `false` for directory nodes.
-   */
-  isFile: boolean
-}
-
-/**
- * Builds a directory tree rooted at `rootPath` from a list of absolute file paths.
- * Paths outside `rootPath` are silently ignored.
- *
- * @example
- * ```ts
- * buildTree('/src/gen/types', [
- *   '/src/gen/types/pet.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
-}