fumadocs-openapi 10.6.6 → 10.6.8

package/dist/utils/schema/sample.js

@@ -0,0 +1,442 @@
+import { require_deepmerge } from "../../node_modules/.pnpm/@fastify_deepmerge@3.2.1/node_modules/@fastify/deepmerge/index.js";
+import { isPlainObject } from "../is-plain-object.js";
+import { resolveRefSync } from "./resolve-ref.js";
+const mergeDeep = (0, require_deepmerge().deepmerge)({
+	all: true,
+	isMergeableObject(value) {
+		return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof RegExp) && !(value instanceof Date);
+	}
+});
+const SKIP = Symbol("skip");
+const defaultOptions = {
+	skipReadOnly: false,
+	maxSampleDepth: 15
+};
+let refResolving = {};
+const seenObjectStack = [];
+function clearCaches() {
+	refResolving = {};
+	seenObjectStack.length = 0;
+}
+function popStack(context) {
+	if (context) seenObjectStack.pop();
+}
+function inferType(schema) {
+	if (schema.type !== void 0) {
+		const t = schema.type;
+		return Array.isArray(t) ? t.length === 0 ? null : String(t[0]) : String(t);
+	}
+	for (const [kw, ty] of Object.entries({
+		multipleOf: "number",
+		maximum: "number",
+		exclusiveMaximum: "number",
+		minimum: "number",
+		exclusiveMinimum: "number",
+		maxLength: "string",
+		minLength: "string",
+		pattern: "string",
+		items: "array",
+		maxItems: "array",
+		minItems: "array",
+		uniqueItems: "array",
+		additionalItems: "array",
+		maxProperties: "object",
+		minProperties: "object",
+		required: "object",
+		additionalProperties: "object",
+		properties: "object",
+		patternProperties: "object",
+		dependencies: "object"
+	})) if (schema[kw] !== void 0) return ty;
+	return null;
+}
+function getCircularPlaceholder(type) {
+	if (type === "object") return {};
+	if (type === "array") return [];
+}
+function hashCode(str) {
+	let hash = 0;
+	for (let i = 0; i < str.length; i++) {
+		hash = (hash << 5) - hash + str.charCodeAt(i);
+		hash |= 0;
+	}
+	return hash;
+}
+function jsf32(a, b, c, d) {
+	return () => {
+		a |= 0;
+		b |= 0;
+		c |= 0;
+		d |= 0;
+		const t = a - (b << 27 | b >>> 5) | 0;
+		a = b ^ (c << 17 | c >>> 15);
+		b = c + d | 0;
+		c = d + t | 0;
+		d = a + t | 0;
+		return (d >>> 0) / 4294967296;
+	};
+}
+function uuidFromSeed(str) {
+	const hash = hashCode(str);
+	const random = jsf32(hash, hash, hash, hash);
+	return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+		const r = random() * 16 | 0;
+		return (c === "x" ? r : r & 3 | 8).toString(16);
+	});
+}
+function toRFCDateTime(date, omitTime, omitDate, ms) {
+	const pad = (n) => n < 10 ? `0${n}` : `${n}`;
+	let res = omitDate ? "" : `${date.getUTCFullYear()}-${pad(date.getUTCMonth() + 1)}-${pad(date.getUTCDate())}`;
+	if (!omitTime) {
+		res += `T${pad(date.getUTCHours())}:${pad(date.getUTCMinutes())}:${pad(date.getUTCSeconds())}`;
+		if (ms) res += `.${(date.getUTCMilliseconds() / 1e3).toFixed(3).slice(2, 5)}`;
+		res += "Z";
+	}
+	return res;
+}
+function ensureMinLength(sample, min) {
+	if (min > sample.length) return sample.repeat(Math.trunc(min / sample.length) + 1).substring(0, min);
+	return sample;
+}
+function sampleBoolean() {
+	return true;
+}
+function sampleNumber(schema) {
+	let res = 0;
+	if (schema.type === "number" && (schema.format === "float" || schema.format === "double")) res = .1;
+	const exMinB = typeof schema.exclusiveMinimum === "boolean";
+	const exMaxB = typeof schema.exclusiveMaximum === "boolean";
+	if (exMinB || exMaxB) {
+		if (schema.maximum != null && schema.minimum != null) {
+			const min = schema.minimum;
+			const max = schema.maximum;
+			res = schema.exclusiveMinimum ? Math.floor(min) + 1 : min;
+			if (schema.exclusiveMaximum && res >= max || !schema.exclusiveMaximum && res > max) res = (max + min) / 2;
+			return res;
+		}
+		if (schema.minimum != null) {
+			const min = schema.minimum;
+			return schema.exclusiveMinimum ? Math.floor(min) + 1 : min;
+		}
+		if (schema.maximum != null) {
+			const max = schema.maximum;
+			if (schema.exclusiveMaximum) return max > 0 ? 0 : Math.floor(max) - 1;
+			return max > 0 ? 0 : max;
+		}
+	} else {
+		if (schema.minimum != null) return schema.minimum;
+		if (schema.exclusiveMinimum != null) {
+			res = Math.floor(schema.exclusiveMinimum) + 1;
+			if (res === schema.exclusiveMaximum) res = (res + Math.floor(schema.exclusiveMaximum) - 1) / 2;
+		} else if (schema.exclusiveMaximum != null) res = Math.floor(schema.exclusiveMaximum) - 1;
+		else if (schema.maximum != null) res = schema.maximum;
+	}
+	return res;
+}
+function defaultStringSample(min, max, pattern, enablePatterns) {
+	if (pattern && enablePatterns) return patternSample(pattern);
+	let res = ensureMinLength("string", min);
+	if (max != null && res.length > max) res = res.substring(0, max);
+	return res;
+}
+/** Minimal pattern sampler for `enablePatterns` (subset of openapi-sampler). */
+function patternSample(pattern) {
+	const stripped = pattern.replace(/^\^?/, "").replace(/\$?$/, "");
+	const m = stripped.match(/^(.)\{(\d+)\}$/);
+	if (m) return m[1].repeat(parseInt(m[2], 10));
+	return stripped.length > 0 ? stripped : "x";
+}
+function sampleString(schema, options, _spec, context) {
+	const format = schema.format || "default";
+	const propertyName = context?.propertyName;
+	const min = schema.minLength ?? 0;
+	const max = schema.maxLength;
+	const pattern = schema.pattern;
+	const fixed = /* @__PURE__ */ new Date("2019-08-24T14:15:22.123Z");
+	const formats = {
+		email: () => "user@example.com",
+		"idn-email": () => "пошта@укр.нет",
+		password: () => {
+			let res = "pa$$word";
+			if (min > res.length) {
+				res += "_";
+				res += ensureMinLength("qwerty!@#$%^123456", min - res.length).substring(0, min - res.length);
+			}
+			return res;
+		},
+		"date-time": () => toRFCDateTime(fixed, false, false, false),
+		date: () => toRFCDateTime(fixed, true, false, false),
+		time: () => toRFCDateTime(fixed, false, true, false).slice(1),
+		ipv4: () => "192.168.0.1",
+		ipv6: () => "2001:0db8:85a3:0000:0000:8a2e:0370:7334",
+		hostname: () => "example.com",
+		"idn-hostname": () => "приклад.укр",
+		uri: () => "http://example.com",
+		"uri-reference": () => "../dictionary",
+		"uri-template": () => "http://example.com/{endpoint}",
+		iri: () => "http://example.com/entity/1",
+		"iri-reference": () => "/entity/1",
+		uuid: () => uuidFromSeed(propertyName || "id"),
+		"json-pointer": () => "/json/pointer",
+		"relative-json-pointer": () => "1/relative/json/pointer",
+		regex: () => "/regex/",
+		default: () => defaultStringSample(min, max, pattern, options.enablePatterns)
+	};
+	return (formats[format] ?? formats.default)();
+}
+function sampleArray(schema, options, spec, context) {
+	const depth = context?.depth ?? 1;
+	let arrayLength = Math.min(schema.maxItems != null ? schema.maxItems : Number.POSITIVE_INFINITY, schema.minItems ?? 1);
+	const items = schema.prefixItems ?? schema.items ?? schema.contains;
+	if (Array.isArray(items)) arrayLength = Math.max(arrayLength, items.length);
+	const itemSchemaGetter = (i) => {
+		if (Array.isArray(items)) return items[i] ?? {};
+		return items ?? {};
+	};
+	const res = [];
+	if (!items) return res;
+	for (let i = 0; i < arrayLength; i++) {
+		const { value } = traverse(itemSchemaGetter(i), options, spec, {
+			depth: depth + 1,
+			propertyName: context?.propertyName
+		});
+		res.push(value);
+	}
+	return res;
+}
+function sampleObject(schema, options, spec, context) {
+	let res = {};
+	const depth = context?.depth ?? 1;
+	if (schema.properties && typeof schema.properties === "object") {
+		const required = Array.isArray(schema.required) ? schema.required : [];
+		const requiredSet = new Set(required);
+		for (const propertyName of Object.keys(schema.properties)) {
+			if (options.skipNonRequired && !requiredSet.has(propertyName)) continue;
+			const propSchema = schema.properties[propertyName];
+			const sample = traverse(propSchema, options, spec, {
+				propertyName,
+				depth: depth + 1
+			});
+			if (options.skipReadOnly && sample.readOnly) {
+				if (context?.isAllOfChild) res[propertyName] = SKIP;
+				continue;
+			}
+			if (options.skipWriteOnly && sample.writeOnly) {
+				if (context?.isAllOfChild) res[propertyName] = SKIP;
+				continue;
+			}
+			res[propertyName] = sample.value;
+		}
+	}
+	if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
+		const ap = schema.additionalProperties;
+		const baseName = ap["x-additionalPropertiesName"] || "property";
+		res[`${String(baseName)}1`] = traverse(ap, options, spec, { depth: depth + 1 }).value;
+		res[`${String(baseName)}2`] = traverse(ap, options, spec, { depth: depth + 1 }).value;
+	}
+	if (schema.properties && typeof schema.properties === "object" && typeof schema.maxProperties === "number" && Object.keys(res).length > schema.maxProperties) {
+		const filtered = {};
+		let added = 0;
+		const req = Array.isArray(schema.required) ? schema.required : [];
+		for (const name of req) if (res[name] !== void 0) {
+			filtered[name] = res[name];
+			added++;
+		}
+		for (const name of Object.keys(res)) if (added < schema.maxProperties && !(name in filtered)) {
+			filtered[name] = res[name];
+			added++;
+		}
+		res = filtered;
+	}
+	return res;
+}
+function inferExample(schema) {
+	if (schema.const !== void 0) return schema.const;
+	if (Array.isArray(schema.examples) && schema.examples.length > 0) return schema.examples[0];
+	if (Array.isArray(schema.enum) && schema.enum.length > 0) return schema.enum[0];
+	if (schema.default !== void 0) return schema.default;
+}
+function tryInferExample(schema) {
+	const example = inferExample(schema);
+	if (example !== void 0) return {
+		value: example,
+		readOnly: schema.readOnly,
+		writeOnly: schema.writeOnly,
+		type: null
+	};
+}
+function allOfSample(into, children, options, spec, context) {
+	const res = traverse(into, options, spec);
+	const subSamples = [];
+	for (const subSchema of children) {
+		const { type, readOnly, writeOnly, value } = traverse({
+			type: res.type,
+			...subSchema
+		}, options, spec, {
+			...context,
+			depth: context?.depth ?? 1,
+			isAllOfChild: true
+		});
+		if (res.type && type && type !== res.type) {
+			if (!options.quiet) console.warn("allOf: schemas with different types can't be merged");
+			res.type = type;
+		}
+		res.type = res.type ?? type;
+		res.readOnly = res.readOnly || readOnly;
+		res.writeOnly = res.writeOnly || writeOnly;
+		if (value != null) subSamples.push(value);
+	}
+	if (res.type === "object") {
+		const merged = mergeDeep(res.value || {}, ...subSamples.filter((s) => typeof s === "object" && s !== null));
+		for (const key of Object.keys(merged)) if (merged[key] === SKIP) delete merged[key];
+		return {
+			...res,
+			value: merged
+		};
+	}
+	if (res.type === "array") {
+		if (!options.quiet) console.warn("OpenAPI Sampler: found allOf with \"array\" type. Result may be incorrect");
+	}
+	const last = subSamples[subSamples.length - 1];
+	return {
+		...res,
+		value: last != null ? last : res.value
+	};
+}
+const typeSamplers = {
+	array: sampleArray,
+	boolean: sampleBoolean,
+	integer: sampleNumber,
+	number: sampleNumber,
+	object: sampleObject,
+	string: sampleString
+};
+function traverseOneOrAnyOf(parent, selectedSubSchema, options, spec, context) {
+	const inferred = tryInferExample(parent);
+	if (inferred !== void 0) return inferred;
+	const localExample = traverse({
+		...parent,
+		oneOf: void 0,
+		anyOf: void 0
+	}, options, spec, context);
+	const subExample = traverse(selectedSubSchema, options, spec, context);
+	if (typeof localExample.value === "object" && localExample.value !== null && typeof subExample.value === "object" && subExample.value !== null) {
+		const mergedExample = mergeDeep(localExample.value, subExample.value);
+		return {
+			...subExample,
+			value: mergedExample
+		};
+	}
+	return subExample;
+}
+function traverse(schema, options, spec, context) {
+	if (context) {
+		if (seenObjectStack.includes(schema)) return {
+			value: getCircularPlaceholder(inferType(schema)),
+			type: null
+		};
+		seenObjectStack.push(schema);
+	}
+	if (context && (context.depth ?? 1) > options.maxSampleDepth) {
+		popStack(context);
+		return {
+			value: getCircularPlaceholder(inferType(schema)),
+			type: null
+		};
+	}
+	if (!isPlainObject(schema)) {
+		popStack(context);
+		return {
+			value: schema,
+			type: null
+		};
+	}
+	const s = schema;
+	if (typeof s.$ref === "string") {
+		if (spec == null) throw new Error("Your schema contains $ref. You must provide full specification in the third parameter.");
+		const ref = decodeURIComponent(s.$ref);
+		if (!ref.startsWith("#")) throw new Error("Your schema contains $ref. Only in-document references (`#/…`) are supported.");
+		if (refResolving[ref]) {
+			const referencedType = inferType(resolveRefSync(ref, spec) ?? {});
+			popStack(context);
+			return {
+				value: getCircularPlaceholder(referencedType),
+				type: null
+			};
+		}
+		refResolving[ref] = true;
+		const referenced = resolveRefSync(ref, spec);
+		if (referenced === void 0) {
+			refResolving[ref] = false;
+			popStack(context);
+			throw new Error(`Could not resolve $ref: ${s.$ref}`);
+		}
+		const result = traverse(referenced, options, spec, context);
+		refResolving[ref] = false;
+		popStack(context);
+		return result;
+	}
+	if (s.example !== void 0) {
+		popStack(context);
+		return {
+			value: s.example,
+			readOnly: s.readOnly,
+			writeOnly: s.writeOnly,
+			type: s.type
+		};
+	}
+	if (s.allOf !== void 0) {
+		popStack(context);
+		return tryInferExample(s) ?? allOfSample({
+			...s,
+			allOf: void 0
+		}, s.allOf, options, spec, context);
+	}
+	if (s.oneOf && Array.isArray(s.oneOf) && s.oneOf.length > 0) {
+		if (s.anyOf && !options.quiet) console.warn("oneOf and anyOf are not supported on the same level. Skipping anyOf");
+		popStack(context);
+		return traverseOneOrAnyOf(s, Object.assign({
+			readOnly: s.readOnly,
+			writeOnly: s.writeOnly
+		}, s.oneOf[0]), options, spec, context);
+	}
+	if (s.anyOf && Array.isArray(s.anyOf) && s.anyOf.length > 0) {
+		popStack(context);
+		return traverseOneOrAnyOf(s, Object.assign({
+			readOnly: s.readOnly,
+			writeOnly: s.writeOnly
+		}, s.anyOf[0]), options, spec, context);
+	}
+	if (s.if && s.then) {
+		popStack(context);
+		const { if: ifSchema, then, ...rest } = s;
+		return traverse(mergeDeep(rest, ifSchema, then), options, spec, context);
+	}
+	let example = inferExample(s);
+	let type = null;
+	if (example === void 0) {
+		example = null;
+		type = s.type;
+		if (Array.isArray(type) && type.length > 0) type = type[0];
+		if (!type) type = inferType(s);
+		const sampler = type ? typeSamplers[type] : void 0;
+		if (sampler) example = sampler(s, options, spec, context);
+	}
+	popStack(context);
+	return {
+		value: example,
+		readOnly: s.readOnly,
+		writeOnly: s.writeOnly,
+		type
+	};
+}
+function sample(schema, options, spec) {
+	const opts = {
+		...defaultOptions,
+		...options
+	};
+	clearCaches();
+	return traverse(schema, opts, spec).value;
+}
+//#endregion
+export { sample };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fumadocs-openapi",
-  "version": "10.6.6",
+  "version": "10.6.8",
   "description": "Generate MDX docs for your OpenAPI spec",
   "keywords": [
     "Docs",
@@ -43,47 +43,45 @@
     "access": "public"
   },
   "dependencies": {
-    "@fastify/deepmerge": "^3.2.1",
     "@fumari/json-schema-ts": "^0.0.2",
     "@radix-ui/react-accordion": "^1.2.12",
     "@radix-ui/react-dialog": "^1.1.15",
     "@radix-ui/react-select": "^2.2.6",
     "@radix-ui/react-slot": "^1.2.4",
-    "@scalar/json-magic": "^0.12.4",
-    "@scalar/openapi-upgrader": "^0.2.2",
+    "@scalar/json-magic": "^0.12.5",
+    "@scalar/openapi-upgrader": "^0.2.4",
     "ajv": "^8.18.0",
     "chokidar": "^5.0.0",
     "class-variance-authority": "^0.7.1",
     "github-slugger": "^2.0.0",
     "hast-util-to-jsx-runtime": "^2.3.6",
     "js-yaml": "^4.1.1",
-    "lucide-react": "^1.7.0",
+    "lucide-react": "^1.8.0",
     "next-themes": "^0.4.6",
-    "openapi-sampler": "^1.7.2",
-    "react-hook-form": "^7.72.0",
     "remark": "^15.0.1",
     "remark-rehype": "^11.1.2",
     "tailwind-merge": "^3.5.0",
     "xml-js": "^1.6.11",
-    "@fumari/stf": "1.0.4"
+    "@fumari/stf": "1.0.5"
   },
   "devDependencies": {
-    "@scalar/api-client-react": "^1.4.15",
+    "@fastify/deepmerge": "^3.2.1",
+    "@scalar/api-client-react": "^2.0.1",
     "@types/js-yaml": "^4.0.9",
-    "@types/node": "25.5.0",
-    "@types/openapi-sampler": "^1.0.3",
+    "@types/node": "25.6.0",
     "@types/react": "^19.2.14",
+    "fast-content-type-parse": "^3.0.0",
     "json-schema-typed": "^8.0.2",
     "shiki": "^4.0.2",
     "tailwindcss": "^4.2.2",
-    "tsdown": "0.21.6",
-    "@fumadocs/tailwind": "0.0.3",
-    "fumadocs-core": "16.7.10",
-    "fumadocs-ui": "16.7.10",
+    "tsdown": "0.21.7",
+    "@fumadocs/tailwind": "0.0.4",
+    "fumadocs-core": "16.7.13",
+    "fumadocs-ui": "16.7.13",
     "tsconfig": "0.0.0"
   },
   "peerDependencies": {
-    "@scalar/api-client-react": "*",
+    "@scalar/api-client-react": "2.x.x",
     "@types/react": "*",
     "fumadocs-core": "^16.7.0",
     "fumadocs-ui": "^16.7.0",
@@ -106,6 +104,10 @@
       "optional": true
     }
   },
+  "inlinedDependencies": {
+    "@fastify/deepmerge": "3.2.1",
+    "fast-content-type-parse": "3.0.0"
+  },
   "scripts": {
     "build": "tsdown --config-loader unrun",
     "clean": "rimraf dist",