@fumadocs/api-docs 0.0.2 → 0.0.4

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

@@ -1,136 +0,0 @@
-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/options.d.ts

@@ -1,166 +0,0 @@
-import { HTTPResolverOptions, JSONSchema, JSONSchemaObject, Plugin, ResolverOptions } from "./types/index.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.d.ts
-type DeepPartial<T> = T extends object ? { [P in keyof T]?: DeepPartial<T[P]> } : T;
-interface BundleOptions {
-  /**
-   * 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.
-   */
-  excludedPathMatcher?(path: string): boolean;
-  /**
-   * Callback invoked during bundling.
-   *
-   * @argument {string} path - The path being processed (ie. the `$ref` string)
-   * @argument {JSONSchemaObject} value - The JSON-Schema that the `$ref` resolved to
-   * @argument {JSONSchemaObject} parent - The parent of the processed object
-   * @argument {string} parentPropName - The prop name of the parent object whose value was processed
-   */
-  onBundle?(path: string, value: JSONSchemaObject, parent?: JSONSchemaObject, parentPropName?: string): void;
-  /**
-   * Whether to optimize internal `$ref` paths by following intermediate `$ref` chains and
-   * rewriting them to point directly to the final target. When `false`, intermediate `$ref`
-   * indirections are preserved as-is.
-   *
-   * Default: `true`
-   */
-  optimizeInternalRefs?: boolean;
-}
-interface DereferenceOptions {
-  /**
-   * Determines whether circular `$ref` pointers are handled.
-   *
-   * If set to `false`, then a `ReferenceError` will be thrown if the schema contains any circular references.
-   *
-   * If set to `"ignore"`, then circular references will simply be ignored. No error will be thrown, but the `$Refs.circular` property will still be set to `true`.
-   */
-  circular?: boolean | "ignore";
-  /**
-   * 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.
-   */
-  excludedPathMatcher?(path: string): boolean;
-  /**
-   * Callback invoked during circular reference detection.
-   *
-   * @argument {string} path - The path that is circular (ie. the `$ref` string)
-   */
-  onCircular?(path: string): void;
-  /**
-   * Callback invoked during dereferencing.
-   *
-   * @argument {string} path - The path being dereferenced (ie. the `$ref` string)
-   * @argument {JSONSchemaObject} value - The JSON-Schema that the `$ref` resolved to
-   * @argument {JSONSchemaObject} parent - The parent of the dereferenced object
-   * @argument {string} parentPropName - The prop name of the parent object whose value was dereferenced
-   */
-  onDereference?(path: string, value: JSONSchemaObject, parent?: JSONSchemaObject, parentPropName?: string): void;
-  /**
-   * An array of properties to preserve when dereferencing a `$ref` schema. Useful if you want to
-   * enforce non-standard dereferencing behavior like present in the OpenAPI 3.1 specification where
-   * `description` and `summary` properties are preserved when alongside a `$ref` pointer.
-   *
-   * If none supplied then no properties will be preserved and the object will be fully replaced
-   * with the dereferenced `$ref`.
-   */
-  preservedProperties?: string[];
-  /**
-   * Whether a reference should resolve relative to its directory/path, or from the cwd
-   *
-   * Default: `relative`
-   */
-  externalReferenceResolution?: "relative" | "root";
-  /**
-   * Whether duplicate keys should be merged when dereferencing objects.
-   *
-   * Default: `true`
-   */
-  mergeKeys?: boolean;
-  /**
-   * The maximum recursion depth for dereferencing nested schemas.
-   * If the schema nesting exceeds this depth, a RangeError will be thrown
-   * with a descriptive message instead of crashing with a stack overflow.
-   *
-   * Default: 500
-   */
-  maxDepth?: number;
-  /**
-   * Whether to create independent clones of each `$ref` target value instead of
-   * reusing the same JS object reference. When `false` (the default), multiple
-   * `$ref` pointers that resolve to the same value will all share the same object
-   * in memory, so modifying one will affect all others. When `true`, each `$ref`
-   * replacement gets its own deep copy, preventing unintended side effects from
-   * post-dereference mutations.
-   *
-   * Note: circular references are never cloned — they always maintain reference
-   * equality to correctly represent the circular structure.
-   *
-   * Default: `false`
-   */
-  cloneReferences?: boolean;
-}
-/**
- * Options that determine how JSON schemas are parsed, resolved, and dereferenced.
- *
- * @param [options] - Overridden options
- * @class
- */
-interface $RefParserOptions<S extends object = JSONSchema> {
-  /**
-   * The `parse` options determine how different types of files will be parsed.
-   *
-   * JSON Schema `$Ref` Parser comes with built-in JSON, YAML, plain-text, and binary parsers, any of which you can configure or disable. You can also add your own custom parsers if you want.
-   */
-  parse: {
-    json?: Plugin | boolean;
-    yaml?: Plugin | boolean;
-    binary?: Plugin | boolean;
-    text?: Plugin | boolean;
-    [key: string]: Plugin | boolean | undefined;
-  };
-  /**
-   * The `resolve` options control how JSON Schema $Ref Parser will resolve file paths and URLs, and how those files will be read/downloaded.
-   *
-   * JSON Schema `$Ref` Parser comes with built-in support for HTTP and HTTPS, as well as support for local files (when running in Node.js). You can configure or disable either of these built-in resolvers. You can also add your own custom resolvers if you want.
-   */
-  resolve: {
-    /**
-     * Determines whether external $ref pointers will be resolved. If this option is disabled, then external `$ref` pointers will simply be ignored.
-     */
-    external?: boolean;
-    file?: Partial<ResolverOptions<S>> | boolean;
-    http?: HTTPResolverOptions<S> | boolean;
-  } & {
-    [key: string]: Partial<ResolverOptions<S>> | HTTPResolverOptions<S> | boolean | undefined;
-  };
-  /**
-   * 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: boolean;
-  /**
-   * The `bundle` options control how JSON Schema `$Ref` Parser will process `$ref` pointers within the JSON schema.
-   */
-  bundle: BundleOptions;
-  /**
-   * The `dereference` options control how JSON Schema `$Ref` Parser will dereference `$ref` pointers within the JSON schema.
-   */
-  dereference: DereferenceOptions;
-  /**
-   * Whether to clone the schema before dereferencing it.
-   * This is useful when you want to dereference the same schema multiple times, but you don't want to modify the original schema.
-   * Default: `true` due to mutating the input being the default behavior historically
-   */
-  mutateInputSchema?: boolean;
-  /**
-   * The maximum amount of time (in milliseconds) that JSON Schema $Ref Parser will spend dereferencing a single schema.
-   * It will throw a timeout error if the operation takes longer than this.
-   */
-  timeoutMs?: number;
-}
-type ParserOptions<S extends object = JSONSchema> = DeepPartial<$RefParserOptions<S>>;
-//#endregion
-export { ParserOptions };

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

