fumadocs-openapi 10.10.2 → 11.0.0

package/dist/ui/schema/index.js

@@ -1,256 +0,0 @@
-import { I18nLabel } from "../client/i18n.js";
-import { mergeAllOf } from "../../utils/schema/merge.js";
-import { schemaToString } from "../../utils/schema/to-string.js";
-import { useMemo } from "react";
-import { jsx } from "react/jsx-runtime";
-//#region src/ui/schema/index.tsx
-function Schema({ ctx, client, root, readOnly, writeOnly }) {
-	const generated = useMemo(() => generateSchemaUI(root, readOnly, writeOnly, ctx), [
-		root,
-		readOnly,
-		writeOnly,
-		ctx
-	]);
-	if (ctx.schemaUI?.render) return ctx.schemaUI.render({
-		client,
-		root,
-		readOnly,
-		writeOnly
-	}, ctx);
-	return /* @__PURE__ */ jsx(ctx.clientBoundary.SchemaUI, {
-		...client,
-		generated
-	});
-}
-function generateSchemaUI(root, readOnly = false, writeOnly = false, ctx) {
-	const refs = {};
-	const { showExample = false } = ctx.schemaUI ?? {};
-	function generateInfoTags(schema) {
-		const fields = [];
-		if (schema.default !== void 0) fields.push({
-			label: /* @__PURE__ */ jsx(I18nLabel, { label: "schemaDefault" }),
-			value: JSON.stringify(schema.default)
-		});
-		if (schema.pattern) fields.push({
-			label: /* @__PURE__ */ jsx(I18nLabel, { label: "schemaMatch" }),
-			value: schema.pattern
-		});
-		if (schema.format) fields.push({
-			label: /* @__PURE__ */ jsx(I18nLabel, { label: "schemaFormat" }),
-			value: schema.format
-		});
-		if (schema.multipleOf) fields.push({
-			label: /* @__PURE__ */ jsx(I18nLabel, { label: "schemaMultipleOf" }),
-			value: schema.multipleOf.toString()
-		});
-		let range = formatRange("value", schema.minimum, schema.exclusiveMinimum, schema.maximum, schema.exclusiveMaximum);
-		if (range) fields.push({
-			label: /* @__PURE__ */ jsx(I18nLabel, { label: "schemaRange" }),
-			value: range
-		});
-		range = formatRange("length", schema.minLength, void 0, schema.maxLength, void 0);
-		if (range) fields.push({
-			label: /* @__PURE__ */ jsx(I18nLabel, { label: "schemaLength" }),
-			value: range
-		});
-		range = formatRange("properties", schema.minProperties, void 0, schema.maxProperties, void 0);
-		if (range) fields.push({
-			label: /* @__PURE__ */ jsx(I18nLabel, { label: "schemaProperties" }),
-			value: range
-		});
-		range = formatRange("items", schema.minItems, void 0, schema.maxItems, void 0);
-		if (range) fields.push({
-			label: /* @__PURE__ */ jsx(I18nLabel, { label: "schemaItems" }),
-			value: range
-		});
-		if (schema.enum) fields.push({
-			label: /* @__PURE__ */ jsx(I18nLabel, { label: "schemaValueIn" }),
-			value: schema.enum.map((value) => JSON.stringify(value)).join(" | ")
-		});
-		if (showExample && schema.examples) for (const example of schema.examples) fields.push({
-			label: /* @__PURE__ */ jsx(I18nLabel, { label: "schemaExample" }),
-			value: JSON.stringify(example, null, 2)
-		});
-		return fields;
-	}
-	let _counter = 0;
-	const autoIds = /* @__PURE__ */ new WeakMap();
-	function getSchemaId(schema) {
-		if (typeof schema === "boolean") return String(schema);
-		const raw = ctx.schema.getRawRef(schema);
-		if (raw) return raw;
-		const prev = autoIds.get(schema);
-		if (prev) return prev;
-		const generated = `__${_counter++}`;
-		autoIds.set(schema, generated);
-		return generated;
-	}
-	function isVisible(schema) {
-		if (typeof schema === "boolean") return true;
-		if (schema.writeOnly) return writeOnly;
-		if (schema.readOnly) return readOnly;
-		return true;
-	}
-	function base(schema) {
-		if (typeof schema === "boolean") {
-			const name = schema ? "any" : "never";
-			return {
-				typeName: name,
-				aliasName: name
-			};
-		}
-		return {
-			description: schema.description ? ctx.renderMarkdown(schema.description) : void 0,
-			infoTags: generateInfoTags(schema),
-			typeName: schemaToString(schema, ctx.schema),
-			aliasName: schemaToString(schema, ctx.schema, 1),
-			deprecated: schema.deprecated
-		};
-	}
-	function scanRefs(id, schema) {
-		if (id in refs) return;
-		if (typeof schema === "boolean") {
-			refs[id] = {
-				type: "primitive",
-				...base(schema)
-			};
-			return;
-		}
-		if (Array.isArray(schema.type)) {
-			const out = {
-				type: "or",
-				items: [],
-				...base(schema)
-			};
-			refs[id] = out;
-			for (const type of schema.type) {
-				const key = `${id}_type:${type}`;
-				scanRefs(key, {
-					...schema,
-					type
-				});
-				out.items.push({
-					name: type,
-					$type: key
-				});
-			}
-			return;
-		}
-		if (schema.oneOf && schema.anyOf) {
-			const out = {
-				type: "and",
-				items: [],
-				...base(schema)
-			};
-			refs[id] = out;
-			for (const omit of ["anyOf", "oneOf"]) {
-				const $type = `${id}_omit:${omit}`;
-				scanRefs($type, {
-					...schema,
-					[omit]: void 0
-				});
-				out.items.push({
-					name: refs[$type].aliasName,
-					$type
-				});
-			}
-			return;
-		}
-		const union = schema.oneOf ?? schema.anyOf;
-		if (union) {
-			const out = {
-				type: "or",
-				items: [],
-				...base(schema)
-			};
-			refs[id] = out;
-			for (const item of union) {
-				if (!item || typeof item !== "object" || !isVisible(item)) continue;
-				const itemId = getSchemaId(item);
-				const key = `${id}_extends:${itemId}`;
-				scanRefs(key, {
-					...schema,
-					oneOf: void 0,
-					anyOf: void 0,
-					...item,
-					properties: {
-						...schema.properties,
-						...item.properties
-					}
-				});
-				out.items.push({
-					$type: key,
-					name: refs[itemId]?.aliasName ?? schemaToString(item, ctx.schema, 1)
-				});
-			}
-			return;
-		}
-		if (schema.allOf) {
-			scanRefs(id, mergeAllOf(schema));
-			return;
-		}
-		if (schema.type === "object") {
-			const out = {
-				type: "object",
-				props: [],
-				...base(schema)
-			};
-			refs[id] = out;
-			const { properties = {}, patternProperties, additionalProperties } = schema;
-			const props = Object.entries(properties);
-			if (patternProperties) props.push(...Object.entries(patternProperties));
-			for (const [key, prop] of props) {
-				if (!prop || !isVisible(prop)) continue;
-				const $type = getSchemaId(prop);
-				scanRefs($type, prop);
-				out.props.push({
-					$type,
-					name: key,
-					required: schema.required?.includes(key) ?? false
-				});
-			}
-			if (additionalProperties && isVisible(additionalProperties)) {
-				const $type = getSchemaId(additionalProperties);
-				scanRefs($type, additionalProperties);
-				out.props.push({
-					$type,
-					name: "[key: string]",
-					required: false
-				});
-			}
-			return;
-		}
-		if (schema.type === "array") {
-			const items = schema.items ?? true;
-			const $type = getSchemaId(items);
-			refs[id] = {
-				type: "array",
-				item: { $type },
-				...base(schema)
-			};
-			scanRefs($type, items);
-			return;
-		}
-		refs[id] = {
-			type: "primitive",
-			...base(schema)
-		};
-	}
-	const $root = getSchemaId(root);
-	scanRefs($root, root);
-	return {
-		refs,
-		$root
-	};
-}
-function formatRange(value, min, exclusiveMin, max, exclusiveMax) {
-	const out = [];
-	if (min !== void 0) out.push(`${min} <=`);
-	else if (exclusiveMin !== void 0) out.push(`${exclusiveMin} <`);
-	out.push(value);
-	if (max !== void 0) out.push(`<= ${max}`);
-	else if (exclusiveMax !== void 0) out.push(`< ${exclusiveMax}`);
-	if (out.length > 1) return out.join(" ");
-}
-//#endregion
-export { Schema };

