fumadocs-openapi 10.6.7 → 10.7.0

package/dist/node_modules/.pnpm/@scalar_json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/get-value-by-path.js

@@ -0,0 +1,42 @@
+import { getId } from "./get-schemas.js";
+//#region ../../node_modules/.pnpm/@scalar+json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/get-value-by-path.js
+/**
+* Traverses an object using an array of string segments (path keys) and returns
+* the value at the specified path along with its context (id if available).
+*
+* @param target - The root object to traverse.
+* @param segments - An array of string keys representing the path to traverse.
+* @returns An object containing the final context (id or previous context) and the value at the path.
+*
+* @example
+* const obj = {
+*   foo: {
+*     bar: {
+*       baz: 42
+*     }
+*   }
+* };
+* // Returns: { context: '', value: 42 }
+* getValueByPath(obj, ['foo', 'bar', 'baz']);
+*/
+function getValueByPath(target, segments) {
+	return segments.reduce((acc, key) => {
+		if (acc.value === void 0) return {
+			context: "",
+			value: void 0
+		};
+		if (typeof acc.value !== "object" || acc.value === null) return {
+			context: "",
+			value: void 0
+		};
+		return {
+			context: getId(acc.value) ?? acc.context,
+			value: acc.value?.[key]
+		};
+	}, {
+		context: "",
+		value: target
+	});
+}
+//#endregion
+export { getValueByPath };

package/dist/node_modules/.pnpm/@scalar_json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/is-file-path.js

@@ -0,0 +1,23 @@
+import { isHttpUrl } from "./is-http-url.js";
+import { isJsonObject } from "./is-json-object.js";
+import { isYaml } from "./is-yaml.js";
+//#region ../../node_modules/.pnpm/@scalar+json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/is-file-path.js
+/**
+* Checks if a string represents a file path by ensuring it's not a remote URL,
+* YAML content, or JSON content.
+*
+* @param value - The string to check
+* @returns true if the string appears to be a file path, false otherwise
+* @example
+* ```ts
+* isFilePath('./schemas/user.json') // true
+* isFilePath('https://example.com/schema.json') // false
+* isFilePath('{"type": "object"}') // false
+* isFilePath('type: object') // false
+* ```
+*/
+function isFilePath(value) {
+	return !isHttpUrl(value) && !isYaml(value) && !isJsonObject(value);
+}
+//#endregion
+export { isFilePath };

package/dist/node_modules/.pnpm/@scalar_json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/is-http-url.js

