@kubb/ast 5.0.0-beta.58 → 5.0.0-beta.59

package/dist/index.cjs

@@ -1,7 +1,157 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_utils = require("./utils-C8bWAzhv.cjs");
-const require_factory = require("./factory-JN-Ylfl6.cjs");
+require("./casing-BE2R1RXg.cjs");
+const require_factory = require("./factory-BmcGBdeg.cjs");
+const require_utils = require("./utils-BCtRXfhI.cjs");
 let node_crypto = require("node:crypto");
+//#region src/constants.ts
+const visitorDepths = {
+	shallow: "shallow",
+	deep: "deep"
+};
+/**
+* Schema type discriminators used by all AST schema nodes.
+*
+* Each value is a stable discriminator across the AST (for example `schema.type === schemaTypes.object`).
+* Call `isScalarPrimitive()` to check for the scalar types.
+*/
+const schemaTypes = {
+	/**
+	* Text value.
+	*/
+	string: "string",
+	/**
+	* Floating-point number (`float`, `double`).
+	*/
+	number: "number",
+	/**
+	* Whole number (`int32`). Use `bigint` for `int64`.
+	*/
+	integer: "integer",
+	/**
+	* 64-bit integer (`int64`). Only used when `integerType` is set to `'bigint'`.
+	*/
+	bigint: "bigint",
+	/**
+	* Boolean value.
+	*/
+	boolean: "boolean",
+	/**
+	* Explicit null value.
+	*/
+	null: "null",
+	/**
+	* Any value (no type restriction).
+	*/
+	any: "any",
+	/**
+	* Unknown value (must be narrowed before usage).
+	*/
+	unknown: "unknown",
+	/**
+	* No return value (`void`).
+	*/
+	void: "void",
+	/**
+	* Object with named properties.
+	*/
+	object: "object",
+	/**
+	* Sequential list of items.
+	*/
+	array: "array",
+	/**
+	* Fixed-length list with position-specific items.
+	*/
+	tuple: "tuple",
+	/**
+	* "One of" multiple schema members.
+	*/
+	union: "union",
+	/**
+	* "All of" multiple schema members.
+	*/
+	intersection: "intersection",
+	/**
+	* Enum schema.
+	*/
+	enum: "enum",
+	/**
+	* Reference to another schema.
+	*/
+	ref: "ref",
+	/**
+	* Calendar date (for example `2026-03-24`).
+	*/
+	date: "date",
+	/**
+	* Date-time value (for example `2026-03-24T09:00:00Z`).
+	*/
+	datetime: "datetime",
+	/**
+	* Time-only value (for example `09:00:00`).
+	*/
+	time: "time",
+	/**
+	* UUID value.
+	*/
+	uuid: "uuid",
+	/**
+	* Email address value.
+	*/
+	email: "email",
+	/**
+	* URL value.
+	*/
+	url: "url",
+	/**
+	* IPv4 address value.
+	*/
+	ipv4: "ipv4",
+	/**
+	* IPv6 address value.
+	*/
+	ipv6: "ipv6",
+	/**
+	* Binary/blob value.
+	*/
+	blob: "blob",
+	/**
+	* Impossible value (`never`).
+	*/
+	never: "never"
+};
+/**
+* Scalar primitive schema types used for union simplification and type narrowing.
+*/
+const SCALAR_PRIMITIVE_TYPES = new Set([
+	"string",
+	"number",
+	"integer",
+	"bigint",
+	"boolean"
+]);
+/**
+* Returns `true` when `type` is a scalar primitive that can be assigned without wrapping
+* (for example `string | number | boolean`).
+*/
+function isScalarPrimitive(type) {
+	return SCALAR_PRIMITIVE_TYPES.has(type);
+}
+/**
+* HTTP method identifiers used by operation nodes.
+*/
+const httpMethods = {
+	get: "GET",
+	post: "POST",
+	put: "PUT",
+	patch: "PATCH",
+	delete: "DELETE",
+	head: "HEAD",
+	options: "OPTIONS",
+	trace: "TRACE"
+};
+Array.from({ length: 2 }, () => " ").join("");
+//#endregion
 //#region src/signature.ts
 /**
 * The flags shared by every node kind that affect its type: `primitive`, `format`, `nullable`.
@@ -228,9 +378,9 @@ function describeShape(node) {
 	return parts.join("|");
 }
 /**
-* Node → digest cache, keyed by identity. A `WeakMap` so entries die with the node, and so a tree
-* hashed during dedupe planning is not walked again when it is rewritten during streaming. Reuse
-* is safe because a signature depends only on content, and nodes are immutable once created.
+* Caches the digest per node, keyed by identity. A `WeakMap` so entries die with the node, and so
+* a tree hashed during dedupe planning is not walked again when it is rewritten during streaming.
+* Reuse is safe because a signature depends only on content, and nodes are immutable once created.
 */
 const signatureCache = /* @__PURE__ */ new WeakMap();
 /**
@@ -254,13 +404,261 @@ function signatureOf(node) {
 	return signature;
 }
 //#endregion
+//#region src/registry.ts
+/**
+* Every node definition. Adding a node means adding its `defineNode` to one
+* `nodes/*.ts` file and listing it here. The visitor tables in `visitor.ts` derive from it.
+*/
+const nodeDefs = [
+	require_factory.inputDef,
+	require_factory.outputDef,
+	require_factory.operationDef,
+	require_factory.requestBodyDef,
+	require_factory.contentDef,
+	require_factory.responseDef,
+	require_factory.schemaDef,
+	require_factory.propertyDef,
+	require_factory.parameterDef,
+	require_factory.functionParameterDef,
+	require_factory.functionParametersDef,
+	require_factory.typeLiteralDef,
+	require_factory.indexedAccessTypeDef,
+	require_factory.objectBindingPatternDef,
+	require_factory.constDef,
+	require_factory.typeDef,
+	require_factory.functionDef,
+	require_factory.arrowFunctionDef,
+	require_factory.textDef,
+	require_factory.breakDef,
+	require_factory.jsxDef,
+	require_factory.importDef,
+	require_factory.exportDef,
+	require_factory.sourceDef,
+	require_factory.fileDef
+];
+//#endregion
+//#region src/visitor.ts
+/**
+* Child node fields per node kind, in traversal order (Babel's `VISITOR_KEYS`).
+* Derived from each definition's `children`.
+*/
+const VISITOR_KEYS = Object.fromEntries(nodeDefs.flatMap((def) => def.children ? [[def.kind, def.children]] : []));
+/**
+* Maps a node kind to the matching visitor callback name. Derived from each
+* definition's `visitorKey`.
+*/
+const VISITOR_KEY_BY_KIND = Object.fromEntries(nodeDefs.flatMap((def) => def.visitorKey ? [[def.kind, def.visitorKey]] : []));
+/**
+* Per-kind builders rerun after children are rebuilt. Derived from each
+* definition's `rebuild` flag.
+*/
+const nodeRebuilders = Object.fromEntries(nodeDefs.flatMap((def) => def.rebuild ? [[def.kind, def.create]] : []));
+/**
+* Creates a small async concurrency limiter.
+*
+* At most `concurrency` tasks are in flight at once. Extra tasks are queued.
+*
+* @example
+* ```ts
+* const limit = createLimit(2)
+* for (const task of [taskA, taskB, taskC]) {
+*   await limit(() => task())
+* }
+* // only 2 tasks run at the same time
+* ```
+*/
+function createLimit(concurrency) {
+	let active = 0;
+	const queue = [];
+	function next() {
+		if (active < concurrency && queue.length > 0) {
+			active++;
+			queue.shift()();
+		}
+	}
+	return function limit(fn) {
+		return new Promise((resolve, reject) => {
+			queue.push(() => {
+				Promise.resolve(fn()).then(resolve, reject).finally(() => {
+					active--;
+					next();
+				});
+			});
+			next();
+		});
+	};
+}
+const visitorKeysByKind = VISITOR_KEYS;
+/**
+* Returns `true` when `value` is an AST node (an object carrying a `kind`).
+*/
+function isNode(value) {
+	return typeof value === "object" && value !== null && "kind" in value;
+}
+/**
+* Returns the immediate traversable children of `node` based on {@link VISITOR_KEYS}.
+*
+* `Schema` children are only included when `recurse` is `true`. Shallow mode skips them.
+*
+* @example
+* ```ts
+* const children = getChildren(operationNode, true)
+* // returns parameters, the request body, and responses
+* ```
+*/
+function* getChildren(node, recurse) {
+	if (node.kind === "Schema" && !recurse) return;
+	const keys = visitorKeysByKind[node.kind];
+	if (!keys) return;
+	const record = node;
+	for (const key of keys) {
+		const value = record[key];
+		if (Array.isArray(value)) {
+			for (const item of value) if (isNode(item)) yield item;
+		} else if (isNode(value)) yield value;
+	}
+}
+/**
+* Runs the visitor callback that matches `node.kind` with the traversal
+* context. The result is a replacement node, a collected value, or `undefined`
+* when no callback is registered for the kind.
+*
+* Shared by `walk`, `transform`, and `collectLazy` so node-kind dispatch lives
+* in one place. `TResult` is the caller's expected return: the same node type
+* for `transform`, the collected value type for `collectLazy`, ignored for `walk`.
+*/
+function applyVisitor(node, visitor, parent) {
+	const key = VISITOR_KEY_BY_KIND[node.kind];
+	if (!key) return void 0;
+	const fn = visitor[key];
+	return fn?.(node, { parent });
+}
+/**
+* Async depth-first traversal for side effects. Visitor return values are
+* ignored. Use `transform` when you want to rewrite nodes.
+*
+* Sibling nodes at each depth run concurrently up to `options.concurrency`
+* (defaults to `WALK_CONCURRENCY`). Higher values overlap I/O-bound visitor
+* work. Lower values reduce memory pressure.
+*
+* @example Log every operation
+* ```ts
+* await walk(root, {
+*   operation(node) {
+*     console.log(node.operationId)
+*   },
+* })
+* ```
+*
+* @example Only visit the root node
+* ```ts
+* await walk(root, { depth: 'shallow', input: () => {} })
+* ```
+*/
+async function walk(node, options) {
+	return _walk(node, options, (options.depth ?? visitorDepths.deep) === visitorDepths.deep, createLimit(options.concurrency ?? 30), void 0);
+}
+async function _walk(node, visitor, recurse, limit, parent) {
+	await limit(() => applyVisitor(node, visitor, parent));
+	const children = Array.from(getChildren(node, recurse));
+	if (children.length === 0) return;
+	await Promise.all(children.map((child) => _walk(child, visitor, recurse, limit, node)));
+}
+function transform(node, options) {
+	const { depth, parent, ...visitor } = options;
+	const recurse = (depth ?? visitorDepths.deep) === visitorDepths.deep;
+	const rebuilt = transformChildren(applyVisitor(node, visitor, parent) ?? node, options, recurse);
+	if (rebuilt === node) return node;
+	const rebuild = nodeRebuilders[rebuilt.kind];
+	return rebuild ? rebuild(rebuilt) : rebuilt;
+}
+/**
+* Immutably rebuilds a node's children using {@link VISITOR_KEYS}, transforming
+* each child node and leaving non-node values (e.g. `additionalProperties: true`) intact.
+* `Schema` children are skipped in shallow mode.
+*/
+function transformChildren(node, options, recurse) {
+	if (node.kind === "Schema" && !recurse) return node;
+	const keys = visitorKeysByKind[node.kind];
+	if (!keys) return node;
+	const record = node;
+	const childOptions = {
+		...options,
+		parent: node
+	};
+	let updates;
+	for (const key of keys) {
+		if (!(key in record)) continue;
+		const value = record[key];
+		if (Array.isArray(value)) {
+			let changed = false;
+			const mapped = value.map((item) => {
+				if (!isNode(item)) return item;
+				const next = transform(item, childOptions);
+				if (next !== item) changed = true;
+				return next;
+			});
+			if (changed) (updates ??= {})[key] = mapped;
+		} else if (isNode(value)) {
+			const next = transform(value, childOptions);
+			if (next !== value) (updates ??= {})[key] = next;
+		}
+	}
+	return updates ? {
+		...node,
+		...updates
+	} : node;
+}
+/**
+* Lazy depth-first collection pass. Yields every non-null value returned by
+* the visitor callbacks. Use `collect` for the eager array form.
+*
+* @example Collect every operationId
+* ```ts
+* const ids: string[] = []
+* for (const id of collectLazy<string>(root, {
+*   operation(node) {
+*     return node.operationId
+*   },
+* })) {
+*   ids.push(id)
+* }
+* ```
+*/
+function* collectLazy(node, options) {
+	const { depth, parent, ...visitor } = options;
+	const recurse = (depth ?? visitorDepths.deep) === visitorDepths.deep;
+	const v = applyVisitor(node, visitor, parent);
+	if (v != null) yield v;
+	for (const child of getChildren(node, recurse)) yield* collectLazy(child, {
+		...options,
+		parent: node
+	});
+}
+/**
+* Eager depth-first collection pass. Gathers every non-null value the visitor
+* callbacks return into an array.
+*
+* @example Collect every operationId
+* ```ts
+* const ids = collect<string>(root, {
+*   operation(node) {
+*     return node.operationId
+*   },
+* })
+* ```
+*/
+function collect(node, options) {
+	return Array.from(collectLazy(node, options));
+}
+//#endregion
 //#region src/dedupe.ts
 /**
 * Builds the shared `ref` replacement for a duplicate occurrence, carrying the
 * usage-slot and documentation fields that are not part of the canonical type.
 */
 function createRefNode(node, canonical) {
-	return require_utils.createSchema({
+	return require_factory.createSchema({
 		type: "ref",
 		name: canonical.name,
 		ref: canonical.ref,
@@ -278,7 +676,7 @@ function applyDedupe(node, plan, skipRootMatch = false) {
 	const { canonicalBySignature, aliasNames } = plan;
 	if (canonicalBySignature.size === 0 && aliasNames.size === 0) return node;
 	const root = node;
-	return require_utils.transform(node, { schema(schemaNode) {
+	return transform(node, { schema(schemaNode) {
 		if (schemaNode.type === "ref") {
 			const target = schemaNode.ref ? require_utils.extractRefName(schemaNode.ref) : schemaNode.name;
 			const canonical = target ? aliasNames.get(target) : void 0;
@@ -346,7 +744,7 @@ function buildDedupePlan(roots, options) {
 	}
 	for (const root of roots) {
 		if (root.kind === "Schema") topLevelNodes.add(root);
-		for (const schemaNode of require_utils.collectLazy(root, { schema: (node) => node })) record(schemaNode);
+		for (const schemaNode of collectLazy(root, { schema: (node) => node })) record(schemaNode);
 	}
 	const canonicalBySignature = /* @__PURE__ */ new Map();
 	const aliasNames = /* @__PURE__ */ new Map();
@@ -502,13 +900,13 @@ function setDiscriminatorEnum({ node, propertyName, values, enumName }) {
 	const objectNode = require_utils.narrowSchema(node, "object");
 	if (!objectNode?.properties?.length) return node;
 	if (!objectNode.properties.some((prop) => prop.name === propertyName)) return node;
-	return require_utils.createSchema({
+	return require_factory.createSchema({
 		...objectNode,
 		properties: objectNode.properties.map((prop) => {
 			if (prop.name !== propertyName) return prop;
-			return require_utils.createProperty({
+			return require_factory.createProperty({
 				...prop,
-				schema: require_utils.createSchema({
+				schema: require_factory.createSchema({
 					type: "enum",
 					primitive: "string",
 					enumValues: values,
@@ -538,7 +936,7 @@ function* mergeAdjacentObjectsLazy(members) {
 		if (objectMember && !objectMember.name && acc !== void 0) {
 			const accObject = require_utils.narrowSchema(acc, "object");
 			if (accObject && !accObject.name) {
-				acc = require_utils.createSchema({
+				acc = require_factory.createSchema({
 					...accObject,
 					properties: [...accObject.properties ?? [], ...objectMember.properties ?? []]
 				});
@@ -563,7 +961,7 @@ function* mergeAdjacentObjectsLazy(members) {
 * ```
 */
 function simplifyUnion(members) {
-	const scalarPrimitives = new Set(members.filter((member) => require_utils.isScalarPrimitive(member.type)).map((m) => m.type));
+	const scalarPrimitives = new Set(members.filter((member) => isScalarPrimitive(member.type)).map((m) => m.type));
 	if (!scalarPrimitives.size) return members;
 	return members.filter((member) => {
 		const enumNode = require_utils.narrowSchema(member, "enum");
@@ -590,55 +988,56 @@ function setEnumName(propNode, parentName, propName, enumSuffix) {
 }
 //#endregion
 exports.applyDedupe = applyDedupe;
-exports.arrowFunctionDef = require_utils.arrowFunctionDef;
-exports.breakDef = require_utils.breakDef;
+exports.arrowFunctionDef = require_factory.arrowFunctionDef;
+exports.breakDef = require_factory.breakDef;
 exports.buildDedupePlan = buildDedupePlan;
-exports.collect = require_utils.collect;
-exports.constDef = require_utils.constDef;
-exports.contentDef = require_utils.contentDef;
+exports.collect = collect;
+exports.constDef = require_factory.constDef;
+exports.contentDef = require_factory.contentDef;
 exports.createPrinterFactory = createPrinterFactory;
-exports.defineNode = require_utils.defineNode;
+exports.defineNode = require_factory.defineNode;
 exports.definePrinter = definePrinter;
 exports.defineSchemaDialect = defineSchemaDialect;
-exports.exportDef = require_utils.exportDef;
-exports.extractStringsFromNodes = require_utils.extractStringsFromNodes;
+exports.exportDef = require_factory.exportDef;
+exports.extractStringsFromNodes = require_factory.extractStringsFromNodes;
 Object.defineProperty(exports, "factory", {
 	enumerable: true,
 	get: function() {
 		return require_factory.factory_exports;
 	}
 });
-exports.fileDef = require_utils.fileDef;
-exports.functionDef = require_utils.functionDef;
-exports.functionParameterDef = require_utils.functionParameterDef;
-exports.functionParametersDef = require_utils.functionParametersDef;
-exports.httpMethods = require_utils.httpMethods;
-exports.importDef = require_utils.importDef;
-exports.indexedAccessTypeDef = require_utils.indexedAccessTypeDef;
-exports.inputDef = require_utils.inputDef;
+exports.fileDef = require_factory.fileDef;
+exports.functionDef = require_factory.functionDef;
+exports.functionParameterDef = require_factory.functionParameterDef;
+exports.functionParametersDef = require_factory.functionParametersDef;
+exports.httpMethods = httpMethods;
+exports.importDef = require_factory.importDef;
+exports.indexedAccessTypeDef = require_factory.indexedAccessTypeDef;
+exports.inputDef = require_factory.inputDef;
 exports.isHttpOperationNode = require_utils.isHttpOperationNode;
-exports.jsxDef = require_utils.jsxDef;
+exports.jsxDef = require_factory.jsxDef;
 exports.mergeAdjacentObjectsLazy = mergeAdjacentObjectsLazy;
 exports.narrowSchema = require_utils.narrowSchema;
-exports.objectBindingPatternDef = require_utils.objectBindingPatternDef;
-exports.operationDef = require_utils.operationDef;
-exports.outputDef = require_utils.outputDef;
-exports.parameterDef = require_utils.parameterDef;
-exports.propertyDef = require_utils.propertyDef;
-exports.requestBodyDef = require_utils.requestBodyDef;
-exports.responseDef = require_utils.responseDef;
-exports.schemaDef = require_utils.schemaDef;
-exports.schemaTypes = require_utils.schemaTypes;
+exports.nodeDefs = nodeDefs;
+exports.objectBindingPatternDef = require_factory.objectBindingPatternDef;
+exports.operationDef = require_factory.operationDef;
+exports.outputDef = require_factory.outputDef;
+exports.parameterDef = require_factory.parameterDef;
+exports.propertyDef = require_factory.propertyDef;
+exports.requestBodyDef = require_factory.requestBodyDef;
+exports.responseDef = require_factory.responseDef;
+exports.schemaDef = require_factory.schemaDef;
+exports.schemaTypes = schemaTypes;
 exports.setDiscriminatorEnum = setDiscriminatorEnum;
 exports.setEnumName = setEnumName;
 exports.signatureOf = signatureOf;
 exports.simplifyUnion = simplifyUnion;
-exports.sourceDef = require_utils.sourceDef;
-exports.syncOptionality = require_utils.syncOptionality;
-exports.textDef = require_utils.textDef;
-exports.transform = require_utils.transform;
-exports.typeDef = require_utils.typeDef;
-exports.typeLiteralDef = require_utils.typeLiteralDef;
-exports.walk = require_utils.walk;
+exports.sourceDef = require_factory.sourceDef;
+exports.syncOptionality = require_factory.syncOptionality;
+exports.textDef = require_factory.textDef;
+exports.transform = transform;
+exports.typeDef = require_factory.typeDef;
+exports.typeLiteralDef = require_factory.typeLiteralDef;
+exports.walk = walk;
 
 //# sourceMappingURL=index.cjs.map