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

package/README.md

@@ -120,10 +120,9 @@ function process(node: Node) {
 ### Refs
 
 ```ts
-import { buildRefMap, resolveRef } from '@kubb/ast'
+import { extractRefName } from '@kubb/ast'
 
-const refMap = buildRefMap(root)
-const pet = resolveRef(refMap, 'Pet')
+extractRefName('#/components/schemas/Pet') // 'Pet'
 ```
 
 ## Supporting Kubb

package/dist/index.cjs

@@ -29,25 +29,6 @@ const visitorDepths = {
 	shallow: "shallow",
 	deep: "deep"
 };
-const nodeKinds = {
-	input: "Input",
-	output: "Output",
-	operation: "Operation",
-	schema: "Schema",
-	property: "Property",
-	parameter: "Parameter",
-	response: "Response",
-	functionParameter: "FunctionParameter",
-	parameterGroup: "ParameterGroup",
-	functionParameters: "FunctionParameters",
-	type: "Type",
-	file: "File",
-	import: "Import",
-	export: "Export",
-	source: "Source",
-	text: "Text",
-	break: "Break"
-};
 /**
 * Schema type discriminators used by all AST schema nodes.
 *
@@ -196,33 +177,6 @@ const httpMethods = {
 	options: "OPTIONS",
 	trace: "TRACE"
 };
-/**
-* Common MIME types used in request/response content negotiation.
-*
-* Covers JSON, XML, form data, PDFs, images, audio, and video formats.
-* Use these as keys when serializing request/response bodies.
-*/
-const mediaTypes = {
-	applicationJson: "application/json",
-	applicationXml: "application/xml",
-	applicationFormUrlEncoded: "application/x-www-form-urlencoded",
-	applicationOctetStream: "application/octet-stream",
-	applicationPdf: "application/pdf",
-	applicationZip: "application/zip",
-	applicationGraphql: "application/graphql",
-	multipartFormData: "multipart/form-data",
-	textPlain: "text/plain",
-	textHtml: "text/html",
-	textCsv: "text/csv",
-	textXml: "text/xml",
-	imagePng: "image/png",
-	imageJpeg: "image/jpeg",
-	imageGif: "image/gif",
-	imageWebp: "image/webp",
-	imageSvgXml: "image/svg+xml",
-	audioMpeg: "audio/mpeg",
-	videoMp4: "video/mp4"
-};
 //#endregion
 //#region ../../internals/utils/src/casing.ts
 /**
@@ -465,28 +419,6 @@ function isKind(kind) {
 	return (node) => node.kind === kind;
 }
 /**
-* Returns `true` when the input is an `InputNode`.
-*
-* @example
-* ```ts
-* if (isInputNode(node)) {
-*   console.log(node.schemas.length)
-* }
-* ```
-*/
-const isInputNode = isKind("Input");
-/**
-* Returns `true` when the input is an `OutputNode`.
-*
-* @example
-* ```ts
-* if (isOutputNode(node)) {
-*   console.log(node.files.length)
-* }
-* ```
-*/
-const isOutputNode = isKind("Output");
-/**
 * Returns `true` when the input is an `OperationNode`.
 *
 * @example
@@ -677,8 +609,9 @@ async function walk(node, options) {
 }
 async function _walk(node, visitor, recurse, limit, parent) {
 	await limit(() => applyVisitor(node, visitor, parent));
-	const children = getChildren(node, recurse);
-	for (const child of children) await _walk(child, visitor, recurse, limit, node);
+	const children = Array.from(getChildren(node, recurse));
+	if (children.length === 0) return;
+	await Promise.all(children.map((child) => _walk(child, visitor, recurse, limit, node)));
 }
 function transform(node, options) {
 	const { depth, parent, ...visitor } = options;
@@ -2097,66 +2030,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"
 		}
-		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}`;
+	],
+	array: arrayTupleFields,
+	tuple: arrayTupleFields,
+	union: [
+		{
+			kind: "scalar",
+			key: "strategy",
+			prefix: "s"
+		},
+		{
+			kind: "scalar",
+			key: "discriminatorPropertyName",
+			prefix: "d"
+		},
+		{
+			kind: "children",
+			key: "members",
+			prefix: "m"
 		}
-		case "union": {
-			const members = (node.members ?? []).map((member) => signatureOf(member, signatures)).join(",");
-			return `union|${flags}|s:${node.strategy ?? ""}|d:${node.discriminatorPropertyName ?? ""}|m[${members}]`;
+	],
+	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 "intersection": return `intersection|${flags}|m[${(node.members ?? []).map((member) => signatureOf(member, signatures)).join(",")}]`;
-		case "enum": {
+		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 (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,18 +2287,7 @@ function signatureOf(node, signatures) {
 * ```
 */
 function schemaSignature(node) {
-	return signatureOf(node, /* @__PURE__ */ new Map());
-}
-/**
-* Returns `true` when two schema nodes are structurally identical under shape-only equality.
-*
-* @example
-* ```ts
-* isSchemaEqual(a, b) // a and b produce the same TypeScript type
-* ```
-*/
-function isSchemaEqual(a, b) {
-	return schemaSignature(a) === schemaSignature(b);
+	return signatureOf(node);
 }
 //#endregion
 //#region src/dedupe.ts
@@ -2211,10 +2312,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 +2352,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);
@@ -2529,9 +2628,6 @@ function* mergeAdjacentObjectsLazy(members) {
 	}
 	if (acc !== void 0) yield acc;
 }
