@kubb/plugin-ts 5.0.0-alpha.9 → 5.0.0-beta.10

package/package.json

@@ -1,64 +1,64 @@
 {
   "name": "@kubb/plugin-ts",
-  "version": "5.0.0-alpha.9",
-  "description": "TypeScript code generation plugin for Kubb, transforming OpenAPI schemas into TypeScript interfaces, types, and utility functions.",
+  "version": "5.0.0-beta.10",
+  "description": "Generate TypeScript types, interfaces, and enums from your OpenAPI specification. The foundational plugin that powers type safety across the entire Kubb ecosystem.",
   "keywords": [
-    "typescript",
-    "types",
-    "type-generation",
+    "code-generation",
+    "codegen",
+    "enums",
     "interfaces",
-    "type-definitions",
-    "type-safe",
+    "kubb",
     "openapi",
     "swagger",
-    "oas",
-    "code-generator",
-    "codegen",
-    "plugins",
-    "kubb"
+    "type-generation",
+    "types",
+    "typescript"
   ],
+  "license": "MIT",
+  "author": "stijnvanhulle",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/kubb-labs/kubb.git",
+    "url": "git+https://github.com/kubb-labs/plugins.git",
     "directory": "packages/plugin-ts"
   },
-  "license": "MIT",
-  "author": "stijnvanhulle",
-  "sideEffects": false,
+  "files": [
+    "src",
+    "dist",
+    "extension.yaml",
+    "!/**/**.test.**",
+    "!/**/__tests__/**",
+    "!/**/__snapshots__/**"
+  ],
   "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "import": "./dist/index.js",
       "require": "./dist/index.cjs"
     },
-    "./components": {
-      "import": "./dist/components.js",
-      "require": "./dist/components.cjs"
-    },
-    "./generators": {
-      "import": "./dist/generators.js",
-      "require": "./dist/generators.cjs"
-    },
     "./package.json": "./package.json"
   },
-  "types": "./dist/index.d.ts",
-  "typesVersions": {
-    "*": {
-      "components": [
-        "./dist/components.d.ts"
-      ],
-      "generators": [
-        "./dist/generators.d.ts"
-      ]
-    }
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "@kubb/core": "5.0.0-beta.10",
+    "@kubb/parser-ts": "5.0.0-beta.10",
+    "@kubb/renderer-jsx": "5.0.0-beta.10",
+    "remeda": "^2.34.0",
+    "typescript": "^6.0.3"
+  },
+  "devDependencies": {
+    "@internals/shared": "0.0.0",
+    "@internals/utils": "0.0.0"
+  },
+  "peerDependencies": {
+    "@kubb/renderer-jsx": "5.0.0-beta.10"
   },
-  "files": [
-    "src",
-    "dist",
-    "!/**/**.test.**",
-    "!/**/__tests__/**",
-    "!/**/__snapshots__/**"
-  ],
   "size-limit": [
     {
       "path": "./dist/*.js",
@@ -66,36 +66,14 @@
       "gzip": true
     }
   ],
-  "dependencies": {
-    "@kubb/fabric-core": "0.14.0",
-    "@kubb/react-fabric": "0.14.0",
-    "remeda": "^2.33.6",
-    "typescript": "5.9.3",
-    "@kubb/ast": "5.0.0-alpha.9",
-    "@kubb/core": "5.0.0-alpha.9",
-    "@kubb/oas": "5.0.0-alpha.9",
-    "@kubb/plugin-oas": "5.0.0-alpha.9"
-  },
-  "peerDependencies": {
-    "@kubb/react-fabric": "0.14.0"
-  },
   "engines": {
     "node": ">=22"
   },
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org/"
-  },
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
-  "devDependencies": {
-    "@internals/utils": "0.0.0"
-  },
   "scripts": {
     "build": "tsdown && size-limit",
     "clean": "npx rimraf ./dist",
-    "lint": "bun biome lint .",
-    "lint:fix": "bun biome lint --fix --unsafe .",
+    "lint": "oxlint .",
+    "lint:fix": "oxlint --fix .",
     "release": "pnpm publish --no-git-check",
     "release:canary": "bash ../../.github/canary.sh && node ../../scripts/build.js canary && pnpm publish --no-git-check",
     "start": "tsdown --watch",

package/src/components/{v2/Enum.tsx → Enum.tsx}

@@ -1,29 +1,45 @@
-import { camelCase, pascalCase, trimQuotes } from '@internals/utils'
-import type { EnumSchemaNode } from '@kubb/ast/types'
-import { safePrint } from '@kubb/fabric-core/parsers/typescript'
-import { File } from '@kubb/react-fabric'
-import type { FabricReactNode } from '@kubb/react-fabric/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 } from '../../types.ts'
+import { camelCase, trimQuotes } from '@internals/utils'
+import type { ast } from '@kubb/core'
+import { safePrint } 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: EnumSchemaNode
+  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. `pascalCase` normalizes it unconditionally; for inline enum
- * properties the adapter already emits a PascalCase+suffix name so `pascalCase` is a no-op.
+ * 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: EnumSchemaNode, enumType: PluginTs['resolvedOptions']['enumType']): { enumName: string; typeName: string } {
-  const resolved = pascalCase(node.name!)
+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) ? `${resolved}Key` : resolved
+  const typeName = ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) ? resolver.resolveEnumKeyName(node, enumTypeSuffix) : resolved
 
   return { enumName, typeName }
 }
