fumadocs-openapi 10.10.1 → 10.10.3

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/index.js

@@ -0,0 +1,136 @@
+import { cwd, fromFileSystemPath, isFileSystemPath, parse as parse$1, resolve as resolve$1, stripHash } from "./util/url.js";
+import { JSONParserErrorGroup, isHandledError } from "./util/errors.js";
+import { registerSchemaResources, usesDynamicIdScope } from "./util/schema-resources.js";
+import $Refs from "./refs.js";
+import parse$2 from "./parse.js";
+import "./resolvers/file.js";
+import "./resolvers/http.js";
+import "./options.js";
+import normalizeArgs from "./normalize-args.js";
+import resolveExternal from "./resolve-external.js";
+import bundle$1 from "./bundle.js";
+import dereference_default from "./dereference.js";
+import maybe from "./util/maybe.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/index.js
+/**
+* This class parses a JSON schema, builds a map of its JSON references and their resolved values,
+* and provides methods for traversing, manipulating, and dereferencing those references.
+*
+* @class
+*/
+var $RefParser = class $RefParser {
+	/**
+	* The parsed (and possibly dereferenced) JSON schema object
+	*
+	* @type {object}
+	* @readonly
+	*/
+	schema = null;
+	/**
+	* The resolved JSON references
+	*
+	* @type {$Refs}
+	* @readonly
+	*/
+	$refs = new $Refs();
+	async parse() {
+		const args = normalizeArgs(arguments);
+		let promise;
+		if (!args.path && !args.schema) {
+			const err = /* @__PURE__ */ new Error(`Expected a file path, URL, or object. Got ${args.path || args.schema}`);
+			return maybe(args.callback, Promise.reject(err));
+		}
+		this.schema = null;
+		this.$refs = new $Refs();
+		let pathType = "http";
+		if (isFileSystemPath(args.path)) {
+			args.path = fromFileSystemPath(args.path);
+			pathType = "file";
+		} else if (!args.path && args.schema && "$id" in args.schema && args.schema.$id) {
+			const params = parse$1(args.schema.$id);
+			const port = params.port ?? (params.protocol === "https:" ? 443 : 80);
+			args.path = `${params.protocol}//${params.hostname}:${port}`;
+		}
+		args.path = resolve$1(cwd(), args.path);
+		if (args.schema && typeof args.schema === "object") {
+			const $ref = this.$refs._add(args.path);
+			$ref.value = args.schema;
+			$ref.pathType = pathType;
+			$ref.dynamicIdScope = usesDynamicIdScope($ref.value);
+			registerSchemaResources(this.$refs, $ref.path, $ref.value, $ref.pathType, $ref.dynamicIdScope);
+			promise = Promise.resolve(args.schema);
+		} else promise = parse$2(args.path, this.$refs, args.options);
+		try {
+			const result = await promise;
+			if (result !== null && typeof result === "object" && !Buffer.isBuffer(result)) {
+				this.schema = result;
+				return maybe(args.callback, Promise.resolve(this.schema));
+			} else if (args.options.continueOnError) {
+				this.schema = null;
+				return maybe(args.callback, Promise.resolve(this.schema));
+			} else throw new SyntaxError(`"${this.$refs._root$Ref.path || result}" is not a valid JSON Schema`);
+		} catch (err) {
+			if (!args.options.continueOnError || !isHandledError(err)) return maybe(args.callback, Promise.reject(err));
+			if (this.$refs._$refs[stripHash(args.path)]) this.$refs._$refs[stripHash(args.path)].addError(err);
+			return maybe(args.callback, Promise.resolve(null));
+		}
+	}
+	static parse() {
+		const parser = new $RefParser();
+		return parser.parse.apply(parser, arguments);
+	}
+	async resolve() {
+		const args = normalizeArgs(arguments);
+		try {
+			await this.parse(args.path, args.schema, args.options);
+			await resolveExternal(this, args.options);
+			finalize(this);
+			return maybe(args.callback, Promise.resolve(this.$refs));
+		} catch (err) {
+			return maybe(args.callback, Promise.reject(err));
+		}
+	}
+	static resolve() {
+		const instance = new $RefParser();
+		return instance.resolve.apply(instance, arguments);
+	}
+	static bundle() {
+		const instance = new $RefParser();
+		return instance.bundle.apply(instance, arguments);
+	}
+	async bundle() {
+		const args = normalizeArgs(arguments);
+		try {
+			await this.resolve(args.path, args.schema, args.options);
+			bundle$1(this, args.options);
+			finalize(this);
+			return maybe(args.callback, Promise.resolve(this.schema));
+		} catch (err) {
+			return maybe(args.callback, Promise.reject(err));
+		}
+	}
+	static dereference() {
+		const instance = new $RefParser();
+		return instance.dereference.apply(instance, arguments);
+	}
+	async dereference() {
+		const args = normalizeArgs(arguments);
+		try {
+			await this.resolve(args.path, args.schema, args.options);
+			dereference_default(this, args.options);
+			finalize(this);
+			return maybe(args.callback, Promise.resolve(this.schema));
+		} catch (err) {
+			return maybe(args.callback, Promise.reject(err));
+		}
+	}
+};
+function finalize(parser) {
+	if (JSONParserErrorGroup.getParserErrors(parser).length > 0) throw new JSONParserErrorGroup(parser);
+}
+$RefParser.parse;
+$RefParser.resolve;
+const bundle = $RefParser.bundle;
+$RefParser.dereference;
+//#endregion
+export { bundle };

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/normalize-args.js

