fumadocs-openapi 10.10.1 → 10.10.2

package/dist/node_modules/.pnpm/@apidevtools_json-schema-ref-parser@15.3.5_@types_json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/util/url.js

@@ -0,0 +1,315 @@
+import convertPathToPosix from "./convert-path-to-posix.js";
+import { isWindows } from "./is-windows.js";
+//#region ../../node_modules/.pnpm/@apidevtools+json-schema-ref-parser@15.3.5_@types+json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/util/url.js
+const forwardSlashPattern = /\//g;
+const protocolPattern = /^(\w{2,}):\/\//i;
+const jsonPointerSlash = /~1/g;
+const jsonPointerTilde = /~0/g;
+const isAbsoluteWin32Path = /^[a-zA-Z]:[\\/]/;
+const urlEncodePatterns = [[/\?/g, "%3F"], [/#/g, "%23"]];
+const urlDecodePatterns = [
+	/%23/g,
+	"#",
+	/%24/g,
+	"$",
+	/%26/g,
+	"&",
+	/%2C/g,
+	",",
+	/%40/g,
+	"@"
+];
+const parse = (u) => new URL(u);
+/**
+* Returns resolved target URL relative to a base URL in a manner similar to that of a Web browser resolving an anchor tag HREF.
+*
+* @returns
+*/
+function resolve(from, to) {
+	const fromUrl = new URL(convertPathToPosix(from), "https://aaa.nonexistanturl.com");
+	const resolvedUrl = new URL(convertPathToPosix(to), fromUrl);
+	const endSpaces = to.match(/(\s*)$/)?.[1] || "";
+	if (resolvedUrl.hostname === "aaa.nonexistanturl.com") {
+		const { pathname, search, hash } = resolvedUrl;
+		return pathname + search + decodeURIComponent(hash) + endSpaces;
+	}
+	const resolved = resolvedUrl.toString() + endSpaces;
+	if (resolved.includes("#")) {
+		const [base, hash] = resolved.split("#", 2);
+		return base + "#" + decodeURIComponent(hash || "");
+	}
+	return resolved;
+}
+/**
+* Returns the current working directory (in Node) or the current page URL (in browsers).
+*
+* @returns
+*/
+function cwd() {
+	if (typeof window !== "undefined" && window.location && window.location.href) {
+		const href = window.location.href;
+		if (!href || !href.startsWith("http")) try {
+			new URL(href);
+			return href;
+		} catch {
+			return "/";
+		}
+		return href;
+	}
+	if (typeof process !== "undefined" && process.cwd) {
+		const path = process.cwd();
+		const lastChar = path.slice(-1);
+		if (lastChar === "/" || lastChar === "\\") return path;
+		else return path + "/";
+	}
+	return "/";
+}
+/**
+* Returns the protocol of the given URL, or `undefined` if it has no protocol.
+*
+* @param path
+* @returns
+*/
+function getProtocol(path) {
+	const match = protocolPattern.exec(path || "");
+	if (match) return match[1].toLowerCase();
+}
+/**
+* Returns the lowercased file extension of the given URL,
+* or an empty string if it has no extension.
+*
+* @param path
+* @returns
+*/
+function getExtension(path) {
+	const lastDot = path.lastIndexOf(".");
+	if (lastDot >= 0) return stripQuery(path.substring(lastDot).toLowerCase());
+	return "";
+}
+/**
+* Removes the query, if any, from the given path.
+*
+* @param path
+* @returns
+*/
+function stripQuery(path) {
+	const queryIndex = path.indexOf("?");
+	if (queryIndex >= 0) path = path.substring(0, queryIndex);
+	return path;
+}
+/**
+* Returns the hash (URL fragment), of the given path.
+* If there is no hash, then the root hash ("#") is returned.
+*
+* @param path
+* @returns
+*/
+function getHash(path) {
+	if (!path) return "#";
+	const hashIndex = path.indexOf("#");
+	if (hashIndex >= 0) return path.substring(hashIndex);
+	return "#";
+}
+/**
+* Removes the hash (URL fragment), if any, from the given path.
+*
+* @param path
+* @returns
+*/
+function stripHash(path) {
+	if (!path) return "";
+	const hashIndex = path.indexOf("#");
+	if (hashIndex >= 0) path = path.substring(0, hashIndex);
+	return path;
+}
+/**
+* Determines whether the given path is an HTTP(S) URL.
+*
+* @param path
+* @returns
+*/
+function isHttp(path) {
+	const protocol = getProtocol(path);
+	if (protocol === "http" || protocol === "https") return true;
+	else if (protocol === void 0) return typeof window !== "undefined";
+	else return false;
+}
+/**
+* Determines whether the given url is an unsafe or internal url.
+*
+* @param path - The URL or path to check
+* @returns true if the URL is unsafe/internal, false otherwise
+*/
+function isUnsafeUrl(path) {
+	if (!path || typeof path !== "string") return true;
+	const normalizedPath = path.trim().toLowerCase();
+	if (!normalizedPath) return true;
+	if (normalizedPath.startsWith("javascript:") || normalizedPath.startsWith("vbscript:") || normalizedPath.startsWith("data:")) return true;
+	if (normalizedPath.startsWith("file:")) return true;
+	if (typeof window !== "undefined" && window.location && window.location.href) return false;
+	const localPatterns = [
+		"localhost",
+		"127.0.0.1",
+		"::1",
+		"10.",
+		"172.16.",
+		"172.17.",
+		"172.18.",
+		"172.19.",
+		"172.20.",
+		"172.21.",
+		"172.22.",
+		"172.23.",
+		"172.24.",
+		"172.25.",
+		"172.26.",
+		"172.27.",
+		"172.28.",
+		"172.29.",
+		"172.30.",
+		"172.31.",
+		"192.168.",
+		"169.254.",
+		".local",
+		".internal",
+		".intranet",
+		".corp",
+		".home",
+		".lan"
+	];
+	try {
+		const url = new URL(normalizedPath.startsWith("//") ? "http:" + normalizedPath : normalizedPath);
+		const hostname = url.hostname.toLowerCase();
+		for (const pattern of localPatterns) if (hostname === pattern || hostname.startsWith(pattern) || hostname.endsWith(pattern)) return true;
+		if (isPrivateIP(hostname)) return true;
+		const port = url.port;
+		if (port && isInternalPort(parseInt(port))) return true;
+	} catch {
+		if (normalizedPath.startsWith("/") && !normalizedPath.startsWith("//")) return false;
+		for (const pattern of localPatterns) if (normalizedPath.includes(pattern)) return true;
+	}
+	return false;
+}
+/**
+* Helper function to check if an IP address is in a private range
+*/
+function isPrivateIP(ip) {
+	const match = ip.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
+	if (!match) return false;
+	const [, a, b, c, d] = match.map(Number);
+	if (a > 255 || b > 255 || c > 255 || d > 255) return false;
+	return a === 10 || a === 127 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168 || a === 169 && b === 254;
+}
+/**
+* Helper function to check if a port is typically used for internal services
+*/
+function isInternalPort(port) {
+	return [
+		22,
+		23,
+		25,
+		53,
+		135,
+		139,
+		445,
+		993,
+		995,
+		1433,
+		1521,
+		3306,
+		3389,
+		5432,
+		5900,
+		6379,
+		8080,
+		8443,
+		9200,
+		27017
+	].includes(port);
+}
+/**
+* Determines whether the given path is a filesystem path.
+* This includes "file://" URLs.
+*
+* @param path
+* @returns
+*/
+function isFileSystemPath(path) {
+	if (typeof window !== "undefined" || typeof process !== "undefined" && process.browser) return false;
+	const protocol = getProtocol(path);
+	return protocol === void 0 || protocol === "file";
+}
+/**
+* Converts a filesystem path to a properly-encoded URL.
+*
+* This is intended to handle situations where JSON Schema $Ref Parser is called
+* with a filesystem path that contains characters which are not allowed in URLs.
+*
+* @example
+* The following filesystem paths would be converted to the following URLs:
+*
+*    <"!@#$%^&*+=?'>.json              ==>   %3C%22!@%23$%25%5E&*+=%3F\'%3E.json
+*    C:\\My Documents\\File (1).json   ==>   C:/My%20Documents/File%20(1).json
+*    file://Project #42/file.json      ==>   file://Project%20%2342/file.json
+*
+* @param path
+* @returns
+*/
+function fromFileSystemPath(path) {
+	if (isWindows()) {
+		const projectDir = cwd();
+		const upperPath = path.toUpperCase();
+		const posixUpper = convertPathToPosix(projectDir).toUpperCase();
+		const hasProjectDir = upperPath.includes(posixUpper);
+		const hasProjectUri = upperPath.includes(posixUpper);
+		const isAbsolutePath = isAbsoluteWin32Path.test(path) || path.startsWith("http://") || path.startsWith("https://") || path.startsWith("file://");
+		if (!(hasProjectDir || hasProjectUri || isAbsolutePath) && !projectDir.startsWith("http")) {
+			const join = (a, b) => {
+				if (a.endsWith("/") || a.endsWith("\\")) return a + b;
+				else return a + "/" + b;
+			};
+			path = join(projectDir, path);
+		}
+		path = convertPathToPosix(path);
+	}
+	path = encodeURI(path);
+	for (const pattern of urlEncodePatterns) path = path.replace(pattern[0], pattern[1]);
+	return path;
+}
+/**
+* Converts a URL to a local filesystem path.
+*/
+function toFileSystemPath(path, keepFileProtocol) {
+	path = path.replace(/%(?![0-9A-Fa-f]{2})/g, "%25");
+	path = decodeURI(path);
+	for (let i = 0; i < urlDecodePatterns.length; i += 2) path = path.replace(urlDecodePatterns[i], urlDecodePatterns[i + 1]);
+	let isFileUrl = path.toLowerCase().startsWith("file://");
+	if (isFileUrl) {
+		path = path.replace(/^file:\/\//, "").replace(/^\//, "");
+		if (isWindows() && path[1] === "/") path = `${path[0]}:${path.substring(1)}`;
+		if (keepFileProtocol) path = "file:///" + path;
+		else {
+			isFileUrl = false;
+			path = isWindows() ? path : "/" + path;
+		}
+	}
+	if (isWindows() && !isFileUrl) {
+		path = path.replace(forwardSlashPattern, "\\");
+		if (path.match(/^[a-z]:\\/i)) path = path[0].toUpperCase() + path.substring(1);
+	}
+	return path;
+}
+/**
+* Converts a $ref pointer to a valid JSON Path.
+*
+* @param pointer
+* @returns
+*/
+function safePointerToPath(pointer) {
+	if (pointer.length <= 1 || pointer[0] !== "#" || pointer[1] !== "/") return [];
+	return pointer.slice(2).split("/").map((value) => {
+		return value.replace(jsonPointerSlash, "/").replace(jsonPointerTilde, "~");
+	});
+}
+//#endregion
+export { cwd, fromFileSystemPath, getExtension, getHash, isFileSystemPath, isHttp, isUnsafeUrl, parse, resolve, safePointerToPath, stripHash, toFileSystemPath };

package/dist/utils/document/process.js

@@ -1,23 +1,18 @@
-import { bundle } from "../../node_modules/.pnpm/@scalar_json-magic@0.12.14/node_modules/@scalar/json-magic/dist/bundle/bundle.js";
 import { upgrade } from "../../node_modules/.pnpm/@scalar_openapi-upgrader@0.2.8/node_modules/@scalar/openapi-upgrader/dist/upgrade.js";
-import { fetchUrls } from "../../node_modules/.pnpm/@scalar_json-magic@0.12.14/node_modules/@scalar/json-magic/dist/bundle/plugins/fetch-urls/index.js";
-import { readFiles } from "../../node_modules/.pnpm/@scalar_json-magic@0.12.14/node_modules/@scalar/json-magic/dist/bundle/plugins/read-files/index.js";
-import "../../node_modules/.pnpm/@scalar_json-magic@0.12.14/node_modules/@scalar/json-magic/dist/bundle/plugins/node.js";
 import { dereferenceDocument } from "./dereference.js";
+import { bundle } from "../../node_modules/.pnpm/@apidevtools_json-schema-ref-parser@15.3.5_@types_json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/index.js";
 //#region src/utils/document/process.ts
 /**
 * process & reference input document to a Fumadocs OpenAPI compatible format
 */
 async function processDocument(input) {
-	return dereferenceDocument(await bundle(input, {
-		plugins: [fetchUrls(), readFiles()],
-		treeShake: true,
-		hooks: { onResolveError(node) {
-			throw new Error(`Failed to resolve ${node.$ref}`);
-		} }
-	}).then((v) => upgrade(v, "3.2")).catch((e) => {
+	try {
+		let bundled = await bundle(input);
+		bundled = upgrade(bundled, "3.2");
+		return dereferenceDocument(bundled);
+	} catch (e) {
 		throw new Error(`[OpenAPI] Failed to resolve input: ${input}`, { cause: e });
-	}));
+	}
 }
 //#endregion
 export { processDocument };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fumadocs-openapi",
-  "version": "10.10.1",
+  "version": "10.10.2",
   "description": "Generate MDX docs for your OpenAPI spec",
   "keywords": [
     "Docs",
@@ -57,9 +57,9 @@
     "@fumari/stf": "1.0.5"
   },
   "devDependencies": {
+    "@apidevtools/json-schema-ref-parser": "^15.3.5",
     "@fastify/deepmerge": "^3.2.1",
     "@scalar/api-client-react": "2.0.20",
-    "@scalar/json-magic": "^0.12.14",
     "@scalar/openapi-upgrader": "^0.2.8",
     "@tailwindcss/oxide": "^4.3.0",
     "@types/js-yaml": "^4.0.9",
@@ -72,8 +72,8 @@
     "tsdown": "0.22.0",
     "xml-js": "^1.6.11",
     "fumadocs-core": "16.9.3",
-    "fumadocs-ui": "16.9.3",
-    "tsconfig": "0.0.0"
+    "tsconfig": "0.0.0",
+    "fumadocs-ui": "16.9.3"
   },
   "peerDependencies": {
     "@scalar/api-client-react": "^2.0.20",
@@ -96,18 +96,15 @@
     }
   },
   "inlinedDependencies": {
+    "@apidevtools/json-schema-ref-parser": "15.3.5",
     "@fastify/deepmerge": "3.2.1",
-    "@scalar/helpers": "0.8.0",
-    "@scalar/json-magic": "0.12.14",
     "@scalar/openapi-upgrader": "0.2.8",
     "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"
+    "xml-js": "1.6.11"
   },
   "scripts": {
     "build": "tsdown",

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

@@ -1,43 +0,0 @@
-import { Queue } from "../queue/queue.js";
-//#region ../../node_modules/.pnpm/@scalar+helpers@0.8.0/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.8.0/node_modules/@scalar/helpers/dist/object/is-object.js

@@ -1,27 +0,0 @@
-//#region ../../node_modules/.pnpm/@scalar+helpers@0.8.0/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.
-*
-* | Value | Result |
-* | :--- | :--- |
-* | `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.8.0/node_modules/@scalar/helpers/dist/object/prevent-pollution.js

@@ -1,33 +0,0 @@
-//#region ../../node_modules/.pnpm/@scalar+helpers@0.8.0/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.8.0/node_modules/@scalar/helpers/dist/queue/queue.js

@@ -1,106 +0,0 @@
-//#region ../../node_modules/.pnpm/@scalar+helpers@0.8.0/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 };