fumadocs-openapi 10.8.4 → 10.8.5

package/dist/node_modules/.pnpm/fast-uri@3.1.0/node_modules/fast-uri/lib/utils.js

@@ -0,0 +1,282 @@
+import { __commonJSMin } from "../../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/fast-uri@3.1.0/node_modules/fast-uri/lib/utils.js
+var require_utils = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {(value: string) => boolean} */
+	const isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
+	/** @type {(value: string) => boolean} */
+	const isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
+	/**
+	* @param {Array<string>} input
+	* @returns {string}
+	*/
+	function stringArrayToHexStripped(input) {
+		let acc = "";
+		let code = 0;
+		let i = 0;
+		for (i = 0; i < input.length; i++) {
+			code = input[i].charCodeAt(0);
+			if (code === 48) continue;
+			if (!(code >= 48 && code <= 57 || code >= 65 && code <= 70 || code >= 97 && code <= 102)) return "";
+			acc += input[i];
+			break;
+		}
+		for (i += 1; i < input.length; i++) {
+			code = input[i].charCodeAt(0);
+			if (!(code >= 48 && code <= 57 || code >= 65 && code <= 70 || code >= 97 && code <= 102)) return "";
+			acc += input[i];
+		}
+		return acc;
+	}
+	/**
+	* @typedef {Object} GetIPV6Result
+	* @property {boolean} error - Indicates if there was an error parsing the IPv6 address.
+	* @property {string} address - The parsed IPv6 address.
+	* @property {string} [zone] - The zone identifier, if present.
+	*/
+	/**
+	* @param {string} value
+	* @returns {boolean}
+	*/
+	const nonSimpleDomain = RegExp.prototype.test.bind(/[^!"$&'()*+,\-.;=_`a-z{}~]/u);
+	/**
+	* @param {Array<string>} buffer
+	* @returns {boolean}
+	*/
+	function consumeIsZone(buffer) {
+		buffer.length = 0;
+		return true;
+	}
+	/**
+	* @param {Array<string>} buffer
+	* @param {Array<string>} address
+	* @param {GetIPV6Result} output
+	* @returns {boolean}
+	*/
+	function consumeHextets(buffer, address, output) {
+		if (buffer.length) {
+			const hex = stringArrayToHexStripped(buffer);
+			if (hex !== "") address.push(hex);
+			else {
+				output.error = true;
+				return false;
+			}
+			buffer.length = 0;
+		}
+		return true;
+	}
+	/**
+	* @param {string} input
+	* @returns {GetIPV6Result}
+	*/
+	function getIPV6(input) {
+		let tokenCount = 0;
+		const output = {
+			error: false,
+			address: "",
+			zone: ""
+		};
+		/** @type {Array<string>} */
+		const address = [];
+		/** @type {Array<string>} */
+		const buffer = [];
+		let endipv6Encountered = false;
+		let endIpv6 = false;
+		let consume = consumeHextets;
+		for (let i = 0; i < input.length; i++) {
+			const cursor = input[i];
+			if (cursor === "[" || cursor === "]") continue;
+			if (cursor === ":") {
+				if (endipv6Encountered === true) endIpv6 = true;
+				if (!consume(buffer, address, output)) break;
+				if (++tokenCount > 7) {
+					output.error = true;
+					break;
+				}
+				if (i > 0 && input[i - 1] === ":") endipv6Encountered = true;
+				address.push(":");
+				continue;
+			} else if (cursor === "%") {
+				if (!consume(buffer, address, output)) break;
+				consume = consumeIsZone;
+			} else {
+				buffer.push(cursor);
+				continue;
+			}
+		}
+		if (buffer.length) if (consume === consumeIsZone) output.zone = buffer.join("");
+		else if (endIpv6) address.push(buffer.join(""));
+		else address.push(stringArrayToHexStripped(buffer));
+		output.address = address.join("");
+		return output;
+	}
+	/**
+	* @typedef {Object} NormalizeIPv6Result
+	* @property {string} host - The normalized host.
+	* @property {string} [escapedHost] - The escaped host.
+	* @property {boolean} isIPV6 - Indicates if the host is an IPv6 address.
+	*/
+	/**
+	* @param {string} host
+	* @returns {NormalizeIPv6Result}
+	*/
+	function normalizeIPv6(host) {
+		if (findToken(host, ":") < 2) return {
+			host,
+			isIPV6: false
+		};
+		const ipv6 = getIPV6(host);
+		if (!ipv6.error) {
+			let newHost = ipv6.address;
+			let escapedHost = ipv6.address;
+			if (ipv6.zone) {
+				newHost += "%" + ipv6.zone;
+				escapedHost += "%25" + ipv6.zone;
+			}
+			return {
+				host: newHost,
+				isIPV6: true,
+				escapedHost
+			};
+		} else return {
+			host,
+			isIPV6: false
+		};
+	}
+	/**
+	* @param {string} str
+	* @param {string} token
+	* @returns {number}
+	*/
+	function findToken(str, token) {
+		let ind = 0;
+		for (let i = 0; i < str.length; i++) if (str[i] === token) ind++;
+		return ind;
+	}
+	/**
+	* @param {string} path
+	* @returns {string}
+	*
+	* @see https://datatracker.ietf.org/doc/html/rfc3986#section-5.2.4
+	*/
+	function removeDotSegments(path) {
+		let input = path;
+		const output = [];
+		let nextSlash = -1;
+		let len = 0;
+		while (len = input.length) {
+			if (len === 1) if (input === ".") break;
+			else if (input === "/") {
+				output.push("/");
+				break;
+			} else {
+				output.push(input);
+				break;
+			}
+			else if (len === 2) {
+				if (input[0] === ".") {
+					if (input[1] === ".") break;
+					else if (input[1] === "/") {
+						input = input.slice(2);
+						continue;
+					}
+				} else if (input[0] === "/") {
+					if (input[1] === "." || input[1] === "/") {
+						output.push("/");
+						break;
+					}
+				}
+			} else if (len === 3) {
+				if (input === "/..") {
+					if (output.length !== 0) output.pop();
+					output.push("/");
+					break;
+				}
+			}
+			if (input[0] === ".") {
+				if (input[1] === ".") {
+					if (input[2] === "/") {
+						input = input.slice(3);
+						continue;
+					}
+				} else if (input[1] === "/") {
+					input = input.slice(2);
+					continue;
+				}
+			} else if (input[0] === "/") {
+				if (input[1] === ".") {
+					if (input[2] === "/") {
+						input = input.slice(2);
+						continue;
+					} else if (input[2] === ".") {
+						if (input[3] === "/") {
+							input = input.slice(3);
+							if (output.length !== 0) output.pop();
+							continue;
+						}
+					}
+				}
+			}
+			if ((nextSlash = input.indexOf("/", 1)) === -1) {
+				output.push(input);
+				break;
+			} else {
+				output.push(input.slice(0, nextSlash));
+				input = input.slice(nextSlash);
+			}
+		}
+		return output.join("");
+	}
+	/**
+	* @param {import('../types/index').URIComponent} component
+	* @param {boolean} esc
+	* @returns {import('../types/index').URIComponent}
+	*/
+	function normalizeComponentEncoding(component, esc) {
+		const func = esc !== true ? escape : unescape;
+		if (component.scheme !== void 0) component.scheme = func(component.scheme);
+		if (component.userinfo !== void 0) component.userinfo = func(component.userinfo);
+		if (component.host !== void 0) component.host = func(component.host);
+		if (component.path !== void 0) component.path = func(component.path);
+		if (component.query !== void 0) component.query = func(component.query);
+		if (component.fragment !== void 0) component.fragment = func(component.fragment);
+		return component;
+	}
+	/**
+	* @param {import('../types/index').URIComponent} component
+	* @returns {string|undefined}
+	*/
+	function recomposeAuthority(component) {
+		const uriTokens = [];
+		if (component.userinfo !== void 0) {
+			uriTokens.push(component.userinfo);
+			uriTokens.push("@");
+		}
+		if (component.host !== void 0) {
+			let host = unescape(component.host);
+			if (!isIPv4(host)) {
+				const ipV6res = normalizeIPv6(host);
+				if (ipV6res.isIPV6 === true) host = `[${ipV6res.escapedHost}]`;
+				else host = component.host;
+			}
+			uriTokens.push(host);
+		}
+		if (typeof component.port === "number" || typeof component.port === "string") {
+			uriTokens.push(":");
+			uriTokens.push(String(component.port));
+		}
+		return uriTokens.length ? uriTokens.join("") : void 0;
+	}
+	module.exports = {
+		nonSimpleDomain,
+		recomposeAuthority,
+		normalizeComponentEncoding,
+		removeDotSegments,
+		isIPv4,
+		isUUID,
+		normalizeIPv6,
+		stringArrayToHexStripped
+	};
+}));
+//#endregion
+export default require_utils();
+export { require_utils };

