@kubb/core 4.36.1 → 5.0.0-alpha.10

package/src/utils/getConfigs.ts

@@ -1,30 +1,12 @@
 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.
  */
 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/linters.ts

@@ -13,7 +13,7 @@ async function isLinterAvailable(linter: Linter): Promise<boolean> {
 }
 
 export async function detectLinter(): Promise<Linter | undefined> {
-  const linterNames: Linter[] = ['biome', 'oxlint', 'eslint']
+  const linterNames = new Set(['biome', 'oxlint', 'eslint'] as const)
 
   for (const linter of linterNames) {
     if (await isLinterAvailable(linter)) {

package/src/utils/packageJSON.ts

@@ -0,0 +1,61 @@
+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 | undefined {
+  const pkgPath = pkg.up({ cwd })
+  if (!pkgPath) {
+    return undefined
+  }
+
+  return JSON.parse(readSync(pkgPath)) as PackageJSON
+}
+
+function match(packageJSON: PackageJSON, dependency: DependencyName | RegExp): string | undefined {
+  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] : undefined
+}
+
+function getVersionSync(dependency: DependencyName | RegExp, cwd?: string): DependencyVersion | undefined {
+  const packageJSON = getPackageJSONSync(cwd)
+
+  return packageJSON ? match(packageJSON, dependency) : undefined
+}
+
+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)
-  }
-}

package/src/PromiseManager.ts

