@kubb/ast 5.0.0-alpha.13 → 5.0.0-alpha.14

package/dist/index.cjs

@@ -112,23 +112,41 @@ function createSchema(props) {
 	};
 }
 /**
+* Derives `schema.optional` and `schema.nullish` from `required` and `schema.nullable`.
+* This keeps `PropertyNode.required` as the single source of truth for optionality.
+*/
+function syncPropertySchema(required, schema) {
+	const nullable = schema.nullable ?? false;
+	return {
+		...schema,
+		optional: !required && !nullable ? true : void 0,
+		nullish: !required && nullable ? true : void 0
+	};
+}
+/**
 * Creates a `PropertyNode`. `required` defaults to `false`.
+* `schema.optional` and `schema.nullish` are auto-derived from `required` and `schema.nullable`.
 */
 function createProperty(props) {
+	const required = props.required ?? false;
 	return {
-		required: false,
 		...props,
-		kind: "Property"
+		kind: "Property",
+		required,
+		schema: syncPropertySchema(required, props.schema)
 	};
 }
 /**
 * Creates a `ParameterNode`. `required` defaults to `false`.
+* `schema.optional` is auto-derived from `required` and `schema.nullable`.
 */
 function createParameter(props) {
+	const required = props.required ?? false;
 	return {
-		required: false,
 		...props,
-		kind: "Parameter"
+		kind: "Parameter",
+		required,
+		schema: syncPropertySchema(required, props.schema)
 	};
 }
 /**
@@ -854,103 +872,129 @@ function getChildren(node, recurse) {
 * Depth-first traversal for side effects. Visitor return values are ignored.
 * Sibling nodes at each level are visited concurrently up to `options.concurrency` (default: 30).
 */
