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

package/src/definePrinter.ts

@@ -1,258 +0,0 @@
-import type { SchemaNode, SchemaNodeByType, SchemaType } from './nodes/index.ts'
-
-/**
- * Runtime context passed as `this` to printer handlers.
- *
- * `this.transform` dispatches to node-level handlers from `nodes`.
- *
- * @example
- * ```ts
- * const context: PrinterHandlerContext<string, {}> = {
- *   options: {},
- *   transform: () => 'value',
- * }
- * ```
- */
-type PrinterHandlerContext<TOutput, TOptions extends object> = {
-  /**
-   * Recursively transform a nested `SchemaNode` to `TOutput` using the node-level handlers.
-   * Use `this.transform` inside `nodes` handlers and inside the `print` override.
-   */
-  transform: (node: SchemaNode) => TOutput | null
-  /**
-   * Options for this printer instance.
-   */
-  options: TOptions
-}
-
-/**
- * Handler for one schema node type.
- *
- * Use a regular function (not an arrow function) if you need `this`.
- *
- * @example
- * ```ts
- * const handler: PrinterHandler<string, {}, 'string'> = function () {
- *   return 'string'
- * }
- * ```
- */
-type PrinterHandler<TOutput, TOptions extends object, T extends SchemaType = SchemaType> = (
-  this: PrinterHandlerContext<TOutput, TOptions>,
-  node: SchemaNodeByType[T],
-) => TOutput | null
-
-/**
- * Partial map of per-node-type handler overrides for a printer.
- *
- * Each key is a `SchemaType` string (e.g. `'date'`, `'string'`).
- * Supply only the handlers you want to replace. The printer's built-in
- * defaults fill in the rest.
- *
- * @example
- * ```ts
- * pluginZod({
- *   printer: {
- *     nodes: {
- *       date(): string {
- *         return 'z.string().date()'
- *       },
- *     } satisfies PrinterPartial<string, PrinterZodOptions>,
- *   },
- * })
- * ```
- */
-export type PrinterPartial<TOutput, TOptions extends object> = Partial<{
-  [K in SchemaType]: PrinterHandler<TOutput, TOptions, K>
-}>
-
-/**
- * Generic shape used by `definePrinter`.
- *
- * - `TName` unique string identifier (e.g. `'zod'`, `'ts'`)
- * - `TOptions` options passed to and stored on the printer instance
- * - `TOutput` the type emitted by node handlers
- * - `TPrintOutput` type returned by public `print` (defaults to `TOutput`)
- *
- * @example
- * ```ts
- * type MyPrinter = PrinterFactoryOptions<'my', { strict: boolean }, string>
- * ```
- */
-export type PrinterFactoryOptions<TName extends string = string, TOptions extends object = object, TOutput = unknown, TPrintOutput = TOutput> = {
-  name: TName
-  options: TOptions
-  output: TOutput
-  printOutput: TPrintOutput
-}
-
-/**
- * Printer instance returned by a printer factory.
- *
- * @example
- * ```ts
- * const printer = definePrinter((options: {}) => ({ name: 'x', options, nodes: {} }))({})
- * ```
- */
-export type Printer<T extends PrinterFactoryOptions = PrinterFactoryOptions> = {
-  /**
-   * Unique identifier supplied at creation time.
-   */
-  name: T['name']
-  /**
-   * Options for this printer instance.
-   */
-  options: T['options']
-  /**
-   * Node-level dispatcher, converts a `SchemaNode` directly to `TOutput` using the `nodes` handlers.
-   * Always dispatches through the `nodes` map. Never calls the `print` override.
-   * Reach for it when you need the raw output (e.g. `ts.TypeNode`) without declaration wrapping.
-   */
-  transform: (node: SchemaNode) => T['output'] | null
-  /**
-   * Public printer. If the builder provides a root-level `print`, this calls that
-   * higher-level function (which may produce full declarations).
-   * Otherwise, falls back to the node-level dispatcher.
-   */
-  print: (node: SchemaNode) => T['printOutput'] | null
-}
-
-/**
- * Builder function passed to `definePrinter`.
- *
- * It receives resolved options and returns:
- * - `name`
- * - `options`
- * - `nodes` handlers
- * - optional top-level `print` override
- *
- * @example
- * ```ts
- * const build = (options: {}) => ({ name: 'x' as const, options, nodes: {} })
- * ```
- */
-type PrinterBuilder<T extends PrinterFactoryOptions> = (options: T['options']) => {
-  name: T['name']
-  /**
-   * Options to store on the printer.
-   */
-  options: T['options']
-  nodes: Partial<{
-    [K in SchemaType]: PrinterHandler<T['output'], T['options'], K>
-  }>
-  /**
-   * Optional root-level print override. When provided, becomes the public `printer.print`.
-   * Use `this.transform(node)` inside this function to dispatch to the node-level handlers (`nodes`),
-   * not the override itself, so recursion is safe.
-   */
-  print?: (this: PrinterHandlerContext<T['output'], T['options']>, node: SchemaNode) => T['printOutput'] | null
-}
-/**
- * Defines a schema printer: a function that takes a `SchemaNode` and emits
- * code in your target language. Each plugin that produces code from schemas
- * (TypeScript types, Zod schemas, Faker factories) ships a printer built
- * with this helper.
- *
- * The builder receives resolved options and returns:
- *
- * - `name` unique identifier for the printer.
- * - `options` stored on the returned printer instance.
- * - `nodes` map of `SchemaType` → handler. Handlers return the rendered
- *   output (a string, a TypeScript AST node, ...) for that schema type.
- * - `print` (optional), top-level override exposed as `printer.print`.
- *   Use `this.transform(node)` inside it to dispatch to `nodes` recursively.
- *
- * Without a `print` override, `printer.print` falls back to `printer.transform`
- * (the node-level dispatcher).
- *
- * @example Tiny Zod printer
- * ```ts
- * import { definePrinter, type PrinterFactoryOptions } from '@kubb/ast'
- *
- * type PrinterZod = PrinterFactoryOptions<'zod', { strict?: boolean }, string>
- *
- * export const zodPrinter = definePrinter<PrinterZod>((options) => ({
- *   name: 'zod',
- *   options: { strict: options.strict ?? true },
- *   nodes: {
- *     string: () => 'z.string()',
- *     object(node) {
- *       const props = node.properties
- *         .map((p) => `${p.name}: ${this.transform(p.schema)}`)
- *         .join(', ')
- *       return `z.object({ ${props} })`
- *     },
- *   },
- * }))
- * ```
- */
-export function definePrinter<T extends PrinterFactoryOptions = PrinterFactoryOptions>(build: PrinterBuilder<T>): (options?: T['options']) => Printer<T> {
-  return createPrinterFactory<SchemaNode, SchemaType, SchemaNodeByType>((node) => node.type)(build) as (options?: T['options']) => Printer<T>
-}
-
-/**
- * Generic printer factory behind `definePrinter`. Pass a `getKey` function that maps a node to its
- * handler key, and it returns a `definePrinter`-style helper for that node and key type. `definePrinter`
- * itself is this factory keyed by `node.type`.
- *
- * @example Key a printer by `node.kind` instead of `node.type`
- * ```ts
- * const defineFunctionPrinter = createPrinterFactory<FunctionParamNode, FunctionParamKind, Partial<Record<FunctionParamKind, FunctionParamNode>>>(
- *   (node) => node.kind,
- * )
- * ```
- */
-export function createPrinterFactory<TNode, TKey extends string, TNodeByKey extends Partial<Record<TKey, TNode>>>(getKey: (node: TNode) => TKey | null) {
-  return function <T extends PrinterFactoryOptions>(
-    build: (options: T['options']) => {
-      name: T['name']
-      options: T['options']
-      nodes: Partial<{
-        [K in TKey]: (
-          this: {
-            transform: (node: TNode) => T['output'] | null
-            options: T['options']
-          },
-          node: TNodeByKey[K],
-        ) => T['output'] | null
-      }>
-      print?: (
-        this: {
-          transform: (node: TNode) => T['output'] | null
-          options: T['options']
-        },
-        node: TNode,
-      ) => T['printOutput'] | null
-    },
-  ): (options?: T['options']) => {
-    name: T['name']
-    options: T['options']
-    transform: (node: TNode) => T['output'] | null
-    print: (node: TNode) => T['printOutput'] | null
-  } {
-    return (options) => {
-      const { name, options: resolvedOptions, nodes, print: printOverride } = build(options ?? ({} as T['options']))
-
-      const context = {
-        options: resolvedOptions,
-        transform: (node: TNode): T['output'] | null => {
-          const key = getKey(node)
-          if (key === null) return null
-
-          const handler = nodes[key]
-
-          if (!handler) return null
-
-          return (handler as (this: typeof context, node: TNode) => T['output'] | null).call(context, node)
-        },
-      }
-
-      return {
-        name,
-        options: resolvedOptions,
-        transform: context.transform,
-        print: (printOverride ? printOverride.bind(context) : context.transform) as (node: TNode) => T['printOutput'] | null,
-      }
-    }
-  }
-}

