@gitbook/react-openapi 1.5.3 → 1.5.5

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @gitbook/react-openapi
 
+## 1.5.5
+
+### Patch Changes
+
+- Updated dependencies [985c1b4]
+  - @gitbook/openapi-parser@3.0.7
+
+## 1.5.4
+
+### Patch Changes
+
+- 4766092: Fix missing properties in allOf/oneOf
+- 8761cee: Enhance discriminator handling in OpenAPISchema
+- 461e15f: Add x-gitbook-prefix and x-gitbook-token-placeholder for OpenAPI security scheme
+- 3e40b4d: Fix OpenAPI basic auth placeholder
+- 87d68ea: Fix OpenAPI oneOf/allOf merge
+- 344842f: Improve OpenAPI circular references
+- Updated dependencies [461e15f]
+  - @gitbook/openapi-parser@3.0.6
+
 ## 1.5.3
 
 ### Patch Changes

package/dist/OpenAPICodeSample.js

@@ -175,25 +175,28 @@ function getSecurityHeaders(args) {
 			let scheme = security.scheme;
 			const format = resolvePrefillCodePlaceholderFromSecurityScheme({
 				security,
-				defaultPlaceholderValue: scheme?.includes("basic") ? "username:password" : "YOUR_SECRET_TOKEN"
+				defaultPlaceholderValue: scheme?.toLowerCase()?.includes("basic") ? "username:password" : "YOUR_SECRET_TOKEN"
 			});
 			if (scheme?.includes("bearer")) scheme = "Bearer";
 			else if (scheme?.includes("basic")) scheme = "Basic";
 			else if (scheme?.includes("token")) scheme = "Token";
+			else scheme = scheme ?? "";
 			headers.Authorization = `${scheme} ${format}`;
 			break;
 		}
 		case "apiKey": {
 			if (security.in !== "header") break;
 			const name = security.name ?? "Authorization";
-			headers[name] = resolvePrefillCodePlaceholderFromSecurityScheme({
+			const placeholder = resolvePrefillCodePlaceholderFromSecurityScheme({
 				security,
 				defaultPlaceholderValue: "YOUR_API_KEY"
 			});
+			const prefix = security["x-gitbook-prefix"];
+			headers[name] = prefix ? `${prefix} ${placeholder}` : placeholder;
 			break;
 		}
 		case "oauth2":
-			headers.Authorization = `Bearer ${resolvePrefillCodePlaceholderFromSecurityScheme({
+			headers.Authorization = `${security["x-gitbook-prefix"] ?? "Bearer"} ${resolvePrefillCodePlaceholderFromSecurityScheme({
 				security,
 				defaultPlaceholderValue: "YOUR_OAUTH2_TOKEN"
 			})}`;

package/dist/OpenAPISchema.js

@@ -18,34 +18,26 @@ import { useId } from "react";
 * Render a property of an OpenAPI schema.
 */
 function OpenAPISchemaProperty(props) {
-	const { circularRefs: parentCircularRefs, context, className, property,...rest } = props;
+	const { circularRefs: parentCircularRefs, context, className, property, discriminator, discriminatorValue,...rest } = props;
 	const { schema } = property;
 	const id = useId();
 	const circularRefId = parentCircularRefs.get(schema);
-	if (circularRefId) return <OpenAPISchemaCircularRef id={circularRefId} schema={schema} />;
+	if (circularRefId) return <OpenAPISchemaPresentation context={context} property={property} circularRefId={circularRefId} />;
 	const circularRefs = new Map(parentCircularRefs);
 	circularRefs.set(schema, id);
-	const properties = getSchemaProperties(schema);
+	const properties = getSchemaProperties(schema, discriminator, discriminatorValue);
 	const alternatives = getSchemaAlternatives(schema, new Set(circularRefs.keys()));
-	const header = <OpenAPISchemaPresentation context={context} property={property} />;
+	const header = <OpenAPISchemaPresentation id={id} context={context} property={property} />;
 	const content = (() => {
-		if (alternatives?.schemas) {
-			const { schemas, discriminator } = alternatives;
-			return <div className="openapi-schema-alternatives">
-                    {schemas.map((alternativeSchema, index) => <div key={index} className="openapi-schema-alternative">
-                            <OpenAPISchemaAlternative schema={alternativeSchema} discriminator={discriminator} circularRefs={circularRefs} context={context} />
-                            {index < schemas.length - 1 ? <OpenAPISchemaAlternativeSeparator schema={schema} context={context} /> : null}
-                        </div>)}
-                </div>;
-		}
+		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} />;
 		return null;
 	})();
-	if (properties?.length) return <OpenAPIDisclosure icon={context.icons.plus} className={clsx("openapi-schema", className)} header={header} label={(isExpanded) => getDisclosureLabel({
+	if (properties?.length) return <OpenAPIDisclosure icon={context.icons.plus} header={header} label={(isExpanded) => getDisclosureLabel({
 		schema,
 		isExpanded,
 		context
-	})} {...rest}>
+	})}>
                 {content}
             </OpenAPIDisclosure>;
 	return <div id={id} {...rest} className={clsx("openapi-schema", className)}>
@@ -75,34 +67,75 @@ function OpenAPIRootSchema(props) {
 	const id = useId();
 	const properties = getSchemaProperties(schema);
 	const description = resolveDescription(schema);
-	if (properties?.length) {
-		const circularRefs = new Map(parentCircularRefs);
-		circularRefs.set(schema, id);
-		return <>
+	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} />;
 }
 function OpenAPIRootSchemaFromServer(props) {
 	return <OpenAPIRootSchema schema={JSON.parse(props.schema, retrocycle())} context={props.context} />;
 }
 /**
+* Get the discriminator value for a schema.
+*/
+function getDiscriminatorValue(schema, discriminator) {
+	if (!discriminator) return;
+	if (discriminator.mapping) {
+		const mappingEntry = Object.entries(discriminator.mapping).find(([key, ref]) => {
+			if (schema.title === ref || !!schema.title && ref.endsWith(`/${schema.title}`)) return true;
+			if (schema.title?.toLowerCase().replace(/\s/g, "").includes(key.toLowerCase())) return true;
+			return false;
+		});
+		if (mappingEntry) return mappingEntry[0];
+	}
+	if (!discriminator.propertyName || !schema.properties) return;
+	const property = schema.properties[discriminator.propertyName];
+	if (!property || checkIsReference(property)) return;
+	if (property.const) return String(property.const);
+	if (property.enum?.length === 1) return String(property.enum[0]);
+}
+/**
+* Render alternatives (oneOf/allOf/anyOf) for a schema.
+*/
+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>;
+}
+/**
 * Render a tab for an alternative schema.
 * It renders directly the properties if relevant;
 * for primitives, it renders the schema itself.
 */
 function OpenAPISchemaAlternative(props) {
 	const { schema, discriminator, circularRefs, context } = props;
-	const properties = getSchemaProperties(schema, discriminator);
+	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,
 		context
 	})}>
             <OpenAPISchemaProperties properties={properties} circularRefs={circularRefs} context={context} />
-        </OpenAPIDisclosure> : <OpenAPISchemaProperty property={{ schema }} circularRefs={circularRefs} context={context} />;
+        </OpenAPIDisclosure> : <OpenAPISchemaProperty property={{ schema }} discriminator={discriminator} discriminatorValue={discriminatorValue} circularRefs={circularRefs} context={context} />;
 }
 function OpenAPISchemaAlternativeSeparator(props) {
 	const { schema, context } = props;
@@ -121,8 +154,8 @@ function OpenAPISchemaAlternativeSeparator(props) {
 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>{" "}
-            <span className="openapi-schema-circular-glyph">↩</span>
         </div>;
 }
 /**
@@ -164,40 +197,81 @@ function OpenAPISchemaEnum(props) {
 * Render the top row of a schema. e.g: name, type, and required status.
 */
 function OpenAPISchemaPresentation(props) {
-	const { property: { schema, propertyName, required, isDiscriminatorProperty }, context } = props;
+	const { id, property: { schema, propertyName, required, isDiscriminatorProperty }, circularRefId, context } = props;
 	const description = resolveDescription(schema);
 	const example = resolveFirstExample(schema);
-	return <div className="openapi-schema-presentation">
-            <OpenAPISchemaName schema={schema} type={getSchemaTitle(schema)} propertyName={propertyName} isDiscriminatorProperty={isDiscriminatorProperty} required={required} context={context} />
-            {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} />
+	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>;
 }
 /**
+* Process properties from a schema object into property entries.
+*/
+function processSchemaProperties(schema, discriminator, discriminatorValue, allRequired) {
+	const result = [];
+	if (schema.properties) Object.entries(schema.properties).forEach(([propertyName, propertySchema]) => {
+		const isDiscriminator = discriminator?.propertyName === propertyName;
+		if (checkIsReference(propertySchema)) {
+			if (!isDiscriminator || !discriminatorValue) return;
+		}
+		let finalSchema = propertySchema;
+		if (isDiscriminator && discriminatorValue) finalSchema = {
+			...propertySchema,
+			const: discriminatorValue,
+			enum: [discriminatorValue]
+		};
+		result.push({
+			propertyName,
+			required: Array.isArray(schema.required) ? schema.required.includes(propertyName) : allRequired?.has(propertyName) ? true : void 0,
+			isDiscriminatorProperty: isDiscriminator,
+			schema: finalSchema
+		});
+	});
+	if (schema.additionalProperties && !checkIsReference(schema.additionalProperties)) result.push({
+		propertyName: "Other properties",
+		schema: schema.additionalProperties === true ? {} : schema.additionalProperties
+	});
+	return result;
+}
+/**
+* Merge properties into a result array, with later properties overriding earlier ones.
+*/
+function mergeProperties(result, newProperties) {
+	for (const prop of newProperties) {
+		const existingIndex = result.findIndex((p) => p.propertyName === prop.propertyName);
+		if (existingIndex >= 0) result[existingIndex] = prop;
+		else result.push(prop);
+	}
+}
+/**
 * Get the sub-properties of a schema.
 */
-function getSchemaProperties(schema, discriminator) {
+function getSchemaProperties(schema, discriminator, discriminatorValue) {
 	if (schema.type === "array" && schema.items && !checkIsReference(schema.items)) {
 		const items = schema.items;
-		const itemProperties = getSchemaProperties(items);
+		const itemProperties = getSchemaProperties(items, discriminator, discriminatorValue);
 		if (itemProperties) return itemProperties.map((prop) => ({
 			...prop,
 			isDiscriminatorProperty: discriminator?.propertyName === prop.propertyName
@@ -208,23 +282,25 @@ function getSchemaProperties(schema, discriminator) {
 			schema: items
 		}];
 	}
-	if (schema.type === "object" || schema.properties) {
-		const result = [];
-		if (schema.properties) Object.entries(schema.properties).forEach(([propertyName, propertySchema]) => {
-			if (checkIsReference(propertySchema)) return;
-			result.push({
-				propertyName,
-				required: Array.isArray(schema.required) ? schema.required.includes(propertyName) : void 0,
-				isDiscriminatorProperty: discriminator?.propertyName === propertyName,
-				schema: propertySchema
+	if (schema.allOf && Array.isArray(schema.allOf)) {
+		const allOfSchemas = schema.allOf.filter((s) => !checkIsReference(s));
+		if (allOfSchemas.length > 0) {
+			const result = [];
+			const allRequired = /* @__PURE__ */ new Set();
+			for (const allOfSchema of allOfSchemas) {
+				if (Array.isArray(allOfSchema.required)) allOfSchema.required.forEach((req) => allRequired.add(req));
+				const allOfProperties = getSchemaProperties(allOfSchema, discriminator, discriminatorValue);
+				if (allOfProperties) mergeProperties(result, allOfProperties);
+			}
+			if (Array.isArray(schema.required)) schema.required.forEach((req) => allRequired.add(req));
+			mergeProperties(result, processSchemaProperties(schema, discriminator, discriminatorValue, allRequired));
+			result.forEach((prop) => {
+				if (prop.propertyName && allRequired.has(prop.propertyName)) prop.required = true;
 			});
-		});
-		if (schema.additionalProperties && !checkIsReference(schema.additionalProperties)) result.push({
-			propertyName: "Other properties",
-			schema: schema.additionalProperties === true ? {} : schema.additionalProperties
-		});
-		return result;
+			return result.length > 0 ? result : null;
+		}
 	}
+	if (schema.type === "object" || schema.properties) return processSchemaProperties(schema, discriminator, discriminatorValue);
 	return null;
 }
 /**
@@ -342,23 +418,55 @@ function mergeAlternatives(alternativeType, schemasOrRefs) {
 }
 function flattenAlternatives(alternativeType, schemasOrRefs, ancestors) {
 	const latestAncestor = Array.from(ancestors).pop();
-	return schemasOrRefs.reduce((acc, schemaOrRef) => {
-		if (checkIsReference(schemaOrRef)) return acc;
-		if (schemaOrRef[alternativeType] && !ancestors.has(schemaOrRef)) {
-			const alternatives = getSchemaAlternatives(schemaOrRef, ancestors);
-			if (alternatives?.schemas) acc.push(...alternatives.schemas.map((schema$1) => ({
-				...schema$1,
-				required: mergeRequiredFields(schema$1, latestAncestor)
-			})));
-			return acc;
+	const result = [];
+	for (const schemaOrRef of schemasOrRefs) {
+		if (checkIsReference(schemaOrRef)) continue;
+		const flattened = flattenSchema(schemaOrRef, alternativeType, ancestors, latestAncestor);
+		if (flattened) result.push(...flattened);
+	}
+	return result;
+}
+/**
+* Flatten a schema that is an alternative of another schema.
+*/
+function flattenSchema(schema, alternativeType, ancestors, latestAncestor) {
+	if (schema[alternativeType] && !ancestors.has(schema)) {
+		const alternatives = getSchemaAlternatives(schema, ancestors);
+		if (alternatives?.schemas) return alternatives.schemas.map((s) => {
+			const required$2 = mergeRequiredFields(s, latestAncestor);
+			return {
+				...s,
+				...required$2 ? { required: required$2 } : {}
+			};
+		});
+		const required$1 = mergeRequiredFields(schema, latestAncestor);
+		return [{
+			...schema,
+			...required$1 ? { required: required$1 } : {}
+		}];
+	}
+	if ((alternativeType === "oneOf" || alternativeType === "anyOf") && schema.allOf && Array.isArray(schema.allOf) && !ancestors.has(schema)) {
+		const allOfSchemas = schema.allOf.filter((s) => !checkIsReference(s));
+		if (allOfSchemas.length > 0) {
+			const merged = mergeAlternatives("allOf", allOfSchemas);
+			if (merged && merged.length > 0) {
+				if (merged.length === 1) return merged.map((s) => {
+					const required$1 = mergeRequiredFields(s, latestAncestor);
+					const result = {
+						...s,
+						...required$1 ? { required: required$1 } : {}
+					};
+					if (schema.title && !s.title) result.title = schema.title;
+					return result;
+				});
+			}
 		}
-		const schema = {
-			...schemaOrRef,
-			required: mergeRequiredFields(schemaOrRef, latestAncestor)
-		};
-		acc.push(schema);
-		return acc;
-	}, []);
+	}
+	const required = mergeRequiredFields(schema, latestAncestor);
+	return [{
+		...schema,
+		...required ? { required } : {}
+	}];
 }
 /**
 * Merge the required fields of a schema with the required fields of its latest ancestor.

package/dist/generateSchemaExample.js

@@ -1,4 +1,5 @@
 import { checkIsReference } from "./utils.js";
+import { isPlainObject } from "./contentTypeChecks.js";
 
 //#region src/generateSchemaExample.ts
 /**
@@ -81,6 +82,10 @@ const getExampleFromSchema = (schema, options, level = 0, parentSchema, name, re
 		resultCache.set(schema$1, result);
 		return result;
 	}
+	function mergeAllOfIntoResponse(allOfItems, response, parent) {
+		const allOfResults = allOfItems.map((item) => getExampleFromSchema(item, options, level + 1, parent, void 0, resultCache)).filter(isPlainObject);
+		if (allOfResults.length > 0) Object.assign(response, ...allOfResults);
+	}
 	if (resultCache.has(schema)) return resultCache.get(schema);
 	if (level === MAX_LEVELS_DEEP + 1) try {
 		JSON.stringify(schema);
@@ -129,9 +134,21 @@ const getExampleFromSchema = (schema, options, level = 0, parentSchema, name, re
 			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));
+		if (schema.anyOf !== void 0) {
+			const anyOfItem = schema.anyOf[0];
+			if (anyOfItem) if (anyOfItem?.allOf !== void 0 && Array.isArray(anyOfItem.allOf)) mergeAllOfIntoResponse(anyOfItem.allOf, response, anyOfItem);
+			else {
+				const anyOfResult = getExampleFromSchema(anyOfItem, options, level + 1, void 0, void 0, resultCache);
+				if (isPlainObject(anyOfResult)) Object.assign(response, anyOfResult);
+			}
+		} else if (schema.oneOf !== void 0) {
+			const oneOfItem = schema.oneOf[0];
+			if (oneOfItem) if (oneOfItem?.allOf !== void 0 && Array.isArray(oneOfItem.allOf)) mergeAllOfIntoResponse(oneOfItem.allOf, response, oneOfItem);
+			else {
+				const oneOfResult = getExampleFromSchema(oneOfItem, options, level + 1, void 0, void 0, resultCache);
+				if (isPlainObject(oneOfResult)) Object.assign(response, oneOfResult);
+			}
+		} else if (schema.allOf !== void 0) mergeAllOfIntoResponse(schema.allOf, response, schema);
 		return cache(schema, response);
 	}
 	if (schema.type === "array" || schema.items !== void 0) {

package/dist/util/tryit-prefill.js

@@ -95,7 +95,10 @@ function resolveTryItPrefillServersForOperationServers(args) {
 function resolvePrefillCodePlaceholderFromSecurityScheme(args) {
 	const { security, defaultPlaceholderValue } = args;
 	const prefillExprParts = extractPrefillExpressionPartsFromSecurityScheme(security);
-	if (prefillExprParts.length === 0) return defaultPlaceholderValue ?? "";
+	if (prefillExprParts.length === 0) {
+		if (security["x-gitbook-token-placeholder"]) return security["x-gitbook-token-placeholder"];
+		return defaultPlaceholderValue ?? "";
+	}
 	return toPrefillCodePlaceholder(templatePartsToExpression(prefillExprParts), defaultPlaceholderValue);
 }
 function extractPrefillExpressionPartsFromSecurityScheme(security) {

package/dist/utils.js

@@ -122,20 +122,22 @@ function getStatusCodeCategory(statusCode) {
 	if (Number.isNaN(code) || code < 100 || code >= 600) return "unknown";
 	return Math.floor(code / 100);
 }
-function getSchemaTitle(schema) {
+function getSchemaTitle(schema, options) {
 	let type = "any";
 	if (schema.enum || schema["x-enumDescriptions"] || schema["x-gitbook-enum"]) type = `${schema.type} · enum`;
-	else if (schema.type === "array" && !!schema.items) type = `${getSchemaTitle(schema.items)}[]`;
+	else if (schema.type === "array" && !!schema.items) type = `${getSchemaTitle(schema.items, options)}[]`;
 	else if (Array.isArray(schema.type)) type = schema.type.join(" | ");
 	else if (schema.type || schema.properties) {
 		type = schema.type ?? "object";
 		if (schema.format) type += ` · ${schema.format}`;
 		if (type === "object" && schema.title) type += ` · ${schema.title.replaceAll(" ", "")}`;
 	}
-	if ("anyOf" in schema) type = "any of";
-	else if ("oneOf" in schema) type = "one of";
-	else if ("allOf" in schema) type = "all of";
-	else if ("not" in schema) type = "not";
+	if (!options?.ignoreAlternatives) {
+		if ("anyOf" in schema) type = "any of";
+		else if ("oneOf" in schema) type = "one of";
+		else if ("allOf" in schema) type = "all of";
+		else if ("not" in schema) type = "not";
+	}
 	return type;
 }
 /**

package/package.json

@@ -7,11 +7,11 @@
             "default": "./dist/index.js"
         }
     },
-    "version": "1.5.3",
+    "version": "1.5.5",
     "sideEffects": false,
     "dependencies": {
         "@gitbook/expr": "1.2.4",
-        "@gitbook/openapi-parser": "3.0.5",
+        "@gitbook/openapi-parser": "3.0.7",
         "@scalar/api-client-react": "^1.3.46",
         "@scalar/oas-utils": "^0.6.3",
         "@scalar/types": "^0.4.0",
@@ -30,8 +30,8 @@
         "@types/react": "^19.0.0",
         "@types/react-dom": "^19.0.0",
         "bun-types": "^1.1.20",
-        "react": "^19.0.0",
-        "react-dom": "^19.0.0",
+        "react": "^19.0.1",
+        "react-dom": "^19.0.1",
         "tsdown": "^0.15.6",
         "typescript": "^5.5.3"
     },