-async function walk(node, visitor, options = {}) {
-	return _walk(node, visitor, (options.depth ?? visitorDepths.deep) === visitorDepths.deep, createLimit(options.concurrency ?? 30));
+async function walk(node, options) {
+	return _walk(node, options, (options.depth ?? visitorDepths.deep) === visitorDepths.deep, createLimit(options.concurrency ?? 30), void 0);
 }
-/**
-* Internal recursive walk implementation — calls visitor then recurses into children.
-*/
-async function _walk(node, visitor, recurse, limit) {
+async function _walk(node, visitor, recurse, limit, parent) {
 	switch (node.kind) {
 		case "Root":
-			await limit(() => visitor.root?.(node));
+			await limit(() => visitor.root?.(node, { parent }));
 			break;
 		case "Operation":
-			await limit(() => visitor.operation?.(node));
+			await limit(() => visitor.operation?.(node, { parent }));
 			break;
 		case "Schema":
-			await limit(() => visitor.schema?.(node));
+			await limit(() => visitor.schema?.(node, { parent }));
 			break;
 		case "Property":
-			await limit(() => visitor.property?.(node));
+			await limit(() => visitor.property?.(node, { parent }));
 			break;
 		case "Parameter":
-			await limit(() => visitor.parameter?.(node));
+			await limit(() => visitor.parameter?.(node, { parent }));
 			break;
 		case "Response":
-			await limit(() => visitor.response?.(node));
+			await limit(() => visitor.response?.(node, { parent }));
 			break;
 		case "FunctionParameter":
 		case "ObjectBindingParameter":
 		case "FunctionParameters": break;
 	}
 	const children = getChildren(node, recurse);
-	await Promise.all(children.map((child) => _walk(child, visitor, recurse, limit)));
+	await Promise.all(children.map((child) => _walk(child, visitor, recurse, limit, node)));
 }
-function transform(node, visitor, options = {}) {
-	const recurse = (options.depth ?? visitorDepths.deep) === visitorDepths.deep;
+function transform(node, options) {
+	const { depth, parent, ...visitor } = options;
+	const recurse = (depth ?? visitorDepths.deep) === visitorDepths.deep;
 	switch (node.kind) {
 		case "Root": {
 			let root = node;
-			const replaced = visitor.root?.(root);
+			const replaced = visitor.root?.(root, { parent });
 			if (replaced) root = replaced;
 			return {
 				...root,
-				schemas: root.schemas.map((s) => transform(s, visitor, options)),
-				operations: root.operations.map((op) => transform(op, visitor, options))
+				schemas: root.schemas.map((s) => transform(s, {
+					...options,
+					parent: root
+				})),
+				operations: root.operations.map((op) => transform(op, {
+					...options,
+					parent: root
+				}))
 			};
 		}
 		case "Operation": {
 			let op = node;
-			const replaced = visitor.operation?.(op);
+			const replaced = visitor.operation?.(op, { parent });
 			if (replaced) op = replaced;
 			return {
 				...op,
-				parameters: op.parameters.map((p) => transform(p, visitor, options)),
+				parameters: op.parameters.map((p) => transform(p, {
+					...options,
+					parent: op
+				})),
 				requestBody: op.requestBody ? {
 					...op.requestBody,
-					schema: op.requestBody.schema ? transform(op.requestBody.schema, visitor, options) : void 0
+					schema: op.requestBody.schema ? transform(op.requestBody.schema, {
+						...options,
+						parent: op
+					}) : void 0
 				} : void 0,
-				responses: op.responses.map((r) => transform(r, visitor, options))
+				responses: op.responses.map((r) => transform(r, {
+					...options,
+					parent: op
+				}))
 			};
 		}
 		case "Schema": {
 			let schema = node;
-			const replaced = visitor.schema?.(schema);
+			const replaced = visitor.schema?.(schema, { parent });
 			if (replaced) schema = replaced;
+			const childOptions = {
+				...options,
+				parent: schema
+			};
 			return {
 				...schema,
-				..."properties" in schema && recurse ? { properties: schema.properties.map((p) => transform(p, visitor, options)) } : {},
-				..."items" in schema && recurse ? { items: schema.items?.map((i) => transform(i, visitor, options)) } : {},
-				..."members" in schema && recurse ? { members: schema.members?.map((m) => transform(m, visitor, options)) } : {},
-				..."additionalProperties" in schema && recurse && schema.additionalProperties && schema.additionalProperties !== true ? { additionalProperties: transform(schema.additionalProperties, visitor, options) } : {}
+				..."properties" in schema && recurse ? { properties: schema.properties.map((p) => transform(p, childOptions)) } : {},
+				..."items" in schema && recurse ? { items: schema.items?.map((i) => transform(i, childOptions)) } : {},
+				..."members" in schema && recurse ? { members: schema.members?.map((m) => transform(m, childOptions)) } : {},
+				..."additionalProperties" in schema && recurse && schema.additionalProperties && schema.additionalProperties !== true ? { additionalProperties: transform(schema.additionalProperties, childOptions) } : {}
 			};
 		}
 		case "Property": {
 			let prop = node;
-			const replaced = visitor.property?.(prop);
+			const replaced = visitor.property?.(prop, { parent });
 			if (replaced) prop = replaced;
-			return {
+			return createProperty({
 				...prop,
-				schema: transform(prop.schema, visitor, options)
-			};
+				schema: transform(prop.schema, {
+					...options,
+					parent: prop
+				})
+			});
 		}
 		case "Parameter": {
 			let param = node;
-			const replaced = visitor.parameter?.(param);
+			const replaced = visitor.parameter?.(param, { parent });
 			if (replaced) param = replaced;
-			return {
+			return createParameter({
 				...param,
-				schema: transform(param.schema, visitor, options)
-			};
+				schema: transform(param.schema, {
+					...options,
+					parent: param
+				})
+			});
 		}
 		case "Response": {
 			let response = node;
-			const replaced = visitor.response?.(response);
+			const replaced = visitor.response?.(response, { parent });
 			if (replaced) response = replaced;
 			return {
 				...response,
-				schema: transform(response.schema, visitor, options)
+				schema: transform(response.schema, {
+					...options,
+					parent: response
+				})
 			};
 		}
 		case "FunctionParameter":
@@ -959,43 +1003,74 @@ function transform(node, visitor, options = {}) {
 	}
 }
 /**
+* Combines multiple visitors into a single visitor that applies them sequentially (left to right).
+* For each node kind, the output of one visitor becomes the input of the next.
+*/
+function composeTransformers(...visitors) {
+	return {
+		root(node, context) {
+			return visitors.reduce((acc, v) => v.root?.(acc, context) ?? acc, node);
+		},
+		operation(node, context) {
+			return visitors.reduce((acc, v) => v.operation?.(acc, context) ?? acc, node);
+		},
+		schema(node, context) {
+			return visitors.reduce((acc, v) => v.schema?.(acc, context) ?? acc, node);
+		},
+		property(node, context) {
+			return visitors.reduce((acc, v) => v.property?.(acc, context) ?? acc, node);
+		},
+		parameter(node, context) {
+			return visitors.reduce((acc, v) => v.parameter?.(acc, context) ?? acc, node);
+		},
+		response(node, context) {
+			return visitors.reduce((acc, v) => v.response?.(acc, context) ?? acc, node);
+		}
+	};
+}
+/**
 * Depth-first synchronous reduction. Collects non-`undefined` visitor return values into an array.
 */
-function collect(node, visitor, options = {}) {
-	const recurse = (options.depth ?? visitorDepths.deep) === visitorDepths.deep;
+function collect(node, options) {
+	const { depth, parent, ...visitor } = options;
+	const recurse = (depth ?? visitorDepths.deep) === visitorDepths.deep;
 	const results = [];
 	let v;
 	switch (node.kind) {
 		case "Root":
-			v = visitor.root?.(node);
+			v = visitor.root?.(node, { parent });
 			break;
 		case "Operation":
-			v = visitor.operation?.(node);
+			v = visitor.operation?.(node, { parent });
 			break;
 		case "Schema":
-			v = visitor.schema?.(node);
+			v = visitor.schema?.(node, { parent });
 			break;
 		case "Property":
-			v = visitor.property?.(node);
+			v = visitor.property?.(node, { parent });
 			break;
 		case "Parameter":
-			v = visitor.parameter?.(node);
+			v = visitor.parameter?.(node, { parent });
 			break;
 		case "Response":
-			v = visitor.response?.(node);
+			v = visitor.response?.(node, { parent });
 			break;
 		case "FunctionParameter":
 		case "ObjectBindingParameter":
 		case "FunctionParameters": break;
 	}
 	if (v !== void 0) results.push(v);
-	for (const child of getChildren(node, recurse)) for (const item of collect(child, visitor, options)) results.push(item);
+	for (const child of getChildren(node, recurse)) for (const item of collect(child, {
+		...options,
+		parent: node
+	})) results.push(item);
 	return results;
 }
 //#endregion
 exports.applyParamsCasing = applyParamsCasing;
 exports.buildRefMap = buildRefMap;
 exports.collect = collect;
+exports.composeTransformers = composeTransformers;
 exports.createFunctionParameter = createFunctionParameter;
 exports.createFunctionParameters = createFunctionParameters;
 exports.createObjectBindingParameter = createObjectBindingParameter;
@@ -1024,6 +1099,7 @@ exports.nodeKinds = nodeKinds;
 exports.refMapToObject = refMapToObject;
 exports.resolveRef = resolveRef;
 exports.schemaTypes = schemaTypes;
+exports.syncPropertySchema = syncPropertySchema;
 exports.transform = transform;
 exports.walk = walk;