package/src/dialect.ts

@@ -1,86 +0,0 @@
-import type { Node } from './nodes/index.ts'
-
-/**
- * The spec-specific questions a schema parser answers while turning a source document into Kubb
- * AST nodes. The rest of the pipeline is generic JSON Schema, so this is the one seam where
- * OpenAPI, AsyncAPI, and plain JSON Schema differ.
- */
-export type SchemaDialect<TSchema = unknown, TRef = TSchema, TDiscriminated = TSchema, TDocument = unknown> = {
-  /**
-   * Whether the schema is nullable.
-   */
-  isNullable(schema?: TSchema): boolean
-  /**
-   * Whether the value is a `$ref` pointer.
-   */
-  isReference(value?: unknown): value is TRef
-  /**
-   * Whether the schema carries a discriminator for polymorphism.
-   */
-  isDiscriminator(value?: unknown): value is TDiscriminated
-  /**
-   * Whether the schema is binary data, converted to a `blob` node.
-   */
-  isBinary(schema: TSchema): boolean
-  /**
-   * Resolves a local `$ref` against the document, or nullish when it cannot.
-   */
-  resolveRef<TResolved>(document: TDocument, ref: string): TResolved | null | undefined
-}
-
-/**
- * How a dialect collapses structurally identical schemas into shared definitions. The contract is
- * generic over the plan and context types, which the adapter supplies. The mechanics live in the
- * adapter, not here, so `@kubb/ast` carries no dedupe logic. The returned plan owns the rewriting
- * behavior, so callers interact with one object.
- */
-export type Dedupe<TPlan = unknown, TContext = unknown> = {
-  /**
-   * Scans a forest of nodes and produces a plan describing which shapes to share.
-   */
-  plan(roots: ReadonlyArray<Node>, context: TContext): TPlan
-}
-
-/**
- * A spec adapter's dialect. `name` identifies it in logs and diagnostics, `schema` holds the
- * spec-specific schema questions the parser answers, and `dedupe` is the schema-sharing seam.
- */
-export type Dialect<TSchema = unknown, TRef = TSchema, TDiscriminated = TSchema, TDocument = unknown, TDedupe extends Dedupe = Dedupe> = {
-  /**
-   * Identifies the dialect in logs and diagnostics.
-   */
-  name: string
-  /**
-   * The spec-specific schema behavior. See {@link SchemaDialect}.
-   */
-  schema: SchemaDialect<TSchema, TRef, TDiscriminated, TDocument>
-  /**
-   * The schema-sharing behavior. See {@link Dedupe}.
-   */
-  dedupe: TDedupe
-}
-
-/**
- * Types a {@link Dialect} for an adapter. Adds no runtime behavior and only pins the
- * dialect's type for inference.
- *
- * @example
- * ```ts
- * export const oasDialect = defineDialect({
- *   name: 'oas',
- *   schema: {
- *     isNullable,
- *     isReference,
- *     isDiscriminator,
- *     isBinary: (schema) => schema.type === 'string' && schema.contentMediaType === 'application/octet-stream',
- *     resolveRef,
- *   },
- *   dedupe: { plan },
- * })
- * ```
- */
-export function defineDialect<TSchema, TRef, TDiscriminated, TDocument, TDedupe extends Dedupe>(
-  dialect: Dialect<TSchema, TRef, TDiscriminated, TDocument, TDedupe>,
-): Dialect<TSchema, TRef, TDiscriminated, TDocument, TDedupe> {
-  return dialect
-}

