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

package/src/types.ts

@@ -1,4 +1,4 @@
-import type { ast, Exclude, Generator, Group, Include, Output, Override, PluginFactoryOptions, Resolver } from '@kubb/core'
+import type { ast, Exclude, Generator, Group, Include, Output, OutputOptions, Override, PluginFactoryOptions, Resolver } from '@kubb/core'
 import type { PrinterTsNodes } from './printers/printerTs.ts'
 /**
  * The concrete resolver type for `@kubb/plugin-ts`.
@@ -93,34 +93,49 @@ export type ResolverTs = Resolver &
 
 type EnumKeyCasing = 'screamingSnakeCase' | 'snakeCase' | 'pascalCase' | 'camelCase' | 'none'
 
+type EnumConstCasing = 'camelCase' | 'pascalCase'
+
 /**
- * Discriminated union that ties `enumTypeSuffix` and `enumKeyCasing` to the enum types that actually use them.
+ * Grouped enum settings. Each `type` uses only some of the other fields.
+ *
+ * - `'asConst'` emits a `const` object plus a `typeof` type alias, so `constCasing`, `typeSuffix`, and `keyCasing` all apply.
+ * - `'enum'` and `'constEnum'` emit a TypeScript enum, so only `keyCasing` (the member names) applies.
+ * - `'literal'` and `'inlineLiteral'` emit union literals and drop the keys, so none of the other fields apply.
  *
- * - `'asConst'` / `'asPascalConst'` — emit a `const` object; both `enumTypeSuffix` (type-alias suffix) and
- *    `enumKeyCasing` (key formatting) are meaningful.
- * - `'enum'` / `'constEnum'` — emit a TypeScript enum; `enumKeyCasing` applies to member names,
- *    but there is no separate type alias so `enumTypeSuffix` is not used.
- * - `'literal'` / `'inlineLiteral'` — emit only union literals; keys are discarded entirely,
- *    so neither `enumTypeSuffix` nor `enumKeyCasing` have any effect.
+ * @example Share one name between the const and the type
+ * ```ts
+ * enum: { type: 'asConst', constCasing: 'pascalCase', typeSuffix: '' }
+ * // export const VehicleType = { … } as const
+ * // export type VehicleType = (typeof VehicleType)[keyof typeof VehicleType]
+ * ```
  */
-type EnumTypeOptions =
+type EnumOptions =
   | {
       /**
-       * Choose to use enum, asConst, asPascalConst, constEnum, literal, or inlineLiteral for enums.
-       * - 'asConst' generates const objects with camelCase names and as const assertion.
-       * - 'asPascalConst' generates const objects with PascalCase names and as const assertion.
+       * Emit a `const` object asserted with `as const`, paired with a `typeof` type alias.
+       * This is tree-shakeable and adds no enum runtime.
+       *
        * @default 'asConst'
        */
-      enumType?: 'asConst' | 'asPascalConst'
+      type?: 'asConst'
       /**
-       * Suffix appended to the generated type alias name.
+       * Casing of the generated const variable.
+       * - 'camelCase' names the const `vehicleType`.
+       * - 'pascalCase' names the const `VehicleType`, matching the schema name.
        *
-       * Only affects the type alias; the const object name is unchanged.
+       * @default 'camelCase'
+       */
+      constCasing?: EnumConstCasing
+      /**
+       * Suffix appended to the generated type alias name. Only the type alias is renamed. The const
+       * object name stays the same. Set it to `''` together with `constCasing: 'pascalCase'` to merge
+       * the const and type under the schema's exact name.
        *
        * @default 'Key'
-       * @example enumTypeSuffix: 'Value' → `export type PetStatusValue = …`
+       * @example A custom suffix
+       * `typeSuffix: 'Value'` renames the alias to `PetStatusValue`
        */
-      enumTypeSuffix?: string
+      typeSuffix?: string
       /**
        * Choose the casing for enum key names.
        * - 'screamingSnakeCase' generates keys in SCREAMING_SNAKE_CASE format.
@@ -130,23 +145,25 @@ type EnumTypeOptions =
        * - 'none' uses the enum value as-is without transformation.
        * @default 'none'
        */
-      enumKeyCasing?: EnumKeyCasing
+      keyCasing?: EnumKeyCasing
     }
   | {
       /**
-       * Choose to use enum, asConst, asPascalConst, constEnum, literal, or inlineLiteral for enums.
-       * - 'enum' generates TypeScript enum declarations.
-       * - 'constEnum' generates TypeScript const enum declarations.
+       * Emit a TypeScript `enum` (`'enum'`) or `const enum` (`'constEnum'`) declaration.
+       *
        * @default 'asConst'
        */
-      enumType?: 'enum' | 'constEnum'
+      type?: 'enum' | 'constEnum'
       /**
-       * `enumTypeSuffix` has no effect for this `enumType`.
-       * It is only used when `enumType` is `'asConst'` or `'asPascalConst'`.
+       * `constCasing` has no effect for this `type`. Only `'asConst'` emits a const object.
        */
-      enumTypeSuffix?: never
+      constCasing?: never
       /**
-       * Choose the casing for enum key names.
+       * `typeSuffix` has no effect for this `type`. Only `'asConst'` emits a separate type alias.
+       */
+      typeSuffix?: never
+      /**
+       * Choose the casing for enum member names.
        * - 'screamingSnakeCase' generates keys in SCREAMING_SNAKE_CASE format.
        * - 'snakeCase' generates keys in snake_case format.
        * - 'pascalCase' generates keys in PascalCase format.
@@ -154,45 +171,39 @@ type EnumTypeOptions =
        * - 'none' uses the enum value as-is without transformation.
        * @default 'none'
        */
-      enumKeyCasing?: EnumKeyCasing
+      keyCasing?: EnumKeyCasing
     }
   | {
       /**
-       * Choose to use enum, asConst, asPascalConst, constEnum, literal, or inlineLiteral for enums.
-       * - 'literal' generates literal union types.
-       * - 'inlineLiteral' will inline enum values directly into the type (default in v5).
+       * Emit a union of literals as a named alias (`'literal'`) or inline the union at every usage
+       * site (`'inlineLiteral'`).
+       *
        * @default 'asConst'
        * @note In Kubb v5, 'inlineLiteral' becomes the default.
        */
-      enumType?: 'literal' | 'inlineLiteral'
+      type?: 'literal' | 'inlineLiteral'
       /**
-       * `enumTypeSuffix` has no effect for this `enumType`.
-       * It is only used when `enumType` is `'asConst'` or `'asPascalConst'`.
+       * `constCasing` has no effect for this `type`; literal modes emit no const object.
        */
-      enumTypeSuffix?: never
+      constCasing?: never
       /**
-       * `enumKeyCasing` has no effect for this `enumType`.
-       * Literal and inlineLiteral modes emit only values; keys are discarded entirely.
+       * `typeSuffix` has no effect for this `type`; literal modes emit no separate type alias.
        */
-      enumKeyCasing?: never
+      typeSuffix?: never
+      /**
+       * `keyCasing` has no effect for this `type`. Literal and inlineLiteral modes emit only values,
+       * so the keys are discarded.
+       */
+      keyCasing?: never
     }
 
