@kubb/plugin-ts 5.0.0-alpha.34 → 5.0.0-alpha.35

package/src/printers/functionPrinter.ts

@@ -1,16 +1,14 @@
-import type { PrinterFactoryOptions } from '@kubb/ast'
-import { createPrinterFactory } from '@kubb/ast'
-import type { FunctionNodeType, FunctionParameterNode, FunctionParametersNode, FunctionParamNode, ParameterGroupNode, ParamsTypeNode } from '@kubb/ast/types'
+import { ast } from '@kubb/core'
 import { PARAM_RANK } from '../constants.ts'
 
 /**
  * Maps each function-printer handler key to its concrete node type.
  */
 export type FunctionNodeByType = {
-  functionParameter: FunctionParameterNode
-  parameterGroup: ParameterGroupNode
-  functionParameters: FunctionParametersNode
-  paramsType: ParamsTypeNode
+  functionParameter: ast.FunctionParameterNode
+  parameterGroup: ast.ParameterGroupNode
+  functionParameters: ast.FunctionParametersNode
+  paramsType: ast.ParamsTypeNode
 }
 
 const kindToHandlerKey = {
@@ -18,7 +16,7 @@ const kindToHandlerKey = {
   ParameterGroup: 'parameterGroup',
   FunctionParameters: 'functionParameters',
   ParamsType: 'paramsType',
-} satisfies Record<string, FunctionNodeType>
+} satisfies Record<string, ast.FunctionNodeType>
 
 /**
  * Creates a function-parameter printer factory.
@@ -26,7 +24,9 @@ const kindToHandlerKey = {
  * Uses `createPrinterFactory` and dispatches handlers by `node.kind`
  * (for function nodes) rather than by `node.type` (for schema nodes).
  */
