@kubb/ast 5.18.0 → 5.18.2

package/dist/index.cjs

@@ -222,6 +222,15 @@ const VISITOR_KEYS = {
 	Property: ["schema"],
 	Parameter: ["schema"]
 };
+/**
+* Schema fields that hold checks rather than shape: the `conditionals` entries, `contains` and a string's `content`.
+* `transform` and `collect` skip them, and `visitChildNodes` walks them with `checks: true`.
+*/
+const schemaCheckKeys = [
+	"conditionals",
+	"contains",
+	"content"
+];
 /** Visitor callback names in traversal order, the keys of {@link Visitor}. */
 const visitorKeys = [
 	"input",
@@ -272,28 +281,35 @@ function getChildren(node, recurse) {
 	});
 	return children;
 }
-/** Calls `visit` for each direct child node and stops at the first call that returns `true`. */
-function visitChildNodes(node, visit) {
-	const keys = VISITOR_KEYS[node.kind];
+/**
+* Calls `visit` for each direct child node and stops at the first call that returns `true`.
+* With `checks: true`, a schema's {@link schemaCheckKeys} fields are walked too.
+*/
+function visitChildNodes(node, visit, { checks = false } = {}) {
+	const keys = checks && node.kind === nodeKinds.schema ? [...VISITOR_KEYS[node.kind] ?? [], ...schemaCheckKeys] : VISITOR_KEYS[node.kind];
 	if (!keys) return false;
 	const record = node;
 	const seen = /* @__PURE__ */ new Set();
 	const visitOnce = (child) => !seen.has(child) && (seen.add(child), visit(child));
+	const visitRecord = (value) => {
+		for (const name in value) {
+			if (!Object.hasOwn(value, name)) continue;
+			const item = value[name];
+			if (isNode(item) && visitOnce(item)) return true;
+		}
+		return false;
+	};
 	for (const key of keys) {
 		const value = record[key];
 		if (Array.isArray(value)) {
-			for (const item of value) if (isNode(item) && visitOnce(item)) return true;
+			for (const item of value) if (isNode(item) ? visitOnce(item) : isNodeRecord(item) && visitRecord(item)) return true;
 			continue;
 		}
 		if (isNode(value)) {
 			if (visitOnce(value)) return true;
 			continue;
 		}
-		if (isNodeRecord(value)) for (const name in value) {
-			if (!Object.hasOwn(value, name)) continue;
-			const item = value[name];
-			if (isNode(item) && visitOnce(item)) return true;
-		}
+		if (isNodeRecord(value) && visitRecord(value)) return true;
 	}
 	return false;
 }
@@ -1202,23 +1218,33 @@ function memo(store, key, compute) {
 	return value;
 }
 // src/utils/schemaGraph.ts
-/**
-* Walks a node's subtree once and lists every ref it holds, in traversal order, as the resolved
-* name plus whether the ref carries a `$ref` pointer. Memoized by node identity, so
-* `collectSchemaRefs` and `collectImportedRefNames` share one scan per schema.
-*/
 const refEntries = /* @__PURE__ */ new WeakMap();
+const checkRefEntries = /* @__PURE__ */ new WeakMap();
 const schemaRefs = /* @__PURE__ */ new WeakMap();
 const importedRefNames = /* @__PURE__ */ new WeakMap();
-function collectRefEntries(node) {
-	return memo(refEntries, node, () => collectSync(node, { schema(child) {
-		if (child.type !== "ref") return void 0;
-		const name = resolveRefName(child);
-		return name ? {
-			name,
-			hasPointer: Boolean(child.ref)
-		} : void 0;
-	} }));
+const importedCheckRefNames = /* @__PURE__ */ new WeakMap();
+/**
+* Walks a node's subtree once and lists every ref it holds, in traversal order, as the resolved
+* name plus whether the ref carries a `$ref` pointer. Memoized per node and per `checks` mode, so
+* each helper below scans a schema once.
+*/
+function collectRefEntries(node, { checks }) {
+	return memo(checks ? checkRefEntries : refEntries, node, () => {
+		const entries = [];
+		const walk = (current) => {
+			if (current.kind === nodeKinds.schema && current.type === "ref") {
+				const name = resolveRefName(current);
+				if (name) entries.push({
+					name,
+					hasPointer: Boolean(current.ref)
+				});
+			}
+			visitChildNodes(current, walk, { checks });
+			return false;
+		};
+		walk(node);
+		return entries;
+	});
 }
 /**
 * Collects the names of every schema a node's subtree references, resolved with `resolveRefName`.
@@ -1232,7 +1258,7 @@ function collectRefEntries(node) {
 * ```
 */
 function collectSchemaRefs(node) {
-	return memo(schemaRefs, node, () => new Set(collectRefEntries(node).map((entry) => entry.name)));
+	return memo(schemaRefs, node, () => new Set(collectRefEntries(node, { checks: true }).map((entry) => entry.name)));
 }
 /**
 * Collects the de-duplicated target names of every pointer-carrying ref in a node's subtree, in
@@ -1241,7 +1267,8 @@ function collectSchemaRefs(node) {
 *
 * Only refs that carry a `$ref` pointer count, so a synthesized ref pointing at a sibling in the
 * same file (a union member created by name) is left out. That leaves exactly the set
-* `resolver.imports` emits.
+* `resolver.imports` emits. Refs inside `conditionals`, `contains` and `content` count only with
+* `checks: true`, for a plugin that prints those checks.
 *
 * @example
 * ```ts
@@ -1249,8 +1276,8 @@ function collectSchemaRefs(node) {
 * // ['Category', 'Tag']
 * ```
 */
-function collectImportedRefNames(node) {
-	return memo(importedRefNames, node, () => [...new Set(collectRefEntries(node).flatMap((entry) => entry.hasPointer ? [entry.name] : []))]);
+function collectImportedRefNames(node, { checks = false } = {}) {
+	return memo(checks ? importedCheckRefNames : importedRefNames, node, () => [...new Set(collectRefEntries(node, { checks }).flatMap((entry) => entry.hasPointer ? [entry.name] : []))]);
 }
 /**
 * Collects the names of all top-level schemas transitively used by a set of operations.