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

package/dist/index.js

@@ -1,10 +1,113 @@
 import "./chunk-CNktS9qV.js";
-import { a as nodeDefs, c as extractRefName, g as schemaTypes, i as walk, m as narrowSchema, n as collectLazy, p as isHttpOperationNode, r as transform, t as collect } from "./visitor-DepQEKyp.js";
-import { $ as schemaDef, A as fileDef, C as objectBindingPatternDef, F as arrowFunctionDef, G as functionDef, I as breakDef, J as typeDef, K as jsxDef, L as constDef, M as sourceDef, N as contentDef, Q as createSchema, S as indexedAccessTypeDef, b as functionParameterDef, c as outputDef, et as defineNode, f as requestBodyDef, i as propertyDef, j as importDef, k as exportDef, m as inputDef, n as responseDef, o as parameterDef, q as textDef, u as operationDef, w as typeLiteralDef, x as functionParametersDef } from "./response-Rd1uisM1.js";
-import "./utils-DW9rnfsD.js";
-import { n as composeMacros, r as defineMacro, t as applyMacros } from "./defineMacro-CNkUpxia.js";
+import { c as collect, d as walk, f as nodeDefs, g as schemaTypes, m as narrowSchema, p as isHttpOperationNode, r as extractRefName, u as transform } from "./refs-BjNDuCBD.js";
+import { $ as textDef, C as functionParameterDef, D as typeLiteralDef, E as objectBindingPatternDef, F as sourceDef, H as breakDef, M as exportDef, N as fileDef, P as importDef, Q as jsxDef, T as indexedAccessTypeDef, U as constDef, V as arrowFunctionDef, Z as functionDef, _ as inputDef, c as parameterDef, d as outputDef, et as typeDef, h as requestBodyDef, i as responseDef, l as optionality, n as schemaDef, o as propertyDef, p as operationDef, tt as defineNode, w as functionParametersDef, z as contentDef } from "./schema-Cbnxmz4b.js";
+import "./utils-DaXkewb1.js";
+import { n as composeMacros, r as defineMacro, t as applyMacros } from "./defineMacro-Shz8f6SG.js";
 import { t as factory_exports } from "./factory.js";
 import { hash } from "node:crypto";
