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

package/dist/types-BpeKGgCn.d.ts

@@ -1,170 +0,0 @@
-import { t as __name } from "./chunk--u3MIqq1.js";
-import { Group, Output, PluginFactoryOptions, ResolveNameParams } from "@kubb/core";
-import { Exclude, Include, Override, ResolvePathOptions } from "@kubb/plugin-oas";
-import { Generator } from "@kubb/plugin-oas/generators";
-import ts from "typescript";
-import { Oas, contentType } from "@kubb/oas";
-
-//#region src/types.d.ts
-type Options = {
-  /**
-   * Specify the export location for the files and define the behavior of the output
-   * @default { path: 'types', barrelType: 'named' }
-   */
-  output?: Output<Oas>;
-  /**
-   * Define which contentType should be used.
-   * By default, uses the first valid JSON media type.
-   */
-  contentType?: contentType;
-  /**
-   * Group the clients based on the provided name.
-   */
-  group?: Group;
-  /**
-   * Array containing exclude parameters to exclude/skip tags/operations/methods/paths.
-   */
-  exclude?: Array<Exclude>;
-  /**
-   * Array containing include parameters to include tags/operations/methods/paths.
-   */
-  include?: Array<Include>;
-  /**
-   * Array containing override parameters to override `options` based on tags/operations/methods/paths.
-   */
-  override?: Array<Override<ResolvedOptions>>;
-  /**
-   * Choose to use enum, asConst, asPascalConst, constEnum, literal, or inlineLiteral for enums.
-   * - 'enum' generates TypeScript enum declarations.
-   * - 'asConst' generates const objects with camelCase names and as const assertion.
-   * - 'asPascalConst' generates const objects with PascalCase names and as const assertion.
-   * - 'constEnum' generates TypeScript const enum declarations.
-   * - 'literal' generates literal union types.
-   * - 'inlineLiteral' inline enum values directly into the type (default in v5).
-   * @default 'asConst'
-   * @note In Kubb v5, 'inlineLiteral' becomes the default.
-   */
-  enumType?: 'enum' | 'asConst' | 'asPascalConst' | 'constEnum' | 'literal' | 'inlineLiteral';
-  /**
-   * Choose the casing for enum key names.
-   * - 'screamingSnakeCase' generates keys in SCREAMING_SNAKE_CASE format.
-   * - 'snakeCase' generates keys in snake_case format.
-   * - 'pascalCase' generates keys in PascalCase format.
-   * - 'camelCase' generates keys in camelCase format.
-   * - 'none' uses the enum value as-is without transformation.
-   * @default 'none'
-   */
-  enumKeyCasing?: 'screamingSnakeCase' | 'snakeCase' | 'pascalCase' | 'camelCase' | 'none';
-  /**
-   * Switch between type or interface for creating TypeScript types.
-   * - 'type' generates type alias declarations.
-   * - 'interface' generates interface declarations.
-   * @default 'type'
-   */
-  syntaxType?: 'type' | 'interface';
-  /**
-   * Set a suffix for the generated enums.
-   * @default 'enum'
-   */
-  enumSuffix?: string;
-  /**
-   * Choose to use date or datetime as JavaScript Date instead of string.
-   * - 'string' represents dates as string values.
-   * - 'date' represents dates as JavaScript Date objects.
-   * @default 'string'
-   */
-  dateType?: 'string' | 'date';
-  /**
-   * Choose to use `number` or `bigint` for integer fields with `int64` format.
-   * - 'number' uses the TypeScript `number` type (matches JSON.parse() runtime behavior).
-   * - 'bigint' uses the TypeScript `bigint` type (accurate for values exceeding Number.MAX_SAFE_INTEGER).
-   * @note in v5 of Kubb 'bigint' will become the default to better align with OpenAPI's int64 specification.
-   * @default 'number'
-   */
-  integerType?: 'number' | 'bigint';
-  /**
-   * Which type to use when the Swagger/OpenAPI file is not providing more information.
-   * - 'any' allows any value.
-   * - 'unknown' requires type narrowing before use.
-   * - 'void' represents no value.
-   * @default 'any'
-   */
-  unknownType?: 'any' | 'unknown' | 'void';
-  /**
-   * Which type to use for empty schema values.
-   * - 'any' allows any value.
-   * - 'unknown' requires type narrowing before use.
-   * - 'void' represents no value.
-   * @default `unknownType`
-   */
-  emptySchemaType?: 'any' | 'unknown' | 'void';
-  /**
-   * Choose what to use as mode for an optional value.
-   * - 'questionToken' marks the property as optional with ? (e.g., type?: string).
-   * - 'undefined' adds undefined to the type union (e.g., type: string | undefined).
-   * - 'questionTokenAndUndefined' combines both approaches (e.g., type?: string | undefined).
-   * @default 'questionToken'
-   */
-  optionalType?: 'questionToken' | 'undefined' | 'questionTokenAndUndefined';
-  /**
-   * Choose between Array<string> or string[] for array types.
-   * - 'generic' generates Array<Type> syntax.
-   * - 'array' generates Type[] syntax.
-   * @default 'array'
-   */
-  arrayType?: 'generic' | 'array';
-  transformers?: {
-    /**
-     * Customize the names based on the type that is provided by the plugin.
-     */
-    name?: (name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string;
-  };
-  /**
-   * @example
-   * Use https://ts-ast-viewer.com to generate factory code(see createPropertySignature)
-   * category: factory.createPropertySignature(
-   *   undefined,
-   *   factory.createIdentifier("category"),
-   *   factory.createToken(ts.SyntaxKind.QuestionToken),
-   *   factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
-   * )
-   */
-  mapper?: Record<string, ts.PropertySignature>;
-  /**
-   * How to style your params, by default no casing is applied
-   * - 'camelcase' uses camelCase for pathParams, queryParams and headerParams property names
-   * @default undefined
-   * @note response types (data/body) are NOT affected by this option
-   */
-  paramsCasing?: 'camelcase';
-  /**
-   * Define some generators next to the ts generators
-   */
-  generators?: Array<Generator<PluginTs>>;
-  /**
-   * Unstable naming for v5
-   */
-  UNSTABLE_NAMING?: true;
-};
-type ResolvedOptions = {
-  output: Output<Oas>;
-  group: Options['group'];
-  override: NonNullable<Options['override']>;
-  enumType: NonNullable<Options['enumType']>;
-  enumKeyCasing: NonNullable<Options['enumKeyCasing']>;
-  enumSuffix: NonNullable<Options['enumSuffix']>;
-  dateType: NonNullable<Options['dateType']>;
-  integerType: NonNullable<Options['integerType']>;
-  unknownType: NonNullable<Options['unknownType']>;
-  emptySchemaType: NonNullable<Options['emptySchemaType']>;
-  optionalType: NonNullable<Options['optionalType']>;
-  arrayType: NonNullable<Options['arrayType']>;
-  transformers: NonNullable<Options['transformers']>;
-  syntaxType: NonNullable<Options['syntaxType']>;
-  mapper: Record<string, any>;
-  paramsCasing: Options['paramsCasing'];
-};
-type PluginTs = PluginFactoryOptions<'plugin-ts', Options, ResolvedOptions, never, ResolvePathOptions>;
-//#endregion
-export { PluginTs as n, Options as t };
-//# sourceMappingURL=types-BpeKGgCn.d.ts.map

package/src/parser.ts

@@ -1,396 +0,0 @@
-import { jsStringEscape } from '@internals/utils'
-import type { SchemaKeywordMapper, SchemaMapper } from '@kubb/plugin-oas'
-import { createParser, isKeyword, schemaKeywords } from '@kubb/plugin-oas'
-import type ts from 'typescript'
-import * as factory from './factory.ts'
-
-export const typeKeywordMapper = {
-  any: () => factory.keywordTypeNodes.any,
-  unknown: () => factory.keywordTypeNodes.unknown,
-  void: () => factory.keywordTypeNodes.void,
-  number: () => factory.keywordTypeNodes.number,
-  integer: () => factory.keywordTypeNodes.number,
-  bigint: () => factory.keywordTypeNodes.bigint,
-  object: (nodes?: ts.TypeElement[]) => {
-    if (!nodes || !nodes.length) {
-      return factory.keywordTypeNodes.object
-    }
-
-    return factory.createTypeLiteralNode(nodes)
-  },
-  string: () => factory.keywordTypeNodes.string,
-  boolean: () => factory.keywordTypeNodes.boolean,
-  undefined: () => factory.keywordTypeNodes.undefined,
-  nullable: undefined,
-  null: () => factory.keywordTypeNodes.null,
-  nullish: undefined,
-  array: (nodes?: ts.TypeNode[], arrayType?: 'array' | 'generic') => {
-    if (!nodes) {
-      return undefined
-    }
-
-    return factory.createArrayDeclaration({ nodes, arrayType })
-  },
-  tuple: (nodes?: ts.TypeNode[], rest?: ts.TypeNode, min?: number, max?: number) => {
-    if (!nodes) {
-      return undefined
-    }
-
-    if (max) {
-      nodes = nodes.slice(0, max)
-
-      if (nodes.length < max && rest) {
-        nodes = [...nodes, ...Array(max - nodes.length).fill(rest)]
-      }
-    }
-
-    if (min) {
-      nodes = nodes.map((node, index) => (index >= min ? factory.createOptionalTypeNode(node) : node))
-    }
-
-    if (typeof max === 'undefined' && rest) {
-      nodes.push(factory.createRestTypeNode(factory.createArrayTypeNode(rest)))
-    }
-
-    return factory.createTupleTypeNode(nodes)
-  },
-  enum: (name?: string) => {
-    if (!name) {
-      return undefined
-    }
-
-    return factory.createTypeReferenceNode(name, undefined)
-  },
-  union: (nodes?: ts.TypeNode[]) => {
-    if (!nodes) {
-      return undefined
-    }
-
-    return factory.createUnionDeclaration({
-      withParentheses: true,
-      nodes,
-    })
-  },
-  const: (name?: string | number | boolean, format?: 'string' | 'number' | 'boolean') => {
-    if (name === null || name === undefined || name === '') {
-      return undefined
-    }
-
-    if (format === 'boolean') {
-      if (name === true) {
-        return factory.createLiteralTypeNode(factory.createTrue())
-      }
-
-      return factory.createLiteralTypeNode(factory.createFalse())
-    }
-
-    if (format === 'number' && typeof name === 'number') {
-      return factory.createLiteralTypeNode(factory.createNumericLiteral(name))
-    }
-
-    return factory.createLiteralTypeNode(factory.createStringLiteral(name.toString()))
-  },
-  datetime: () => factory.keywordTypeNodes.string,
-  date: (type: 'date' | 'string' = 'string') =>
-    type === 'string' ? factory.keywordTypeNodes.string : factory.createTypeReferenceNode(factory.createIdentifier('Date')),
-  time: (type: 'date' | 'string' = 'string') =>
-    type === 'string' ? factory.keywordTypeNodes.string : factory.createTypeReferenceNode(factory.createIdentifier('Date')),
-  uuid: () => factory.keywordTypeNodes.string,
-  url: () => factory.keywordTypeNodes.string,
-  default: undefined,
-  and: (nodes?: ts.TypeNode[]) => {
-    if (!nodes) {
-      return undefined
-    }
-
-    return factory.createIntersectionDeclaration({
-      withParentheses: true,
-      nodes,
-    })
-  },
-  describe: undefined,
-  min: undefined,
-  max: undefined,
-  optional: undefined,
-  matches: () => factory.keywordTypeNodes.string,
-  email: () => factory.keywordTypeNodes.string,
-  firstName: undefined,
-  lastName: undefined,
-  password: undefined,
-  phone: undefined,
-  readOnly: undefined,
-  writeOnly: undefined,
-  ref: (propertyName?: string) => {
-    if (!propertyName) {
-      return undefined
-    }
-
-    return factory.createTypeReferenceNode(propertyName, undefined)
-  },
-  blob: () => factory.createTypeReferenceNode('Blob', []),
-  deprecated: undefined,
-  example: undefined,
-  schema: undefined,
-  catchall: undefined,
-  name: undefined,
-  interface: undefined,
-  exclusiveMaximum: undefined,
-  exclusiveMinimum: undefined,
-} satisfies SchemaMapper<ts.TypeNode | null | undefined>
-
-type ParserOptions = {
-  /**
-   * @default `'questionToken'`
-   */
-  optionalType: 'questionToken' | 'undefined' | 'questionTokenAndUndefined'
-  /**
-   * @default `'array'`
-   */
-  arrayType: 'array' | 'generic'
-  /**
-   * Choose to use `enum`, `asConst`, `asPascalConst`, `constEnum`, `literal`, or `inlineLiteral` for enums.
-   * - `enum`: TypeScript enum
-   * - `asConst`: const with camelCase name (e.g., `petType`)
-   * - `asPascalConst`: const with PascalCase name (e.g., `PetType`)
-   * - `constEnum`: const enum
-   * - `literal`: literal union type
-   * - `inlineLiteral`: inline enum values directly into the type (default in v5)
-   * @default `'asConst'`
-   * @note In Kubb v5, `inlineLiteral` becomes the default.
-   */
-  enumType: 'enum' | 'asConst' | 'asPascalConst' | 'constEnum' | 'literal' | 'inlineLiteral'
-  mapper?: Record<string, ts.PropertySignature>
-}
-
-/**
- * Recursively parses a schema tree node into a corresponding TypeScript AST node.
- *
- * Maps OpenAPI schema keywords to TypeScript AST nodes using the `typeKeywordMapper`, handling complex types such as unions, intersections, arrays, tuples (with optional/rest elements and length constraints), enums, constants, references, and objects with property modifiers and documentation annotations.
- *
- * @param current - The schema node to parse.
- * @param siblings - Sibling schema nodes, used for context in certain mappings.
- * @param name - The name of the schema or property being parsed.
- * @param options - Parsing options controlling output style, property handling, and custom mappers.
- * @returns The generated TypeScript AST node, or `undefined` if the schema keyword is not mapped.
- */
-export const parse = createParser<ts.Node | null, ParserOptions>({
-  mapper: typeKeywordMapper,
-  handlers: {
-    union(tree, options) {
-      const { current, schema, name } = tree
-
-      return typeKeywordMapper.union(
-        current.args.map((it) => this.parse({ schema, parent: current, name, current: it, siblings: [] }, options)).filter(Boolean) as ts.TypeNode[],
-      )
-    },
-    and(tree, options) {
-      const { current, schema, name } = tree
-
-      return typeKeywordMapper.and(
-        current.args.map((it) => this.parse({ schema, parent: current, name, current: it, siblings: [] }, options)).filter(Boolean) as ts.TypeNode[],
-      )
-    },
-    array(tree, options) {
-      const { current, schema, name } = tree
-
-      return typeKeywordMapper.array(
-        current.args.items.map((it) => this.parse({ schema, parent: current, name, current: it, siblings: [] }, options)).filter(Boolean) as ts.TypeNode[],
-        options.arrayType,
-      )
-    },
-    enum(tree, options) {
-      const { current } = tree
-
-      // If enumType is 'inlineLiteral', generate the literal union inline instead of a type reference
-      if (options.enumType === 'inlineLiteral') {
-        const enumValues = current.args.items
-          .map((item) => item.value)
-          .filter((value): value is string | number | boolean => value !== undefined && value !== null)
-          .map((value) => {
-            const format = typeof value === 'number' ? 'number' : typeof value === 'boolean' ? 'boolean' : 'string'
-            return typeKeywordMapper.const(value, format)
-          })
-          .filter(Boolean) as ts.TypeNode[]
-
-        return typeKeywordMapper.union(enumValues)
-      }
-
-      // Adding suffix to enum (see https://github.com/kubb-labs/kubb/issues/1873)
-      return typeKeywordMapper.enum(['asConst', 'asPascalConst'].includes(options.enumType) ? `${current.args.typeName}Key` : current.args.typeName)
-    },
-    ref(tree, _options) {
-      const { current } = tree
-
-      return typeKeywordMapper.ref(current.args.name)
-    },
-    blob() {
-      return typeKeywordMapper.blob()
-    },
-    tuple(tree, options) {
-      const { current, schema, name } = tree
-
-      return typeKeywordMapper.tuple(
-        current.args.items.map((it) => this.parse({ schema, parent: current, name, current: it, siblings: [] }, options)).filter(Boolean) as ts.TypeNode[],
-        current.args.rest &&
-          ((this.parse({ schema, parent: current, name, current: current.args.rest, siblings: [] }, options) ?? undefined) as ts.TypeNode | undefined),
-        current.args.min,
-        current.args.max,
-      )
-    },
-    const(tree, _options) {
-      const { current } = tree
-
-      return typeKeywordMapper.const(current.args.name, current.args.format)
-    },
-    object(tree, options) {
-      const { current, schema, name } = tree
-
-      const properties = Object.entries(current.args?.properties || {})
-        .filter((item) => {
-          const schemas = item[1]
-          return schemas && typeof schemas.map === 'function'
-        })
-        .map(([name, schemas]) => {
-          const nameSchema = schemas.find((schema) => schema.keyword === schemaKeywords.name) as SchemaKeywordMapper['name']
-          const mappedName = nameSchema?.args || name
-
-          // custom mapper(pluginOptions)
-          // Use Object.hasOwn to avoid matching inherited properties like 'toString', 'valueOf', etc.
-          if (options.mapper && Object.hasOwn(options.mapper, mappedName)) {
-            return options.mapper[mappedName]
-          }
-
-          const isNullish = schemas.some((schema) => schema.keyword === schemaKeywords.nullish)
-          const isNullable = schemas.some((schema) => schema.keyword === schemaKeywords.nullable)
-          const isOptional = schemas.some((schema) => schema.keyword === schemaKeywords.optional)
-          const isReadonly = schemas.some((schema) => schema.keyword === schemaKeywords.readOnly)
-          const describeSchema = schemas.find((schema) => schema.keyword === schemaKeywords.describe) as SchemaKeywordMapper['describe'] | undefined
-          const deprecatedSchema = schemas.find((schema) => schema.keyword === schemaKeywords.deprecated) as SchemaKeywordMapper['deprecated'] | undefined
-          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((it) =>
-              this.parse(
-                {
-                  schema,
-                  parent: current,
-                  name,
-                  current: it,
-                  siblings: schemas,
-                },
-                options,
-              ),
-            )
-            .filter(Boolean)[0] as ts.TypeNode
-
-          if (isNullable) {
-            type = factory.createUnionDeclaration({
-              nodes: [type, factory.keywordTypeNodes.null],
-            }) as ts.TypeNode
-          }
-
-          if (isNullish && ['undefined', 'questionTokenAndUndefined'].includes(options.optionalType as string)) {
-            type = factory.createUnionDeclaration({
-              nodes: [type, factory.keywordTypeNodes.undefined],
-            }) as ts.TypeNode
-          }
-
-          if (isOptional && ['undefined', 'questionTokenAndUndefined'].includes(options.optionalType as string)) {
-            type = factory.createUnionDeclaration({
-              nodes: [type, factory.keywordTypeNodes.undefined],
-            }) as ts.TypeNode
-          }
-
-          const propertyNode = factory.createPropertySignature({
-            questionToken: isOptional || isNullish ? ['questionToken', 'questionTokenAndUndefined'].includes(options.optionalType as string) : false,
-            name: mappedName,
-            type,
-            readOnly: isReadonly,
-          })
-
-          return factory.appendJSDocToNode({
-            node: propertyNode,
-            comments: [
-              describeSchema ? `@description ${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
-                ? [`@type ${schemaSchema?.args?.type || 'unknown'}${!isOptional ? '' : ' | undefined'}`, schemaSchema?.args?.format].filter(Boolean).join(', ')
-                : undefined,
-            ].filter(Boolean),
-          })
-        })
-
-      let additionalProperties: any
-
-      if (current.args?.additionalProperties?.length) {
-        let additionalPropertiesType = current.args.additionalProperties
-          .map((it) => this.parse({ schema, parent: current, name, current: it, siblings: [] }, options))
-          .filter(Boolean)
-          .at(0) as ts.TypeNode
-
-        const isNullable = current.args?.additionalProperties.some((schema) => isKeyword(schema, schemaKeywords.nullable))
-        if (isNullable) {
-          additionalPropertiesType = factory.createUnionDeclaration({
-            nodes: [additionalPropertiesType, factory.keywordTypeNodes.null],
-          }) as ts.TypeNode
-        }
-
-        // When there are typed properties alongside additionalProperties, use 'unknown' type
-        // for the index signature to avoid TS2411 errors (index signature type conflicts with property types).
-        // This occurs commonly in QueryParams where some params are typed (enums, objects) and
-        // others are dynamic (additionalProperties with explode=true).
-        const hasTypedProperties = properties.length > 0
-        const indexSignatureType = hasTypedProperties ? factory.keywordTypeNodes.unknown : additionalPropertiesType
-
-        additionalProperties = factory.createIndexSignature(indexSignatureType)
-      }
-
-      let patternProperties: ts.TypeNode | ts.IndexSignatureDeclaration | undefined
-
-      if (current.args?.patternProperties) {
-        const allPatternSchemas = Object.values(current.args.patternProperties).flat()
-
-        if (allPatternSchemas.length > 0) {
-          patternProperties = allPatternSchemas
-            .map((it) => this.parse({ schema, parent: current, name, current: it, siblings: [] }, options))
-            .filter(Boolean)
-            .at(0) as ts.TypeNode
-
-          const isNullable = allPatternSchemas.some((schema) => isKeyword(schema, schemaKeywords.nullable))
-          if (isNullable) {
-            patternProperties = factory.createUnionDeclaration({
-              nodes: [patternProperties, factory.keywordTypeNodes.null],
-            }) as ts.TypeNode
-          }
-
-          patternProperties = factory.createIndexSignature(patternProperties)
-        }
-      }
-
-      return typeKeywordMapper.object([...properties, additionalProperties, patternProperties].filter(Boolean))
-    },
-    datetime() {
-      return typeKeywordMapper.datetime()
-    },
-    date(tree) {
-      const { current } = tree
-
-      return typeKeywordMapper.date(current.args.type)
-    },
-    time(tree) {
-      const { current } = tree
-
-      return typeKeywordMapper.time(current.args.type)
-    },
-  },
-})