@kubb/ast 5.13.0 → 5.13.1

package/dist/index.cjs

@@ -195,6 +195,7 @@ const VISITOR_KEYS = {
 		"members",
 		"additionalProperties",
 		"patternProperties",
+		"propertyNames",
 		"rest"
 	],
 	Property: ["schema"],
@@ -242,25 +243,101 @@ function isNodeRecord(value) {
 * ```
 */
 function getChildren(node, recurse) {
+	if (node.kind === "Schema" && !recurse) return [];
 	const children = [];
-	const keys = node.kind === "Schema" && !recurse ? void 0 : VISITOR_KEYS[node.kind];
-	if (!keys) return children;
+	visitChildNodes(node, (child) => {
+		children.push(child);
+		return false;
+	});
+	return children;
+}
+/**
+* Visits each direct child node in the AST's traversal order.
+*
+* @example
+* ```ts
+* forEachChild(operationNode, (child) => {
+*   console.log(child.kind)
+* })
+* ```
+*/
+function forEachChild(node, visit) {
+	visitChildNodes(node, (child) => {
+		visit(child);
+		return false;
+	});
+}
+function visitChildNodes(node, visit) {
+	const keys = VISITOR_KEYS[node.kind];
+	if (!keys) return false;
 	const record = node;
 	for (const key of keys) {
 		const value = record[key];
 		if (Array.isArray(value)) {
-			for (const item of value) if (isNode(item)) children.push(item);
+			for (const item of value) if (isNode(item) && visit(item)) return true;
 			continue;
 		}
 		if (isNode(value)) {
-			children.push(value);
+			if (visit(value)) return true;
 			continue;
 		}
-		if (isNodeRecord(value)) {
-			for (const item of Object.values(value)) if (isNode(item)) children.push(item);
+		if (isNodeRecord(value)) for (const name in value) {
+			if (!Object.hasOwn(value, name)) continue;
+			const item = value[name];
+			if (isNode(item) && visit(item)) return true;
 		}
 	}
-	return children;
+	return false;
+}
+/**
+* Visits each schema in a node's child tree in depth-first order. Includes `node` when it is a schema.
+*
+* @example
+* ```ts
+* forEachSchema(operationNode, (schema) => {
+*   console.log(schema.type)
+* })
+* ```
+*/
+function forEachSchema(node, visit) {
+	const walk = (current) => {
+		if (current.kind === "Schema") visit(current);
+		forEachChild(current, walk);
+	};
+	walk(node);
+}
+/**
+* Finds the first schema that matches `predicate` in depth-first order. Set `followRefs` to include resolved ref targets.
+*
+* @example
+* ```ts
+* const firstString = findSchema(operationNode, {
+*   predicate: (schema) => schema.type === 'string',
+* })
+* ```
+*/
+function findSchema(node, { predicate, followRefs = false }) {
+	const seen = followRefs ? /* @__PURE__ */ new WeakSet() : void 0;
+	const walk = (current) => {
+		if (current.kind === "Schema") {
+			if (predicate(current)) return current;
+			if (seen) {
+				if (seen.has(current)) return void 0;
+				seen.add(current);
+				if (current.type === "ref" && current.schema) {
+					const found = walk(current.schema);
+					if (found) return found;
+				}
+			}
+		}
+		let found;
+		visitChildNodes(current, (child) => {
+			found = walk(child);
+			return found !== void 0;
+		});
+		if (found) return found;
+	};
+	return walk(node);
 }
 /**
 * Runs the visitor callback that matches `node.kind` with the traversal
@@ -644,6 +721,25 @@ function resolveRefName(node) {
 	if (node.ref) return refName(node.ref);
 	return node.name ?? node.schema?.name ?? null;
 }
+/**
+* Follows a resolved ref chain to its target schema. Returns an unresolved or cyclic ref as is.
+*
+* @example
+* ```ts
+* const target = resolveRef(refSchema)
+* ```
+*/
+function resolveRef(node) {
+	if (node.type !== "ref" || !node.schema) return node;
+	const seen = /* @__PURE__ */ new WeakSet();
+	let current = node;
+	while (current.type === "ref" && current.schema) {
+		if (seen.has(current)) return current;
+		seen.add(current);
+		current = current.schema;
+	}
+	return current;
+}
 /** Fields of a ref node that describe the ref itself, so they never override the resolved schema. */
 const REF_OWN_KEYS = /* @__PURE__ */ new Set([
 	"kind",
@@ -1538,6 +1634,9 @@ var src_exports = /* @__PURE__ */ __exportAll({
 	factory: () => nodes_exports,
 	findCircularSchemas: () => findCircularSchemas,
 	findCircularSchemasFromGraph: () => findCircularSchemasFromGraph,
+	findSchema: () => findSchema,
+	forEachChild: () => forEachChild,
+	forEachSchema: () => forEachSchema,
 	getSchemaLiteralValues: () => getSchemaLiteralValues,
 	inferDiscriminatorPropertyName: () => inferDiscriminatorPropertyName,
 	isBareRef: () => isBareRef,
@@ -1546,6 +1645,7 @@ var src_exports = /* @__PURE__ */ __exportAll({
 	narrowSchema: () => narrowSchema,
 	optionality: () => optionality,
 	refName: () => refName,
+	resolveRef: () => resolveRef,
 	resolveRefName: () => resolveRefName,
 	resolveSchemaProperties: () => resolveSchemaProperties,
 	schemaTypes: () => schemaTypes,
@@ -1576,6 +1676,9 @@ Object.defineProperty(exports, "factory", {
 });
 exports.findCircularSchemas = findCircularSchemas;
 exports.findCircularSchemasFromGraph = findCircularSchemasFromGraph;
+exports.findSchema = findSchema;
+exports.forEachChild = forEachChild;
+exports.forEachSchema = forEachSchema;
 exports.getSchemaLiteralValues = getSchemaLiteralValues;
 exports.inferDiscriminatorPropertyName = inferDiscriminatorPropertyName;
 exports.isBareRef = isBareRef;
@@ -1584,6 +1687,7 @@ exports.mergeRefWithSchema = mergeRefWithSchema;
 exports.narrowSchema = narrowSchema;
 exports.optionality = optionality;
 exports.refName = refName;
+exports.resolveRef = resolveRef;
 exports.resolveRefName = resolveRefName;
 exports.resolveSchemaProperties = resolveSchemaProperties;
 exports.schemaTypes = schemaTypes;