@kubb/ast 5.0.0-beta.63 → 5.0.0-beta.65

package/src/macros/macroSimplifyUnion.ts

@@ -1,60 +0,0 @@
-import { defineMacro } from '../defineMacro.ts'
-import { narrowSchema } from '../guards.ts'
-import type { SchemaNode } from '../nodes/schema.ts'
-
-type ScalarPrimitive = 'string' | 'number' | 'integer' | 'bigint' | 'boolean'
-
-/**
- * Scalar primitive schema types used for union simplification and type narrowing.
- */
-const SCALAR_PRIMITIVE_TYPES = new Set<ScalarPrimitive>(['string', 'number', 'integer', 'bigint', 'boolean'])
-
-function isScalarPrimitive(type: string): type is ScalarPrimitive {
-  return SCALAR_PRIMITIVE_TYPES.has(type as ScalarPrimitive)
-}
-
-/**
- * Filters union members, dropping enum members that a broader scalar primitive already covers.
- */
-function simplifyUnionMembers(members: Array<SchemaNode>): Array<SchemaNode> {
-  const scalarPrimitives = new Set(members.filter((member) => isScalarPrimitive(member.type)).map((m) => m.type))
-  if (!scalarPrimitives.size) return members
-
-  return members.filter((member) => {
-    const enumNode = narrowSchema(member, 'enum')
-    if (!enumNode) return true
-
-    const primitive = enumNode.primitive
-    if (!primitive) return true
-
-    const enumValueCount = enumNode.namedEnumValues?.length ?? enumNode.enumValues?.length ?? 0
-    if (enumValueCount <= 1) return true
-
-    if (scalarPrimitives.has(primitive)) return false
-    if ((primitive === 'integer' || primitive === 'number') && (scalarPrimitives.has('integer') || scalarPrimitives.has('number'))) return false
-
-    return true
-  })
-}
-
-/**
- * Removes union members a broader scalar primitive already covers, such as a multi-value string enum
- * sitting next to a plain `string`. Single-value enums are kept.
- *
- * @example
- * ```ts
- * const next = applyMacros(unionSchema, [macroSimplifyUnion], { depth: 'shallow' })
- * ```
- */
-export const macroSimplifyUnion = defineMacro({
-  name: 'simplify-union',
-  schema(node) {
-    const unionNode = narrowSchema(node, 'union')
-    if (!unionNode?.members?.length) return undefined
-
-    const simplified = simplifyUnionMembers(unionNode.members)
-    if (simplified.length === unionNode.members.length) return undefined
-
-    return { ...unionNode, members: simplified }
-  },
-})

package/src/nodes/base.ts

@@ -1,49 +0,0 @@
-/**
- * `kind` values used by AST nodes.
- *
- * @example
- * ```ts
- * const kind: NodeKind = 'Schema'
- * ```
- */
-export type NodeKind =
-  | 'Input'
-  | 'Output'
-  | 'Operation'
-  | 'Schema'
-  | 'Property'
-  | 'Parameter'
-  | 'Response'
-  | 'RequestBody'
-  | 'Content'
-  | 'FunctionParameter'
-  | 'FunctionParameters'
-  | 'TypeLiteral'
-  | 'IndexedAccessType'
-  | 'ObjectBindingPattern'
-  | 'Type'
-  | 'File'
-  | 'Import'
-  | 'Export'
-  | 'Source'
-  | 'Const'
-  | 'Function'
-  | 'ArrowFunction'
-  | 'Text'
-  | 'Break'
-  | 'Jsx'
-
-/**
- * Base shape shared by all AST nodes.
- *
- * @example
- * ```ts
- * const base: BaseNode = { kind: 'Input' }
- * ```
- */
-export type BaseNode = {
-  /**
-   * Node discriminator.
-   */
-  kind: NodeKind
-}

package/src/nodes/code.ts

