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

package/package.json

@@ -1,19 +1,16 @@
 {
   "name": "@kubb/plugin-ts",
-  "version": "5.0.0-beta.4",
-  "description": "TypeScript code generation plugin for Kubb, transforming OpenAPI schemas into TypeScript interfaces, types, and utility functions.",
+  "version": "5.0.0-beta.42",
+  "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-generator",
+    "code-generation",
     "codegen",
+    "enums",
     "interfaces",
     "kubb",
-    "oas",
     "openapi",
-    "plugins",
     "swagger",
-    "type-definitions",
     "type-generation",
-    "type-safe",
     "types",
     "typescript"
   ],
@@ -49,17 +46,17 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@kubb/core": "5.0.0-beta.4",
-    "@kubb/parser-ts": "5.0.0-beta.4",
-    "@kubb/renderer-jsx": "5.0.0-beta.4",
-    "remeda": "^2.34.0",
+    "@kubb/core": "5.0.0-beta.42",
+    "@kubb/parser-ts": "5.0.0-beta.42",
+    "@kubb/renderer-jsx": "5.0.0-beta.42",
     "typescript": "^6.0.3"
   },
   "devDependencies": {
+    "@internals/shared": "0.0.0",
     "@internals/utils": "0.0.0"
   },
   "peerDependencies": {
-    "@kubb/renderer-jsx": "5.0.0-beta.4"
+    "@kubb/renderer-jsx": "5.0.0-beta.42"
   },
   "size-limit": [
     {
@@ -78,6 +75,7 @@
     "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",
+    "release:stage": "pnpm stage publish --no-git-check",
     "start": "tsdown --watch",
     "test": "vitest --passWithNoTests",
     "typecheck": "tsc -p ./tsconfig.json --noEmit --emitDeclarationOnly false"

package/src/components/Enum.tsx

@@ -1,6 +1,6 @@
 import { camelCase, trimQuotes } from '@internals/utils'
 import type { ast } from '@kubb/core'
-import { safePrint } from '@kubb/parser-ts'
+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'
@@ -72,11 +72,11 @@ export function Enum({ node, enumType, enumTypeSuffix, enumKeyCasing, resolver }
     <>
       {nameNode && (
         <File.Source name={enumName} isExportable isIndexable isTypeOnly={false}>
-          {safePrint(nameNode)}
+          {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)}>
-        {safePrint(typeNode)}
+        {parserTs.print(typeNode)}
       </File.Source>
     </>
   )

package/src/factory.ts

@@ -1,11 +1,24 @@
 import { camelCase, pascalCase, screamingSnakeCase, snakeCase } from '@internals/utils'
 import { ast } from '@kubb/core'
-import { isNumber, sortBy } from 'remeda'
 import ts from 'typescript'
 import { OPTIONAL_ADDS_UNDEFINED } from './constants.ts'
 
 const { SyntaxKind, factory } = ts
 
+/**
+ * Compares two strings by UTF-16 code unit, keeping sorted output identical across platforms
+ * regardless of locale.
+ */
+function compareStrings(a: string, b: string): number {
+  if (a < b) return -1
+  if (a > b) return 1
+  return 0
+}
+
+function isNumber(value: unknown): value is number {
+  return typeof value === 'number' && !Number.isNaN(value)
+}
+
 // https://ts-ast-viewer.com/
 
 /**
@@ -27,13 +40,30 @@ export const syntaxKind = {
   stringLiteral: SyntaxKind.StringLiteral,
 } as const
 
+function isNonNullable<T>(value: T | null | undefined): value is T {
+  return value !== null && value !== undefined
+}
+
 function isValidIdentifier(str: string): boolean {
   if (!str.length || str.trim() !== str) {
     return false
   }
-  const node = ts.parseIsolatedEntityName(str, ts.ScriptTarget.Latest)
 
-  return !!node && node.kind === ts.SyntaxKind.Identifier && ts.identifierToKeywordKind(node.kind as unknown as ts.Identifier) === undefined
+  // Mirrors `ts.isIdentifierText`, which is not in the public type declarations.
+  // Walking by code point with `isIdentifierStart`/`isIdentifierPart` rejects
+  // invalid names such as private identifiers (`#FOO`), forcing `propertyName`
+  // to quote them.
+  let ch = str.codePointAt(0)!
+  if (!ts.isIdentifierStart(ch, ts.ScriptTarget.Latest)) {
+    return false
+  }
+  for (let i = ch > 0xffff ? 2 : 1; i < str.length; i += ch > 0xffff ? 2 : 1) {
+    ch = str.codePointAt(i)!
+    if (!ts.isIdentifierPart(ch, ts.ScriptTarget.Latest)) {
+      return false
+    }
+  }
+  return true
 }
 
 function propertyName(name: string | ts.PropertyName): ts.PropertyName {
@@ -158,7 +188,9 @@ export function createPropertySignature({
   type?: ts.TypeNode
 }) {
   return factory.createPropertySignature(
-    [...modifiers, readOnly ? factory.createToken(ts.SyntaxKind.ReadonlyKeyword) : undefined].filter(Boolean),
+    [...modifiers, readOnly ? factory.createToken(ts.SyntaxKind.ReadonlyKeyword) : undefined].filter(
+      (modifier): modifier is ts.Modifier => modifier !== undefined,
+    ),
     propertyName(name),
     createQuestionToken(questionToken),
     type,
@@ -192,7 +224,7 @@ export function createParameterSignature(
  * Creates a JSDoc comment node from an array of comment strings.
  * Returns null if no comments are provided.
  */
-export function createJSDoc({ comments }: { comments: string[] }) {
+export function createJSDoc({ comments }: { comments: Array<string> }) {
   if (!comments.length) {
     return null
   }
@@ -332,7 +364,7 @@ export function createTypeDeclaration({
 /**
  * Creates a TypeScript namespace declaration (exported module).
  */
-export function createNamespaceDeclaration({ statements, name }: { name: string; statements: ts.Statement[] }) {
+export function createNamespaceDeclaration({ statements, name }: { name: string; statements: Array<ts.Statement> }) {
   return factory.createModuleDeclaration(
     [factory.createToken(ts.SyntaxKind.ExportKeyword)],
     factory.createIdentifier(name),
@@ -366,13 +398,8 @@ export function createImportDeclaration({
   isNameSpace?: boolean
 }) {
   if (!Array.isArray(name)) {
-    let importPropertyName: ts.Identifier | undefined = factory.createIdentifier(name)
-    let importName: ts.NamedImportBindings | undefined
-
-    if (isNameSpace) {
-      importPropertyName = undefined
-      importName = factory.createNamespaceImport(factory.createIdentifier(name))
-    }
+    const importPropertyName = isNameSpace ? undefined : factory.createIdentifier(name)
+    const importName = isNameSpace ? factory.createNamespaceImport(factory.createIdentifier(name)) : undefined
 
     return factory.createImportDeclaration(
       undefined,
@@ -383,7 +410,7 @@ export function createImportDeclaration({
   }
 
   // Sort the imports alphabetically for consistent output across platforms
-  const sortedName = sortBy(name, [(item) => (typeof item === 'object' ? item.propertyName : item), 'asc'])
+  const sortedName = name.toSorted((a, b) => compareStrings(typeof a === 'object' ? a.propertyName : a, typeof b === 'object' ? b.propertyName : b))
 
   return factory.createImportDeclaration(
     undefined,
@@ -442,7 +469,7 @@ export function createExportDeclaration({
   }
 
   // Sort the exports alphabetically for consistent output across platforms
-  const sortedName = sortBy(name, [(propertyName) => (typeof propertyName === 'string' ? propertyName : propertyName.text), 'asc'])
+  const sortedName = name.toSorted((a, b) => compareStrings(typeof a === 'string' ? a : a.text, typeof b === 'string' ? b : b.text))
 
   return factory.createExportDeclaration(
     undefined,
@@ -518,7 +545,7 @@ export function createEnumDeclaration({
    * Enum name in PascalCase.
    */
   typeName: string
-  enums: [key: string | number, value: string | number | boolean][]
+  enums: Array<[key: string | number, value: string | number | boolean]>
   /**
    * Choose the casing for enum key names.
    * @default 'none'
@@ -553,7 +580,7 @@ export function createEnumDeclaration({
 
               return undefined
             })
-            .filter(Boolean),
+            .filter((node): node is ts.LiteralTypeNode => node !== undefined),
         ),
       ),
     ]
@@ -563,7 +590,9 @@ export function createEnumDeclaration({
     return [
       undefined,
       factory.createEnumDeclaration(
-        [factory.createToken(ts.SyntaxKind.ExportKeyword), type === 'constEnum' ? factory.createToken(ts.SyntaxKind.ConstKeyword) : undefined].filter(Boolean),
+        [factory.createToken(ts.SyntaxKind.ExportKeyword), type === 'constEnum' ? factory.createToken(ts.SyntaxKind.ConstKeyword) : undefined].filter(
+          (modifier): modifier is ts.ModifierToken<ts.SyntaxKind.ExportKeyword> | ts.ModifierToken<ts.SyntaxKind.ConstKeyword> => modifier !== undefined,
+        ),
         factory.createIdentifier(typeName),
         enums
           .map(([key, value]) => {
@@ -594,7 +623,7 @@ export function createEnumDeclaration({
 
             return undefined
           })
-          .filter(Boolean),
+          .filter((member): member is ts.EnumMember => member !== undefined),
       ),
     ]
   }
@@ -657,7 +686,7 @@ export function createEnumDeclaration({
 
                     return undefined
                   })
-                  .filter(Boolean),
+                  .filter((property): property is ts.PropertyAssignment => property !== undefined),
                 true,
               ),
               factory.createTypeReferenceNode(factory.createIdentifier('const'), undefined),
@@ -737,8 +766,8 @@ export function createUrlTemplateType(path: string): ts.TypeNode {
   }
 
   const segments = normalized.split(/(\{[^}]+\})/)
-  const parts: string[] = []
-  const parameterIndices: number[] = []
+  const parts: Array<string> = []
+  const parameterIndices: Array<number> = []
 
   segments.forEach((segment) => {
     if (segment.startsWith('{') && segment.endsWith('}')) {
@@ -750,7 +779,7 @@ export function createUrlTemplateType(path: string): ts.TypeNode {
   })
 
   const head = ts.factory.createTemplateHead(parts[0] || '')
-  const templateSpans: ts.TemplateLiteralTypeSpan[] = []
+  const templateSpans: Array<ts.TemplateLiteralTypeSpan> = []
 
   parameterIndices.forEach((paramIndex, i) => {
     const isLast = i === parameterIndices.length - 1
@@ -885,7 +914,7 @@ export function buildMemberNodes(
   members: Array<ast.SchemaNode> | undefined,
   print: (node: ast.SchemaNode) => ts.TypeNode | null | undefined,
 ): Array<ts.TypeNode> {
-  return (members ?? []).map(print).filter(Boolean)
+  return (members ?? []).map(print).filter(isNonNullable)
 }
 
 /**
@@ -893,7 +922,7 @@ export function buildMemberNodes(
  * applying min/max slice and optional/rest element rules.
  */
 export function buildTupleNode(node: ast.ArraySchemaNode, print: (node: ast.SchemaNode) => ts.TypeNode | null | undefined): ts.TypeNode | undefined {
-  let items = (node.items ?? []).map(print).filter(Boolean)
+  let items = (node.items ?? []).map(print).filter(isNonNullable)
 
   const restNode = node.rest ? (print(node.rest) ?? undefined) : undefined
   const { min, max } = node

package/src/generators/typeGenerator.tsx

@@ -1,14 +1,21 @@
+import { resolveContentTypeVariants } from '@internals/shared'
 import { ast, defineGenerator } from '@kubb/core'
-import { File, jsxRenderer } from '@kubb/renderer-jsx'
+import { File, jsxRendererSync } 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'
 
+/**
+ * Built-in generator for `@kubb/plugin-ts`. Emits one TypeScript file per
+ * schema in the spec plus per-operation request, response, and parameter
+ * types. Drop-replace with a custom `Generator<PluginTs>` to change how
+ * TypeScript output is produced.
+ */
 export const typeGenerator = defineGenerator<PluginTs>({
   name: 'typescript',
-  renderer: jsxRenderer,
+  renderer: jsxRendererSync,
   schema(node, ctx) {
     const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, printer } = ctx.options
     const { adapter, config, resolver, root } = ctx
@@ -19,7 +26,7 @@ export const typeGenerator = defineGenerator<PluginTs>({
     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!))
+    const enumSchemaNames = new Set<string>(ctx.meta.enumNames)
 
     function resolveImportName(schemaName: string): string {
       if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && enumTypeSuffix && enumSchemaNames.has(schemaName)) {
@@ -30,14 +37,14 @@ export const typeGenerator = defineGenerator<PluginTs>({
 
     const imports = adapter.getImports(node, (schemaName) => ({
       name: resolveImportName(schemaName),
-      path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
+      path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group: group ?? undefined }).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 }),
+      file: resolver.resolveFile({ name: node.name, extname: '.ts' }, { root, output, group: group ?? undefined }),
     } as const
 
     const schemaPrinter = printerTs({
@@ -58,8 +65,8 @@ export const typeGenerator = defineGenerator<PluginTs>({
         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 })}
+        banner={resolver.resolveBanner(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}
+        footer={resolver.resolveFooter(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}
       >
         {mode === 'split' &&
           imports.map((imp) => (
@@ -86,12 +93,15 @@ export const typeGenerator = defineGenerator<PluginTs>({
     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 }),
+      file: resolver.resolveFile(
+        { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
+        { root, output, group: group ?? undefined },
+      ),
     } 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!))
+    const enumSchemaNames = new Set<string>(ctx.meta.enumNames)
 
     function resolveImportName(schemaName: string): string {
       if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && enumTypeSuffix && enumSchemaNames.has(schemaName)) {
@@ -100,12 +110,12 @@ export const typeGenerator = defineGenerator<PluginTs>({
       return resolver.resolveTypeName(schemaName)
     }
 
-    function renderSchemaType({ schema, name, keysToOmit }: { schema: ast.SchemaNode | null; name: string; keysToOmit?: Array<string> }) {
+    function renderSchemaType({ schema, name, keysToOmit }: { schema: ast.SchemaNode | null; name: string; keysToOmit?: Array<string> | null }) {
       if (!schema) return null
 
       const imports = adapter.getImports(schema, (schemaName) => ({
         name: resolveImportName(schemaName),
-        path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
+        path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group: group ?? undefined }).path,
       }))
 
       const schemaPrinter = printerTs({
@@ -141,6 +151,34 @@ export const typeGenerator = defineGenerator<PluginTs>({
       )
     }
 
+    /**
+     * Emits an individual type per content type plus a union alias under `baseName`.
+     * Shared by the request body and multi-content-type responses.
+     */
+    function buildContentTypeVariants(
+      entries: Array<{ contentType: string; schema?: ast.SchemaNode | null; keysToOmit?: Array<string> | null }>,
+      baseName: string,
+      decorate?: (schema: ast.SchemaNode) => ast.SchemaNode,
+    ) {
+      const variants = resolveContentTypeVariants(entries, baseName)
+      const unionSchema = ast.createSchema({
+        type: 'union',
+        members: variants.map((variant) => ast.createSchema({ type: 'ref', name: variant.name })),
+      })
+      return (
+        <>
+          {variants.map((variant) =>
+            renderSchemaType({
+              schema: decorate ? decorate(variant.schema) : variant.schema,
+              name: variant.name,
+              keysToOmit: variant.keysToOmit,
+            }),
+          )}
+          {renderSchemaType({ schema: unionSchema, name: baseName })}
+        </>
+      )
+    }
+
     const paramTypes = params.map((param) =>
       renderSchemaType({
         schema: param.schema,
@@ -148,24 +186,44 @@ export const typeGenerator = defineGenerator<PluginTs>({
       }),
     )
 
-    const requestType = node.requestBody?.content?.[0]?.schema
-      ? renderSchemaType({
+    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: {
-            ...node.requestBody.content![0]!.schema!,
-            description: node.requestBody.description ?? node.requestBody.content![0]!.schema!.description,
+            ...entry.schema,
+            description: node.requestBody!.description ?? entry.schema.description,
           },
           name: resolver.resolveDataName(node),
-          keysToOmit: node.requestBody.content![0]!.keysToOmit,
+          keysToOmit: entry.keysToOmit,
         })
-      : null
+      }
+      // Multiple content types — generate individual types + union alias
+      return buildContentTypeVariants(requestBodyContent, resolver.resolveDataName(node), (schema) => ({
+        ...schema,
+        description: node.requestBody!.description ?? schema.description,
+      }))
+    }
 
-    const responseTypes = node.responses.map((res) =>
-      renderSchemaType({
-        schema: res.schema,
+    const requestType = buildRequestType()
+
+    const responseTypes = node.responses.map((res) => {
+      const variants = (res.content ?? []).filter((entry) => entry.schema)
+      // Multiple content types for a single status code — generate a union of the variants.
+      if (variants.length > 1) {
+        return buildContentTypeVariants(variants, resolver.resolveResponseStatusName(node, res.statusCode))
+      }
+      const primary = variants[0] ?? res.content?.[0]
+      return renderSchemaType({
+        schema: primary?.schema ?? null,
         name: resolver.resolveResponseStatusName(node, res.statusCode),
-        keysToOmit: res.keysToOmit,
-      }),
-    )
+        keysToOmit: primary?.keysToOmit,
+      })
+    })
 
     const dataType = renderSchemaType({
       schema: buildData({ ...node, parameters: params }, { resolver }),
@@ -177,26 +235,27 @@ export const typeGenerator = defineGenerator<PluginTs>({
       name: resolver.resolveResponsesName(node),
     })
 
-    const responseType = (() => {
-      if (!node.responses.some((res) => res.schema)) {
+    function buildResponseType() {
+      const hasSchema = (res: ast.ResponseNode) => (res.content ?? []).some((entry) => entry.schema)
+      if (!node.responses.some(hasSchema)) {
         return null
       }
 
       const responseName = resolver.resolveResponseName(node)
 
-      // Skip generating the response union type when an imported component schema
-      // has the same resolved name to avoid redeclaration errors.
-      const responsesWithSchema = node.responses.filter((res) => res.schema)
+      const responsesWithSchema = node.responses.filter(hasSchema)
       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]))
-            : [],
+          (res.content ?? []).flatMap((entry) =>
+            entry.schema
+              ? adapter
+                  .getImports(entry.schema, (schemaName) => ({
+                    name: resolveImportName(schemaName),
+                    path: '',
+                  }))
+                  .flatMap((imp) => (Array.isArray(imp.name) ? imp.name : [imp.name]))
+              : [],
+          ),
         ),
       )
 
@@ -211,15 +270,17 @@ export const typeGenerator = defineGenerator<PluginTs>({
         },
         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 })}
+        banner={resolver.resolveBanner(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}
+        footer={resolver.resolveFooter(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}
       >
         {paramTypes}
         {responseTypes}

package/src/plugin.ts

@@ -1,27 +1,36 @@
-import { camelCase } from '@internals/utils'
-import { definePlugin, type Group } from '@kubb/core'
+import { createGroupConfig } from '@internals/shared'
+import { definePlugin } 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.
+ * Canonical plugin name for `@kubb/plugin-ts`. Used for driver lookups and
+ * cross-plugin dependency references.
  */
 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`.
+ * Generates TypeScript `type` aliases and `interface` declarations from an
+ * OpenAPI spec. The foundation that every other Kubb plugin builds on:
+ * clients, query hooks, mocks, and validators all reference the names this
+ * plugin produces.
  *
  * @example
  * ```ts
- * import pluginTs from '@kubb/plugin-ts'
+ * import { defineConfig } from 'kubb'
+ * import { pluginTs } from '@kubb/plugin-ts'
  *
  * export default defineConfig({
- *   plugins: [pluginTs({ output: { path: 'types' }, enumType: 'asConst' })],
+ *   input: { path: './petStore.yaml' },
+ *   output: { path: './src/gen' },
+ *   plugins: [
+ *     pluginTs({
+ *       output: { path: './types' },
+ *       enumType: 'asConst',
+ *       optionalType: 'questionTokenAndUndefined',
+ *     }),
+ *   ],
  * })
  * ```
  */
@@ -45,17 +54,7 @@ export const pluginTs = definePlugin<PluginTs>((options) => {
     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
+  const groupConfig = createGroupConfig(group, { suffix: 'Controller' })
 
   return {
     name: pluginTsName,

package/src/printers/functionPrinter.ts

@@ -64,11 +64,11 @@ function rank(param: ast.FunctionParameterNode | ast.ParameterGroupNode): number
 }
 
 function sortParams(params: ReadonlyArray<ast.FunctionParameterNode | ast.ParameterGroupNode>): Array<ast.FunctionParameterNode | ast.ParameterGroupNode> {
-  return [...params].sort((a, b) => rank(a) - rank(b))
+  return params.toSorted((a, b) => rank(a) - rank(b))
 }
 
 function sortChildParams(params: Array<ast.FunctionParameterNode>): Array<ast.FunctionParameterNode> {
-  return [...params].sort((a, b) => rank(a) - rank(b))
+  return params.toSorted((a, b) => rank(a) - rank(b))
 }
 
 /**