@kubb/ast 5.0.0-beta.60 → 5.0.0-beta.61

package/dist/{utils-Dj_KoXMv.js → utils-CF_-Pn_c.js}

@@ -1,157 +1,6 @@
 import "./chunk-CNktS9qV.js";
-import { A as contentDef, D as fileDef, E as exportDef, G as typeDef, H as functionDef, K as createProperty, M as arrowFunctionDef, N as breakDef, O as importDef, P as constDef, Q as schemaDef, S as typeLiteralDef, U as jsxDef, W as textDef, X as pascalCase, Y as camelCase, Z as createSchema, _ as createTypeLiteral, b as indexedAccessTypeDef, c as operationDef, f as inputDef, h as createIndexedAccessType, i as parameterDef, k as sourceDef, m as createFunctionParameters, n as responseDef, o as outputDef, p as createFunctionParameter, q as propertyDef, u as requestBodyDef, v as functionParameterDef, x as objectBindingPatternDef, y as functionParametersDef } from "./response-DKxTr522.js";
-//#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"
-};
-/**
-* One indentation level, derived from {@link INDENT_SIZE}.
-*/
-const INDENT = Array.from({ length: 2 }, () => " ").join("");
-//#endregion
+import { d as resolveRefName, h as INDENT, m as narrowSchema, n as collectLazy, t as collect, u as resolveGroupType } from "./visitor-DJ6ZEJvq.js";
+import { J as camelCase, X as createSchema, _ as createIndexedAccessType, g as createFunctionParameters, h as createFunctionParameter, y as createTypeLiteral } from "./response-KUdWiDWw.js";
 //#region ../../internals/utils/src/promise.ts
 /**
 * Wraps `factory` with a keyed cache backed by the provided store.
@@ -398,173 +247,15 @@ function buildList(items, brackets = ["[", "]"]) {
 	return `${open}\n${items.map((item) => `${indentLines(item)},`).join("\n")}\n${close}`;
 }
 //#endregion
-//#region src/guards.ts
-/**
-* Narrows a `SchemaNode` to the variant that matches `type`.
-*
-* @example
-* ```ts
-* const schema = createSchema({ type: 'string' })
-* const stringNode = narrowSchema(schema, 'string') // StringSchemaNode | null
-* ```
-*/
-function narrowSchema(node, type) {
-	return node?.type === type ? node : null;
-}
-/**
-* Narrows an `OperationNode` to an `HttpOperationNode` so `method` and `path` are present.
-*
-* @example
-* ```ts
-* if (isHttpOperationNode(node)) {
-*   console.log(node.method, node.path)
-* }
-* ```
-*/
-function isHttpOperationNode(node) {
-	return node.protocol === "http" || node.method !== void 0 && node.path !== void 0;
-}
-//#endregion
-//#region src/utils/refs.ts
-const plainStringTypes = new Set([
-	"string",
-	"uuid",
-	"email",
-	"url",
-	"datetime"
-]);
-/**
-* Returns the last path segment of a reference string.
-*
-* @example
-* ```ts
-* extractRefName('#/components/schemas/Pet') // 'Pet'
-* ```
-*/
-function extractRefName(ref) {
-	return ref.split("/").at(-1) ?? ref;
-}
+//#region src/utils/schemaMerge.ts
 /**
-* Resolves the schema name of a ref node, falling back through `ref` → `name` → nested `schema.name`.
-*
-* Returns `null` for non-ref nodes or when no name resolves.
+* Merges a run of adjacent anonymous object members into one. Named or non-object members break the
+* run and pass through. Stays a construction-time helper, not a macro, so callers keep control of the
+* member boundaries (such as keeping synthetic discriminant objects out of a run).
 *
 * @example
 * ```ts
-* resolveRefName({ kind: 'Schema', type: 'ref', ref: '#/components/schemas/Pet' })
-* // => 'Pet'
-* ```
-*/
-function resolveRefName(node) {
-	if (!node || node.type !== "ref") return null;
-	if (node.ref) return extractRefName(node.ref) ?? node.name ?? node.schema?.name ?? null;
-	return node.name ?? node.schema?.name ?? null;
-}
-/**
-* Builds a PascalCase child schema name by joining a parent name and property name.
-* Returns `null` when there is no parent to nest under.
-*
-* @example
-* ```ts
-* childName('Order', 'shipping_address') // 'OrderShippingAddress'
-* childName(undefined, 'params')         // null
-* ```
-*/
-function childName(parentName, propName) {
-	return parentName ? pascalCase([parentName, propName].join(" ")) : null;
-}
-/**
-* Builds a PascalCase enum name from the parent name, property name, and a suffix, skipping any
-* empty parts.
-*
-* @example
-* ```ts
-* enumPropName('Order', 'status', 'enum') // 'OrderStatusEnum'
-* ```
-*/
-function enumPropName(parentName, propName, enumSuffix) {
-	return pascalCase([
-		parentName,
-		propName,
-		enumSuffix
-	].filter(Boolean).join(" "));
-}
-/**
-* Type guard that returns `true` when a schema emits as a plain `string` type.
-*
-* Covers `string`, `uuid`, `email`, `url`, and `datetime` types. For `date` and `time`
-* types, returns `true` only when `representation` is `'string'` rather than `'date'`.
-*/
-function isStringType(node) {
-	if (plainStringTypes.has(node.type)) return true;
-	const temporal = narrowSchema(node, "date") ?? narrowSchema(node, "time");
-	if (temporal) return temporal.representation !== "date";
-	return false;
-}
-/**
-* Derives a {@link ParamGroupType} for a query or header group from the resolver.
-*
-* Returns `null` when there is no resolver, no params, or the group name equals the
-* individual param name (so there is no real group to emit).
-*/
-function resolveGroupType({ node, params, group, resolver }) {
-	if (!resolver || !params.length) return null;
-	const firstParam = params[0];
-	const groupName = (group === "query" ? resolver.resolveQueryParamsName : resolver.resolveHeaderParamsName).call(resolver, node, firstParam);
-	if (groupName === resolver.resolveParamName(node, firstParam)) return null;
-	return {
-		type: groupName,
-		optional: params.every((p) => !p.required)
-	};
-}
-//#endregion
-//#region src/transformers.ts
-/**
-* Replaces a discriminator property's schema with a string enum of allowed values.
-*
-* If `node` is not an object schema, or if the property does not exist, the input
-* node is returned as-is.
-*
-* @example
-* ```ts
-* const schema = createSchema({
-*   type: 'object',
-*   properties: [createProperty({ name: 'type', required: true, schema: createSchema({ type: 'string' }) })],
-* })
-* const result = setDiscriminatorEnum({ node: schema, propertyName: 'type', values: ['dog', 'cat'] })
-* ```
-*/
-function setDiscriminatorEnum({ node, propertyName, values, enumName }) {
-	const objectNode = narrowSchema(node, "object");
-	if (!objectNode?.properties?.length) return node;
-	if (!objectNode.properties.some((prop) => prop.name === propertyName)) return node;
-	return createSchema({
-		...objectNode,
-		properties: objectNode.properties.map((prop) => {
-			if (prop.name !== propertyName) return prop;
-			return createProperty({
-				...prop,
-				schema: createSchema({
-					type: "enum",
-					primitive: "string",
-					enumValues: values,
-					name: enumName,
-					readOnly: prop.schema.readOnly,
-					writeOnly: prop.schema.writeOnly
-				})
-			});
-		})
-	});
-}
-/**
-* Merges adjacent anonymous object members into a single anonymous object member.
-*
-* @example
-* ```ts
-* const merged = mergeAdjacentObjects([
-*   createSchema({ type: 'object', properties: [createProperty({ name: 'a', schema: createSchema({ type: 'string' }) })] }),
-*   createSchema({ type: 'object', properties: [createProperty({ name: 'b', schema: createSchema({ type: 'number' }) })] }),
-* ])
+* const merged = [...mergeAdjacentObjectsLazy([objectA, objectB])]
 * ```
 */
 function* mergeAdjacentObjectsLazy(members) {
@@ -586,68 +277,6 @@ function* mergeAdjacentObjectsLazy(members) {
 	}
 	if (acc !== void 0) yield acc;
 }