package/src/factory.ts

@@ -1,44 +0,0 @@
-import type { Node } from './nodes/index.ts'
-
-// Node constructors, grouped under the `factory` namespace the way the TypeScript compiler exposes
-// `ts.factory.createX`. Aggregating them here lets `export * as factory from './factory.ts'` in the
-// barrel surface every `createX` alongside the `createFile`/`update` helpers from a single module.
-export { createArrowFunction, createBreak, createConst, createFunction, createJsx, createText, createType } from './nodes/code.ts'
-export { createContent } from './nodes/content.ts'
-export { createExport, createFile, createImport, createSource } from './nodes/file.ts'
-export type { UserFileNode } from './nodes/file.ts'
-export { createFunctionParameter, createFunctionParameters, createIndexedAccessType, createObjectBindingPattern, createTypeLiteral } from './nodes/function.ts'
-export { createInput } from './nodes/input.ts'
-export { createOperation } from './nodes/operation.ts'
-export { createOutput } from './nodes/output.ts'
-export { createParameter } from './nodes/parameter.ts'
-export { createProperty } from './nodes/property.ts'
-export { createRequestBody } from './nodes/requestBody.ts'
-export { createResponse } from './nodes/response.ts'
-export { createSchema } from './nodes/schema.ts'
-
-/**
- * Identity-preserving node update: returns `node` unchanged when every field in
- * `changes` already equals (by reference) the current value, otherwise a new node
- * with the changes applied.
- *
- * Mirrors the TypeScript compiler's `factory.updateX` contract. Pair it with the
- * structural sharing in {@link transform} so a no-op rewrite does not allocate and
- * downstream passes can detect "nothing changed" by identity. Comparison is shallow,
- * so a structurally equal but newly allocated array or object counts as a change.
- *
- * @example
- * ```ts
- * update(node, { name: node.name })        // -> same `node` reference
- * update(node, { name: 'renamed' })        // -> new node, `name` replaced
- * ```
- */
-export function update<T extends Node>(node: T, changes: Partial<T>): T {
-  for (const key in changes) {
-    if (changes[key] !== node[key as keyof T]) {
-      return { ...node, ...changes }
-    }
-  }
-
-  return node
-}