@@ -0,0 +1,41 @@
+import { getNewOptions } from "./options.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/normalize-args.js
+/**
+* Normalizes the given arguments, accounting for optional args.
+*/
+function normalizeArgs(_args) {
+	let path;
+	let schema;
+	let options;
+	let callback;
+	const args = Array.prototype.slice.call(_args);
+	if (typeof args[args.length - 1] === "function") callback = args.pop();
+	if (typeof args[0] === "string") {
+		path = args[0];
+		if (typeof args[2] === "object") {
+			schema = args[1];
+			options = args[2];
+		} else {
+			schema = void 0;
+			options = args[1];
+		}
+	} else {
+		path = "";
+		schema = args[0];
+		options = args[1];
+	}
+	try {
+		options = getNewOptions(options);
+	} catch (e) {
+		console.error(`JSON Schema Ref Parser: Error normalizing options: ${e}`);
+	}
+	if (!options.mutateInputSchema && typeof schema === "object") schema = JSON.parse(JSON.stringify(schema));
+	return {
+		path,
+		schema,
+		options,
+		callback
+	};
+}
+//#endregion
+export { normalizeArgs as default };

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/options.js

@@ -0,0 +1,124 @@
+import json_default from "./parsers/json.js";
+import yaml_default from "./parsers/yaml.js";
+import text_default from "./parsers/text.js";
+import binary_default from "./parsers/binary.js";
+import file_default from "./resolvers/file.js";
+import http_default from "./resolvers/http.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/options.js
+const getJsonSchemaRefParserDefaultOptions = () => {
+	return {
+		/**
+		* Determines how different types of files will be parsed.
+		*
+		* You can add additional parsers of your own, replace an existing one with
+		* your own implementation, or disable any parser by setting it to false.
+		*/
+		parse: {
+			json: { ...json_default },
+			yaml: { ...yaml_default },
+			text: { ...text_default },
+			binary: { ...binary_default }
+		},
+		/**
+		* Determines how JSON References will be resolved.
+		*
+		* You can add additional resolvers of your own, replace an existing one with
+		* your own implementation, or disable any resolver by setting it to false.
+		*/
+		resolve: {
+			file: { ...file_default },
+			http: { ...http_default },
+			/**
+			* Determines whether external $ref pointers will be resolved.
+			* If this option is disabled, then none of above resolvers will be called.
+			* Instead, external $ref pointers will simply be ignored.
+			*
+			* @type {boolean}
+			*/
+			external: true
+		},
+		/**
+		* By default, JSON Schema $Ref Parser throws the first error it encounters. Setting `continueOnError` to `true`
+		* causes it to keep processing as much as possible and then throw a single error that contains all errors
+		* that were encountered.
+		*/
+		continueOnError: false,
+		/**
+		* Determines the types of JSON references that are allowed.
+		*/
+		bundle: { 
+		/**
+		* A function, called for each path, which can return true to stop this path and all
+		* subpaths from being processed further. This is useful in schemas where some
+		* subpaths contain literal $ref keys that should not be changed.
+		*
+		* @type {function}
+		*/
+excludedPathMatcher: () => false },
+		/**
+		* Determines the types of JSON references that are allowed.
+		*/
+		dereference: {
+			/**
+			* Dereference circular (recursive) JSON references?
+			* If false, then a {@link ReferenceError} will be thrown if a circular reference is found.
+			* If "ignore", then circular references will not be dereferenced.
+			*
+			* @type {boolean|string}
+			*/
+			circular: true,
+			/**
+			* A function, called for each path, which can return true to stop this path and all
+			* subpaths from being dereferenced further. This is useful in schemas where some
+			* subpaths contain literal $ref keys that should not be dereferenced.
+			*
+			* @type {function}
+			*/
+			excludedPathMatcher: () => false,
+			referenceResolution: "relative",
+			mergeKeys: true
+		},
+		mutateInputSchema: true
+	};
+};
+const getNewOptions = (options) => {
+	const newOptions = getJsonSchemaRefParserDefaultOptions();
+	if (options) merge(newOptions, options);
+	return newOptions;
+};
+/**
+* Merges the properties of the source object into the target object.
+*
+* @param target - The object that we're populating
+* @param source - The options that are being merged
+* @returns
+*/
+function merge(target, source) {
+	if (isMergeable(source)) {
+		const keys = Object.keys(source).filter((key) => ![
+			"__proto__",
+			"constructor",
+			"prototype"
+		].includes(key));
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i];
+			const sourceSetting = source[key];
+			const targetSetting = target[key];
+			if (isMergeable(sourceSetting)) target[key] = merge(targetSetting || {}, sourceSetting);
+			else if (sourceSetting !== void 0) target[key] = sourceSetting;
+		}
+	}
+	return target;
+}
+/**
+* Determines whether the given value can be merged,
+* or if it is a scalar value that should just override the target value.
+*
+* @param val
+* @returns
+*/
+function isMergeable(val) {
+	return val && typeof val === "object" && !Array.isArray(val) && !(val instanceof RegExp) && !(val instanceof Date);
+}
+//#endregion
+export { getJsonSchemaRefParserDefaultOptions, getNewOptions };

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/parse.js

