@gitbook/react-openapi 1.5.4 → 1.5.6

package/dist/OpenAPIResponseExample.js

@@ -5,6 +5,7 @@ import { getOpenAPIClientContext } from "./context.js";
 import { getExampleFromReference, getExamples } from "./util/example.js";
 import { OpenAPIMediaTypeContent } from "./OpenAPIMediaType.js";
 import { OpenAPIResponseExampleContent } from "./OpenAPIResponseExampleContent.js";
+import { Fragment, jsx } from "react/jsx-runtime";
 
 //#region src/OpenAPIResponseExample.tsx
 /**
@@ -23,28 +24,39 @@ function OpenAPIResponseExample(props) {
 	});
 	const tabs = responses.filter(([_, responseObject]) => responseObject && typeof responseObject === "object" && !responseObject["x-hideSample"]).map(([key, responseObject]) => {
 		const description = resolveDescription(responseObject);
-		const label = description ? <Markdown key={`response-description-${key}`} source={description} /> : getStatusCodeDefaultLabel(key, context);
+		const label = description ? /* @__PURE__ */ jsx(Markdown, { source: description }, `response-description-${key}`) : getStatusCodeDefaultLabel(key, context);
 		if (checkIsReference(responseObject)) return {
 			key,
 			label,
 			statusCode: key,
-			body: <OpenAPIExample example={getExampleFromReference(responseObject, context)} context={context} syntax="json" />
+			body: /* @__PURE__ */ jsx(OpenAPIExample, {
+				example: getExampleFromReference(responseObject, context),
+				context,
+				syntax: "json"
+			})
 		};
 		if (!responseObject.content || Object.keys(responseObject.content).length === 0) return {
 			key,
 			label,
 			statusCode: key,
-			body: <OpenAPIEmptyExample context={context} />
+			body: /* @__PURE__ */ jsx(OpenAPIEmptyExample, { context })
 		};
 		return {
 			key,
 			label,
 			statusCode: key,
-			body: <OpenAPIResponse context={context} content={responseObject.content} />
+			body: /* @__PURE__ */ jsx(OpenAPIResponse, {
+				context,
+				content: responseObject.content
+			})
 		};
 	});
 	if (tabs.length === 0) return null;
-	return <OpenAPIResponseExampleContent selectIcon={context.icons.chevronDown} blockKey={context.blockKey} items={tabs} />;
+	return /* @__PURE__ */ jsx(OpenAPIResponseExampleContent, {
+		selectIcon: context.icons.chevronDown,
+		blockKey: context.blockKey,
+		items: tabs
+	});
 }
 function OpenAPIResponse(props) {
 	const { context, content } = props;
@@ -55,12 +67,12 @@ function OpenAPIResponse(props) {
 		if (!mediaTypeObject) return {
 			key: mediaType,
 			label: mediaType,
-			body: <OpenAPIEmptyExample context={context} />
+			body: /* @__PURE__ */ jsx(OpenAPIEmptyExample, { context })
 		};
 		return {
 			key: mediaType,
 			label: mediaType,
-			body: <></>,
+			body: /* @__PURE__ */ jsx(Fragment, {}),
 			examples: getExamples({
 				mediaTypeObject,
 				mediaType,
@@ -68,7 +80,12 @@ function OpenAPIResponse(props) {
 			})
 		};
 	});
-	return <OpenAPIMediaTypeContent selectIcon={context.icons.chevronDown} stateKey={createStateKey("response-media-types", context.blockKey)} items={tabs} context={getOpenAPIClientContext(context)} />;
+	return /* @__PURE__ */ jsx(OpenAPIMediaTypeContent, {
+		selectIcon: context.icons.chevronDown,
+		stateKey: createStateKey("response-media-types", context.blockKey),
+		items: tabs,
+		context: getOpenAPIClientContext(context)
+	});
 }
 
 //#endregion

package/dist/OpenAPIResponseExampleContent.js

