@kubb/ast 5.0.0-beta.67 → 5.0.0-beta.69

package/dist/index.cjs

@@ -1,8 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_refs = require("./refs-DDIY_Tpn.cjs");
-require("./utils-DYhjlv0E.cjs");
-const require_defineMacro = require("./defineMacro-BxfaP1iL.cjs");
-let node_crypto = require("node:crypto");
+const require_visitor = require("./visitor-CLLDwBvv.cjs");
+const require_defineMacro = require("./defineMacro-Bh5E_Il6.cjs");
 //#region src/defineDialect.ts
 /**
 * Types a {@link Dialect} for an adapter. Adds no runtime behavior and only pins the
@@ -19,7 +17,6 @@ let node_crypto = require("node:crypto");
 *     isBinary: (schema) => schema.type === 'string' && schema.contentMediaType === 'application/octet-stream',
 *     resolveRef,
 *   },
-*   dedupe: { plan },
 * })
 * ```
 */
@@ -87,285 +84,33 @@ function createPrinter(build) {
 	};
 }
 //#endregion
-//#region src/signature.ts
-/**
-* The flags shared by every node kind that affect its type: `primitive`, `format`, `nullable`.
-*/
-function flagsDescriptor(node) {
-	return `${node.primitive ?? ""};${node.format ?? ""};${node.nullable ? 1 : 0}`;
-}
-function refTargetName(node) {
-	if (node.ref) return require_refs.extractRefName(node.ref);
-	return node.name ?? "";
-}
-const arrayTupleFields = [
-	{
-		kind: "children",
-		key: "items",
-		prefix: "i"
-	},
-	{
-		kind: "child",
-		key: "rest",
-		prefix: "r"
-	},
-	{
-		kind: "scalar",
-		key: "min",
-		prefix: "mn"
-	},
-	{
-		kind: "scalar",
-		key: "max",
-		prefix: "mx"
-	},
-	{
-		kind: "bool",
-		key: "unique",
-		prefix: "u"
-	}
-];
-const numericFields = [
-	{
-		kind: "scalar",
-		key: "min",
-		prefix: "mn"
-	},
-	{
-		kind: "scalar",
-		key: "max",
-		prefix: "mx"
-	},
-	{
-		kind: "scalar",
-		key: "exclusiveMinimum",
-		prefix: "emn"
-	},
-	{
-		kind: "scalar",
-		key: "exclusiveMaximum",
-		prefix: "emx"
-	},
-	{
-		kind: "scalar",
-		key: "multipleOf",
-		prefix: "mo"
-	}
-];
-const rangeFields = [{
-	kind: "scalar",
-	key: "min",
-	prefix: "mn"
-}, {
-	kind: "scalar",
-	key: "max",
-	prefix: "mx"
-}];
-/**
-* Maps each node `type` to its ordered shape-contributing fields. Types absent from the map
-* (boolean, null, any, and other scalars) fall back to `${type}|${flags}`.
-*/
-const SHAPE_KEYS = {
-	object: [
-		{ kind: "objectProps" },
-		{ kind: "additionalProps" },
-		{ kind: "patternProps" },
-		{
-			kind: "scalar",
-			key: "minProperties",
-			prefix: "mn"
-		},
-		{
-			kind: "scalar",
-			key: "maxProperties",
-			prefix: "mx"
-		}
-	],
-	array: arrayTupleFields,
-	tuple: arrayTupleFields,
-	union: [
-		{
-			kind: "scalar",
-			key: "strategy",
-			prefix: "s"
-		},
-		{
-			kind: "scalar",
-			key: "discriminatorPropertyName",
-			prefix: "d"
-		},
-		{
-			kind: "children",
-			key: "members",
-			prefix: "m"
-		}
-	],
-	intersection: [{
-		kind: "children",
-		key: "members",
-		prefix: "m"
-	}],
-	enum: [{ kind: "enumValues" }],
-	ref: [{ kind: "refTarget" }],
-	string: [
-		{
-			kind: "scalar",
-			key: "min",
-			prefix: "mn"
-		},
-		{
-			kind: "scalar",
-			key: "max",
-			prefix: "mx"
-		},
-		{
-			kind: "scalar",
-			key: "pattern",
-			prefix: "pt"
-		}
-	],
-	number: numericFields,
-	integer: numericFields,
-	bigint: numericFields,
-	url: [
-		{
-			kind: "scalar",
-			key: "path",
-			prefix: "path"
-		},
-		{
-			kind: "scalar",
-			key: "min",
-			prefix: "mn"
-		},
-		{
-			kind: "scalar",
-			key: "max",
-			prefix: "mx"
-		}
-	],
-	uuid: rangeFields,
-	email: rangeFields,
-	datetime: [{
-		kind: "bool",
-		key: "offset",
-		prefix: "o"
-	}, {
-		kind: "bool",
-		key: "local",
-		prefix: "l"
-	}],
-	date: [{
-		kind: "scalar",
-		key: "representation",
-		prefix: "rep"
-	}],
-	time: [{
-		kind: "scalar",
-		key: "representation",
-		prefix: "rep"
-	}]
-};
-function serializeShapeField(field, node, record) {
-	switch (field.kind) {
-		case "scalar": return `${field.prefix}:${record[field.key] ?? ""}`;
-		case "bool": return `${field.prefix}:${record[field.key] ? 1 : 0}`;
-		case "child": {
-			const child = record[field.key];
-			return `${field.prefix}:${child ? signatureOf(child) : ""}`;
-		}
-		case "children": {
-			const children = record[field.key] ?? [];
-			return `${field.prefix}[${children.map((c) => signatureOf(c)).join(",")}]`;
-		}
-		case "objectProps": return `p[${(node.properties ?? []).map((prop) => `${prop.name}${prop.required ? "!" : "?"}${signatureOf(prop.schema)}`).join(",")}]`;
-		case "additionalProps": {
-			const obj = node;
-			if (typeof obj.additionalProperties === "boolean") return `ab:${obj.additionalProperties}`;
-			if (obj.additionalProperties) return `as:${signatureOf(obj.additionalProperties)}`;
-			return "";
-		}
-		case "patternProps": {
-			const obj = node;
-			return `pp[${obj.patternProperties ? Object.keys(obj.patternProperties).sort().map((key) => `${key}=${signatureOf(obj.patternProperties[key])}`).join(",") : ""}]`;
-		}
-		case "enumValues": {
-			const en = node;
-			let values = "";
-			if (en.namedEnumValues?.length) values = en.namedEnumValues.map((entry) => `${entry.name}=${entry.primitive}:${String(entry.value)}`).join(",");
-			else if (en.enumValues?.length) values = en.enumValues.map((value) => `${value === null ? "null" : typeof value}:${String(value)}`).join(",");
-			return `v[${values}]`;
-		}
-		case "refTarget": return `->${refTargetName(node)}`;
-	}
-}
-/**
-* Builds the local shape descriptor that {@link signatureOf} hashes: the node's kind, flags,
-* constraints, and its children's signatures.
-*/
-function describeShape(node) {
-	const flags = flagsDescriptor(node);
-	const fields = SHAPE_KEYS[node.type];
-	if (!fields) return `${node.type}|${flags}`;
-	const record = node;
-	const parts = [`${node.type}|${flags}`];
-	for (const field of fields) parts.push(serializeShapeField(field, node, record));
-	return parts.join("|");
-}
-/**
-* Caches the digest per node, keyed by identity. A `WeakMap` so entries die with the node, and so
-* a tree hashed during dedupe planning is not walked again when it is rewritten during streaming.
-* Reuse is safe because a signature depends only on content, and nodes are immutable once created.
-*/
-const signatureCache = /* @__PURE__ */ new WeakMap();
-/**
-* Computes a deterministic, shape-only signature (a content hash) for a schema node. Two schemas
-* share a signature when they are structurally identical, ignoring documentation (`name`, `title`,
-* `description`, `examples`, `default`, `deprecated`) and usage-slot flags (`optional`, `nullish`,
-* `readOnly`, `writeOnly`). `nullable` is kept because it changes the produced type, and `ref`
-* nodes compare by target name, which also terminates on circular shapes.
-*
-* @example Two enums with different descriptions share a signature
-* ```ts
-* signatureOf(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'], description: 'x' })) ===
-*   signatureOf(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'] }))
-* ```
-*/
-function signatureOf(node) {
-	const cached = signatureCache.get(node);
-	if (cached !== void 0) return cached;
-	const signature = (0, node_crypto.hash)("sha256", describeShape(node), "hex");
-	signatureCache.set(node, signature);
-	return signature;
-}
-//#endregion
 //#region src/factory.ts
