@kubb/ast 5.18.7 → 5.19.0

package/dist/index.cjs

@@ -46,11 +46,37 @@ let node_crypto = require("node:crypto");
 * `const refs = memo(refCache, node, () => collectRefs(node))`
 */
 function memo(store, key, compute) {
-	if (store.has(key)) return store.get(key);
+	const cached = store.get(key);
+	if (cached !== void 0 || store.has(key)) return cached;
 	const value = compute();
 	store.set(key, value);
 	return value;
 }
+function createStore({ weak, max } = {}) {
+	if (weak) return /* @__PURE__ */ new WeakMap();
+	const entry = /* @__PURE__ */ new Map();
+	if (max === void 0) return entry;
+	const set = (key, value) => {
+		if (entry.size >= max) entry.clear();
+		entry.set(key, value);
+	};
+	if (max !== 1) return {
+		has: (key) => entry.has(key),
+		get: (key) => entry.get(key),
+		set
+	};
+	const touch = (key) => {
+		if (!entry.has(key)) return false;
+		set(key, entry.get(key));
+		return true;
+	};
+	return {
+		has: touch,
+		get: (key) => touch(key) ? entry.get(key) : void 0,
+		set
+	};
+}
+memo.create = createStore;
 // src/constants.ts
 /**
 * Node kind discriminators used by every AST node (for example `node.kind === nodeKinds.text`).
@@ -321,14 +347,17 @@ function walkSchema(node, through, visit) {
 * ```
 */
 function getSchemaLiteralValues$1(node) {
-	const values = /* @__PURE__ */ new Set();
-	walkSchema(node, "union", (current) => {
-		if (current.type !== "enum") return;
-		for (const { value } of current.namedEnumValues ?? current.enumValues?.map((value) => ({ value })) ?? []) values.add(value);
+	return memo(literalValues, node, () => {
+		const values = /* @__PURE__ */ new Set();
+		walkSchema(node, "union", (current) => {
+			if (current.type !== "enum") return;
+			for (const { value } of current.namedEnumValues ?? current.enumValues?.map((value) => ({ value })) ?? []) values.add(value);
+		});
+		return Object.freeze([...values]);
 	});
-	return [...values];
 }
 __name(getSchemaLiteralValues$1, "getSchemaLiteralValues");
+const literalValues = memo.create({ weak: true });
 function collectPropertyNames(node) {
 	const names = /* @__PURE__ */ new Set();
 	walkSchema(node, "intersection", (current) => {
@@ -477,24 +506,6 @@ function isNode(value) {
 function isNodeRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-/**
-* Returns the immediate traversable children of `node`.
-*
-* @example
-* ```ts
-* const children = getChildren(operationNode, true)
-* // returns parameters, the request body, and responses
-* ```
-*/
-function getChildren(node, recurse) {
-	if (node.kind === nodeKinds$1.schema && !recurse) return [];
-	const children = [];
-	visitChildNodes(node, (child) => {
-		children.push(child);
-		return false;
-	});
-	return children;
-}
 function isNeverPrinted({ node, key }) {
 	if (node.kind !== nodeKinds$1.schema) return false;
 	if (key === "contains" && (node.type === "array" || node.type === "tuple")) return node.contains?.min === 0 && node.contains.max === void 0;
@@ -502,41 +513,63 @@ function isNeverPrinted({ node, key }) {
 	return false;
 }
 /**
+* Child keys of a schema walked with `checks: true`: the shape keys, then {@link schemaCheckKeys}.
+*/
+const SCHEMA_CHECK_VISITOR_KEYS = [...VISITOR_KEYS.Schema, ...schemaCheckKeys];
+function visitOnce(child, seen, visit) {
+	if (seen.first === void 0) {
+		seen.first = child;
+		return visit(child);
+	}
+	if (seen.first === child || seen.rest?.has(child)) return false;
+	(seen.rest ??= /* @__PURE__ */ new Set()).add(child);
+	return visit(child);
+}
+function visitRecord(value, seen, visit) {
+	for (const name in value) {
+		if (!Object.hasOwn(value, name)) continue;
+		const item = value[name];
+		if (isNode(item) && visitOnce(item, seen, visit)) return true;
+	}
+	return false;
+}
+/**
 * Calls `visit` for each direct child node and stops at the first call that returns `true`.
 * With `checks: true`, a schema's {@link schemaCheckKeys} fields are walked too, except checks that cannot fail.
 */
 function visitChildNodes(node, visit, { checks = false } = {}) {
-	const keys = checks && node.kind === nodeKinds$1.schema ? [...VISITOR_KEYS[node.kind] ?? [], ...schemaCheckKeys] : VISITOR_KEYS[node.kind];
+	const withChecks = checks && node.kind === nodeKinds$1.schema;
+	const keys = withChecks ? SCHEMA_CHECK_VISITOR_KEYS : VISITOR_KEYS[node.kind];
 	if (!keys) return false;
 	const record = node;
-	const seen = /* @__PURE__ */ new Set();
-	const visitOnce = (child) => !seen.has(child) && (seen.add(child), visit(child));
-	const visitRecord = (value) => {
-		for (const name in value) {
-			if (!Object.hasOwn(value, name)) continue;
-			const item = value[name];
-			if (isNode(item) && visitOnce(item)) return true;
-		}
-		return false;
-	};
+	let seen;
 	for (const key of keys) {
-		if (checks && isNeverPrinted({
+		const value = record[key];
+		if (value === void 0 || value === null) continue;
+		if (withChecks && isNeverPrinted({
 			node,
 			key
 		})) continue;
-		const value = record[key];
+		seen ??= {
+			first: void 0,
+			rest: void 0
+		};
 		if (Array.isArray(value)) {
-			for (const item of value) if (isNode(item) ? visitOnce(item) : isNodeRecord(item) && visitRecord(item)) return true;
+			for (const item of value) if (isNode(item) ? visitOnce(item, seen, visit) : isNodeRecord(item) && visitRecord(item, seen, visit)) return true;
 			continue;
 		}
 		if (isNode(value)) {
-			if (visitOnce(value)) return true;
+			if (visitOnce(value, seen, visit)) return true;
 			continue;
 		}
-		if (isNodeRecord(value) && visitRecord(value)) return true;
+		if (isNodeRecord(value) && visitRecord(value, seen, visit)) return true;
 	}
 	return false;
 }
+const notFound = {
+	found: void 0,
+	low: Number.POSITIVE_INFINITY
+};
 /**
 * Finds the first schema that matches `predicate` in depth-first order. Set `followRefs` to include resolved ref targets.
 *
@@ -547,28 +580,68 @@ function visitChildNodes(node, visit, { checks = false } = {}) {
 * })
 * ```
 */
-function findSchema$1(node, { predicate, followRefs = false }) {
-	const seen = followRefs ? /* @__PURE__ */ new WeakSet() : void 0;
-	const walk = (current) => {
-		if (current.kind === nodeKinds$1.schema) {
-			if (predicate(current)) return current;
-			if (seen) {
-				if (seen.has(current)) return void 0;
-				seen.add(current);
-				if (current.type === "ref" && current.schema) {
-					const found = walk(current.schema);
-					if (found) return found;
-				}
-			}
-		}
-		let found;
+function findSchema$1(node, { predicate, followRefs = false, cache }) {
+	const state = followRefs ? /* @__PURE__ */ new Map() : void 0;
+	const pending = [];
+	let order = 0;
+	const walkChildren = (current, initial) => {
+		let result = initial;
 		visitChildNodes(current, (child) => {
-			found = walk(child);
-			return found !== void 0;
+			const next = walk(child);
+			result = next.found || next.low < result.low ? next : result;
+			return next.found !== void 0;
 		});
-		if (found) return found;
+		return result;
+	};
+	const walkSchema = (current) => {
+		const target = state && current.type === "ref" && current.schema ? walk(current.schema) : notFound;
+		if (target.found) return target;
+		return walkChildren(current, target);
 	};
-	return walk(node);
+	const walk = (current) => {
+		if (current.kind !== nodeKinds$1.schema) return walkChildren(current, notFound);
+		const cached = cache?.get(current);
+		if (cached === null) return notFound;
+		if (cached) return {
+			found: cached,
+			low: Number.POSITIVE_INFINITY
+		};
+		if (predicate(current)) {
+			cache?.set(current, current);
+			return {
+				found: current,
+				low: Number.POSITIVE_INFINITY
+			};
+		}
+		const known = state?.get(current);
+		if (known !== void 0) return {
+			found: void 0,
+			low: known
+		};
+		const index = order++;
+		const start = pending.length;
+		state?.set(current, index);
+		const result = walkSchema(current);
+		if (result.found) {
+			cache?.set(current, result.found);
+			return result;
+		}
+		if (!state) {
+			cache?.set(current, null);
+			return notFound;
+		}
+		if (result.low < index) {
+			state.set(current, result.low);
+			pending.push(current);
+			return result;
+		}
+		for (const done of [...pending.splice(start), current]) {
+			state.set(done, Number.POSITIVE_INFINITY);
+			cache?.set(done, null);
+		}
+		return notFound;
+	};
+	return walk(node).found;
 }
 __name(findSchema$1, "findSchema");
 /**
@@ -632,15 +705,16 @@ function transformChildren(node, visitor, recurse) {
 	if (!keys) return node;
 	const record = node;
 	let updates;
-	const done = /* @__PURE__ */ new Map();
+	let done;
 	const transformOnce = (child) => {
+		done ??= /* @__PURE__ */ new Map();
 		const next = done.get(child) ?? transformNode(child, visitor, recurse, node);
 		done.set(child, next);
 		return next;
 	};
 	for (const key of keys) {
-		if (!(key in record)) continue;
 		const value = record[key];
+		if (value === void 0 || value === null) continue;
 		if (Array.isArray(value)) {
 			let mapped;
 			for (const [i, item] of value.entries()) {
@@ -697,7 +771,11 @@ __name(collect$1, "collect");
 function collectInto(node, visitor, recurse, parent, result) {
 	const v = applyVisitor(node, visitor, parent);
 	if (v != null) result.push(v);
-	for (const child of getChildren(node, recurse)) collectInto(child, visitor, recurse, node, result);
+	if (node.kind === nodeKinds$1.schema && !recurse) return;
+	visitChildNodes(node, (child) => {
+		collectInto(child, visitor, recurse, node, result);
+		return false;
+	});
 }
 // src/utils/refs.ts
 /**
@@ -706,21 +784,17 @@ function collectInto(node, visitor, recurse, parent, result) {
 * (RFC 6901), so `a~1b~0c` names the component `a/b~c`.
 */
 function refName$1(ref) {
-	const cached = refNames.get(ref);
-	if (cached !== void 0) return cached;
-	const segment = ref.split("/").at(-1) ?? ref;
-	let decoded = segment;
-	try {
-		decoded = decodeURIComponent(segment);
-	} catch {}
-	const name = decoded.replaceAll("~1", "/").replaceAll("~0", "~");
-	if (refNames.size >= memoLimit) refNames.clear();
-	refNames.set(ref, name);
-	return name;
+	return memo(refNames, ref, () => {
+		const segment = ref.split("/").at(-1) ?? ref;
+		let decoded = segment;
+		try {
+			decoded = decodeURIComponent(segment);
+		} catch {}
+		return decoded.replaceAll("~1", "/").replaceAll("~0", "~");
+	});
 }
 __name(refName$1, "refName");
-const refNames = /* @__PURE__ */ new Map();
-const memoLimit = 1e5;
+const refNames = memo.create({ max: 1e5 });
 /**
 * 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`,
@@ -806,11 +880,11 @@ function isBareRef$1(node, keysToOmit) {
 }
 __name(isBareRef$1, "isBareRef");
 // src/utils/schemaGraph.ts
-const refEntries = /* @__PURE__ */ new WeakMap();
-const checkRefEntries = /* @__PURE__ */ new WeakMap();
-const schemaRefs = /* @__PURE__ */ new WeakMap();
-const importedRefNames = /* @__PURE__ */ new WeakMap();
-const importedCheckRefNames = /* @__PURE__ */ new WeakMap();
+const refEntries = memo.create({ weak: true });
+const checkRefEntries = memo.create({ weak: true });
+const schemaRefs = memo.create({ weak: true });
+const importedRefNames = memo.create({ weak: true });
+const importedCheckRefNames = memo.create({ weak: true });
 /**
 * 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 per node and per `checks` mode, so
@@ -1032,27 +1106,25 @@ function getBaseURL(server) {
 	if (!server || server.variables || server.url.includes("{") || !server.url.includes("://")) return void 0;
 	return URL.canParse(server.url) ? server.url : void 0;
 }
-const parametersByNode = /* @__PURE__ */ new WeakMap();
+const parametersByNode = memo.create({ weak: true });
 /** The operation's parameters by location, with a `querystring` parameter in `query`. A repeated name keeps its first parameter. */
 function groupParameters(node) {
-	const cached = parametersByNode.get(node);
-	if (cached) return cached;
-	const group = (...locations) => {
-		const seen = /* @__PURE__ */ new Set();
-		return locations.flatMap((location) => node.parameters.filter((param) => {
-			if (param.in !== location || seen.has(param.name)) return false;
-			seen.add(param.name);
-			return true;
-		}));
-	};
-	const groups = {
-		path: group("path"),
-		query: group("query", "querystring"),
-		header: group("header"),
-		cookie: group("cookie")
-	};
-	parametersByNode.set(node, groups);
-	return groups;
+	return memo(parametersByNode, node, () => {
+		const group = (...locations) => {
+			const seen = /* @__PURE__ */ new Set();
+			return locations.flatMap((location) => node.parameters.filter((param) => {
+				if (param.in !== location || seen.has(param.name)) return false;
+				seen.add(param.name);
+				return true;
+			}));
+		};
+		return {
+			path: group("path"),
+			query: group("query", "querystring"),
+			header: group("header"),
+			cookie: group("cookie")
+		};
+	});
 }
 // src/nodes/schema.ts
 /**
@@ -1458,12 +1530,11 @@ function combineImports(imports, exports, source) {
 	const exportedNames = new Set(exports.flatMap((e) => Array.isArray(e.name) ? e.name : e.name ? [e.name] : []));
 	const identifiers = source && imports.length > INDEX_ABOVE_IMPORTS ? new Set(source.match(IDENTIFIER_RUN)) : null;
 	const isUsed = (importName) => !source || identifiers?.has(importName) || source.includes(importName) || exportedNames.has(importName);
-	const importNameMemo = /* @__PURE__ */ new Map();
+	const importNameMemo = memo.create();
 	const canonicalizeName = (n) => {
 		if (typeof n === "string") return n;
 		const key = `${n.propertyName}:${n.name ?? ""}`;
-		if (!importNameMemo.has(key)) importNameMemo.set(key, n);
-		return importNameMemo.get(key);
+		return memo(importNameMemo, key, () => n);
 	};
 	const pathsWithUsedNamedImport = /* @__PURE__ */ new Set();
 	for (const node of imports) if (Array.isArray(node.name) && node.name.some((item) => isUsed(importLocalName(item)))) pathsWithUsedNamedImport.add(node.path);