package/dist/utils/auto-anchor.client.js

@@ -1,20 +0,0 @@
-"use client";
-import { anchorSegments } from "./auto-anchor.js";
-import { createContext, use, useMemo } from "react";
-import { jsx } from "react/jsx-runtime";
-//#region src/utils/auto-anchor.client.tsx
-const AnchorContext = createContext([]);
-/** Append segment to anchor IDs */
-function AnchorSection({ segments, children }) {
-	const v = use(AnchorContext);
-	return /* @__PURE__ */ jsx(AnchorContext, {
-		value: useMemo(() => [...v, ...segments], [v, segments]),
-		children
-	});
-}
-function useAnchorId(segments) {
-	if (!segments) return null;
-	return anchorSegments(...use(AnchorContext), ...segments);
-}
-//#endregion
-export { AnchorSection, useAnchorId };

package/dist/utils/auto-anchor.js

@@ -1,17 +0,0 @@
-import { slug } from "github-slugger";
-//#region src/utils/auto-anchor.ts
-/** slugify segments, append `\0` to keep segment as-is */
-function anchorSegments(...segs) {
-	const mapped = [];
-	for (const seg of segs) if (seg.startsWith("\0")) mapped.push(seg.slice(1));
-	else if (seg.length > 0) mapped.push(slug(seg));
-	return mapped.join(".");
-}
-/**
-* Check if `id1` starts with `id2`
-*/
-function anchorIdStartsWith(id1, id2) {
-	return id1 === id2 || id1.startsWith(`${id2}.`);
-}
-//#endregion
-export { anchorIdStartsWith, anchorSegments };