package/dist/node_modules/.pnpm/json-schema-traverse@1.0.0/node_modules/json-schema-traverse/index.js

@@ -0,0 +1,78 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/json-schema-traverse@1.0.0/node_modules/json-schema-traverse/index.js
+var require_json_schema_traverse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var traverse = module.exports = function(schema, opts, cb) {
+		if (typeof opts == "function") {
+			cb = opts;
+			opts = {};
+		}
+		cb = opts.cb || cb;
+		var pre = typeof cb == "function" ? cb : cb.pre || function() {};
+		var post = cb.post || function() {};
+		_traverse(opts, pre, post, schema, "", schema);
+	};
+	traverse.keywords = {
+		additionalItems: true,
+		items: true,
+		contains: true,
+		additionalProperties: true,
+		propertyNames: true,
+		not: true,
+		if: true,
+		then: true,
+		else: true
+	};
+	traverse.arrayKeywords = {
+		items: true,
+		allOf: true,
+		anyOf: true,
+		oneOf: true
+	};
+	traverse.propsKeywords = {
+		$defs: true,
+		definitions: true,
+		properties: true,
+		patternProperties: true,
+		dependencies: true
+	};
+	traverse.skipKeywords = {
+		default: true,
+		enum: true,
+		const: true,
+		required: true,
+		maximum: true,
+		minimum: true,
+		exclusiveMaximum: true,
+		exclusiveMinimum: true,
+		multipleOf: true,
+		maxLength: true,
+		minLength: true,
+		pattern: true,
+		format: true,
+		maxItems: true,
+		minItems: true,
+		uniqueItems: true,
+		maxProperties: true,
+		minProperties: true
+	};
+	function _traverse(opts, pre, post, schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) {
+		if (schema && typeof schema == "object" && !Array.isArray(schema)) {
+			pre(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
+			for (var key in schema) {
+				var sch = schema[key];
+				if (Array.isArray(sch)) {
+					if (key in traverse.arrayKeywords) for (var i = 0; i < sch.length; i++) _traverse(opts, pre, post, sch[i], jsonPtr + "/" + key + "/" + i, rootSchema, jsonPtr, key, schema, i);
+				} else if (key in traverse.propsKeywords) {
+					if (sch && typeof sch == "object") for (var prop in sch) _traverse(opts, pre, post, sch[prop], jsonPtr + "/" + key + "/" + escapeJsonPtr(prop), rootSchema, jsonPtr, key, schema, prop);
+				} else if (key in traverse.keywords || opts.allKeys && !(key in traverse.skipKeywords)) _traverse(opts, pre, post, sch, jsonPtr + "/" + key, rootSchema, jsonPtr, key, schema);
+			}
+			post(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
+		}
+	}
+	function escapeJsonPtr(str) {
+		return str.replace(/~/g, "~0").replace(/\//g, "~1");
+	}
+}));
+//#endregion
+export default require_json_schema_traverse();
+export { require_json_schema_traverse };

