@kubb/ast 5.0.0-beta.18 → 5.0.0-beta.19

package/dist/index.d.ts

@@ -3229,13 +3229,6 @@ declare function syncSchemaRef(node: SchemaNode): SchemaNode;
  * types, returns `true` only when `representation` is `'string'` rather than `'date'`.
  */
 declare function isStringType(node: SchemaNode): boolean;
-/**
- * Applies casing rules to parameter names and returns a new parameter array.
- *
- * Use this before passing parameters to schema builders so output property keys match
- * the desired casing while preserving `OperationNode.parameters` for other consumers.
- * The input array is not mutated. When `casing` is not set, the original array is returned unchanged.
- */
 declare function caseParams(params: Array<ParameterNode>, casing: 'camelcase' | undefined): Array<ParameterNode>;
 /**
  * Creates a single-property object schema used as a discriminator literal.
@@ -3407,34 +3400,6 @@ declare function extractStringsFromNodes(nodes: Array<CodeNode> | undefined): st
  */
 declare function resolveRefName(node: SchemaNode | undefined): string | undefined;
 declare function collectReferencedSchemaNames(node: SchemaNode | undefined, out?: Set<string>): Set<string>;
-/**
- * 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
- * ```
- */
 declare function collectUsedSchemaNames(operations: ReadonlyArray<OperationNode>, schemas: ReadonlyArray<SchemaNode>): Set<string>;
 /**
  * Identifies all schemas that participate in circular dependency chains, including direct self-loops.

package/dist/index.js

@@ -600,9 +600,7 @@ function transform(node, options) {
 	const recurse = (depth ?? visitorDepths.deep) === visitorDepths.deep;
 	switch (node.kind) {
 		case "Input": {
-			let input = node;
-			const replaced = visitor.input?.(input, { parent });
-			if (replaced) input = replaced;
+			const input = visitor.input?.(node, { parent }) ?? node;
 			return {
 				...input,
 				schemas: input.schemas.map((s) => transform(s, {
@@ -615,16 +613,9 @@ function transform(node, options) {
 				}))
 			};
 		}
-		case "Output": {
-			let output = node;
-			const replaced = visitor.output?.(output, { parent });
-			if (replaced) output = replaced;
-			return output;
-		}
+		case "Output": return visitor.output?.(node, { parent }) ?? node;
 		case "Operation": {
-			let op = node;
-			const replaced = visitor.operation?.(op, { parent });
-			if (replaced) op = replaced;
+			const op = visitor.operation?.(node, { parent }) ?? node;
 			return {
 				...op,
 				parameters: op.parameters.map((p) => transform(p, {
@@ -648,9 +639,7 @@ function transform(node, options) {
 			};
 		}
 		case "Schema": {
-			let schema = node;
-			const replaced = visitor.schema?.(schema, { parent });
-			if (replaced) schema = replaced;
+			const schema = visitor.schema?.(node, { parent }) ?? node;
 			const childOptions = {
 				...options,
 				parent: schema
@@ -664,9 +653,7 @@ function transform(node, options) {
 			};
 		}
 		case "Property": {
-			let prop = node;
-			const replaced = visitor.property?.(prop, { parent });
-			if (replaced) prop = replaced;
+			const prop = visitor.property?.(node, { parent }) ?? node;
 			return createProperty({
 				...prop,
 				schema: transform(prop.schema, {
@@ -676,9 +663,7 @@ function transform(node, options) {
 			});
 		}
 		case "Parameter": {
-			let param = node;
-			const replaced = visitor.parameter?.(param, { parent });
-			if (replaced) param = replaced;
+			const param = visitor.parameter?.(node, { parent }) ?? node;
 			return createParameter({
 				...param,
 				schema: transform(param.schema, {
@@ -688,9 +673,7 @@ function transform(node, options) {
 			});
 		}
 		case "Response": {
-			let response = node;
-			const replaced = visitor.response?.(response, { parent });
-			if (replaced) response = replaced;
+			const response = visitor.response?.(node, { parent }) ?? node;
 			return {
 				...response,
 				schema: transform(response.schema, {
@@ -817,15 +800,25 @@ function isStringType(node) {
 * the desired casing while preserving `OperationNode.parameters` for other consumers.
 * The input array is not mutated. When `casing` is not set, the original array is returned unchanged.
 */
+const caseParamsCache = /* @__PURE__ */ new WeakMap();
 function caseParams(params, casing) {
 	if (!casing) return params;
-	return params.map((param) => {
+	let byParams = caseParamsCache.get(params);
+	if (!byParams) {
+		byParams = /* @__PURE__ */ new Map();
+		caseParamsCache.set(params, byParams);
+	}
+	const cached = byParams.get(casing);
+	if (cached) return cached;
+	const result = params.map((param) => {
 		const transformed = casing === "camelcase" || !isValidVarName(param.name) ? camelCase(param.name) : param.name;
 		return {
 			...param,
 			name: transformed
 		};
 	});
+	byParams.set(casing, result);
+	return result;
 }
 /**
 * Creates a single-property object schema used as a discriminator literal.
@@ -1310,7 +1303,15 @@ function collectReferencedSchemaNames(node, out = /* @__PURE__ */ new Set()) {
 * allowed.has('OrderStatus') // false when no included operation references OrderStatus
 * ```
 */
+const usedSchemaNamesCache = /* @__PURE__ */ new WeakMap();
 function collectUsedSchemaNames(operations, schemas) {
+	let byOps = usedSchemaNamesCache.get(operations);
+	if (!byOps) {
+		byOps = /* @__PURE__ */ new WeakMap();
+		usedSchemaNamesCache.set(operations, byOps);
+	}
+	const cached = byOps.get(schemas);
+	if (cached) return cached;
 	const schemaMap = /* @__PURE__ */ new Map();
 	for (const schema of schemas) if (schema.name) schemaMap.set(schema.name, schema);
 	const result = /* @__PURE__ */ new Set();
@@ -1326,8 +1327,11 @@ function collectUsedSchemaNames(operations, schemas) {
 		depth: "shallow",
 		schema: (node) => node
 	})) visitSchema(schema);
+	byOps.set(schemas, result);
 	return result;
 }
+const EMPTY_CIRCULAR_SET = /* @__PURE__ */ new Set();
+const circularSchemaCache = /* @__PURE__ */ new WeakMap();
 /**
 * Identifies all schemas that participate in circular dependency chains, including direct self-loops.
 *
@@ -1338,6 +1342,9 @@ function collectUsedSchemaNames(operations, schemas) {
 * @note Call this once on the full schema graph, then use `containsCircularRef()` to check individual schemas.
 */
 function findCircularSchemas(schemas) {
+	if (schemas.length === 0) return EMPTY_CIRCULAR_SET;
+	const cached = circularSchemaCache.get(schemas);
+	if (cached) return cached;
 	const graph = /* @__PURE__ */ new Map();
 	for (const schema of schemas) {
 		if (!schema.name) continue;
@@ -1359,6 +1366,7 @@ function findCircularSchemas(schemas) {
 			if (next) for (const r of next) stack.push(r);
 		}
 	}
+	circularSchemaCache.set(schemas, circular);
 	return circular;
 }
 /**