@@ -5,6 +5,7 @@ import { createStateKey, getStatusCodeClassName } from "./utils.js";
 import { StaticSection } from "./StaticSection.js";
 import { OpenAPISelect, OpenAPISelectItem, useSelectState } from "./OpenAPISelect.js";
 import clsx from "classnames";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 
 //#region src/OpenAPIResponseExampleContent.tsx
 /**
@@ -15,40 +16,60 @@ function useResponseExamplesState(blockKey, initialKey = "default") {
 }
 function OpenAPIResponseExampleContent(props) {
 	const { blockKey, items, selectIcon } = props;
-	return <StaticSection header={<OpenAPIResponseExampleHeader selectIcon={selectIcon} blockKey={blockKey} items={items} />} className="openapi-response-examples">
-            <OpenAPIResponseExampleBody blockKey={blockKey} items={items} />
-        </StaticSection>;
+	return /* @__PURE__ */ jsx(StaticSection, {
+		header: /* @__PURE__ */ jsx(OpenAPIResponseExampleHeader, {
+			selectIcon,
+			blockKey,
+			items
+		}),
+		className: "openapi-response-examples",
+		children: /* @__PURE__ */ jsx(OpenAPIResponseExampleBody, {
+			blockKey,
+			items
+		})
+	});
 }
 function OpenAPIResponseExampleHeader(props) {
 	const { items, blockKey, selectIcon } = props;
 	if (items.length === 1) {
 		const item = items[0];
 		if (!item) return null;
-		return <span className="openapi-response-examples-statuscode-title">
-                <OpenAPIResponseExampleItem item={item} />
-            </span>;
+		return /* @__PURE__ */ jsx("span", {
+			className: "openapi-response-examples-statuscode-title",
+			children: /* @__PURE__ */ jsx(OpenAPIResponseExampleItem, { item })
+		});
 	}
-	return <OpenAPISelect items={items} icon={selectIcon} stateKey={getResponseExampleStateKey(blockKey)} placement="bottom start">
-            {items.map((item) => <OpenAPISelectItem key={item.key} id={item.key} value={item}>
-                    <OpenAPIResponseExampleItem item={item} />
-                </OpenAPISelectItem>)}
-        </OpenAPISelect>;
+	return /* @__PURE__ */ jsx(OpenAPISelect, {
+		items,
+		icon: selectIcon,
+		stateKey: getResponseExampleStateKey(blockKey),
+		placement: "bottom start",
+		children: items.map((item) => /* @__PURE__ */ jsx(OpenAPISelectItem, {
+			id: item.key,
+			value: item,
+			children: /* @__PURE__ */ jsx(OpenAPIResponseExampleItem, { item })
+		}, item.key))
+	});
 }
 function OpenAPIResponseExampleItem(props) {
 	const { item } = props;
-	return <>
-            <span className={clsx("openapi-statuscode", `openapi-statuscode-${getStatusCodeClassName(item.statusCode)}`, "openapi-response-examples-statuscode")}>
-                {item.statusCode}
-            </span>
-            <span className="openapi-response-examples-statuscode-label">{item.label}</span>
-        </>;
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("span", {
+		className: clsx("openapi-statuscode", `openapi-statuscode-${getStatusCodeClassName(item.statusCode)}`, "openapi-response-examples-statuscode"),
+		children: item.statusCode
+	}), /* @__PURE__ */ jsx("span", {
+		className: "openapi-response-examples-statuscode-label",
+		children: item.label
+	})] });
 }
 function OpenAPIResponseExampleBody(props) {
 	const { blockKey, items } = props;
 	const state = useResponseExamplesState(blockKey, items[0]?.key);
 	const selectedItem = items.find((item) => item.key === state.key) ?? items[0];
 	if (!selectedItem) return null;
-	return <div className="openapi-response-examples-panel">{selectedItem.body}</div>;
+	return /* @__PURE__ */ jsx("div", {
+		className: "openapi-response-examples-panel",
+		children: selectedItem.body
+	});
 }
 /**
 * Return the state key for the response examples.

package/dist/OpenAPIResponses.js

@@ -9,6 +9,7 @@ import { useResponseExamplesState } from "./OpenAPIResponseExampleContent.js";
 import { OpenAPIDisclosureGroup } from "./OpenAPIDisclosureGroup.js";
 import { OpenAPIResponse } from "./OpenAPIResponse.js";
 import clsx from "classnames";
+import { jsx, jsxs } from "react/jsx-runtime";
 
 //#region src/OpenAPIResponses.tsx
 /**
@@ -21,40 +22,62 @@ function OpenAPIResponses(props) {
 			if ((!response.content || !Object.keys(response.content).length) && response.headers && Object.keys(response.headers).length) return [{
 				key: "default",
 				label: "",
-				body: <OpenAPIResponse response={response} mediaType={{}} context={context} />
+				body: /* @__PURE__ */ jsx(OpenAPIResponse, {
+					response,
+					mediaType: {},
+					context
+				})
 			}];
 			if (!response.content) return [{
 				key: "default",
 				label: "",
-				body: <pre className="openapi-example-empty">
-                                    <p>{t(context.translation, "no_content")}</p>
-                                </pre>
+				body: /* @__PURE__ */ jsx("pre", {
+					className: "openapi-example-empty",
+					children: /* @__PURE__ */ jsx("p", { children: t(context.translation, "no_content") })
+				})
 			}];
 			return Object.entries(response.content ?? {}).map(([contentType, mediaType]) => ({
 				key: contentType,
 				label: contentType,
-				body: <OpenAPIResponse response={response} mediaType={mediaType} context={context} />
+				body: /* @__PURE__ */ jsx(OpenAPIResponse, {
+					response,
+					mediaType,
+					context
+				})
 			}));
 		})();
 		const description = resolveDescription(response);
 		return {
 			key: statusCode,
-			label: <div className="openapi-response-tab-content">
-                        <span className={clsx("openapi-statuscode", `openapi-statuscode-${getStatusCodeClassName(statusCode)}`)}>
-                            {statusCode}
-                        </span>
-                        {description ? <Markdown source={description} className="openapi-response-description" /> : getStatusCodeDefaultLabel(statusCode, context)}
-                    </div>,
+			label: /* @__PURE__ */ jsxs("div", {
+				className: "openapi-response-tab-content",
+				children: [/* @__PURE__ */ jsx("span", {
+					className: clsx("openapi-statuscode", `openapi-statuscode-${getStatusCodeClassName(statusCode)}`),
+					children: statusCode
+				}), description ? /* @__PURE__ */ jsx(Markdown, {
+					source: description,
+					className: "openapi-response-description"
+				}) : getStatusCodeDefaultLabel(statusCode, context)]
+			}),
 			tabs
 		};
 	});
 	const state = useResponseExamplesState(context.blockKey, groups[0]?.key);
