@kubb/core 5.0.0-alpha.34 → 5.0.0-alpha.36

package/src/utils/TreeNode.ts

@@ -1,5 +1,5 @@
 import path from 'node:path'
-import type { FileNode } from '@kubb/ast/types'
+import type { FileNode } from '@kubb/ast'
 import { getMode } from '../PluginDriver.ts'
 
 type BarrelData = {

package/src/utils/getBarrelFiles.ts

@@ -1,8 +1,8 @@
 /** biome-ignore-all lint/suspicious/useIterableCallbackReturn: not needed */
 import { join } from 'node:path'
 import { getRelativePath } from '@internals/utils'
+import type { FileNode } from '@kubb/ast'
 import { createExport, createFile, createSource } from '@kubb/ast'
-import type { FileNode } from '@kubb/ast/types'
 import type { BarrelType } from '../types.ts'
 import { TreeNode } from './TreeNode.ts'
 
@@ -13,11 +13,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

package/src/utils/getFunctionParams.ts

@@ -2,22 +2,29 @@ import { sortBy } from 'remeda'
 
 export type Param = {
   /**
-   * `object` will return the pathParams as an object.
+   * Controls how path parameters are emitted in the function signature.
+   * - `'object'` groups them as a single destructured parameter.
+   * - `'inline'` spreads them as individual comma-separated parameters.
+   * - `'inlineSpread'` emits a single rest parameter.
    *
-   * `inline` will return the pathParams as comma separated params.
-   * @default `'inline'`
-   * @private
+   * @default 'inline'
+   * @internal
    */
   mode?: 'object' | 'inline' | 'inlineSpread'
   type?: 'string' | 'number' | (string & {})
   optional?: boolean
   /**
-   * @example test = "default"
+   * Default value expression for the parameter.
+   *
+   * @example Assignment syntax
+   * `test = "default"`
    */
   default?: string
   /**
-   * Used for no TypeScript(with mode object)
-   * @example test: "default"
+   * Used for no TypeScript (with mode object).
+   *
+   * @example Value syntax
+   * `test: "default"`
    */
   value?: string
   children?: Params

package/src/utils/isInputPath.ts

@@ -1,8 +1,8 @@
-import type { InputPath, UserConfig } from '../types'
+import type { Config, InputPath } 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> {
   return typeof config?.input === 'object' && config.input !== null && 'path' in config.input
 }

package/src/utils/packageJSON.ts

@@ -1,5 +1,4 @@
-import { readSync } from '@internals/utils'
-import * as pkg from 'empathic/package'
+import { findPackageJSON, readSync } from '@internals/utils'
 import { coerce, satisfies } from 'semver'
 
 type PackageJSON = {
@@ -11,7 +10,7 @@ type DependencyName = string
 type DependencyVersion = string
 
 function getPackageJSONSync(cwd?: string): PackageJSON | null {
-  const pkgPath = pkg.up({ cwd })
+  const pkgPath = findPackageJSON(cwd)
   if (!pkgPath) {
     return null
   }

package/src/defineConfig.ts

@@ -1,51 +0,0 @@
-import type { PossiblePromise } from '@internals/utils'
-import type { UserConfig } from './types.ts'
-
-/**
- * CLI options derived from command-line flags.
- */
-export type CLIOptions = {
-  /**
-   * Path to `kubb.config.js`.
-   */
-  config?: string
-  /**
-   * Enable watch mode for input files.
-   */
-  watch?: boolean
-  /**
-   * Logging verbosity for CLI usage.
-   *
-   * - `silent`: hide non-essential logs
-   * - `info`: show general logs (non-plugin-related)
-   * - `debug`: include detailed plugin lifecycle logs
-   * @default 'silent'
-   */
-  logLevel?: 'silent' | 'info' | 'debug'
-}
-
-/**
- * All accepted forms of a Kubb configuration.
- */
-export type ConfigInput = PossiblePromise<UserConfig | UserConfig[]> | ((cli: CLIOptions) => PossiblePromise<UserConfig | UserConfig[]>)
-
-/**
- * Helper for defining a Kubb configuration.
- *
- * Accepts either:
- * - A config object or array of configs
- * - A function returning the config(s), optionally async,
- *   receiving the CLI options as argument
- *
- * @example
- * export default defineConfig(({ logLevel }) => ({
- *   root: 'src',
- *   plugins: [myPlugin()],
- * }))
- * @deprecated as of Kubb v5, @kubb/core will not expose `defineConfig` anymore. use the `kubb` package instead
- */
-export function defineConfig(config: (cli: CLIOptions) => PossiblePromise<UserConfig | UserConfig[]>): typeof config
-export function defineConfig(config: PossiblePromise<UserConfig | UserConfig[]>): typeof config
-export function defineConfig(config: ConfigInput): ConfigInput {
-  return config
-}

package/src/definePresets.ts

@@ -1,16 +0,0 @@
-import type { Preset, Presets, Resolver } from './types.ts'
-
-/**
- * Creates a typed presets registry object — a named collection of {@link Preset} entries.
- *
- * @example
- * import { definePreset, definePresets } from '@kubb/core'
- * import { resolverTsLegacy } from '@kubb/plugin-ts'
- *
- * export const myPresets = definePresets({
- *   kubbV4: definePreset('kubbV4', { resolvers: [resolverTsLegacy] }),
- * })
- */
-export function definePresets<TResolver extends Resolver = Resolver>(presets: Presets<TResolver>): Presets<TResolver> {
-  return presets
-}

package/src/renderNode.tsx

@@ -1,28 +0,0 @@
-import type { FileNode } from '@kubb/ast/types'
-import { createRenderer } from '@kubb/renderer-jsx'
-import type { KubbReactNode } from '@kubb/renderer-jsx/types'
-import type { PluginDriver } from './PluginDriver.ts'
-
-/**
- * Handles the return value of a plugin AST hook or generator method.
- *
- * - React element → rendered via renderer-jsx, files stored in `driver.fileManager`
- * - `Array<FileNode>` → upserted directly into `driver.fileManager`
- * - `void` / `null` / `undefined` → no-op (plugin handled it via `this.upsertFile`)
- */
-export async function applyHookResult(result: KubbReactNode | Array<FileNode> | void, driver: PluginDriver): Promise<void> {
-  if (!result) return
-
-  if (Array.isArray(result)) {
-    driver.fileManager.upsert(...(result as Array<FileNode>))
-    return
-  }
-
-  const renderer = createRenderer()
-
-  // biome-ignore lint/complexity/noUselessFragments: not needed
-  await renderer.render(<>{result as KubbReactNode}</>)
-
-  driver.fileManager.upsert(...renderer.files)
-  renderer.unmount()
-}

package/src/utils/getConfigs.ts

@@ -1,16 +0,0 @@
-import type { CLIOptions, ConfigInput } from '../defineConfig.ts'
-import type { Config, UserConfig } from '../types.ts'
-
-/**
- * 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 resolved = await (typeof config === 'function' ? config(args as CLIOptions) : config)
-  const userConfigs = Array.isArray(resolved) ? resolved : [resolved]
-
-  return userConfigs.map((item) => ({ plugins: [], ...item }) as Config)
-}

package/src/utils/getPreset.ts

@@ -1,78 +0,0 @@
-import { composeTransformers } from '@kubb/ast'
-import type { Visitor } from '@kubb/ast/types'
-import type { CompatibilityPreset, Generator, Preset, Presets, Resolver } from '../types.ts'
-
-/**
- * Returns a copy of `defaults` where each function in `userOverrides` is wrapped
- * so a `null`/`undefined` return falls back to the original. Non-function values
- * are assigned directly. All calls use the merged object as `this`.
- */
-function withFallback<T extends object>(defaults: T, userOverrides: Partial<T>): T {
-  const merged = { ...defaults } as T
-
-  for (const key of Object.keys(userOverrides) as Array<keyof T>) {
-    const userVal = userOverrides[key]
-    const defaultVal = defaults[key]
-
-    if (typeof userVal === 'function' && typeof defaultVal === 'function') {
-      ;(merged as any)[key] = (...args: any[]) => (userVal as Function).apply(merged, args) ?? (defaultVal as Function).apply(merged, args)
-    } else if (userVal !== undefined) {
-      merged[key] = userVal as T[typeof key]
-    }
-  }
-
-  return merged
-}
-
-type GetPresetParams<TResolver extends Resolver> = {
-  preset: CompatibilityPreset
-  presets: Presets<TResolver>
-  /**
-   * Optional single resolver whose methods override the preset resolver.
-   * When a method returns `null` or `undefined` the preset resolver's method is used instead.
-   */
-  resolver?: Partial<TResolver> & ThisType<TResolver>
-  /**
-   * User-supplied generators to append after the preset's generators.
-   */
-  generators?: Array<Generator<any>>
-  /**
-   * Optional single transformer visitor whose methods override the preset transformer.
-   * When a method returns `null` or `undefined` the preset transformer's method is used instead.
-   */
-  transformer?: Visitor
-}
-
-type GetPresetResult<TResolver extends Resolver> = {
-  resolver: TResolver
-  transformer: Visitor | undefined
-  generators: Array<Generator<any>>
-  preset: Preset<TResolver> | undefined
-}
-
-/**
- * Resolves a named preset into a resolver, transformer, and generators.
- *
- * - Selects the preset resolver; wraps it with user overrides using null/undefined fallback.
- * - Composes the preset's transformers into a single visitor; wraps it with the user transformer using null/undefined fallback.
- * - 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, resolver: userResolver, transformer: userTransformer, generators: userGenerators = [] } = params
-  const preset = presets[presetName]
-
-  const presetResolver = preset?.resolver ?? presets['default']!.resolver
-  const resolver = userResolver ? withFallback(presetResolver, userResolver) : presetResolver
-
-  const presetTransformers = preset?.transformers ?? []
-  const presetTransformer = presetTransformers.length > 0 ? composeTransformers(...presetTransformers) : undefined
-  const transformer = presetTransformer && userTransformer ? withFallback(presetTransformer, userTransformer) : (userTransformer ?? presetTransformer)
-
-  const presetGenerators = preset?.generators ?? []
-  const defaultGenerators = presets['default']?.generators ?? []
-  const generators = (presetGenerators.length > 0 || userGenerators.length > 0 ? [...presetGenerators, ...userGenerators] : defaultGenerators) as Array<
-    Generator<any>
-  >
-
-  return { resolver, transformer, generators, preset }
-}