@@ -1,40 +0,0 @@
-import type { Strategy, StrategySwitch } from './utils/executeStrategies.ts'
-import { hookFirst, hookParallel, hookSeq } from './utils/executeStrategies.ts'
-
-type PromiseFunc<T = unknown, T2 = never> = () => T2 extends never ? Promise<T> : Promise<T> | T2
-
-type Options<TState = unknown> = {
-  nullCheck?: (state: TState) => boolean
-}
-
-export class PromiseManager<TState = unknown> {
-  #options: Options<TState> = {}
-
-  constructor(options: Options<TState> = {}) {
-    this.#options = options
-  }
-
-  run<TInput extends Array<PromiseFunc<TValue, null>>, TValue, TStrategy extends Strategy, TOutput = StrategySwitch<TStrategy, TInput, TValue>>(
-    strategy: TStrategy,
-    promises: TInput,
-    { concurrency = Number.POSITIVE_INFINITY }: { concurrency?: number } = {},
-  ): TOutput {
-    if (strategy === 'seq') {
-      return hookSeq<TInput, TValue, TOutput>(promises)
-    }
-
-    if (strategy === 'first') {
-      return hookFirst<TInput, TValue, TOutput>(promises, this.#options.nullCheck as ((state: unknown) => boolean) | undefined)
-    }
-
-    if (strategy === 'parallel') {
-      return hookParallel<TInput, TValue, TOutput>(promises, concurrency)
-    }
-
-    throw new Error(`${strategy} not implemented`)
-  }
-}
-
-export function isPromiseRejectedResult<T>(result: PromiseSettledResult<unknown>): result is Omit<PromiseRejectedResult, 'reason'> & { reason: T } {
-  return result.status === 'rejected'
-}

package/src/defineAdapter.ts

@@ -1,22 +0,0 @@
-import type { Adapter, AdapterFactoryOptions } from './types.ts'
-
-type AdapterBuilder<T extends AdapterFactoryOptions> = (options: T['options']) => Adapter<T>
-
-/**
- * Wraps an adapter builder to make the options parameter optional.
- *
- * @example
- * ```ts
- * export const adapterOas = defineAdapter<OasAdapter>((options) => {
- *   const { validate = true, dateType = 'string' } = options
- *   return {
- *     name: adapterOasName,
- *     options: { validate, dateType, ... },
- *     parse(source) { ... },
- *   }
- * })
- * ```
- */
-export function defineAdapter<T extends AdapterFactoryOptions = AdapterFactoryOptions>(build: AdapterBuilder<T>): (options?: T['options']) => Adapter<T> {
-  return (options) => build(options ?? ({} as T['options']))
-}

package/src/definePlugin.ts

@@ -1,12 +0,0 @@
-import type { PluginFactoryOptions, UserPluginWithLifeCycle } from './types.ts'
-
-type PluginBuilder<T extends PluginFactoryOptions = PluginFactoryOptions> = (options: T['options']) => UserPluginWithLifeCycle<T>
-
-/**
- * Wraps a plugin builder to make the options parameter optional.
- */
-export function definePlugin<T extends PluginFactoryOptions = PluginFactoryOptions>(
-  build: PluginBuilder<T>,
-): (options?: T['options']) => UserPluginWithLifeCycle<T> {
-  return (options) => build(options ?? ({} as T['options']))
-}

package/src/defineStorage.ts

@@ -1,56 +0,0 @@
-/**
- * Storage interface for persisting Kubb output.
- *
- * Keys are root-relative forward-slash paths (e.g. `src/gen/api/getPets.ts`).
- * Implement this interface to route generated files to any backend — filesystem,
- * S3, Redis, in-memory, etc.
- *
- * Use `defineStorage` to create a typed storage driver.
- */
-export interface DefineStorage {
-  /** Identifier used for logging and debugging (e.g. `'fs'`, `'s3'`). */
-  readonly name: string
-  /** Returns `true` when an entry for `key` exists in storage. */
-  hasItem(key: string): Promise<boolean>
-  /** Returns the stored string value, or `null` when `key` does not exist. */
-  getItem(key: string): Promise<string | null>
-  /** Persists `value` under `key`, creating any required structure. */
-  setItem(key: string, value: string): Promise<void>
-  /** Removes the entry for `key`. No-ops when the key does not exist. */
-  removeItem(key: string): Promise<void>
-  /** Returns all keys, optionally filtered to those starting with `base`. */
-  getKeys(base?: string): Promise<Array<string>>
-  /** Removes all entries, optionally scoped to those starting with `base`. */
-  clear(base?: string): Promise<void>
-  /** Optional teardown hook called after the build completes. */
-  dispose?(): Promise<void>
-}
-
-/**
- * Wraps a storage builder so the `options` argument is optional, following the
- * same factory pattern as `definePlugin`, `defineLogger`, and `defineAdapter`.
- *
- * The builder receives the resolved options object and must return a
- * `DefineStorage`-compatible object that includes a `name` string.
- *
- * @example
- * ```ts
- * import { defineStorage } from '@kubb/core'
- *
- * export const memoryStorage = defineStorage((_options) => {
- *   const store = new Map<string, string>()
- *   return {
- *     name: 'memory',
- *     async hasItem(key) { return store.has(key) },
- *     async getItem(key) { return store.get(key) ?? null },
- *     async setItem(key, value) { store.set(key, value) },
- *     async removeItem(key) { store.delete(key) },
- *     async getKeys() { return [...store.keys()] },
- *     async clear() { store.clear() },
- *   }
- * })
- * ```
- */
-export function defineStorage<TOptions = Record<string, never>>(build: (options: TOptions) => DefineStorage): (options?: TOptions) => DefineStorage {
-  return (options) => build(options ?? ({} as TOptions))
-}

package/src/errors.ts

@@ -1 +0,0 @@
-export { BuildError, ValidationPluginError } from '@internals/utils'

package/src/hooks/usePluginManager.ts

@@ -1,8 +0,0 @@
-import { useApp } from '@kubb/react-fabric'
-import type { PluginManager } from '../PluginManager.ts'
-
-export function usePluginManager(): PluginManager {
-  const { meta } = useApp<{ pluginManager: PluginManager }>()
-
-  return meta.pluginManager
-}

package/src/utils/getPlugins.ts

@@ -1,23 +0,0 @@
-import type { UnknownUserPlugin, UserConfig } from '../types.ts'
-
-type PluginsArray = Array<Omit<UnknownUserPlugin, 'inject'>>
-
-function isJSONPlugins(plugins: UserConfig['plugins']): boolean {
-  return Array.isArray(plugins) && plugins.some((plugin) => Array.isArray(plugin) && typeof (plugin as unknown[])[0] === 'string')
-}
-
-function isObjectPlugins(plugins: UserConfig['plugins']): boolean {
-  return plugins instanceof Object && !Array.isArray(plugins)
-}
-
-export function getPlugins(plugins: UserConfig['plugins']): Promise<PluginsArray | undefined> {
-  if (isObjectPlugins(plugins)) {
-    throw new Error('Object plugins are not supported anymore, best to use http://kubb.dev/getting-started/configure#json')
-  }
-
-  if (isJSONPlugins(plugins)) {
-    throw new Error('JSON plugins are not supported anymore, best to use http://kubb.dev/getting-started/configure#json')
-  }
-
-  return Promise.resolve(plugins)
-}