package/src/guards.ts

@@ -1,28 +0,0 @@
-import type { HttpOperationNode, OperationNode, SchemaNode, SchemaNodeByType } from './nodes/index.ts'
-
-/**
- * Narrows a `SchemaNode` to the variant that matches `type`.
- *
- * @example
- * ```ts
- * const schema = createSchema({ type: 'string' })
- * const stringNode = narrowSchema(schema, 'string') // StringSchemaNode | null
- * ```
- */
-export function narrowSchema<T extends SchemaNode['type']>(node: SchemaNode | undefined, type: T): SchemaNodeByType[T] | null {
-  return node?.type === type ? (node as SchemaNodeByType[T]) : null
-}
-
-/**
- * Narrows an `OperationNode` to an `HttpOperationNode` so `method` and `path` are present.
- *
- * @example
- * ```ts
- * if (isHttpOperationNode(node)) {
- *   console.log(node.method, node.path)
- * }
- * ```
- */
-export function isHttpOperationNode(node: OperationNode): node is HttpOperationNode {
-  return node.protocol === 'http' || (node.method !== undefined && node.path !== undefined)
-}

package/src/index.ts

@@ -1,13 +0,0 @@
-export { schemaTypes } from './constants.ts'
-export { defineDialect } from './dialect.ts'
-export { isHttpOperationNode, narrowSchema } from './guards.ts'
-export { applyMacros, composeMacros, defineMacro } from './defineMacro.ts'
-export { defineNode } from './defineNode.ts'
-export { optionality } from './optionality.ts'
-export { createPrinterFactory, definePrinter } from './definePrinter.ts'
-export { signatureOf } from './signature.ts'
-export { collect, transform, walk } from './visitor.ts'
-
-export * as factory from './factory.ts'
-export * from './registry.ts'
-export type * from './types.ts'

package/src/infer.ts

