@kubb/core 5.0.0-alpha.2 → 5.0.0-alpha.21

package/src/utils/formatters.ts

@@ -4,18 +4,13 @@ import type { formatters } from '../constants.ts'
 type Formatter = keyof typeof formatters
 
 /**
- * Check if a formatter command is available in the system.
+ * Returns `true` when the given formatter is installed and callable.
  *
- * @param formatter - The formatter to check ('biome', 'prettier', or 'oxfmt')
- * @returns Promise that resolves to true if the formatter is available, false otherwise
- *
- * @remarks
- * This function checks availability by running `<formatter> --version` command.
- * All supported formatters (biome, prettier, oxfmt) implement the --version flag.
+ * Availability is detected by running `<formatter> --version` and checking
+ * that the process exits without error.
  */
 async function isFormatterAvailable(formatter: Formatter): Promise<boolean> {
   try {
-    // Try to get the version of the formatter to check if it's installed
     await x(formatter, ['--version'], { nodeOptions: { stdio: 'ignore' } })
     return true
   } catch {
@@ -24,27 +19,21 @@ async function isFormatterAvailable(formatter: Formatter): Promise<boolean> {
 }
 
 /**
- * Detect which formatter is available in the system.
- *
- * @returns Promise that resolves to the first available formatter or undefined if none are found
+ * Detects the first available code formatter on the current system.
  *
- * @remarks
- * Checks in order of preference: biome, oxfmt, prettier.
- * Uses the `--version` flag to detect if each formatter command is available.
- * This is a reliable method as all supported formatters implement this flag.
+ * - Checks in preference order: `biome`, `oxfmt`, `prettier`.
+ * - Returns `null` when none are found.
  *
  * @example
- * ```typescript
+ * ```ts
  * const formatter = await detectFormatter()
  * if (formatter) {
  *   console.log(`Using ${formatter} for formatting`)
- * } else {
- *   console.log('No formatter found')
  * }
  * ```
  */
-export async function detectFormatter(): Promise<Formatter | undefined> {
-  const formatterNames: Formatter[] = ['biome', 'oxfmt', 'prettier']
+export async function detectFormatter(): Promise<Formatter | null> {
+  const formatterNames = new Set(['biome', 'oxfmt', 'prettier'] as const)
 
   for (const formatter of formatterNames) {
     if (await isFormatterAvailable(formatter)) {
@@ -52,5 +41,5 @@ export async function detectFormatter(): Promise<Formatter | undefined> {
     }
   }
 
-  return undefined
+  return null
 }

package/src/utils/getBarrelFiles.ts

@@ -1,7 +1,9 @@
+/** biome-ignore-all lint/suspicious/useIterableCallbackReturn: not needed */
 import { join } from 'node:path'
+import { getRelativePath } from '@internals/utils'
 import type { KubbFile } from '@kubb/fabric-core/types'
-import { BarrelManager } from '../BarrelManager.ts'
 import type { BarrelType } from '../types.ts'
+import { TreeNode } from './TreeNode.ts'
 
 export type FileMetaBase = {
   pluginName?: string
@@ -27,6 +29,72 @@ type AddIndexesProps = {
   meta?: FileMetaBase
 }
 
+function getBarrelFilesByRoot(root: string | undefined, files: Array<KubbFile.ResolvedFile>): Array<KubbFile.File> {
+  const cachedFiles = new Map<KubbFile.Path, KubbFile.File>()
+
+  TreeNode.build(files, root)?.forEach((treeNode) => {
+    if (!treeNode?.children || !treeNode.parent?.data.path) {
+      return
+    }
+
+    const barrelFilePath = join(treeNode.parent?.data.path, 'index.ts') as KubbFile.Path
+    const barrelFile: KubbFile.File = {
+      path: barrelFilePath,
+      baseName: 'index.ts',
+      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({
+          name: [source.name],
+          path: getRelativePath(treeNode.parent?.data.path, item.data.path),
+          isTypeOnly: source.isTypeOnly,
+        })
+
+        barrelFile.sources.push({
+          name: source.name,
+          isTypeOnly: source.isTypeOnly,
+          //TODO use parser to generate import
+          value: '',
+          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,24 +105,26 @@ 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<KubbFile.ResolvedFile>, { type, meta = {}, root, output }: AddIndexesProps): Promise<Array<KubbFile.File>> {
   if (!type || type === 'propagate') {
     return []
   }
 
-  const barrelManager = new BarrelManager()
-
   const pathToBuildFrom = join(root, output.path)
 
   if (trimExtName(pathToBuildFrom).endsWith('index')) {
     return []
   }
 
-  const barrelFiles = barrelManager.getFiles({
-    files,
-    root: pathToBuildFrom,
-    meta,
-  })
+  const barrelFiles = getBarrelFilesByRoot(pathToBuildFrom, files)
 
   if (type === 'all') {
     return barrelFiles.map((file) => {

package/src/utils/getConfigs.ts

@@ -1,30 +1,16 @@
 import type { CLIOptions, ConfigInput } from '../config.ts'
 import type { Config, UserConfig } from '../types.ts'
-import { getPlugins } from './getPlugins.ts'
 
 /**
- * Converting UserConfig to Config Array without a change in the object beside the JSON convert.
+ * Resolves a {@link ConfigInput} into a normalized array of {@link Config} objects.
+ *
+ * - Awaits the config when it is a `Promise`.
+ * - Calls the factory function with `args` when the config is a function.
+ * - Wraps a single config object in an array for uniform downstream handling.
  */
 export async function getConfigs(config: ConfigInput | UserConfig, args: CLIOptions): Promise<Array<Config>> {
-  const resolvedConfig: Promise<UserConfig | Array<UserConfig>> =
-    typeof config === 'function' ? Promise.resolve(config(args as CLIOptions)) : Promise.resolve(config)
+  const resolved = await (typeof config === 'function' ? config(args as CLIOptions) : config)
+  const userConfigs = Array.isArray(resolved) ? resolved : [resolved]
 
-  let userConfigs = await resolvedConfig
-
-  if (!Array.isArray(userConfigs)) {
-    userConfigs = [userConfigs]
-  }
-
-  const results: Array<Config> = []
-
-  for (const item of userConfigs) {
-    const plugins = item.plugins ? await getPlugins(item.plugins) : undefined
-
-    results.push({
-      ...item,
-      plugins,
-    } as Config)
-  }
-
-  return results
+  return userConfigs.map((item) => ({ ...item }) as Config)
 }

package/src/utils/getPreset.ts

@@ -0,0 +1,52 @@
+import type { Visitor } from '@kubb/ast/types'
+import type { CompatibilityPreset, Generator, Preset, Presets, Resolver } from '../types.ts'
+import { mergeResolvers } from './mergeResolvers.ts'
+
+type GetPresetParams<TResolver extends Resolver> = {
+  preset: CompatibilityPreset
+  presets: Presets<TResolver>
+  resolvers: Array<TResolver>
+  /**
+   * User-supplied generators to append after the preset's generators.
+   */
+  generators: Array<Generator<any>>
+  transformers?: Array<Visitor>
+}
+
+type GetPresetResult<TResolver extends Resolver> = {
+  resolver: TResolver
+  transformers: Array<Visitor>
+  generators: Array<Generator<any>>
+  preset: Preset<TResolver> | undefined
+}
+
+/**
+ * Resolves a named preset into merged resolvers, transformers, and generators.
+ *
+ * - Merges the preset's resolvers on top of the first (default)
+ * - Merges any additional user-supplied resolvers on top of that to produce the final `resolver`.
+ * - Concatenates preset transformers before user-supplied transformers.
+ * - Combines preset generators with user-supplied generators; falls back to the `default` preset's generators when neither provides any.
+ */
+export function getPreset<TResolver extends Resolver = Resolver>(params: GetPresetParams<TResolver>): GetPresetResult<TResolver> {
+  const { preset: presetName, presets, resolvers, transformers: userTransformers, generators: userGenerators } = params
+  const [defaultResolver, ...userResolvers] = resolvers
+  const preset = presets[presetName]
+
+  const baseResolver = mergeResolvers(defaultResolver!, ...(preset?.resolvers ?? []))
+  const resolver = mergeResolvers(baseResolver, ...(userResolvers ?? []))
+  const transformers = [...(preset?.transformers ?? []), ...(userTransformers ?? [])]
+
+  const presetGenerators = preset?.generators ?? []
+  const defaultPresetGenerators = presets['default']?.generators ?? []
+  const generators = (presetGenerators.length > 0 || userGenerators.length
+    ? [...presetGenerators, ...userGenerators]
+    : defaultPresetGenerators) as unknown as Array<Generator<any>>
+
+  return {
+    resolver,
+    transformers,
+    generators,
+    preset,
+  }
+}

package/src/utils/linters.ts

@@ -3,6 +3,12 @@ import type { linters } from '../constants.ts'
 
 type Linter = keyof typeof linters
 
+/**
+ * Returns `true` when the given linter is installed and callable.
+ *
+ * Availability is detected by running `<linter> --version` and checking
+ * that the process exits without error.
+ */
 async function isLinterAvailable(linter: Linter): Promise<boolean> {
   try {
     await x(linter, ['--version'], { nodeOptions: { stdio: 'ignore' } })
@@ -12,8 +18,22 @@ async function isLinterAvailable(linter: Linter): Promise<boolean> {
   }
 }
 
-export async function detectLinter(): Promise<Linter | undefined> {
-  const linterNames: Linter[] = ['biome', 'oxlint', 'eslint']
+/**
+ * Detects the first available linter on the current system.
+ *
+ * - Checks in preference order: `biome`, `oxlint`, `eslint`.
+ * - Returns `null` when none are found.
+ *
+ * @example
+ * ```ts
+ * const linter = await detectLinter()
+ * if (linter) {
+ *   console.log(`Using ${linter} for linting`)
+ * }
+ * ```
+ */
+export async function detectLinter(): Promise<Linter | null> {
+  const linterNames = new Set(['biome', 'oxlint', 'eslint'] as const)
 
   for (const linter of linterNames) {
     if (await isLinterAvailable(linter)) {
@@ -21,5 +41,5 @@ export async function detectLinter(): Promise<Linter | undefined> {
     }
   }
 
-  return undefined
+  return null
 }

package/src/utils/mergeResolvers.ts

@@ -0,0 +1,8 @@
+import type { Resolver } from '../types.ts'
+
+/**
+ * Merges an array of resolvers into a single resolver. Later entries override earlier ones (last wins).
+ */
+export function mergeResolvers<T extends Resolver>(...resolvers: Array<T>): T {
+  return resolvers.reduce<T>((acc, curr) => ({ ...acc, ...curr }), resolvers[0]!)
+}

package/src/utils/packageJSON.ts

@@ -0,0 +1,76 @@
+import { readSync } from '@internals/utils'
+import * as pkg from 'empathic/package'
+import { coerce, satisfies } from 'semver'
+
+type PackageJSON = {
+  dependencies?: Record<string, string>
+  devDependencies?: Record<string, string>
+}
+
+type DependencyName = string
+type DependencyVersion = string
+
+function getPackageJSONSync(cwd?: string): PackageJSON | null {
+  const pkgPath = pkg.up({ 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
+ * ```
+ */
+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 = coerce(packageVersion)
+
+  if (!semVer) {
+    return false
+  }
+
+  return satisfies(semVer, version)
+}

package/src/BarrelManager.ts

@@ -1,74 +0,0 @@
-/** biome-ignore-all lint/suspicious/useIterableCallbackReturn: not needed */
-import { join } from 'node:path'
-import { getRelativePath } from '@internals/utils'
-import type { KubbFile } from '@kubb/fabric-core/types'
-
-import type { FileMetaBase } from './utils/getBarrelFiles.ts'
-import { TreeNode } from './utils/TreeNode.ts'
-
-export class BarrelManager {
-  getFiles({ files: generatedFiles, root }: { files: KubbFile.File[]; root?: string; meta?: FileMetaBase | undefined }): Array<KubbFile.File> {
-    const cachedFiles = new Map<KubbFile.Path, KubbFile.File>()
-
-    TreeNode.build(generatedFiles, root)?.forEach((treeNode) => {
-      if (!treeNode || !treeNode.children || !treeNode.parent?.data.path) {
-        return
-      }
-
-      const barrelFile: KubbFile.File = {
-        path: join(treeNode.parent?.data.path, 'index.ts') as KubbFile.Path,
-        baseName: 'index.ts',
-        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({
-            name: [source.name],
-            path: getRelativePath(treeNode.parent?.data.path, item.data.path),
-            isTypeOnly: source.isTypeOnly,
-          })
-
-          barrelFile.sources.push({
-            name: source.name,
-            isTypeOnly: source.isTypeOnly,
-            //TODO use parser to generate import
-            value: '',
-            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()]
-  }
-}

package/src/PackageManager.ts

@@ -1,180 +0,0 @@
-import mod from 'node:module'
-import os from 'node:os'
-import { pathToFileURL } from 'node:url'
-import { read, readSync } from '@internals/utils'
-import * as pkg from 'empathic/package'
-import { coerce, satisfies } from 'semver'
-import { PATH_SEPARATORS } from './constants.ts'
-
-type PackageJSON = {
-  dependencies?: Record<string, string>
-  devDependencies?: Record<string, string>
-}
-
-type DependencyName = string
-
-type DependencyVersion = string
-
-export class PackageManager {
-  static #cache: Record<DependencyName, DependencyVersion> = {}
-
-  #cwd?: string
-
-  constructor(workspace?: string) {
-    if (workspace) {
-      this.#cwd = workspace
-    }
-  }
-
-  set workspace(workspace: string) {
-    this.#cwd = workspace
-  }
-
-  get workspace(): string | undefined {
-    return this.#cwd
-  }
-
-  normalizeDirectory(directory: string): string {
-    const lastChar = directory[directory.length - 1]
-    if (lastChar && !(PATH_SEPARATORS as readonly string[]).includes(lastChar)) {
-      return `${directory}/`
-    }
-
-    return directory
-  }
-
-  getLocation(path: string): string {
-    let location = path
-
-    if (this.#cwd) {
-      const require = mod.createRequire(this.normalizeDirectory(this.#cwd))
-      location = require.resolve(path)
-    }
-
-    return location
-  }
-
-  async import(path: string): Promise<unknown> {
-    let location = this.getLocation(path)
-
-    if (os.platform() === 'win32') {
-      location = pathToFileURL(location).href
-    }
-
-    const module = await import(location)
-
-    return module?.default ?? module
-  }
-
-  async getPackageJSON(): Promise<PackageJSON | undefined> {
-    const pkgPath = pkg.up({
-      cwd: this.#cwd,
-    })
-    if (!pkgPath) {
-      return undefined
-    }
-
-    const json = await read(pkgPath)
-
-    return JSON.parse(json) as PackageJSON
-  }
-
-  getPackageJSONSync(): PackageJSON | undefined {
-    const pkgPath = pkg.up({
-      cwd: this.#cwd,
-    })
-    if (!pkgPath) {
-      return undefined
-    }
-
-    const json = readSync(pkgPath)
-
-    return JSON.parse(json) as PackageJSON
-  }
-
-  static setVersion(dependency: DependencyName, version: DependencyVersion): void {
-    PackageManager.#cache[dependency] = version
-  }
-
-  #match(packageJSON: PackageJSON, dependency: DependencyName | RegExp): string | undefined {
-    const dependencies = {
-      ...(packageJSON.dependencies || {}),
-      ...(packageJSON.devDependencies || {}),
-    }
-
-    if (typeof dependency === 'string' && dependencies[dependency]) {
-      return dependencies[dependency]
-    }
-
-    const matchedDependency = Object.keys(dependencies).find((dep) => dep.match(dependency))
-
-    return matchedDependency ? dependencies[matchedDependency] : undefined
-  }
-
-  async getVersion(dependency: DependencyName | RegExp): Promise<DependencyVersion | undefined> {
-    if (typeof dependency === 'string' && PackageManager.#cache[dependency]) {
-      return PackageManager.#cache[dependency]
-    }
-
-    const packageJSON = await this.getPackageJSON()
-
-    if (!packageJSON) {
-      return undefined
-    }
-
-    return this.#match(packageJSON, dependency)
-  }
-
-  getVersionSync(dependency: DependencyName | RegExp): DependencyVersion | undefined {
-    if (typeof dependency === 'string' && PackageManager.#cache[dependency]) {
-      return PackageManager.#cache[dependency]
-    }
-
-    const packageJSON = this.getPackageJSONSync()
-
-    if (!packageJSON) {
-      return undefined
-    }
-
-    return this.#match(packageJSON, dependency)
-  }
-
-  async isValid(dependency: DependencyName | RegExp, version: DependencyVersion): Promise<boolean> {
-    const packageVersion = await this.getVersion(dependency)
-
-    if (!packageVersion) {
-      return false
-    }
-
-    if (packageVersion === version) {
-      return true
-    }
-
-    const semVer = coerce(packageVersion)
-
-    if (!semVer) {
-      return false
-    }
-
-    return satisfies(semVer, version)
-  }
-  isValidSync(dependency: DependencyName | RegExp, version: DependencyVersion): boolean {
-    const packageVersion = this.getVersionSync(dependency)
-
-    if (!packageVersion) {
-      return false
-    }
-
-    if (packageVersion === version) {
-      return true
-    }
-
-    const semVer = coerce(packageVersion)
-
-    if (!semVer) {
-      return false
-    }
-
-    return satisfies(semVer, version)
-  }
-}