fumadocs-openapi 10.6.7 → 10.7.0

package/css/generated/shared.css

@@ -337,6 +337,7 @@
 @source inline("font-semibold");
 @source inline("for");
 @source inline("form");
+@source inline("formData");
 @source inline("format");
 @source inline("forwardRef");
 @source inline("found");
@@ -555,7 +556,6 @@
 @source inline("never");
 @source inline("new");
 @source inline("newKey");
-@source inline("next-themes");
 @source inline("no-cache");
 @source inline("node");
 @source inline("node:path");
@@ -591,7 +591,6 @@
 @source inline("openApiData");
 @source inline("openIdConnect");
 @source inline("openapi");
-@source inline("openapi-sampler");
 @source inline("openapi-types");
 @source inline("openid");
 @source inline("operation");
@@ -708,7 +707,6 @@
 @source inline("raw");
 @source inline("rawSearch");
 @source inline("react");
-@source inline("react-hook-form");
 @source inline("react-hooks/exhaustive-deps");
 @source inline("react/jsx-runtime");
 @source inline("read");
@@ -1037,12 +1035,11 @@
 @source inline("usageTabs");
 @source inline("usages");
 @source inline("use");
-@source inline("useApiClientModal");
+@source inline("useApiClient");
 @source inline("useApiContext");
 @source inline("useAuth");
 @source inline("useCopyButton");
 @source inline("useFieldValue");
-@source inline("useForm");
 @source inline("useI18n");
 @source inline("useMemo");
 @source inline("useNamespace");

package/dist/_virtual/_rolldown/runtime.js