-var factory_exports = /* @__PURE__ */ require_refs.__exportAll({
-	createArrowFunction: () => require_refs.createArrowFunction,
-	createBreak: () => require_refs.createBreak,
-	createConst: () => require_refs.createConst,
-	createContent: () => require_refs.createContent,
-	createExport: () => require_refs.createExport,
-	createFile: () => require_refs.createFile,
-	createFunction: () => require_refs.createFunction,
-	createFunctionParameter: () => require_refs.createFunctionParameter,
-	createFunctionParameters: () => require_refs.createFunctionParameters,
-	createImport: () => require_refs.createImport,
-	createIndexedAccessType: () => require_refs.createIndexedAccessType,
-	createInput: () => require_refs.createInput,
-	createJsx: () => require_refs.createJsx,
-	createObjectBindingPattern: () => require_refs.createObjectBindingPattern,
-	createOperation: () => require_refs.createOperation,
-	createOutput: () => require_refs.createOutput,
-	createParameter: () => require_refs.createParameter,
-	createProperty: () => require_refs.createProperty,
-	createRequestBody: () => require_refs.createRequestBody,
-	createResponse: () => require_refs.createResponse,
-	createSchema: () => require_refs.createSchema,
-	createSource: () => require_refs.createSource,
-	createText: () => require_refs.createText,
-	createType: () => require_refs.createType,
-	createTypeLiteral: () => require_refs.createTypeLiteral,
+var factory_exports = /* @__PURE__ */ require_visitor.__exportAll({
+	createArrowFunction: () => require_visitor.createArrowFunction,
+	createBreak: () => require_visitor.createBreak,
+	createConst: () => require_visitor.createConst,
+	createContent: () => require_visitor.createContent,
+	createExport: () => require_visitor.createExport,
+	createFile: () => require_visitor.createFile,
+	createFunction: () => require_visitor.createFunction,
+	createFunctionParameter: () => require_visitor.createFunctionParameter,
+	createFunctionParameters: () => require_visitor.createFunctionParameters,
+	createImport: () => require_visitor.createImport,
+	createIndexedAccessType: () => require_visitor.createIndexedAccessType,
+	createInput: () => require_visitor.createInput,
+	createJsx: () => require_visitor.createJsx,
+	createObjectBindingPattern: () => require_visitor.createObjectBindingPattern,
+	createOperation: () => require_visitor.createOperation,
+	createOutput: () => require_visitor.createOutput,
+	createParameter: () => require_visitor.createParameter,
+	createProperty: () => require_visitor.createProperty,
+	createRequestBody: () => require_visitor.createRequestBody,
+	createResponse: () => require_visitor.createResponse,
+	createSchema: () => require_visitor.createSchema,
+	createSource: () => require_visitor.createSource,
+	createText: () => require_visitor.createText,
+	createType: () => require_visitor.createType,
+	createTypeLiteral: () => require_visitor.createTypeLiteral,
 	update: () => update
 });
 /**
@@ -393,101 +138,99 @@ function update(node, changes) {
 }
 //#endregion
 //#region src/exports.ts
-var exports_exports = /* @__PURE__ */ require_refs.__exportAll({
+var exports_exports = /* @__PURE__ */ require_visitor.__exportAll({
 	applyMacros: () => require_defineMacro.applyMacros,
-	arrowFunctionDef: () => require_refs.arrowFunctionDef,
-	breakDef: () => require_refs.breakDef,
-	collect: () => require_refs.collect,
+	arrowFunctionDef: () => require_visitor.arrowFunctionDef,
+	breakDef: () => require_visitor.breakDef,
+	collect: () => require_visitor.collect,
 	composeMacros: () => require_defineMacro.composeMacros,
-	constDef: () => require_refs.constDef,
-	contentDef: () => require_refs.contentDef,
+	constDef: () => require_visitor.constDef,
+	contentDef: () => require_visitor.contentDef,
 	createPrinter: () => createPrinter,
 	defineDialect: () => defineDialect,
 	defineMacro: () => require_defineMacro.defineMacro,
-	defineNode: () => require_refs.defineNode,
-	exportDef: () => require_refs.exportDef,
+	defineNode: () => require_visitor.defineNode,
+	exportDef: () => require_visitor.exportDef,
 	factory: () => factory_exports,
-	fileDef: () => require_refs.fileDef,
-	functionDef: () => require_refs.functionDef,
-	functionParameterDef: () => require_refs.functionParameterDef,
-	functionParametersDef: () => require_refs.functionParametersDef,
-	importDef: () => require_refs.importDef,
-	indexedAccessTypeDef: () => require_refs.indexedAccessTypeDef,
-	inputDef: () => require_refs.inputDef,
-	isHttpOperationNode: () => require_refs.isHttpOperationNode,
-	jsxDef: () => require_refs.jsxDef,
-	narrowSchema: () => require_refs.narrowSchema,
-	nodeDefs: () => require_refs.nodeDefs,
-	objectBindingPatternDef: () => require_refs.objectBindingPatternDef,
-	operationDef: () => require_refs.operationDef,
-	optionality: () => require_refs.optionality,
-	outputDef: () => require_refs.outputDef,
-	parameterDef: () => require_refs.parameterDef,
-	propertyDef: () => require_refs.propertyDef,
-	requestBodyDef: () => require_refs.requestBodyDef,
-	responseDef: () => require_refs.responseDef,
-	schemaDef: () => require_refs.schemaDef,
-	schemaTypes: () => require_refs.schemaTypes,
-	signatureOf: () => signatureOf,
-	sourceDef: () => require_refs.sourceDef,
-	textDef: () => require_refs.textDef,
-	transform: () => require_refs.transform,
-	typeDef: () => require_refs.typeDef,
-	typeLiteralDef: () => require_refs.typeLiteralDef,
-	walk: () => require_refs.walk
+	fileDef: () => require_visitor.fileDef,
+	functionDef: () => require_visitor.functionDef,
+	functionParameterDef: () => require_visitor.functionParameterDef,
+	functionParametersDef: () => require_visitor.functionParametersDef,
+	importDef: () => require_visitor.importDef,
+	indexedAccessTypeDef: () => require_visitor.indexedAccessTypeDef,
+	inputDef: () => require_visitor.inputDef,
+	isHttpOperationNode: () => require_visitor.isHttpOperationNode,
+	jsxDef: () => require_visitor.jsxDef,
+	narrowSchema: () => require_visitor.narrowSchema,
+	nodeDefs: () => require_visitor.nodeDefs,
+	objectBindingPatternDef: () => require_visitor.objectBindingPatternDef,
+	operationDef: () => require_visitor.operationDef,
+	optionality: () => require_visitor.optionality,
+	outputDef: () => require_visitor.outputDef,
+	parameterDef: () => require_visitor.parameterDef,
+	propertyDef: () => require_visitor.propertyDef,
+	requestBodyDef: () => require_visitor.requestBodyDef,
+	responseDef: () => require_visitor.responseDef,
+	schemaDef: () => require_visitor.schemaDef,
+	schemaTypes: () => require_visitor.schemaTypes,
+	sourceDef: () => require_visitor.sourceDef,
+	textDef: () => require_visitor.textDef,
+	transform: () => require_visitor.transform,
+	typeDef: () => require_visitor.typeDef,
+	typeLiteralDef: () => require_visitor.typeLiteralDef,
+	walk: () => require_visitor.walk
 });
 //#endregion
 exports.applyMacros = require_defineMacro.applyMacros;
-exports.arrowFunctionDef = require_refs.arrowFunctionDef;
+exports.arrowFunctionDef = require_visitor.arrowFunctionDef;
 Object.defineProperty(exports, "ast", {
 	enumerable: true,
 	get: function() {
 		return exports_exports;
 	}
 });
-exports.breakDef = require_refs.breakDef;
-exports.collect = require_refs.collect;
+exports.breakDef = require_visitor.breakDef;
+exports.collect = require_visitor.collect;
 exports.composeMacros = require_defineMacro.composeMacros;
-exports.constDef = require_refs.constDef;
-exports.contentDef = require_refs.contentDef;
+exports.constDef = require_visitor.constDef;
+exports.contentDef = require_visitor.contentDef;
 exports.createPrinter = createPrinter;
 exports.defineDialect = defineDialect;
 exports.defineMacro = require_defineMacro.defineMacro;
-exports.defineNode = require_refs.defineNode;
-exports.exportDef = require_refs.exportDef;
+exports.defineNode = require_visitor.defineNode;
+exports.exportDef = require_visitor.exportDef;
 Object.defineProperty(exports, "factory", {
 	enumerable: true,
 	get: function() {
 		return factory_exports;
 	}
 });
-exports.fileDef = require_refs.fileDef;
-exports.functionDef = require_refs.functionDef;
-exports.functionParameterDef = require_refs.functionParameterDef;
-exports.functionParametersDef = require_refs.functionParametersDef;
-exports.importDef = require_refs.importDef;
-exports.indexedAccessTypeDef = require_refs.indexedAccessTypeDef;
-exports.inputDef = require_refs.inputDef;
-exports.isHttpOperationNode = require_refs.isHttpOperationNode;
-exports.jsxDef = require_refs.jsxDef;
-exports.narrowSchema = require_refs.narrowSchema;
-exports.nodeDefs = require_refs.nodeDefs;
-exports.objectBindingPatternDef = require_refs.objectBindingPatternDef;
-exports.operationDef = require_refs.operationDef;
-exports.optionality = require_refs.optionality;
-exports.outputDef = require_refs.outputDef;
-exports.parameterDef = require_refs.parameterDef;
-exports.propertyDef = require_refs.propertyDef;
-exports.requestBodyDef = require_refs.requestBodyDef;
-exports.responseDef = require_refs.responseDef;
-exports.schemaDef = require_refs.schemaDef;
-exports.schemaTypes = require_refs.schemaTypes;
-exports.signatureOf = signatureOf;
-exports.sourceDef = require_refs.sourceDef;
-exports.textDef = require_refs.textDef;
-exports.transform = require_refs.transform;
-exports.typeDef = require_refs.typeDef;
-exports.typeLiteralDef = require_refs.typeLiteralDef;
-exports.walk = require_refs.walk;
+exports.fileDef = require_visitor.fileDef;
+exports.functionDef = require_visitor.functionDef;
+exports.functionParameterDef = require_visitor.functionParameterDef;
+exports.functionParametersDef = require_visitor.functionParametersDef;
+exports.importDef = require_visitor.importDef;
+exports.indexedAccessTypeDef = require_visitor.indexedAccessTypeDef;
+exports.inputDef = require_visitor.inputDef;
+exports.isHttpOperationNode = require_visitor.isHttpOperationNode;
+exports.jsxDef = require_visitor.jsxDef;
+exports.narrowSchema = require_visitor.narrowSchema;
+exports.nodeDefs = require_visitor.nodeDefs;
+exports.objectBindingPatternDef = require_visitor.objectBindingPatternDef;
+exports.operationDef = require_visitor.operationDef;
+exports.optionality = require_visitor.optionality;
+exports.outputDef = require_visitor.outputDef;
+exports.parameterDef = require_visitor.parameterDef;
+exports.propertyDef = require_visitor.propertyDef;
+exports.requestBodyDef = require_visitor.requestBodyDef;
+exports.responseDef = require_visitor.responseDef;
+exports.schemaDef = require_visitor.schemaDef;
+exports.schemaTypes = require_visitor.schemaTypes;
+exports.sourceDef = require_visitor.sourceDef;
+exports.textDef = require_visitor.textDef;
+exports.transform = require_visitor.transform;
+exports.typeDef = require_visitor.typeDef;
+exports.typeLiteralDef = require_visitor.typeLiteralDef;
+exports.walk = require_visitor.walk;
 
 //# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["extractRefName","obj"],"sources":["../src/defineDialect.ts","../src/createPrinter.ts","../src/signature.ts","../src/factory.ts","../src/exports.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 * Creates 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 { createPrinter, type PrinterFactoryOptions } from '@kubb/ast'\n *\n * type PrinterZod = PrinterFactoryOptions<'zod', { strict?: boolean }, string>\n *\n * export const zodPrinter = createPrinter<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 createPrinter<T extends PrinterFactoryOptions = PrinterFactoryOptions>(build: PrinterBuilder<T>): (options?: T['options']) => Printer<T> {\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: SchemaNode): T['output'] | null => {\n        const handler = nodes[node.type]\n        if (!handler) return null\n\n        return (handler as (this: typeof context, node: SchemaNode) => 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: SchemaNode) => T['printOutput'] | null,\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`, `examples`, `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 } from './nodes/index.ts'\n\n// Node constructors, grouped under the `factory` namespace the way the TypeScript compiler exposes\n// `ts.factory.createX`. Aggregating them here lets `export * as factory from './factory.ts'` in the\n// barrel surface every `createX` alongside the `createFile`/`update` helpers from a single module.\nexport { createArrowFunction, createBreak, createConst, createFunction, createJsx, createText, createType } from './nodes/code.ts'\nexport { createContent } from './nodes/content.ts'\nexport { createExport, createFile, createImport, createSource } from './nodes/file.ts'\nexport type { UserFileNode } from './nodes/file.ts'\nexport { createFunctionParameter, createFunctionParameters, createIndexedAccessType, createObjectBindingPattern, createTypeLiteral } from './nodes/function.ts'\nexport { createInput } from './nodes/input.ts'\nexport { createOperation } from './nodes/operation.ts'\nexport { createOutput } from './nodes/output.ts'\nexport { createParameter } from './nodes/parameter.ts'\nexport { createProperty } from './nodes/property.ts'\nexport { createRequestBody } from './nodes/requestBody.ts'\nexport { createResponse } from './nodes/response.ts'\nexport { createSchema } from './nodes/schema.ts'\n\n/**\n * Identity-preserving node update: returns `node` unchanged when every field in\n * `changes` already equals (by reference) the current value, otherwise a new node\n * with the changes applied.\n *\n * Mirrors the TypeScript compiler's `factory.updateX` contract. Pair it with the\n * structural sharing in {@link transform} so a no-op rewrite does not allocate and\n * downstream passes can detect \"nothing changed\" by identity. Comparison is shallow,\n * so a structurally equal but newly allocated array or object counts as a change.\n *\n * @example\n * ```ts\n * update(node, { name: node.name })        // -> same `node` reference\n * update(node, { name: 'renamed' })        // -> new node, `name` replaced\n * ```\n */\nexport function update<T extends Node>(node: T, changes: Partial<T>): T {\n  for (const key in changes) {\n    if (changes[key] !== node[key as keyof T]) {\n      return { ...node, ...changes }\n    }\n  }\n\n  return node\n}\n","export { schemaTypes } from './constants.ts'\nexport { defineDialect } from './defineDialect.ts'\nexport { isHttpOperationNode, narrowSchema } from './guards.ts'\nexport { applyMacros, composeMacros, defineMacro } from './defineMacro.ts'\nexport { defineNode } from './defineNode.ts'\nexport { optionality } from './optionality.ts'\nexport { createPrinter } from './createPrinter.ts'\nexport { signatureOf } from './signature.ts'\nexport { collect, transform, walk } from './visitor.ts'\n\nexport * as factory from './factory.ts'\nexport * from './registry.ts'\nexport type * from './types.ts'\n"],"mappings":"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"}
+{"version":3,"file":"index.cjs","names":[],"sources":["../src/defineDialect.ts","../src/createPrinter.ts","../src/factory.ts","../src/exports.ts"],"sourcesContent":["/**\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 * A spec adapter's dialect. `name` identifies it in logs and diagnostics, and `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 *   },\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 * Creates 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 { createPrinter, type PrinterFactoryOptions } from '@kubb/ast'\n *\n * type PrinterZod = PrinterFactoryOptions<'zod', { strict?: boolean }, string>\n *\n * export const zodPrinter = createPrinter<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 createPrinter<T extends PrinterFactoryOptions = PrinterFactoryOptions>(build: PrinterBuilder<T>): (options?: T['options']) => Printer<T> {\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: SchemaNode): T['output'] | null => {\n        const handler = nodes[node.type]\n        if (!handler) return null\n\n        return (handler as (this: typeof context, node: SchemaNode) => 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: SchemaNode) => T['printOutput'] | null,\n    }\n  }\n}\n","import type { Node } from './nodes/index.ts'\n\n// Node constructors, grouped under the `factory` namespace the way the TypeScript compiler exposes\n// `ts.factory.createX`. Aggregating them here lets `export * as factory from './factory.ts'` in the\n// barrel surface every `createX` alongside the `createFile`/`update` helpers from a single module.\nexport { createArrowFunction, createBreak, createConst, createFunction, createJsx, createText, createType } from './nodes/code.ts'\nexport { createContent } from './nodes/content.ts'\nexport { createExport, createFile, createImport, createSource } from './nodes/file.ts'\nexport type { UserFileNode } from './nodes/file.ts'\nexport { createFunctionParameter, createFunctionParameters, createIndexedAccessType, createObjectBindingPattern, createTypeLiteral } from './nodes/function.ts'\nexport { createInput } from './nodes/input.ts'\nexport { createOperation } from './nodes/operation.ts'\nexport { createOutput } from './nodes/output.ts'\nexport { createParameter } from './nodes/parameter.ts'\nexport { createProperty } from './nodes/property.ts'\nexport { createRequestBody } from './nodes/requestBody.ts'\nexport { createResponse } from './nodes/response.ts'\nexport { createSchema } from './nodes/schema.ts'\n\n/**\n * Identity-preserving node update: returns `node` unchanged when every field in\n * `changes` already equals (by reference) the current value, otherwise a new node\n * with the changes applied.\n *\n * Mirrors the TypeScript compiler's `factory.updateX` contract. Pair it with the\n * structural sharing in {@link transform} so a no-op rewrite does not allocate and\n * downstream passes can detect \"nothing changed\" by identity. Comparison is shallow,\n * so a structurally equal but newly allocated array or object counts as a change.\n *\n * @example\n * ```ts\n * update(node, { name: node.name })        // -> same `node` reference\n * update(node, { name: 'renamed' })        // -> new node, `name` replaced\n * ```\n */\nexport function update<T extends Node>(node: T, changes: Partial<T>): T {\n  for (const key in changes) {\n    if (changes[key] !== node[key as keyof T]) {\n      return { ...node, ...changes }\n    }\n  }\n\n  return node\n}\n","export { schemaTypes } from './constants.ts'\nexport { defineDialect } from './defineDialect.ts'\nexport { isHttpOperationNode, narrowSchema } from './guards.ts'\nexport { applyMacros, composeMacros, defineMacro } from './defineMacro.ts'\nexport { defineNode } from './defineNode.ts'\nexport { optionality } from './optionality.ts'\nexport { createPrinter } from './createPrinter.ts'\nexport { collect, transform, walk } from './visitor.ts'\n\nexport * as factory from './factory.ts'\nexport * from './registry.ts'\nexport type * from './types.ts'\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AA6DA,SAAgB,cACd,SACmD;CACnD,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC2HA,SAAgB,cAAuE,OAAkE;CACvJ,QAAQ,YAAY;EAClB,MAAM,EAAE,MAAM,SAAS,iBAAiB,OAAO,OAAO,kBAAkB,MAAM,WAAY,CAAC,CAAkB;EAE7G,MAAM,UAAU;GACd,SAAS;GACT,YAAY,SAAyC;IACnD,MAAM,UAAU,MAAM,KAAK;IAC3B,IAAI,CAAC,SAAS,OAAO;IAErB,OAAQ,QAA2E,KAAK,SAAS,IAAI;GACvG;EACF;EAEA,OAAO;GACL;GACA,SAAS;GACT,WAAW,QAAQ;GACnB,OAAQ,gBAAgB,cAAc,KAAK,OAAO,IAAI,QAAQ;EAChE;CACF;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC9KA,SAAgB,OAAuB,MAAS,SAAwB;CACtE,KAAK,MAAM,OAAO,SAChB,IAAI,QAAQ,SAAS,KAAK,MACxB,OAAO;EAAE,GAAG;EAAM,GAAG;CAAQ;CAIjC,OAAO;AACT"}