@kubb/core 5.0.0-alpha.5 → 5.0.0-alpha.51

package/src/utils/TreeNode.ts

@@ -1,17 +1,26 @@
 import path from 'node:path'
-import type { KubbFile } from '@kubb/fabric-core/types'
-import { getMode } from '../PluginManager.ts'
+import type { FileNode } from '@kubb/ast'
+import { PluginDriver } from '../PluginDriver.ts'
 
 type BarrelData = {
-  file?: KubbFile.File
+  file?: FileNode
   /**
    * @deprecated use file instead
    */
-  type: KubbFile.Mode
+  type: 'single' | 'split'
   path: string
   name: string
 }
 
+/**
+ * Tree structure used to build per-directory barrel (`index.ts`) files from a
+ * flat list of generated {@link FileNode} entries.
+ *
+ * Each node represents either a directory or a file within the output tree.
+ * Use {@link TreeNode.build} to construct a root node from a file list, then
+ * traverse with {@link TreeNode.forEach}, {@link TreeNode.leaves}, or the
+ * `*Deep` helpers.
+ */
 export class TreeNode {
   data: BarrelData
   parent?: TreeNode
@@ -32,6 +41,9 @@ export class TreeNode {
     return child
   }
 
+  /**
+   * Returns the root ancestor of this node, walking up via `parent` links.
+   */
   get root(): TreeNode {
     if (!this.parent) {
       return this
@@ -39,6 +51,11 @@ export class TreeNode {
     return this.parent.root
   }
 
+  /**
+   * Returns all leaf descendants (nodes with no children) of this node.
+   *
+   * Results are cached after the first traversal.
+   */
   get leaves(): Array<TreeNode> {
     if (!this.children || this.children.length === 0) {
       // this is a leaf
@@ -59,6 +76,9 @@ export class TreeNode {
     return leaves
   }
 
+  /**
+   * Visits this node and every descendant in depth-first order.
+   */
   forEach(callback: (treeNode: TreeNode) => void): this {
     if (typeof callback !== 'function') {
       throw new TypeError('forEach() callback must be a function')
@@ -73,6 +93,9 @@ export class TreeNode {
     return this
   }
 
+  /**
+   * Finds the first leaf that satisfies `predicate`, or `undefined` when none match.
+   */
   findDeep(predicate?: (value: TreeNode, index: number, obj: TreeNode[]) => boolean): TreeNode | undefined {
     if (typeof predicate !== 'function') {
       throw new TypeError('find() predicate must be a function')
@@ -81,6 +104,9 @@ export class TreeNode {
     return this.leaves.find(predicate)
   }
 
+  /**
+   * Calls `callback` for every leaf of this node.
+   */
   forEachDeep(callback: (treeNode: TreeNode) => void): void {
     if (typeof callback !== 'function') {
       throw new TypeError('forEach() callback must be a function')
@@ -89,6 +115,9 @@ export class TreeNode {
     this.leaves.forEach(callback)
   }
 
+  /**
+   * Returns all leaves that satisfy `callback`.
+   */
   filterDeep(callback: (treeNode: TreeNode) => boolean): Array<TreeNode> {
     if (typeof callback !== 'function') {
       throw new TypeError('filter() callback must be a function')
@@ -97,6 +126,9 @@ export class TreeNode {
     return this.leaves.filter(callback)
   }
 
+  /**
+   * Maps every leaf through `callback` and returns the resulting array.
+   */
   mapDeep<T>(callback: (treeNode: TreeNode) => T): Array<T> {
     if (typeof callback !== 'function') {
       throw new TypeError('map() callback must be a function')
@@ -105,7 +137,13 @@ export class TreeNode {
     return this.leaves.map(callback)
   }
 
-  public static build(files: KubbFile.File[], root?: string): TreeNode | null {
+  /**
+   * Builds a {@link TreeNode} tree from a flat list of files.
+   *
+   * - Filters to files under `root` (when provided) and skips `.json` files.
+   * - Returns `null` when no files match.
+   */
+  public static build(files: FileNode[], root?: string): TreeNode | null {
     try {
       const filteredTree = buildDirectoryTree(files, root)
 
@@ -117,7 +155,7 @@ export class TreeNode {
         name: filteredTree.name,
         path: filteredTree.path,
         file: filteredTree.file,
-        type: getMode(filteredTree.path),
+        type: PluginDriver.getMode(filteredTree.path),
       })
 
       const recurse = (node: typeof treeNode, item: DirectoryTree) => {
@@ -125,7 +163,7 @@ export class TreeNode {
           name: item.name,
           path: item.path,
           file: item.file,
-          type: getMode(item.path),
+          type: PluginDriver.getMode(item.path),
         })
 
         if (item.children?.length) {
@@ -149,13 +187,13 @@ export class TreeNode {
 type DirectoryTree = {
   name: string
   path: string
-  file?: KubbFile.File
+  file?: FileNode
   children: Array<DirectoryTree>
 }
 
 const normalizePath = (p: string): string => p.replaceAll('\\', '/')
 
-function buildDirectoryTree(files: Array<KubbFile.File>, rootFolder = ''): DirectoryTree | null {
+function buildDirectoryTree(files: Array<FileNode>, rootFolder = ''): DirectoryTree | null {
   const normalizedRootFolder = normalizePath(rootFolder)
   const rootPrefix = normalizedRootFolder.endsWith('/') ? normalizedRootFolder : `${normalizedRootFolder}/`
 

package/src/utils/diagnostics.ts

@@ -2,7 +2,10 @@ import { version as nodeVersion } from 'node:process'
 import { version as KubbVersion } from '../../package.json'
 
 /**
- * Get diagnostic information for debugging
+ * Returns a snapshot of the current runtime environment.
+ *
+ * Useful for attaching context to debug logs and error reports so that
+ * issues can be reproduced without manual information gathering.
  */
 export function getDiagnosticInfo() {
   return {

package/src/utils/getBarrelFiles.ts

@@ -1,8 +1,16 @@
 import { join } from 'node:path'
-import type { KubbFile } from '@kubb/fabric-core/types'
-import { BarrelManager } from '../BarrelManager.ts'
+import { getRelativePath } from '@internals/utils'
+import type { FileNode } from '@kubb/ast'
+import { createExport, createFile, createSource } from '@kubb/ast'
+import { BARREL_BASENAME, BARREL_FILENAME } from '../constants.ts'
 import type { BarrelType } from '../types.ts'
+import { TreeNode } from './TreeNode.ts'
 
+/**
+ * Minimal file metadata attached to every generated file for barrel-file bookkeeping.
+ *
+ * @internal
+ */
 export type FileMetaBase = {
   pluginName?: string
 }
@@ -10,11 +18,11 @@ export type FileMetaBase = {
 type AddIndexesProps = {
   type: BarrelType | false | undefined
   /**
-   * Root based on root and output.path specified in the config
+   * Absolute output root derived from config `root` and `output.path`.
    */
   root: string
   /**
-   * Output for plugin
+   * Output settings for the plugin.
    */
   output: {
     path: string
@@ -27,6 +35,74 @@ type AddIndexesProps = {
   meta?: FileMetaBase
 }
 
+function getBarrelFilesByRoot(root: string | undefined, files: Array<FileNode>): Array<FileNode> {
+  const cachedFiles = new Map<string, FileNode>()
+
+  TreeNode.build(files, root)?.forEach((treeNode) => {
+    if (!treeNode?.children || !treeNode.parent?.data.path) {
+      return
+    }
+
+    const barrelFilePath = join(treeNode.parent?.data.path, BARREL_FILENAME)
+    const barrelFile = createFile({
+      path: barrelFilePath,
+      baseName: BARREL_FILENAME,
+      exports: [],
+      imports: [],
+      sources: [],
+    })
+    const previousBarrelFile = cachedFiles.get(barrelFile.path)
+    const leaves = treeNode.leaves
+
+    leaves.forEach((item) => {
+      if (!item.data.name) {
+        return
+      }
+
+      const sources = item.data.file?.sources || []
+
+      sources.forEach((source) => {
+        if (!item.data.file?.path || !source.isIndexable || !source.name) {
+          return
+        }
+        const alreadyContainInPreviousBarrelFile = previousBarrelFile?.sources.some(
+          (item) => item.name === source.name && item.isTypeOnly === source.isTypeOnly,
+        )
+
+        if (alreadyContainInPreviousBarrelFile) {
+          return
+        }
+
+        barrelFile.exports.push(
+          createExport({
+            name: [source.name],
+            path: getRelativePath(treeNode.parent?.data.path, item.data.path),
+            isTypeOnly: source.isTypeOnly,
+          }),
+        )
+
+        barrelFile.sources.push(
+          createSource({
+            name: source.name,
+            isTypeOnly: source.isTypeOnly,
+            isExportable: false,
+            isIndexable: false,
+          }),
+        )
+      })
+    })
+
+    if (previousBarrelFile) {
+      previousBarrelFile.sources.push(...barrelFile.sources)
+      previousBarrelFile.exports.push(...barrelFile.exports)
+    } else {
+      cachedFiles.set(barrelFile.path, barrelFile)
+    }
+  })
+
+  return [...cachedFiles.values()]
+}
+
 function trimExtName(text: string): string {
   const dotIndex = text.lastIndexOf('.')
   // Only strip when the dot is found and no path separator follows it
@@ -37,36 +113,38 @@ function trimExtName(text: string): string {
   return text
 }
 
-export async function getBarrelFiles(files: Array<KubbFile.ResolvedFile>, { type, meta = {}, root, output }: AddIndexesProps): Promise<KubbFile.File[]> {
+/**
+ * Generates `index.ts` barrel files for all directories under `root/output.path`.
+ *
+ * - Returns an empty array when `type` is falsy or `'propagate'`.
+ * - Skips generation when the output path itself ends with `index` (already a barrel).
+ * - When `type` is `'all'`, strips named exports so every re-export becomes a wildcard (`export * from`).
+ * - Attaches `meta` to each barrel file for downstream plugin identification.
+ */
+export async function getBarrelFiles(files: Array<FileNode>, { type, meta = {}, root, output }: AddIndexesProps): Promise<Array<FileNode>> {
   if (!type || type === 'propagate') {
     return []
   }
 
-  const barrelManager = new BarrelManager()
-
   const pathToBuildFrom = join(root, output.path)
 
-  if (trimExtName(pathToBuildFrom).endsWith('index')) {
+  if (trimExtName(pathToBuildFrom).endsWith(BARREL_BASENAME)) {
     return []
   }
 
-  const barrelFiles = barrelManager.getFiles({
-    files,
-    root: pathToBuildFrom,
-    meta,
-  })
+  const barrelFiles = getBarrelFilesByRoot(pathToBuildFrom, files)
 
   if (type === 'all') {
     return barrelFiles.map((file) => {
       return {
         ...file,
-        exports: file.exports?.map((exportItem) => {
+        exports: file.exports.map((exportItem) => {
           return {
             ...exportItem,
             name: undefined,
           }
         }),
-      }
+      } as FileNode
     })
   }
 
@@ -74,6 +152,6 @@ export async function getBarrelFiles(files: Array<KubbFile.ResolvedFile>, { type
     return {
       ...indexFile,
       meta,
-    }
+    } as FileNode
   })
 }

package/src/utils/isInputPath.ts

@@ -0,0 +1,10 @@
+import type { Config, InputPath, UserConfig } from '../types'
+
+/**
+ * Type guard to check if a given config has an `input.path`.
+ */
+export function isInputPath(config: UserConfig | undefined): config is UserConfig<InputPath>
+export function isInputPath(config: Config | undefined): config is Config<InputPath>
+export function isInputPath(config: Config | UserConfig | undefined): config is Config<InputPath> | UserConfig<InputPath> {
+  return typeof config?.input === 'object' && config.input !== null && 'path' in config.input
+}

package/src/utils/packageJSON.ts

@@ -0,0 +1,99 @@
+import { findPackageJSON, readSync } from '@internals/utils'
+
+type PackageJSON = {
+  dependencies?: Record<string, string>
+  devDependencies?: Record<string, string>
+}
+
+type DependencyName = string
+type DependencyVersion = string
+
+function getPackageJSONSync(cwd?: string): PackageJSON | null {
+  const pkgPath = findPackageJSON(cwd)
+  if (!pkgPath) {
+    return null
+  }
+
+  return JSON.parse(readSync(pkgPath)) as PackageJSON
+}
+
+function match(packageJSON: PackageJSON, dependency: DependencyName | RegExp): string | null {
+  const dependencies = {
+    ...(packageJSON.dependencies || {}),
+    ...(packageJSON.devDependencies || {}),
+  }
+
+  if (typeof dependency === 'string' && dependencies[dependency]) {
+    return dependencies[dependency]
+  }
+
+  const matched = Object.keys(dependencies).find((dep) => dep.match(dependency))
+
+  return matched ? (dependencies[matched] ?? null) : null
+}
+
+function getVersionSync(dependency: DependencyName | RegExp, cwd?: string): DependencyVersion | null {
+  const packageJSON = getPackageJSONSync(cwd)
+
+  return packageJSON ? match(packageJSON, dependency) : null
+}
+
+/**
+ * Returns `true` when the nearest `package.json` declares a dependency that
+ * satisfies the given semver range.
+ *
+ * - Searches both `dependencies` and `devDependencies`.
+ * - Accepts a string package name or a `RegExp` to match scoped/pattern packages.
+ * - Uses `semver.satisfies` for range comparison; returns `false` when the
+ *   version string cannot be coerced into a valid semver.
+ *
+ * @example
+ * ```ts
+ * satisfiesDependency('react', '>=18')          // true when react@18.x is installed
+ * satisfiesDependency(/^@tanstack\//, '>=5')    // true when any @tanstack/* >=5 is found
+ * ```
+ */
+function coerceSemver(version: string): [number, number, number] | null {
+  const m = version.match(/(\d+)(?:\.(\d+))?(?:\.(\d+))?/)
+  return m ? [Number(m[1]), Number(m[2] ?? 0), Number(m[3] ?? 0)] : null
+}
+
+function satisfiesSemver(v: [number, number, number], range: string): boolean {
+  return range
+    .trim()
+    .split(/\s+/)
+    .every((cond) => {
+      const m = cond.match(/^(>=|<=|>|<|=|\^|~)?(\d+)(?:\.(\d+))?(?:\.(\d+))?$/)
+      if (!m) return false
+      const op = m[1] ?? '='
+      const r: [number, number, number] = [Number(m[2]), Number(m[3] ?? 0), Number(m[4] ?? 0)]
+      const cmp = v[0] !== r[0] ? v[0] - r[0] : v[1] !== r[1] ? v[1] - r[1] : v[2] - r[2]
+      if (op === '>=') return cmp >= 0
+      if (op === '<=') return cmp <= 0
+      if (op === '>') return cmp > 0
+      if (op === '<') return cmp < 0
+      if (op === '^') return v[0] === r[0] && cmp >= 0
+      if (op === '~') return v[0] === r[0] && v[1] === r[1] && cmp >= 0
+      return cmp === 0
+    })
+}
+
+export function satisfiesDependency(dependency: DependencyName | RegExp, version: DependencyVersion, cwd?: string): boolean {
+  const packageVersion = getVersionSync(dependency, cwd)
+
+  if (!packageVersion) {
+    return false
+  }
+
+  if (packageVersion === version) {
+    return true
+  }
+
+  const semVer = coerceSemver(packageVersion)
+
+  if (!semVer) {
+    return false
+  }
+
+  return satisfiesSemver(semVer, version)
+}