@@ -1,355 +0,0 @@
-import { defineNode } from '../defineNode.ts'
-import type { BaseNode } from './base.ts'
-
-/**
- * JSDoc documentation metadata attached to code declarations.
- */
-export type JSDocNode = {
-  /**
-   * JSDoc comment lines. `undefined` entries are filtered out during rendering.
-   *
-   * @example
-   * ```ts
-   * ['@description A pet resource', '@deprecated']
-   * ```
-   */
-  comments?: Array<string | undefined>
-}
-
-/**
- * AST node representing a TypeScript `const` declaration.
- *
- * Mirrors the props of the `Const` component from `@kubb/renderer-jsx`.
- * The `children` prop of the component is represented as `nodes`.
- *
- * @example
- * ```ts
- * createConst({ name: 'pet', export: true, asConst: true })
- * // export const pet = ... as const
- * ```
- */
-export type ConstNode = BaseNode & {
-  kind: 'Const'
-  /**
-   * Name of the constant declaration.
-   */
-  name: string
-  /**
-   * Whether the declaration should be exported.
-   */
-  export?: boolean | null
-  /**
-   * Explicit type annotation.
-   *
-   * @example Type reference
-   * `'Pet'`
-   */
-  type?: string | null
-  /**
-   * JSDoc documentation metadata.
-   */
-  JSDoc?: JSDocNode | null
-  /**
-   * Whether to append `as const` to the declaration.
-   */
-  asConst?: boolean | null
-  /**
-   * Child nodes representing the value of the constant (children of the `Const` component).
-   * Each entry is a {@link CodeNode}. Use {@link TextNode} for raw string content.
-   */
-  nodes?: Array<CodeNode>
-}
-
-/**
- * AST node representing a TypeScript `type` alias declaration.
- *
- * Mirrors the props of the `Type` component from `@kubb/renderer-jsx`.
- * The `children` prop of the component is represented as `nodes`.
- *
- * @example
- * ```ts
- * createType({ name: 'Pet', export: true })
- * // export type Pet = ...
- * ```
- */
-export type TypeNode = BaseNode & {
-  kind: 'Type'
-  /**
-   * Name of the type alias.
-   */
-  name: string
-  /**
-   * Whether the declaration should be exported.
-   */
-  export?: boolean | null
-  /**
-   * JSDoc documentation metadata.
-   */
-  JSDoc?: JSDocNode | null
-  /**
-   * Child nodes representing the type body (children of the `Type` component).
-   * Each entry is a {@link CodeNode}. Use {@link TextNode} for raw string content.
-   */
-  nodes?: Array<CodeNode>
-}
-
-/**
- * AST node representing a TypeScript `function` declaration.
- *
- * Mirrors the props of the `Function` component from `@kubb/renderer-jsx`.
- * The `children` prop of the component is represented as `nodes`.
- *
- * @example
- * ```ts
- * createFunctionDeclaration({ name: 'getPet', export: true, async: true, returnType: 'Pet' })
- * // export async function getPet(): Promise<Pet> { ... }
- * ```
- */
-export type FunctionNode = BaseNode & {
-  kind: 'Function'
-  /**
-   * Name of the function.
-   */
-  name: string
-  /**
-   * Whether the function is a default export.
-   */
-  default?: boolean | null
-  /**
-   * Function parameter list as a pre-rendered string, written verbatim between the parentheses.
-   *
-   * @example
-   * `'id: string, config: Config = {}'`
-   */
-  params?: string | null
-  /**
-   * Whether the function should be exported.
-   */
-  export?: boolean | null
-  /**
-   * Whether the function is async. When `true`, the return type is wrapped in `Promise<>`.
-   */
-  async?: boolean | null
-  /**
-   * TypeScript generic type parameters.
-   *
-   * @example Constrained generics
-   * `['T', 'U extends string']`
-   */
-  generics?: string | Array<string> | null
-  /**
-   * Return type annotation.
-   *
-   * @example Type reference
-   * `'Pet'`
-   */
-  returnType?: string | null
-  /**
-   * JSDoc documentation metadata.
-   */
-  JSDoc?: JSDocNode | null
-  /**
-   * Child nodes representing the function body (children of the `Function` component).
-   * Each entry is a {@link CodeNode}. Use {@link TextNode} for raw string content.
-   */
-  nodes?: Array<CodeNode>
-}
-
-/**
- * AST node representing a TypeScript arrow function (`const name = () => { ... }`).
- *
- * Mirrors the props of the `Function.Arrow` component from `@kubb/renderer-jsx`.
- * The `children` prop of the component is represented as `nodes`.
- *
- * @example
- * ```ts
- * createArrowFunctionDeclaration({ name: 'getPet', export: true, singleLine: true })
- * // export const getPet = () => ...
- * ```
- */
-export type ArrowFunctionNode = Omit<FunctionNode, 'kind'> & {
-  kind: 'ArrowFunction'
-  /**
-   * Render the arrow function body as a single-line expression.
-   */
-  singleLine?: boolean | null
-}
-
-/**
- * AST node representing a raw text/string fragment in the source output.
- *
- * Used instead of bare `string` values so that all entries in `nodes` arrays
- * are typed `CodeNode` objects rather than a mixed `CodeNode | string` union.
- *
- * @example
- * ```ts
- * createText('return fetch(id)')
- * // { kind: 'Text', value: 'return fetch(id)' }
- * ```
- */
-export type TextNode = BaseNode & {
-  kind: 'Text'
-  /**
-   * The raw string content.
-   */
-  value: string
-}
-
-/**
- * AST node representing a blank line in the source output.
- *
- * Corresponds to `<br/>` in JSX components. `printNodes` turns a `Break` between two
- * statements into one blank line. Consecutive breaks, and breaks at the start or end of
- * the list, are folded away, so a `Break` never produces more than one blank line.
- *
- * @example
- * ```ts
- * createBreak()
- * // { kind: 'Break' }
- * ```
- */
-export type BreakNode = BaseNode & {
-  kind: 'Break'
-}
-
-/**
- * AST node representing a raw JSX fragment in the source output.
- *
- * Mirrors the `Jsx` component from `@kubb/renderer-jsx`. Embeds raw JSX/TSX markup
- * (including fragments `<>…</>`) directly in generated code.
- *
- * @example
- * ```ts
- * createJsx('<>\n  <a href={href}>Open</a>\n</>')
- * // { kind: 'Jsx', value: '<>\n  <a href={href}>Open</a>\n</>' }
- * ```
- */
-export type JsxNode = BaseNode & {
-  kind: 'Jsx'
-  /**
-   * The raw JSX string content.
-   */
-  value: string
-}
-
-/**
- * Union of all code-generation AST nodes.
- *
- * These nodes mirror the JSX components from `@kubb/renderer-jsx` and are used as
- * structured children in {@link SourceNode.nodes}.
- */
-export type CodeNode = ConstNode | TypeNode | FunctionNode | ArrowFunctionNode | TextNode | BreakNode | JsxNode
-
-/**
- * Definition for the {@link ConstNode}.
- */
-export const constDef = defineNode<ConstNode>({ kind: 'Const' })
-
-/**
- * Definition for the {@link TypeNode}.
- */
-export const typeDef = defineNode<TypeNode>({ kind: 'Type' })
-
-/**
- * Definition for the {@link FunctionNode}.
- */
-export const functionDef = defineNode<FunctionNode>({ kind: 'Function' })
-
-/**
- * Definition for the {@link ArrowFunctionNode}.
- */
-export const arrowFunctionDef = defineNode<ArrowFunctionNode>({ kind: 'ArrowFunction' })
-
-/**
- * Definition for the {@link TextNode}.
- */
-export const textDef = defineNode<TextNode, string>({ kind: 'Text', build: (value) => ({ value }) })
-
-/**
- * Definition for the {@link BreakNode}.
- */
-export const breakDef = defineNode<BreakNode, void>({ kind: 'Break', build: () => ({}) })
-
-/**
- * Definition for the {@link JsxNode}.
- */
-export const jsxDef = defineNode<JsxNode, string>({ kind: 'Jsx', build: (value) => ({ value }) })
-
-/**
- * Creates a `ConstNode` representing a TypeScript `const` declaration.
- *
- * @example Exported constant with type and `as const`
- * ```ts
- * createConst({ name: 'pets', export: true, type: 'Pet[]', asConst: true })
- * // export const pets: Pet[] = ... as const
- * ```
- */
-export const createConst = constDef.create
-
-/**
- * Creates a `TypeNode` representing a TypeScript `type` alias declaration.
- *
- * @example
- * ```ts
- * createType({ name: 'Pet', export: true })
- * // export type Pet = ...
- * ```
- */
-export const createType = typeDef.create
-
-/**
- * Creates a `FunctionNode` representing a TypeScript `function` declaration.
- *
- * @example
- * ```ts
- * createFunction({ name: 'fetchPet', export: true, async: true, returnType: 'Pet' })
- * // export async function fetchPet(): Promise<Pet> { ... }
- * ```
- */
-export const createFunction = functionDef.create
-
-/**
- * Creates an `ArrowFunctionNode` representing a TypeScript arrow function.
- *
- * @example
- * ```ts
- * createArrowFunction({ name: 'double', export: true, params: 'n: number', singleLine: true })
- * // export const double = (n: number) => ...
- * ```
- */
-export const createArrowFunction = arrowFunctionDef.create
-
-/**
- * Creates a {@link TextNode} representing a raw string fragment in the source output.
- *
- * @example
- * ```ts
- * createText('return fetch(id)')
- * // { kind: 'Text', value: 'return fetch(id)' }
- * ```
- */
-export const createText = textDef.create
-
-/**
- * Creates a {@link BreakNode} representing a line break in the source output.
- *
- * @example
- * ```ts
- * createBreak()
- * // { kind: 'Break' }
- * ```
- */
-export function createBreak(): BreakNode {
-  return breakDef.create()
-}
-
-/**
- * Creates a {@link JsxNode} representing a raw JSX fragment in the source output.
- *
- * @example
- * ```ts
- * createJsx('<>\n  <a href={href}>Open</a>\n</>')
- * // { kind: 'Jsx', value: '<>\n  <a href={href}>Open</a>\n</>' }
- * ```
- */
-export const createJsx = jsxDef.create

