@kubb/plugin-ts 5.0.0-alpha.2 → 5.0.0-alpha.21

package/src/components/Enum.tsx

@@ -0,0 +1,83 @@
+import { camelCase, 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, ResolverTs } from '../types.ts'
+
+type Props = {
+  node: EnumSchemaNode
+  enumType: PluginTs['resolvedOptions']['enumType']
+  enumKeyCasing: PluginTs['resolvedOptions']['enumKeyCasing']
+  resolver: ResolverTs
+}
+
+/**
+ * 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, resolver }: { node: EnumSchemaNode; enumType: PluginTs['resolvedOptions']['enumType']; resolver: ResolverTs }): {
+  enumName: string
+  typeName: string
+  /**
+   * The PascalCase name that `$ref` importers will use to reference this enum type.
+   * For `asConst`/`asPascalConst` this differs from `typeName` (which has a `Key` suffix).
+   */
+  refName: 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
+
+  return { enumName, typeName, refName: resolved }
+}
+
+/**
+ * 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, enumKeyCasing, resolver }: Props): FabricReactNode {
+  const { enumName, typeName, refName } = getEnumNames({ node, enumType, 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]>,
+    type: enumType,
+    enumKeyCasing,
+  })
+
+  const needsRefAlias = ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && refName !== typeName
+
+  return (
+    <>
+      {nameNode && (
+        <File.Source name={enumName} isExportable isIndexable isTypeOnly={false}>
+          {safePrint(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)}
+      </File.Source>
+      {needsRefAlias && (
+        <File.Source name={refName} isExportable isIndexable isTypeOnly>
+          {`export type ${refName} = ${typeName}`}
+        </File.Source>
+      )}
+    </>
+  )
+}

package/src/components/Type.tsx

@@ -1,25 +1,21 @@
-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 { collect, narrowSchema, schemaTypes } from '@kubb/ast'
+import type { EnumSchemaNode, SchemaNode } from '@kubb/ast/types'
 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 { printerTs } from '../printers/printerTs.ts'
 import type { PluginTs } from '../types.ts'
+import { Enum, getEnumNames } from './Enum.tsx'
 
 type Props = {
   name: string
   typedName: string
-  schema: SchemaObject
-  tree: Array<Schema>
+  node: SchemaNode
   optionalType: PluginTs['resolvedOptions']['optionalType']
   arrayType: PluginTs['resolvedOptions']['arrayType']
   enumType: PluginTs['resolvedOptions']['enumType']
   enumKeyCasing: PluginTs['resolvedOptions']['enumKeyCasing']
-  mapper: PluginTs['resolvedOptions']['mapper']
   syntaxType: PluginTs['resolvedOptions']['syntaxType']
+  resolver: PluginTs['resolvedOptions']['resolver']
   description?: string
   keysToOmit?: string[]
 }
@@ -27,133 +23,35 @@ type Props = {
 export function Type({
   name,
   typedName,
-  tree,
+  node,
   keysToOmit,
-  schema,
   optionalType,
   arrayType,
   syntaxType,
   enumType,
   enumKeyCasing,
-  mapper,
   description,
+  resolver,
 }: 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,
-            mapper,
-          },
-        ),
-      )
-      .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)
+  const resolvedDescription = description || node?.description
+  const enumSchemaNodes = collect<EnumSchemaNode>(node, {
+    schema(n): EnumSchemaNode | undefined {
+      const enumNode = narrowSchema(n, schemaTypes.enum)
+      if (enumNode?.name) return enumNode
+    },
+  })
 
-    if (isNullable) {
-      type = factory.createUnionDeclaration({
-        nodes: [type, factory.keywordTypeNodes.null],
-      }) as ts.TypeNode
-    }
+  const printer = printerTs({ optionalType, arrayType, enumType, typeName: name, syntaxType, description: resolvedDescription, keysToOmit, resolver })
+  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, resolver }),
     }
   })
 
@@ -163,29 +61,10 @@ 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>
-            }
-          </>
-        ))}
+      {shouldExportEnums && enums.map(({ node }) => <Enum node={node} enumType={enumType} enumKeyCasing={enumKeyCasing} resolver={resolver} />)}
       {shouldExportType && (
         <File.Source name={typedName} isTypeOnly isExportable isIndexable>
-          {safePrint(...typeNodes)}
+          {output}
         </File.Source>
       )}
     </>

package/src/components/index.ts

@@ -1 +1,2 @@
+export { Enum } from './Enum.tsx'
 export { Type } from './Type.tsx'

package/src/constants.ts

@@ -0,0 +1,29 @@
+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)

package/src/factory.ts

@@ -15,18 +15,10 @@ export const modifiers = {
 
 export const syntaxKind = {
   union: SyntaxKind.UnionType as 192,
+  literalType: SyntaxKind.LiteralType,
+  stringLiteral: SyntaxKind.StringLiteral,
 } as const
 
-export function getUnknownType(unknownType: 'any' | 'unknown' | 'void' | undefined) {
-  if (unknownType === 'any') {
-    return keywordTypeNodes.any
-  }
-  if (unknownType === 'void') {
-    return keywordTypeNodes.void
-  }
-
-  return keywordTypeNodes.unknown
-}
 function isValidIdentifier(str: string): boolean {
   if (!str.length || str.trim() !== str) {
     return false
@@ -74,28 +66,6 @@ export function createIntersectionDeclaration({ nodes, withParentheses }: { node
   return node
 }
 
-/**
- * Minimum nodes length of 2
- * @example `string & number`
- */
-export function createTupleDeclaration({ nodes, withParentheses }: { nodes: Array<ts.TypeNode>; withParentheses?: boolean }): ts.TypeNode | null {
-  if (!nodes.length) {
-    return null
-  }
-
-  if (nodes.length === 1) {
-    return nodes[0] || null
-  }
-
-  const node = factory.createTupleTypeNode(nodes)
-
-  if (withParentheses) {
-    return factory.createParenthesizedType(node)
-  }
-
-  return node
-}
-
 export function createArrayDeclaration({ nodes, arrayType = 'array' }: { nodes: Array<ts.TypeNode>; arrayType?: 'array' | 'generic' }): ts.TypeNode | null {
   if (!nodes.length) {
     return factory.createTupleTypeNode([])
@@ -660,43 +630,39 @@ export const keywordTypeNodes = {
  * Converts a path like '/pet/{petId}/uploadImage' to a template literal type
  * like `/pet/${string}/uploadImage`
  */
+/**
+ * Converts an OAS-style path (e.g. `/pets/{petId}`) or an Express-style path
+ * (e.g. `/pets/:petId`) to a TypeScript template literal type
+ * like `` `/pets/${string}` ``.
+ */
 export function createUrlTemplateType(path: string): ts.TypeNode {
-  // If no parameters, return literal string type
-  if (!path.includes('{')) {
-    return factory.createLiteralTypeNode(factory.createStringLiteral(path))
-  }
+  // normalized Express `:param` → OAS `{param}` so a single regex handles both.
+  const normalized = path.replace(/:([^/]+)/g, '{$1}')
 
-  // Split path by parameter placeholders, e.g. '/pet/{petId}/upload' -> ['/pet/', 'petId', '/upload']
-  const segments = path.split(/(\{[^}]+\})/)
+  if (!normalized.includes('{')) {
+    return factory.createLiteralTypeNode(factory.createStringLiteral(normalized))
+  }
 
-  // Separate static parts from parameter placeholders
+  const segments = normalized.split(/(\{[^}]+\})/)
   const parts: string[] = []
   const parameterIndices: number[] = []
 
   segments.forEach((segment) => {
     if (segment.startsWith('{') && segment.endsWith('}')) {
-      // This is a parameter placeholder
       parameterIndices.push(parts.length)
-      parts.push(segment) // Will be replaced with ${string}
+      parts.push(segment)
     } else if (segment) {
-      // This is a static part
       parts.push(segment)
     }
   })
 
-  // Build template literal type
-  // Template literal structure: head + templateSpans[]
-  // For '/pet/{petId}/upload': head = '/pet/', spans = [{ type: string, literal: '/upload' }]
-
   const head = ts.factory.createTemplateHead(parts[0] || '')
   const templateSpans: ts.TemplateLiteralTypeSpan[] = []
 
   parameterIndices.forEach((paramIndex, i) => {
     const isLast = i === parameterIndices.length - 1
     const nextPart = parts[paramIndex + 1] || ''
-
     const literal = isLast ? ts.factory.createTemplateTail(nextPart) : ts.factory.createTemplateMiddle(nextPart)
-
     templateSpans.push(ts.factory.createTemplateLiteralTypeSpan(keywordTypeNodes.string, literal))
   })
 

package/src/generators/index.ts

@@ -1 +1,2 @@
 export { typeGenerator } from './typeGenerator.tsx'
+export { typeGeneratorLegacy } from './typeGeneratorLegacy.tsx'