@kubb/ast 5.0.0-beta.99 → 5.0.0

package/dist/index.js

@@ -331,33 +331,6 @@ const contentDef = defineNode({
 */
 const createContent = contentDef.create;
 //#endregion
-//#region ../../internals/utils/src/casing.ts
-/**
-* Shared implementation for camelCase and PascalCase conversion.
-* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
-* and capitalizes each word according to `pascal`.
-*
-* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
-*/
-function toCamelOrPascal(text, pascal) {
-	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
-		if (word.length > 1 && word === word.toUpperCase()) return word;
-		return (i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1);
-	}).join("").replace(/[^a-zA-Z0-9]/g, "");
-}
-/**
-* Converts `text` to PascalCase.
-*
-* @example Word boundaries
-* `pascalCase('hello-world') // 'HelloWorld'`
-*
-* @example With a suffix
-* `pascalCase('tag', { suffix: 'schema' }) // 'TagSchema'`
-*/
-function pascalCase(text, { prefix = "", suffix = "" } = {}) {
-	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
-}
-//#endregion
 //#region ../../internals/utils/src/fs.ts
 /**
 * Strips the file extension from a path or file name.
@@ -452,6 +425,17 @@ function extractStringsFromNodes(nodes) {
 }
 //#endregion
 //#region src/utils/combineFileMembers.ts
+const IDENTIFIER_RUN = /[\w$]+/g;
+/**
+* How many imports a file needs before indexing the source beats scanning it once per name.
+*/
+const INDEX_ABOVE_IMPORTS = 128;
+/**
+* Every unbroken run of identifier characters in the source.
+*/
+function collectIdentifiers(source) {
+	return new Set(source.match(IDENTIFIER_RUN));
+}
 function sourceKey(source) {
 	return `${source.name ?? extractStringsFromNodes(source.nodes)}:${source.isExportable ?? false}:${source.isTypeOnly ?? false}`;
 }