@@ -39,15 +55,15 @@ export function getEnumNames(node: EnumSchemaNode, enumType: PluginTs['resolvedO
  * 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, enumKeyCasing }: Props): FabricReactNode {
-  const { enumName, typeName } = getEnumNames(node, enumType)
+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 unknown as Array<[string, string]>,
+      []) as Array<[string | number, string | number | boolean]>,
     type: enumType,
     enumKeyCasing,
   })

package/src/components/Type.tsx

@@ -1,156 +1,42 @@
-import { camelCase, jsStringEscape, pascalCase, trimQuotes } from '@internals/utils'
-import { safePrint } from '@kubb/fabric-core/parsers/typescript'
-import type { SchemaObject } from '@kubb/oas'
-import { isKeyword, type Schema, SchemaGenerator, schemaKeywords } from '@kubb/plugin-oas'
-import { File } from '@kubb/react-fabric'
-import type { FabricReactNode } from '@kubb/react-fabric/types'
-import type ts from 'typescript'
-import * as factory from '../factory.ts'
-import { parse, typeKeywordMapper } from '../parser.ts'
-import type { PluginTs } from '../types.ts'
+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
-  typedName: string
-  schema: SchemaObject
-  tree: Array<Schema>
-  optionalType: PluginTs['resolvedOptions']['optionalType']
-  arrayType: PluginTs['resolvedOptions']['arrayType']
+  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']
-  syntaxType: PluginTs['resolvedOptions']['syntaxType']
-  description?: string
-  keysToOmit?: string[]
+  resolver: ResolverTs
 }
 
-export function Type({
-  name,
-  typedName,
-  tree,
-  keysToOmit,
-  schema,
-  optionalType,
-  arrayType,
-  syntaxType,
-  enumType,
-  enumKeyCasing,
-  description,
-}: Props): FabricReactNode {
-  const typeNodes: ts.Node[] = []
-
-  if (!tree.length) {
-    return ''
-  }
-
-  const schemaFromTree = tree.find((item) => item.keyword === schemaKeywords.schema)
-  const enumSchemas = SchemaGenerator.deepSearch(tree, schemaKeywords.enum)
-
-  let type =
-    (tree
-      .map((current, _index, siblings) =>
-        parse(
-          { name, schema, parent: undefined, current, siblings },
-          {
-            optionalType,
-            arrayType,
-            enumType,
-          },
-        ),
-      )
-      .filter(Boolean)
-      .at(0) as ts.TypeNode) || typeKeywordMapper.undefined()
-
-  // Add a "Key" suffix to avoid collisions where necessary
-  if (['asConst', 'asPascalConst'].includes(enumType) && enumSchemas.length > 0) {
-    const isDirectEnum = schema.type === 'array' && schema.items !== undefined
-    const isEnumOnly = 'enum' in schema && schema.enum
-
-    if (isDirectEnum || isEnumOnly) {
-      const enumSchema = enumSchemas[0]!
-      const typeNameWithKey = `${enumSchema.args.typeName}Key`
-
-      type = factory.createTypeReferenceNode(typeNameWithKey)
-
-      if (schema.type === 'array') {
-        if (arrayType === 'generic') {
-          type = factory.createTypeReferenceNode(factory.createIdentifier('Array'), [type])
-        } else {
-          type = factory.createArrayTypeNode(type)
-        }
-      }
-    }
-  }
-
-  if (schemaFromTree && isKeyword(schemaFromTree, schemaKeywords.schema)) {
-    const isNullish = tree.some((item) => item.keyword === schemaKeywords.nullish)
-    const isNullable = tree.some((item) => item.keyword === schemaKeywords.nullable)
-    const isOptional = tree.some((item) => item.keyword === schemaKeywords.optional)
+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
+    },
+  })
 