-export type Options = {
-  /**
-   * Where the generated `.ts` files are written and how they are exported.
-   *
-   * @default { path: 'types', barrel: { type: 'named' } }
-   */
-  output?: Output
-  /**
-   * Media type read from the OpenAPI spec when an operation defines several.
-   * Defaults to the first JSON-compatible media type Kubb finds.
-   */
-  contentType?: 'application/json' | (string & {})
-  /**
-   * Split generated files into subfolders based on the operation's tag.
-   */
-  group?: Group
+/**
+ * Where the generated `.ts` files are written and how they are exported, plus the optional
+ * `group` strategy. The `group` option organizes `output.mode: 'directory'` output into per-tag or per-path subdirectories.
+ *
+ * @default { path: 'types', barrel: { type: 'named' } }
+ */
+export type Options = OutputOptions & {
   /**
    * Skip operations matching at least one entry in the list.
    */
@@ -286,7 +297,18 @@ export type Options = {
   printer?: {
     nodes?: PrinterTsNodes
   }
-} & EnumTypeOptions
+  /**
+   * How OpenAPI enums are represented in the generated TypeScript, and how their names are cased.
+   */
+  enum?: EnumOptions
+}
+
+type ResolvedEnumOptions = {
+  type: NonNullable<EnumOptions['type']>
+  constCasing: EnumConstCasing
+  typeSuffix: string
+  keyCasing: EnumKeyCasing
+}
 
 type ResolvedOptions = {
   output: Output
@@ -294,9 +316,7 @@ type ResolvedOptions = {
   include: Array<Include> | undefined
   override: Array<Override<ResolvedOptions>>
   group: Group | null
-  enumType: NonNullable<Options['enumType']>
-  enumTypeSuffix: NonNullable<Options['enumTypeSuffix']>
-  enumKeyCasing: EnumKeyCasing
+  enum: ResolvedEnumOptions
   optionalType: NonNullable<Options['optionalType']>
   arrayType: NonNullable<Options['arrayType']>
   syntaxType: NonNullable<Options['syntaxType']>

package/src/utils.ts

@@ -1,4 +1,4 @@
-import { jsStringEscape, stringify } from '@internals/utils'
+import { jsStringEscape, stringify } from '@kubb/ast/utils'
 import { getOperationParameters } from '@internals/shared'
 import { ast } from '@kubb/core'
 import type { ResolverTs } from './types.ts'