@kubb/plugin-ts 5.0.0-beta.10 → 5.0.0-beta.100

package/src/generators/typeGenerator.tsx

@@ -1,296 +0,0 @@
-import { ast, defineGenerator } from '@kubb/core'
-import { File, jsxRenderer } from '@kubb/renderer-jsx'
-import { Type } from '../components/Type.tsx'
-import { ENUM_TYPES_WITH_KEY_SUFFIX } from '../constants.ts'
-import { printerTs } from '../printers/printerTs.ts'
-import type { PluginTs } from '../types'
-import { buildData, buildResponses, buildResponseUnion } from '../utils.ts'
-
-function getContentTypeSuffix(contentType: string): string {
-  const baseType = contentType.split(';')[0]!.trim()
-  if (baseType === 'application/json') return 'Json'
-  if (baseType === 'multipart/form-data') return 'FormData'
-  if (baseType === 'application/x-www-form-urlencoded') return 'FormUrlEncoded'
-  const subtype = baseType.split('/').pop() ?? baseType
-  const parts = subtype.split(/[^a-zA-Z0-9]+/).filter(Boolean)
-  if (parts.length === 0) return 'Unknown'
-  return parts.map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join('')
-}
-
-function getPerContentTypeName(dataName: string, suffix: string): string {
-  if (dataName.endsWith('Data')) {
-    return suffix.endsWith('Data') ? dataName.slice(0, -4) + suffix : `${dataName.slice(0, -4)}${suffix}Data`
-  }
-  return dataName + suffix
-}
-
-export const typeGenerator = defineGenerator<PluginTs>({
-  name: 'typescript',
-  renderer: jsxRenderer,
-  schema(node, ctx) {
-    const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, printer } = ctx.options
-    const { adapter, config, resolver, root } = ctx
-
-    if (!node.name) {
-      return
-    }
-    const mode = ctx.getMode(output)
-    // Build a set of schema names that are enums so the ref handler and getImports
-    // callback can use the suffixed type name (e.g. `StatusKey`) for those refs.
-    const enumSchemaNames = new Set((adapter.inputNode?.schemas ?? []).filter((s) => ast.narrowSchema(s, ast.schemaTypes.enum) && s.name).map((s) => s.name!))
-
-    function resolveImportName(schemaName: string): string {
-      if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && enumTypeSuffix && enumSchemaNames.has(schemaName)) {
-        return resolver.resolveEnumKeyName({ name: schemaName }, enumTypeSuffix)
-      }
-      return resolver.resolveTypeName(schemaName)
-    }
-
-    const imports = adapter.getImports(node, (schemaName) => ({
-      name: resolveImportName(schemaName),
-      path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
-    }))
-
-    const isEnumSchema = !!ast.narrowSchema(node, ast.schemaTypes.enum)
-
-    const meta = {
-      name: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyName(node, enumTypeSuffix) : resolver.resolveTypeName(node.name),
-      file: resolver.resolveFile({ name: node.name, extname: '.ts' }, { root, output, group }),
-    } as const
-
-    const schemaPrinter = printerTs({
-      optionalType,
-      arrayType,
-      enumType,
-      enumTypeSuffix,
-      name: meta.name,
-      syntaxType,
-      description: node.description,
-      resolver,
-      enumSchemaNames,
-      nodes: printer?.nodes,
-    })
-
-    return (
-      <File
-        baseName={meta.file.baseName}
-        path={meta.file.path}
-        meta={meta.file.meta}
-        banner={resolver.resolveBanner(adapter.inputNode, { output, config })}
-        footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
-      >
-        {mode === 'split' &&
-          imports.map((imp) => (
-            <File.Import key={[node.name, imp.path, imp.isTypeOnly].join('-')} root={meta.file.path} path={imp.path} name={imp.name} isTypeOnly />
-          ))}
-        <Type
-          name={meta.name}
-          node={node}
-          enumType={enumType}
-          enumTypeSuffix={enumTypeSuffix}
-          enumKeyCasing={enumKeyCasing}
-          resolver={resolver}
-          printer={schemaPrinter}
-        />
-      </File>
-    )
-  },
-  operation(node, ctx) {
-    const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output, printer } = ctx.options
-    const { adapter, config, resolver, root } = ctx
-
-    const mode = ctx.getMode(output)
-
-    const params = ast.caseParams(node.parameters, paramsCasing)
-
-    const meta = {
-      file: resolver.resolveFile({ name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path }, { root, output, group }),
-    } as const
-
-    // Build a set of schema names that are enums so the ref handler and getImports
-    // callback can use the suffixed type name (e.g. `StatusKey`) for those refs.
-    const enumSchemaNames = new Set((adapter.inputNode?.schemas ?? []).filter((s) => ast.narrowSchema(s, ast.schemaTypes.enum) && s.name).map((s) => s.name!))
-
-    function resolveImportName(schemaName: string): string {
-      if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && enumTypeSuffix && enumSchemaNames.has(schemaName)) {
-        return resolver.resolveEnumKeyName({ name: schemaName }, enumTypeSuffix)
-      }
-      return resolver.resolveTypeName(schemaName)
-    }
-
-    function renderSchemaType({ schema, name, keysToOmit }: { schema: ast.SchemaNode | null; name: string; keysToOmit?: Array<string> }) {
-      if (!schema) return null
-
-      const imports = adapter.getImports(schema, (schemaName) => ({
-        name: resolveImportName(schemaName),
-        path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
-      }))
-
-      const schemaPrinter = printerTs({
-        optionalType,
-        arrayType,
-        enumType,
-        enumTypeSuffix,
-        name,
-        syntaxType,
-        description: schema.description,
-        keysToOmit,
-        resolver,
-        enumSchemaNames,
-        nodes: printer?.nodes,
-      })
-
-      return (
-        <>
-          {mode === 'split' &&
-            imports.map((imp) => (
-              <File.Import key={[name, imp.path, imp.isTypeOnly].join('-')} root={meta.file.path} path={imp.path} name={imp.name} isTypeOnly />
-            ))}
-          <Type
-            name={name}
-            node={schema}
-            enumType={enumType}
-            enumTypeSuffix={enumTypeSuffix}
-            enumKeyCasing={enumKeyCasing}
-            resolver={resolver}
-            printer={schemaPrinter}
-          />
-        </>
-      )
-    }
-
-    const paramTypes = params.map((param) =>
-      renderSchemaType({
-        schema: param.schema,
-        name: resolver.resolveParamName(node, param),
-      }),
-    )
-
-    const requestBodyContent = node.requestBody?.content ?? []
-
-    function buildRequestType() {
-      if (requestBodyContent.length === 0) return null
-      if (requestBodyContent.length === 1) {
-        const entry = requestBodyContent[0]!
-        if (!entry.schema) return null
-        return renderSchemaType({
-          schema: {
-            ...entry.schema,
-            description: node.requestBody!.description ?? entry.schema.description,
-          },
-          name: resolver.resolveDataName(node),
-          keysToOmit: entry.keysToOmit,
-        })
-      }
-      // Multiple content types — generate individual types + union alias
-      const dataName = resolver.resolveDataName(node)
-      const usedNames = new Set<string>()
-      const individualItems = requestBodyContent
-        .filter((entry) => entry.schema)
-        .map((entry) => {
-          const baseSuffix = getContentTypeSuffix(entry.contentType)
-          let individualName = getPerContentTypeName(dataName, baseSuffix)
-          let counter = 2
-          while (usedNames.has(individualName)) {
-            individualName = getPerContentTypeName(dataName, `${baseSuffix}${counter++}`)
-          }
-          usedNames.add(individualName)
-          return {
-            name: individualName,
-            rendered: renderSchemaType({
-              schema: {
-                ...entry.schema!,
-                description: node.requestBody!.description ?? entry.schema!.description,
-              },
-              name: individualName,
-              keysToOmit: entry.keysToOmit,
-            }),
-          }
-        })
-      const unionSchema = ast.createSchema({
-        type: 'union',
-        members: individualItems.map((item) => ast.createSchema({ type: 'ref', name: item.name })),
-      })
-      const unionType = renderSchemaType({ schema: unionSchema, name: dataName })
-      return (
-        <>
-          {individualItems.map((item) => item.rendered)}
-          {unionType}
-        </>
-      )
-    }
-
-    const requestType = buildRequestType()
-
-    const responseTypes = node.responses.map((res) =>
-      renderSchemaType({
-        schema: res.schema,
-        name: resolver.resolveResponseStatusName(node, res.statusCode),
-        keysToOmit: res.keysToOmit,
-      }),
-    )
-
-    const dataType = renderSchemaType({
-      schema: buildData({ ...node, parameters: params }, { resolver }),
-      name: resolver.resolveRequestConfigName(node),
-    })
-
-    const responsesType = renderSchemaType({
-      schema: buildResponses(node, { resolver }),
-      name: resolver.resolveResponsesName(node),
-    })
-
-    function buildResponseType() {
-      if (!node.responses.some((res) => res.schema)) {
-        return null
-      }
-
-      const responseName = resolver.resolveResponseName(node)
-
-      const responsesWithSchema = node.responses.filter((res) => res.schema)
-      const importedNames = new Set(
-        responsesWithSchema.flatMap((res) =>
-          res.schema
-            ? adapter
-                .getImports(res.schema, (schemaName) => ({
-                  name: resolveImportName(schemaName),
-                  path: '',
-                }))
-                .flatMap((imp) => (Array.isArray(imp.name) ? imp.name : [imp.name]))
-            : [],
-        ),
-      )
-
-      if (importedNames.has(responseName)) {
-        return null
-      }
-
-      return renderSchemaType({
-        schema: {
-          ...buildResponseUnion(node, { resolver })!,
-          description: 'Union of all possible responses',
-        },
-        name: responseName,
-      })
-    }
-
-    const responseType = buildResponseType()
-
-    return (
-      <File
-        baseName={meta.file.baseName}
-        path={meta.file.path}
-        meta={meta.file.meta}
-        banner={resolver.resolveBanner(adapter.inputNode, { output, config })}
-        footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
-      >
-        {paramTypes}
-        {responseTypes}
-        {requestType}
-        {dataType}
-        {responsesType}
-        {responseType}
-      </File>
-    )
-  },
-})