@@ -0,0 +1,109 @@
+import { getExtension } from "./util/url.js";
+import { ParserError, ResolverError, UnmatchedParserError, UnmatchedResolverError, isHandledError } from "./util/errors.js";
+import { registerSchemaResources, usesDynamicIdScope } from "./util/schema-resources.js";
+import { all, filter, run, sort } from "./util/plugins.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/parse.js
+/**
+* Reads and parses the specified file path or URL.
+*/
+async function parse(target, $refs, options) {
+	let path = typeof target === "string" ? target : target.url;
+	const baseUrl = typeof target === "string" ? void 0 : target.baseUrl;
+	let reference = typeof target === "string" ? void 0 : target.reference;
+	const hashIndex = path.indexOf("#");
+	let hash = "";
+	if (hashIndex >= 0) {
+		hash = path.substring(hashIndex);
+		path = path.substring(0, hashIndex);
+	}
+	if (reference) {
+		const referenceHashIndex = reference.indexOf("#");
+		if (referenceHashIndex >= 0) reference = reference.substring(0, referenceHashIndex);
+	}
+	const $ref = $refs._add(path);
+	const file = {
+		url: path,
+		hash,
+		extension: getExtension(path),
+		...reference !== void 0 ? { reference } : {},
+		...baseUrl !== void 0 ? { baseUrl } : {}
+	};
+	try {
+		const resolver = await readFile(file, options, $refs);
+		$ref.pathType = resolver.plugin.name;
+		file.data = resolver.result;
+		const parser = await parseFile(file, options, $refs);
+		$ref.value = parser.result;
+		$ref.dynamicIdScope = usesDynamicIdScope($ref.value);
+		registerSchemaResources($refs, $ref.path, $ref.value, $ref.pathType, $ref.dynamicIdScope);
+		return parser.result;
+	} catch (err) {
+		if (isHandledError(err)) $ref.value = err;
+		throw err;
+	}
+}
+/**
+* Reads the given file, using the configured resolver plugins
+*
+* @param file           - An object containing information about the referenced file
+* @param file.url       - The full URL of the referenced file
+* @param file.extension - The lowercased file extension (e.g. ".txt", ".html", etc.)
+* @param options
+* @param $refs
+* @returns
+* The promise resolves with the raw file contents and the resolver that was used.
+*/
+async function readFile(file, options, $refs) {
+	let resolvers = all(options.resolve);
+	resolvers = filter(resolvers, "canRead", file, void 0, $refs);
+	sort(resolvers);
+	try {
+		return await run(resolvers, "read", file, $refs);
+	} catch (err) {
+		if (!err && options.continueOnError) throw new UnmatchedResolverError(file.url);
+		else if (!err || !("error" in err)) throw new SyntaxError(`Unable to resolve $ref pointer "${file.url}"`, { cause: err });
+		else if (err.error instanceof ResolverError) throw err.error;
+		else throw new ResolverError(err, file.url);
+	}
+}
+/**
+* Parses the given file's contents, using the configured parser plugins.
+*
+* @param file           - An object containing information about the referenced file
+* @param file.url       - The full URL of the referenced file
+* @param file.extension - The lowercased file extension (e.g. ".txt", ".html", etc.)
+* @param file.data      - The file contents. This will be whatever data type was returned by the resolver
+* @param options
+* @param $refs
+*
+* @returns
+* The promise resolves with the parsed file contents and the parser that was used.
+*/
+async function parseFile(file, options, $refs) {
+	const allParsers = all(options.parse);
+	const filteredParsers = filter(allParsers, "canParse", file);
+	const parsers = filteredParsers.length > 0 ? filteredParsers : allParsers;
+	sort(parsers);
+	try {
+		const parser = await run(parsers, "parse", file, $refs);
+		if (!parser.plugin.allowEmpty && isEmpty(parser.result)) throw new SyntaxError(`Error parsing "${file.url}" as ${parser.plugin.name}. \nParsed value is empty`);
+		else return parser;
+	} catch (err) {
+		if (!err && options.continueOnError) throw new UnmatchedParserError(file.url);
+		else if (err && err.message && err.message.startsWith("Error parsing")) throw err;
+		else if (!err || !("error" in err)) throw new SyntaxError(`Unable to parse ${file.url}`, { cause: err });
+		else if (err.error instanceof ParserError) throw err.error;
+		else throw new ParserError(err.error.message, file.url);
+	}
+}
+/**
+* Determines whether the parsed value is "empty".
+*
+* @param value
+* @returns
+*/
+function isEmpty(value) {
+	return value === void 0 || typeof value === "object" && Object.keys(value).length === 0 || typeof value === "string" && value.trim().length === 0 || Buffer.isBuffer(value) && value.length === 0;
+}
+//#endregion
+export { parse as default };

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/parsers/binary.js

