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

package/src/components/Enum.tsx

@@ -1,83 +0,0 @@
-import { camelCase, trimQuotes } from '@internals/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 Props = {
-  node: ast.EnumSchemaNode
-  enumType: PluginTs['resolvedOptions']['enumType']
-  enumTypeSuffix: PluginTs['resolvedOptions']['enumTypeSuffix']
-  enumKeyCasing: PluginTs['resolvedOptions']['enumKeyCasing']
-  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.
- */
-export function getEnumNames({
-  node,
-  enumType,
-  enumTypeSuffix,
-  resolver,
-}: {
-  node: ast.EnumSchemaNode
-  enumType: PluginTs['resolvedOptions']['enumType']
-  enumTypeSuffix: PluginTs['resolvedOptions']['enumTypeSuffix']
-  resolver: ResolverTs
-}): {
-  enumName: string
-  typeName: string
-} {
-  const resolved = resolver.default(node.name!, 'type')
-  const enumName = enumType === 'asPascalConst' ? resolved : camelCase(node.name!)
-  const typeName = ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) ? resolver.resolveEnumKeyName(node, enumTypeSuffix) : resolved
-
-  return { enumName, typeName }
-}
-
-/**
- * Renders the enum declaration(s) for a single named `EnumSchemaNode`.
- *
- * Depending on `enumType` this may emit:
- * - A runtime object (`asConst` / `asPascalConst`) 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, enumType, enumTypeSuffix, enumKeyCasing, resolver }: Props): KubbReactNode {
-  const { enumName, typeName } = getEnumNames({ node, enumType, enumTypeSuffix, 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: enumType,
-    enumKeyCasing,
-  })
-
-  return (
-    <>
-      {nameNode && (
-        <File.Source name={enumName} isExportable isIndexable isTypeOnly={false}>
-          {parserTs.print(nameNode)}
-        </File.Source>
-      )}
-      <File.Source name={typeName} isIndexable isExportable={ENUM_TYPES_WITH_RUNTIME_VALUE.has(enumType)} isTypeOnly={ENUM_TYPES_WITH_TYPE_ONLY.has(enumType)}>
-        {parserTs.print(typeNode)}
-      </File.Source>
-    </>
-  )
-}

package/src/components/Type.tsx

@@ -1,60 +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>
-  enumType: PluginTs['resolvedOptions']['enumType']
-  enumTypeSuffix: PluginTs['resolvedOptions']['enumTypeSuffix']
-  enumKeyCasing: PluginTs['resolvedOptions']['enumKeyCasing']
-  resolver: ResolverTs
-}
-
-export function Type({ name, node, printer, enumType, enumTypeSuffix, enumKeyCasing, 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, enumType, enumTypeSuffix, resolver }),
-    }
-  })
-
-  // Skip enum exports when using inlineLiteral
-  const shouldExportEnums = enumType !== 'inlineLiteral'
-  const shouldExportType = enumType === 'inlineLiteral' || enums.every((item) => item.typeName !== name)
-
-  return (
-    <>
-      {shouldExportEnums &&
-        enums.map(({ node }) => (
-          <Enum key={node.name} node={node} enumType={enumType} enumTypeSuffix={enumTypeSuffix} enumKeyCasing={enumKeyCasing} 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']['enumType']
-
-/**
- * `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)
-
-/**
- * `enumType` values that append a `Key` suffix to the generated enum type alias.
- */
-export const ENUM_TYPES_WITH_KEY_SUFFIX = new Set<EnumType>(['asConst', 'asPascalConst'] as const)
-
-/**
- * `enumType` values that require a runtime value declaration (object, enum, or literal).
- */
-export const ENUM_TYPES_WITH_RUNTIME_VALUE = new Set<EnumType | undefined>(['enum', 'asConst', 'asPascalConst', 'constEnum', 'literal', undefined] as const)
-
-/**
- * `enumType` 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', 'asPascalConst', '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