@@ -1,5 +1,6 @@
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __exportAll = (all, no_symbols) => {
 	let target = {};
 	for (var name in all) __defProp(target, name, {
@@ -10,4 +11,4 @@ var __exportAll = (all, no_symbols) => {
 	return target;
 };
 //#endregion
-export { __exportAll };
+export { __commonJSMin, __exportAll };

package/dist/i18n.js

@@ -1,5 +1,6 @@
-import { deepmerge } from "@fastify/deepmerge";
+import { require_deepmerge } from "./node_modules/.pnpm/@fastify_deepmerge@3.2.1/node_modules/@fastify/deepmerge/index.js";
 //#region src/i18n.ts
+var import_deepmerge = require_deepmerge();
 const defaultTranslations = {
 	loading: "loading...",
 	empty: "Empty",
@@ -95,7 +96,7 @@ const defaultTranslations = {
 	playgroundInputUnset: "Unset"
 };
 function defineI18nOpenAPI(config, translations) {
-	const dm = deepmerge();
+	const dm = (0, import_deepmerge.deepmerge)();
 	return {
 		...config,
 		provider(locale = config.defaultLanguage) {

package/dist/node_modules/.pnpm/@fastify_deepmerge@3.2.1/node_modules/@fastify/deepmerge/index.js

@@ -0,0 +1,108 @@
+import { __commonJSMin } from "../../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/@fastify+deepmerge@3.2.1/node_modules/@fastify/deepmerge/index.js
+var require_deepmerge = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const JSON_PROTO = Object.getPrototypeOf({});
+	function defaultIsMergeableObjectFactory() {
+		return function defaultIsMergeableObject(value) {
+			return typeof value === "object" && value !== null && !(value instanceof RegExp) && !(value instanceof Date);
+		};
+	}
+	function deepmergeConstructor(options) {
+		function isNotPrototypeKey(value) {
+			return value !== "constructor" && value !== "prototype" && value !== "__proto__";
+		}
+		function cloneArray(value) {
+			let i = 0;
+			const il = value.length;
+			const result = new Array(il);
+			for (; i < il; ++i) result[i] = clone(value[i]);
+			return result;
+		}
+		function cloneObject(target) {
+			const result = {};
+			if (cloneProtoObject && Object.getPrototypeOf(target) !== JSON_PROTO) return cloneProtoObject(target);
+			const targetKeys = getKeys(target);
+			let i, il, key;
+			for (i = 0, il = targetKeys.length; i < il; ++i) isNotPrototypeKey(key = targetKeys[i]) && (result[key] = clone(target[key]));
+			return result;
+		}
+		function concatArrays(target, source) {
+			const tl = target.length;
+			const sl = source.length;
+			let i = 0;
+			const result = new Array(tl + sl);
+			for (; i < tl; ++i) result[i] = clone(target[i]);
+			for (i = 0; i < sl; ++i) result[i + tl] = clone(source[i]);
+			return result;
+		}
+		const propertyIsEnumerable = Object.prototype.propertyIsEnumerable;
+		function getSymbolsAndKeys(value) {
+			const result = Object.keys(value);
+			const keys = Object.getOwnPropertySymbols(value);
+			for (let i = 0, il = keys.length; i < il; ++i) propertyIsEnumerable.call(value, keys[i]) && result.push(keys[i]);
+			return result;
+		}
+		const getKeys = options?.symbols ? getSymbolsAndKeys : Object.keys;
+		const cloneProtoObject = typeof options?.cloneProtoObject === "function" ? options.cloneProtoObject : void 0;
+		const isMergeableObject = typeof options?.isMergeableObject === "function" ? options.isMergeableObject : defaultIsMergeableObjectFactory();
+		const onlyDefinedProperties = options?.onlyDefinedProperties === true;
+		function isPrimitive(value) {
+			return typeof value !== "object" || value === null;
+		}
+		const mergeArray = options && typeof options.mergeArray === "function" ? options.mergeArray({
+			clone,
+			deepmerge: _deepmerge,
+			getKeys,
+			isMergeableObject
+		}) : concatArrays;
+		function clone(entry) {
+			return isMergeableObject(entry) ? Array.isArray(entry) ? cloneArray(entry) : cloneObject(entry) : entry;
+		}
+		function mergeObject(target, source) {
+			const result = {};
+			const targetKeys = getKeys(target);
+			const sourceKeys = getKeys(source);
+			let i, il, key;
+			for (i = 0, il = targetKeys.length; i < il; ++i) isNotPrototypeKey(key = targetKeys[i]) && sourceKeys.indexOf(key) === -1 && (result[key] = clone(target[key]));
+			for (i = 0, il = sourceKeys.length; i < il; ++i) {
+				if (!isNotPrototypeKey(key = sourceKeys[i])) continue;
+				if (key in target) {
+					if (targetKeys.indexOf(key) !== -1) if (cloneProtoObject && isMergeableObject(source[key]) && Object.getPrototypeOf(source[key]) !== JSON_PROTO) result[key] = cloneProtoObject(source[key]);
+					else result[key] = _deepmerge(target[key], source[key]);
+				} else {
+					if (onlyDefinedProperties && typeof source[key] === "undefined") continue;
+					result[key] = clone(source[key]);
+				}
+			}
+			return result;
+		}
+		function _deepmerge(target, source) {
+			if (onlyDefinedProperties && typeof source === "undefined") return clone(target);
+			const sourceIsArray = Array.isArray(source);
+			const targetIsArray = Array.isArray(target);
+			if (isPrimitive(source)) return source;
+			else if (!isMergeableObject(target)) return clone(source);
+			else if (sourceIsArray && targetIsArray) return mergeArray(target, source);
+			else if (sourceIsArray !== targetIsArray) return clone(source);
+			else return mergeObject(target, source);
+		}
+		function _deepmergeAll() {
+			switch (arguments.length) {
+				case 0: return {};
+				case 1: return clone(arguments[0]);
+				case 2: return _deepmerge(arguments[0], arguments[1]);
+			}
+			let result;
+			for (let i = 0, il = arguments.length; i < il; ++i) result = _deepmerge(result, arguments[i]);
+			return result;
+		}
+		return options?.all ? _deepmergeAll : _deepmerge;
+	}
+	module.exports = deepmergeConstructor;
+	module.exports.default = deepmergeConstructor;
+	module.exports.deepmerge = deepmergeConstructor;
+	Object.defineProperty(module.exports, "isMergeableObject", { get: defaultIsMergeableObjectFactory });
+}));
+//#endregion
+export default require_deepmerge();
+export { require_deepmerge };

package/dist/node_modules/.pnpm/@scalar_helpers@0.4.3/node_modules/@scalar/helpers/dist/general/create-limiter.js

@@ -0,0 +1,43 @@
+import { Queue } from "../queue/queue.js";
+//#region ../../node_modules/.pnpm/@scalar+helpers@0.4.3/node_modules/@scalar/helpers/dist/general/create-limiter.js
+/**
+* Creates a function that limits the number of concurrent executions of async functions.
+*
+* @param maxConcurrent - Maximum number of concurrent executions allowed
+* @returns A function that wraps async functions to limit their concurrent execution
+*
+* @example
+* ```ts
+* const limiter = createLimiter(2) // Allow max 2 concurrent executions
+*
+* // These will run with max 2 at a time
+* const results = await Promise.all([
+*   limiter(() => fetch('/api/1')),
+*   limiter(() => fetch('/api/2')),
+*   limiter(() => fetch('/api/3')),
+*   limiter(() => fetch('/api/4'))
+* ])
+* ```
+*/
+function createLimiter(maxConcurrent) {
+	let activeCount = 0;
+	const queue = new Queue();
+	const next = () => {
+		if (queue.isEmpty() || activeCount >= maxConcurrent) return;
+		const resolve = queue.dequeue();
+		if (resolve) resolve();
+	};
+	const run = async (fn) => {
+		if (activeCount >= maxConcurrent) await new Promise((resolve) => queue.enqueue(resolve));
+		activeCount++;
+		try {
+			return await fn();
+		} finally {
+			activeCount--;
+			next();
+		}
+	};
+	return run;
+}
+//#endregion
+export { createLimiter };

package/dist/node_modules/.pnpm/@scalar_helpers@0.4.3/node_modules/@scalar/helpers/dist/object/is-object.js

@@ -0,0 +1,26 @@
+//#region ../../node_modules/.pnpm/@scalar+helpers@0.4.3/node_modules/@scalar/helpers/dist/object/is-object.js
+/**
+* Returns true if the provided value is a record object
+* (i.e. not null, not an array, and has an actual object as the prototype).
+*
+* Differs from the previous isObject in that it returns false for Date,
+* RegExp, Error, Map, Set, WeakMap, WeakSet, Promise, and other non-plain objects.
+*
+* Examples:
+*   isObject({})                  // true
+*   isObject({ a: 1 })            // true
+*   isObject([])                  // false (Array)
+*   isObject(null)                // false
+*   isObject(123)                 // false
+*   isObject('string')            // false
+*   isObject(new Error('test'))   // false
+*   isObject(new Date())          // false
+*   isObject(Object.create(null)) // true
+*/
+const isObject = (value) => {
+	if (value === null || typeof value !== "object") return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+};
+//#endregion
+export { isObject };

package/dist/node_modules/.pnpm/@scalar_helpers@0.4.3/node_modules/@scalar/helpers/dist/object/prevent-pollution.js

@@ -0,0 +1,33 @@
+//#region ../../node_modules/.pnpm/@scalar+helpers@0.4.3/node_modules/@scalar/helpers/dist/object/prevent-pollution.js
+/**
+* Set of dangerous keys that can be used for prototype pollution attacks.
+* These keys should never be used as property names in dynamic object operations.
+*/
+const PROTOTYPE_POLLUTION_KEYS = new Set([
+	"__proto__",
+	"prototype",
+	"constructor"
+]);
+/**
+* Validates that a key is safe to use and does not pose a prototype pollution risk.
+* Throws an error if a dangerous key is detected.
+*
+* @param key - The key to validate
+* @param context - Optional context string to help identify where the validation failed
+* @throws {Error} If the key matches a known prototype pollution vector
+*
+* @example
+* ```ts
+* preventPollution('__proto__') // throws Error
+* preventPollution('safeName') // passes
+* preventPollution('constructor', 'operation update') // throws Error with context
+* ```
+*/
+const preventPollution = (key, context) => {
+	if (PROTOTYPE_POLLUTION_KEYS.has(key)) {
+		const errorMessage = context ? `Prototype pollution key detected: "${key}" in ${context}` : `Prototype pollution key detected: "${key}"`;
+		throw new Error(errorMessage);
+	}
+};
+//#endregion
+export { preventPollution };

package/dist/node_modules/.pnpm/@scalar_helpers@0.4.3/node_modules/@scalar/helpers/dist/queue/queue.js

@@ -0,0 +1,106 @@
+//#region ../../node_modules/.pnpm/@scalar+helpers@0.4.3/node_modules/@scalar/helpers/dist/queue/queue.js
+/**
+* Represents a node in a singly linked list structure, used internally by the Queue.
+*
+* Example:
+*   const node = new Node<number>(42);
+*   console.log(node.data); // 42
+*   console.log(node.next); // null
+*/
+var Node = class {
+	data;
+	next;
+	constructor(data) {
+		this.data = data;
+		this.next = null;
+	}
+};
+/**
+* A generic queue implementation using a singly linked list.
+*
+* Example usage:
+*
+*   const q = new Queue<number>();
+*   q.enqueue(1);
+*   q.enqueue(2);
+*   q.enqueue(3);
+*   console.log(q.dequeue()); // 1
+*   console.log(q.peek());    // 2
+*   console.log(q.getSize()); // 2
+*   console.log(q.toString()); // "2 -> 3"
+*   console.log(q.isEmpty()); // false
+*/
+var Queue = class {
+	front;
+	rear;
+	size;
+	constructor() {
+		this.front = null;
+		this.rear = null;
+		this.size = 0;
+	}
+	/**
+	* Adds an element to the end of the queue.
+	* @param data - The data to add to the queue.
+	*/
+	enqueue(data) {
+		const newNode = new Node(data);
+		if (this.isEmpty() || !this.rear) {
+			this.front = newNode;
+			this.rear = newNode;
+		} else {
+			this.rear.next = newNode;
+			this.rear = newNode;
+		}
+		this.size++;
+	}
+	/**
+	* Removes and returns the front element of the queue.
+	* @returns The data from the removed node, or null if the queue is empty.
+	*/
+	dequeue() {
+		if (this.isEmpty() || !this.front) return null;
+		const removedNode = this.front;
+		this.front = this.front.next;
+		if (this.front === null) this.rear = null;
+		this.size--;
+		return removedNode.data;
+	}
+	/**
+	* Returns the front element of the queue without removing it.
+	* @returns The front data, or null if the queue is empty.
+	*/
+	peek() {
+		if (this.isEmpty() || !this.front) return null;
+		return this.front.data;
+	}
+	/**
+	* Checks whether the queue is empty.
+	* @returns True if the queue has no elements, false otherwise.
+	*/
+	isEmpty() {
+		return this.size === 0;
+	}
+	/**
+	* Returns the number of elements in the queue.
+	* @returns The size of the queue.
+	*/
+	getSize() {
+		return this.size;
+	}
+	/**
+	* Returns a string representation of the queue.
+	* @returns Elements of the queue separated by ' -> '.
+	*/
+	toString() {
+		let current = this.front;
+		const elements = [];
+		while (current) {
+			elements.push(current.data);
+			current = current.next;
+		}
+		return elements.join(" -> ");
+	}
+};
+//#endregion
+export { Queue };

package/dist/node_modules/.pnpm/@scalar_helpers@0.4.3/node_modules/@scalar/helpers/dist/string/generate-hash.js

@@ -0,0 +1,120 @@
+//#region ../../node_modules/.pnpm/@scalar+helpers@0.4.3/node_modules/@scalar/helpers/dist/string/generate-hash.js
+/**
+* MurmurHash3 implementation
+*
+* Generate a hash from a string using the MurmurHash3 algorithm
+* Provides 64-bit hash output with excellent speed and distribution
+*
+* We had to move away from xxhash-wasm since it was causing issues with content security policy (CSP) violations.
+*
+* We cannot use crypto.subtle because it is only available in secure contexts (HTTPS) or on localhost.
+*
+* @param input - The string to hash
+* @returns The 64-bit hash of the input string as a 16-character hex string
+*/
+const generateHash = (input) => {
+	const seed = 0;
+	let h1 = seed;
+	let h2 = seed;
+	const len = input.length;
+	const remainder = len & 15;
+	const bytes = len - remainder;
+	const c1 = 2277735313;
+	const c2 = 1291169091;
+	const c3 = 1390208809;
+	const c4 = 944331445;
+	for (let i = 0; i < bytes; i += 16) {
+		let k1 = input.charCodeAt(i) & 255 | (input.charCodeAt(i + 1) & 255) << 8 | (input.charCodeAt(i + 2) & 255) << 16 | (input.charCodeAt(i + 3) & 255) << 24;
+		let k2 = input.charCodeAt(i + 4) & 255 | (input.charCodeAt(i + 5) & 255) << 8 | (input.charCodeAt(i + 6) & 255) << 16 | (input.charCodeAt(i + 7) & 255) << 24;
+		let k3 = input.charCodeAt(i + 8) & 255 | (input.charCodeAt(i + 9) & 255) << 8 | (input.charCodeAt(i + 10) & 255) << 16 | (input.charCodeAt(i + 11) & 255) << 24;
+		let k4 = input.charCodeAt(i + 12) & 255 | (input.charCodeAt(i + 13) & 255) << 8 | (input.charCodeAt(i + 14) & 255) << 16 | (input.charCodeAt(i + 15) & 255) << 24;
+		k1 = Math.imul(k1, c1);
+		k1 = k1 << 15 | k1 >>> 17;
+		k1 = Math.imul(k1, c2);
+		h1 ^= k1;
+		h1 = h1 << 13 | h1 >>> 19;
+		h1 = Math.imul(h1, 5) + 3864292196;
+		k2 = Math.imul(k2, c2);
+		k2 = k2 << 16 | k2 >>> 16;
+		k2 = Math.imul(k2, c3);
+		h2 ^= k2;
+		h2 = h2 << 17 | h2 >>> 15;
+		h2 = Math.imul(h2, 5) + 461845907;
+		k3 = Math.imul(k3, c3);
+		k3 = k3 << 17 | k3 >>> 15;
+		k3 = Math.imul(k3, c4);
+		h1 ^= k3;
+		h1 = h1 << 15 | h1 >>> 17;
+		h1 = Math.imul(h1, 5) + 1390208809;
+		k4 = Math.imul(k4, c4);
+		k4 = k4 << 18 | k4 >>> 14;
+		k4 = Math.imul(k4, c1);
+		h2 ^= k4;
+		h2 = h2 << 13 | h2 >>> 19;
+		h2 = Math.imul(h2, 5) + 944331445;
+	}
+	if (remainder > 0) {
+		let k1 = 0;
+		let k2 = 0;
+		let k3 = 0;
+		let k4 = 0;
+		if (remainder >= 15) k4 ^= (input.charCodeAt(bytes + 14) & 255) << 16;
+		if (remainder >= 14) k4 ^= (input.charCodeAt(bytes + 13) & 255) << 8;
+		if (remainder >= 13) {
+			k4 ^= input.charCodeAt(bytes + 12) & 255;
+			k4 = Math.imul(k4, c4);
+			k4 = k4 << 18 | k4 >>> 14;
+			k4 = Math.imul(k4, c1);
+			h2 ^= k4;
+		}
+		if (remainder >= 12) k3 ^= (input.charCodeAt(bytes + 11) & 255) << 24;
+		if (remainder >= 11) k3 ^= (input.charCodeAt(bytes + 10) & 255) << 16;
+		if (remainder >= 10) k3 ^= (input.charCodeAt(bytes + 9) & 255) << 8;
+		if (remainder >= 9) {
+			k3 ^= input.charCodeAt(bytes + 8) & 255;
+			k3 = Math.imul(k3, c3);
+			k3 = k3 << 17 | k3 >>> 15;
+			k3 = Math.imul(k3, c4);
+			h1 ^= k3;
+		}
+		if (remainder >= 8) k2 ^= (input.charCodeAt(bytes + 7) & 255) << 24;
+		if (remainder >= 7) k2 ^= (input.charCodeAt(bytes + 6) & 255) << 16;
+		if (remainder >= 6) k2 ^= (input.charCodeAt(bytes + 5) & 255) << 8;
+		if (remainder >= 5) {
+			k2 ^= input.charCodeAt(bytes + 4) & 255;
+			k2 = Math.imul(k2, c2);
+			k2 = k2 << 16 | k2 >>> 16;
+			k2 = Math.imul(k2, c3);
+			h2 ^= k2;
+		}
+		if (remainder >= 4) k1 ^= (input.charCodeAt(bytes + 3) & 255) << 24;
+		if (remainder >= 3) k1 ^= (input.charCodeAt(bytes + 2) & 255) << 16;
+		if (remainder >= 2) k1 ^= (input.charCodeAt(bytes + 1) & 255) << 8;
+		if (remainder >= 1) {
+			k1 ^= input.charCodeAt(bytes) & 255;
+			k1 = Math.imul(k1, c1);
+			k1 = k1 << 15 | k1 >>> 17;
+			k1 = Math.imul(k1, c2);
+			h1 ^= k1;
+		}
+	}
+	h1 ^= len;
+	h2 ^= len;
+	h1 += h2;
+	h2 += h1;
+	h1 ^= h1 >>> 16;
+	h1 = Math.imul(h1, 2246822507);
+	h1 ^= h1 >>> 13;
+	h1 = Math.imul(h1, 3266489909);
+	h1 ^= h1 >>> 16;
+	h2 ^= h2 >>> 16;
+	h2 = Math.imul(h2, 2246822507);
+	h2 ^= h2 >>> 13;
+	h2 = Math.imul(h2, 3266489909);
+	h2 ^= h2 >>> 16;
+	h1 += h2;
+	h2 += h1;
+	return (h1 >>> 0).toString(16).padStart(8, "0") + (h2 >>> 0).toString(16).padStart(8, "0");
+};
+//#endregion
+export { generateHash };