@kubb/ast 5.0.0-beta.31 → 5.0.0-beta.32

package/dist/index.cjs

@@ -2097,66 +2097,245 @@ function refTargetName(node) {
 	if (node.ref) return extractRefName(node.ref);
 	return node.name ?? "";
 }
-/**
-* Builds the local, shape-only descriptor for a node: its kind, flags, constraints, and its
-* children's signatures. {@link signatureOf} hashes this string; children contribute their
-* fixed-length signature rather than their own full descriptor, which keeps the result bounded.
-*/
-function describeShape(node, signatures) {
-	const flags = flagsDescriptor(node);
-	switch (node.type) {
-		case "object": {
-			const props = (node.properties ?? []).map((prop) => `${prop.name}${prop.required ? "!" : "?"}${signatureOf(prop.schema, signatures)}`).join(",");
-			let additional = "";
-			if (typeof node.additionalProperties === "boolean") additional = `ab:${node.additionalProperties}`;
-			else if (node.additionalProperties) additional = `as:${signatureOf(node.additionalProperties, signatures)}`;
-			const pattern = node.patternProperties ? Object.keys(node.patternProperties).sort().map((key) => `${key}=${signatureOf(node.patternProperties[key], signatures)}`).join(",") : "";
-			return `object|${flags}|p[${props}]|${additional}|pp[${pattern}]|mn:${node.minProperties ?? ""}|mx:${node.maxProperties ?? ""}`;
+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 schema node `type` to the ordered list of shape-contributing fields.
+* Node types absent from this map (scalar types like boolean, null, any, etc.) fall
+* back to `${type}|${flags}` with no additional fields.
+*/
+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"
 		}
-		case "array":
-		case "tuple": {
-			const items = (node.items ?? []).map((item) => signatureOf(item, signatures)).join(",");
-			const rest = node.rest ? signatureOf(node.rest, signatures) : "";
-			return `${node.type}|${flags}|i[${items}]|r:${rest}|mn:${node.min ?? ""}|mx:${node.max ?? ""}|u:${node.unique ? 1 : 0}`;
+	],
+	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 "union": {
-			const members = (node.members ?? []).map((member) => signatureOf(member, signatures)).join(",");
-			return `union|${flags}|s:${node.strategy ?? ""}|d:${node.discriminatorPropertyName ?? ""}|m[${members}]`;
+		case "children": {
+			const children = record[field.key] ?? [];
+			return `${field.prefix}[${children.map((c) => signatureOf(c)).join(",")}]`;
 		}
-		case "intersection": return `intersection|${flags}|m[${(node.members ?? []).map((member) => signatureOf(member, signatures)).join(",")}]`;
-		case "enum": {
+		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 (node.namedEnumValues?.length) values = node.namedEnumValues.map((entry) => `${entry.name}=${entry.primitive}:${String(entry.value)}`).join(",");
-			else if (node.enumValues?.length) values = node.enumValues.map((value) => `${value === null ? "null" : typeof value}:${String(value)}`).join(",");
-			return `enum|${flags}|v[${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 "ref": return `ref|${flags}|->${refTargetName(node)}`;
-		case "string": return `string|${flags}|mn:${node.min ?? ""}|mx:${node.max ?? ""}|pt:${node.pattern ?? ""}`;
-		case "number":
-		case "integer":
-		case "bigint": return `${node.type}|${flags}|mn:${node.min ?? ""}|mx:${node.max ?? ""}|emn:${node.exclusiveMinimum ?? ""}|emx:${node.exclusiveMaximum ?? ""}|mo:${node.multipleOf ?? ""}`;
-		case "url": return `url|${flags}|path:${node.path ?? ""}|mn:${node.min ?? ""}|mx:${node.max ?? ""}`;
-		case "uuid":
-		case "email": return `${node.type}|${flags}|mn:${node.min ?? ""}|mx:${node.max ?? ""}`;
-		case "datetime": return `datetime|${flags}|o:${node.offset ? 1 : 0}|l:${node.local ? 1 : 0}`;
-		case "date":
-		case "time": return `${node.type}|${flags}|rep:${node.representation}`;
-		default: return `${node.type}|${flags}`;
+		case "refTarget": return `->${refTargetName(node)}`;
 	}
 }
 /**
+* Builds the local, shape-only descriptor for a node: its kind, flags, constraints, and its
+* children's signatures. {@link signatureOf} hashes this string; children contribute their
+* fixed-length signature rather than their own full descriptor, which keeps the result bounded.
+*/
+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("|");
+}
+/**
+* Persistent hash-consing cache: `SchemaNode` → signature digest, keyed by node identity.
+*
+* A `WeakMap` so entries are released once the node is garbage-collected, and so a node hashed
+* during dedupe planning is not re-hashed when the same tree is rewritten during streaming
+* (where `schemaSignature` and `applyDedupe` would otherwise each walk it from scratch). Reuse
+* across calls is sound because a signature depends only on a node's content, and schema nodes
+* are immutable once created — transforms allocate new objects rather than mutating in place.
+*/
+const signatureCache = /* @__PURE__ */ new WeakMap();
+/**
 * Hash-consing: each node's signature is a fixed-length digest of its local shape plus its
 * children's digests (a Merkle hash). Children contribute their 64-char hash instead of their
 * full nested descriptor, so a signature stays bounded regardless of subtree depth, and the
 * digest is identical across calls because it depends only on content — never on traversal
 * order. This keeps the keys built during planning consistent with the ones recomputed later
-* during streaming. `signatures` memoizes node → digest within a single computation.
+* during streaming. {@link signatureCache} memoizes node → digest across every computation.
 */
-function signatureOf(node, signatures) {
-	const cached = signatures.get(node);
+function signatureOf(node) {
+	const cached = signatureCache.get(node);
 	if (cached !== void 0) return cached;
-	const signature = (0, node_crypto.createHash)("sha256").update(describeShape(node, signatures)).digest("hex");
-	signatures.set(node, signature);
+	const signature = (0, node_crypto.createHash)("sha256").update(describeShape(node)).digest("hex");
+	signatureCache.set(node, signature);
 	return signature;
 }
 /**
@@ -2175,7 +2354,7 @@ function signatureOf(node, signatures) {
 * ```
 */
 function schemaSignature(node) {
-	return signatureOf(node, /* @__PURE__ */ new Map());
+	return signatureOf(node);
 }
 /**
 * Returns `true` when two schema nodes are structurally identical under shape-only equality.
@@ -2211,10 +2390,9 @@ function createRefNode(node, canonical) {
 }
 function applyDedupe(node, canonicalBySignature, skipRootMatch = false) {
 	if (canonicalBySignature.size === 0) return node;
-	const signatures = /* @__PURE__ */ new Map();
 	const root = node;
 	return transform(node, { schema(schemaNode) {
-		const signature = signatureOf(schemaNode, signatures);
+		const signature = signatureOf(schemaNode);
 		if (skipRootMatch && schemaNode === root) return void 0;
 		const canonical = canonicalBySignature.get(signature);
 		if (!canonical) return void 0;
@@ -2252,11 +2430,10 @@ function cleanDefinition(node, name) {
 */
 function buildDedupePlan(roots, options) {
 	const { isCandidate, nameFor, refFor, minOccurrences = 2 } = options;
-	const signatures = /* @__PURE__ */ new Map();
 	const topLevelNodes = /* @__PURE__ */ new Set();
 	const groups = /* @__PURE__ */ new Map();
 	function record(schemaNode) {
-		const signature = signatureOf(schemaNode, signatures);
+		const signature = signatureOf(schemaNode);
 		if (!isCandidate(schemaNode)) return;
 		const isTopLevel = topLevelNodes.has(schemaNode) && !!schemaNode.name;
 		const group = groups.get(signature);