@gitbook/react-openapi 1.5.2 → 1.5.4

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/OpenAPISecurities.js

@@ -4,6 +4,7 @@ import { OpenAPICopyButton } from "./OpenAPICopyButton.js";
 import { OpenAPISchemaName } from "./OpenAPISchemaName.js";
 import { createStateKey, extractOperationSecurityInfo, resolveDescription } from "./utils.js";
 import { InteractiveSection } from "./InteractiveSection.js";
+import { OpenAPIRequiredScopes, OpenAPISchemaScopes } from "./OpenAPIRequiredScopes.js";
 import { Fragment } from "react";
 
 //#region src/OpenAPISecurities.tsx
@@ -17,20 +18,23 @@ function OpenAPISecurities(props) {
 		securityRequirement,
 		securities
 	});
-	return <InteractiveSection header={t(context.translation, "authorizations")} stateKey={createStateKey("securities", context.blockKey)} toggeable defaultOpened={false} toggleIcon={context.icons.chevronRight} selectIcon={context.icons.chevronDown} className="openapi-securities" tabs={tabsData.map(({ key, label, schemes }) => ({
+	const stateKey = createStateKey("securities", context.blockKey);
+	return <>
+            <OpenAPIRequiredScopes context={context} stateKey={stateKey} securities={tabsData} />
+            <InteractiveSection header={t(context.translation, "authorizations")} stateKey={stateKey} toggleIcon={context.icons.chevronRight} selectIcon={context.icons.chevronDown} className="openapi-securities" tabs={tabsData.map(({ key, label, schemes }) => ({
 		key,
 		label,
 		body: <div className="openapi-schema">
-                        {schemes.map((security, index) => {
-			const description = resolveDescription(security);
+                            {schemes.map((security, index) => {
+			const description = security.type !== "oauth2" ? resolveDescription(security) : void 0;
 			return <div key={`${key}-${index}`} className="openapi-schema-presentation">
-                                    {getLabelForType(security, context)}
-                                    {description ? <Markdown source={description} className="openapi-securities-description" /> : null}
-                                    {security.scopes?.length ? <OpenAPISchemaScopes scopes={security.scopes} context={context} /> : null}
-                                </div>;
+                                        {getLabelForType(security, context)}
+                                        {description ? <Markdown source={description} className="openapi-securities-description" /> : null}
+                                    </div>;
 		})}
-                    </div>
-	}))} />;
+                        </div>
+	}))} />
+        </>;
 }
 function getLabelForType(security, context) {
 	switch (security.type) {
@@ -61,11 +65,12 @@ function OpenAPISchemaOAuth2Flows(props) {
 function OpenAPISchemaOAuth2Item(props) {
 	const { flow, context, security, name } = props;
 	if (!flow) return null;
-	const scopes = flow.scopes ? Object.entries(flow.scopes) : [];
+	const scopes = !security.scopes?.length && flow.scopes ? Object.entries(flow.scopes) : [];
+	const description = resolveDescription(security);
 	return <div>
             <OpenAPISchemaName context={context} propertyName="OAuth2" type={name} required={security.required} />
             <div className="openapi-securities-oauth-content openapi-markdown">
-                {security.description ? <Markdown source={security.description} /> : null}
+                {description ? <Markdown source={description} className="openapi-securities-description" /> : null}
                 {"authorizationUrl" in flow && flow.authorizationUrl ? <span>
                         Authorization URL:{" "}
                         <OpenAPICopyButton value={flow.authorizationUrl} context={context} className="openapi-securities-url" withTooltip>
@@ -84,41 +89,10 @@ function OpenAPISchemaOAuth2Item(props) {
                             {flow.refreshUrl}
                         </OpenAPICopyButton>
                     </span> : null}
-                {scopes.length ? <OpenAPISchemaScopes scopes={scopes} context={context} /> : null}
+                {scopes.length ? <OpenAPISchemaScopes scopes={scopes} context={context} isOAuth2 /> : null}
             </div>
         </div>;
 }
-/**
-* Render a list of available scopes.
-*/
-function OpenAPISchemaScopes(props) {
-	const { scopes, context } = props;
-	return <div className="openapi-securities-scopes openapi-markdown">
-            <span>{t(context.translation, "required_scopes")}: </span>
-            <ul>
-                {scopes.map((scope) => <OpenAPIScopeItem key={scope[0]} scope={scope} context={context} />)}
-            </ul>
-        </div>;
-}
-/**
-* Display a scope item. Either a key-value pair or a single string.
-*/
-function OpenAPIScopeItem(props) {
-	const { scope, context } = props;
-	return <li>
-            <OpenAPIScopeItemKey name={scope[0]} context={context} />
-            {scope[1] ? `: ${scope[1]}` : null}
-        </li>;
-}
-/**
-* Displays the scope name within a copyable button.
-*/
-function OpenAPIScopeItemKey(props) {
-	const { name, context } = props;
-	return <OpenAPICopyButton value={name} context={context} withTooltip>
-            <code>{name}</code>
-        </OpenAPICopyButton>;
-}
 
 //#endregion
 export { OpenAPISecurities };

package/dist/OpenAPISelect.js

@@ -16,16 +16,16 @@ function useSelectState(stateKey = "select-state", initialKey = "default") {
 	};
 }
 function OpenAPISelect(props) {
-	const { icon = "▼", items, children, className, placement, stateKey, selectedKey, onSelectionChange } = props;
-	const state = useSelectState(stateKey, items[0]?.key);
+	const { icon, items, children, className, placement, stateKey, value, onChange, defaultValue } = props;
+	const state = useSelectState(stateKey, defaultValue ?? items[0]?.key);
 	const selected = items.find((item) => item.key === state.key) || items[0];
-	return <Select aria-label="OpenAPI Select" {...props} value={selectedKey || selected?.key} onChange={(key) => {
-		onSelectionChange?.(key);
+	return <Select aria-label="OpenAPI Select" {...props} value={value ?? selected?.key} onChange={(key) => {
+		onChange?.(key);
 		state.setKey(key);
 	}} className={clsx("openapi-select", className)}>
             <Button>
                 <SelectValue />
-                {icon}
+                {icon !== null ? icon || "▼" : null}
             </Button>
             <Popover placement={placement} className="openapi-select-popover">
                 <ListBox className="openapi-select-listbox" items={items}>
@@ -38,7 +38,7 @@ function OpenAPISelectItem(props) {
 	return <ListBoxItem {...props} className={({ isFocused, isSelected }) => clsx("openapi-select-item", {
 		"openapi-select-item-focused": isFocused,
 		"openapi-select-item-selected": isSelected
-	})} />;
+	}, props.className)} />;
 }
 
 //#endregion

package/dist/OpenAPISpec.js

@@ -36,7 +36,7 @@ function groupParameters(parameters, context) {
 		const key = parameter.in;
 		const label = getParameterGroupName(parameter.in, context);
 		const group = groups.find((group$1) => group$1.key === key);
-		if (group) group.parameters.push(parameter);
+		if (group) group.parameters = [...group.parameters, parameter];
 		else groups.push({
 			key,
 			label,

package/dist/OpenAPITooltip.js

@@ -0,0 +1,23 @@
+'use client';
+
+
+import clsx from "classnames";
+import { Tooltip, TooltipTrigger } from "react-aria-components";
+
+//#region src/OpenAPITooltip.tsx
+function OpenAPITooltip(props) {
+	const { children,...rest } = props;
+	return <TooltipTrigger {...rest} closeDelay={200} delay={200}>
+            {children}
+        </TooltipTrigger>;
+}
+function OpenAPITooltipContent(props) {
+	const { children, placement = "top", offset = 4, className,...rest } = props;
+	return <Tooltip {...rest} placement={placement} offset={offset} className={clsx("openapi-tooltip", className)}>
+            {children}
+        </Tooltip>;
+}
+OpenAPITooltip.Content = OpenAPITooltipContent;
+
+//#endregion
+export { OpenAPITooltip };

package/dist/ScalarApiButton.js

@@ -47,12 +47,15 @@ function ScalarModal(props) {
 		url: specUrl,
 		...prefillConfig
 	}} initialRequest={{
-		method,
+		method: toScalarHttpMethod(method),
 		path
 	}}>
             <ScalarModalController method={method} path={path} controllerRef={controllerRef} />
         </ApiClientModalProvider>;
 }
+function toScalarHttpMethod(method) {
+	return method.toUpperCase();
+}
 function ScalarModalController(props) {
 	const { method, path, controllerRef } = props;
 	const openScalarClient = useApiClientModal()?.open;
@@ -60,7 +63,7 @@ function ScalarModalController(props) {
 	const openClient = useMemo(() => {
 		if (openScalarClient) return () => {
 			openScalarClient({
-				method,
+				method: toScalarHttpMethod(method),
 				path,
 				_source: "gitbook"
 			});

package/dist/code-samples.js

@@ -33,7 +33,6 @@ ${headerString}${bodyString}`;
 		label: "cURL",
 		syntax: "bash",
 		generate: ({ method, url: { origin, path }, headers, body }) => {
-			const separator = " \\\n";
 			const lines = ["curl -L"];
 			if (method.toUpperCase() !== "GET") lines.push(`--request ${method.toUpperCase()}`);
 			lines.push(`--url '${origin}${path}'`);
@@ -49,7 +48,7 @@ ${headerString}${bodyString}`;
 			});
 			if (body) if (Array.isArray(body)) lines.push(...body);
 			else lines.push(body);
-			return lines.map((line, index) => index > 0 ? indent(line, 2) : line).join(separator);
+			return buildHeredoc(lines);
 		}
 	},
 	{
@@ -138,7 +137,15 @@ const BodyGenerators = {
 			headersCopy["Content-Type"] = "application/json";
 		} else if (isPDF(contentType)) body = `--data-binary '@${String(body)}'`;
 		else if (isYAML(contentType)) body = `--data-binary $'${yaml.dump(body).replace(/'/g, "").replace(/\\n/g, "\n")}'`;
-		else body = `--data '${stringifyOpenAPI(body, null, 2).replace(/\\n/g, "\n")}'`;
+		else {
+			const jsonString = stringifyOpenAPI(body, null, 2).replace(/\\n/g, "\n");
+			if (jsonString.includes("'")) body = [
+				"--data @- <<'EOF'",
+				...jsonString.split("\n"),
+				"EOF"
+			];
+			else body = `--data '${jsonString}'`;
+		}
 		return {
 			body,
 			headers: headersCopy
@@ -270,6 +277,29 @@ function convertBodyToXML(body) {
 	}
 	return json2xml(body).replace(/"/g, "").replace(/\\n/g, "\n").replace(/\\t/g, "	");
 }
+/**
+* Builds a heredoc string from an array of lines
+*/
+function buildHeredoc(lines) {
+	const separator = " \\\n";
+	let result = "";
+	let inHeredoc = false;
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		if (!line) continue;
+		const isHeredocStart = line.includes("<<'EOF'");
+		const isHeredocEnd = inHeredoc && line === "EOF";
+		if (isHeredocStart) {
+			inHeredoc = true;
+			result += `${i > 0 ? indent(line, 2) : line}\n`;
+		} else if (isHeredocEnd) {
+			inHeredoc = false;
+			result += line;
+		} else if (inHeredoc) result += `${indent(line, 2)}\n`;
+		else result += `${i > 0 ? indent(line, 2) : line}${i < lines.length - 1 ? separator : ""}`;
+	}
+	return result;
+}
 
 //#endregion
 export { codeSampleGenerators, parseHostAndPath };

package/dist/context.d.ts

@@ -14,6 +14,9 @@ interface OpenAPIClientContext {
     chevronDown: React.ReactNode;
     chevronRight: React.ReactNode;
     plus: React.ReactNode;
+    copy: React.ReactNode;
+    check: React.ReactNode;
+    lock: React.ReactNode;
   };
   /**
    * Force all sections to be opened by default.

package/dist/formatPath.js

@@ -0,0 +1,25 @@
+//#region src/formatPath.tsx
+/**
+* Format the path by wrapping placeholders in <span> tags.
+*/
+function formatPath(path) {
+	const regex = /\{\s*(\w+)\s*\}|:\w+/g;
+	const parts = [];
+	let lastIndex = 0;
+	path.replace(regex, (match, _, offset) => {
+		if (offset > lastIndex) parts.push(path.slice(lastIndex, offset));
+		parts.push(<span key={`offset-${offset}`} className="openapi-path-variable">
+                {match}
+            </span>);
+		lastIndex = offset + match.length;
+		return match;
+	});
+	if (lastIndex < path.length) parts.push(path.slice(lastIndex));
+	return parts.map((part, index) => {
+		if (typeof part === "string") return <span key={`part-${index}`}>{part}</span>;
+		return part;
+	});
+}
+
+//#endregion
+export { formatPath };