@kubb/plugin-ts 5.0.0-beta.56 → 5.0.0-beta.64

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-ts",
-  "version": "5.0.0-beta.56",
+  "version": "5.0.0-beta.64",
   "description": "Generate TypeScript types, interfaces, and enums from your OpenAPI specification. The foundational plugin that powers type safety across the entire Kubb ecosystem.",
   "keywords": [
     "code-generation",
@@ -22,7 +22,6 @@
     "directory": "packages/plugin-ts"
   },
   "files": [
-    "src",
     "dist",
     "!/**/**.test.**",
     "!/**/__tests__/**",
@@ -45,10 +44,10 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@kubb/ast": "5.0.0-beta.55",
-    "@kubb/core": "5.0.0-beta.55",
-    "@kubb/parser-ts": "5.0.0-beta.55",
-    "@kubb/renderer-jsx": "5.0.0-beta.55",
+    "@kubb/ast": "5.0.0-beta.63",
+    "@kubb/core": "5.0.0-beta.63",
+    "@kubb/parser-ts": "5.0.0-beta.63",
+    "@kubb/renderer-jsx": "5.0.0-beta.63",
     "typescript": "^6.0.3"
   },
   "devDependencies": {
@@ -56,7 +55,7 @@
     "@internals/utils": "0.0.0"
   },
   "peerDependencies": {
-    "@kubb/renderer-jsx": "5.0.0-beta.55"
+    "@kubb/renderer-jsx": "5.0.0-beta.63"
   },
   "engines": {
     "node": ">=22"

package/src/components/Enum.tsx

@@ -1,87 +0,0 @@
-import { camelCase } from '@internals/utils'
-import { trimQuotes } from '@kubb/ast/utils'
-import type { ast } from '@kubb/core'
-import { parserTs } from '@kubb/parser-ts'
-import { File } from '@kubb/renderer-jsx'
-import type { KubbReactNode } from '@kubb/renderer-jsx/types'
-import { ENUM_TYPES_WITH_KEY_SUFFIX, ENUM_TYPES_WITH_RUNTIME_VALUE, ENUM_TYPES_WITH_TYPE_ONLY } from '../constants.ts'
-import * as factory from '../factory.ts'
-import type { PluginTs, ResolverTs } from '../types.ts'
-
-type EnumOptions = PluginTs['resolvedOptions']['enum']
-
-type Props = {
-  node: ast.EnumSchemaNode
-  enum: EnumOptions
-  resolver: ResolverTs
-  key?: string | number | null
-}
-
-/**
- * Resolves the runtime identifier name and the TypeScript type name for an enum schema node.
- *
- * The raw `node.name` may be a YAML key such as `"enumNames.Type"` which is not a
- * valid TypeScript identifier. The resolver normalizes it. For inline enum properties the adapter
- * already emits a PascalCase+suffix name, so resolution is typically a no-op.
- *
- * When `constCasing` is `'pascalCase'` and `typeSuffix` is empty, the const and the type
- * resolve to the same name, which TypeScript merges into a single value+type declaration.
- */
-export function getEnumNames({ node, enum: enumOptions, resolver }: { node: ast.EnumSchemaNode; enum: EnumOptions; resolver: ResolverTs }): {
-  enumName: string
-  typeName: string
-} {
-  const resolved = resolver.default(node.name!, 'type')
-  const enumName = enumOptions.constCasing === 'pascalCase' ? resolved : camelCase(node.name!)
-  const typeName = ENUM_TYPES_WITH_KEY_SUFFIX.has(enumOptions.type) ? resolver.resolveEnumKeyName(node, enumOptions.typeSuffix) : resolved
-
-  return { enumName, typeName }
-}
-
-/**
- * Renders the enum declaration(s) for a single named `EnumSchemaNode`.
- *
- * Depending on `enum.type` this may emit:
- * - A runtime object (`asConst`) plus a `typeof` type alias
- * - A `const enum` or plain `enum` declaration (`constEnum` / `enum`)
- * - A union literal type alias (`literal`)
- *
- * The emitted `File.Source` nodes carry the resolved names so that the barrel
- * index picks up the correct export identifiers.
- */
-export function Enum({ node, enum: enumOptions, resolver }: Props): KubbReactNode {
-  const { enumName, typeName } = getEnumNames({ node, enum: enumOptions, resolver })
-
-  const [nameNode, typeNode] = factory.createEnumDeclaration({
-    name: enumName,
-    typeName,
-    enums: (node.namedEnumValues?.map((v) => [trimQuotes(v.name.toString()), v.value]) ??
-      node.enumValues?.filter((v): v is NonNullable<typeof v> => v !== null && v !== undefined).map((v) => [trimQuotes(v.toString()), v]) ??
-      []) as Array<[string | number, string | number | boolean]>,
-    type: enumOptions.type,
-    enumKeyCasing: enumOptions.keyCasing,
-  })
-
-  // When the const and the type share a name (pascalCase const + empty typeSuffix) they merge into
-  // one declaration. The const carries the barrel export, so keep the type alias in the file but out
-  // of the barrel to avoid re-exporting the name a second time as `export type { … }`.
-  const namesMerge = !!nameNode && enumName === typeName
-
-  return (
-    <>
-      {nameNode && (
-        <File.Source name={enumName} isExportable isIndexable isTypeOnly={false}>
-          {parserTs.print(nameNode)}
-        </File.Source>
-      )}
-      <File.Source
-        name={typeName}
-        isIndexable={!namesMerge}
-        isExportable={!namesMerge && ENUM_TYPES_WITH_RUNTIME_VALUE.has(enumOptions.type)}
-        isTypeOnly={ENUM_TYPES_WITH_TYPE_ONLY.has(enumOptions.type)}
-      >
-        {parserTs.print(typeNode)}
-      </File.Source>
-    </>
-  )
-}

package/src/components/Type.tsx

@@ -1,55 +0,0 @@
-import { ast } from '@kubb/core'
-import { File } from '@kubb/renderer-jsx'
-import type { KubbReactNode } from '@kubb/renderer-jsx/types'
-import type { PrinterTsFactory } from '../printers/printerTs.ts'
-import type { PluginTs, ResolverTs } from '../types.ts'
-import { Enum, getEnumNames } from './Enum.tsx'
-
-type Props = {
-  name: string
-  node: ast.SchemaNode
-  /**
-   * Pre-configured printer instance created by the generator.
-   * Created with `printerTs({ ..., nodes: options.printer?.nodes })`.
-   */
-  printer: ast.Printer<PrinterTsFactory>
-  enum: PluginTs['resolvedOptions']['enum']
-  resolver: ResolverTs
-}
-
-export function Type({ name, node, printer, enum: enumOptions, resolver }: Props): KubbReactNode {
-  const enumSchemaNodes = ast.collect<ast.EnumSchemaNode>(node, {
-    schema(n): ast.EnumSchemaNode | undefined {
-      const enumNode = ast.narrowSchema(n, ast.schemaTypes.enum)
-      if (enumNode?.name) return enumNode
-    },
-  })
-
-  const output = printer.print(node)
-
-  if (!output) {
-    return
-  }
-
-  const enums = [...new Map(enumSchemaNodes.map((n) => [n.name, n])).values()].map((node) => {
-    return {
-      node,
-      ...getEnumNames({ node, enum: enumOptions, resolver }),
-    }
-  })
-
-  // Skip enum exports when using inlineLiteral
-  const shouldExportEnums = enumOptions.type !== 'inlineLiteral'
-  const shouldExportType = enumOptions.type === 'inlineLiteral' || enums.every((item) => item.typeName !== name)
-
-  return (
-    <>
-      {shouldExportEnums && enums.map(({ node }) => <Enum key={node.name} node={node} enum={enumOptions} resolver={resolver} />)}
-      {shouldExportType && (
-        <File.Source name={name} isTypeOnly isExportable isIndexable>
-          {output}
-        </File.Source>
-      )}
-    </>
-  )
-}

package/src/constants.ts

@@ -1,39 +0,0 @@
-import type { PluginTs } from './types.ts'
-
-type OptionalType = PluginTs['resolvedOptions']['optionalType']
-type EnumType = PluginTs['resolvedOptions']['enum']['type']
-
-/**
- * `optionalType` values that cause a property's type to include `| undefined`.
- */
-export const OPTIONAL_ADDS_UNDEFINED = new Set<OptionalType>(['undefined', 'questionTokenAndUndefined'] as const)
-
-/**
- * `optionalType` values that render the property key with a `?` token.
- */
-export const OPTIONAL_ADDS_QUESTION_TOKEN = new Set<OptionalType>(['questionToken', 'questionTokenAndUndefined'] as const)
-
-/**
- * `enum.type` values that append a `typeSuffix` to the generated enum type alias.
- */
-export const ENUM_TYPES_WITH_KEY_SUFFIX = new Set<EnumType>(['asConst'] as const)
-
-/**
- * `enum.type` values that require a runtime value declaration (object, enum, or literal).
- */
-export const ENUM_TYPES_WITH_RUNTIME_VALUE = new Set<EnumType | undefined>(['enum', 'asConst', 'constEnum', 'literal', undefined] as const)
-
-/**
- * `enum.type` values whose type declaration is type-only (no runtime value emitted for the type alias).
- */
-export const ENUM_TYPES_WITH_TYPE_ONLY = new Set<EnumType | undefined>(['asConst', 'literal', undefined] as const)
-
-/**
- * Ordering priority for function parameters: lower = sorted earlier.
- */
-export const PARAM_RANK = {
-  required: 0,
-  optional: 1,
-  withDefault: 2,
-  rest: 3,
-} as const