package/dist/playground/schema.d.ts

@@ -1,7 +1,5 @@
 import { ReactNode } from "react";
-import { Ajv2020 } from "ajv/dist/2020.js";
 import { FieldKey } from "@fumari/stf";
-
 //#region src/playground/schema.d.ts
 interface SchemaScope {
   /**

package/dist/playground/schema.js

@@ -1,13 +1,14 @@
+import { require__2020 } from "../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/2020.js";
 import { mergeAllOf } from "../utils/schema/merge.js";
 import { sample } from "../utils/schema/sample.js";
 import { schemaToString } from "../utils/schema/to-string.js";
 import { dereferenceSwallow } from "../utils/schema/dereference.js";
 import { createContext, use, useMemo } from "react";
 import { jsx } from "react/jsx-runtime";
-import { Ajv2020 } from "ajv/dist/2020.js";
 import { useDataEngine, useFieldValue, useNamespace } from "@fumari/stf";
 import { stringifyFieldKey } from "@fumari/stf/lib/utils";
 //#region src/playground/schema.tsx
+var import__2020 = require__2020();
 const SchemaContext = createContext(void 0);
 const anyFields = {
 	type: [
@@ -21,7 +22,7 @@ const anyFields = {
 	additionalProperties: true
 };
 function SchemaProvider({ doc, readOnly, writeOnly, children }) {
-	const ajv = useMemo(() => new Ajv2020({
+	const ajv = useMemo(() => new import__2020.Ajv2020({
 		strict: false,
 		validateSchema: false,
 		validateFormats: false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fumadocs-openapi",
-  "version": "10.8.4",
+  "version": "10.8.5",
   "description": "Generate MDX docs for your OpenAPI spec",
   "keywords": [
     "Docs",
@@ -45,7 +45,6 @@
     "@radix-ui/react-dialog": "^1.1.15",
     "@radix-ui/react-select": "^2.2.6",
     "@radix-ui/react-slot": "^1.2.4",
-    "ajv": "^8.20.0",
     "chokidar": "^5.0.0",
     "class-variance-authority": "^0.7.1",
     "github-slugger": "^2.0.0",
@@ -67,13 +66,14 @@
     "@types/js-yaml": "^4.0.9",
     "@types/node": "25.7.0",
     "@types/react": "^19.2.14",
+    "ajv": "^8.20.0",
     "fast-content-type-parse": "^3.0.0",
     "json-schema-typed": "^8.0.2",
     "tailwindcss": "^4.3.0",
     "tsdown": "0.22.0",
     "xml-js": "^1.6.11",
-    "fumadocs-ui": "16.8.11",
     "fumadocs-core": "16.8.11",
+    "fumadocs-ui": "16.8.11",
     "tsconfig": "0.0.0"
   },
   "peerDependencies": {
@@ -101,7 +101,11 @@
     "@scalar/helpers": "0.6.0",
     "@scalar/json-magic": "0.12.12",
     "@scalar/openapi-upgrader": "0.2.7",
+    "ajv": "8.20.0",
     "fast-content-type-parse": "3.0.0",
+    "fast-deep-equal": "3.1.3",
+    "fast-uri": "3.1.0",
+    "json-schema-traverse": "1.0.0",
     "pathe": "2.0.3",
     "xml-js": "1.6.11",
     "yaml": "2.9.0"