package/src/index.ts

@@ -1,9 +0,0 @@
-export { Enum } from './components/Enum.tsx'
-export { Type } from './components/Type.tsx'
-export { typeGenerator } from './generators/typeGenerator.tsx'
-export { default, pluginTs, pluginTsName } from './plugin.ts'
-export { functionPrinter } from './printers/functionPrinter.ts'
-export type { PrinterTsFactory, PrinterTsNodes, PrinterTsOptions } from './printers/printerTs.ts'
-export { printerTs } from './printers/printerTs.ts'
-export { resolverTs } from './resolvers/resolverTs.ts'
-export type { PluginTs, ResolverTs } from './types.ts'

package/src/plugin.ts

@@ -1,93 +0,0 @@
-import { camelCase } from '@internals/utils'
-import { definePlugin, type Group } from '@kubb/core'
-import { typeGenerator } from './generators/typeGenerator.tsx'
-import { resolverTs } from './resolvers/resolverTs.ts'
-import type { PluginTs } from './types.ts'
-
-/**
- * Canonical plugin name for `@kubb/plugin-ts`, used to identify the plugin in driver lookups and warnings.
- */
-export const pluginTsName = 'plugin-ts' satisfies PluginTs['name']
-
-/**
- * The `@kubb/plugin-ts` plugin factory.
- *
- * Generates TypeScript type declarations from an OpenAPI/AST `RootNode`.
- * Walks schemas and operations, delegates rendering to the active generators,
- * and writes barrel files based on `output.barrelType`.
- *
- * @example
- * ```ts
- * import pluginTs from '@kubb/plugin-ts'
- *
- * export default defineConfig({
- *   plugins: [pluginTs({ output: { path: 'types' }, enumType: 'asConst' })],
- * })
- * ```
- */
-export const pluginTs = definePlugin<PluginTs>((options) => {
-  const {
-    output = { path: 'types', barrelType: 'named' },
-    group,
-    exclude = [],
-    include,
-    override = [],
-    enumType = 'asConst',
-    enumTypeSuffix = 'Key',
-    enumKeyCasing = 'none',
-    optionalType = 'questionToken',
-    arrayType = 'array',
-    syntaxType = 'type',
-    paramsCasing,
-    printer,
-    resolver: userResolver,
-    transformer: userTransformer,
-    generators: userGenerators = [],
-  } = options
-
-  const groupConfig = group
-    ? ({
-        ...group,
-        name: (ctx) => {
-          if (group.type === 'path') {
-            return `${ctx.group.split('/')[1]}`
-          }
-          return `${camelCase(ctx.group)}Controller`
-        },
-      } satisfies Group)
-    : undefined
-
-  return {
-    name: pluginTsName,
-    options,
-    hooks: {
-      'kubb:plugin:setup'(ctx) {
-        ctx.setOptions({
-          output,
-          exclude,
-          include,
-          override,
-          optionalType,
-          group: groupConfig,
-          arrayType,
-          enumType,
-          enumTypeSuffix,
-          enumKeyCasing,
-          syntaxType,
-          paramsCasing,
-          printer,
-        })
-        ctx.setResolver(userResolver ? { ...resolverTs, ...userResolver } : resolverTs)
-        if (userTransformer) {
-          ctx.setTransformer(userTransformer)
-        }
-        ctx.addGenerator(typeGenerator)
-        for (const gen of userGenerators) {
-          ctx.addGenerator(gen)
-        }
-      },
-    },
-  }
-})
-
-export default pluginTs