package/dist/utils/deep-equal.js

@@ -1,21 +0,0 @@
-import { isPlainObject } from "./is-plain-object.js";
-//#region src/utils/deep-equal.ts
-function deepEqual(a, b) {
-	if (a === b) return true;
-	if (a == null || b == null) return false;
-	if (typeof a !== "object" || typeof b !== "object") return false;
-	if (Array.isArray(a) && Array.isArray(b)) {
-		if (a.length !== b.length) return false;
-		return a.every((item, index) => deepEqual(item, b[index]));
-	}
-	if (Array.isArray(a) || Array.isArray(b)) return false;
-	if (isPlainObject(a) && isPlainObject(b)) {
-		const keysA = Object.keys(a);
-		const keysB = Object.keys(b);
-		if (keysA.length !== keysB.length) return false;
-		return keysA.every((key) => key in b && deepEqual(a[key], b[key]));
-	}
-	return false;
-}
-//#endregion
-export { deepEqual };

package/dist/utils/document/process.d.ts

@@ -1,6 +0,0 @@
-import { DereferencedDocument } from "./dereference.js";
-
-//#region src/utils/document/process.d.ts
-type ProcessedDocument = DereferencedDocument;
-//#endregion
-export { ProcessedDocument };

package/dist/utils/document/process.js

@@ -1,18 +0,0 @@
-import { upgrade } from "../../node_modules/.pnpm/@scalar_openapi-upgrader@0.2.8/node_modules/@scalar/openapi-upgrader/dist/upgrade.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) {
-	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/dist/utils/id-to-title.js

@@ -1,12 +0,0 @@
-//#region src/utils/id-to-title.ts
-function idToTitle(id) {
-	let result = [];
-	for (const c of id) if (result.length === 0) result.push(c.toLocaleUpperCase());
-	else if (c === ".") result = [];
-	else if (/^[A-Z]$/.test(c) && result.at(-1) !== " ") result.push(" ", c);
-	else if (c === "-") result.push(" ");
-	else result.push(c);
-	return result.join("");
-}
-//#endregion
-export { idToTitle };

