@fumadocs/api-docs 0.0.1

package/dist/schema/resolve-ref.d.ts

@@ -0,0 +1,4 @@
+//#region src/schema/resolve-ref.d.ts
+declare function resolveRefSync(ref: string, schema: unknown): unknown | undefined;
+//#endregion
+export { resolveRefSync };

package/dist/schema/resolve-ref.js

@@ -0,0 +1,11 @@
+import { decodeInternalRef } from "./ref.js";
+import { isPlainObject } from "../utils/is-plain-object.js";
+//#region src/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 };

package/dist/schema/sample.d.ts

@@ -0,0 +1,12 @@
+//#region src/schema/sample.d.ts
+interface JsonSchemaSampleOptions {
+  readonly skipNonRequired?: boolean;
+  readonly skipReadOnly?: boolean;
+  readonly skipWriteOnly?: boolean;
+  readonly quiet?: boolean;
+  readonly enablePatterns?: boolean;
+  readonly maxSampleDepth?: number;
+}
+declare function sample(schema: object, options?: JsonSchemaSampleOptions, spec?: object): unknown;
+//#endregion
+export { JsonSchemaSampleOptions, sample };

package/dist/schema/sample.js

@@ -0,0 +1,442 @@
+import { isPlainObject } from "../utils/is-plain-object.js";
+import { resolveRefSync } from "./resolve-ref.js";
+import { require_deepmerge } from "../node_modules/.pnpm/@fastify_deepmerge@3.2.1/node_modules/@fastify/deepmerge/index.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/dist/schema/to-string.d.ts

@@ -0,0 +1,10 @@
+import { ParsedSchema, SchemaResolver } from "./index.js";
+
+//#region src/schema/to-string.d.ts
+declare enum FormatFlags {
+  None = 0,
+  UseAlias = 1
+}
+declare function schemaToString(value: ParsedSchema, resolver?: SchemaResolver, flags?: FormatFlags): string;
+//#endregion
+export { FormatFlags, schemaToString };

package/dist/schema/to-string.js

@@ -0,0 +1,51 @@
+//#region src/schema/to-string.ts
+let FormatFlags = /* @__PURE__ */ function(FormatFlags) {
+	FormatFlags[FormatFlags["None"] = 0] = "None";
+	FormatFlags[FormatFlags["UseAlias"] = 1] = "UseAlias";
+	return FormatFlags;
+}({});
+function schemaToString(value, resolver, flags = 0) {
+	function union(union, sep, flags) {
+		const members = /* @__PURE__ */ new Set();
+		const out = [];
+		let nullable = false;
+		for (const item of union) {
+			const result = run(item, flags | 1);
+			if (result === "null") nullable = true;
+			else if (result !== "unknown" && !members.has(result)) {
+				out.push(result);
+				members.add(result);
+			}
+		}
+		if (nullable) out.push("null");
+		return out.join(sep);
+	}
+	function run(input, flags) {
+		const { dereferenced: schema, $ref: rawRef } = resolver?.(input) ?? { dereferenced: input };
+		if (schema === true) return "any";
+		else if (schema === false) return "never";
+		if ((flags & 1) === 1) {
+			if (schema.title) return schema.title;
+			if (typeof rawRef === "string") {
+				const ref = rawRef.split("/");
+				if (ref.length > 0) return ref[ref.length - 1];
+			}
+		}
+		if (Array.isArray(schema.type)) return union(schema.type.map((type) => ({
+			...schema,
+			type
+		})), " | ", flags);
+		if (schema.type === "array") return `array<${schema.items ? run(schema.items, flags | 1) : "unknown"}>`;
+		if (schema.oneOf && schema.anyOf) return `(${union(schema.oneOf, " | ", flags)}) & (${union(schema.anyOf, " | ", flags)})`;
+		const or = schema.oneOf ?? schema.anyOf;
+		if (or) return union(or, " | ", flags);
+		if (schema.allOf) return union(schema.allOf, " & ", flags);
+		if (schema.not) return `not (${run(schema.not, flags)})`;
+		if (schema.type === "string" && schema.format === "binary") return "file";
+		if (typeof schema.type === "string") return schema.type;
+		return "unknown";
+	}
+	return run(value, flags);
+}
+//#endregion
+export { FormatFlags, schemaToString };

package/dist/utils/cn.js

@@ -0,0 +1,2 @@
+import { twMerge as cn } from "tailwind-merge";
+export { cn };

package/dist/utils/deep-equal.js

@@ -0,0 +1,21 @@
+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/id-to-title.d.ts

@@ -0,0 +1,4 @@
+//#region src/utils/id-to-title.d.ts
+declare function idToTitle(id: string): string;
+//#endregion
+export { idToTitle };

package/dist/utils/id-to-title.js

@@ -0,0 +1,12 @@
+//#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

@@ -0,0 +1,8 @@
+//#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

@@ -0,0 +1,11 @@
+//#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/url.d.ts

@@ -0,0 +1,5 @@
+//#region src/utils/url.d.ts
+declare function joinURL(base: string, pathname: string): string;
+declare function resolveServerUrl(template: string, variables: Record<string, string>): string;
+//#endregion
+export { joinURL, resolveServerUrl };

package/dist/utils/url.js

@@ -0,0 +1,13 @@
+//#region src/utils/url.ts
+function joinURL(base, pathname) {
+	if (pathname.startsWith("/")) pathname = pathname.slice(1);
+	if (base.endsWith("/")) base = base.slice(0, -1);
+	if (pathname.length > 0) return base + "/" + pathname;
+	else return base;
+}
+function resolveServerUrl(template, variables) {
+	for (const [key, value] of Object.entries(variables)) template = template.replaceAll(`{${key}}`, value);
+	return template;
+}
+//#endregion
+export { joinURL, resolveServerUrl };