-function mergeAdjacentObjects(members) {
-	return [...mergeAdjacentObjectsLazy(members)];
-}
 /**
 * Removes enum members that are covered by broader scalar primitives in the same union.
 *
@@ -2577,14 +2673,11 @@ exports.caseParams = caseParams;
 exports.childName = childName;
 exports.collect = collect;
 exports.collectImports = collectImports;
-exports.collectLazy = collectLazy;
-exports.collectReferencedSchemaNames = collectReferencedSchemaNames;
 exports.collectUsedSchemaNames = collectUsedSchemaNames;
 exports.containsCircularRef = containsCircularRef;
 exports.createArrowFunction = createArrowFunction;
 exports.createBreak = createBreak;
 exports.createConst = createConst;
-exports.createContent = createContent;
 exports.createDiscriminantNode = createDiscriminantNode;
 exports.createExport = createExport;
 exports.createFile = createFile;
@@ -2602,7 +2695,6 @@ exports.createParameterGroup = createParameterGroup;
 exports.createParamsType = createParamsType;
 exports.createPrinterFactory = createPrinterFactory;
 exports.createProperty = createProperty;
-exports.createRequestBody = createRequestBody;
 exports.createResponse = createResponse;
 exports.createSchema = createSchema;
 exports.createSource = createSource;
@@ -2619,19 +2711,11 @@ exports.findCircularSchemas = findCircularSchemas;
 exports.findDiscriminator = findDiscriminator;
 exports.httpMethods = httpMethods;
 exports.isHttpOperationNode = isHttpOperationNode;
-exports.isInputNode = isInputNode;
 exports.isOperationNode = isOperationNode;
-exports.isOutputNode = isOutputNode;
-exports.isScalarPrimitive = isScalarPrimitive;
-exports.isSchemaEqual = isSchemaEqual;
 exports.isSchemaNode = isSchemaNode;
 exports.isStringType = isStringType;
-exports.mediaTypes = mediaTypes;
-exports.mergeAdjacentObjects = mergeAdjacentObjects;
 exports.mergeAdjacentObjectsLazy = mergeAdjacentObjectsLazy;
 exports.narrowSchema = narrowSchema;
-exports.nodeKinds = nodeKinds;
-exports.resolveRefName = resolveRefName;
 exports.schemaSignature = schemaSignature;
 exports.schemaTypes = schemaTypes;
 exports.setDiscriminatorEnum = setDiscriminatorEnum;