@@ -0,0 +1,23 @@
+//#region ../../node_modules/.pnpm/@scalar+json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/is-http-url.js
+/**
+* Checks if a string is a remote URL (starts with http:// or https://)
+* @param value - The URL string to check
+* @returns true if the string is a remote URL, false otherwise
+* @example
+* ```ts
+* isHttpUrl('https://example.com/schema.json') // true
+* isHttpUrl('http://api.example.com/schemas/user.json') // true
+* isHttpUrl('#/components/schemas/User') // false
+* isHttpUrl('./local-schema.json') // false
+* ```
+*/
+function isHttpUrl(value) {
+	try {
+		const url = new URL(value);
+		return url.protocol === "http:" || url.protocol === "https:";
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { isHttpUrl };

package/dist/node_modules/.pnpm/@scalar_json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/is-json-object.js

@@ -0,0 +1,28 @@
+import { isObject } from "../../../../../../@scalar_helpers@0.4.3/node_modules/@scalar/helpers/dist/object/is-object.js";
+//#region ../../node_modules/.pnpm/@scalar+json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/is-json-object.js
+/**
+* Determines if a string represents a valid JSON object (i.e., a plain object, not an array, primitive, or null).
+* The function first checks if the string appears to start with an opening curly brace (ignoring leading whitespace),
+* which is a quick heuristic to rule out arrays, primitives, and most invalid JSON. If this check passes,
+* it attempts to parse the string with JSON.parse. The result is then checked to ensure it is a plain object
+* (not an array, null, or primitive) using the isObject utility.
+*
+* @param value - The string to evaluate
+* @returns true if the string is valid JSON and parses to a plain object, false otherwise
+*
+* @example
+* isJsonObject('{"foo": "bar"}') // true
+* isJsonObject('[1,2,3]') // false
+* isJsonObject('not json') // false
+* isJsonObject('42') // false
+*/
+function isJsonObject(value) {
+	if (!/^\s*(\{)/.test(value.slice(0, 500))) return false;
+	try {
+		return isObject(JSON.parse(value));
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { isJsonObject };

package/dist/node_modules/.pnpm/@scalar_json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/is-yaml.js

@@ -0,0 +1,21 @@
+//#region ../../node_modules/.pnpm/@scalar+json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/is-yaml.js
+/**
+* Checks if a string appears to be YAML content.
+* This function uses a simple heuristic: it looks for a line that starts with an optional dash,
+* followed by a key (alphanumeric or dash), a colon, and a value, and then at least one more line.
+* This is not a full YAML parser, but works for basic detection.
+*
+* @param value - The string to check
+* @returns true if the string looks like YAML, false otherwise
+*
+* @example
+* isYaml('openapi: 3.0.0\ninfo:\n  title: Example') // true
+* isYaml('{"openapi": "3.0.0", "info": {"title": "Example"}}') // false
+* isYaml('- name: value\n- name: value2') // true
+* isYaml('type: object') // false (only one line)
+*/
+function isYaml(value) {
+	return /^\s*(?:-\s*)?[\w\-]+\s*:\s*.+\n.*/.test(value);
+}
+//#endregion
+export { isYaml };

package/dist/node_modules/.pnpm/@scalar_json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/normalize.js

@@ -0,0 +1,26 @@
+import { parse } from "../../../../../../yaml@2.8.3/node_modules/yaml/browser/dist/public-api.js";
+import "../../../../../../yaml@2.8.3/node_modules/yaml/browser/index.js";
+//#region ../../node_modules/.pnpm/@scalar+json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/normalize.js
+/**
+* Normalize a string (YAML, JSON, object) to a JavaScript datatype.
+*/
+function normalize(content) {
+	if (content === null) return;
+	if (typeof content === "string") {
+		if (content.trim() === "") return;
+		try {
+			return JSON.parse(content);
+		} catch (_error) {
+			const hasColon = /^[^:]+:/.test(content);
+			const isJson = content.slice(0, 50).trimStart().startsWith("{");
+			if (!hasColon || isJson) return;
+			return parse(content, {
+				maxAliasCount: 1e4,
+				merge: true
+			});
+		}
+	}
+	return content;
+}
+//#endregion
+export { normalize };

package/dist/node_modules/.pnpm/@scalar_json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/resolve-reference-path.js

@@ -0,0 +1,30 @@
+import { isHttpUrl } from "./is-http-url.js";
+import { posix } from "../../../../../../pathe@2.0.3/node_modules/pathe/dist/index.js";
+//#region ../../node_modules/.pnpm/@scalar+json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/resolve-reference-path.js
+/**
+* Resolves a reference path by combining a base path with a relative path.
+* Handles both remote URLs and local file paths.
+*
+* @param base - The base path (can be a URL or local file path)
+* @param relativePath - The relative path to resolve against the base
+* @returns The resolved absolute path
+* @example
+* // Resolve remote URL
+* resolveReferencePath('https://example.com/api/schema.json', 'user.json')
+* // Returns: 'https://example.com/api/user.json'
+*
+* // Resolve local path
+* resolveReferencePath('/path/to/schema.json', 'user.json')
+* // Returns: '/path/to/user.json'
+*/
+const resolveReferencePath = (base, relativePath) => {
+	if (isHttpUrl(relativePath)) return relativePath;
+	if (isHttpUrl(base)) {
+		const baseUrl = new URL(base);
+		baseUrl.pathname = posix.posix.resolve("/", posix.dirname(baseUrl.pathname), relativePath);
+		return baseUrl.toString();
+	}
+	return posix.resolve(posix.dirname(base), relativePath);
+};
+//#endregion
+export { resolveReferencePath };

package/dist/node_modules/.pnpm/@scalar_json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/set-value-at-path.js

@@ -0,0 +1,70 @@
+import { preventPollution } from "../../../../../../@scalar_helpers@0.4.3/node_modules/@scalar/helpers/dist/object/prevent-pollution.js";
+import { getSegmentsFromPath } from "./get-segments-from-path.js";
+//#region ../../node_modules/.pnpm/@scalar+json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/set-value-at-path.js
+/**
+* Sets a value at a specified path in an object, creating intermediate objects/arrays as needed.
+* This function traverses the object structure and creates any missing intermediate objects
+* or arrays based on the path segments. If the next segment is a numeric string, it creates
+* an array instead of an object.
+*
+* ⚠️ Warning: Be careful with object keys that look like numbers (e.g. "123") as this function
+* will interpret them as array indices and create arrays instead of objects. If you need to
+* use numeric-looking keys, consider prefixing them with a non-numeric character.
+*
+* @param obj - The target object to set the value in
+* @param path - The JSON pointer path where the value should be set
+* @param value - The value to set at the specified path
+* @throws {Error} If attempting to set a value at the root path ('')
+*
+* @example
+* const obj = {}
+* setValueAtPath(obj, '/foo/bar/0', 'value')
+* // Result:
+* // {
+* //   foo: {
+* //     bar: ['value']
+* //   }
+* // }
+*
+* @example
+* const obj = { existing: { path: 'old' } }
+* setValueAtPath(obj, '/existing/path', 'new')
+* // Result:
+* // {
+* //   existing: {
+* //     path: 'new'
+* //   }
+* // }
+*
+* @example
+* // ⚠️ Warning: This will create an array instead of an object with key "123"
+* setValueAtPath(obj, '/foo/123/bar', 'value')
+* // Result:
+* // {
+* //   foo: [
+* //     undefined,
+* //     undefined,
+* //     undefined,
+* //     { bar: 'value' }
+* //   ]
+* // }
+*/
+function setValueAtPath(obj, path, value) {
+	if (path === "") throw new Error("Cannot set value at root ('') pointer");
+	const parts = getSegmentsFromPath(path);
+	parts.forEach((part) => preventPollution(part));
+	let current = obj;
+	for (let i = 0; i < parts.length; i++) {
+		const key = parts[i];
+		const isLast = i === parts.length - 1;
+		const nextKey = parts[i + 1];
+		const shouldBeArray = /^\d+$/.test(nextKey ?? "");
+		if (isLast) current[key] = value;
+		else {
+			if (!(key in current) || typeof current[key] !== "object") current[key] = shouldBeArray ? [] : {};
+			current = current[key];
+		}
+	}
+}
+//#endregion
+export { setValueAtPath };

package/dist/node_modules/.pnpm/@scalar_json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/to-relative-path.js

@@ -0,0 +1,33 @@
+import { isHttpUrl } from "./is-http-url.js";
+import { posix } from "../../../../../../pathe@2.0.3/node_modules/pathe/dist/index.js";
+//#region ../../node_modules/.pnpm/@scalar+json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/to-relative-path.js
+/**
+* Converts an input path or URL to a relative path based on the provided base.
+* Handles both remote URLs and local file system paths.
+* - If both input and base are remote URLs and share the same origin, computes the relative pathname.
+* - If base is a remote URL but input is local, returns a remote URL with a relative pathname.
+* - If input is a remote URL but base is local, returns input as is.
+* - Otherwise, computes the relative path between two local paths.
+*/
+const toRelativePath = (input, base) => {
+	if (isHttpUrl(input) && isHttpUrl(base)) {
+		const inputUrl = new URL(input);
+		const baseUrl = new URL(base);
+		if (inputUrl.origin !== baseUrl.origin) return input;
+		const baseDir = posix.dirname(posix.posix.resolve("/", baseUrl.pathname));
+		const inputPath = posix.posix.resolve("/", inputUrl.pathname);
+		return posix.posix.relative(baseDir, inputPath);
+	}
+	if (isHttpUrl(base)) {
+		const baseUrl = new URL(base);
+		const baseDir = posix.dirname(posix.posix.resolve("/", baseUrl.pathname));
+		baseUrl.pathname = posix.posix.relative(baseDir, posix.posix.resolve("/", input));
+		return baseUrl.toString();
+	}
+	if (isHttpUrl(input)) return input;
+	const baseDir = posix.dirname(posix.resolve(base));
+	const inputPath = posix.resolve(input);
+	return posix.relative(baseDir, inputPath);
+};
+//#endregion
+export { toRelativePath };

package/dist/node_modules/.pnpm/@scalar_json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/unescape-json-pointer.js

@@ -0,0 +1,12 @@
+//#region ../../node_modules/.pnpm/@scalar+json-magic@0.12.5/node_modules/@scalar/json-magic/dist/helpers/unescape-json-pointer.js
+/**
+* Unescape JSON pointer
+*
+* Examples:
+* /foo~1bar~0baz -> /foo/bar~baz
+*/
+function unescapeJsonPointer(uri) {
+	return decodeURI(uri.replace(/~1/g, "/").replace(/~0/g, "~"));
+}
+//#endregion
+export { unescapeJsonPointer };