-/**
-* Removes enum members that are covered by broader scalar primitives in the same union.
-*
-* @example
-* ```ts
-* const simplified = simplifyUnion([
-*   createSchema({ type: 'enum', primitive: 'string', enumValues: ['active'] }),
-*   createSchema({ type: 'string' }),
-* ])
-* // keeps only string member
-* ```
-*/
-function simplifyUnion(members) {
-	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 = narrowSchema(member, "enum");
-		if (!enumNode) return true;
-		const primitive = enumNode.primitive;
-		if (!primitive) return true;
-		if ((enumNode.namedEnumValues?.length ?? enumNode.enumValues?.length ?? 0) <= 1) return true;
-		if (scalarPrimitives.has(primitive)) return false;
-		if ((primitive === "integer" || primitive === "number") && (scalarPrimitives.has("integer") || scalarPrimitives.has("number"))) return false;
-		return true;
-	});
-}
-function setEnumName(propNode, parentName, propName, enumSuffix) {
-	const enumNode = narrowSchema(propNode, "enum");
-	if (enumNode?.primitive === "boolean") return {
-		...propNode,
-		name: null
-	};
-	if (enumNode) return {
-		...propNode,
-		name: enumPropName(parentName, propName, enumSuffix)
-	};
-	return propNode;
-}
-/**
-* Merges a ref node with its resolved schema, giving usage-site fields precedence.
-*
-* Usage-site fields (`description`, `readOnly`, `nullable`, `deprecated`) on the ref node override
-* the same fields in the resolved `node.schema`. Non-ref nodes are returned unchanged.
-*
-* @example
-* ```ts
-* // Ref with description override
-* const ref = createSchema({ type: 'ref', ref: '#/components/schemas/Pet', description: 'A cute pet' })
-* const merged = syncSchemaRef(ref)  // merges with resolved Pet schema
-* ```
-*/
-function syncSchemaRef(node) {
-	const ref = narrowSchema(node, "ref");
-	if (!ref) return node;
-	if (!ref.schema) return node;
-	const { kind: _kind, type: _type, name: _name, ref: _ref, schema: _schema, ...overrides } = ref;
-	const definedOverrides = Object.fromEntries(Object.entries(overrides).filter(([, v]) => v !== void 0));
-	return createSchema({
-		...ref.schema,
-		...definedOverrides
-	});
-}
 //#endregion
 //#region src/utils/strings.ts
 /**
@@ -763,254 +392,6 @@ function getNestedAccessor(param, accessor) {
 	return `${accessor}?.['${`${parts.join("']?.['")}']`}`;
 }
 //#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 = [
-	inputDef,
-	outputDef,
-	operationDef,
-	requestBodyDef,
-	contentDef,
-	responseDef,
-	schemaDef,
-	propertyDef,
-	parameterDef,
-	functionParameterDef,
-	functionParametersDef,
-	typeLiteralDef,
-	indexedAccessTypeDef,
-	objectBindingPatternDef,
-	constDef,
-	typeDef,
-	functionDef,
-	arrowFunctionDef,
-	textDef,
-	breakDef,
-	jsxDef,
-	importDef,
-	exportDef,
-	sourceDef,
-	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/utils/schemaGraph.ts
 /**
 * Collects every named schema referenced transitively from a node through its ref edges.
@@ -1384,6 +765,6 @@ function buildTypeLiteral({ node, params, resolver }) {
 	})) });
 }
 //#endregion
-export { enumPropName as A, objectKey as B, trimQuotes as C, simplifyUnion as D, setEnumName as E, isHttpOperationNode as F, httpMethods as H, narrowSchema as I, buildJSDoc as L, isStringType as M, resolveGroupType as N, syncSchemaRef as O, resolveRefName as P, buildList as R, toRegExpString as S, setDiscriminatorEnum as T, schemaTypes as U, isValidVarName as V, nodeDefs as _, resolveParamType as a, stringify as b, mapSchemaMembers as c, containsCircularRef as d, findCircularSchemas as f, walk as g, transform as h, createOperationParams as i, extractRefName as j, childName as k, mapSchemaProperties as l, collectLazy as m, buildTypeLiteral as n, lazyGetter as o, collect as p, caseParams as r, mapSchemaItems as s, buildGroupParam as t, collectUsedSchemaNames as u, getNestedAccessor as v, mergeAdjacentObjectsLazy as w, stringifyObject as x, jsStringEscape as y, buildObject as z };
+export { objectKey as C, buildObject as S, toRegExpString as _, resolveParamType as a, buildJSDoc as b, mapSchemaMembers as c, containsCircularRef as d, findCircularSchemas as f, stringifyObject as g, stringify as h, createOperationParams as i, mapSchemaProperties as l, jsStringEscape as m, buildTypeLiteral as n, lazyGetter as o, getNestedAccessor as p, caseParams as r, mapSchemaItems as s, buildGroupParam as t, collectUsedSchemaNames as u, trimQuotes as v, isValidVarName as w, buildList as x, mergeAdjacentObjectsLazy as y };
 
-//# sourceMappingURL=utils-Dj_KoXMv.js.map
+//# sourceMappingURL=utils-CF_-Pn_c.js.map