package/dist/utils/is-plain-object.js

@@ -1,8 +0,0 @@
-//#region src/utils/is-plain-object.ts
-function isPlainObject(value) {
-	if (typeof value !== "object" || value === null) return false;
-	const prototype = Object.getPrototypeOf(value);
-	return prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null;
-}
-//#endregion
-export { isPlainObject };

package/dist/utils/merge-refs.js

@@ -1,11 +0,0 @@
-//#region src/utils/merge-refs.ts
-function mergeRefs(...refs) {
-	return (value) => {
-		refs.forEach((ref) => {
-			if (typeof ref === "function") ref(value);
-			else if (ref != null) ref.current = value;
-		});
-	};
-}
-//#endregion
-export { mergeRefs };

package/dist/utils/schema/dereference.js

@@ -1,45 +0,0 @@
-import { isPlainObject } from "../is-plain-object.js";
-import { resolveRefSync } from "./resolve-ref.js";
-//#region src/utils/schema/dereference.ts
-/**
-* Resolves all $ref pointers in a schema and returns a new schema without any $ref pointers.
-*/
-function dereferenceSync(schema, setOriginalRef) {
-	if (typeof schema === "boolean") return schema;
-	const visitedNodes = /* @__PURE__ */ new Set();
-	const cloned = structuredClone(schema);
-	function resolve(current) {
-		if (visitedNodes.has(current)) return current;
-		visitedNodes.add(current);
-		if (Array.isArray(current)) for (let index = 0; index < current.length; index++) current[index] = resolve(current[index]);
-		else if (isPlainObject(current)) {
-			if (typeof current.$ref === "string") {
-				const ref = current["$ref"];
-				delete current["$ref"];
-				const resolved = resolve(resolveRefSync(ref, cloned));
-				setOriginalRef(resolved, ref);
-				setOriginalRef(current, ref);
-				if (typeof resolved === "boolean") throw new Error("invalid schema");
-				for (const k in resolved) if (!(k in current)) current[k] = resolved[k];
-			}
-			for (const key in current) current[key] = resolve(current[key]);
-		}
-		return current;
-	}
-	return resolve(cloned);
-}
-function dereferenceSwallow(schema, full) {
-	if (isPlainObject(schema)) {
-		if (typeof schema.$ref !== "string") return schema;
-		const { $ref, ...rest } = schema;
-		const resolved = dereferenceSwallow(resolveRefSync($ref, full), full);
-		if (typeof resolved !== "object") throw new Error(`invalid schema referenced via "${$ref}"`);
-		return {
-			...resolved,
-			...rest
-		};
-	}
-	return schema;
-}
-//#endregion
-export { dereferenceSwallow, dereferenceSync };

package/dist/utils/schema/index.d.ts

@@ -1,18 +0,0 @@
-import { ReferenceObject } from "../../types.js";
-import { JSONSchema } from "json-schema-typed/draft-2020-12";
-
-//#region src/utils/schema/index.d.ts
-type NoReference<T> = T extends (infer I)[] ? NoReference<I>[] : T extends ReferenceObject ? Exclude<T, ReferenceObject> : T extends object ? { [K in keyof T]: NoReference<T[K]> } : T;
-type ParsedSchema = (JSONSchema & {
-  'x-playground-lazy'?: boolean;
-  discriminator?: {
-    propertyName?: string;
-    mapping?: Record<string, string>;
-  };
-}) | boolean;
-interface SecurityEntry {
-  scopes: string[];
-  id: string;
-}
-//#endregion
-export { NoReference, ParsedSchema, SecurityEntry };

package/dist/utils/schema/merge.js

