@kubb/ast 5.0.0-beta.75 → 5.0.0-beta.8

package/README.md

@@ -128,7 +128,7 @@ const pet = resolveRef(refMap, 'Pet')
 
 ## Supporting Kubb
 
-Kubb uses an MIT-licensed open source project with its ongoing development made possible entirely by the support of Sponsors. If you would like to become a sponsor, please consider:
+Kubb is an MIT-licensed open source project with its ongoing development made possible entirely by the support of Sponsors. If you would like to become a sponsor, please consider:
 
 - [Become a Sponsor on GitHub](https://github.com/sponsors/stijnvanhulle)
 

package/dist/index.cjs

@@ -468,12 +468,6 @@ const isOperationNode = isKind("Operation");
 * ```
 */
 const isSchemaNode = isKind("Schema");
-isKind("Property");
-isKind("Parameter");
-isKind("Response");
-isKind("FunctionParameter");
-isKind("ParameterGroup");
-isKind("FunctionParameters");
 //#endregion
 //#region src/refs.ts
 /**
@@ -1180,6 +1174,13 @@ function combineExports(exports) {
 function combineImports(imports, exports, source) {
 	const exportedNames = new Set(exports.flatMap((e) => Array.isArray(e.name) ? e.name : e.name ? [e.name] : []));
 	const isUsed = (importName) => !source || source.includes(importName) || exportedNames.has(importName);
+	const importNameMemo = /* @__PURE__ */ new Map();
+	const canonicalizeName = (n) => {
+		if (typeof n === "string") return n;
+		const key = `${n.propertyName}:${n.name ?? ""}`;
+		if (!importNameMemo.has(key)) importNameMemo.set(key, n);
+		return importNameMemo.get(key);
+	};
 	const result = [];
 	const namedByPath = /* @__PURE__ */ new Map();
 	const seen = /* @__PURE__ */ new Set();
@@ -1193,7 +1194,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.map(canonicalizeName))].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 +1267,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 +1292,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 +2220,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;