package/src/printers/functionPrinter.ts

@@ -1,197 +0,0 @@
-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: ast.FunctionParameterNode
-  parameterGroup: ast.ParameterGroupNode
-  functionParameters: ast.FunctionParametersNode
-  paramsType: ast.ParamsTypeNode
-}
-
-const kindToHandlerKey = {
-  FunctionParameter: 'functionParameter',
-  ParameterGroup: 'parameterGroup',
-  FunctionParameters: 'functionParameters',
-  ParamsType: 'paramsType',
-} satisfies Record<string, ast.FunctionNodeType>
-
-/**
- * Creates a function-parameter printer factory.
- *
- * Uses `createPrinterFactory` and dispatches handlers by `node.kind`
- * (for function nodes) rather than by `node.type` (for schema nodes).
- */
-export const defineFunctionPrinter = ast.createPrinterFactory<ast.FunctionParamNode, ast.FunctionNodeType, FunctionNodeByType>(
-  (node) => kindToHandlerKey[node.kind],
-)
-
-export type FunctionPrinterOptions = {
-  /**
-   * Rendering modes supported by `functionPrinter`.
-   *
-   * | Mode          | Output example                              | Use case                        |
-   * |---------------|---------------------------------------------|---------------------------------|
-   * | `declaration` | `id: string, config: Config = {}`           | Function parameter declaration |
-   * | `call`        | `id, { method, url }`                       | Function call arguments |
-   * | `keys`        | `{ id, config }`                            | Key names only (destructuring) |
-   * | `values`      | `{ id: id, config: config }`                | Key/value object entries |
-   */
-  mode: 'declaration' | 'call' | 'keys' | 'values'
-  /**
-   * Optional transformation applied to every parameter name before printing.
-   */
-  transformName?: (name: string) => string
-  /**
-   * Optional transformation applied to every type string before printing.
-   */
-  transformType?: (type: string) => string
-}
-
-type DefaultPrinter = ast.PrinterFactoryOptions<'functionParameters', FunctionPrinterOptions, string>
-
-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)
-    return isOptional ? PARAM_RANK.optional : PARAM_RANK.required
-  }
-  if (param.rest) return PARAM_RANK.rest
-  if (param.default) return PARAM_RANK.withDefault
-  return param.optional ? PARAM_RANK.optional : PARAM_RANK.required
-}
-
-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<ast.FunctionParameterNode>): Array<ast.FunctionParameterNode> {
-  return [...params].sort((a, b) => rank(a) - rank(b))
-}
-
-/**
- * Default function-signature printer.
- * Covers the four standard output modes used across Kubb plugins.
- *
- * @example
- * ```ts
- * const printer = functionPrinter({ mode: 'declaration' })
- *
- * const sig = createFunctionParameters({
- *   params: [
- *     createFunctionParameter({ name: 'petId', type: 'string', optional: false }),
- *     createFunctionParameter({ name: 'config', type: 'Config', optional: false, default: '{}' }),
- *   ],
- * })
- *
- * printer.print(sig)  // → "petId: string, config: Config = {}"
- * ```
- */
-export const functionPrinter = defineFunctionPrinter<DefaultPrinter>((options) => ({
-  name: 'functionParameters',
-  options,
-  nodes: {
-    paramsType(node) {
-      if (node.kind !== 'ParamsType') return null
-      if (node.variant === 'member') {
-        return `${node.base}['${node.key}']`
-      }
-      if (node.variant === 'struct') {
-        const parts = node.properties.map((p) => {
-          const typeStr = this.transform(p.type)
-          const key = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(p.name) ? p.name : JSON.stringify(p.name)
-          return p.optional ? `${key}?: ${typeStr}` : `${key}: ${typeStr}`
-        })
-        return `{ ${parts.join('; ')} }`
-      }
-      if (node.variant === 'reference') {
-        return node.name
-      }
-      return null
-    },
-    functionParameter(node) {
-      const { mode, transformName, transformType } = this.options
-      const name = transformName ? transformName(node.name) : node.name
-
-      const rawType = node.type ? this.transform(node.type) : undefined
-      const type = rawType != null && transformType ? transformType(rawType) : rawType
-
-      if (mode === 'keys' || mode === 'values') {
-        return node.rest ? `...${name}` : name
-      }
-
-      if (mode === 'call') {
-        return node.rest ? `...${name}` : name
-      }
-
-      if (node.rest) {
-        return type ? `...${name}: ${type}` : `...${name}`
-      }
-      if (type) {
-        if (node.optional) return `${name}?: ${type}`
-        return node.default ? `${name}: ${type} = ${node.default}` : `${name}: ${type}`
-      }
-      return node.default ? `${name} = ${node.default}` : name
-    },
-    parameterGroup(node) {
-      const { mode, transformName, transformType } = this.options
-      const sorted = sortChildParams(node.properties)
-      const isOptional = node.optional ?? sorted.every((p) => p.optional || p.default !== undefined)
-
-      if (node.inline) {
-        return sorted
-          .map((p) => this.transform(p))
-          .filter(Boolean)
-          .join(', ')
-      }
-
-      if (mode === 'keys' || mode === 'values') {
-        const keys = sorted.map((p) => p.name).join(', ')
-        return `{ ${keys} }`
-      }
-
-      if (mode === 'call') {
-        const keys = sorted.map((p) => p.name).join(', ')
-        return `{ ${keys} }`
-      }
-
-      const names = sorted.map((p) => {
-        const n = transformName ? transformName(p.name) : p.name
-
-        return n
-      })
-
-      const nameStr = names.length ? `{ ${names.join(', ')} }` : undefined
-      if (!nameStr) return null
-
-      let typeAnnotation: string | undefined = node.type ? (this.transform(node.type) ?? undefined) : undefined
-      if (!typeAnnotation) {
-        const typeParts = sorted
-          .filter((p) => p.type)
-          .map((p) => {
-            const rawT = p.type ? this.transform(p.type) : undefined
-            const t = rawT != null && transformType ? transformType(rawT) : rawT
-            return p.optional || p.default !== undefined ? `${p.name}?: ${t}` : `${p.name}: ${t}`
-          })
-        typeAnnotation = typeParts.length ? `{ ${typeParts.join('; ')} }` : undefined
-      }
-
-      if (typeAnnotation) {
-        if (isOptional) return `${nameStr}: ${typeAnnotation} = ${node.default ?? '{}'}`
-        return node.default ? `${nameStr}: ${typeAnnotation} = ${node.default}` : `${nameStr}: ${typeAnnotation}`
-      }
-
-      return node.default ? `${nameStr} = ${node.default}` : nameStr
-    },
-    functionParameters(node) {
-      const sorted = sortParams(node.params)
-
-      return sorted
-        .map((p) => this.transform(p))
-        .filter(Boolean)
-        .join(', ')
-    },
-  },
-}))