@@ -546,7 +530,8 @@ function combineExports(exports) {
 */
 function combineImports(imports, exports, source) {
 	const exportedNames = new Set(exports.flatMap((e) => Array.isArray(e.name) ? e.name : e.name ? [e.name] : []));
-	const isUsed = (importName) => !source || source.includes(importName) || exportedNames.has(importName);
+	const identifiers = source && imports.length > INDEX_ABOVE_IMPORTS ? collectIdentifiers(source) : null;
+	const isUsed = (importName) => !source || identifiers?.has(importName) || source.includes(importName) || exportedNames.has(importName);
 	const importNameMemo = /* @__PURE__ */ new Map();
 	const canonicalizeName = (n) => {
 		if (typeof n === "string") return n;
@@ -1065,9 +1050,9 @@ function* getChildren(node, recurse) {
 * context. The result is a replacement node, a collected value, or `undefined`
 * when no callback is registered for the kind.
 *
-* Shared by `transform` and `collectLazy` so node-kind dispatch lives in one place.
+* Shared by `transform` and `collect` 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`.
+* the collected value type for `collect`.
 */
 function applyVisitor(node, visitor, parent) {
 	const key = VISITOR_KEY_BY_KIND[node.kind];
@@ -1125,12 +1110,12 @@ function transformChildren(node, visitor, recurse) {
 }
 /**
 * Lazy depth-first collection pass. Yields every non-null value returned by
-* the visitor callbacks. Use `collect` for the eager array form.
+* the visitor callbacks. Use `collectSync` for the eager array form.
 *
 * @example Collect every operationId
 * ```ts
 * const ids: string[] = []
-* for (const id of collectLazy<string>(root, {
+* for (const id of collect<string>(root, {
 *   operation(node) {
 *     return node.operationId
 *   },
@@ -1139,7 +1124,7 @@ function transformChildren(node, visitor, recurse) {
 * }
 * ```
 */
-function* collectLazy(node, options) {
+function* collect(node, options) {
 	const { depth, parent, ...visitor } = options;
 	yield* collectNode(node, visitor, (depth ?? visitorDepths.deep) === visitorDepths.deep, parent);
 }
@@ -1154,15 +1139,15 @@ function* collectNode(node, visitor, recurse, parent) {
 *
 * @example Collect every operationId
 * ```ts
-* const ids = collect<string>(root, {
+* const ids = collectSync<string>(root, {
 *   operation(node) {
 *     return node.operationId
 *   },
 * })
 * ```
 */
-function collect(node, options) {
-	return Array.from(collectLazy(node, options));
+function collectSync(node, options) {
+	return Array.from(collect(node, options));
 }
 //#endregion
 //#region src/defineMacro.ts
@@ -1202,7 +1187,7 @@ function chain({ macros, key, node, context }) {
 	for (const macro of macros) {
 		const callback = macro[key];
 		if (!callback) continue;
-		if (macro.when && !macro.when(current)) continue;
+		if (macro.match && !macro.match(current)) continue;
 		const next = callback(current, context);
 		if (next != null) current = next;
 	}
@@ -1329,54 +1314,7 @@ function createPrinter(build) {
 	};
 }
 //#endregion
-//#region src/utils/mergeAdjacentSchemas.ts
-/**
-* Merges a run of adjacent anonymous object members into one. Named or non-object members break the
-* run and pass through unchanged. The merge follows member order, so callers control which members
-* combine by where they place them in the sequence.
-*
-* @example
-* ```ts
-* const merged = [...mergeAdjacentObjectsLazy([objectA, objectB])]
-* ```
-*/
-function* mergeAdjacentObjectsLazy(members) {
-	let acc;
-	for (const member of members) {
-		const objectMember = narrowSchema(member, "object");
-		if (objectMember && !objectMember.name && acc !== void 0) {
-			const accObject = narrowSchema(acc, "object");
-			if (accObject && !accObject.name) {
-				acc = createSchema({
-					...accObject,
-					properties: [...accObject.properties ?? [], ...objectMember.properties ?? []]
-				});
-				continue;
-			}
-		}
-		if (acc !== void 0) yield acc;
-		acc = member;
-	}
-	if (acc !== void 0) yield acc;
-}
-//#endregion
 //#region src/utils/refs.ts
-const plainStringTypes = /* @__PURE__ */ new Set([
-	"string",
-	"uuid",
-	"email",
-	"url",
-	"datetime"
-]);
-/**
-* Returns the last path segment of a reference string.
-*
-* @example
-* `extractRefName('#/components/schemas/Pet') // 'Pet'`
-*/
-function extractRefName(ref) {
-	return ref.split("/").at(-1) ?? ref;
-}
 /**
 * Resolves the emitted name of the schema a ref node points at. Prefers `targetName` (set when
 * the referenced schema was renamed, e.g. to break a collision), then the last segment of `ref`,
@@ -1393,73 +1331,9 @@ function extractRefName(ref) {
 function resolveRefName(node) {
 	if (!node || node.type !== "ref") return null;
 	if (node.targetName) return node.targetName;
-	if (node.ref) return extractRefName(node.ref);
+	if (node.ref) return node.ref.split("/").at(-1) ?? node.ref;
 	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 Nested under a parent
-* `childName('Order', 'shipping_address') // 'OrderShippingAddress'`
-*
-* @example No parent
-* `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
-* `enumPropName('Order', 'status', 'enum') // 'OrderStatusEnum'`
-*/
-function enumPropName(parentName, propName, enumSuffix) {
-	return pascalCase([
-		parentName,
-		propName,
-		enumSuffix
-	].filter(Boolean).join(" "));
-}
-/**
-* Merges a ref node with its resolved schema, giving usage-site fields precedence.
-*
-* Every field set on the ref node except `kind`, `type`, `name`, `ref`, and `schema` overrides the
-* same field in the resolved `node.schema` (for example `description`, `nullable`, `readOnly`,
-* `deprecated`). Fields left `undefined` on the ref do not shadow the resolved schema. Non-ref
-* nodes and refs without a resolved `schema` are returned unchanged.
-*
-* @example
-* ```ts
-* 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
-	});
-}
-/**
-* 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;
-}
 //#endregion
 //#region src/utils/schemaGraph.ts
 /**
@@ -1467,7 +1341,7 @@ function isStringType(node) {
 */
 const collectSchemaRefs = memoize(/* @__PURE__ */ new WeakMap(), (node) => {
 	const refs = /* @__PURE__ */ new Set();
-	collect(node, { schema(child) {
+	collectSync(node, { schema(child) {
 		if (child.type === "ref") {
 			const name = resolveRefName(child);
 			if (name) refs.add(name);
@@ -1500,6 +1374,36 @@ function collectReferencedSchemaNames(node, out = /* @__PURE__ */ new Set()) {
 	for (const name of collectSchemaRefs(node)) out.add(name);
 	return out;
 }
+/**
+* Collects the de-duplicated target names of every pointer-carrying ref in a node's subtree, in
+* first-occurrence order. The walk is memoized by node identity, so the subtree is scanned once and
+* `resolver.imports` reads the same result across the ts, zod, and faker plugins instead of
+* re-scanning the same schema per plugin.
+*
+* Only refs that carry a `$ref` pointer count, so a synthesized ref pointing at a sibling in the
+* same file (a union member created by name) is left out. That leaves exactly the set
+* `resolver.imports` emits. This is the ordered, import-facing counterpart to
+* {@link collectReferencedSchemaNames}, which returns an unordered set for graph analysis.
+*
+* @example
+* ```ts
+* collectImportedRefNames(petSchema)
+* // ['Category', 'Tag']
+* ```
+*/
+const collectImportedRefNames = memoize(/* @__PURE__ */ new WeakMap(), (node) => {
+	const seen = /* @__PURE__ */ new Set();
+	const names = [];
+	collectSync(node, { schema(child) {
+		if (child.type !== "ref" || !child.ref) return;
+		const name = resolveRefName(child);
+		if (name && !seen.has(name)) {
+			seen.add(name);
+			names.push(name);
+		}
+	} });
+	return names;
+});
 function computeUsedSchemaNames(operations, schemas) {
 	const schemaMap = /* @__PURE__ */ new Map();
 	for (const schema of schemas) if (schema.name) schemaMap.set(schema.name, schema);
@@ -1512,7 +1416,7 @@ function computeUsedSchemaNames(operations, schemas) {
 			if (namedSchema) visitSchema(namedSchema);
 		}
 	}
-	for (const op of operations) for (const schema of collectLazy(op, {
+	for (const op of operations) for (const schema of collect(op, {
 		depth: "shallow",
 		schema: (node) => node
 	})) visitSchema(schema);
@@ -1542,12 +1446,24 @@ function collectUsedSchemaNames(operations, schemas) {
 	return computeUsedSchemaNames(operations, schemas);
 }
 const EMPTY_CIRCULAR_SET = /* @__PURE__ */ new Set();
-const findCircularSchemasMemo = memoize(/* @__PURE__ */ new WeakMap(), (schemas) => {
-	const graph = /* @__PURE__ */ new Map();
-	for (const schema of schemas) {
-		if (!schema.name) continue;
-		graph.set(schema.name, collectReferencedSchemaNames(schema));
-	}
+/**
+* Finds every schema that takes part in a circular dependency chain in a schema dependency graph
+* that maps each schema name to the names it references directly.
+*
+* Use this when the graph was already collected during another pass (e.g. the adapter's convert
+* walk), so the schema nodes are not swept a second time. `findCircularSchemas` builds the graph
+* from schema nodes and delegates here.
+*
+* @example
+* ```ts
+* const graph = new Map([
+*   ['Pet', new Set(['Category'])],
+*   ['Category', new Set(['Pet'])],
+* ])
+* findCircularSchemasFromGraph(graph) // Set { 'Pet', 'Category' }
+* ```
+*/
+function findCircularSchemasFromGraph(graph) {
 	const circular = /* @__PURE__ */ new Set();
 	for (const start of graph.keys()) {
 		const visited = /* @__PURE__ */ new Set();
@@ -1565,6 +1481,14 @@ const findCircularSchemasMemo = memoize(/* @__PURE__ */ new WeakMap(), (schemas)
 		}
 	}
 	return circular;
+}
+const findCircularSchemasMemo = memoize(/* @__PURE__ */ new WeakMap(), (schemas) => {
+	const graph = /* @__PURE__ */ new Map();
+	for (const schema of schemas) {
+		if (!schema.name) continue;
+		graph.set(schema.name, collectReferencedSchemaNames(schema));
+	}
+	return findCircularSchemasFromGraph(graph);
 });
 /**
 * Finds every schema that takes part in a circular dependency chain, including direct self-loops.
@@ -1579,174 +1503,6 @@ function findCircularSchemas(schemas) {
 	if (schemas.length === 0) return EMPTY_CIRCULAR_SET;
 	return findCircularSchemasMemo(schemas);
 }
-/**
-* Returns `true` when a schema, or anything nested inside it, references a circular schema.
-*
-* Pass `excludeName` to skip refs to a specific schema, which helps when self-references are handled
-* on their own. Pair it with `findCircularSchemas()` to decide where lazy wrappers go.
-*
-* @note Stops at the first matching circular ref.
-*/
-function containsCircularRef(node, { circularSchemas, excludeName }) {
-	if (!node || circularSchemas.size === 0) return false;
-	for (const _ of collectLazy(node, { schema(child) {
-		if (child.type !== "ref") return null;
-		const name = resolveRefName(child);
-		return name && name !== excludeName && circularSchemas.has(name) ? true : null;
-	} })) return true;
-	return false;
-}
-//#endregion
-//#region src/macros/macroDiscriminatorEnum.ts
-/**
-* Builds a macro that replaces a discriminator property's schema with a string enum of the given
-* values. Object schemas that lack the property are returned unchanged.
-*
-* @example
-* ```ts
-* const macro = macroDiscriminatorEnum({ propertyName: 'type', values: ['dog', 'cat'] })
-* const next = applyMacros(objectSchema, [macro], { depth: 'shallow' })
-* ```
-*/
-function macroDiscriminatorEnum({ propertyName, values, enumName }) {
-	return defineMacro({
-		name: "discriminator-enum",
-		schema(node) {
-			const objectNode = narrowSchema(node, "object");
-			if (!objectNode?.properties?.length) return void 0;
-			if (!objectNode.properties.some((prop) => prop.name === propertyName)) return void 0;
-			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
-						})
-					});
-				})
-			});
-		}
-	});
-}
-//#endregion
-//#region src/macros/macroEnumName.ts
-/**
-* Builds a macro that names an inline enum schema from its parent and property name. Boolean enums
-* are left anonymous. Non-enum nodes are returned unchanged.
-*
-* @example
-* ```ts
-* const macro = macroEnumName({ parentName: 'Pet', propName: 'status', enumSuffix: 'enum' })
-* const named = applyMacros(propSchema, [macro], { depth: 'shallow' })
-* ```
-*/
-function macroEnumName({ parentName, propName, enumSuffix }) {
-	return defineMacro({
-		name: "enum-name",
-		schema(node) {
-			const enumNode = narrowSchema(node, "enum");
-			if (enumNode?.primitive === "boolean") return {
-				...node,
-				name: null
-			};
-			if (enumNode) return {
-				...node,
-				name: enumPropName(parentName, propName, enumSuffix)
-			};
-		}
-	});
-}
-//#endregion
-//#region src/macros/macroRenameSchema.ts
-/**
-* Builds a macro that renames a schema consistently: the declaration (`name`) and every ref
-* pointing at it (`targetName`) change together, so imports and printed references stay in
-* sync. Renaming only one side by hand produces imports for files that are never generated.
-*
-* @example
-* `const macro = macroRenameSchema({ from: 'Order', to: 'StoreOrder' })`
-*/
-function macroRenameSchema({ from, to }) {
-	return defineMacro({
-		name: "rename-schema",
-		schema(node) {
-			const refNode = narrowSchema(node, "ref");
-			if (!refNode) return node.name === from ? {
-				...node,
-				name: to
-			} : void 0;
-			const renamesDeclaration = refNode.name === from;
-			const renamesTarget = resolveRefName(refNode) === from;
-			if (!renamesDeclaration && !renamesTarget) return void 0;
-			return {
-				...refNode,
-				...renamesDeclaration ? { name: to } : {},
-				...renamesTarget ? { targetName: to } : {}
-			};
-		}
-	});
-}
-//#endregion
-//#region src/macros/macroSimplifyUnion.ts
-/**
-* Scalar primitive schema types used for union simplification and type narrowing.
-*/
-const SCALAR_PRIMITIVE_TYPES = /* @__PURE__ */ new Set([
-	"string",
-	"number",
-	"integer",
-	"bigint",
-	"boolean"
-]);
-function isScalarPrimitive(type) {
-	return SCALAR_PRIMITIVE_TYPES.has(type);
-}
-/**
-* Filters union members, dropping enum members that a broader scalar primitive already covers.
-*/
-function simplifyUnionMembers(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;
-	});
-}
-/**
-* Removes union members a broader scalar primitive already covers, such as a multi-value string enum
-* sitting next to a plain `string`. Single-value enums are kept.
-*
-* @example
-* ```ts
-* const next = applyMacros(unionSchema, [macroSimplifyUnion], { depth: 'shallow' })
-* ```
-*/
-const macroSimplifyUnion = defineMacro({
-	name: "simplify-union",
-	schema(node) {
-		const unionNode = narrowSchema(node, "union");
-		if (!unionNode?.members?.length) return void 0;
-		const simplified = simplifyUnionMembers(unionNode.members);
-		if (simplified.length === unionNode.members.length) return void 0;
-		return {
-			...unionNode,
-			members: simplified
-		};
-	}
-});
 //#endregion
 //#region src/factory.ts
 var factory_exports = /* @__PURE__ */ __exportAll({
@@ -1801,37 +1557,27 @@ var exports_exports = /* @__PURE__ */ __exportAll({
 	applyMacros: () => applyMacros,
 	arrowFunctionDef: () => arrowFunctionDef,
 	breakDef: () => breakDef,
-	childName: () => childName,
 	collect: () => collect,
+	collectImportedRefNames: () => collectImportedRefNames,
+	collectSync: () => collectSync,
 	collectUsedSchemaNames: () => collectUsedSchemaNames,
-	combineExports: () => combineExports,
-	combineImports: () => combineImports,
-	combineSources: () => combineSources,
 	composeMacros: () => composeMacros,
 	constDef: () => constDef,
-	containsCircularRef: () => containsCircularRef,
 	contentDef: () => contentDef,
 	createPrinter: () => createPrinter,
 	defineMacro: () => defineMacro,
 	defineNode: () => defineNode,
-	enumPropName: () => enumPropName,
 	exportDef: () => exportDef,
-	extractRefName: () => extractRefName,
 	extractStringsFromNodes: () => extractStringsFromNodes,
 	factory: () => factory_exports,
 	fileDef: () => fileDef,
 	findCircularSchemas: () => findCircularSchemas,
+	findCircularSchemasFromGraph: () => findCircularSchemasFromGraph,
 	functionDef: () => functionDef,
 	importDef: () => importDef,
 	inputDef: () => inputDef,
 	isHttpOperationNode: () => isHttpOperationNode,
-	isStringType: () => isStringType,
 	jsxDef: () => jsxDef,
-	macroDiscriminatorEnum: () => macroDiscriminatorEnum,
-	macroEnumName: () => macroEnumName,
-	macroRenameSchema: () => macroRenameSchema,
-	macroSimplifyUnion: () => macroSimplifyUnion,
-	mergeAdjacentObjectsLazy: () => mergeAdjacentObjectsLazy,
 	narrowSchema: () => narrowSchema,
 	nodeDefs: () => nodeDefs,
 	operationDef: () => operationDef,
@@ -1845,12 +1591,11 @@ var exports_exports = /* @__PURE__ */ __exportAll({
 	schemaDef: () => schemaDef,
 	schemaTypes: () => schemaTypes,
 	sourceDef: () => sourceDef,
-	syncSchemaRef: () => syncSchemaRef,
 	textDef: () => textDef,
 	transform: () => transform,
 	typeDef: () => typeDef
 });
 //#endregion
-export { applyMacros, arrowFunctionDef, exports_exports as ast, breakDef, childName, collect, collectUsedSchemaNames, combineExports, combineImports, combineSources, composeMacros, constDef, containsCircularRef, contentDef, createPrinter, defineMacro, defineNode, enumPropName, exportDef, extractRefName, extractStringsFromNodes, factory_exports as factory, fileDef, findCircularSchemas, functionDef, importDef, inputDef, isHttpOperationNode, isStringType, jsxDef, macroDiscriminatorEnum, macroEnumName, macroRenameSchema, macroSimplifyUnion, mergeAdjacentObjectsLazy, narrowSchema, nodeDefs, operationDef, optionality, outputDef, parameterDef, propertyDef, requestBodyDef, resolveRefName, responseDef, schemaDef, schemaTypes, sourceDef, syncSchemaRef, textDef, transform, typeDef };
+export { applyMacros, arrowFunctionDef, exports_exports as ast, breakDef, collect, collectImportedRefNames, collectSync, collectUsedSchemaNames, composeMacros, constDef, contentDef, createPrinter, defineMacro, defineNode, exportDef, extractStringsFromNodes, factory_exports as factory, fileDef, findCircularSchemas, findCircularSchemasFromGraph, functionDef, importDef, inputDef, isHttpOperationNode, jsxDef, narrowSchema, nodeDefs, operationDef, optionality, outputDef, parameterDef, propertyDef, requestBodyDef, resolveRefName, responseDef, schemaDef, schemaTypes, sourceDef, textDef, transform, typeDef };
 
 //# sourceMappingURL=index.js.map