@kubb/ast 5.0.0-beta.103 → 5.0.0-beta.104

package/dist/index.cjs

@@ -1207,7 +1207,7 @@ function chain({ macros, key, node, context }) {
 	for (const macro of macros) {
 		const callback = macro[key];
 		if (!callback) continue;
-		if (macro.when && !macro.when(current)) continue;
+		if (macro.match && !macro.match(current)) continue;
 		const next = callback(current, context);
 		if (next != null) current = next;
 	}
@@ -1394,6 +1394,36 @@ function collectReferencedSchemaNames(node, out = /* @__PURE__ */ new Set()) {
 	for (const name of collectSchemaRefs(node)) out.add(name);
 	return out;
 }
+/**
+* Collects the de-duplicated target names of every pointer-carrying ref in a node's subtree, in
+* first-occurrence order. The walk is memoized by node identity, so the subtree is scanned once and
+* `resolver.imports` reads the same result across the ts, zod, and faker plugins instead of
+* re-scanning the same schema per plugin.
+*
+* 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. This is the ordered, import-facing counterpart to
+* {@link collectReferencedSchemaNames}, which returns an unordered set for graph analysis.
+*
+* @example
+* ```ts
+* collectImportedRefNames(petSchema)
+* // ['Category', 'Tag']
+* ```
+*/
+const collectImportedRefNames = memoize(/* @__PURE__ */ new WeakMap(), (node) => {
+	const seen = /* @__PURE__ */ new Set();
+	const names = [];
+	collectSync(node, { schema(child) {
+		if (child.type !== "ref" || !child.ref) return;
+		const name = resolveRefName(child);
+		if (name && !seen.has(name)) {
+			seen.add(name);
+			names.push(name);
+		}
+	} });
+	return names;
+});
 function computeUsedSchemaNames(operations, schemas) {
 	const schemaMap = /* @__PURE__ */ new Map();
 	for (const schema of schemas) if (schema.name) schemaMap.set(schema.name, schema);
@@ -1436,12 +1466,24 @@ function collectUsedSchemaNames(operations, schemas) {
 	return computeUsedSchemaNames(operations, schemas);
 }
 const EMPTY_CIRCULAR_SET = /* @__PURE__ */ new Set();
-const findCircularSchemasMemo = memoize(/* @__PURE__ */ new WeakMap(), (schemas) => {
-	const graph = /* @__PURE__ */ new Map();
-	for (const schema of schemas) {
-		if (!schema.name) continue;
-		graph.set(schema.name, collectReferencedSchemaNames(schema));
-	}
+/**
+* Finds every schema that takes part in a circular dependency chain in a schema dependency graph
+* that maps each schema name to the names it references directly.
+*
+* Use this when the graph was already collected during another pass (e.g. the adapter's convert
+* walk), so the schema nodes are not swept a second time. `findCircularSchemas` builds the graph
+* from schema nodes and delegates here.
+*
+* @example
+* ```ts
+* const graph = new Map([
+*   ['Pet', new Set(['Category'])],
+*   ['Category', new Set(['Pet'])],
+* ])
+* findCircularSchemasFromGraph(graph) // Set { 'Pet', 'Category' }
+* ```
+*/
+function findCircularSchemasFromGraph(graph) {
 	const circular = /* @__PURE__ */ new Set();
 	for (const start of graph.keys()) {
 		const visited = /* @__PURE__ */ new Set();
@@ -1459,6 +1501,14 @@ const findCircularSchemasMemo = memoize(/* @__PURE__ */ new WeakMap(), (schemas)
 		}
 	}
 	return circular;
+}
+const findCircularSchemasMemo = memoize(/* @__PURE__ */ new WeakMap(), (schemas) => {
+	const graph = /* @__PURE__ */ new Map();
+	for (const schema of schemas) {
+		if (!schema.name) continue;
+		graph.set(schema.name, collectReferencedSchemaNames(schema));
+	}
+	return findCircularSchemasFromGraph(graph);
 });
 /**
 * Finds every schema that takes part in a circular dependency chain, including direct self-loops.
@@ -1528,6 +1578,7 @@ var exports_exports = /* @__PURE__ */ __exportAll({
 	arrowFunctionDef: () => arrowFunctionDef,
 	breakDef: () => breakDef,
 	collect: () => collect,
+	collectImportedRefNames: () => collectImportedRefNames,
 	collectSync: () => collectSync,
 	collectUsedSchemaNames: () => collectUsedSchemaNames,
 	combineExports: () => combineExports,
@@ -1544,6 +1595,7 @@ var exports_exports = /* @__PURE__ */ __exportAll({
 	factory: () => factory_exports,
 	fileDef: () => fileDef,
 	findCircularSchemas: () => findCircularSchemas,
+	findCircularSchemasFromGraph: () => findCircularSchemasFromGraph,
 	functionDef: () => functionDef,
 	importDef: () => importDef,
 	inputDef: () => inputDef,
@@ -1577,6 +1629,7 @@ Object.defineProperty(exports, "ast", {
 });
 exports.breakDef = breakDef;
 exports.collect = collect;
+exports.collectImportedRefNames = collectImportedRefNames;
 exports.collectSync = collectSync;
 exports.collectUsedSchemaNames = collectUsedSchemaNames;
 exports.combineExports = combineExports;
@@ -1598,6 +1651,7 @@ Object.defineProperty(exports, "factory", {
 });
 exports.fileDef = fileDef;
 exports.findCircularSchemas = findCircularSchemas;
+exports.findCircularSchemasFromGraph = findCircularSchemasFromGraph;
 exports.functionDef = functionDef;
 exports.importDef = importDef;
 exports.inputDef = inputDef;