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

package/dist/index.cjs

@@ -623,9 +623,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, {
@@ -638,16 +636,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, {
@@ -671,9 +662,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
@@ -687,9 +676,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, {
@@ -699,9 +686,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, {
@@ -711,9 +696,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, {
@@ -840,15 +823,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.
@@ -1333,7 +1326,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();
@@ -1349,8 +1350,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.
 *
@@ -1361,6 +1365,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;
@@ -1382,6 +1389,7 @@ function findCircularSchemas(schemas) {
 			if (next) for (const r of next) stack.push(r);
 		}
 	}
+	circularSchemaCache.set(schemas, circular);
 	return circular;
 }
 /**