@@ -0,0 +1,30 @@
+//#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/parsers/binary.js
+const BINARY_REGEXP = /\.(jpeg|jpg|gif|png|bmp|ico)$/i;
+var binary_default = {
+	/**
+	* The order that this parser will run, in relation to other parsers.
+	*/
+	order: 400,
+	/**
+	* Whether to allow "empty" files (zero bytes).
+	*/
+	allowEmpty: true,
+	/**
+	* Determines whether this parser can parse a given file reference.
+	* Parsers that return true will be tried, in order, until one successfully parses the file.
+	* Parsers that return false will be skipped, UNLESS all parsers returned false, in which case
+	* every parser will be tried.
+	*/
+	canParse(file) {
+		return Buffer.isBuffer(file.data) && BINARY_REGEXP.test(file.url);
+	},
+	/**
+	* Parses the given data as a Buffer (byte array).
+	*/
+	parse(file) {
+		if (Buffer.isBuffer(file.data)) return file.data;
+		else return Buffer.from(file.data);
+	}
+};
+//#endregion
+export { binary_default as default };

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/parsers/json.js

@@ -0,0 +1,46 @@
+import { ParserError } from "../util/errors.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/parsers/json.js
+var json_default = {
+	/**
+	* The order that this parser will run, in relation to other parsers.
+	*/
+	order: 100,
+	/**
+	* Whether to allow "empty" files. This includes zero-byte files, as well as empty JSON objects.
+	*/
+	allowEmpty: true,
+	/**
+	* Determines whether this parser can parse a given file reference.
+	* Parsers that match will be tried, in order, until one successfully parses the file.
+	* Parsers that don't match will be skipped, UNLESS none of the parsers match, in which case
+	* every parser will be tried.
+	*/
+	canParse: ".json",
+	/**
+	* Allow JSON files with byte order marks (BOM)
+	*/
+	allowBOM: true,
+	/**
+	* Parses the given file as JSON
+	*/
+	async parse(file) {
+		let data = file.data;
+		if (Buffer.isBuffer(data)) data = data.toString();
+		if (typeof data === "string") if (data.trim().length === 0) return;
+		else try {
+			return JSON.parse(data);
+		} catch (e) {
+			if (this.allowBOM) try {
+				const firstCurlyBrace = data.indexOf("{");
+				data = data.slice(firstCurlyBrace);
+				return JSON.parse(data);
+			} catch (e) {
+				throw new ParserError(e.message, file.url);
+			}
+			throw new ParserError(e.message, file.url);
+		}
+		else return data;
+	}
+};
+//#endregion
+export { json_default as default };

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/parsers/text.js