+//#region src/dialect.ts
+/**
+* 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 },
+* })
+* ```
+*/
+function defineDialect(dialect) {
+	return dialect;
+}
+//#endregion
+//#region src/definePrinter.ts
+/**
+* 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} })`
+*     },
+*   },
+* }))
+* ```
+*/
+function definePrinter(build) {
+	return createPrinterFactory((node) => node.type)(build);
+}
+/**
+* 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,
+* )
+* ```
+*/
+function createPrinterFactory(getKey) {
+	return function(build) {
+		return (options) => {
+			const { name, options: resolvedOptions, nodes, print: printOverride } = build(options ?? {});
+			const context = {
+				options: resolvedOptions,
+				transform: (node) => {
+					const key = getKey(node);
+					if (key === null) return null;
+					const handler = nodes[key];
+					if (!handler) return null;
+					return handler.call(context, node);
+				}
+			};
+			return {
+				name,
+				options: resolvedOptions,
+				transform: context.transform,
+				print: printOverride ? printOverride.bind(context) : context.transform
+			};
+		};
+	};
+}
+//#endregion
 //#region src/signature.ts
 /**
 * The flags shared by every node kind that affect its type: `primitive`, `format`, `nullable`.
@@ -257,237 +360,6 @@ function signatureOf(node) {
 	return signature;
 }
 //#endregion
-//#region src/dedupe.ts
-/**
-* Builds the shared `ref` replacement for a duplicate occurrence, carrying the
-* usage-slot and documentation fields that are not part of the canonical type.
-*/
-function createRefNode(node, canonical) {
-	return createSchema({
-		type: "ref",
-		name: canonical.name,
-		ref: canonical.ref,
-		optional: node.optional,
-		nullish: node.nullish,
-		readOnly: node.readOnly,
-		writeOnly: node.writeOnly,
-		deprecated: node.deprecated,
-		description: node.description,
-		default: node.default,
-		example: node.example
-	});
-}
-function applyDedupe(node, plan, skipRootMatch = false) {
-	const { canonicalBySignature, aliasNames } = plan;
-	if (canonicalBySignature.size === 0 && aliasNames.size === 0) return node;
-	const root = node;
-	return transform(node, { schema(schemaNode) {
-		if (schemaNode.type === "ref") {
-			const target = schemaNode.ref ? extractRefName(schemaNode.ref) : schemaNode.name;
-			const canonical = target ? aliasNames.get(target) : void 0;
-			return canonical ? {
-				...schemaNode,
-				name: canonical.name,
-				ref: canonical.ref
-			} : void 0;
-		}
-		const signature = signatureOf(schemaNode);
-		if (skipRootMatch && schemaNode === root) return void 0;
-		const canonical = canonicalBySignature.get(signature);
-		if (!canonical) return void 0;
-		return createRefNode(schemaNode, canonical);
-	} });
-}
-/**
-* Strips usage-slot flags from a hoisted definition and applies its canonical name.
-* A standalone definition is never optional, so `optional`/`nullish` are cleared.
-*/
-function cleanDefinition(node, name) {
-	return {
-		...node,
-		name,
-		optional: void 0,
-		nullish: void 0
-	};
-}
-/**
-* Scans a forest of schema and operation nodes and produces a {@link DedupePlan}.
-*
-* A shape that occurs at least `minOccurrences` times is deduplicated: if any occurrence
-* is a named top-level schema, the first one becomes the canonical (so other top-level
-* duplicates and inline copies turn into references to it). Every other top-level name with
-* the same content is recorded in `aliasNames`, so refs to it can be repointed at the
-* canonical. Otherwise a new definition is hoisted using `nameFor`. The plan is then applied
-* per node with {@link applyDedupe}.
-*
-* @example
-* ```ts
-* const plan = buildDedupePlan([...schemaNodes, ...operationNodes], {
-*   isCandidate: (node) => node.type === 'enum' || node.type === 'object',
-*   nameFor: (node) => node.name ?? null,
-*   refFor: (name) => `#/components/schemas/${name}`,
-* })
-* ```
-*/
-function buildDedupePlan(roots, options) {
-	const { isCandidate, nameFor, refFor, minOccurrences = 2 } = options;
-	const topLevelNodes = /* @__PURE__ */ new Set();
-	const groups = /* @__PURE__ */ new Map();
-	function record(schemaNode) {
-		if (!isCandidate(schemaNode)) return;
-		const signature = signatureOf(schemaNode);
-		const isTopLevel = topLevelNodes.has(schemaNode) && !!schemaNode.name;
-		const group = groups.get(signature);
-		if (group) {
-			group.count++;
-			if (isTopLevel) group.topLevelNames.push(schemaNode.name);
-		} else groups.set(signature, {
-			count: 1,
-			representative: schemaNode,
-			topLevelNames: isTopLevel ? [schemaNode.name] : []
-		});
-	}
-	for (const root of roots) {
-		if (root.kind === "Schema") topLevelNodes.add(root);
-		for (const schemaNode of collectLazy(root, { schema: (node) => node })) record(schemaNode);
-	}
-	const canonicalBySignature = /* @__PURE__ */ new Map();
-	const aliasNames = /* @__PURE__ */ new Map();
-	const pendingHoists = [];
-	for (const [signature, group] of groups) {
-		if (group.count < minOccurrences) continue;
-		const [firstName, ...duplicateNames] = group.topLevelNames;
-		if (firstName) {
-			const canonical = {
-				name: firstName,
-				ref: refFor(firstName)
-			};
-			canonicalBySignature.set(signature, canonical);
-			for (const duplicate of duplicateNames) aliasNames.set(duplicate, canonical);
-			continue;
-		}
-		const name = nameFor(group.representative, signature);
-		if (!name) continue;
-		canonicalBySignature.set(signature, {
-			name,
-			ref: refFor(name)
-		});
-		pendingHoists.push({
-			name,
-			representative: group.representative
-		});
-	}
-	return {
-		canonicalBySignature,
-		aliasNames,
-		hoisted: pendingHoists.map(({ name, representative }) => cleanDefinition(applyDedupe(representative, {
-			canonicalBySignature,
-			aliasNames
-		}, true), name))
-	};
-}
-//#endregion
-//#region src/dialect.ts
-/**
-* 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,
-*     optionality,
-*   },
-* })
-* ```
-*/
-function defineDialect(dialect) {
-	return dialect;
-}
-//#endregion
-//#region src/definePrinter.ts
-/**
-* 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} })`
-*     },
-*   },
-* }))
-* ```
-*/
-function definePrinter(build) {
-	return createPrinterFactory((node) => node.type)(build);
-}
-/**
-* Generic printer-factory function used by `definePrinter` and `defineFunctionPrinter`.
-*
-* @example
-* ```ts
-* export const defineFunctionPrinter = createPrinterFactory<FunctionParamNode, FunctionParamKind, Partial<Record<FunctionParamKind, FunctionParamNode>>>(
-*   (node) => node.kind,
-* )
-* ```
-*/
-function createPrinterFactory(getKey) {
-	return function(build) {
-		return (options) => {
-			const { name, options: resolvedOptions, nodes, print: printOverride } = build(options ?? {});
-			const context = {
-				options: resolvedOptions,
-				transform: (node) => {
-					const key = getKey(node);
-					if (key === null) return null;
-					const handler = nodes[key];
-					if (!handler) return null;
-					return handler.call(context, node);
-				}
-			};
-			return {
-				name,
-				options: resolvedOptions,
-				transform: context.transform,
-				print: printOverride ? printOverride.bind(context) : context.transform
-			};
-		};
-	};
-}
-//#endregion
-export { applyDedupe, applyMacros, arrowFunctionDef, breakDef, buildDedupePlan, collect, composeMacros, constDef, contentDef, createPrinterFactory, defineDialect, defineMacro, defineNode, definePrinter, exportDef, factory_exports as factory, fileDef, functionDef, functionParameterDef, functionParametersDef, importDef, indexedAccessTypeDef, inputDef, isHttpOperationNode, jsxDef, narrowSchema, nodeDefs, objectBindingPatternDef, operationDef, outputDef, parameterDef, propertyDef, requestBodyDef, responseDef, schemaDef, schemaTypes, signatureOf, sourceDef, textDef, transform, typeDef, typeLiteralDef, walk };
+export { applyMacros, arrowFunctionDef, breakDef, collect, composeMacros, constDef, contentDef, createPrinterFactory, defineDialect, defineMacro, defineNode, definePrinter, exportDef, factory_exports as factory, fileDef, functionDef, functionParameterDef, functionParametersDef, importDef, indexedAccessTypeDef, inputDef, isHttpOperationNode, jsxDef, narrowSchema, nodeDefs, objectBindingPatternDef, operationDef, optionality, outputDef, parameterDef, propertyDef, requestBodyDef, responseDef, schemaDef, schemaTypes, signatureOf, sourceDef, textDef, transform, typeDef, typeLiteralDef, walk };
 
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["obj"],"sources":["../src/signature.ts","../src/dedupe.ts","../src/dialect.ts","../src/definePrinter.ts"],"sourcesContent":["import { hash } from 'node:crypto'\nimport type { SchemaNode } from './nodes/index.ts'\nimport { extractRefName } from './utils/index.ts'\n\n/**\n * The flags shared by every node kind that affect its type: `primitive`, `format`, `nullable`.\n */\nfunction flagsDescriptor(node: SchemaNode): string {\n  return `${node.primitive ?? ''};${node.format ?? ''};${node.nullable ? 1 : 0}`\n}\n\nfunction refTargetName(node: Extract<SchemaNode, { type: 'ref' }>): string {\n  if (node.ref) return extractRefName(node.ref)\n  return node.name ?? ''\n}\n\ntype ScalarField = { kind: 'scalar'; key: string; prefix: string }\ntype BoolField = { kind: 'bool'; key: string; prefix: string }\ntype ChildField = { kind: 'child'; key: string; prefix: string }\ntype ChildrenField = { kind: 'children'; key: string; prefix: string }\ntype ObjectPropsField = { kind: 'objectProps' }\ntype AdditionalPropsField = { kind: 'additionalProps' }\ntype PatternPropsField = { kind: 'patternProps' }\ntype EnumValuesField = { kind: 'enumValues' }\ntype RefTargetField = { kind: 'refTarget' }\n\ntype ShapeField =\n  | ScalarField\n  | BoolField\n  | ChildField\n  | ChildrenField\n  | ObjectPropsField\n  | AdditionalPropsField\n  | PatternPropsField\n  | EnumValuesField\n  | RefTargetField\n\nconst arrayTupleFields: ReadonlyArray<ShapeField> = [\n  { kind: 'children', key: 'items', prefix: 'i' },\n  { kind: 'child', key: 'rest', prefix: 'r' },\n  { kind: 'scalar', key: 'min', prefix: 'mn' },\n  { kind: 'scalar', key: 'max', prefix: 'mx' },\n  { kind: 'bool', key: 'unique', prefix: 'u' },\n]\n\nconst numericFields: ReadonlyArray<ShapeField> = [\n  { kind: 'scalar', key: 'min', prefix: 'mn' },\n  { kind: 'scalar', key: 'max', prefix: 'mx' },\n  { kind: 'scalar', key: 'exclusiveMinimum', prefix: 'emn' },\n  { kind: 'scalar', key: 'exclusiveMaximum', prefix: 'emx' },\n  { kind: 'scalar', key: 'multipleOf', prefix: 'mo' },\n]\n\nconst rangeFields: ReadonlyArray<ShapeField> = [\n  { kind: 'scalar', key: 'min', prefix: 'mn' },\n  { kind: 'scalar', key: 'max', prefix: 'mx' },\n]\n\n/**\n * Maps each node `type` to its ordered shape-contributing fields. Types absent from the map\n * (boolean, null, any, and other scalars) fall back to `${type}|${flags}`.\n */\nconst SHAPE_KEYS: Partial<Record<SchemaNode['type'], ReadonlyArray<ShapeField>>> = {\n  object: [\n    { kind: 'objectProps' },\n    { kind: 'additionalProps' },\n    { kind: 'patternProps' },\n    { kind: 'scalar', key: 'minProperties', prefix: 'mn' },\n    { kind: 'scalar', key: 'maxProperties', prefix: 'mx' },\n  ],\n  array: arrayTupleFields,\n  tuple: arrayTupleFields,\n  union: [\n    { kind: 'scalar', key: 'strategy', prefix: 's' },\n    { kind: 'scalar', key: 'discriminatorPropertyName', prefix: 'd' },\n    { kind: 'children', key: 'members', prefix: 'm' },\n  ],\n  intersection: [{ kind: 'children', key: 'members', prefix: 'm' }],\n  enum: [{ kind: 'enumValues' }],\n  ref: [{ kind: 'refTarget' }],\n  string: [\n    { kind: 'scalar', key: 'min', prefix: 'mn' },\n    { kind: 'scalar', key: 'max', prefix: 'mx' },\n    { kind: 'scalar', key: 'pattern', prefix: 'pt' },\n  ],\n  number: numericFields,\n  integer: numericFields,\n  bigint: numericFields,\n  url: [\n    { kind: 'scalar', key: 'path', prefix: 'path' },\n    { kind: 'scalar', key: 'min', prefix: 'mn' },\n    { kind: 'scalar', key: 'max', prefix: 'mx' },\n  ],\n  uuid: rangeFields,\n  email: rangeFields,\n  datetime: [\n    { kind: 'bool', key: 'offset', prefix: 'o' },\n    { kind: 'bool', key: 'local', prefix: 'l' },\n  ],\n  date: [{ kind: 'scalar', key: 'representation', prefix: 'rep' }],\n  time: [{ kind: 'scalar', key: 'representation', prefix: 'rep' }],\n}\n\nfunction serializeShapeField(field: ShapeField, node: SchemaNode, record: Record<string, unknown>): string {\n  switch (field.kind) {\n    case 'scalar':\n      return `${field.prefix}:${record[field.key] ?? ''}`\n    case 'bool':\n      return `${field.prefix}:${record[field.key] ? 1 : 0}`\n    case 'child': {\n      const child = record[field.key] as SchemaNode | undefined\n      return `${field.prefix}:${child ? signatureOf(child) : ''}`\n    }\n    case 'children': {\n      const children = (record[field.key] as Array<SchemaNode> | undefined) ?? []\n      return `${field.prefix}[${children.map((c) => signatureOf(c)).join(',')}]`\n    }\n    case 'objectProps': {\n      const obj = node as Extract<SchemaNode, { type: 'object' }>\n      const props = (obj.properties ?? []).map((prop) => `${prop.name}${prop.required ? '!' : '?'}${signatureOf(prop.schema)}`).join(',')\n      return `p[${props}]`\n    }\n    case 'additionalProps': {\n      const obj = node as Extract<SchemaNode, { type: 'object' }>\n      if (typeof obj.additionalProperties === 'boolean') return `ab:${obj.additionalProperties}`\n      if (obj.additionalProperties) return `as:${signatureOf(obj.additionalProperties)}`\n      return ''\n    }\n    case 'patternProps': {\n      const obj = node as Extract<SchemaNode, { type: 'object' }>\n      const pattern = obj.patternProperties\n        ? Object.keys(obj.patternProperties)\n            .sort()\n            .map((key) => `${key}=${signatureOf(obj.patternProperties![key]!)}`)\n            .join(',')\n        : ''\n      return `pp[${pattern}]`\n    }\n    case 'enumValues': {\n      const en = node as Extract<SchemaNode, { type: 'enum' }>\n      let values = ''\n      if (en.namedEnumValues?.length) {\n        values = en.namedEnumValues.map((entry) => `${entry.name}=${entry.primitive}:${String(entry.value)}`).join(',')\n      } else if (en.enumValues?.length) {\n        values = en.enumValues.map((value) => `${value === null ? 'null' : typeof value}:${String(value)}`).join(',')\n      }\n      return `v[${values}]`\n    }\n    case 'refTarget': {\n      return `->${refTargetName(node as Extract<SchemaNode, { type: 'ref' }>)}`\n    }\n  }\n}\n\n/**\n * Builds the local shape descriptor that {@link signatureOf} hashes: the node's kind, flags,\n * constraints, and its children's signatures.\n */\nfunction describeShape(node: SchemaNode): string {\n  const flags = flagsDescriptor(node)\n  const fields = SHAPE_KEYS[node.type]\n  if (!fields) return `${node.type}|${flags}`\n\n  const record = node as unknown as Record<string, unknown>\n  const parts: Array<string> = [`${node.type}|${flags}`]\n  for (const field of fields) {\n    parts.push(serializeShapeField(field, node, record))\n  }\n  return parts.join('|')\n}\n\n/**\n * Caches the digest per node, keyed by identity. A `WeakMap` so entries die with the node, and so\n * a tree hashed during dedupe planning is not walked again when it is rewritten during streaming.\n * Reuse is safe because a signature depends only on content, and nodes are immutable once created.\n */\nconst signatureCache = new WeakMap<SchemaNode, string>()\n\n/**\n * Computes a deterministic, shape-only signature (a content hash) for a schema node. Two schemas\n * share a signature when they are structurally identical, ignoring documentation (`name`, `title`,\n * `description`, `example`, `default`, `deprecated`) and usage-slot flags (`optional`, `nullish`,\n * `readOnly`, `writeOnly`). `nullable` is kept because it changes the produced type, and `ref`\n * nodes compare by target name, which also terminates on circular shapes.\n *\n * @example Two enums with different descriptions share a signature\n * ```ts\n * signatureOf(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'], description: 'x' })) ===\n *   signatureOf(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'] }))\n * ```\n */\nexport function signatureOf(node: SchemaNode): string {\n  const cached = signatureCache.get(node)\n  if (cached !== undefined) return cached\n  const signature = hash('sha256', describeShape(node), 'hex')\n  signatureCache.set(node, signature)\n\n  return signature\n}\n\n/**\n * Returns `true` when two schema nodes are structurally identical under shape-only equality,\n * meaning they produce the same TypeScript type.\n */\nexport function isSchemaEqual(a: SchemaNode, b: SchemaNode): boolean {\n  return signatureOf(a) === signatureOf(b)\n}\n","import type { Node, OperationNode, SchemaNode } from './nodes/index.ts'\nimport { createSchema } from './nodes/schema.ts'\nimport { signatureOf } from './signature.ts'\nimport { extractRefName } from './utils/index.ts'\nimport { collectLazy, transform } from './visitor.ts'\n\n/**\n * A canonical destination for a deduplicated shape: the shared schema name and\n * the synthetic `$ref` path that points at it.\n */\nexport type DedupeCanonical = {\n  /**\n   * Canonical schema name every duplicate occurrence refers to.\n   */\n  name: string\n  /**\n   * `$ref` path stored on the generated `ref` nodes (for example `#/components/schemas/Status`).\n   */\n  ref: string\n}\n\n/**\n * The result of {@link buildDedupePlan}: a lookup from structural signature to its\n * canonical target, plus the freshly hoisted definitions that must be added to\n * the schema list.\n */\nexport type DedupePlan = {\n  /**\n   * Maps a structural signature to the canonical schema that represents it.\n   */\n  canonicalBySignature: Map<string, DedupeCanonical>\n  /**\n   * Maps the name of a top-level schema that duplicates a canonical one to that canonical, so\n   * references to the duplicate can be repointed at the first schema with the same content.\n   */\n  aliasNames: Map<string, DedupeCanonical>\n  /**\n   * New top-level schema definitions created for inline shapes that had no existing\n   * named component. Nested duplicates inside each definition are already collapsed.\n   */\n  hoisted: Array<SchemaNode>\n}\n\n/**\n * The lookups {@link applyDedupe} needs from a {@link DedupePlan}.\n */\nexport type DedupeLookups = Pick<DedupePlan, 'canonicalBySignature' | 'aliasNames'>\n\n/**\n * Options that inject the naming and candidate policy into {@link buildDedupePlan}.\n * The mechanics (grouping, counting, rewriting) live here. The policy lives in the caller.\n */\nexport type BuildDedupePlanOptions = {\n  /**\n   * Returns `true` when a node should be deduplicated. This is the only gate, so it must\n   * reject both ineligible kinds (return `false` for anything other than, say, enums and\n   * objects) and unsafe shapes (e.g. nodes that reference a circular schema).\n   */\n  isCandidate: (node: SchemaNode) => boolean\n  /**\n   * Produces the canonical name for an inline shape with no existing named component.\n   * Return `null` to leave the shape inline (for example when no contextual name exists).\n   */\n  nameFor: (node: SchemaNode, signature: string) => string | null\n  /**\n   * Builds the `$ref` path for a canonical name.\n   */\n  refFor: (name: string) => string\n  /**\n   * Minimum number of occurrences before a shape is deduplicated.\n   *\n   * @default 2\n   */\n  minOccurrences?: number\n}\n\n/**\n * Builds the shared `ref` replacement for a duplicate occurrence, carrying the\n * usage-slot and documentation fields that are not part of the canonical type.\n */\nfunction createRefNode(node: SchemaNode, canonical: DedupeCanonical): SchemaNode {\n  return createSchema({\n    type: 'ref',\n    name: canonical.name,\n    ref: canonical.ref,\n    optional: node.optional,\n    nullish: node.nullish,\n    readOnly: node.readOnly,\n    writeOnly: node.writeOnly,\n    deprecated: node.deprecated,\n    description: node.description,\n    default: node.default,\n    example: node.example,\n  })\n}\n\n/**\n * Rewrites a node, replacing every candidate sub-schema whose signature has a canonical\n * target with a `ref` to that target. Replacing a node with a `ref` prunes its subtree,\n * so nested duplicates inside a replaced shape are not visited again. A `ref` that points\n * at a duplicate top-level schema (see `aliasNames`) is repointed at the first schema with\n * the same content.\n *\n * Pass `skipRootMatch` when rewriting a canonical definition so its own root is not\n * turned into a reference to itself. Nested duplicates are still collapsed.\n *\n * @example\n * ```ts\n * const next = applyDedupe(operationNode, plan)\n * ```\n */\nexport function applyDedupe(node: SchemaNode, plan: DedupeLookups, skipRootMatch?: boolean): SchemaNode\nexport function applyDedupe(node: OperationNode, plan: DedupeLookups, skipRootMatch?: boolean): OperationNode\nexport function applyDedupe(node: Node, plan: DedupeLookups, skipRootMatch = false): Node {\n  const { canonicalBySignature, aliasNames } = plan\n  if (canonicalBySignature.size === 0 && aliasNames.size === 0) return node\n\n  const root = node\n\n  return transform(node, {\n    schema(schemaNode) {\n      if (schemaNode.type === 'ref') {\n        const target = schemaNode.ref ? extractRefName(schemaNode.ref) : schemaNode.name\n        const canonical = target ? aliasNames.get(target) : undefined\n\n        return canonical ? { ...schemaNode, name: canonical.name, ref: canonical.ref } : undefined\n      }\n\n      const signature = signatureOf(schemaNode)\n      if (skipRootMatch && schemaNode === root) return undefined\n\n      const canonical = canonicalBySignature.get(signature)\n      if (!canonical) return undefined\n\n      return createRefNode(schemaNode, canonical)\n    },\n  })\n}\n\n/**\n * Strips usage-slot flags from a hoisted definition and applies its canonical name.\n * A standalone definition is never optional, so `optional`/`nullish` are cleared.\n */\nfunction cleanDefinition(node: SchemaNode, name: string): SchemaNode {\n  return { ...node, name, optional: undefined, nullish: undefined }\n}\n\n/**\n * Scans a forest of schema and operation nodes and produces a {@link DedupePlan}.\n *\n * A shape that occurs at least `minOccurrences` times is deduplicated: if any occurrence\n * is a named top-level schema, the first one becomes the canonical (so other top-level\n * duplicates and inline copies turn into references to it). Every other top-level name with\n * the same content is recorded in `aliasNames`, so refs to it can be repointed at the\n * canonical. Otherwise a new definition is hoisted using `nameFor`. The plan is then applied\n * per node with {@link applyDedupe}.\n *\n * @example\n * ```ts\n * const plan = buildDedupePlan([...schemaNodes, ...operationNodes], {\n *   isCandidate: (node) => node.type === 'enum' || node.type === 'object',\n *   nameFor: (node) => node.name ?? null,\n *   refFor: (name) => `#/components/schemas/${name}`,\n * })\n * ```\n */\nexport function buildDedupePlan(roots: ReadonlyArray<Node>, options: BuildDedupePlanOptions): DedupePlan {\n  const { isCandidate, nameFor, refFor, minOccurrences = 2 } = options\n\n  const topLevelNodes = new Set<SchemaNode>()\n\n  type Group = {\n    count: number\n    representative: SchemaNode\n    topLevelNames: Array<string>\n  }\n  const groups = new Map<string, Group>()\n\n  function record(schemaNode: SchemaNode): void {\n    if (!isCandidate(schemaNode)) return\n    const signature = signatureOf(schemaNode)\n\n    const isTopLevel = topLevelNodes.has(schemaNode) && !!schemaNode.name\n    const group = groups.get(signature)\n    if (group) {\n      group.count++\n      if (isTopLevel) group.topLevelNames.push(schemaNode.name!)\n    } else {\n      groups.set(signature, { count: 1, representative: schemaNode, topLevelNames: isTopLevel ? [schemaNode.name!] : [] })\n    }\n  }\n\n  for (const root of roots) {\n    if (root.kind === 'Schema') topLevelNodes.add(root)\n    for (const schemaNode of collectLazy<SchemaNode>(root, { schema: (node) => node })) {\n      record(schemaNode)\n    }\n  }\n\n  const canonicalBySignature = new Map<string, DedupeCanonical>()\n  const aliasNames = new Map<string, DedupeCanonical>()\n  const pendingHoists: Array<{ name: string; representative: SchemaNode }> = []\n\n  for (const [signature, group] of groups) {\n    if (group.count < minOccurrences) continue\n\n    const [firstName, ...duplicateNames] = group.topLevelNames\n    if (firstName) {\n      const canonical: DedupeCanonical = { name: firstName, ref: refFor(firstName) }\n      canonicalBySignature.set(signature, canonical)\n      for (const duplicate of duplicateNames) {\n        aliasNames.set(duplicate, canonical)\n      }\n      continue\n    }\n\n    const name = nameFor(group.representative, signature)\n    if (!name) continue\n\n    canonicalBySignature.set(signature, { name, ref: refFor(name) })\n    pendingHoists.push({ name, representative: group.representative })\n  }\n\n  // Build hoisted definitions only after every canonical name is known, so nested\n  // duplicates inside a definition also resolve to refs.\n  const hoisted = pendingHoists.map(({ name, representative }) =>\n    cleanDefinition(applyDedupe(representative, { canonicalBySignature, aliasNames }, true), name),\n  )\n\n  return { canonicalBySignature, aliasNames, hoisted }\n}\n","import type { SchemaNode } from './nodes/index.ts'\n\n/**\n * The spec-specific questions a schema parser answers while turning a source document into Kubb\n * AST nodes. The rest of the pipeline is generic JSON Schema, so this is the one seam where\n * OpenAPI, AsyncAPI, and plain JSON Schema differ.\n */\nexport type SchemaDialect<TSchema = unknown, TRef = TSchema, TDiscriminated = TSchema, TDocument = unknown> = {\n  /**\n   * Whether the schema is nullable.\n   */\n  isNullable(schema?: TSchema): boolean\n  /**\n   * Whether the value is a `$ref` pointer.\n   */\n  isReference(value?: unknown): value is TRef\n  /**\n   * Whether the schema carries a discriminator for polymorphism.\n   */\n  isDiscriminator(value?: unknown): value is TDiscriminated\n  /**\n   * Whether the schema is binary data, converted to a `blob` node.\n   */\n  isBinary(schema: TSchema): boolean\n  /**\n   * Resolves a local `$ref` against the document, or nullish when it cannot.\n   */\n  resolveRef<TResolved>(document: TDocument, ref: string): TResolved | null | undefined\n  /**\n   * Derives a schema's `optional`/`nullish` flags from a parent's `required` value and the\n   * schema's own `nullable`. How \"required\" and \"nullable\" combine is spec-specific, so the\n   * dialect owns it. Method syntax keeps a concrete dialect assignable to the base\n   * `SchemaDialect` (bivariant parameters).\n   */\n  optionality(schema: SchemaNode, required: boolean): SchemaNode\n}\n\n/**\n * A spec adapter's dialect. `name` identifies it in logs and diagnostics; `schema` holds the\n * spec-specific schema questions the parser answers.\n */\nexport type Dialect<TSchema = unknown, TRef = TSchema, TDiscriminated = TSchema, TDocument = unknown> = {\n  /**\n   * Identifies the dialect in logs and diagnostics.\n   */\n  name: string\n  /**\n   * The spec-specific schema behavior. See {@link SchemaDialect}.\n   */\n  schema: SchemaDialect<TSchema, TRef, TDiscriminated, TDocument>\n}\n\n/**\n * Types a {@link Dialect} for an adapter. Adds no runtime behavior and only pins the\n * dialect's type for inference.\n *\n * @example\n * ```ts\n * export const oasDialect = defineDialect({\n *   name: 'oas',\n *   schema: {\n *     isNullable,\n *     isReference,\n *     isDiscriminator,\n *     isBinary: (schema) => schema.type === 'string' && schema.contentMediaType === 'application/octet-stream',\n *     resolveRef,\n *     optionality,\n *   },\n * })\n * ```\n */\nexport function defineDialect<TSchema, TRef, TDiscriminated, TDocument>(\n  dialect: Dialect<TSchema, TRef, TDiscriminated, TDocument>,\n): Dialect<TSchema, TRef, TDiscriminated, TDocument> {\n  return dialect\n}\n","import type { SchemaNode, SchemaNodeByType, SchemaType } from './nodes/index.ts'\n\n/**\n * Runtime context passed as `this` to printer handlers.\n *\n * `this.transform` dispatches to node-level handlers from `nodes`.\n *\n * @example\n * ```ts\n * const context: PrinterHandlerContext<string, {}> = {\n *   options: {},\n *   transform: () => 'value',\n * }\n * ```\n */\ntype PrinterHandlerContext<TOutput, TOptions extends object> = {\n  /**\n   * Recursively transform a nested `SchemaNode` to `TOutput` using the node-level handlers.\n   * Use `this.transform` inside `nodes` handlers and inside the `print` override.\n   */\n  transform: (node: SchemaNode) => TOutput | null\n  /**\n   * Options for this printer instance.\n   */\n  options: TOptions\n}\n\n/**\n * Handler for one schema node type.\n *\n * Use a regular function (not an arrow function) if you need `this`.\n *\n * @example\n * ```ts\n * const handler: PrinterHandler<string, {}, 'string'> = function () {\n *   return 'string'\n * }\n * ```\n */\ntype PrinterHandler<TOutput, TOptions extends object, T extends SchemaType = SchemaType> = (\n  this: PrinterHandlerContext<TOutput, TOptions>,\n  node: SchemaNodeByType[T],\n) => TOutput | null\n\n/**\n * Partial map of per-node-type handler overrides for a printer.\n *\n * Each key is a `SchemaType` string (e.g. `'date'`, `'string'`).\n * Supply only the handlers you want to replace. The printer's built-in\n * defaults fill in the rest.\n *\n * @example\n * ```ts\n * pluginZod({\n *   printer: {\n *     nodes: {\n *       date(): string {\n *         return 'z.string().date()'\n *       },\n *     } satisfies PrinterPartial<string, PrinterZodOptions>,\n *   },\n * })\n * ```\n */\nexport type PrinterPartial<TOutput, TOptions extends object> = Partial<{\n  [K in SchemaType]: PrinterHandler<TOutput, TOptions, K>\n}>\n\n/**\n * Generic shape used by `definePrinter`.\n *\n * - `TName` unique string identifier (e.g. `'zod'`, `'ts'`)\n * - `TOptions` options passed to and stored on the printer instance\n * - `TOutput` the type emitted by node handlers\n * - `TPrintOutput` type returned by public `print` (defaults to `TOutput`)\n *\n * @example\n * ```ts\n * type MyPrinter = PrinterFactoryOptions<'my', { strict: boolean }, string>\n * ```\n */\nexport type PrinterFactoryOptions<TName extends string = string, TOptions extends object = object, TOutput = unknown, TPrintOutput = TOutput> = {\n  name: TName\n  options: TOptions\n  output: TOutput\n  printOutput: TPrintOutput\n}\n\n/**\n * Printer instance returned by a printer factory.\n *\n * @example\n * ```ts\n * const printer = definePrinter((options: {}) => ({ name: 'x', options, nodes: {} }))({})\n * ```\n */\nexport type Printer<T extends PrinterFactoryOptions = PrinterFactoryOptions> = {\n  /**\n   * Unique identifier supplied at creation time.\n   */\n  name: T['name']\n  /**\n   * Options for this printer instance.\n   */\n  options: T['options']\n  /**\n   * Node-level dispatcher, converts a `SchemaNode` directly to `TOutput` using the `nodes` handlers.\n   * Always dispatches through the `nodes` map. Never calls the `print` override.\n   * Reach for it when you need the raw output (e.g. `ts.TypeNode`) without declaration wrapping.\n   */\n  transform: (node: SchemaNode) => T['output'] | null\n  /**\n   * Public printer. If the builder provides a root-level `print`, this calls that\n   * higher-level function (which may produce full declarations).\n   * Otherwise, falls back to the node-level dispatcher.\n   */\n  print: (node: SchemaNode) => T['printOutput'] | null\n}\n\n/**\n * Builder function passed to `definePrinter`.\n *\n * It receives resolved options and returns:\n * - `name`\n * - `options`\n * - `nodes` handlers\n * - optional top-level `print` override\n *\n * @example\n * ```ts\n * const build = (options: {}) => ({ name: 'x' as const, options, nodes: {} })\n * ```\n */\ntype PrinterBuilder<T extends PrinterFactoryOptions> = (options: T['options']) => {\n  name: T['name']\n  /**\n   * Options to store on the printer.\n   */\n  options: T['options']\n  nodes: Partial<{\n    [K in SchemaType]: PrinterHandler<T['output'], T['options'], K>\n  }>\n  /**\n   * Optional root-level print override. When provided, becomes the public `printer.print`.\n   * Use `this.transform(node)` inside this function to dispatch to the node-level handlers (`nodes`),\n   * not the override itself, so recursion is safe.\n   */\n  print?: (this: PrinterHandlerContext<T['output'], T['options']>, node: SchemaNode) => T['printOutput'] | null\n}\n/**\n * Defines a schema printer: a function that takes a `SchemaNode` and emits\n * code in your target language. Each plugin that produces code from schemas\n * (TypeScript types, Zod schemas, Faker factories) ships a printer built\n * with this helper.\n *\n * The builder receives resolved options and returns:\n *\n * - `name` unique identifier for the printer.\n * - `options` stored on the returned printer instance.\n * - `nodes` map of `SchemaType` → handler. Handlers return the rendered\n *   output (a string, a TypeScript AST node, ...) for that schema type.\n * - `print` (optional), top-level override exposed as `printer.print`.\n *   Use `this.transform(node)` inside it to dispatch to `nodes` recursively.\n *\n * Without a `print` override, `printer.print` falls back to `printer.transform`\n * (the node-level dispatcher).\n *\n * @example Tiny Zod printer\n * ```ts\n * import { definePrinter, type PrinterFactoryOptions } from '@kubb/ast'\n *\n * type PrinterZod = PrinterFactoryOptions<'zod', { strict?: boolean }, string>\n *\n * export const zodPrinter = definePrinter<PrinterZod>((options) => ({\n *   name: 'zod',\n *   options: { strict: options.strict ?? true },\n *   nodes: {\n *     string: () => 'z.string()',\n *     object(node) {\n *       const props = node.properties\n *         .map((p) => `${p.name}: ${this.transform(p.schema)}`)\n *         .join(', ')\n *       return `z.object({ ${props} })`\n *     },\n *   },\n * }))\n * ```\n */\nexport function definePrinter<T extends PrinterFactoryOptions = PrinterFactoryOptions>(build: PrinterBuilder<T>): (options?: T['options']) => Printer<T> {\n  return createPrinterFactory<SchemaNode, SchemaType, SchemaNodeByType>((node) => node.type)(build) as (options?: T['options']) => Printer<T>\n}\n\n/**\n * Generic printer-factory function used by `definePrinter` and `defineFunctionPrinter`.\n *\n * @example\n * ```ts\n * export const defineFunctionPrinter = createPrinterFactory<FunctionParamNode, FunctionParamKind, Partial<Record<FunctionParamKind, FunctionParamNode>>>(\n *   (node) => node.kind,\n * )\n * ```\n */\nexport function createPrinterFactory<TNode, TKey extends string, TNodeByKey extends Partial<Record<TKey, TNode>>>(getKey: (node: TNode) => TKey | null) {\n  return function <T extends PrinterFactoryOptions>(\n    build: (options: T['options']) => {\n      name: T['name']\n      options: T['options']\n      nodes: Partial<{\n        [K in TKey]: (\n          this: {\n            transform: (node: TNode) => T['output'] | null\n            options: T['options']\n          },\n          node: TNodeByKey[K],\n        ) => T['output'] | null\n      }>\n      print?: (\n        this: {\n          transform: (node: TNode) => T['output'] | null\n          options: T['options']\n        },\n        node: TNode,\n      ) => T['printOutput'] | null\n    },\n  ): (options?: T['options']) => {\n    name: T['name']\n    options: T['options']\n    transform: (node: TNode) => T['output'] | null\n    print: (node: TNode) => T['printOutput'] | null\n  } {\n    return (options) => {\n      const { name, options: resolvedOptions, nodes, print: printOverride } = build(options ?? ({} as T['options']))\n\n      const context = {\n        options: resolvedOptions,\n        transform: (node: TNode): T['output'] | null => {\n          const key = getKey(node)\n          if (key === null) return null\n\n          const handler = nodes[key]\n\n          if (!handler) return null\n\n          return (handler as (this: typeof context, node: TNode) => T['output'] | null).call(context, node)\n        },\n      }\n\n      return {\n        name,\n        options: resolvedOptions,\n        transform: context.transform,\n        print: (printOverride ? printOverride.bind(context) : context.transform) as (node: TNode) => T['printOutput'] | null,\n      }\n    }\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":["obj"],"sources":["../src/dialect.ts","../src/definePrinter.ts","../src/signature.ts"],"sourcesContent":["import type { Node } from './nodes/index.ts'\n\n/**\n * The spec-specific questions a schema parser answers while turning a source document into Kubb\n * AST nodes. The rest of the pipeline is generic JSON Schema, so this is the one seam where\n * OpenAPI, AsyncAPI, and plain JSON Schema differ.\n */\nexport type SchemaDialect<TSchema = unknown, TRef = TSchema, TDiscriminated = TSchema, TDocument = unknown> = {\n  /**\n   * Whether the schema is nullable.\n   */\n  isNullable(schema?: TSchema): boolean\n  /**\n   * Whether the value is a `$ref` pointer.\n   */\n  isReference(value?: unknown): value is TRef\n  /**\n   * Whether the schema carries a discriminator for polymorphism.\n   */\n  isDiscriminator(value?: unknown): value is TDiscriminated\n  /**\n   * Whether the schema is binary data, converted to a `blob` node.\n   */\n  isBinary(schema: TSchema): boolean\n  /**\n   * Resolves a local `$ref` against the document, or nullish when it cannot.\n   */\n  resolveRef<TResolved>(document: TDocument, ref: string): TResolved | null | undefined\n}\n\n/**\n * How a dialect collapses structurally identical schemas into shared definitions. The contract is\n * generic over the plan and context types, which the adapter supplies. The mechanics live in the\n * adapter, not here, so `@kubb/ast` carries no dedupe logic. The returned plan owns the rewriting\n * behavior, so callers interact with one object.\n */\nexport type Dedupe<TPlan = unknown, TContext = unknown> = {\n  /**\n   * Scans a forest of nodes and produces a plan describing which shapes to share.\n   */\n  plan(roots: ReadonlyArray<Node>, context: TContext): TPlan\n}\n\n/**\n * A spec adapter's dialect. `name` identifies it in logs and diagnostics, `schema` holds the\n * spec-specific schema questions the parser answers, and `dedupe` is the schema-sharing seam.\n */\nexport type Dialect<TSchema = unknown, TRef = TSchema, TDiscriminated = TSchema, TDocument = unknown, TDedupe extends Dedupe = Dedupe> = {\n  /**\n   * Identifies the dialect in logs and diagnostics.\n   */\n  name: string\n  /**\n   * The spec-specific schema behavior. See {@link SchemaDialect}.\n   */\n  schema: SchemaDialect<TSchema, TRef, TDiscriminated, TDocument>\n  /**\n   * The schema-sharing behavior. See {@link Dedupe}.\n   */\n  dedupe: TDedupe\n}\n\n/**\n * Types a {@link Dialect} for an adapter. Adds no runtime behavior and only pins the\n * dialect's type for inference.\n *\n * @example\n * ```ts\n * export const oasDialect = defineDialect({\n *   name: 'oas',\n *   schema: {\n *     isNullable,\n *     isReference,\n *     isDiscriminator,\n *     isBinary: (schema) => schema.type === 'string' && schema.contentMediaType === 'application/octet-stream',\n *     resolveRef,\n *   },\n *   dedupe: { plan },\n * })\n * ```\n */\nexport function defineDialect<TSchema, TRef, TDiscriminated, TDocument, TDedupe extends Dedupe>(\n  dialect: Dialect<TSchema, TRef, TDiscriminated, TDocument, TDedupe>,\n): Dialect<TSchema, TRef, TDiscriminated, TDocument, TDedupe> {\n  return dialect\n}\n","import type { SchemaNode, SchemaNodeByType, SchemaType } from './nodes/index.ts'\n\n/**\n * Runtime context passed as `this` to printer handlers.\n *\n * `this.transform` dispatches to node-level handlers from `nodes`.\n *\n * @example\n * ```ts\n * const context: PrinterHandlerContext<string, {}> = {\n *   options: {},\n *   transform: () => 'value',\n * }\n * ```\n */\ntype PrinterHandlerContext<TOutput, TOptions extends object> = {\n  /**\n   * Recursively transform a nested `SchemaNode` to `TOutput` using the node-level handlers.\n   * Use `this.transform` inside `nodes` handlers and inside the `print` override.\n   */\n  transform: (node: SchemaNode) => TOutput | null\n  /**\n   * Options for this printer instance.\n   */\n  options: TOptions\n}\n\n/**\n * Handler for one schema node type.\n *\n * Use a regular function (not an arrow function) if you need `this`.\n *\n * @example\n * ```ts\n * const handler: PrinterHandler<string, {}, 'string'> = function () {\n *   return 'string'\n * }\n * ```\n */\ntype PrinterHandler<TOutput, TOptions extends object, T extends SchemaType = SchemaType> = (\n  this: PrinterHandlerContext<TOutput, TOptions>,\n  node: SchemaNodeByType[T],\n) => TOutput | null\n\n/**\n * Partial map of per-node-type handler overrides for a printer.\n *\n * Each key is a `SchemaType` string (e.g. `'date'`, `'string'`).\n * Supply only the handlers you want to replace. The printer's built-in\n * defaults fill in the rest.\n *\n * @example\n * ```ts\n * pluginZod({\n *   printer: {\n *     nodes: {\n *       date(): string {\n *         return 'z.string().date()'\n *       },\n *     } satisfies PrinterPartial<string, PrinterZodOptions>,\n *   },\n * })\n * ```\n */\nexport type PrinterPartial<TOutput, TOptions extends object> = Partial<{\n  [K in SchemaType]: PrinterHandler<TOutput, TOptions, K>\n}>\n\n/**\n * Generic shape used by `definePrinter`.\n *\n * - `TName` unique string identifier (e.g. `'zod'`, `'ts'`)\n * - `TOptions` options passed to and stored on the printer instance\n * - `TOutput` the type emitted by node handlers\n * - `TPrintOutput` type returned by public `print` (defaults to `TOutput`)\n *\n * @example\n * ```ts\n * type MyPrinter = PrinterFactoryOptions<'my', { strict: boolean }, string>\n * ```\n */\nexport type PrinterFactoryOptions<TName extends string = string, TOptions extends object = object, TOutput = unknown, TPrintOutput = TOutput> = {\n  name: TName\n  options: TOptions\n  output: TOutput\n  printOutput: TPrintOutput\n}\n\n/**\n * Printer instance returned by a printer factory.\n *\n * @example\n * ```ts\n * const printer = definePrinter((options: {}) => ({ name: 'x', options, nodes: {} }))({})\n * ```\n */\nexport type Printer<T extends PrinterFactoryOptions = PrinterFactoryOptions> = {\n  /**\n   * Unique identifier supplied at creation time.\n   */\n  name: T['name']\n  /**\n   * Options for this printer instance.\n   */\n  options: T['options']\n  /**\n   * Node-level dispatcher, converts a `SchemaNode` directly to `TOutput` using the `nodes` handlers.\n   * Always dispatches through the `nodes` map. Never calls the `print` override.\n   * Reach for it when you need the raw output (e.g. `ts.TypeNode`) without declaration wrapping.\n   */\n  transform: (node: SchemaNode) => T['output'] | null\n  /**\n   * Public printer. If the builder provides a root-level `print`, this calls that\n   * higher-level function (which may produce full declarations).\n   * Otherwise, falls back to the node-level dispatcher.\n   */\n  print: (node: SchemaNode) => T['printOutput'] | null\n}\n\n/**\n * Builder function passed to `definePrinter`.\n *\n * It receives resolved options and returns:\n * - `name`\n * - `options`\n * - `nodes` handlers\n * - optional top-level `print` override\n *\n * @example\n * ```ts\n * const build = (options: {}) => ({ name: 'x' as const, options, nodes: {} })\n * ```\n */\ntype PrinterBuilder<T extends PrinterFactoryOptions> = (options: T['options']) => {\n  name: T['name']\n  /**\n   * Options to store on the printer.\n   */\n  options: T['options']\n  nodes: Partial<{\n    [K in SchemaType]: PrinterHandler<T['output'], T['options'], K>\n  }>\n  /**\n   * Optional root-level print override. When provided, becomes the public `printer.print`.\n   * Use `this.transform(node)` inside this function to dispatch to the node-level handlers (`nodes`),\n   * not the override itself, so recursion is safe.\n   */\n  print?: (this: PrinterHandlerContext<T['output'], T['options']>, node: SchemaNode) => T['printOutput'] | null\n}\n/**\n * Defines a schema printer: a function that takes a `SchemaNode` and emits\n * code in your target language. Each plugin that produces code from schemas\n * (TypeScript types, Zod schemas, Faker factories) ships a printer built\n * with this helper.\n *\n * The builder receives resolved options and returns:\n *\n * - `name` unique identifier for the printer.\n * - `options` stored on the returned printer instance.\n * - `nodes` map of `SchemaType` → handler. Handlers return the rendered\n *   output (a string, a TypeScript AST node, ...) for that schema type.\n * - `print` (optional), top-level override exposed as `printer.print`.\n *   Use `this.transform(node)` inside it to dispatch to `nodes` recursively.\n *\n * Without a `print` override, `printer.print` falls back to `printer.transform`\n * (the node-level dispatcher).\n *\n * @example Tiny Zod printer\n * ```ts\n * import { definePrinter, type PrinterFactoryOptions } from '@kubb/ast'\n *\n * type PrinterZod = PrinterFactoryOptions<'zod', { strict?: boolean }, string>\n *\n * export const zodPrinter = definePrinter<PrinterZod>((options) => ({\n *   name: 'zod',\n *   options: { strict: options.strict ?? true },\n *   nodes: {\n *     string: () => 'z.string()',\n *     object(node) {\n *       const props = node.properties\n *         .map((p) => `${p.name}: ${this.transform(p.schema)}`)\n *         .join(', ')\n *       return `z.object({ ${props} })`\n *     },\n *   },\n * }))\n * ```\n */\nexport function definePrinter<T extends PrinterFactoryOptions = PrinterFactoryOptions>(build: PrinterBuilder<T>): (options?: T['options']) => Printer<T> {\n  return createPrinterFactory<SchemaNode, SchemaType, SchemaNodeByType>((node) => node.type)(build) as (options?: T['options']) => Printer<T>\n}\n\n/**\n * Generic printer factory behind `definePrinter`. Pass a `getKey` function that maps a node to its\n * handler key, and it returns a `definePrinter`-style helper for that node and key type. `definePrinter`\n * itself is this factory keyed by `node.type`.\n *\n * @example Key a printer by `node.kind` instead of `node.type`\n * ```ts\n * const defineFunctionPrinter = createPrinterFactory<FunctionParamNode, FunctionParamKind, Partial<Record<FunctionParamKind, FunctionParamNode>>>(\n *   (node) => node.kind,\n * )\n * ```\n */\nexport function createPrinterFactory<TNode, TKey extends string, TNodeByKey extends Partial<Record<TKey, TNode>>>(getKey: (node: TNode) => TKey | null) {\n  return function <T extends PrinterFactoryOptions>(\n    build: (options: T['options']) => {\n      name: T['name']\n      options: T['options']\n      nodes: Partial<{\n        [K in TKey]: (\n          this: {\n            transform: (node: TNode) => T['output'] | null\n            options: T['options']\n          },\n          node: TNodeByKey[K],\n        ) => T['output'] | null\n      }>\n      print?: (\n        this: {\n          transform: (node: TNode) => T['output'] | null\n          options: T['options']\n        },\n        node: TNode,\n      ) => T['printOutput'] | null\n    },\n  ): (options?: T['options']) => {\n    name: T['name']\n    options: T['options']\n    transform: (node: TNode) => T['output'] | null\n    print: (node: TNode) => T['printOutput'] | null\n  } {\n    return (options) => {\n      const { name, options: resolvedOptions, nodes, print: printOverride } = build(options ?? ({} as T['options']))\n\n      const context = {\n        options: resolvedOptions,\n        transform: (node: TNode): T['output'] | null => {\n          const key = getKey(node)\n          if (key === null) return null\n\n          const handler = nodes[key]\n\n          if (!handler) return null\n\n          return (handler as (this: typeof context, node: TNode) => T['output'] | null).call(context, node)\n        },\n      }\n\n      return {\n        name,\n        options: resolvedOptions,\n        transform: context.transform,\n        print: (printOverride ? printOverride.bind(context) : context.transform) as (node: TNode) => T['printOutput'] | null,\n      }\n    }\n  }\n}\n","import { hash } from 'node:crypto'\nimport type { SchemaNode } from './nodes/index.ts'\nimport { extractRefName } from './utils/index.ts'\n\n/**\n * The flags shared by every node kind that affect its type: `primitive`, `format`, `nullable`.\n */\nfunction flagsDescriptor(node: SchemaNode): string {\n  return `${node.primitive ?? ''};${node.format ?? ''};${node.nullable ? 1 : 0}`\n}\n\nfunction refTargetName(node: Extract<SchemaNode, { type: 'ref' }>): string {\n  if (node.ref) return extractRefName(node.ref)\n  return node.name ?? ''\n}\n\ntype ScalarField = { kind: 'scalar'; key: string; prefix: string }\ntype BoolField = { kind: 'bool'; key: string; prefix: string }\ntype ChildField = { kind: 'child'; key: string; prefix: string }\ntype ChildrenField = { kind: 'children'; key: string; prefix: string }\ntype ObjectPropsField = { kind: 'objectProps' }\ntype AdditionalPropsField = { kind: 'additionalProps' }\ntype PatternPropsField = { kind: 'patternProps' }\ntype EnumValuesField = { kind: 'enumValues' }\ntype RefTargetField = { kind: 'refTarget' }\n\ntype ShapeField =\n  | ScalarField\n  | BoolField\n  | ChildField\n  | ChildrenField\n  | ObjectPropsField\n  | AdditionalPropsField\n  | PatternPropsField\n  | EnumValuesField\n  | RefTargetField\n\nconst arrayTupleFields: ReadonlyArray<ShapeField> = [\n  { kind: 'children', key: 'items', prefix: 'i' },\n  { kind: 'child', key: 'rest', prefix: 'r' },\n  { kind: 'scalar', key: 'min', prefix: 'mn' },\n  { kind: 'scalar', key: 'max', prefix: 'mx' },\n  { kind: 'bool', key: 'unique', prefix: 'u' },\n]\n\nconst numericFields: ReadonlyArray<ShapeField> = [\n  { kind: 'scalar', key: 'min', prefix: 'mn' },\n  { kind: 'scalar', key: 'max', prefix: 'mx' },\n  { kind: 'scalar', key: 'exclusiveMinimum', prefix: 'emn' },\n  { kind: 'scalar', key: 'exclusiveMaximum', prefix: 'emx' },\n  { kind: 'scalar', key: 'multipleOf', prefix: 'mo' },\n]\n\nconst rangeFields: ReadonlyArray<ShapeField> = [\n  { kind: 'scalar', key: 'min', prefix: 'mn' },\n  { kind: 'scalar', key: 'max', prefix: 'mx' },\n]\n\n/**\n * Maps each node `type` to its ordered shape-contributing fields. Types absent from the map\n * (boolean, null, any, and other scalars) fall back to `${type}|${flags}`.\n */\nconst SHAPE_KEYS: Partial<Record<SchemaNode['type'], ReadonlyArray<ShapeField>>> = {\n  object: [\n    { kind: 'objectProps' },\n    { kind: 'additionalProps' },\n    { kind: 'patternProps' },\n    { kind: 'scalar', key: 'minProperties', prefix: 'mn' },\n    { kind: 'scalar', key: 'maxProperties', prefix: 'mx' },\n  ],\n  array: arrayTupleFields,\n  tuple: arrayTupleFields,\n  union: [\n    { kind: 'scalar', key: 'strategy', prefix: 's' },\n    { kind: 'scalar', key: 'discriminatorPropertyName', prefix: 'd' },\n    { kind: 'children', key: 'members', prefix: 'm' },\n  ],\n  intersection: [{ kind: 'children', key: 'members', prefix: 'm' }],\n  enum: [{ kind: 'enumValues' }],\n  ref: [{ kind: 'refTarget' }],\n  string: [\n    { kind: 'scalar', key: 'min', prefix: 'mn' },\n    { kind: 'scalar', key: 'max', prefix: 'mx' },\n    { kind: 'scalar', key: 'pattern', prefix: 'pt' },\n  ],\n  number: numericFields,\n  integer: numericFields,\n  bigint: numericFields,\n  url: [\n    { kind: 'scalar', key: 'path', prefix: 'path' },\n    { kind: 'scalar', key: 'min', prefix: 'mn' },\n    { kind: 'scalar', key: 'max', prefix: 'mx' },\n  ],\n  uuid: rangeFields,\n  email: rangeFields,\n  datetime: [\n    { kind: 'bool', key: 'offset', prefix: 'o' },\n    { kind: 'bool', key: 'local', prefix: 'l' },\n  ],\n  date: [{ kind: 'scalar', key: 'representation', prefix: 'rep' }],\n  time: [{ kind: 'scalar', key: 'representation', prefix: 'rep' }],\n}\n\nfunction serializeShapeField(field: ShapeField, node: SchemaNode, record: Record<string, unknown>): string {\n  switch (field.kind) {\n    case 'scalar':\n      return `${field.prefix}:${record[field.key] ?? ''}`\n    case 'bool':\n      return `${field.prefix}:${record[field.key] ? 1 : 0}`\n    case 'child': {\n      const child = record[field.key] as SchemaNode | undefined\n      return `${field.prefix}:${child ? signatureOf(child) : ''}`\n    }\n    case 'children': {\n      const children = (record[field.key] as Array<SchemaNode> | undefined) ?? []\n      return `${field.prefix}[${children.map((c) => signatureOf(c)).join(',')}]`\n    }\n    case 'objectProps': {\n      const obj = node as Extract<SchemaNode, { type: 'object' }>\n      const props = (obj.properties ?? []).map((prop) => `${prop.name}${prop.required ? '!' : '?'}${signatureOf(prop.schema)}`).join(',')\n      return `p[${props}]`\n    }\n    case 'additionalProps': {\n      const obj = node as Extract<SchemaNode, { type: 'object' }>\n      if (typeof obj.additionalProperties === 'boolean') return `ab:${obj.additionalProperties}`\n      if (obj.additionalProperties) return `as:${signatureOf(obj.additionalProperties)}`\n      return ''\n    }\n    case 'patternProps': {\n      const obj = node as Extract<SchemaNode, { type: 'object' }>\n      const pattern = obj.patternProperties\n        ? Object.keys(obj.patternProperties)\n            .sort()\n            .map((key) => `${key}=${signatureOf(obj.patternProperties![key]!)}`)\n            .join(',')\n        : ''\n      return `pp[${pattern}]`\n    }\n    case 'enumValues': {\n      const en = node as Extract<SchemaNode, { type: 'enum' }>\n      let values = ''\n      if (en.namedEnumValues?.length) {\n        values = en.namedEnumValues.map((entry) => `${entry.name}=${entry.primitive}:${String(entry.value)}`).join(',')\n      } else if (en.enumValues?.length) {\n        values = en.enumValues.map((value) => `${value === null ? 'null' : typeof value}:${String(value)}`).join(',')\n      }\n      return `v[${values}]`\n    }\n    case 'refTarget': {\n      return `->${refTargetName(node as Extract<SchemaNode, { type: 'ref' }>)}`\n    }\n  }\n}\n\n/**\n * Builds the local shape descriptor that {@link signatureOf} hashes: the node's kind, flags,\n * constraints, and its children's signatures.\n */\nfunction describeShape(node: SchemaNode): string {\n  const flags = flagsDescriptor(node)\n  const fields = SHAPE_KEYS[node.type]\n  if (!fields) return `${node.type}|${flags}`\n\n  const record = node as unknown as Record<string, unknown>\n  const parts: Array<string> = [`${node.type}|${flags}`]\n  for (const field of fields) {\n    parts.push(serializeShapeField(field, node, record))\n  }\n  return parts.join('|')\n}\n\n/**\n * Caches the digest per node, keyed by identity. A `WeakMap` so entries die with the node, and so\n * a tree hashed during dedupe planning is not walked again when it is rewritten during streaming.\n * Reuse is safe because a signature depends only on content, and nodes are immutable once created.\n */\nconst signatureCache = new WeakMap<SchemaNode, string>()\n\n/**\n * Computes a deterministic, shape-only signature (a content hash) for a schema node. Two schemas\n * share a signature when they are structurally identical, ignoring documentation (`name`, `title`,\n * `description`, `example`, `default`, `deprecated`) and usage-slot flags (`optional`, `nullish`,\n * `readOnly`, `writeOnly`). `nullable` is kept because it changes the produced type, and `ref`\n * nodes compare by target name, which also terminates on circular shapes.\n *\n * @example Two enums with different descriptions share a signature\n * ```ts\n * signatureOf(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'], description: 'x' })) ===\n *   signatureOf(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'] }))\n * ```\n */\nexport function signatureOf(node: SchemaNode): string {\n  const cached = signatureCache.get(node)\n  if (cached !== undefined) return cached\n  const signature = hash('sha256', describeShape(node), 'hex')\n  signatureCache.set(node, signature)\n\n  return signature\n}\n\n/**\n * Returns `true` when two schema nodes are structurally identical under shape-only equality,\n * meaning they produce the same TypeScript type.\n */\nexport function isSchemaEqual(a: SchemaNode, b: SchemaNode): boolean {\n  return signatureOf(a) === signatureOf(b)\n}\n"],"mappings":"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"}