@@ -1,156 +0,0 @@
-import { deepEqual } from "../deep-equal.js";
-//#region src/utils/schema/merge.ts
-/**
-* Merge `allOf` object schema
-*/
-function mergeAllOf(schema, options = {}) {
-	if (typeof schema === "boolean") return schema;
-	const { dereference } = options;
-	if (dereference && "$ref" in schema && typeof schema.$ref === "string") schema = dereference(schema) ?? schema;
-	if (typeof schema === "boolean" || !schema.allOf) return schema;
-	const { allOf, ...rest } = schema;
-	let result = rest;
-	for (const item of allOf) result = intersection(result, item, options);
-	return result;
-}
-function intersection(a, b, options) {
-	a = mergeAllOf(a, options);
-	b = mergeAllOf(b, options);
-	if (typeof a === "boolean" && typeof b === "boolean") return a && b;
-	if (typeof a === "boolean") return a;
-	if (typeof b === "boolean") return b;
-	for (const unionField of ["anyOf", "oneOf"]) {
-		if (a[unionField] === void 0 && b[unionField] !== void 0) return {
-			...b,
-			[unionField]: b[unionField].map((item) => intersection(item, a, options))
-		};
-		if (a[unionField] !== void 0 && b[unionField] === void 0) return {
-			...a,
-			[unionField]: a[unionField].map((item) => intersection(item, b, options))
-		};
-	}
-	const result = { ...a };
-	for (const _k in b) {
-		const key = _k;
-		switch (key) {
-			case "$id":
-			case "$comment":
-			case "description":
-			case "examples":
-			case "allOf":
-			case "writeOnly":
-			case "readOnly": break;
-			case "title": {
-				const value = b[key];
-				if (value === void 0) break;
-				if (result[key]) result[key] = `${result[key]} & ${value}`;
-				else result[key] = value;
-				break;
-			}
-			case "minItems":
-			case "minimum":
-			case "exclusiveMinimum":
-			case "minProperties":
-			case "minContains":
-			case "minLength": {
-				const value = b[key];
-				if (value === void 0) break;
-				result[key] = result[key] === void 0 ? value : Math.max(result[key], value);
-				break;
-			}
-			case "maxContains":
-			case "maxItems":
-			case "maxLength":
-			case "maxProperties":
-			case "maximum":
-			case "exclusiveMaximum": {
-				const value = b[key];
-				if (value === void 0) break;
-				result[key] = result[key] === void 0 ? value : Math.min(result[key], value);
-				break;
-			}
-			case "enum": {
-				const value = b[key];
-				if (value === void 0) break;
-				result[key] = result[key] === void 0 ? value : intersectArray(result[key], value);
-				break;
-			}
-			case "anyOf":
-			case "oneOf": {
-				const value = b[key];
-				if (value !== void 0 && result[key] !== void 0) {
-					const product = [];
-					for (const aItem of result[key]) for (const bItem of value) {
-						const merged = intersection(aItem, bItem, options);
-						if (merged !== false) product.push(merged);
-					}
-					result[key] = product;
-				}
-				break;
-			}
-			case "format":
-			case "const":
-			case "type": {
-				const value = b[key];
-				if (value === void 0) break;
-				result[key] ??= value;
-				if (!deepEqual(result[key], value)) return false;
-				break;
-			}
-			case "required": {
-				const value = b[key];
-				if (value === void 0) break;
-				result[key] = [...result[key] ?? [], ...value];
-				break;
-			}
-			case "properties":
-			case "patternProperties": {
-				const value = b[key];
-				if (value === void 0) break;
-				if (result[key] === void 0) {
-					result[key] = value;
-					break;
-				}
-				const out = {};
-				const allProps = /* @__PURE__ */ new Set();
-				for (const k in result[key]) allProps.add(k);
-				for (const k in value) allProps.add(k);
-				for (const prop of allProps) {
-					const aProp = result[key][prop];
-					const bProp = value[prop];
-					if (aProp === void 0) out[prop] = bProp;
-					else if (bProp === void 0) out[prop] = aProp;
-					else out[prop] = intersection(aProp, bProp, options);
-				}
-				result[key] = out;
-				break;
-			}
-			case "additionalProperties":
-			case "additionalItems":
-			case "contains":
-			case "items": {
-				const value = b[key];
-				if (value === void 0) break;
-				result[key] = result[key] === void 0 ? value : intersection(result[key], value, options);
-				break;
-			}
-			case "not": {
-				const value = b[key];
-				if (value === void 0) break;
-				if (result[key] && value) result.not = { anyOf: [result[key], value] };
-				else if (value) result.not = value;
-				break;
-			}
-			default: result[key] = b[key];
-		}
-	}
-	return result;
-}
-function intersectArray(a, b) {
-	const out = /* @__PURE__ */ new Set();
-	for (const item of a) if (b.includes(item)) out.add(item);
-	for (const item of b) if (a.includes(item)) out.add(item);
-	return Array.from(out);
-}
-//#endregion
-export { mergeAllOf };

