@kubb/ast 5.18.6 → 5.18.8

package/dist/index.cjs

@@ -10,14 +10,14 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __exportAll = (all, no_symbols) => {
-	let target = {};
+var __exportAll = (all, flags) => {
+	let target = Object.setPrototypeOf({}, null);
 	for (var name in all) __defProp(target, name, {
 		get: all[name],
 		enumerable: true
 	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
+	if (!(flags & 1)) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return flags & 2 ? target : Object.preventExtensions(target);
 };
 var __copyProps = (to, from, except, desc) => {
 	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
@@ -46,11 +46,32 @@ 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({ type }) {
+	if (type === "weak") return /* @__PURE__ */ new WeakMap();
+	const entry = /* @__PURE__ */ new Map();
+	if (type === "map") return entry;
+	const set = (key, value) => {
+		entry.clear();
+		entry.set(key, value);
+	};
+	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 +342,19 @@ function walkSchema(node, through, visit) {
 * ```
 */
 function getSchemaLiteralValues$1(node) {
+	const cached = literalValues.get(node);
+	if (cached) return cached;
 	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 [...values];
+	const result = Object.freeze([...values]);
+	literalValues.set(node, result);
+	return result;
 }
 __name(getSchemaLiteralValues$1, "getSchemaLiteralValues");
+const literalValues = /* @__PURE__ */ new WeakMap();
 function collectPropertyNames(node) {
 	const names = /* @__PURE__ */ new Set();
 	walkSchema(node, "intersection", (current) => {
@@ -477,24 +503,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 +510,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 +577,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 +702,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 +768,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
 /**