@kubb/ast 5.0.0-beta.80 → 5.0.0-beta.82

package/dist/defineMacro-DzsACbFo.d.ts

@@ -1,466 +0,0 @@
-import { n as __name } from "./rolldown-runtime-CNktS9qV.js";
-import { B as ContentNode, C as ParameterNode, et as SchemaNode, f as OperationNode, h as ResponseNode, lt as PropertyNode, n as OutputNode, o as InputNode, t as Node, y as RequestBodyNode } from "./index-Cu2zmNxv.js";
-
-//#region src/constants.d.ts
-/**
- * Traversal depth for AST visitor utilities.
- *
- * - `'shallow'` visits only the immediate node, skipping children.
- * - `'deep'` recursively visits all descendant nodes.
- */
-type VisitorDepth = 'shallow' | 'deep';
-/**
- * Schema type discriminators used by all AST schema nodes.
- *
- * Each value is a stable discriminator across the AST (for example `schema.type === schemaTypes.object`).
- */
-declare const schemaTypes: {
-  /**
-   * Text value.
-   */
-  readonly string: "string";
-  /**
-   * Floating-point number (`float`, `double`).
-   */
-  readonly number: "number";
-  /**
-   * Whole number (`int32`). Use `bigint` for `int64`.
-   */
-  readonly integer: "integer";
-  /**
-   * 64-bit integer (`int64`). Only used when `integerType` is set to `'bigint'`.
-   */
-  readonly bigint: "bigint";
-  /**
-   * Boolean value.
-   */
-  readonly boolean: "boolean";
-  /**
-   * Explicit null value.
-   */
-  readonly null: "null";
-  /**
-   * Any value (no type restriction).
-   */
-  readonly any: "any";
-  /**
-   * Unknown value (must be narrowed before usage).
-   */
-  readonly unknown: "unknown";
-  /**
-   * No return value (`void`).
-   */
-  readonly void: "void";
-  /**
-   * Object with named properties.
-   */
-  readonly object: "object";
-  /**
-   * Sequential list of items.
-   */
-  readonly array: "array";
-  /**
-   * Fixed-length list with position-specific items.
-   */
-  readonly tuple: "tuple";
-  /**
-   * "One of" multiple schema members.
-   */
-  readonly union: "union";
-  /**
-   * "All of" multiple schema members.
-   */
-  readonly intersection: "intersection";
-  /**
-   * Enum schema.
-   */
-  readonly enum: "enum";
-  /**
-   * Reference to another schema.
-   */
-  readonly ref: "ref";
-  /**
-   * Calendar date (for example `2026-03-24`).
-   */
-  readonly date: "date";
-  /**
-   * Date-time value (for example `2026-03-24T09:00:00Z`).
-   */
-  readonly datetime: "datetime";
-  /**
-   * Time-only value (for example `09:00:00`).
-   */
-  readonly time: "time";
-  /**
-   * UUID value.
-   */
-  readonly uuid: "uuid";
-  /**
-   * Email address value.
-   */
-  readonly email: "email";
-  /**
-   * URL value.
-   */
-  readonly url: "url";
-  /**
-   * IPv4 address value.
-   */
-  readonly ipv4: "ipv4";
-  /**
-   * IPv6 address value.
-   */
-  readonly ipv6: "ipv6";
-  /**
-   * Binary/blob value.
-   */
-  readonly blob: "blob";
-  /**
-   * Impossible value (`never`).
-   */
-  readonly never: "never";
-};
-//#endregion
-//#region src/visitor.d.ts
-/**
- * Ordered mapping of `[NodeType, ParentType]` pairs.
- *
- * `ParentOf` uses this map to find parent types.
- */
-type ParentNodeMap = [[InputNode, undefined], [OutputNode, undefined], [OperationNode, InputNode], [RequestBodyNode, OperationNode], [ContentNode, RequestBodyNode | ResponseNode], [SchemaNode, InputNode | ContentNode | SchemaNode | PropertyNode | ParameterNode], [PropertyNode, SchemaNode], [ParameterNode, OperationNode], [ResponseNode, OperationNode]];
-/**
- * Resolves the parent node type for a given AST node type.
- *
- * Visitor context relies on this so `ctx.parent` is typed for each callback.
- *
- * @example
- * ```ts
- * type InputParent = ParentOf<InputNode>
- * // undefined
- * ```
- *
- * @example
- * ```ts
- * type PropertyParent = ParentOf<PropertyNode>
- * // SchemaNode
- * ```
- *
- * @example
- * ```ts
- * type SchemaParent = ParentOf<SchemaNode>
- * // InputNode | ContentNode | SchemaNode | PropertyNode | ParameterNode
- * ```
- */
-type ParentOf<T extends Node, TEntries extends ReadonlyArray<[Node, unknown]> = ParentNodeMap> = TEntries extends [infer TEntry extends [Node, unknown], ...infer TRest extends ReadonlyArray<[Node, unknown]>] ? T extends TEntry[0] ? TEntry[1] : ParentOf<T, TRest> : Node;
-/**
- * Traversal context passed as the second argument to every visitor callback.
- * `parent` is typed from the current node type.
- *
- * @example
- * ```ts
- * const visitor: Visitor = {
- *   schema(node, { parent }) {
- *     // parent type is narrowed by node kind
- *   },
- * }
- * ```
- */
-type VisitorContext<T extends Node = Node> = {
-  /**
-   * Parent node of the currently visited node.
-   * For `InputNode`, this is `undefined`.
-   */
-  parent?: ParentOf<T>;
-};
-/**
- * Synchronous visitor consumed by `transform`. Each optional callback runs
- * for the matching node type. Return a new node to replace it, or `undefined`
- * to leave it untouched.
- *
- * Plugins typically expose `transformer` so users can supply a `Visitor` that
- * rewrites the AST before printing.
- *
- * @example Prefix every operationId
- * ```ts
- * const visitor: Visitor = {
- *   operation(node) {
- *     return { ...node, operationId: `api_${node.operationId}` }
- *   },
- * }
- * ```
- *
- * @example Strip schema descriptions
- * ```ts
- * const visitor: Visitor = {
- *   schema(node) {
- *     return { ...node, description: undefined }
- *   },
- * }
- * ```
- */
-type Visitor = {
-  input?(node: InputNode, context: VisitorContext<InputNode>): undefined | null | InputNode;
-  output?(node: OutputNode, context: VisitorContext<OutputNode>): undefined | null | OutputNode;
-  operation?(node: OperationNode, context: VisitorContext<OperationNode>): undefined | null | OperationNode;
-  schema?(node: SchemaNode, context: VisitorContext<SchemaNode>): undefined | null | SchemaNode;
-  property?(node: PropertyNode, context: VisitorContext<PropertyNode>): undefined | null | PropertyNode;
-  parameter?(node: ParameterNode, context: VisitorContext<ParameterNode>): undefined | null | ParameterNode;
-  response?(node: ResponseNode, context: VisitorContext<ResponseNode>): undefined | null | ResponseNode;
-};
-/**
- * A visitor callback result that may be sync or async.
- */
-type MaybePromise<T> = T | Promise<T>;
-/**
- * Async visitor for `walk`. Synchronous `Visitor` objects are compatible.
- *
- * @example
- * ```ts
- * const visitor: AsyncVisitor = {
- *   async operation(node) {
- *     await Promise.resolve(node.operationId)
- *   },
- * }
- * ```
- */
-type AsyncVisitor = {
-  input?(node: InputNode, context: VisitorContext<InputNode>): MaybePromise<undefined | null | InputNode>;
-  output?(node: OutputNode, context: VisitorContext<OutputNode>): MaybePromise<undefined | null | OutputNode>;
-  operation?(node: OperationNode, context: VisitorContext<OperationNode>): MaybePromise<undefined | null | OperationNode>;
-  schema?(node: SchemaNode, context: VisitorContext<SchemaNode>): MaybePromise<undefined | null | SchemaNode>;
-  property?(node: PropertyNode, context: VisitorContext<PropertyNode>): MaybePromise<undefined | null | PropertyNode>;
-  parameter?(node: ParameterNode, context: VisitorContext<ParameterNode>): MaybePromise<undefined | null | ParameterNode>;
-  response?(node: ResponseNode, context: VisitorContext<ResponseNode>): MaybePromise<undefined | null | ResponseNode>;
-};
-/**
- * Visitor used by `collect`.
- *
- * @example
- * ```ts
- * const visitor: CollectVisitor<string> = {
- *   operation(node) {
- *     return node.operationId
- *   },
- * }
- * ```
- */
-type CollectVisitor<T> = {
-  input?(node: InputNode, context: VisitorContext<InputNode>): T | null | undefined;
-  output?(node: OutputNode, context: VisitorContext<OutputNode>): T | null | undefined;
-  operation?(node: OperationNode, context: VisitorContext<OperationNode>): T | null | undefined;
-  schema?(node: SchemaNode, context: VisitorContext<SchemaNode>): T | null | undefined;
-  property?(node: PropertyNode, context: VisitorContext<PropertyNode>): T | null | undefined;
-  parameter?(node: ParameterNode, context: VisitorContext<ParameterNode>): T | null | undefined;
-  response?(node: ResponseNode, context: VisitorContext<ResponseNode>): T | null | undefined;
-};
-/**
- * Options for `transform`.
- *
- * @example
- * ```ts
- * const options: TransformOptions = { depth: 'deep', schema: (node) => node }
- * ```
- *
- * @example
- * ```ts
- * // Only transform the current node, not nested children
- * const options: TransformOptions = { depth: 'shallow', schema: (node) => node }
- * ```
- */
-type TransformOptions = Visitor & {
-  /**
-   * Traversal depth.
-   * @default 'deep'
-   */
-  depth?: VisitorDepth;
-  /**
-   * Internal parent override used during recursion.
-   */
-  parent?: Node;
-};
-/**
- * Options for `walk`.
- *
- * @example
- * ```ts
- * const options: WalkOptions = { depth: 'deep', concurrency: 10, root: () => {} }
- * ```
- */
-type WalkOptions = AsyncVisitor & {
-  /**
-   * Traversal depth.
-   * @default 'deep'
-   */
-  depth?: VisitorDepth;
-  /**
-   * Maximum number of sibling nodes visited concurrently.
-   * @default 30
-   */
-  concurrency?: number;
-};
-/**
- * Options for `collect`.
- *
- * @example
- * ```ts
- * const options: CollectOptions<string> = { depth: 'shallow', schema: () => undefined }
- * ```
- */
-type CollectOptions<T> = CollectVisitor<T> & {
-  /**
-   * Traversal depth.
-   * @default 'deep'
-   */
-  depth?: VisitorDepth;
-  /**
-   * Internal parent override used during recursion.
-   */
-  parent?: Node;
-};
-/**
- * Async depth-first traversal for side effects. Visitor return values are
- * ignored. Use `transform` when you want to rewrite nodes.
- *
- * Sibling nodes at each depth run concurrently up to `options.concurrency`
- * (defaults to `WALK_CONCURRENCY`). Higher values overlap I/O-bound visitor
- * work. Lower values reduce memory pressure.
- *
- * @example Log every operation
- * ```ts
- * await walk(root, {
- *   operation(node) {
- *     console.log(node.operationId)
- *   },
- * })
- * ```
- *
- * @example Only visit the root node
- * ```ts
- * await walk(root, { depth: 'shallow', input: () => {} })
- * ```
- */
-declare function walk(node: Node, options: WalkOptions): Promise<void>;
-/**
- * Synchronous depth-first transform. Each visitor callback can return a
- * replacement node. Returning `undefined` keeps the original.
- *
- * The original tree is never mutated, a new tree is returned. Pass
- * `depth: 'shallow'` to skip recursion into children.
- *
- * @example Prefix every operationId
- * ```ts
- * const next = transform(root, {
- *   operation(node) {
- *     return { ...node, operationId: `prefixed_${node.operationId}` }
- *   },
- * })
- * ```
- *
- * @example Replace only the root node
- * ```ts
- * const next = transform(root, {
- *   depth: 'shallow',
- *   input: (node) => ({ ...node, meta: { ...node.meta, title: 'Rewritten' } }),
- * })
- * ```
- */
-declare function transform(node: InputNode, options: TransformOptions): InputNode;
-declare function transform(node: OutputNode, options: TransformOptions): OutputNode;
-declare function transform(node: OperationNode, options: TransformOptions): OperationNode;
-declare function transform(node: SchemaNode, options: TransformOptions): SchemaNode;
-declare function transform(node: PropertyNode, options: TransformOptions): PropertyNode;
-declare function transform(node: ParameterNode, options: TransformOptions): ParameterNode;
-declare function transform(node: ResponseNode, options: TransformOptions): ResponseNode;
-declare function transform(node: Node, options: TransformOptions): Node;
-/**
- * Eager depth-first collection pass. Gathers every non-null value the visitor
- * callbacks return into an array.
- *
- * @example Collect every operationId
- * ```ts
- * const ids = collect<string>(root, {
- *   operation(node) {
- *     return node.operationId
- *   },
- * })
- * ```
- */
-declare function collect<T>(node: Node, options: CollectOptions<T>): Array<T>;
-//#endregion
-//#region src/defineMacro.d.ts
-/**
- * Ordering hint shared by macros and plugins. `pre` runs before unmarked items, `post` after,
- * and `undefined` keeps declaration order.
- */
-type Enforce = 'pre' | 'post';
-/**
- * A named, composable transform over the Kubb AST. It carries the same per-kind callbacks as a
- * {@link Visitor} (`schema`, `operation`, …), plus a `name`, an optional `enforce` order, and an
- * optional `when` gate. Macros run on the shared AST, so the same macro works across every adapter
- * and output target. Exports follow the `macro<Name>` convention, mirroring plugins (`pluginTs`).
- */
-type Macro = Visitor & {
-  /**
-   * Macro identifier used to tell macros apart, for example `'simplify-union'`.
-   */
-  name: string;
-  /**
-   * Ordering hint. `pre` macros run before unmarked macros, `post` macros run after.
-   * Ordering within a bucket follows list order.
-   */
-  enforce?: Enforce;
-  /**
-   * Gate checked against the current node before any callback runs. When it returns `false`
-   * the macro is skipped for that node.
-   */
-  when?: (node: Node) => boolean;
-};
-/**
- * Types a macro for inference and a single construction site, mirroring `definePlugin`.
- * Adds no runtime behavior.
- *
- * @example
- * ```ts
- * const macroUntagged = defineMacro({
- *   name: 'untagged',
- *   operation(node) {
- *     return node.tags?.length ? undefined : { ...node, tags: ['untagged'] }
- *   },
- * })
- * ```
- */
-declare function defineMacro(macro: Macro): Macro;
-/**
- * Folds an ordered list of macros into a single {@link Visitor} that `transform` (and the per-plugin
- * transform layer in `@kubb/core`) can run. Macros are stable-sorted by `enforce`, then applied
- * sequentially per node so later macros see earlier output. This differs from a plain visitor, which
- * has no names, ordering, or composition.
- *
- * @example
- * ```ts
- * const visitor = composeMacros([macroSimplifyUnion, macroDiscriminatorEnum])
- * const next = transform(root, visitor)
- * ```
- */
-declare function composeMacros(macros: ReadonlyArray<Macro>): Visitor;
-/**
- * Runs a list of macros over a node tree and returns the rewritten tree. Keeps `transform`'s
- * structural sharing, so an empty or no-op macro list returns the same reference. Pass
- * `depth: 'shallow'` to rewrite the root node only.
- *
- * @example
- * ```ts
- * const next = applyMacros(root, [macroIntegerToString])
- * ```
- *
- * @example Apply to the root node only
- * ```ts
- * const named = applyMacros(node, [macroEnumName({ parentName, propName, enumSuffix })], { depth: 'shallow' })
- * ```
- */
-declare function applyMacros<TNode extends Node>(root: TNode, macros: ReadonlyArray<Macro>, options?: {
-  depth?: VisitorDepth;
-}): TNode;
-//#endregion
-export { defineMacro as a, VisitorContext as c, walk as d, schemaTypes as f, composeMacros as i, collect as l, Macro as n, ParentOf as o, applyMacros as r, Visitor as s, Enforce as t, transform as u };
-//# sourceMappingURL=defineMacro-DzsACbFo.d.ts.map

