@kubb/ast 5.15.1 → 5.15.2

package/dist/index.js

@@ -251,22 +251,6 @@ function getChildren(node, recurse) {
 	});
 	return children;
 }
-/**
-* Visits each direct child node in the AST's traversal order.
-*
-* @example
-* ```ts
-* forEachChild(operationNode, (child) => {
-*   console.log(child.kind)
-* })
-* ```
-*/
-function forEachChild(node, visit) {
-	visitChildNodes(node, (child) => {
-		visit(child);
-		return false;
-	});
-}
 function visitChildNodes(node, visit) {
 	const keys = VISITOR_KEYS[node.kind];
 	if (!keys) return false;
@@ -290,23 +274,6 @@ function visitChildNodes(node, visit) {
 	return false;
 }
 /**
-* Visits each schema in a node's child tree in depth-first order. Includes `node` when it is a schema.
-*
-* @example
-* ```ts
-* forEachSchema(operationNode, (schema) => {
-*   console.log(schema.type)
-* })
-* ```
-*/
-function forEachSchema(node, visit) {
-	const walk = (current) => {
-		if (current.kind === nodeKinds.schema) visit(current);
-		forEachChild(current, walk);
-	};
-	walk(node);
-}
-/**
 * Finds the first schema that matches `predicate` in depth-first order. Set `followRefs` to include resolved ref targets.
 *
 * @example
@@ -495,6 +462,16 @@ function enforceWeight(enforce) {
 	return 1;
 }
 /**
+* Compares two `enforce` hints for `Array.prototype.sort`: `pre` first, unmarked next, `post`
+* last. Equal hints compare as `0`, so a stable sort keeps authored order within a bucket.
+*
+* @example
+* `plugins.sort((a, b) => compareEnforce(a.enforce, b.enforce))`
+*/
+function compareEnforce(a, b) {
+	return enforceWeight(a) - enforceWeight(b);
+}
+/**
 * Types a macro for inference and a single construction site, mirroring `defineExtension`.
 * Adds no runtime behavior.
 *
@@ -528,19 +505,11 @@ function chain({ macros, key, node, context }) {
 	return current === node ? void 0 : current;
 }
 /**
-* Folds an ordered list of macros into a single {@link Visitor} that `transform` (and the per-plugin
-* transform layer in `@kubb/core`) can run. Macros are stable-sorted by `enforce`, then applied
-* sequentially per node so later macros see earlier output. This differs from a plain visitor, which
-* has no names, ordering, or composition.
-*
-* @example
-* ```ts
-* const visitor = composeMacros([macroSimplifyUnion, macroDiscriminatorEnum])
-* const next = transform(root, visitor)
-* ```
+* Folds an ordered list of macros into a single {@link Visitor} for `transform`. Macros are
+* stable-sorted by `enforce`, then applied sequentially per node so later macros see earlier output.
 */
 function composeMacros(macros) {
-	const ordered = [...macros].sort((a, b) => enforceWeight(a.enforce) - enforceWeight(b.enforce));
+	const ordered = [...macros].sort((a, b) => compareEnforce(a.enforce, b.enforce));
 	const visitor = {};
 	for (const key of visitorKeys) {
 		if (!ordered.some((macro) => typeof macro[key] === "function")) continue;
@@ -662,11 +631,25 @@ function createPrinter(build) {
 	};
 }
 // src/utils/extractStringsFromNodes.ts
+const CODE_NODE_TEXT_FIELDS = {
+	Text: ["value"],
+	Jsx: ["value"],
+	Function: [
+		"params",
+		"generics",
+		"returnType"
+	],
+	ArrowFunction: [
+		"params",
+		"generics",
+		"returnType"
+	],
+	Const: ["type"]
+};
 /**
 * Extracts all string content from a `CodeNode` tree recursively.
 *
-* Collects text node values, identifier references in string fields (`params`, `generics`, `returnType`, `type`),
-* and nested node content. Used to build the full source string for import filtering.
+* Collects the text fields and nested node content, to build the source string for import filtering.
 */
 function extractStringsFromNodes(nodes) {
 	if (!nodes?.length) return "";
@@ -676,17 +659,15 @@ function extractStringsFromNodes(nodes) {
 			if (node) collected.push(node);
 			continue;
 		}
-		if (node.kind === nodeKinds.text || node.kind === nodeKinds.jsx) {
-			if (node.value) collected.push(node.value);
-			continue;
-		}
 		if (node.kind === nodeKinds.break) continue;
 		const parts = [];
-		if ("params" in node && node.params) parts.push(node.params);
-		if ("generics" in node && node.generics) parts.push(Array.isArray(node.generics) ? node.generics.join(", ") : node.generics);
-		if ("returnType" in node && node.returnType) parts.push(node.returnType);
-		if ("type" in node && typeof node.type === "string") parts.push(node.type);
-		const nested = extractStringsFromNodes(node.nodes);
+		const record = node;
+		for (const field of CODE_NODE_TEXT_FIELDS[node.kind] ?? []) {
+			const value = record[field];
+			if (Array.isArray(value)) parts.push(value.join(", "));
+			if (typeof value === "string" && value) parts.push(value);
+		}
+		const nested = "nodes" in node ? extractStringsFromNodes(node.nodes) : "";
 		if (nested) parts.push(nested);
 		if (parts.length) collected.push(parts.join("\n"));
 	}
@@ -954,17 +935,11 @@ function createFile(input) {
 }
 // src/utils/inline.ts
 /**
-* Whether every source of `file` is inline. Other files absorb such a file, so it is never written.
-*/
-function isVirtualFile(file) {
-	return file.sources.length > 0 && file.sources.every((source) => source.inline);
-}
-/**
-* Replaces every name a file imports from a virtual file (see {@link isVirtualFile}) with that name's
+* Replaces every name a file imports from a virtual file (one whose sources are all inline, so it is never written) with that name's
 * `inline.expression`, until no inline names are left. The definitions' own imports move to the importing file.
 */
 function inlineFiles(files, { language }) {
-	const virtualFiles = new Map(files.filter(isVirtualFile).map((file) => [file.path, file]));
+	const virtualFiles = new Map(files.filter((file) => file.sources.length > 0 && file.sources.every((source) => source.inline)).map((file) => [file.path, file]));
 	const result = {
 		files: [],
 		virtualPaths: [...virtualFiles.keys()],
@@ -1069,31 +1044,15 @@ function pickNames(imp, used) {
 function rewriteNodes(nodes, rewrite) {
 	return nodes?.map((node) => {
 		if (typeof node === "string") return rewrite(node);
-		switch (node.kind) {
-			case nodeKinds.break: return node;
-			case nodeKinds.text:
-			case nodeKinds.jsx: return {
-				...node,
-				value: rewrite(node.value)
-			};
-			case nodeKinds.function:
-			case nodeKinds.arrowFunction: return {
-				...node,
-				params: node.params && rewrite(node.params),
-				generics: Array.isArray(node.generics) ? node.generics.map(rewrite) : node.generics && rewrite(node.generics),
-				returnType: node.returnType && rewrite(node.returnType),
-				nodes: rewriteNodes(node.nodes, rewrite)
-			};
-			case nodeKinds.const: return {
-				...node,
-				type: node.type && rewrite(node.type),
-				nodes: rewriteNodes(node.nodes, rewrite)
-			};
-			default: return {
-				...node,
-				nodes: rewriteNodes(node.nodes, rewrite)
-			};
+		if (node.kind === nodeKinds.break) return node;
+		const next = { ...node };
+		for (const field of CODE_NODE_TEXT_FIELDS[node.kind] ?? []) {
+			const value = next[field];
+			if (Array.isArray(value)) next[field] = value.map(rewrite);
+			if (typeof value === "string" && value) next[field] = rewrite(value);
 		}
+		if ("nodes" in node && node.nodes) next.nodes = rewriteNodes(node.nodes, rewrite);
+		return next;
 	});
 }
 // src/utils/refs.ts
@@ -1199,49 +1158,42 @@ function isBareRef(node, keysToOmit) {
 }
 // ../../internals/utils/src/promise.ts
 /**
-* Wraps `factory` with a keyed cache backed by the provided store.
+* Returns the value cached under `key` in `store`, computing and storing it on the first call.
+* Pass a `WeakMap` for object keys, so an entry goes away with its key, or a `Map` for primitive
+* keys. A cached `null` or `undefined` counts as a hit, so `compute` runs once per key.
 *
-* Pass a `WeakMap` for object keys (results are GC-eligible when the key is
-* collected) or a `Map` for primitive keys. For multi-argument functions,
-* nest two `memoize` calls — the outer keyed by the first argument, the
-* inner (created once per outer miss) keyed by the second.
-*
-* Because the cache is owned by the caller, it can be shared, inspected, or
-* cleared independently of the memoized function.
-*
-* @example Single WeakMap key
-* ```ts
-* const cache = new WeakMap<SchemaNode, Set<string>>()
-* const getRefs = memoize(cache, (node) => collectRefs(node))
-* ```
-*
-* @example Single Map key (primitive)
-* ```ts
-* const cache = new Map<string, Resolver>()
-* const getResolver = memoize(cache, (name) => buildResolver(name))
-* ```
-*
-* @example Two-level (object + primitive)
-* ```ts
-* const outer = new WeakMap<Params[], Map<string, Params[]>>()
-* const fn = memoize(outer, (params) => memoize(new Map(), (key) => transform(params, key)))
-* fn(params)('camelcase')
-* ```
+* @example
+* `const refs = memo(refCache, node, () => collectRefs(node))`
 */
-function memoize(store, factory) {
-	return (key) => {
-		if (store.has(key)) return store.get(key);
-		const value = factory(key);
-		store.set(key, value);
-		return value;
-	};
+function memo(store, key, compute) {
+	if (store.has(key)) return store.get(key);
+	const value = compute();
+	store.set(key, value);
+	return value;
 }
 // src/utils/schemaGraph.ts
 /**
+* Walks a node's subtree once and lists every ref it holds, in traversal order, as the resolved
+* name plus whether the ref carries a `$ref` pointer. Memoized by node identity, so
+* `collectSchemaRefs` and `collectImportedRefNames` share one scan per schema.
+*/
+const refEntries = /* @__PURE__ */ new WeakMap();
+const schemaRefs = /* @__PURE__ */ new WeakMap();
+const importedRefNames = /* @__PURE__ */ new WeakMap();
+function collectRefEntries(node) {
+	return memo(refEntries, node, () => collectSync(node, { schema(child) {
+		if (child.type !== "ref") return void 0;
+		const name = resolveRefName(child);
+		return name ? {
+			name,
+			hasPointer: Boolean(child.ref)
+		} : void 0;
+	} }));
+}
+/**
 * Collects the names of every schema a node's subtree references, resolved with `resolveRefName`.
-* Each ref contributes its name only, so the schema it points to is never traversed. The walk is
-* memoized by node identity, which lets `findCircularSchemas` and `containsCircularRef` share one
-* scan per schema.
+* Each ref contributes its name only, so the schema it points to is never traversed. Memoized by
+* node identity, which lets `findCircularSchemas` and `containsCircularRef` share one scan per schema.
 *
 * @example
 * ```ts
@@ -1249,21 +1201,13 @@ function memoize(store, factory) {
 * // Set { 'Category', 'Tag' }
 * ```
 */
-const collectSchemaRefs = memoize(/* @__PURE__ */ new WeakMap(), (node) => {
-	const refs = /* @__PURE__ */ new Set();
-	collectSync(node, { schema(child) {
-		if (child.type === "ref") {
-			const name = resolveRefName(child);
-			if (name) refs.add(name);
-		}
-	} });
-	return refs;
-});
+function collectSchemaRefs(node) {
+	return memo(schemaRefs, node, () => new Set(collectRefEntries(node).map((entry) => entry.name)));
+}
 /**
 * 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.
+* first-occurrence order. Memoized by node identity, so `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
@@ -1275,19 +1219,9 @@ const collectSchemaRefs = memoize(/* @__PURE__ */ new WeakMap(), (node) => {
 * // ['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 collectImportedRefNames(node) {
+	return memo(importedRefNames, node, () => [...new Set(collectRefEntries(node).flatMap((entry) => entry.hasPointer ? [entry.name] : []))]);
+}
 /**
 * Collects the names of all top-level schemas transitively used by a set of operations.
 *
@@ -1326,23 +1260,17 @@ function collectUsedSchemaNames(operations, schemas) {
 	return result;
 }
 /**
-* 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.
+* Finds every schema that takes part in a circular dependency chain, including direct self-loops.
 *
-* 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.
+* Wrap the returned schema positions in a deferred construct (a lazy getter or `z.lazy(() => …)`) so
+* the generated code does not recurse forever. Refs are followed by name only, so the walk stays
+* linear in the size of the schema graph.
 *
-* @example
-* ```ts
-* const graph = new Map([
-*   ['Pet', new Set(['Category'])],
-*   ['Category', new Set(['Pet'])],
-* ])
-* findCircularSchemasFromGraph(graph) // Set { 'Pet', 'Category' }
-* ```
+* @note Call this once on the full graph, then check individual schemas with `containsCircularRef()`.
 */
-function findCircularSchemasFromGraph(graph) {
+function findCircularSchemas(schemas) {
+	const graph = /* @__PURE__ */ new Map();
+	for (const schema of schemas) if (schema.name) graph.set(schema.name, collectSchemaRefs(schema));
 	const circular = /* @__PURE__ */ new Set();
 	for (const start of graph.keys()) {
 		const visited = /* @__PURE__ */ new Set();
@@ -1361,20 +1289,6 @@ function findCircularSchemasFromGraph(graph) {
 	}
 	return circular;
 }
-/**
-* Finds every schema that takes part in a circular dependency chain, including direct self-loops.
-*
-* Wrap the returned schema positions in a deferred construct (a lazy getter or `z.lazy(() => …)`) so
-* the generated code does not recurse forever. Refs are followed by name only, so the walk stays
-* linear in the size of the schema graph.
-*
-* @note Call this once on the full graph, then check individual schemas with `containsCircularRef()`.
-*/
-function findCircularSchemas(schemas) {
-	const graph = /* @__PURE__ */ new Map();
-	for (const schema of schemas) if (schema.name) graph.set(schema.name, collectSchemaRefs(schema));
-	return findCircularSchemasFromGraph(graph);
-}
 // src/utils/schemaProperties.ts
 /**
 * Finds every matching property exposed by an object, resolved reference, or intersection.
@@ -1407,23 +1321,23 @@ function findCircularSchemas(schemas) {
 */
 function resolveSchemaProperties({ node, propertyName }) {
 	const properties = [];
+	walkSchema(node, "intersection", (current) => {
+		if (current.type !== "object") return;
+		const property = current.properties.find((candidate) => candidate.name === propertyName);
+		if (property) properties.push(property);
+	});
+	return properties;
+}
+function walkSchema(node, through, visit) {
 	const visited = /* @__PURE__ */ new WeakSet();
-	function visit(current) {
+	function walk(current) {
 		if (!current || visited.has(current)) return;
 		visited.add(current);
-		if (current.type === "object") {
-			const property = current.properties.find((candidate) => candidate.name === propertyName);
-			if (property) properties.push(property);
-			return;
-		}
-		if (current.type === "ref") {
-			visit(current.schema);
-			return;
-		}
-		if (current.type === "intersection") for (const member of current.members ?? []) visit(member);
+		visit(current);
+		if (current.type === "ref") return walk(current.schema);
+		if (current.type === through) for (const member of current.members ?? []) walk(member);
 	}
-	visit(node);
-	return properties;
+	walk(node);
 }
 /**
 * Reads the unique literal values represented by an enum, resolved reference, or union.
@@ -1439,35 +1353,18 @@ function resolveSchemaProperties({ node, propertyName }) {
 */
 function getSchemaLiteralValues(node) {
 	const values = /* @__PURE__ */ new Set();
-	const visited = /* @__PURE__ */ new WeakSet();
-	function visit(current) {
-		if (!current || visited.has(current)) return;
-		visited.add(current);
-		if (current.type === "enum") {
-			const enumValues = current.namedEnumValues?.map(({ value }) => value) ?? current.enumValues ?? [];
-			for (const value of enumValues) values.add(value);
-			return;
-		}
-		if (current.type === "ref") {
-			visit(current.schema);
-			return;
-		}
-		if (current.type === "union") for (const member of current.members ?? []) visit(member);
-	}
-	visit(node);
+	walkSchema(node, "union", (current) => {
+		if (current.type !== "enum") return;
+		for (const { value } of current.namedEnumValues ?? current.enumValues?.map((value) => ({ value })) ?? []) values.add(value);
+	});
 	return [...values];
 }
-function collectPropertyNames(node, visited = /* @__PURE__ */ new WeakSet()) {
-	if (visited.has(node)) return /* @__PURE__ */ new Set();
-	visited.add(node);
-	if (node.type === "object") return new Set(node.properties.map((property) => property.name));
-	if (node.type === "ref") return node.schema ? collectPropertyNames(node.schema, visited) : /* @__PURE__ */ new Set();
-	if (node.type === "intersection") {
-		const names = /* @__PURE__ */ new Set();
-		for (const member of node.members ?? []) for (const name of collectPropertyNames(member, visited)) names.add(name);
-		return names;
-	}
-	return /* @__PURE__ */ new Set();
+function collectPropertyNames(node) {
+	const names = /* @__PURE__ */ new Set();
+	walkSchema(node, "intersection", (current) => {
+		if (current.type === "object") for (const property of current.properties) names.add(property.name);
+	});
+	return names;
 }
 /**
 * Infers an implicit discriminator: a property every member exposes with a distinct single
@@ -1581,8 +1478,8 @@ function createJsx(value) {
 const createContent = nodeFactory(nodeKinds.content);
 // src/nodes/input.ts
 /**
-* Creates an `InputNode`, defaulting `schemas`/`operations` to empty arrays and `meta` to empty
-* name lists. Every call allocates fresh defaults so no two inputs share them.
+* Creates an `InputNode`, defaulting `schemas`/`operations` to empty arrays and `meta` to an empty
+* object. Every call allocates fresh defaults so no two inputs share them.
 *
 * @example
 * ```ts
@@ -1594,10 +1491,7 @@ function createInput(overrides = {}) {
 	return {
 		schemas: [],
 		operations: [],
-		meta: {
-			circularNames: /* @__PURE__ */ new Set(),
-			enumNames: /* @__PURE__ */ new Set()
-		},
+		meta: {},
 		...overrides,
 		kind: nodeKinds.input
 	};
@@ -1765,22 +1659,18 @@ var src_exports = /* @__PURE__ */ __exportAll({
 	collectSchemaRefs: () => collectSchemaRefs,
 	collectSync: () => collectSync,
 	collectUsedSchemaNames: () => collectUsedSchemaNames,
-	composeMacros: () => composeMacros,
+	compareEnforce: () => compareEnforce,
 	createPrinter: () => createPrinter,
 	defineMacro: () => defineMacro,
 	extractStringsFromNodes: () => extractStringsFromNodes,
 	factory: () => nodes_exports,
 	findCircularSchemas: () => findCircularSchemas,
-	findCircularSchemasFromGraph: () => findCircularSchemasFromGraph,
 	findSchema: () => findSchema,
-	forEachChild: () => forEachChild,
-	forEachSchema: () => forEachSchema,
 	getSchemaLiteralValues: () => getSchemaLiteralValues,
 	inferDiscriminatorPropertyName: () => inferDiscriminatorPropertyName,
 	inlineFiles: () => inlineFiles,
 	isBareRef: () => isBareRef,
 	isHttpOperationNode: () => isHttpOperationNode,
-	isVirtualFile: () => isVirtualFile,
 	mergeRefWithSchema: () => mergeRefWithSchema,
 	narrowSchema: () => narrowSchema,
 	nodeKinds: () => nodeKinds,
@@ -1792,6 +1682,6 @@ var src_exports = /* @__PURE__ */ __exportAll({
 	schemaTypes: () => schemaTypes,
 	transform: () => transform
 });
-export { applyMacros, src_exports as ast, collect, collectImportedRefNames, collectSchemaRefs, collectSync, collectUsedSchemaNames, composeMacros, createPrinter, defineMacro, extractStringsFromNodes, nodes_exports as factory, findCircularSchemas, findCircularSchemasFromGraph, findSchema, forEachChild, forEachSchema, getSchemaLiteralValues, inferDiscriminatorPropertyName, inlineFiles, isBareRef, isHttpOperationNode, isVirtualFile, mergeRefWithSchema, narrowSchema, nodeKinds, optionality, refName, resolveRef, resolveRefName, resolveSchemaProperties, schemaTypes, transform };
+export { applyMacros, src_exports as ast, collect, collectImportedRefNames, collectSchemaRefs, collectSync, collectUsedSchemaNames, compareEnforce, createPrinter, defineMacro, extractStringsFromNodes, nodes_exports as factory, findCircularSchemas, findSchema, getSchemaLiteralValues, inferDiscriminatorPropertyName, inlineFiles, isBareRef, isHttpOperationNode, mergeRefWithSchema, narrowSchema, nodeKinds, optionality, refName, resolveRef, resolveRefName, resolveSchemaProperties, schemaTypes, transform };
 
 //# sourceMappingURL=index.js.map