@@ -1,132 +0,0 @@
-import type {
-  ArraySchemaNode,
-  DateSchemaNode,
-  DatetimeSchemaNode,
-  EnumSchemaNode,
-  IntersectionSchemaNode,
-  NumberSchemaNode,
-  ObjectSchemaNode,
-  RefSchemaNode,
-  ScalarSchemaNode,
-  SchemaNode,
-  StringSchemaNode,
-  TimeSchemaNode,
-  UnionSchemaNode,
-  UrlSchemaNode,
-} from './nodes/index.ts'
-
-/**
- * Options that control how the adapter parser maps OpenAPI schemas to AST nodes.
- */
-export type ParserOptions = {
-  /**
-   * How `format: 'date-time'` schemas are represented downstream.
-   * - `false` falls through to a plain `string` (no validation).
-   * - `'string'` emits a datetime string node.
-   * - `'stringOffset'` emits a datetime node with timezone offset.
-   * - `'stringLocal'` emits a local datetime node.
-   * - `'date'` emits a `date` node (JavaScript `Date` object).
-   */
-  dateType: false | 'string' | 'stringOffset' | 'stringLocal' | 'date'
-  /**
-   * How `type: 'integer'` (and `format: 'int64'`) maps to TypeScript.
-   * - `'bigint'` is exact for 64-bit IDs, but does not round-trip through JSON.
-   * - `'number'` fits most JSON APIs. Loses precision above `Number.MAX_SAFE_INTEGER`.
-   *
-   * @default 'bigint'
-   */
-  integerType?: 'number' | 'bigint'
-  /**
-   * AST type used when a schema's type cannot be inferred from the spec
-   * (`additionalProperties: true`, missing `type`, ...).
-   */
-  unknownType: 'any' | 'unknown' | 'void'
-  /**
-   * AST type used for completely empty schemas (`{}`).
-   */
-  emptySchemaType: 'any' | 'unknown' | 'void'
-  /**
-   * Suffix appended to derived enum names when Kubb has to invent one
-   * (typically for inline enums on object properties).
-   */
-  enumSuffix: 'enum' | (string & {})
-}
-
-/**
- * Maps each `dateType` option value to the AST node produced by `format: 'date-time'`.
- */
-type DateTimeNodeByDateType = {
-  date: DateSchemaNode
-  string: DatetimeSchemaNode
-  stringOffset: DatetimeSchemaNode
-  stringLocal: DatetimeSchemaNode
-  false: StringSchemaNode
-}
-
-/**
- * Resolves the AST node produced by `format: 'date-time'` based on the `dateType` option.
- */
-type ResolveDateTimeNode<TDateType extends ParserOptions['dateType']> = DateTimeNodeByDateType[TDateType extends keyof DateTimeNodeByDateType
-  ? TDateType
-  : 'string']
-
-/**
- * Ordered list of `[schema-shape, SchemaNode]` pairs.
- * `InferSchemaNode` walks this tuple in order and returns the first matching node type.
- */
-type SchemaNodeMap<TDateType extends ParserOptions['dateType'] = 'string'> = [
-  [{ $ref: string }, RefSchemaNode],
-  [{ allOf: ReadonlyArray<unknown>; properties: object }, IntersectionSchemaNode],
-  [{ allOf: readonly [unknown, unknown, ...Array<unknown>] }, IntersectionSchemaNode],
-  [{ allOf: ReadonlyArray<unknown> }, SchemaNode],
-  [{ oneOf: ReadonlyArray<unknown> }, UnionSchemaNode],
-  [{ anyOf: ReadonlyArray<unknown> }, UnionSchemaNode],
-  [{ const: null }, ScalarSchemaNode],
-  [{ const: string | number | boolean }, EnumSchemaNode],
-  [{ type: ReadonlyArray<string> }, UnionSchemaNode],
-  [{ type: 'array'; enum: ReadonlyArray<unknown> }, ArraySchemaNode],
-  [{ enum: ReadonlyArray<unknown> }, EnumSchemaNode],
-  [{ type: 'enum' }, EnumSchemaNode],
-  [{ type: 'union' }, UnionSchemaNode],
-  [{ type: 'intersection' }, IntersectionSchemaNode],
-  [{ type: 'tuple' }, ArraySchemaNode],
-  [{ type: 'ref' }, RefSchemaNode],
-  [{ type: 'datetime' }, DatetimeSchemaNode],
-  [{ type: 'date' }, DateSchemaNode],
-  [{ type: 'time' }, TimeSchemaNode],
-  [{ type: 'url' }, UrlSchemaNode],
-  [{ type: 'object' }, ObjectSchemaNode],
-  [{ additionalProperties: boolean | {} }, ObjectSchemaNode],
-  [{ type: 'array' }, ArraySchemaNode],
-  [{ items: object }, ArraySchemaNode],
-  [{ prefixItems: ReadonlyArray<unknown> }, ArraySchemaNode],
-  [{ type: string; format: 'date-time' }, ResolveDateTimeNode<TDateType>],
-  [{ type: string; format: 'date' }, DateSchemaNode],
-  [{ type: string; format: 'time' }, TimeSchemaNode],
-  [{ format: 'date-time' }, ResolveDateTimeNode<TDateType>],
-  [{ format: 'date' }, DateSchemaNode],
-  [{ format: 'time' }, TimeSchemaNode],
-  [{ type: 'string' }, StringSchemaNode],
-  [{ type: 'number' }, NumberSchemaNode],
-  [{ type: 'integer' }, NumberSchemaNode],
-  [{ type: 'bigint' }, NumberSchemaNode],
-  [{ type: string }, ScalarSchemaNode],
-  [{ minLength: number }, StringSchemaNode],
-  [{ maxLength: number }, StringSchemaNode],
-  [{ pattern: string }, StringSchemaNode],
-  [{ minimum: number }, NumberSchemaNode],
-  [{ maximum: number }, NumberSchemaNode],
-]
-
-/**
- * Infers the matching AST `SchemaNode` type from an input schema shape.
- */
-export type InferSchemaNode<
-  TSchema extends object,
-  TDateType extends ParserOptions['dateType'] = 'string',
-  TEntries extends ReadonlyArray<[object, SchemaNode]> = SchemaNodeMap<TDateType>,
-> = TEntries extends [infer TEntry extends [object, SchemaNode], ...infer TRest extends ReadonlyArray<[object, SchemaNode]>]
-  ? TSchema extends TEntry[0]
-    ? TEntry[1]
-    : InferSchemaNode<TSchema, TDateType, TRest>
-  : SchemaNode

