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

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.56",
+  "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"
   ],
@@ -27,7 +24,6 @@
   "files": [
     "src",
     "dist",
-    "extension.yaml",
     "!/**/**.test.**",
     "!/**/__tests__/**",
     "!/**/__snapshots__/**"
@@ -49,35 +45,30 @@
     "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/ast": "5.0.0-beta.55",
+    "@kubb/core": "5.0.0-beta.55",
+    "@kubb/parser-ts": "5.0.0-beta.55",
+    "@kubb/renderer-jsx": "5.0.0-beta.55",
     "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.55"
   },
-  "size-limit": [
-    {
-      "path": "./dist/*.js",
-      "limit": "510 KiB",
-      "gzip": true
-    }
-  ],
   "engines": {
     "node": ">=22"
   },
   "scripts": {
-    "build": "tsdown && size-limit",
-    "clean": "npx rimraf ./dist",
+    "build": "tsdown",
+    "clean": "node -e \"require('node:fs').rmSync('./dist', {recursive:true,force:true})\"",
     "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",
+    "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,17 +1,18 @@
-import { camelCase, trimQuotes } from '@internals/utils'
+import { camelCase } from '@internals/utils'
+import { trimQuotes } from '@kubb/ast/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'
 import * as factory from '../factory.ts'
 import type { PluginTs, ResolverTs } from '../types.ts'
 
+type EnumOptions = PluginTs['resolvedOptions']['enum']
+
 type Props = {
   node: ast.EnumSchemaNode
-  enumType: PluginTs['resolvedOptions']['enumType']
-  enumTypeSuffix: PluginTs['resolvedOptions']['enumTypeSuffix']
-  enumKeyCasing: PluginTs['resolvedOptions']['enumKeyCasing']
+  enum: EnumOptions
   resolver: ResolverTs
   key?: string | number | null
 }
@@ -20,26 +21,19 @@ type Props = {
  * 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.
+ * 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.
+ *
+ * When `constCasing` is `'pascalCase'` and `typeSuffix` is empty, the const and the type
+ * resolve to the same name, which TypeScript merges into a single value+type declaration.
  */
-export function getEnumNames({
-  node,
-  enumType,
-  enumTypeSuffix,
-  resolver,
-}: {
-  node: ast.EnumSchemaNode
-  enumType: PluginTs['resolvedOptions']['enumType']
-  enumTypeSuffix: PluginTs['resolvedOptions']['enumTypeSuffix']
-  resolver: ResolverTs
-}): {
+export function getEnumNames({ node, enum: enumOptions, resolver }: { node: ast.EnumSchemaNode; enum: EnumOptions; 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) ? resolver.resolveEnumKeyName(node, enumTypeSuffix) : resolved
+  const enumName = enumOptions.constCasing === 'pascalCase' ? resolved : camelCase(node.name!)
+  const typeName = ENUM_TYPES_WITH_KEY_SUFFIX.has(enumOptions.type) ? resolver.resolveEnumKeyName(node, enumOptions.typeSuffix) : resolved
 
   return { enumName, typeName }
 }
@@ -47,16 +41,16 @@ export function getEnumNames({
 /**
  * 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
+ * Depending on `enum.type` this may emit:
+ * - A runtime object (`asConst`) 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, enumTypeSuffix, enumKeyCasing, resolver }: Props): KubbReactNode {
-  const { enumName, typeName } = getEnumNames({ node, enumType, enumTypeSuffix, resolver })
+export function Enum({ node, enum: enumOptions, resolver }: Props): KubbReactNode {
+  const { enumName, typeName } = getEnumNames({ node, enum: enumOptions, resolver })
 
   const [nameNode, typeNode] = factory.createEnumDeclaration({
     name: enumName,
@@ -64,19 +58,29 @@ export function Enum({ node, enumType, enumTypeSuffix, enumKeyCasing, resolver }
     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 Array<[string | number, string | number | boolean]>,
-    type: enumType,
-    enumKeyCasing,
+    type: enumOptions.type,
+    enumKeyCasing: enumOptions.keyCasing,
   })
 
+  // When the const and the type share a name (pascalCase const + empty typeSuffix) they merge into
+  // one declaration. The const carries the barrel export, so keep the type alias in the file but out
+  // of the barrel to avoid re-exporting the name a second time as `export type { … }`.
+  const namesMerge = !!nameNode && enumName === typeName
+
   return (
     <>
       {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)}
+      <File.Source
+        name={typeName}
+        isIndexable={!namesMerge}
+        isExportable={!namesMerge && ENUM_TYPES_WITH_RUNTIME_VALUE.has(enumOptions.type)}
+        isTypeOnly={ENUM_TYPES_WITH_TYPE_ONLY.has(enumOptions.type)}
+      >
+        {parserTs.print(typeNode)}
       </File.Source>
     </>
   )

package/src/components/Type.tsx

@@ -13,13 +13,11 @@ type Props = {
    * Created with `printerTs({ ..., nodes: options.printer?.nodes })`.
    */
   printer: ast.Printer<PrinterTsFactory>
-  enumType: PluginTs['resolvedOptions']['enumType']
-  enumTypeSuffix: PluginTs['resolvedOptions']['enumTypeSuffix']
-  enumKeyCasing: PluginTs['resolvedOptions']['enumKeyCasing']
+  enum: PluginTs['resolvedOptions']['enum']
   resolver: ResolverTs
 }
 
-export function Type({ name, node, printer, enumType, enumTypeSuffix, enumKeyCasing, resolver }: Props): KubbReactNode {
+export function Type({ name, node, printer, enum: enumOptions, resolver }: Props): KubbReactNode {
   const enumSchemaNodes = ast.collect<ast.EnumSchemaNode>(node, {
     schema(n): ast.EnumSchemaNode | undefined {
       const enumNode = ast.narrowSchema(n, ast.schemaTypes.enum)
@@ -36,20 +34,17 @@ export function Type({ name, node, printer, enumType, enumTypeSuffix, enumKeyCas
   const enums = [...new Map(enumSchemaNodes.map((n) => [n.name, n])).values()].map((node) => {
     return {
       node,
-      ...getEnumNames({ node, enumType, enumTypeSuffix, resolver }),
+      ...getEnumNames({ node, enum: enumOptions, resolver }),
     }
   })
 
   // Skip enum exports when using inlineLiteral
-  const shouldExportEnums = enumType !== 'inlineLiteral'
-  const shouldExportType = enumType === 'inlineLiteral' || enums.every((item) => item.typeName !== name)
+  const shouldExportEnums = enumOptions.type !== 'inlineLiteral'
+  const shouldExportType = enumOptions.type === 'inlineLiteral' || enums.every((item) => item.typeName !== name)
 
   return (
     <>
-      {shouldExportEnums &&
-        enums.map(({ node }) => (
-          <Enum key={node.name} node={node} enumType={enumType} enumTypeSuffix={enumTypeSuffix} enumKeyCasing={enumKeyCasing} resolver={resolver} />
-        ))}
+      {shouldExportEnums && enums.map(({ node }) => <Enum key={node.name} node={node} enum={enumOptions} resolver={resolver} />)}
       {shouldExportType && (
         <File.Source name={name} isTypeOnly isExportable isIndexable>
           {output}

package/src/constants.ts

@@ -1,7 +1,7 @@
 import type { PluginTs } from './types.ts'
 
 type OptionalType = PluginTs['resolvedOptions']['optionalType']
-type EnumType = PluginTs['resolvedOptions']['enumType']
+type EnumType = PluginTs['resolvedOptions']['enum']['type']
 
 /**
  * `optionalType` values that cause a property's type to include `| undefined`.
@@ -14,19 +14,19 @@ export const OPTIONAL_ADDS_UNDEFINED = new Set<OptionalType>(['undefined', 'ques
 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.
+ * `enum.type` values that append a `typeSuffix` to the generated enum type alias.
  */
-export const ENUM_TYPES_WITH_KEY_SUFFIX = new Set<EnumType>(['asConst', 'asPascalConst'] as const)
+export const ENUM_TYPES_WITH_KEY_SUFFIX = new Set<EnumType>(['asConst'] as const)
 
 /**
- * `enumType` values that require a runtime value declaration (object, enum, or literal).
+ * `enum.type` 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)
+export const ENUM_TYPES_WITH_RUNTIME_VALUE = new Set<EnumType | undefined>(['enum', 'asConst', 'constEnum', 'literal', undefined] as const)
 
 /**
- * `enumType` values whose type declaration is type-only (no runtime value emitted for the type alias).
+ * `enum.type` 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)
+export const ENUM_TYPES_WITH_TYPE_ONLY = new Set<EnumType | undefined>(['asConst', 'literal', undefined] as const)
 
 /**
  * Ordering priority for function parameters: lower = sorted earlier.

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
   }
@@ -329,18 +361,6 @@ export function createTypeDeclaration({
   })
 }
 
-/**
- * Creates a TypeScript namespace declaration (exported module).
- */
-export function createNamespaceDeclaration({ statements, name }: { name: string; statements: ts.Statement[] }) {
-  return factory.createModuleDeclaration(
-    [factory.createToken(ts.SyntaxKind.ExportKeyword)],
-    factory.createIdentifier(name),
-    factory.createModuleBlock(statements),
-    ts.NodeFlags.Namespace,
-  )
-}
-
 /**
  * Creates an import declaration with support for default imports, named imports, namespace imports, and type-only imports.
  * Optionally rename imported members with `propertyName` and `name` pairs.
@@ -366,13 +386,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 +398,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 +457,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,
@@ -501,15 +516,14 @@ export function createEnumDeclaration({
   enumKeyCasing = 'none',
 }: {
   /**
-   * Choose to use `enum`, `asConst`, `asPascalConst`, `constEnum`, or `literal` for enums.
+   * Choose to use `enum`, `asConst`, `constEnum`, or `literal` for enums.
    * - `enum`: TypeScript enum
-   * - `asConst`: const with camelCase name (e.g., `petType`)
-   * - `asPascalConst`: const with PascalCase name (e.g., `PetType`)
+   * - `asConst`: const object asserted with `as const` (the caller decides the const name casing)
    * - `constEnum`: const enum
    * - `literal`: literal union type
    * @default `'enum'`
    */
-  type?: 'enum' | 'asConst' | 'asPascalConst' | 'constEnum' | 'literal' | 'inlineLiteral'
+  type?: 'enum' | 'asConst' | 'constEnum' | 'literal' | 'inlineLiteral'
   /**
    * Enum name in camelCase.
    */
@@ -518,7 +532,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 +567,7 @@ export function createEnumDeclaration({
 
               return undefined
             })
-            .filter(Boolean),
+            .filter((node): node is ts.LiteralTypeNode => node !== undefined),
         ),
       ),
     ]
@@ -563,7 +577,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,14 +610,14 @@ export function createEnumDeclaration({
 
             return undefined
           })
-          .filter(Boolean),
+          .filter((member): member is ts.EnumMember => member !== undefined),
       ),
     ]
   }
 
   // used when using `as const` instead of an TypeScript enum.
-  // name is already PascalCase for asPascalConst and camelCase for asConst (set in Type.tsx)
-  // typeName has the Key suffix for type alias, so we use name for the const identifier
+  // name is already cased by the caller (camelCase or pascalCase, driven by enum.constCasing).
+  // typeName carries the typeSuffix for the type alias, so we use name for the const identifier.
   const identifierName = name
 
   // When there are no enum items (empty or all-null enum), don't generate a runtime const.
@@ -657,7 +673,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 +753,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 +766,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
@@ -787,21 +803,11 @@ export const createStringLiteral = factory.createStringLiteral
  */
 export const createArrayTypeNode = factory.createArrayTypeNode
 
-/**
- * Creates a parenthesized type node to control operator precedence.
- */
-export const createParenthesizedType = factory.createParenthesizedType
-
 /**
  * Creates a literal type node (e.g., `'hello'`, `42`, `true`).
  */
 export const createLiteralTypeNode = factory.createLiteralTypeNode
 
-/**
- * Creates a null literal type node.
- */
-export const createNull = factory.createNull
-
 /**
  * Creates an identifier node.
  */
@@ -832,16 +838,6 @@ export const createTrue = factory.createTrue
  */
 export const createFalse = factory.createFalse
 
-/**
- * Creates an indexed access type node (e.g., `T[K]`).
- */
-export const createIndexedAccessTypeNode = factory.createIndexedAccessTypeNode
-
-/**
- * Creates a type operator node (e.g., `keyof T`, `readonly T[]`).
- */
-export const createTypeOperatorNode = factory.createTypeOperatorNode
-
 /**
  * Creates a prefix unary expression (e.g., negative numbers, logical not).
  */
@@ -885,7 +881,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 +889,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