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

package/src/utils/getPreset.ts

@@ -5,11 +5,11 @@ import { mergeResolvers } from './mergeResolvers.ts'
 type GetPresetParams<TResolver extends Resolver> = {
   preset: CompatibilityPreset
   presets: Presets<TResolver>
-  resolvers: Array<TResolver>
+  resolvers?: Array<TResolver>
   /**
    * User-supplied generators to append after the preset's generators.
    */
-  generators: Array<Generator<any>>
+  generators?: Array<Generator<any>>
   transformers?: Array<Visitor>
 }
 
@@ -29,7 +29,7 @@ type GetPresetResult<TResolver extends Resolver> = {
  * - 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 { preset: presetName, presets, resolvers = [], transformers: userTransformers = [], generators: userGenerators = [] } = params
   const [defaultResolver, ...userResolvers] = resolvers
   const preset = presets[presetName]
 

package/src/utils/mergeResolvers.ts

@@ -1,7 +1,15 @@
 import type { Resolver } from '../types.ts'
 
 /**
- * Merges an array of resolvers into a single resolver. Later entries override earlier ones (last wins).
+ * Merges an ordered list of resolvers into a single resolver by shallow-merging each entry left to right.
+ *
+ * Later entries win when keys conflict, so the last resolver in the list takes highest precedence.
+ *
+ * @example
+ * ```ts
+ * const resolver = mergeResolvers(resolverTs, resolverTsLegacy)
+ * // resolverTsLegacy methods override resolverTs where they overlap
+ * ```
  */
 export function mergeResolvers<T extends Resolver>(...resolvers: Array<T>): T {
   return resolvers.reduce<T>((acc, curr) => ({ ...acc, ...curr }), resolvers[0]!)

package/src/defineBuilder.ts

@@ -1,26 +0,0 @@
-import type { PluginFactoryOptions } from './types.ts'
-
-/**
- * Builder type for the plugin-specific builder fields.
- * `name` is required; all other methods are defined by the concrete plugin builder type.
- */
-type BuilderBuilder<T extends PluginFactoryOptions> = () => T['builder'] & ThisType<T['builder']>
-
-/**
- * Defines a builder for a plugin — a named collection of schema-building helpers that
- * can be exported alongside the plugin and imported by other plugins or generators.
- *
- * @example
- * export const builder = defineBuilder<PluginTs>(() => ({
- *   name: 'default',
- *   buildParamsSchema({ params, node, resolver }) {
- *     return createSchema({ type: 'object', properties: [] })
- *   },
- *   buildDataSchemaNode({ node, resolver }) {
- *     return createSchema({ type: 'object', properties: [] })
- *   },
- * }))
- */
-export function defineBuilder<T extends PluginFactoryOptions>(build: BuilderBuilder<T>): T['builder'] {
-  return build() as T['builder']
-}

package/src/definePreset.ts

@@ -1,27 +0,0 @@
-import type { Visitor } from '@kubb/ast/types'
-import type { Generator, Preset, Resolver } from './types.ts'
-
-/**
- * Creates a typed preset object that bundles a name, resolvers, optional
- * transformers, and optional generators — the building block for composable plugin presets.
- *
- * @example
- * import { definePreset } from '@kubb/core'
- * import { resolverTsLegacy } from '@kubb/plugin-ts'
- *
- * export const myPreset = definePreset('myPreset', { resolvers: [resolverTsLegacy] })
- *
- * @example
- * // With custom transformers
- * export const myPreset = definePreset('myPreset', { resolvers: [resolverTsLegacy], transformers: [myTransformer] })
- *
- * @example
- * // With generators
- * export const myPreset = definePreset('myPreset', { resolvers: [resolverTsLegacy], generators: [typeGeneratorLegacy] })
- */
-export function definePreset<TResolver extends Resolver = Resolver, TName extends string = string>(
-  name: TName,
-  { resolvers, transformers, generators }: { resolvers: Array<TResolver>; transformers?: Array<Visitor>; generators?: Array<Generator<any>> },
-): Preset<TResolver> & { name: TName } {
-  return { name, resolvers, transformers, generators }
-}