-	return <StaticSection header={t(context.translation, "responses")} className="openapi-responses">
-            <OpenAPIDisclosureGroup icon={context.icons.chevronRight} expandedKeys={state.key ? new Set([state.key]) : /* @__PURE__ */ new Set()} onExpandedChange={(keys) => {
-		const key = keys.values().next().value ?? null;
-		state.setKey(key);
-	}} groups={groups} selectIcon={context.icons.chevronDown} selectStateKey={createStateKey("response-media-types", context.blockKey)} />
-        </StaticSection>;
+	return /* @__PURE__ */ jsx(StaticSection, {
+		header: t(context.translation, "responses"),
+		className: "openapi-responses",
+		children: /* @__PURE__ */ jsx(OpenAPIDisclosureGroup, {
+			icon: context.icons.chevronRight,
+			expandedKeys: state.key ? new Set([state.key]) : /* @__PURE__ */ new Set(),
+			onExpandedChange: (keys) => {
+				const key = keys.values().next().value ?? null;
+				state.setKey(key);
+			},
+			groups,
+			selectIcon: context.icons.chevronDown,
+			selectStateKey: createStateKey("response-media-types", context.blockKey)
+		})
+	});
 }
 
 //#endregion

package/dist/OpenAPISchema.js

@@ -12,6 +12,7 @@ import { getDisclosureLabel } from "./getDisclosureLabel.js";
 import { checkIsReference, getSchemaTitle, resolveDescription, resolveFirstExample } from "./utils.js";
 import clsx from "classnames";
 import { useId } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
 
 //#region src/OpenAPISchema.tsx
 /**
@@ -22,42 +23,77 @@ function OpenAPISchemaProperty(props) {
 	const { schema } = property;
 	const id = useId();
 	const circularRefId = parentCircularRefs.get(schema);
-	if (circularRefId) return <OpenAPISchemaPresentation context={context} property={property} circularRefId={circularRefId} />;
+	if (circularRefId) return /* @__PURE__ */ jsx(OpenAPISchemaPresentation, {
+		context,
+		property,
+		circularRefId
+	});
 	const circularRefs = new Map(parentCircularRefs);
 	circularRefs.set(schema, id);
 	const properties = getSchemaProperties(schema, discriminator, discriminatorValue);
 	const alternatives = getSchemaAlternatives(schema, new Set(circularRefs.keys()));