package/dist/macros.cjs

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_response = require("./response-BeG6hq2D.cjs");
-const require_visitor = require("./visitor-B7Zlnp4c.cjs");
-const require_defineMacro = require("./defineMacro-BryDiuQl.cjs");
+const require_schema = require("./schema-BkvrrOAr.cjs");
+const require_refs = require("./refs-u5SDdyV7.cjs");
+const require_defineMacro = require("./defineMacro-CEZHaCXE.cjs");
 //#region src/macros/macroDiscriminatorEnum.ts
 /**
 * Builds a macro that replaces a discriminator property's schema with a string enum of the given
@@ -17,16 +17,16 @@ function macroDiscriminatorEnum({ propertyName, values, enumName }) {
 	return require_defineMacro.defineMacro({
 		name: "discriminator-enum",
 		schema(node) {
-			const objectNode = require_visitor.narrowSchema(node, "object");
+			const objectNode = require_refs.narrowSchema(node, "object");
 			if (!objectNode?.properties?.length) return void 0;
 			if (!objectNode.properties.some((prop) => prop.name === propertyName)) return void 0;
-			return require_response.createSchema({
+			return require_schema.createSchema({
 				...objectNode,
 				properties: objectNode.properties.map((prop) => {
 					if (prop.name !== propertyName) return prop;
-					return require_response.createProperty({
+					return require_schema.createProperty({
 						...prop,
-						schema: require_response.createSchema({
+						schema: require_schema.createSchema({
 							type: "enum",
 							primitive: "string",
 							enumValues: values,
@@ -44,7 +44,7 @@ function macroDiscriminatorEnum({ propertyName, values, enumName }) {
 //#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.
+* are left anonymous. Non-enum nodes are returned unchanged.
 *
 * @example
 * ```ts
@@ -56,14 +56,14 @@ function macroEnumName({ parentName, propName, enumSuffix }) {
 	return require_defineMacro.defineMacro({
 		name: "enum-name",
 		schema(node) {
-			const enumNode = require_visitor.narrowSchema(node, "enum");
+			const enumNode = require_refs.narrowSchema(node, "enum");
 			if (enumNode?.primitive === "boolean") return {
 				...node,
 				name: null
 			};
 			if (enumNode) return {
 				...node,
-				name: require_visitor.enumPropName(parentName, propName, enumSuffix)
+				name: require_refs.enumPropName(parentName, propName, enumSuffix)
 			};
 		}
 	});
@@ -90,7 +90,7 @@ 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");
+		const enumNode = require_refs.narrowSchema(member, "enum");
 		if (!enumNode) return true;
 		const primitive = enumNode.primitive;
 		if (!primitive) return true;
@@ -112,7 +112,7 @@ function simplifyUnionMembers(members) {
 const macroSimplifyUnion = require_defineMacro.defineMacro({
 	name: "simplify-union",
 	schema(node) {
-		const unionNode = require_visitor.narrowSchema(node, "union");
+		const unionNode = require_refs.narrowSchema(node, "union");
 		if (!unionNode?.members?.length) return void 0;
 		const simplified = simplifyUnionMembers(unionNode.members);
 		if (simplified.length === unionNode.members.length) return void 0;

package/dist/macros.cjs.map

@@ -1 +1 @@
-{"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,iBAAAA,aAAa;IAClB,GAAG;IACH,YAAY,WAAW,WAAW,KAAK,SAAS;KAC9C,IAAI,KAAK,SAAS,cAAc,OAAO;KAEvC,OAAOC,iBAAAA,eAAe;MACpB,GAAG;MACH,QAAQD,iBAAAA,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,gBAAAA,aAAa,YAAY,UAAU,UAAU;GAAE;EAGvF;CACF,CAAC;AACH;;;;;;ACvBA,MAAM,yBAAyB,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"}
+{"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,aAAAA,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,eAAAA,aAAa;IAClB,GAAG;IACH,YAAY,WAAW,WAAW,KAAK,SAAS;KAC9C,IAAI,KAAK,SAAS,cAAc,OAAO;KAEvC,OAAOC,eAAAA,eAAe;MACpB,GAAG;MACH,QAAQD,eAAAA,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,aAAAA,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,yBAAyB,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,aAAAA,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,aAAAA,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,5 +1,5 @@
 import { n as __name } from "./chunk-CNktS9qV.js";
-import { n as Macro } from "./defineMacro-Vw-xQvq7.js";
+import { n as Macro } from "./defineMacro-BATi7xoC.js";
 
 //#region src/macros/macroDiscriminatorEnum.d.ts
 type Props$1 = {
@@ -31,7 +31,7 @@ type Props = {
 };
 /**
  * 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.
+ * are left anonymous. Non-enum nodes are returned unchanged.
  *
  * @example
  * ```ts