@kubb/plugin-ts 3.3.2 → 3.3.4

package/dist/index.cjs

@@ -1,17 +1,17 @@
 'use strict';
 
-var chunk663J2WTL_cjs = require('./chunk-663J2WTL.cjs');
-require('./chunk-PNGMUZT2.cjs');
+var chunkJZIXHFCA_cjs = require('./chunk-JZIXHFCA.cjs');
+require('./chunk-YKKU2PFK.cjs');
 
 
 
 Object.defineProperty(exports, "pluginTs", {
   enumerable: true,
-  get: function () { return chunk663J2WTL_cjs.pluginTs; }
+  get: function () { return chunkJZIXHFCA_cjs.pluginTs; }
 });
 Object.defineProperty(exports, "pluginTsName", {
   enumerable: true,
-  get: function () { return chunk663J2WTL_cjs.pluginTsName; }
+  get: function () { return chunkJZIXHFCA_cjs.pluginTsName; }
 });
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map

package/dist/index.js

@@ -1,4 +1,4 @@
-export { pluginTs, pluginTsName } from './chunk-XCUOQALP.js';
-import './chunk-2FMMBGL3.js';
+export { pluginTs, pluginTsName } from './chunk-TFCUDXXU.js';
+import './chunk-U7IYQJBH.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-ts",
-  "version": "3.3.2",
+  "version": "3.3.4",
   "description": "Generator plugin-ts",
   "keywords": [
     "zod",
@@ -58,20 +58,20 @@
     "!/**/__tests__/**"
   ],
   "dependencies": {
-    "@kubb/core": "3.3.2",
-    "@kubb/fs": "3.3.2",
-    "@kubb/oas": "3.3.2",
-    "@kubb/parser-ts": "3.3.2",
-    "@kubb/plugin-oas": "3.3.2",
-    "@kubb/react": "3.3.2"
+    "@kubb/core": "3.3.4",
+    "@kubb/fs": "3.3.4",
+    "@kubb/oas": "3.3.4",
+    "@kubb/parser-ts": "3.3.4",
+    "@kubb/plugin-oas": "3.3.4",
+    "@kubb/react": "3.3.4"
   },
   "devDependencies": {
-    "@types/react": "^18.3.16",
+    "@types/react": "^18.3.17",
     "react": "^18.3.1",
     "tsup": "^8.3.5",
     "typescript": "^5.7.2",
-    "@kubb/config-ts": "3.3.2",
-    "@kubb/config-tsup": "3.3.2"
+    "@kubb/config-ts": "3.3.4",
+    "@kubb/config-tsup": "3.3.4"
   },
   "peerDependencies": {
     "@kubb/react": "^3.0.0"

package/src/components/OasType.tsx

@@ -1,7 +1,6 @@
 import { File, Type } from '@kubb/react'
 
 import type { OasTypes } from '@kubb/oas'
-import type { ReactNode } from 'react'
 
 type Props = {
   /**
@@ -12,7 +11,7 @@ type Props = {
   api: OasTypes.OASDocument
 }
 
-export function OasType({ name, typeName, api }: Props): ReactNode {
+export function OasType({ name, typeName, api }: Props) {
   return (
     <>
       <File.Source name={name} isExportable isIndexable>

package/src/components/Type.tsx

@@ -1,6 +1,7 @@
 import { File } from '@kubb/react'
 
 import transformers from '@kubb/core/transformers'
+import type { SchemaObject } from '@kubb/oas'
 import { print } from '@kubb/parser-ts'
 import * as factory from '@kubb/parser-ts/factory'
 import { createTypeDeclaration } from '@kubb/parser-ts/factory'
@@ -13,6 +14,7 @@ import type { PluginTs } from '../types.ts'
 type Props = {
   name: string
   typedName: string
+  schema: SchemaObject
   tree: Array<Schema>
   optionalType: PluginTs['resolvedOptions']['optionalType']
   enumType: PluginTs['resolvedOptions']['enumType']
@@ -22,20 +24,20 @@ type Props = {
   keysToOmit?: string[]
 }
 
-export function Type({ name, typedName, tree, keysToOmit, optionalType, syntaxType, enumType, mapper, description }: Props): ReactNode {
+export function Type({ name, typedName, tree, keysToOmit, schema, optionalType, syntaxType, enumType, mapper, description }: Props): ReactNode {
   const typeNodes: ts.Node[] = []
 
   if (!tree.length) {
     return ''
   }
 
-  const schema = tree.find((item) => item.keyword === schemaKeywords.schema)
+  const schemaFromTree = tree.find((item) => item.keyword === schemaKeywords.schema)
 
   let type =
     (tree
-      .map((schema, _index, siblings) =>
+      .map((current, _index, siblings) =>
         parse(
-          { parent: undefined, current: schema, siblings },
+          { parent: undefined, current, siblings },
           {
             name,
             typedName,
@@ -51,7 +53,7 @@ export function Type({ name, typedName, tree, keysToOmit, optionalType, syntaxTy
       .filter(Boolean)
       .at(0) as ts.TypeNode) || typeKeywordMapper.undefined()
 
-  if (schema && isKeyword(schema, schemaKeywords.schema) && schema.args.type !== 'object') {
+  if (schemaFromTree && isKeyword(schemaFromTree, schemaKeywords.schema) && schemaFromTree.args.type !== 'object') {
     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)
@@ -89,7 +91,15 @@ export function Type({ name, typedName, tree, keysToOmit, optionalType, syntaxTy
           })
         : type,
       syntax: useTypeGeneration ? 'type' : 'interface',
-      description: description ? transformers.jsStringEscape(description) : undefined,
+      comments: [
+        description ? `@description ${transformers.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,
+      ],
     }),
   )
 
@@ -119,7 +129,8 @@ export function Type({ name, typedName, tree, keysToOmit, optionalType, syntaxTy
   return (
     <Fragment>
       {enums.map(({ name, nameNode, typeName, typeNode }, index) => (
-        <Fragment key={[name, nameNode].join('-')}>
+        // biome-ignore lint/correctness/useJsxKeyInIterable: <explanation>
+        <Fragment>
           {nameNode && (
             <File.Source name={name} isExportable isIndexable>
               {print([nameNode])}

package/src/generators/typeGenerator.tsx

@@ -146,6 +146,7 @@ export const typeGenerator = createReactGenerator<PluginTs>({
             typedName={type.typedName}
             description={description}
             tree={tree}
+            schema={schema}
             mapper={mapper}
             enumType={enumType}
             optionalType={optionalType}
@@ -196,6 +197,7 @@ export const typeGenerator = createReactGenerator<PluginTs>({
           typedName={type.typedName}
           description={schema.value.description}
           tree={schema.tree}
+          schema={schema.value}
           mapper={mapper}
           enumType={enumType}
           optionalType={optionalType}

package/src/parser.ts

@@ -206,6 +206,9 @@ export function parse({ parent, current, siblings }: SchemaTree, options: Parser
         const defaultSchema = schemas.find((schema) => schema.keyword === schemaKeywords.default) as SchemaKeywordMapper['default'] | undefined
         const exampleSchema = schemas.find((schema) => schema.keyword === schemaKeywords.example) as SchemaKeywordMapper['example'] | undefined
         const schemaSchema = schemas.find((schema) => schema.keyword === schemaKeywords.schema) as SchemaKeywordMapper['schema'] | undefined
+        const minSchema = schemas.find((schema) => schema.keyword === schemaKeywords.min) as SchemaKeywordMapper['min'] | undefined
+        const maxSchema = schemas.find((schema) => schema.keyword === schemaKeywords.max) as SchemaKeywordMapper['max'] | undefined
+        const matchesSchema = schemas.find((schema) => schema.keyword === schemaKeywords.matches) as SchemaKeywordMapper['matches'] | undefined
 
         let type = schemas.map((schema) => parse({ parent: current, current: schema, siblings }, options)).filter(Boolean)[0] as ts.TypeNode
 
@@ -239,6 +242,9 @@ export function parse({ parent, current, siblings }: SchemaTree, options: Parser
           comments: [
             describeSchema ? `@description ${transformers.jsStringEscape(describeSchema.args)}` : undefined,
             deprecatedSchema ? '@deprecated' : undefined,
+            minSchema ? `@minLength ${minSchema.args}` : undefined,
+            maxSchema ? `@maxLength ${maxSchema.args}` : undefined,
+            matchesSchema ? `@pattern ${matchesSchema.args}` : undefined,
             defaultSchema ? `@default ${defaultSchema.args}` : undefined,
             exampleSchema ? `@example ${exampleSchema.args}` : undefined,
             schemaSchema?.args?.type || schemaSchema?.args?.format