@@ -0,0 +1,36 @@
+import { ParserError } from "../util/errors.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/parsers/text.js
+const TEXT_REGEXP = /\.(txt|htm|html|md|xml|js|min|map|css|scss|less|svg)$/i;
+var text_default = {
+	/**
+	* The order that this parser will run, in relation to other parsers.
+	*/
+	order: 300,
+	/**
+	* Whether to allow "empty" files (zero bytes).
+	*/
+	allowEmpty: true,
+	/**
+	* The encoding that the text is expected to be in.
+	*/
+	encoding: "utf8",
+	/**
+	* Determines whether this parser can parse a given file reference.
+	* Parsers that return true will be tried, in order, until one successfully parses the file.
+	* Parsers that return false will be skipped, UNLESS all parsers returned false, in which case
+	* every parser will be tried.
+	*/
+	canParse(file) {
+		return (typeof file.data === "string" || Buffer.isBuffer(file.data)) && TEXT_REGEXP.test(file.url);
+	},
+	/**
+	* Parses the given file as text
+	*/
+	parse(file) {
+		if (typeof file.data === "string") return file.data;
+		else if (Buffer.isBuffer(file.data)) return file.data.toString(this.encoding);
+		else throw new ParserError("data is not text", file.url);
+	}
+};
+//#endregion
+export { text_default as default };

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/parsers/yaml.js

@@ -0,0 +1,49 @@
+import { ParserError } from "../util/errors.js";
+import yaml, { JSON_SCHEMA } from "js-yaml";
+//#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/parsers/yaml.js
+var yaml_default = {
+	/**
+	* The order that this parser will run, in relation to other parsers.
+	*/
+	order: 200,
+	/**
+	* Whether to allow "empty" files. This includes zero-byte files, as well as empty JSON objects.
+	*/
+	allowEmpty: true,
+	/**
+	* Determines whether this parser can parse a given file reference.
+	* Parsers that match will be tried, in order, until one successfully parses the file.
+	* Parsers that don't match will be skipped, UNLESS none of the parsers match, in which case
+	* every parser will be tried.
+	*/
+	canParse: [
+		".yaml",
+		".yml",
+		".json"
+	],
+	/**
+	* Parses the given file as YAML
+	*
+	* @param file           - An object containing information about the referenced file
+	* @param file.url       - The full URL of the referenced file
+	* @param file.extension - The lowercased file extension (e.g. ".txt", ".html", etc.)
+	* @param file.data      - The file contents. This will be whatever data type was returned by the resolver
+	* @returns
+	*/
+	async parse(file) {
+		let data = file.data;
+		if (Buffer.isBuffer(data)) data = data.toString();
+		if (typeof data === "string") try {
+			return yaml.load(data, { schema: JSON_SCHEMA });
+		} catch {
+			try {
+				return yaml.load(data);
+			} catch (e) {
+				throw new ParserError(e?.message || "Parser Error", file.url);
+			}
+		}
+		else return data;
+	}
+};
+//#endregion
+export { yaml_default as default };