@gitbook/react-openapi 1.5.1 → 1.5.2

package/dist/context.js

@@ -0,0 +1,29 @@
+import { translations } from "./translations/index.js";
+
+//#region src/context.ts
+/**
+* Resolve OpenAPI context from the input.
+*/
+function resolveOpenAPIContext(context) {
+	const { locale,...rest } = context;
+	return {
+		...rest,
+		translation: translations[locale ?? "en"]
+	};
+}
+/**
+* Get the client context from the OpenAPI context.
+*/
+function getOpenAPIClientContext(context) {
+	return {
+		translation: context.translation,
+		icons: context.icons,
+		defaultInteractiveOpened: context.defaultInteractiveOpened,
+		blockKey: context.blockKey,
+		id: context.id,
+		$$isClientContext$$: true
+	};
+}
+
+//#endregion
+export { getOpenAPIClientContext, resolveOpenAPIContext };

package/dist/decycle.js

@@ -0,0 +1,41 @@
+//#region src/decycle.ts
+const isObject = (value) => typeof value === "object" && value != null && !(value instanceof Boolean) && !(value instanceof Date) && !(value instanceof Number) && !(value instanceof RegExp) && !(value instanceof String);
+const toPointer = (parts) => `#${parts.map((part) => String(part).replace(/~/g, "~0").replace(/\//g, "~1")).join("/")}`;
+const decycle = () => {
+	const paths = /* @__PURE__ */ new WeakMap();
+	return function replacer(key, value) {
+		if (key !== "$reference" && isObject(value)) {
+			if (paths.has(value)) return { $reference: toPointer(paths.get(value)) };
+			paths.set(value, [...paths.get(this) ?? [], key]);
+		}
+		return value;
+	};
+};
+function retrocycle() {
+	const parents = /* @__PURE__ */ new WeakMap();
+	const keys = /* @__PURE__ */ new WeakMap();
+	const refs = /* @__PURE__ */ new Set();
+	function dereference(ref) {
+		const parts = ref.$reference.slice(1).split("/");
+		let key;
+		let value = this;
+		for (let i = 0; i < parts.length; i++) {
+			key = parts[i]?.replace(/~1/g, "/").replace(/~0/g, "~");
+			value = value[key];
+		}
+		const parent = parents.get(ref);
+		parent[keys.get(ref)] = value;
+	}
+	return function reviver(key, value) {
+		if (key === "$reference") refs.add(this);
+		else if (isObject(value)) if (key === "" && Object.keys(this).length === 1) refs.forEach(dereference, this);
+		else {
+			parents.set(value, this);
+			keys.set(value, key);
+		}
+		return value;
+	};
+}
+
+//#endregion
+export { decycle, retrocycle };

package/dist/dereference.js

@@ -0,0 +1,24 @@
+import { dereference } from "@gitbook/openapi-parser";
+
+//#region src/dereference.ts
+const dereferenceCache = /* @__PURE__ */ new WeakMap();
+/**
+* Memoized version of `dereferenceSchema`.
+*/
+function dereferenceFilesystem(filesystem) {
+	if (dereferenceCache.has(filesystem)) return dereferenceCache.get(filesystem);
+	const promise = baseDereferenceFilesystem(filesystem);
+	dereferenceCache.set(filesystem, promise);
+	return promise;
+}
+/**
+* Dereference an OpenAPI schema.
+*/
+async function baseDereferenceFilesystem(filesystem) {
+	const result = await dereference(filesystem);
+	if (!result.schema) throw new Error("Failed to dereference OpenAPI document");
+	return result.schema;
+}
+
+//#endregion
+export { dereferenceFilesystem };

package/dist/generateSchemaExample.js