-	const header = <OpenAPISchemaPresentation id={id} context={context} property={property} />;
+	const header = /* @__PURE__ */ jsx(OpenAPISchemaPresentation, {
+		id,
+		context,
+		property
+	});
 	const content = (() => {
-		if (alternatives?.schemas) return <OpenAPISchemaAlternatives alternatives={alternatives} schema={schema} circularRefs={circularRefs} context={context} parentDiscriminator={discriminator} parentDiscriminatorValue={discriminatorValue} />;
-		if (properties?.length) return <OpenAPISchemaProperties properties={properties} circularRefs={circularRefs} context={context} />;
+		if (alternatives?.schemas) return /* @__PURE__ */ jsx(OpenAPISchemaAlternatives, {
+			alternatives,
+			schema,
+			circularRefs,
+			context,
+			parentDiscriminator: discriminator,
+			parentDiscriminatorValue: discriminatorValue
+		});
+		if (properties?.length) return /* @__PURE__ */ jsx(OpenAPISchemaProperties, {
+			properties,
+			circularRefs,
+			context
+		});
 		return null;
 	})();
-	if (properties?.length) return <OpenAPIDisclosure icon={context.icons.plus} header={header} label={(isExpanded) => getDisclosureLabel({
-		schema,
-		isExpanded,
-		context
-	})}>
-                {content}
-            </OpenAPIDisclosure>;
-	return <div id={id} {...rest} className={clsx("openapi-schema", className)}>
-            {header}
-            {content}
-        </div>;
+	if (properties?.length) return /* @__PURE__ */ jsx(OpenAPIDisclosure, {
+		icon: context.icons.plus,
+		header,
+		label: (isExpanded) => getDisclosureLabel({
+			schema,
+			isExpanded,
+			context
+		}),
+		children: content
+	});
+	return /* @__PURE__ */ jsxs("div", {
+		id,
+		...rest,
+		className: clsx("openapi-schema", className),
+		children: [header, content]
+	});
 }
 /**
 * Render a set of properties of an OpenAPI schema.
 */
 function OpenAPISchemaProperties(props) {
 	const { id, properties, circularRefs = /* @__PURE__ */ new Map(), context } = props;
-	return <div id={id} className="openapi-schema-properties">
-            {properties.map((property, index) => {
-		return <OpenAPISchemaProperty key={index} circularRefs={circularRefs} property={property} context={context} style={{ animationDelay: `${index * .02}s` }} />;
-	})}
-        </div>;
+	return /* @__PURE__ */ jsx("div", {
+		id,
+		className: "openapi-schema-properties",
+		children: properties.map((property, index) => {
+			return /* @__PURE__ */ jsx(OpenAPISchemaProperty, {
+				circularRefs,
+				property,
+				context,
+				style: { animationDelay: `${index * .02}s` }
+			}, index);
+		})
+	});
 }
 function OpenAPISchemaPropertiesFromServer(props) {
-	return <OpenAPISchemaProperties id={props.id} properties={JSON.parse(props.properties, retrocycle())} context={props.context} />;
+	return /* @__PURE__ */ jsx(OpenAPISchemaProperties, {
+		id: props.id,
+		properties: JSON.parse(props.properties, retrocycle()),
+		context: props.context
+	});
 }
 /**
 * Render a root schema (such as the request body or response body).
@@ -70,18 +106,35 @@ function OpenAPIRootSchema(props) {
 	const alternatives = getSchemaAlternatives(schema, new Set(parentCircularRefs.keys()));
 	const circularRefs = new Map(parentCircularRefs);
 	circularRefs.set(schema, id);
-	if (alternatives?.schemas) return <>
-                {description ? <Markdown source={description} className="openapi-schema-root-description" /> : null}
-                <OpenAPISchemaAlternatives alternatives={alternatives} schema={schema} circularRefs={circularRefs} context={context} />
-            </>;
-	if (properties?.length) return <>
-                {description ? <Markdown source={description} className="openapi-schema-root-description" /> : null}
-                <OpenAPISchemaProperties properties={properties} circularRefs={circularRefs} context={context} />
-            </>;
-	return <OpenAPISchemaProperty className="openapi-schema-root" property={{ schema }} context={context} circularRefs={parentCircularRefs} />;
+	if (alternatives?.schemas) return /* @__PURE__ */ jsxs(Fragment$1, { children: [description ? /* @__PURE__ */ jsx(Markdown, {
+		source: description,
+		className: "openapi-schema-root-description"
+	}) : null, /* @__PURE__ */ jsx(OpenAPISchemaAlternatives, {
+		alternatives,
+		schema,
+		circularRefs,
+		context
+	})] });
+	if (properties?.length) return /* @__PURE__ */ jsxs(Fragment$1, { children: [description ? /* @__PURE__ */ jsx(Markdown, {
+		source: description,
+		className: "openapi-schema-root-description"
+	}) : null, /* @__PURE__ */ jsx(OpenAPISchemaProperties, {
+		properties,
+		circularRefs,
+		context
+	})] });
+	return /* @__PURE__ */ jsx(OpenAPISchemaProperty, {
+		className: "openapi-schema-root",
+		property: { schema },
+		context,
+		circularRefs: parentCircularRefs
+	});
 }
 function OpenAPIRootSchemaFromServer(props) {
-	return <OpenAPIRootSchema schema={JSON.parse(props.schema, retrocycle())} context={props.context} />;
+	return /* @__PURE__ */ jsx(OpenAPIRootSchema, {
+		schema: JSON.parse(props.schema, retrocycle()),
+		context: props.context
+	});
 }
 /**
 * Get the discriminator value for a schema.
@@ -109,16 +162,24 @@ function OpenAPISchemaAlternatives(props) {
 	const { alternatives, schema, circularRefs, context, parentDiscriminator, parentDiscriminatorValue } = props;
 	if (!alternatives?.schemas) return null;
 	const { schemas, discriminator: alternativeDiscriminator, type } = alternatives;
-	return <div className="openapi-schema-alternatives">
-            {schemas.map((alternativeSchema, index) => {
-		const effectiveDiscriminator = alternativeDiscriminator || (type === "allOf" ? parentDiscriminator : void 0);
-		const effectiveDiscriminatorValue = !alternativeDiscriminator && type === "allOf" ? parentDiscriminatorValue : void 0;
-		return <div key={index} className="openapi-schema-alternative">
-                        <OpenAPISchemaAlternative schema={alternativeSchema} discriminator={effectiveDiscriminator} discriminatorValue={effectiveDiscriminatorValue} circularRefs={circularRefs} context={context} />
-                        {index < schemas.length - 1 ? <OpenAPISchemaAlternativeSeparator schema={schema} context={context} /> : null}
-                    </div>;
-	})}
-        </div>;
+	return /* @__PURE__ */ jsx("div", {
+		className: "openapi-schema-alternatives",
+		children: schemas.map((alternativeSchema, index) => {
+			return /* @__PURE__ */ jsxs("div", {
+				className: "openapi-schema-alternative",
+				children: [/* @__PURE__ */ jsx(OpenAPISchemaAlternative, {
+					schema: alternativeSchema,
+					discriminator: alternativeDiscriminator || (type === "allOf" ? parentDiscriminator : void 0),
+					discriminatorValue: !alternativeDiscriminator && type === "allOf" ? parentDiscriminatorValue : void 0,
+					circularRefs,
+					context
+				}), index < schemas.length - 1 ? /* @__PURE__ */ jsx(OpenAPISchemaAlternativeSeparator, {
+					schema,
+					context
+				}) : null]
+			}, index);
+		})
+	});
 }
 /**
 * Render a tab for an alternative schema.
@@ -129,13 +190,29 @@ function OpenAPISchemaAlternative(props) {
 	const { schema, discriminator, circularRefs, context } = props;
 	const discriminatorValue = props.discriminatorValue || getDiscriminatorValue(schema, discriminator);
 	const properties = getSchemaProperties(schema, discriminator, discriminatorValue);
-	return properties?.length ? <OpenAPIDisclosure icon={context.icons.plus} header={<OpenAPISchemaPresentation property={{ schema }} context={context} />} label={(isExpanded) => getDisclosureLabel({
-		schema,
-		isExpanded,
+	return properties?.length ? /* @__PURE__ */ jsx(OpenAPIDisclosure, {
+		icon: context.icons.plus,
+		header: /* @__PURE__ */ jsx(OpenAPISchemaPresentation, {
+			property: { schema },
+			context
+		}),
+		label: (isExpanded) => getDisclosureLabel({
+			schema,
+			isExpanded,
+			context
+		}),
+		children: /* @__PURE__ */ jsx(OpenAPISchemaProperties, {
+			properties,
+			circularRefs,
+			context
+		})
+	}) : /* @__PURE__ */ jsx(OpenAPISchemaProperty, {
+		property: { schema },
+		discriminator,
+		discriminatorValue,
+		circularRefs,
 		context
-	})}>
-            <OpenAPISchemaProperties properties={properties} circularRefs={circularRefs} context={context} />
-        </OpenAPIDisclosure> : <OpenAPISchemaProperty property={{ schema }} discriminator={discriminator} discriminatorValue={discriminatorValue} circularRefs={circularRefs} context={context} />;
+	});
 }
 function OpenAPISchemaAlternativeSeparator(props) {
 	const { schema, context } = props;
@@ -143,20 +220,31 @@ function OpenAPISchemaAlternativeSeparator(props) {
 	const oneOf = schema.oneOf || schema.items?.oneOf;
 	const allOf = schema.allOf || schema.items?.allOf;
 	if (!anyOf && !oneOf && !allOf) return null;
-	return <span className="openapi-schema-alternative-separator">
-            {(anyOf || oneOf) && tString(context.translation, "or")}
-            {allOf && tString(context.translation, "and")}
-        </span>;
+	return /* @__PURE__ */ jsxs("span", {
+		className: "openapi-schema-alternative-separator",
+		children: [(anyOf || oneOf) && tString(context.translation, "or"), allOf && tString(context.translation, "and")]
+	});
 }
 /**
 * Render a circular reference to a schema.
 */
 function OpenAPISchemaCircularRef(props) {
 	const { id, schema } = props;
-	return <div className="openapi-schema-circular">
-            <span className="openapi-schema-circular-glyph">⤷</span>
-            Circular reference to <a href={`#${id}`}>{getSchemaTitle(schema)}</a>{" "}
-        </div>;
+	return /* @__PURE__ */ jsxs("div", {
+		className: "openapi-schema-circular",
+		children: [
+			/* @__PURE__ */ jsx("span", {
+				className: "openapi-schema-circular-glyph",
+				children: "⤷"
+			}),
+			"Circular reference to ",
+			/* @__PURE__ */ jsx("a", {
+				href: `#${id}`,
+				children: getSchemaTitle(schema)
+			}),
+			" "
+		]
+	});
 }
 /**
 * Render the enum value for a schema.
@@ -184,14 +272,24 @@ function OpenAPISchemaEnum(props) {
 		});
 	})();
 	if (!enumValues?.length) return null;
-	return <span className="openapi-schema-enum">
-            {tString(context.translation, "possible_values")}:{" "}
-            {enumValues.map((item, index) => <span key={index} className="openapi-schema-enum-value">
-                    <OpenAPICopyButton value={item.value} label={item.description} withTooltip={!!item.description} context={context}>
-                        <code>{`${item.value}`}</code>
-                    </OpenAPICopyButton>
-                </span>)}
-        </span>;
+	return /* @__PURE__ */ jsxs("span", {
+		className: "openapi-schema-enum",
+		children: [
+			tString(context.translation, "possible_values"),
+			":",
+			" ",
+			enumValues.map((item, index) => /* @__PURE__ */ jsx("span", {
+				className: "openapi-schema-enum-value",
+				children: /* @__PURE__ */ jsx(OpenAPICopyButton, {
+					value: item.value,
+					label: item.description,
+					withTooltip: !!item.description,
+					context,
+					children: /* @__PURE__ */ jsx("code", { children: `${item.value}` })
+				})
+			}, index))
+		]
+	});
 }
 /**
 * Render the top row of a schema. e.g: name, type, and required status.
@@ -200,31 +298,57 @@ function OpenAPISchemaPresentation(props) {
 	const { id, property: { schema, propertyName, required, isDiscriminatorProperty }, circularRefId, context } = props;
 	const description = resolveDescription(schema);
 	const example = resolveFirstExample(schema);
-	return <div id={id} className="openapi-schema-presentation">
-            <OpenAPISchemaName schema={schema} type={getSchemaTitle(schema, { ignoreAlternatives: !propertyName })} propertyName={propertyName} isDiscriminatorProperty={isDiscriminatorProperty} required={required} context={context} />
-            {circularRefId ? <OpenAPISchemaCircularRef id={circularRefId} schema={schema} /> : <>
-                    {typeof schema["x-deprecated-sunset"] === "string" ? <div className="openapi-deprecated-sunset openapi-schema-description openapi-markdown">
-                            Sunset date:{" "}
-                            <span className="openapi-deprecated-sunset-date">
-                                {schema["x-deprecated-sunset"]}
-                            </span>
-                        </div> : null}
-                    {description ? <Markdown source={description} className="openapi-schema-description" /> : null}
-                    {schema.default !== void 0 ? <span className="openapi-schema-default">
-                            Default:{" "}
-                            <code>
-                                {typeof schema.default === "string" && schema.default ? schema.default : stringifyOpenAPI(schema.default)}
-                            </code>
-                        </span> : null}
-                    {typeof example === "string" ? <span className="openapi-schema-example">
-                            Example: <code>{example}</code>
-                        </span> : null}
-                    {schema.pattern ? <span className="openapi-schema-pattern">
-                            Pattern: <code>{schema.pattern}</code>
-                        </span> : null}
-                    <OpenAPISchemaEnum schema={schema} context={context} />
-                </>}
-        </div>;
+	return /* @__PURE__ */ jsxs("div", {
+		id,
+		className: "openapi-schema-presentation",
+		children: [/* @__PURE__ */ jsx(OpenAPISchemaName, {
+			schema,
+			type: getSchemaTitle(schema, { ignoreAlternatives: !propertyName }),
+			propertyName,
+			isDiscriminatorProperty,
+			required,
+			context
+		}), circularRefId ? /* @__PURE__ */ jsx(OpenAPISchemaCircularRef, {
+			id: circularRefId,
+			schema
+		}) : /* @__PURE__ */ jsxs(Fragment$1, { children: [
+			typeof schema["x-deprecated-sunset"] === "string" ? /* @__PURE__ */ jsxs("div", {
+				className: "openapi-deprecated-sunset openapi-schema-description openapi-markdown",
+				children: [
+					"Sunset date:",
+					" ",
+					/* @__PURE__ */ jsx("span", {
+						className: "openapi-deprecated-sunset-date",
+						children: schema["x-deprecated-sunset"]
+					})
+				]
+			}) : null,
+			description ? /* @__PURE__ */ jsx(Markdown, {
+				source: description,
+				className: "openapi-schema-description"
+			}) : null,
+			schema.default !== void 0 ? /* @__PURE__ */ jsxs("span", {
+				className: "openapi-schema-default",
+				children: [
+					"Default:",
+					" ",
+					/* @__PURE__ */ jsx("code", { children: typeof schema.default === "string" && schema.default ? schema.default : stringifyOpenAPI(schema.default) })
+				]
+			}) : null,
+			typeof example === "string" ? /* @__PURE__ */ jsxs("span", {
+				className: "openapi-schema-example",
+				children: ["Example: ", /* @__PURE__ */ jsx("code", { children: example })]
+			}) : null,
+			schema.pattern ? /* @__PURE__ */ jsxs("span", {
+				className: "openapi-schema-pattern",
+				children: ["Pattern: ", /* @__PURE__ */ jsx("code", { children: schema.pattern })]
+			}) : null,
+			/* @__PURE__ */ jsx(OpenAPISchemaEnum, {
+				schema,
+				context
+			})
+		] })]
+	});
 }
 /**
 * Process properties from a schema object into property entries.