@kubb/adapter-oas 5.12.4 → 5.12.6

package/dist/index.js

@@ -3,6 +3,7 @@ import { Diagnostics, ast, childName, enumPropName, extractRefName, macroDiscrim
 import { access, readFile } from "node:fs/promises";
 import { upgrade } from "@scalar/openapi-upgrader";
 import { bundle } from "api-ref-bundler";
+import { CORE_SCHEMA, load } from "js-yaml";
 import * as yaml from "yaml";
 import { parse } from "yaml";
 //#endregion
@@ -13,7 +14,7 @@ var compatibility = {
 };
 //#endregion
 //#region package.json
-var version = "5.12.4";
+var version = "5.12.6";
 //#endregion
 //#region src/constants.ts
 /**
@@ -221,12 +222,23 @@ function patchDiscriminatorNode(node, entry) {
 *
 * When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
 */
-function toCamelOrPascal(text, pascal) {
+function convert(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, "");
 }
+const cache = /* @__PURE__ */ new Map();
+const cacheLimit = 1e4;
+function toCamelOrPascal(text, pascal) {
+	const key = `${pascal ? "P" : "c"}${text}`;
+	const cached = cache.get(key);
+	if (cached !== void 0) return cached;
+	const result = convert(text, pascal);
+	if (cache.size >= cacheLimit) cache.clear();
+	cache.set(key, result);
+	return result;
+}
 /**
 * Converts `text` to PascalCase.
 *
@@ -395,29 +407,28 @@ async function readSource(sourcePath) {
 /**
 * Reads and parses one source file or URL referenced during bundling: YAML/JSON is parsed into an
 * object, Markdown is returned as-is (bundled inline rather than dereferenced).
-*
-* JSON is valid YAML, so `yaml`'s `parse` handles both, but its general-purpose parser (comments,
-* anchors, block scalars, multi-document streams) does much more work than `JSON.parse` needs to.
-* `JSON.parse` runs first and fails fast on the first non-JSON character, so a real YAML document
-* falls through to `parse` at negligible cost.
 */
 async function resolveSource(sourcePath) {
 	const data = await readSource(sourcePath);
 	if (sourcePath.toLowerCase().endsWith(".md")) return data;
-	try {
-		return JSON.parse(data);
-	} catch {
-		return parseYaml(data, {
-			origin: sourcePath,
-			help: "Fix the syntax at the reported line, or check that `input` points at the spec and not an HTML page."
-		});
-	}
+	return parseYaml(data, {
+		origin: sourcePath,
+		help: "Fix the syntax at the reported line, or check that `input` points at the spec and not an HTML page."
+	});
 }
 /**
 * Parses a YAML (or JSON) spec. A syntax error throws `KUBB_INVALID_DOCUMENT` naming `origin`,
 * with the parser message, which keeps the line and column.
+*
+* JSON is valid YAML, so one parser handles both. `js-yaml` parses about ten times faster than
+* `yaml`, and unlike `JSON.parse` it rejects duplicate keys instead of keeping the last one. Its
+* core schema keeps timestamps as strings and `<<` as a plain key, as `yaml` does for YAML 1.2.
 */
 function parseYaml(data, { origin, help }) {
+	try {
+		const document = load(data, { schema: CORE_SCHEMA });
+		if (document !== void 0) return document;
+	} catch {}
 	try {
 		return parse(data);
 	} catch (error) {
@@ -2296,7 +2307,7 @@ function visit(node, pointer) {
 }
 //#endregion
 //#region src/sourceLocator.ts
-const cache = /* @__PURE__ */ new Map();
+let cached;
 const toRange = ([start, end]) => ({
 	start,
 	end
@@ -2339,11 +2350,12 @@ function findRefUsage(document, ref) {
 */
 const locate = (source, location) => {
 	if (!("pointer" in location)) return void 0;
-	if (!cache.has(source)) {
-		cache.clear();
-		cache.set(source, yaml.parseDocument(source));
-	}
-	const document = cache.get(source);
+	if (cached?.source === source) cached.source = source;
+	else cached = {
+		source,
+		document: yaml.parseDocument(source)
+	};
+	const { document } = cached;
 	return findPointer(document, location.pointer) ?? ("ref" in location && location.ref ? findRefUsage(document, location.ref) : void 0);
 };
 //#endregion