@@ -0,0 +1,198 @@
+import { checkIsReference } from "./utils.js";
+
+//#region src/generateSchemaExample.ts
+/**
+* Generate a JSON example from a schema
+*/
+function generateSchemaExample(schema, options) {
+	return getExampleFromSchema(schema, {
+		emptyString: "text",
+		...options
+	});
+}
+/**
+* Generate an example for a media type.
+*/
+function generateMediaTypeExamples(mediaType, options) {
+	if (mediaType.example) return [{
+		summary: "default",
+		value: mediaType.example
+	}];
+	if (mediaType.examples) {
+		const { examples } = mediaType;
+		const keys = Object.keys(examples);
+		if (keys.length > 0) return keys.reduce((result, key) => {
+			const example = examples[key];
+			if (!example || checkIsReference(example)) return result;
+			result.push({
+				summary: example.summary || key,
+				value: example.value,
+				description: example.description,
+				externalValue: example.externalValue
+			});
+			return result;
+		}, []);
+	}
+	if (mediaType.schema) return [{
+		summary: "default",
+		value: generateSchemaExample(mediaType.schema, options)
+	}];
+	return [];
+}
+/** Hard limit for rendering circular references */
+const MAX_LEVELS_DEEP = 5;
+const genericExampleValues = {
+	"date-time": (/* @__PURE__ */ new Date()).toISOString(),
+	date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0] ?? "1970-01-01",
+	email: "name@gmail.com",
+	hostname: "example.com",
+	ipv4: "0.0.0.0",
+	ipv6: "2001:0db8:85a3:0000:0000:8a2e:0370:7334",
+	uri: "https://example.com",
+	uuid: "123e4567-e89b-12d3-a456-426614174000",
+	binary: "binary",
+	byte: "Ynl0ZXM=",
+	password: "password",
+	"idn-email": "jane.doe@example.com",
+	"idn-hostname": "example.com",
+	"iri-reference": "/entitiy/1",
+	iri: "https://example.com/entity/123",
+	"json-pointer": "/nested/objects",
+	regex: "/[a-z]/",
+	"relative-json-pointer": "1/nested/objects",
+	time: (/* @__PURE__ */ new Date()).toISOString().split("T")[1]?.split(".")[0] ?? "00:00:00Z",
+	"uri-reference": "../folder",
+	"uri-template": "https://example.com/{id}",
+	"object-id": "6592008029c8c3e4dc76256c"
+};
+/**
+* We can use the `format` to generate some random values.
+*/
+function guessFromFormat(schema, fallback = "") {
+	return genericExampleValues[schema.format] ?? fallback;
+}
+/**
+* This function takes an OpenAPI schema and generates an example from it
+* Forked from : https://github.com/scalar/scalar/blob/main/packages/oas-utils/src/spec-getters/getExampleFromSchema.ts
+*/
+const getExampleFromSchema = (schema, options, level = 0, parentSchema, name, resultCache = /* @__PURE__ */ new WeakMap()) => {
+	function cache(schema$1, result) {
+		if (typeof result !== "object" || result === null) return result;
+		resultCache.set(schema$1, result);
+		return result;
+	}
+	if (resultCache.has(schema)) return resultCache.get(schema);
+	if (level === MAX_LEVELS_DEEP + 1) try {
+		JSON.stringify(schema);
+	} catch {
+		return "[Circular Reference]";
+	}
+	const makeUpRandomData = !!options?.emptyString;
+	if (schema.deprecated || schema.type === "array" && schema.items?.deprecated) return;
+	if (options?.mode === "write" && schema.readOnly || options?.mode === "read" && schema.writeOnly) return;
+	if (schema["x-variable"]) {
+		const value = options?.variables?.[schema["x-variable"]];
+		if (value !== void 0) {
+			if (schema.type === "number" || schema.type === "integer") return Number.parseInt(value, 10);
+			return cache(schema, value);
+		}
+	}
+	if (Array.isArray(schema.examples) && schema.examples.length > 0) return cache(schema, schema.examples[0]);
+	if (schema.example !== void 0) return cache(schema, schema.example);
+	if (schema.default !== void 0 && [
+		"string",
+		"number",
+		"boolean"
+	].includes(typeof schema.default)) return cache(schema, schema.default);
+	if (Array.isArray(schema.enum) && schema.enum.length > 0) return cache(schema, schema.enum[0]);
+	if (!(schema.type === "object" || schema.type === "array" || !!schema.allOf?.at?.(0) || !!schema.anyOf?.at?.(0) || !!schema.oneOf?.at?.(0)) && options?.omitEmptyAndOptionalProperties === true) {
+		if (!(schema.required === true || parentSchema?.required === true || parentSchema?.required?.includes(name ?? schema.name))) return;
+	}
+	if (schema.type === "object" || schema.properties !== void 0) {
+		const response = {};
+		if (schema.properties !== void 0) {
+			for (const propertyName in schema.properties) if (Object.prototype.hasOwnProperty.call(schema.properties, propertyName)) {
+				const property = schema.properties[propertyName];
+				const propertyXmlTagName = options?.xml ? property.xml?.name : void 0;
+				response[propertyXmlTagName ?? propertyName] = getExampleFromSchema(property, options, level + 1, schema, propertyName, resultCache);
+				if (typeof response[propertyXmlTagName ?? propertyName] === "undefined") delete response[propertyXmlTagName ?? propertyName];
+			}
+		}
+		if (schema.patternProperties !== void 0) {
+			for (const pattern in schema.patternProperties) if (Object.prototype.hasOwnProperty.call(schema.patternProperties, pattern)) {
+				const property = schema.patternProperties[pattern];
+				const exampleKey = pattern;
+				response[exampleKey] = getExampleFromSchema(property, options, level + 1, schema, exampleKey, resultCache);
+			}
+		}
+		if (schema.additionalProperties !== void 0) {
+			if (schema.additionalProperties === true || typeof schema.additionalProperties === "object" && !Object.keys(schema.additionalProperties).length) response.ANY_ADDITIONAL_PROPERTY = "anything";
+			else if (schema.additionalProperties !== false) response.ANY_ADDITIONAL_PROPERTY = getExampleFromSchema(schema.additionalProperties, options, level + 1, void 0, void 0, resultCache);
+		}
+		if (schema.anyOf !== void 0) Object.assign(response, getExampleFromSchema(schema.anyOf[0], options, level + 1, void 0, void 0, resultCache));
+		else if (schema.oneOf !== void 0) Object.assign(response, getExampleFromSchema(schema.oneOf[0], options, level + 1, void 0, void 0, resultCache));
+		else if (schema.allOf !== void 0) Object.assign(response, ...schema.allOf.map((item) => getExampleFromSchema(item, options, level + 1, schema, void 0, resultCache)).filter((item) => item !== void 0));
+		return cache(schema, response);
+	}
+	if (schema.type === "array" || schema.items !== void 0) {
+		const itemsXmlTagName = schema?.items?.xml?.name;
+		const wrapItems = !!(options?.xml && schema.xml?.wrapped && itemsXmlTagName);
+		if (schema.example !== void 0) return cache(schema, wrapItems ? { [itemsXmlTagName]: schema.example } : schema.example);
+		if (schema.items) {
+			if (schema.items.allOf) {
+				if (schema.items.allOf[0].type === "object") {
+					const mergedExample = getExampleFromSchema({
+						type: "object",
+						allOf: schema.items.allOf
+					}, options, level + 1, schema, void 0, resultCache);
+					return cache(schema, wrapItems ? [{ [itemsXmlTagName]: mergedExample }] : [mergedExample]);
+				}
+				const examples = schema.items.allOf.map((item) => getExampleFromSchema(item, options, level + 1, schema, void 0, resultCache)).filter((item) => item !== void 0);
+				return cache(schema, wrapItems ? examples.map((example) => ({ [itemsXmlTagName]: example })) : examples);
+			}
+			for (const rule of ["anyOf", "oneOf"]) {
+				if (!schema.items[rule]) continue;
+				const exampleFromRule = schema.items[rule].slice(0, 1).map((item) => getExampleFromSchema(item, options, level + 1, schema, void 0, resultCache)).filter((item) => item !== void 0);
+				return cache(schema, wrapItems ? [{ [itemsXmlTagName]: exampleFromRule }] : exampleFromRule);
+			}
+		}
+		if (schema.items?.type) {
+			const exampleFromSchema = getExampleFromSchema(schema.items, options, level + 1, void 0, void 0, resultCache);
+			return wrapItems ? [{ [itemsXmlTagName]: exampleFromSchema }] : [exampleFromSchema];
+		}
+		return [];
+	}
+	const exampleValues = {
+		string: makeUpRandomData ? guessFromFormat(schema, options?.emptyString) : "",
+		boolean: true,
+		integer: schema.min ?? 1,
+		number: schema.min ?? 1,
+		array: []
+	};
+	if (schema.type !== void 0 && exampleValues[schema.type] !== void 0) return cache(schema, exampleValues[schema.type]);
+	const discriminateSchema = schema.oneOf || schema.anyOf;
+	if (Array.isArray(discriminateSchema) && discriminateSchema.length > 0) {
+		const firstOneOfItem = discriminateSchema[0];
+		return getExampleFromSchema(firstOneOfItem, options, level + 1, void 0, void 0, resultCache);
+	}
+	if (Array.isArray(schema.allOf)) {
+		let example = null;
+		schema.allOf.forEach((allOfItem) => {
+			const newExample = getExampleFromSchema(allOfItem, options, level + 1, void 0, void 0, resultCache);
+			example = typeof newExample === "object" && typeof example === "object" ? {
+				...example ?? {},
+				...newExample
+			} : Array.isArray(newExample) && Array.isArray(example) ? [...example ?? {}, ...newExample] : newExample;
+		});
+		return cache(schema, example);
+	}
+	if (Array.isArray(schema.type)) {
+		if (schema.type.includes("null")) return null;
+		const exampleValue = exampleValues[schema.type[0]];
+		if (exampleValue !== void 0) return cache(schema, exampleValue);
+	}
+	return null;
+};
+
+//#endregion
+export { generateMediaTypeExamples, generateSchemaExample };