package/src/macros/index.ts

@@ -1,3 +0,0 @@
-export { macroDiscriminatorEnum } from './macroDiscriminatorEnum.ts'
-export { macroEnumName } from './macroEnumName.ts'
-export { macroSimplifyUnion } from './macroSimplifyUnion.ts'

package/src/macros/macroDiscriminatorEnum.ts

@@ -1,50 +0,0 @@
-import { defineMacro } from '../defineMacro.ts'
-import { narrowSchema } from '../guards.ts'
-import { createProperty } from '../nodes/property.ts'
-import { createSchema } from '../nodes/schema.ts'
-
-type Props = {
-  propertyName: string
-  values: Array<string>
-  enumName?: string
-}
-
-/**
- * Builds a macro that replaces a discriminator property's schema with a string enum of the given
- * values. Object schemas that lack the property are returned unchanged.
- *
- * @example
- * ```ts
- * const macro = macroDiscriminatorEnum({ propertyName: 'type', values: ['dog', 'cat'] })
- * const next = applyMacros(objectSchema, [macro], { depth: 'shallow' })
- * ```
- */
-export function macroDiscriminatorEnum({ propertyName, values, enumName }: Props) {
-  return defineMacro({
-    name: 'discriminator-enum',
-    schema(node) {
-      const objectNode = narrowSchema(node, 'object')
-      if (!objectNode?.properties?.length) return undefined
-      if (!objectNode.properties.some((prop) => prop.name === propertyName)) return undefined
-
-      return createSchema({
-        ...objectNode,
-        properties: objectNode.properties.map((prop) => {
-          if (prop.name !== propertyName) return prop
-
-          return createProperty({
-            ...prop,
-            schema: createSchema({
-              type: 'enum',
-              primitive: 'string',
-              enumValues: values,
-              name: enumName,
-              readOnly: prop.schema.readOnly,
-              writeOnly: prop.schema.writeOnly,
-            }),
-          })
-        }),
-      })
-    },
-  })
-}

package/src/macros/macroEnumName.ts

@@ -1,33 +0,0 @@
-import { defineMacro } from '../defineMacro.ts'
-import { narrowSchema } from '../guards.ts'
-import { enumPropName } from '../utils/refs.ts'
-
-type Props = {
-  parentName: string | null | undefined
-  propName: string
-  enumSuffix: string
-}
-
-/**
- * Builds a macro that names an inline enum schema from its parent and property name. Boolean enums
- * are left anonymous. Non-enum nodes are returned unchanged.
- *
- * @example
- * ```ts
- * const macro = macroEnumName({ parentName: 'Pet', propName: 'status', enumSuffix: 'enum' })
- * const named = applyMacros(propSchema, [macro], { depth: 'shallow' })
- * ```
- */
-export function macroEnumName({ parentName, propName, enumSuffix }: Props) {
-  return defineMacro({
-    name: 'enum-name',
-    schema(node) {
-      const enumNode = narrowSchema(node, 'enum')
-
-      if (enumNode?.primitive === 'boolean') return { ...node, name: null }
-      if (enumNode) return { ...node, name: enumPropName(parentName, propName, enumSuffix) }
-
-      return undefined
-    },
-  })
-}