package/src/nodes/content.ts

@@ -1,51 +0,0 @@
-import { defineNode } from '../defineNode.ts'
-import type { BaseNode } from './base.ts'
-import type { SchemaNode } from './schema.ts'
-
-/**
- * AST node representing one content-type entry of a request body or response.
- *
- * There is one entry per content type declared in the spec (e.g. `application/json`,
- * `multipart/form-data`), and each entry holds its own body schema.
- *
- * @example
- * ```ts
- * const content: ContentNode = {
- *   kind: 'Content',
- *   contentType: 'application/json',
- *   schema: createSchema({ type: 'string' }),
- * }
- * ```
- */
-export type ContentNode = BaseNode & {
-  /**
-   * Node kind.
-   */
-  kind: 'Content'
-  /**
-   * The content type for this entry (e.g. `'application/json'`).
-   */
-  contentType: string
-  /**
-   * Body schema for this content type.
-   */
-  schema?: SchemaNode
-  /**
-   * Property keys to exclude from the generated type via `Omit<Type, Keys>`.
-   * Set when a referenced schema has `readOnly`/`writeOnly` fields that should be omitted.
-   */
-  keysToOmit?: Array<string> | null
-}
-
-/**
- * Definition for the {@link ContentNode}.
- */
-export const contentDef = defineNode<ContentNode>({
-  kind: 'Content',
-  children: ['schema'],
-})
-
-/**
- * Creates a `ContentNode` for a single request-body or response content type.
- */
-export const createContent = contentDef.create