package/dist/getDisclosureLabel.js

@@ -0,0 +1,17 @@
+'use client';
+
+
+import { tString } from "./translate.js";
+
+//#region src/getDisclosureLabel.ts
+function getDisclosureLabel(props) {
+	const { schema, isExpanded, context } = props;
+	let label;
+	if (schema.type === "array" && !!schema.items) if (schema.items.oneOf) label = tString(context.translation, "available_items").toLowerCase();
+	else label = tString(context.translation, "properties").toLowerCase();
+	else label = tString(context.translation, "properties").toLowerCase();
+	return tString(context.translation, isExpanded ? "hide" : "show", label);
+}
+
+//#endregion
+export { getDisclosureLabel };

package/dist/getOrCreateStoreByKey.js

@@ -0,0 +1,22 @@
+import { createStore } from "zustand";
+
+//#region src/getOrCreateStoreByKey.ts
+const createStateStore = (initial) => {
+	return createStore()((set) => ({
+		key: initial ?? null,
+		setKey: (key) => {
+			set(() => ({ key }));
+		}
+	}));
+};
+const defaultStores = /* @__PURE__ */ new Map();
+const createStateStoreFactory = (stores) => {
+	return (storeKey, initialKey) => {
+		if (!stores.has(storeKey)) stores.set(storeKey, createStateStore(initialKey));
+		return stores.get(storeKey);
+	};
+};
+const getOrCreateStoreByKey = createStateStoreFactory(defaultStores);
+
+//#endregion
+export { getOrCreateStoreByKey };