package/dist/macros.cjs

@@ -1,130 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_visitor = require("./visitor-h6dEM3vR.cjs");
-const require_defineMacro = require("./defineMacro-DmGR7vfu.cjs");
-const require_refs = require("./refs-Bg3rmujP.cjs");
-//#region src/macros/macroDiscriminatorEnum.ts
-/**
-* 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' })
-* ```
-*/
-function macroDiscriminatorEnum({ propertyName, values, enumName }) {
-	return require_defineMacro.defineMacro({
-		name: "discriminator-enum",
-		schema(node) {
-			const objectNode = require_visitor.narrowSchema(node, "object");
-			if (!objectNode?.properties?.length) return void 0;
-			if (!objectNode.properties.some((prop) => prop.name === propertyName)) return void 0;
-			return require_visitor.createSchema({
-				...objectNode,
-				properties: objectNode.properties.map((prop) => {
-					if (prop.name !== propertyName) return prop;
-					return require_visitor.createProperty({
-						...prop,
-						schema: require_visitor.createSchema({
-							type: "enum",
-							primitive: "string",
-							enumValues: values,
-							name: enumName,
-							readOnly: prop.schema.readOnly,
-							writeOnly: prop.schema.writeOnly
-						})
-					});
-				})
-			});
-		}
-	});
-}
-//#endregion
-//#region src/macros/macroEnumName.ts
-/**
-* 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' })
-* ```
-*/
-function macroEnumName({ parentName, propName, enumSuffix }) {
-	return require_defineMacro.defineMacro({
-		name: "enum-name",
-		schema(node) {
-			const enumNode = require_visitor.narrowSchema(node, "enum");
-			if (enumNode?.primitive === "boolean") return {
-				...node,
-				name: null
-			};
-			if (enumNode) return {
-				...node,
-				name: require_refs.enumPropName(parentName, propName, enumSuffix)
-			};
-		}
-	});
-}
-//#endregion
-//#region src/macros/macroSimplifyUnion.ts
-/**
-* Scalar primitive schema types used for union simplification and type narrowing.
-*/
-const SCALAR_PRIMITIVE_TYPES = /* @__PURE__ */ new Set([
-	"string",
-	"number",
-	"integer",
-	"bigint",
-	"boolean"
-]);
-function isScalarPrimitive(type) {
-	return SCALAR_PRIMITIVE_TYPES.has(type);
-}
-/**
-* Filters union members, dropping enum members that a broader scalar primitive already covers.
-*/
-function simplifyUnionMembers(members) {
-	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 = require_visitor.narrowSchema(member, "enum");
-		if (!enumNode) return true;
-		const primitive = enumNode.primitive;
-		if (!primitive) return true;
-		if ((enumNode.namedEnumValues?.length ?? enumNode.enumValues?.length ?? 0) <= 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' })
-* ```
-*/
-const macroSimplifyUnion = require_defineMacro.defineMacro({
-	name: "simplify-union",
-	schema(node) {
-		const unionNode = require_visitor.narrowSchema(node, "union");
-		if (!unionNode?.members?.length) return void 0;
-		const simplified = simplifyUnionMembers(unionNode.members);
-		if (simplified.length === unionNode.members.length) return void 0;
-		return {
-			...unionNode,
-			members: simplified
-		};
-	}
-});
-//#endregion
-exports.macroDiscriminatorEnum = macroDiscriminatorEnum;
-exports.macroEnumName = macroEnumName;
-exports.macroSimplifyUnion = macroSimplifyUnion;
-
-//# sourceMappingURL=macros.cjs.map

package/dist/macros.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"macros.cjs","names":["defineMacro","narrowSchema","createSchema","createProperty","defineMacro","narrowSchema","enumPropName","narrowSchema","defineMacro"],"sources":["../src/macros/macroDiscriminatorEnum.ts","../src/macros/macroEnumName.ts","../src/macros/macroSimplifyUnion.ts"],"sourcesContent":["import { defineMacro } from '../defineMacro.ts'\nimport { narrowSchema } from '../guards.ts'\nimport { createProperty } from '../nodes/property.ts'\nimport { createSchema } from '../nodes/schema.ts'\n\ntype Props = {\n  propertyName: string\n  values: Array<string>\n  enumName?: string\n}\n\n/**\n * Builds a macro that replaces a discriminator property's schema with a string enum of the given\n * values. Object schemas that lack the property are returned unchanged.\n *\n * @example\n * ```ts\n * const macro = macroDiscriminatorEnum({ propertyName: 'type', values: ['dog', 'cat'] })\n * const next = applyMacros(objectSchema, [macro], { depth: 'shallow' })\n * ```\n */\nexport function macroDiscriminatorEnum({ propertyName, values, enumName }: Props) {\n  return defineMacro({\n    name: 'discriminator-enum',\n    schema(node) {\n      const objectNode = narrowSchema(node, 'object')\n      if (!objectNode?.properties?.length) return undefined\n      if (!objectNode.properties.some((prop) => prop.name === propertyName)) return undefined\n\n      return createSchema({\n        ...objectNode,\n        properties: objectNode.properties.map((prop) => {\n          if (prop.name !== propertyName) return prop\n\n          return createProperty({\n            ...prop,\n            schema: createSchema({\n              type: 'enum',\n              primitive: 'string',\n              enumValues: values,\n              name: enumName,\n              readOnly: prop.schema.readOnly,\n              writeOnly: prop.schema.writeOnly,\n            }),\n          })\n        }),\n      })\n    },\n  })\n}\n","import { defineMacro } from '../defineMacro.ts'\nimport { narrowSchema } from '../guards.ts'\nimport { enumPropName } from '../utils/refs.ts'\n\ntype Props = {\n  parentName: string | null | undefined\n  propName: string\n  enumSuffix: string\n}\n\n/**\n * Builds a macro that names an inline enum schema from its parent and property name. Boolean enums\n * are left anonymous. Non-enum nodes are returned unchanged.\n *\n * @example\n * ```ts\n * const macro = macroEnumName({ parentName: 'Pet', propName: 'status', enumSuffix: 'enum' })\n * const named = applyMacros(propSchema, [macro], { depth: 'shallow' })\n * ```\n */\nexport function macroEnumName({ parentName, propName, enumSuffix }: Props) {\n  return defineMacro({\n    name: 'enum-name',\n    schema(node) {\n      const enumNode = narrowSchema(node, 'enum')\n\n      if (enumNode?.primitive === 'boolean') return { ...node, name: null }\n      if (enumNode) return { ...node, name: enumPropName(parentName, propName, enumSuffix) }\n\n      return undefined\n    },\n  })\n}\n","import { defineMacro } from '../defineMacro.ts'\nimport { narrowSchema } from '../guards.ts'\nimport type { SchemaNode } from '../nodes/schema.ts'\n\ntype ScalarPrimitive = 'string' | 'number' | 'integer' | 'bigint' | 'boolean'\n\n/**\n * Scalar primitive schema types used for union simplification and type narrowing.\n */\nconst SCALAR_PRIMITIVE_TYPES = new Set<ScalarPrimitive>(['string', 'number', 'integer', 'bigint', 'boolean'])\n\nfunction isScalarPrimitive(type: string): type is ScalarPrimitive {\n  return SCALAR_PRIMITIVE_TYPES.has(type as ScalarPrimitive)\n}\n\n/**\n * Filters union members, dropping enum members that a broader scalar primitive already covers.\n */\nfunction simplifyUnionMembers(members: Array<SchemaNode>): Array<SchemaNode> {\n  const scalarPrimitives = new Set(members.filter((member) => isScalarPrimitive(member.type)).map((m) => m.type))\n  if (!scalarPrimitives.size) return members\n\n  return members.filter((member) => {\n    const enumNode = narrowSchema(member, 'enum')\n    if (!enumNode) return true\n\n    const primitive = enumNode.primitive\n    if (!primitive) return true\n\n    const enumValueCount = enumNode.namedEnumValues?.length ?? enumNode.enumValues?.length ?? 0\n    if (enumValueCount <= 1) return true\n\n    if (scalarPrimitives.has(primitive)) return false\n    if ((primitive === 'integer' || primitive === 'number') && (scalarPrimitives.has('integer') || scalarPrimitives.has('number'))) return false\n\n    return true\n  })\n}\n\n/**\n * Removes union members a broader scalar primitive already covers, such as a multi-value string enum\n * sitting next to a plain `string`. Single-value enums are kept.\n *\n * @example\n * ```ts\n * const next = applyMacros(unionSchema, [macroSimplifyUnion], { depth: 'shallow' })\n * ```\n */\nexport const macroSimplifyUnion = defineMacro({\n  name: 'simplify-union',\n  schema(node) {\n    const unionNode = narrowSchema(node, 'union')\n    if (!unionNode?.members?.length) return undefined\n\n    const simplified = simplifyUnionMembers(unionNode.members)\n    if (simplified.length === unionNode.members.length) return undefined\n\n    return { ...unionNode, members: simplified }\n  },\n})\n"],"mappings":";;;;;;;;;;;;;;;AAqBA,SAAgB,uBAAuB,EAAE,cAAc,QAAQ,YAAmB;CAChF,OAAOA,oBAAAA,YAAY;EACjB,MAAM;EACN,OAAO,MAAM;GACX,MAAM,aAAaC,gBAAAA,aAAa,MAAM,QAAQ;GAC9C,IAAI,CAAC,YAAY,YAAY,QAAQ,OAAO,KAAA;GAC5C,IAAI,CAAC,WAAW,WAAW,MAAM,SAAS,KAAK,SAAS,YAAY,GAAG,OAAO,KAAA;GAE9E,OAAOC,gBAAAA,aAAa;IAClB,GAAG;IACH,YAAY,WAAW,WAAW,KAAK,SAAS;KAC9C,IAAI,KAAK,SAAS,cAAc,OAAO;KAEvC,OAAOC,gBAAAA,eAAe;MACpB,GAAG;MACH,QAAQD,gBAAAA,aAAa;OACnB,MAAM;OACN,WAAW;OACX,YAAY;OACZ,MAAM;OACN,UAAU,KAAK,OAAO;OACtB,WAAW,KAAK,OAAO;MACzB,CAAC;KACH,CAAC;IACH,CAAC;GACH,CAAC;EACH;CACF,CAAC;AACH;;;;;;;;;;;;;AC7BA,SAAgB,cAAc,EAAE,YAAY,UAAU,cAAqB;CACzE,OAAOE,oBAAAA,YAAY;EACjB,MAAM;EACN,OAAO,MAAM;GACX,MAAM,WAAWC,gBAAAA,aAAa,MAAM,MAAM;GAE1C,IAAI,UAAU,cAAc,WAAW,OAAO;IAAE,GAAG;IAAM,MAAM;GAAK;GACpE,IAAI,UAAU,OAAO;IAAE,GAAG;IAAM,MAAMC,aAAAA,aAAa,YAAY,UAAU,UAAU;GAAE;EAGvF;CACF,CAAC;AACH;;;;;;ACvBA,MAAM,yCAAyB,IAAI,IAAqB;CAAC;CAAU;CAAU;CAAW;CAAU;AAAS,CAAC;AAE5G,SAAS,kBAAkB,MAAuC;CAChE,OAAO,uBAAuB,IAAI,IAAuB;AAC3D;;;;AAKA,SAAS,qBAAqB,SAA+C;CAC3E,MAAM,mBAAmB,IAAI,IAAI,QAAQ,QAAQ,WAAW,kBAAkB,OAAO,IAAI,CAAC,CAAC,CAAC,KAAK,MAAM,EAAE,IAAI,CAAC;CAC9G,IAAI,CAAC,iBAAiB,MAAM,OAAO;CAEnC,OAAO,QAAQ,QAAQ,WAAW;EAChC,MAAM,WAAWC,gBAAAA,aAAa,QAAQ,MAAM;EAC5C,IAAI,CAAC,UAAU,OAAO;EAEtB,MAAM,YAAY,SAAS;EAC3B,IAAI,CAAC,WAAW,OAAO;EAGvB,KADuB,SAAS,iBAAiB,UAAU,SAAS,YAAY,UAAU,MACpE,GAAG,OAAO;EAEhC,IAAI,iBAAiB,IAAI,SAAS,GAAG,OAAO;EAC5C,KAAK,cAAc,aAAa,cAAc,cAAc,iBAAiB,IAAI,SAAS,KAAK,iBAAiB,IAAI,QAAQ,IAAI,OAAO;EAEvI,OAAO;CACT,CAAC;AACH;;;;;;;;;;AAWA,MAAa,qBAAqBC,oBAAAA,YAAY;CAC5C,MAAM;CACN,OAAO,MAAM;EACX,MAAM,YAAYD,gBAAAA,aAAa,MAAM,OAAO;EAC5C,IAAI,CAAC,WAAW,SAAS,QAAQ,OAAO,KAAA;EAExC,MAAM,aAAa,qBAAqB,UAAU,OAAO;EACzD,IAAI,WAAW,WAAW,UAAU,QAAQ,QAAQ,OAAO,KAAA;EAE3D,OAAO;GAAE,GAAG;GAAW,SAAS;EAAW;CAC7C;AACF,CAAC"}

package/dist/macros.d.ts

@@ -1,61 +0,0 @@
-import { n as __name } from "./rolldown-runtime-CNktS9qV.js";
-import { n as Macro } from "./defineMacro-DzsACbFo.js";
-
-//#region src/macros/macroDiscriminatorEnum.d.ts
-type Props$1 = {
-  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' })
- * ```
- */
-declare function macroDiscriminatorEnum({
-  propertyName,
-  values,
-  enumName
-}: Props$1): Macro;
-//#endregion
-//#region src/macros/macroEnumName.d.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' })
- * ```
- */
-declare function macroEnumName({
-  parentName,
-  propName,
-  enumSuffix
-}: Props): Macro;
-//#endregion
-//#region src/macros/macroSimplifyUnion.d.ts
-/**
- * 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' })
- * ```
- */
-declare const macroSimplifyUnion: Macro;
-//#endregion
-export { macroDiscriminatorEnum, macroEnumName, macroSimplifyUnion };
-//# sourceMappingURL=macros.d.ts.map