@@ -1,124 +0,0 @@
-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/parsers/binary.js

@@ -1,30 +0,0 @@
-//#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/text.js

@@ -1,36 +0,0 @@
-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/pointer.d.ts

@@ -1,96 +0,0 @@
-import { JSONSchema } from "./types/index.js";
-import { ParserOptions } from "./options.js";
-import { $Ref } from "./ref.js";
-import { JSONSchema4Type, JSONSchema6Type, JSONSchema7Type } from "json-schema";
-
-//#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/pointer.d.ts
-/**
- * This class represents a single JSON pointer and its resolved value.
- *
- * @param $ref
- * @param path
- * @param [friendlyPath] - The original user-specified path (used for error messages)
- * @class
- */
-declare class Pointer<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>> {
-  /**
-   * The {@link $Ref} object that contains this {@link Pointer} object.
-   */
-  $ref: $Ref<S, O>;
-  /**
-   * The file path or URL, containing the JSON pointer in the hash.
-   * This path is relative to the path of the main JSON schema file.
-   */
-  path: string;
-  /**
-   * The original path or URL, used for error messages.
-   */
-  originalPath: string;
-  /**
-   * The current base URI used to resolve nested $ref pointers while walking this pointer.
-   */
-  scopeBase: string;
-  /**
-   * The value of the JSON pointer.
-   * Can be any JSON type, not just objects. Unknown file types are represented as Buffers (byte arrays).
-   */
-  value: any;
-  /**
-   * Indicates whether the pointer references itself.
-   */
-  circular: boolean;
-  /**
-   * The number of indirect references that were traversed to resolve the value.
-   * Resolving a single pointer may require resolving multiple $Refs.
-   */
-  indirections: number;
-  constructor($ref: $Ref<S, O>, path: string, friendlyPath?: string);
-  /**
-   * Resolves the value of a nested property within the given object.
-   *
-   * @param obj - The object that will be crawled
-   * @param options
-   * @param pathFromRoot - the path of place that initiated resolving
-   *
-   * @returns
-   * Returns a JSON pointer whose {@link Pointer#value} is the resolved value.
-   * If resolving this value required resolving other JSON references, then
-   * the {@link Pointer#$ref} and {@link Pointer#path} will reflect the resolution path
-   * of the resolved value.
-   */
-  resolve(obj: S, options?: O, pathFromRoot?: string): this;
-  /**
-   * Sets the value of a nested property within the given object.
-   *
-   * @param obj - The object that will be crawled
-   * @param value - the value to assign
-   * @param options
-   *
-   * @returns
-   * Returns the modified object, or an entirely new object if the entire object is overwritten.
-   */
-  set(obj: S, value: JSONSchema4Type | JSONSchema6Type | JSONSchema7Type, options?: O): string | number | boolean | import("json-schema").JSONSchema4Object | import("json-schema").JSONSchema4Array | S | null;
-  /**
-   * Parses a JSON pointer (or a path containing a JSON pointer in the hash)
-   * and returns an array of the pointer's tokens.
-   * (e.g. "schema.json#/definitions/person/name" => ["definitions", "person", "name"])
-   *
-   * The pointer is parsed according to RFC 6901
-   * {@link https://tools.ietf.org/html/rfc6901#section-3}
-   *
-   * @param path
-   * @param [originalPath]
-   * @returns
-   */
-  static parse(path: string, originalPath?: string): string[];
-  /**
-   * Creates a JSON pointer path, by joining one or more tokens to a base path.
-   *
-   * @param base - The base path (e.g. "schema.json#/definitions/person")
-   * @param tokens - The token(s) to append (e.g. ["name", "first"])
-   * @returns
-   */
-  static join(base: string, tokens: string | string[]): string;
-}
-//#endregion
-export { Pointer };