@kubb/ast 5.18.8 → 5.19.0

package/dist/index.cjs

@@ -52,14 +52,19 @@ function memo(store, key, compute) {
 	store.set(key, value);
 	return value;
 }
-function createStore({ type }) {
-	if (type === "weak") return /* @__PURE__ */ new WeakMap();
+function createStore({ weak, max } = {}) {
+	if (weak) return /* @__PURE__ */ new WeakMap();
 	const entry = /* @__PURE__ */ new Map();
-	if (type === "map") return entry;
+	if (max === void 0) return entry;
 	const set = (key, value) => {
-		entry.clear();
+		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));
@@ -342,19 +347,17 @@ 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 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]);
 	});
-	const result = Object.freeze([...values]);
-	literalValues.set(node, result);
-	return result;
 }
 __name(getSchemaLiteralValues$1, "getSchemaLiteralValues");
-const literalValues = /* @__PURE__ */ new WeakMap();
+const literalValues = memo.create({ weak: true });
 function collectPropertyNames(node) {
 	const names = /* @__PURE__ */ new Set();
 	walkSchema(node, "intersection", (current) => {
@@ -781,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`,
@@ -881,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
@@ -1107,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
 /**
@@ -1533,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);