package/dist/utils/schema/pick.js

@@ -1,44 +0,0 @@
-import { isPlainObject } from "../is-plain-object.js";
-import { decodeInternalRef } from "./ref.js";
-import { resolveRefSync } from "./resolve-ref.js";
-//#region src/utils/schema/pick.ts
-/**
-* return a filtered object that only contains the given `$ref` & its referenced fields.
-*/
-function pickSchema(root, $ref) {
-	const out = {};
-	const scanned = /* @__PURE__ */ new Set();
-	function scan(next) {
-		if (isPlainObject(next)) {
-			if (typeof next.$ref === "string") {
-				if (scanned.has(next.$ref)) return;
-				const resolved = resolveRefSync(next.$ref, root);
-				scanned.add(next.$ref);
-				scan(resolved);
-				setField(out, decodeInternalRef(next.$ref), resolved);
-			}
-			for (const k in next) scan(next[k]);
-			return;
-		}
-		if (Array.isArray(next)) for (const item of next) scan(item);
-	}
-	scan({ $ref });
-	return out;
-}
-function setField(obj, field, value) {
-	if (field.length === 0) return value;
-	const out = isPlainObject(obj) ? obj : {};
-	let current = out;
-	for (let i = 0; i < field.length; i++) {
-		const k = field[i];
-		if (i === field.length - 1) current[k] = value;
-		else {
-			const v = current[k];
-			if (isPlainObject(v)) current = v;
-			else current = current[k] = {};
-		}
-	}
-	return out;
-}
-//#endregion
-export { pickSchema };

package/dist/utils/schema/ref.js

@@ -1,35 +0,0 @@
-//#region src/utils/schema/ref.ts
-/**
-* RFC 6901 reference-token encoding for JSON Pointer fragments used in in-document `$ref` (`#/…`).
-*
-* @see https://datatracker.ietf.org/doc/html/rfc6901
-*/
-function encodeSegment(segment) {
-	return segment.replace(/~/g, "~0").replace(/\//g, "~1");
-}
-function decodeSegment(segment) {
-	return segment.replace(/~1/g, "/").replace(/~0/g, "~");
-}
-/**
-* Build an in-document `$ref` string from logical path segments (e.g. `['components','schemas','Pet']` → `#/components/schemas/Pet`).
-*/
-function encodeInternalRef(segments) {
-	if (segments.length === 0) return "#/";
-	return `#/${segments.map(encodeSegment).join("/")}`;
-}
-/**
-* Parse an in-document `$ref` (`#/…`) into decoded path segments for walking the root document.
-*/
-function decodeInternalRef(ref) {
-	if (!ref.startsWith("#")) throw new Error("expected in-document $ref starting with `#`");
-	const raw = ref.slice(1);
-	const out = [];
-	if (raw.length === 0) return out;
-	for (const token of raw.split("/")) {
-		if (token.length === 0) continue;
-		out.push(decodeSegment(token));
-	}
-	return out;
-}
-//#endregion
-export { decodeInternalRef, encodeInternalRef };

package/dist/utils/schema/resolve-ref.js

@@ -1,11 +0,0 @@
-import { isPlainObject } from "../is-plain-object.js";
-import { decodeInternalRef } from "./ref.js";
-//#region src/utils/schema/resolve-ref.ts
-function resolveRefSync(ref, schema) {
-	let current = schema;
-	for (const seg of decodeInternalRef(ref)) if (isPlainObject(current)) current = current[seg];
-	else return;
-	return current;
-}
-//#endregion
-export { resolveRefSync };