-    if (isNullable) {
-      type = factory.createUnionDeclaration({
-        nodes: [type, factory.keywordTypeNodes.null],
-      }) as ts.TypeNode
-    }
+  const output = printer.print(node)
 
-    if (isNullish && ['undefined', 'questionTokenAndUndefined'].includes(optionalType as string)) {
-      type = factory.createUnionDeclaration({
-        nodes: [type, factory.keywordTypeNodes.undefined],
-      }) as ts.TypeNode
-    }
-
-    if (isOptional && ['undefined', 'questionTokenAndUndefined'].includes(optionalType as string)) {
-      type = factory.createUnionDeclaration({
-        nodes: [type, factory.keywordTypeNodes.undefined],
-      }) as ts.TypeNode
-    }
+  if (!output) {
+    return
   }
 
-  const useTypeGeneration = syntaxType === 'type' || [factory.syntaxKind.union].includes(type.kind as typeof factory.syntaxKind.union) || !!keysToOmit?.length
-
-  typeNodes.push(
-    factory.createTypeDeclaration({
-      name,
-      isExportable: true,
-      type: keysToOmit?.length
-        ? factory.createOmitDeclaration({
-            keys: keysToOmit,
-            type,
-            nonNullable: true,
-          })
-        : type,
-      syntax: useTypeGeneration ? 'type' : 'interface',
-      comments: [
-        schema.title ? `${jsStringEscape(schema.title)}` : undefined,
-        description ? `@description ${jsStringEscape(description)}` : undefined,
-        schema.deprecated ? '@deprecated' : undefined,
-        schema.minLength ? `@minLength ${schema.minLength}` : undefined,
-        schema.maxLength ? `@maxLength ${schema.maxLength}` : undefined,
-        schema.pattern ? `@pattern ${schema.pattern}` : undefined,
-        schema.default ? `@default ${schema.default}` : undefined,
-        schema.example ? `@example ${schema.example}` : undefined,
-      ],
-    }),
-  )
-
-  const enums = [...new Set(enumSchemas)].map((enumSchema) => {
-    const name = enumType === 'asPascalConst' ? pascalCase(enumSchema.args.name) : camelCase(enumSchema.args.name)
-    const typeName = ['asConst', 'asPascalConst'].includes(enumType) ? `${enumSchema.args.typeName}Key` : enumSchema.args.typeName
-
-    const [nameNode, typeNode] = factory.createEnumDeclaration({
-      name,
-      typeName,
-      enums: enumSchema.args.items
-        .map((item) => (item.value === undefined ? undefined : [trimQuotes(item.name?.toString()), item.value]))
-        .filter(Boolean) as unknown as Array<[string, string]>,
-      type: enumType,
-      enumKeyCasing,
-    })
-
+  const enums = [...new Map(enumSchemaNodes.map((n) => [n.name, n])).values()].map((node) => {
     return {
-      nameNode,
-      typeNode,
-      name,
-      typeName,
+      node,
+      ...getEnumNames({ node, enumType, enumTypeSuffix, resolver }),
     }
   })
 
@@ -161,28 +47,12 @@ export function Type({
   return (
     <>
       {shouldExportEnums &&
-        enums.map(({ name, nameNode, typeName, typeNode }) => (
-          <>
-            {nameNode && (
-              <File.Source name={name} isExportable isIndexable isTypeOnly={false}>
-                {safePrint(nameNode)}
-              </File.Source>
-            )}
-            {
-              <File.Source
-                name={typeName}
-                isIndexable
-                isExportable={['enum', 'asConst', 'asPascalConst', 'constEnum', 'literal', undefined].includes(enumType)}
-                isTypeOnly={['asConst', 'asPascalConst', 'literal', undefined].includes(enumType)}
-              >
-                {safePrint(typeNode)}
-              </File.Source>
-            }
-          </>
+        enums.map(({ node }) => (
+          <Enum key={node.name} node={node} enumType={enumType} enumTypeSuffix={enumTypeSuffix} enumKeyCasing={enumKeyCasing} resolver={resolver} />
         ))}
       {shouldExportType && (
-        <File.Source name={typedName} isTypeOnly isExportable isIndexable>
-          {safePrint(...typeNodes)}
+        <File.Source name={name} isTypeOnly isExportable isIndexable>
+          {output}
         </File.Source>
       )}
     </>

package/src/constants.ts

@@ -27,3 +27,13 @@ export const ENUM_TYPES_WITH_RUNTIME_VALUE = new Set<EnumType | undefined>(['enu
  * `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