@kubb/ast 5.0.0-beta.1 → 5.0.0-beta.2

package/dist/index.cjs

@@ -1193,7 +1193,7 @@ function combineImports(imports, exports, source) {
 		const { path, isTypeOnly } = curr;
 		let { name } = curr;
 		if (Array.isArray(name)) {
-			name = [...new Set(name)].filter((item) => typeof item === "string" ? isUsed(item) : isUsed(item.propertyName));
+			name = [...new Set(name)].filter((item) => typeof item === "string" ? isUsed(item) : isUsed(item.name ?? item.propertyName));
 			if (!name.length) continue;
 			const key = pathTypeKey(path, isTypeOnly);
 			const existing = namedByPath.get(key);
@@ -1266,7 +1266,19 @@ function resolveRefName(node) {
 * Refs are followed by name only — the resolved `node.schema` is not traversed inline.
 * Use this to determine schema dependencies, build reference graphs, or detect what schemas need to be emitted.
 *
-* @note Returns a Set of schema names for efficient membership testing.
+* @example Collect refs from a single schema
+* ```ts
+* const names = collectReferencedSchemaNames(petSchema)
+* // → Set { 'Category', 'Tag' }
+* ```
+*
+* @example Accumulate refs from multiple schemas into one set
+* ```ts
+* const out = new Set<string>()
+* for (const schema of schemas) {
+*   collectReferencedSchemaNames(schema, out)
+* }
+* ```
 */
 function collectReferencedSchemaNames(node, out = /* @__PURE__ */ new Set()) {
 	if (!node) return out;
@@ -1279,6 +1291,52 @@ function collectReferencedSchemaNames(node, out = /* @__PURE__ */ new Set()) {
 	return out;
 }
 /**
+* Collects the names of all top-level schemas transitively used by a set of operations.
+*
+* An operation uses a schema when any of its parameters, request body content, or responses
+* reference it — directly or indirectly through other named schemas.
+* The walk is iterative and safe against reference cycles.
+*
+* Use this together with `include` filters to determine which schemas from `components/schemas`
+* are reachable from the allowed operations, so that schemas used only by excluded operations
+* are not generated.
+*
+* @example Only generate schemas referenced by included operations
+* ```ts
+* const includedOps = inputNode.operations.filter(op => resolver.resolveOptions(op, { options, include }) !== null)
+* const allowed = collectUsedSchemaNames(includedOps, inputNode.schemas)
+*
+* for (const schema of inputNode.schemas) {
+*   if (schema.name && !allowed.has(schema.name)) continue
+*   // … generate schema
+* }
+* ```
+*
+* @example Check whether a specific schema is needed
+* ```ts
+* const allowed = collectUsedSchemaNames(includedOps, inputNode.schemas)
+* allowed.has('OrderStatus') // false when no included operation references OrderStatus
+* ```
+*/
+function collectUsedSchemaNames(operations, schemas) {
+	const schemaMap = /* @__PURE__ */ new Map();
+	for (const schema of schemas) if (schema.name) schemaMap.set(schema.name, schema);
+	const result = /* @__PURE__ */ new Set();
+	function visitSchema(schema) {
+		const directRefs = collectReferencedSchemaNames(schema);
+		for (const name of directRefs) if (!result.has(name)) {
+			result.add(name);
+			const namedSchema = schemaMap.get(name);
+			if (namedSchema) visitSchema(namedSchema);
+		}
+	}
+	for (const op of operations) for (const schema of collect(op, {
+		depth: "shallow",
+		schema: (node) => node
+	})) visitSchema(schema);
+	return result;
+}
+/**
 * Identifies all schemas that participate in circular dependency chains, including direct self-loops.
 *
 * Returns a Set of schema names with circular dependencies. Use this to wrap recursive schema positions
@@ -2161,6 +2219,7 @@ exports.childName = childName;
 exports.collect = collect;
 exports.collectImports = collectImports;
 exports.collectReferencedSchemaNames = collectReferencedSchemaNames;
+exports.collectUsedSchemaNames = collectUsedSchemaNames;
 exports.containsCircularRef = containsCircularRef;
 exports.createArrowFunction = createArrowFunction;
 exports.createBreak = createBreak;