@kubb/ast 5.12.8 → 5.13.1

package/dist/index.cjs

@@ -195,6 +195,7 @@ const VISITOR_KEYS = {
 		"members",
 		"additionalProperties",
 		"patternProperties",
+		"propertyNames",
 		"rest"
 	],
 	Property: ["schema"],
@@ -241,24 +242,102 @@ function isNodeRecord(value) {
 * // returns parameters, the request body, and responses
 * ```
 */
-function* getChildren(node, recurse) {
-	const keys = node.kind === "Schema" && !recurse ? void 0 : VISITOR_KEYS[node.kind];
-	if (!keys) return;
+function getChildren(node, recurse) {
+	if (node.kind === "Schema" && !recurse) return [];
+	const 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)) yield item;
+			for (const item of value) if (isNode(item) && visit(item)) return true;
 			continue;
 		}
 		if (isNode(value)) {
-			yield value;
+			if (visit(value)) return true;
 			continue;
 		}
-		if (isNodeRecord(value)) {
-			for (const item of Object.values(value)) if (isNode(item)) yield 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 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
@@ -395,7 +474,15 @@ function* collectNode(node, visitor, recurse, parent) {
 * ```
 */
 function collectSync(node, options) {
-	return Array.from(collect(node, options));
+	const { depth, parent, ...visitor } = options;
+	const result = [];
+	collectInto(node, visitor, (depth ?? "deep") === "deep", parent, result);
+	return result;
+}
+function collectInto(node, visitor, recurse, parent, result) {
+	const v = applyVisitor(node, visitor, parent);
+	if (v != null) result.push(v);
+	for (const child of getChildren(node, recurse)) collectInto(child, visitor, recurse, node, result);
 }
 //#endregion
 //#region src/defineMacro.ts
@@ -635,6 +722,33 @@ function resolveRefName(node) {
 	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",
+	"type",
+	"name",
+	"ref",
+	"schema"
+]);
+/**
 * Merges a ref node with its resolved schema, giving the fields set at the usage site precedence.
 *
 * Every field on the ref except `kind`, `type`, `name`, `ref`, and `schema` overrides the same field
@@ -650,12 +764,12 @@ function resolveRefName(node) {
 */
 function mergeRefWithSchema(node) {
 	if (!node.schema) return node;
-	const { kind: _kind, type: _type, name: _name, ref: _ref, schema: _schema, ...overrides } = node;
-	const definedOverrides = Object.fromEntries(Object.entries(overrides).filter(([, value]) => value !== void 0));
-	return {
-		...node.schema,
-		...definedOverrides
-	};
+	const merged = { ...node.schema };
+	for (const key of Object.keys(node)) {
+		const value = node[key];
+		if (value !== void 0 && !REF_OWN_KEYS.has(key)) merged[key] = value;
+	}
+	return merged;
 }
 /**
 * Returns `true` when a schema is a bare ref without modifiers, metadata, or omit keys.
@@ -1109,16 +1223,23 @@ function mergeByPath(result) {
 	return ({ node, names }) => {
 		const key = `${node.path}:${node.isTypeOnly ?? false}`;
 		const existing = byPath.get(key);
-		if (existing && Array.isArray(existing.name)) {
-			existing.name = [.../* @__PURE__ */ new Set([...existing.name, ...names])];
+		if (existing) {
+			for (const name of names) {
+				if (existing.seen.has(name)) continue;
+				existing.seen.add(name);
+				existing.names.push(name);
+			}
 			return;
 		}
 		const item = {
 			...node,
-			name: names
+			name: [...names]
 		};
 		result.push(item);
-		byPath.set(key, item);
+		byPath.set(key, {
+			names: item.name,
+			seen: new Set(names)
+		});
 	};
 }
 /**
@@ -1513,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,
@@ -1521,6 +1645,7 @@ var src_exports = /* @__PURE__ */ __exportAll({
 	narrowSchema: () => narrowSchema,
 	optionality: () => optionality,
 	refName: () => refName,
+	resolveRef: () => resolveRef,
 	resolveRefName: () => resolveRefName,
 	resolveSchemaProperties: () => resolveSchemaProperties,
 	schemaTypes: () => schemaTypes,
@@ -1551,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;
@@ -1559,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;