-export const defineFunctionPrinter = createPrinterFactory<FunctionParamNode, FunctionNodeType, FunctionNodeByType>((node) => kindToHandlerKey[node.kind])
+export const defineFunctionPrinter = ast.createPrinterFactory<ast.FunctionParamNode, ast.FunctionNodeType, FunctionNodeByType>(
+  (node) => kindToHandlerKey[node.kind],
+)
 
 export type FunctionPrinterOptions = {
   /**
@@ -50,9 +50,9 @@ export type FunctionPrinterOptions = {
   transformType?: (type: string) => string
 }
 
-type DefaultPrinter = PrinterFactoryOptions<'functionParameters', FunctionPrinterOptions, string>
+type DefaultPrinter = ast.PrinterFactoryOptions<'functionParameters', FunctionPrinterOptions, string>
 
-function rank(param: FunctionParameterNode | ParameterGroupNode): number {
+function rank(param: ast.FunctionParameterNode | ast.ParameterGroupNode): number {
   if (param.kind === 'ParameterGroup') {
     if (param.default) return PARAM_RANK.withDefault
     const isOptional = param.optional ?? param.properties.every((p) => p.optional || p.default !== undefined)
@@ -63,11 +63,11 @@ function rank(param: FunctionParameterNode | ParameterGroupNode): number {
   return param.optional ? PARAM_RANK.optional : PARAM_RANK.required
 }
 
-function sortParams(params: ReadonlyArray<FunctionParameterNode | ParameterGroupNode>): Array<FunctionParameterNode | ParameterGroupNode> {
+function sortParams(params: ReadonlyArray<ast.FunctionParameterNode | ast.ParameterGroupNode>): Array<ast.FunctionParameterNode | ast.ParameterGroupNode> {
   return [...params].sort((a, b) => rank(a) - rank(b))
 }
 
-function sortChildParams(params: Array<FunctionParameterNode>): Array<FunctionParameterNode> {
+function sortChildParams(params: Array<ast.FunctionParameterNode>): Array<ast.FunctionParameterNode> {
   return [...params].sort((a, b) => rank(a) - rank(b))
 }
 

package/src/printers/printerTs.ts

@@ -1,6 +1,5 @@
-import { extractRefName, isStringType, narrowSchema, schemaTypes, syncSchemaRef } from '@kubb/ast'
 import type { PrinterFactoryOptions, PrinterPartial } from '@kubb/core'
-import { definePrinter } from '@kubb/core'
+import { ast, definePrinter } from '@kubb/core'
 import { safePrint } from '@kubb/parser-ts'
 import type ts from 'typescript'
 import { ENUM_TYPES_WITH_KEY_SUFFIX, OPTIONAL_ADDS_QUESTION_TOKEN, OPTIONAL_ADDS_UNDEFINED } from '../constants.ts'
@@ -154,7 +153,7 @@ export const printerTs = definePrinter<PrinterTs>((options) => {
         // Use the canonical name from the $ref path — node.name may have been overridden
         // (e.g. by single-member allOf flatten using the property-derived child name).
         // Inline refs (without $ref) from utils already carry resolved type names.
-        const refName = node.ref ? (extractRefName(node.ref) ?? node.name) : node.name
+        const refName = node.ref ? (ast.extractRefName(node.ref) ?? node.name) : node.name
 
         // When a Key suffix is configured, enum refs must use the suffixed name (e.g. `StatusKey`)
         // so the reference matches what the enum file actually exports.
@@ -192,15 +191,15 @@ export const printerTs = definePrinter<PrinterTs>((options) => {
         const members = node.members ?? []
 
         const hasStringLiteral = members.some((m) => {
-          const enumNode = narrowSchema(m, schemaTypes.enum)
+          const enumNode = ast.narrowSchema(m, ast.schemaTypes.enum)
           return enumNode?.primitive === 'string'
         })
-        const hasPlainString = members.some((m) => isStringType(m))
+        const hasPlainString = members.some((m) => ast.isStringType(m))
 
         if (hasStringLiteral && hasPlainString) {
           const memberNodes = members
             .map((m) => {
-              if (isStringType(m)) {
+              if (ast.isStringType(m)) {
                 return factory.createIntersectionDeclaration({
                   nodes: [factory.keywordTypeNodes.string, factory.createTypeLiteralNode([])],
                   withParentheses: true,
@@ -235,7 +234,7 @@ export const printerTs = definePrinter<PrinterTs>((options) => {
         const propertyNodes: Array<ts.TypeElement> = node.properties.map((prop) => {
           const baseType = transform(prop.schema) ?? factory.keywordTypeNodes.unknown
           const type = factory.buildPropertyType(prop.schema, baseType, options.optionalType)
-          const propMeta = syncSchemaRef(prop.schema)
+          const propMeta = ast.syncSchemaRef(prop.schema)
 
           const propertyNode = factory.createPropertySignature({
             questionToken: prop.schema.optional || prop.schema.nullish ? addsQuestionToken : false,
@@ -264,7 +263,7 @@ export const printerTs = definePrinter<PrinterTs>((options) => {
       if (!base) return null
 
       // For ref nodes, structural metadata lives on node.schema rather than the ref node itself.
-      const meta = syncSchemaRef(node)
+      const meta = ast.syncSchemaRef(node)
 
       // Without name, apply modifiers inline and return.
       if (!name) {

package/src/types.ts

@@ -1,6 +1,5 @@
-import type { OperationParamsResolver } from '@kubb/ast'
-import type { OperationNode, ParameterNode, StatusCode, Visitor } from '@kubb/ast/types'
 import type {
+  ast,
   CompatibilityPreset,
   Exclude,
   Generator,
@@ -20,7 +19,7 @@ import type { PrinterTsNodes } from './printers/printerTs.ts'
  * plugin-specific naming helpers for operations, parameters, responses, and schemas.
  */
 export type ResolverTs = Resolver &
-  OperationParamsResolver & {
+  ast.OperationParamsResolver & {
     /**
      * Resolves the name for a given raw name (equivalent to `default(name, 'function')`).
      * Since TypeScript only emits types, this is the canonical naming method.
@@ -39,7 +38,7 @@ export type ResolverTs = Resolver &
     /**
      * Resolves the request body type name for an operation (required on ResolverTs).
      */
-    resolveDataName(node: OperationNode): string
+    resolveDataName(node: ast.OperationNode): string
 
     /**
      * Resolves the name for an operation response by status code.
@@ -48,28 +47,28 @@ export type ResolverTs = Resolver &
      * @example
      * resolver.resolveResponseStatusName(node, 200) // → 'ListPetsStatus200'
      */
-    resolveResponseStatusName(node: OperationNode, statusCode: StatusCode): string
+    resolveResponseStatusName(node: ast.OperationNode, statusCode: ast.StatusCode): string
     /**
      * Resolves the name for an operation's request config (`RequestConfig`).
      *
      * @example
      * resolver.resolveRequestConfigName(node) // → 'ListPetsRequestConfig'
      */
-    resolveRequestConfigName(node: OperationNode): string
+    resolveRequestConfigName(node: ast.OperationNode): string
     /**
      * Resolves the name for the collection of all operation responses (`Responses`).
      *
      * @example
      * resolver.resolveResponsesName(node) // → 'ListPetsResponses'
      */
-    resolveResponsesName(node: OperationNode): string
+    resolveResponsesName(node: ast.OperationNode): string
     /**
      * Resolves the name for the union of all operation responses (`Response`).
      *
      * @example
      * resolver.resolveResponseName(node) // → 'ListPetsResponse'
      */
-    resolveResponseName(node: OperationNode): string
+    resolveResponseName(node: ast.OperationNode): string
     /**
      * Resolves the TypeScript type alias name for an enum schema's key variant.
      * Appends `enumTypeSuffix` (default `'Key'`) after applying the default naming convention.
@@ -86,21 +85,21 @@ export type ResolverTs = Resolver &
      * @example
      * resolver.resolvePathParamsName(node, param) // → 'GetPetByIdPathParams'
      */
-    resolvePathParamsName(node: OperationNode, param: ParameterNode): string
+    resolvePathParamsName(node: ast.OperationNode, param: ast.ParameterNode): string
     /**
      * Resolves the name for an operation's grouped query parameters type.
      *
      * @example
      * resolver.resolveQueryParamsName(node, param) // → 'FindPetsByStatusQueryParams'
      */
-    resolveQueryParamsName(node: OperationNode, param: ParameterNode): string
+    resolveQueryParamsName(node: ast.OperationNode, param: ast.ParameterNode): string
     /**
      * Resolves the name for an operation's grouped header parameters type.
      *
      * @example
      * resolver.resolveHeaderParamsName(node, param) // → 'DeletePetHeaderParams'
      */
-    resolveHeaderParamsName(node: OperationNode, param: ParameterNode): string
+    resolveHeaderParamsName(node: ast.OperationNode, param: ast.ParameterNode): string
   }
 
 type EnumKeyCasing = 'screamingSnakeCase' | 'snakeCase' | 'pascalCase' | 'camelCase' | 'none'
@@ -274,7 +273,7 @@ export type Options = {
    * }
    * ```
    */
-  transformer?: Visitor
+  transformer?: ast.Visitor
   /**
    * Override individual printer node handlers to customize rendering of specific schema types.
    *

package/src/utils.ts

@@ -1,6 +1,5 @@
 import { jsStringEscape, stringify } from '@internals/utils'
-import { createProperty, createSchema, syncSchemaRef } from '@kubb/ast'
-import type { OperationNode, ParameterNode, SchemaNode } from '@kubb/ast/types'
+import { ast } from '@kubb/core'
 import type { ResolverTs } from './types.ts'
 
 /**
@@ -10,8 +9,8 @@ import type { ResolverTs } from './types.ts'
  * Constraint metadata (min/max length, pattern, multipleOf, min/maxProperties) is emitted as plain-text lines.
 
  */
-export function buildPropertyJSDocComments(schema: SchemaNode): Array<string | undefined> {
-  const meta = syncSchemaRef(schema)
+export function buildPropertyJSDocComments(schema: ast.SchemaNode): Array<string | undefined> {
+  const meta = ast.syncSchemaRef(schema)
 
   const isArray = meta?.primitive === 'array'
 
@@ -33,7 +32,7 @@ export function buildPropertyJSDocComments(schema: SchemaNode): Array<string | u
 }
 
 type BuildParamsSchemaOptions = {
-  params: Array<ParameterNode>
+  params: Array<ast.ParameterNode>
   resolver: ResolverTs
 }
 
@@ -41,14 +40,14 @@ type BuildOperationSchemaOptions = {
   resolver: ResolverTs
 }
 
-export function buildParams(node: OperationNode, { params, resolver }: BuildParamsSchemaOptions): SchemaNode {
-  return createSchema({
+export function buildParams(node: ast.OperationNode, { params, resolver }: BuildParamsSchemaOptions): ast.SchemaNode {
+  return ast.createSchema({
     type: 'object',
     properties: params.map((param) =>
-      createProperty({
+      ast.createProperty({
         name: param.name,
         required: param.required,
-        schema: createSchema({
+        schema: ast.createSchema({
           type: 'ref',
           name: resolver.resolveParamName(node, param),
         }),
@@ -57,75 +56,75 @@ export function buildParams(node: OperationNode, { params, resolver }: BuildPara
   })
 }
 
-export function buildData(node: OperationNode, { resolver }: BuildOperationSchemaOptions): SchemaNode {
+export function buildData(node: ast.OperationNode, { resolver }: BuildOperationSchemaOptions): ast.SchemaNode {
   const pathParams = node.parameters.filter((p) => p.in === 'path')
   const queryParams = node.parameters.filter((p) => p.in === 'query')
   const headerParams = node.parameters.filter((p) => p.in === 'header')
 
-  return createSchema({
+  return ast.createSchema({
     type: 'object',
     deprecated: node.deprecated,
     properties: [
-      createProperty({
+      ast.createProperty({
         name: 'data',
         schema: node.requestBody?.schema
-          ? createSchema({ type: 'ref', name: resolver.resolveDataName(node), optional: true })
-          : createSchema({ type: 'never', primitive: undefined, optional: true }),
+          ? ast.createSchema({ type: 'ref', name: resolver.resolveDataName(node), optional: true })
+          : ast.createSchema({ type: 'never', primitive: undefined, optional: true }),
       }),
-      createProperty({
+      ast.createProperty({
         name: 'pathParams',
         required: pathParams.length > 0,
-        schema: pathParams.length > 0 ? buildParams(node, { params: pathParams, resolver }) : createSchema({ type: 'never', primitive: undefined }),
+        schema: pathParams.length > 0 ? buildParams(node, { params: pathParams, resolver }) : ast.createSchema({ type: 'never', primitive: undefined }),
       }),
-      createProperty({
+      ast.createProperty({
         name: 'queryParams',
         schema:
           queryParams.length > 0
-            ? createSchema({ ...buildParams(node, { params: queryParams, resolver }), optional: true })
-            : createSchema({ type: 'never', primitive: undefined, optional: true }),
+            ? ast.createSchema({ ...buildParams(node, { params: queryParams, resolver }), optional: true })
+            : ast.createSchema({ type: 'never', primitive: undefined, optional: true }),
       }),
-      createProperty({
+      ast.createProperty({
         name: 'headerParams',
         schema:
           headerParams.length > 0
-            ? createSchema({ ...buildParams(node, { params: headerParams, resolver }), optional: true })
-            : createSchema({ type: 'never', primitive: undefined, optional: true }),
+            ? ast.createSchema({ ...buildParams(node, { params: headerParams, resolver }), optional: true })
+            : ast.createSchema({ type: 'never', primitive: undefined, optional: true }),
       }),
-      createProperty({
+      ast.createProperty({
         name: 'url',
         required: true,
-        schema: createSchema({ type: 'url', path: node.path }),
+        schema: ast.createSchema({ type: 'url', path: node.path }),
       }),
     ],
   })
 }
 
-export function buildResponses(node: OperationNode, { resolver }: BuildOperationSchemaOptions): SchemaNode | null {
+export function buildResponses(node: ast.OperationNode, { resolver }: BuildOperationSchemaOptions): ast.SchemaNode | null {
   if (node.responses.length === 0) {
     return null
   }
 
-  return createSchema({
+  return ast.createSchema({
     type: 'object',
     properties: node.responses.map((res) =>
-      createProperty({
+      ast.createProperty({
         name: String(res.statusCode),
         required: true,
-        schema: createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, res.statusCode) }),
+        schema: ast.createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, res.statusCode) }),
       }),
     ),
   })
 }
 
-export function buildResponseUnion(node: OperationNode, { resolver }: BuildOperationSchemaOptions): SchemaNode | null {
+export function buildResponseUnion(node: ast.OperationNode, { resolver }: BuildOperationSchemaOptions): ast.SchemaNode | null {
   const responsesWithSchema = node.responses.filter((res) => res.schema)
 
   if (responsesWithSchema.length === 0) {
     return null
   }
 
-  return createSchema({
+  return ast.createSchema({
     type: 'union',
-    members: responsesWithSchema.map((res) => createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, res.statusCode) })),
+    members: responsesWithSchema.map((res) => ast.createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, res.statusCode) })),
   })
 }

package/src/presets.ts

@@ -1,28 +0,0 @@
-import { definePresets } from '@kubb/core'
-import { typeGenerator } from './generators/typeGenerator.tsx'
-import { typeGeneratorLegacy } from './generators/typeGeneratorLegacy.tsx'
-import { printerTs } from './printers/printerTs.ts'
-import { resolverTs } from './resolvers/resolverTs.ts'
-import { resolverTsLegacy } from './resolvers/resolverTsLegacy.ts'
-import type { ResolverTs } from './types.ts'
-
-/**
- * Built-in preset registry for `@kubb/plugin-ts`.
- *
- * - `default` — uses `resolverTs` and `typeGenerator` (current naming conventions).
- * - `kubbV4` — uses `resolverTsLegacy` and `typeGeneratorLegacy` (Kubb v4 naming conventions).
- */
-export const presets = definePresets<ResolverTs>({
-  default: {
-    name: 'default',
-    resolver: resolverTs,
-    generators: [typeGenerator],
-    printer: printerTs,
-  },
-  kubbV4: {
-    name: 'kubbV4',
-    resolver: resolverTsLegacy,
-    generators: [typeGeneratorLegacy],
-    printer: printerTs,
-  },
-})