@gitbook/react-openapi 1.1.5 → 1.1.7

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import type { OpenAPICustomOperationProperties, OpenAPICustomSpecProperties, OpenAPIV3 } from '@gitbook/openapi-parser';
+import type { OpenAPICustomOperationProperties, OpenAPICustomSpecProperties, OpenAPISchema, OpenAPIV3 } from '@gitbook/openapi-parser';
 export interface OpenAPIContextProps extends OpenAPIClientContext {
     /**
      * Render a code block.
@@ -13,6 +13,7 @@ export interface OpenAPIContextProps extends OpenAPIClientContext {
     renderHeading: (props: {
         deprecated: boolean;
         title: string;
+        stability?: string;
     }) => React.ReactNode;
     /**
      * Render the document of the operation.
@@ -51,10 +52,6 @@ export interface OpenAPIOperationData extends OpenAPICustomSpecProperties {
     /** Securities that should be used for this operation */
     securities: [string, OpenAPIV3.SecuritySchemeObject][];
 }
-export type OpenAPISchema = {
-    name: string;
-    schema: OpenAPIV3.SchemaObject;
-};
 export interface OpenAPISchemasData {
     /** Components schemas to be used for schemas */
     schemas: OpenAPISchema[];

package/dist/utils.d.ts

@@ -1,5 +1,5 @@
 import type { AnyObject, OpenAPIV3, OpenAPIV3_1 } from '@gitbook/openapi-parser';
-export declare function checkIsReference(input: unknown): input is OpenAPIV3.ReferenceObject | OpenAPIV3_1.ReferenceObject;
+export declare function checkIsReference(input: unknown): input is OpenAPIV3.ReferenceObject;
 export declare function createStateKey(key: string, scope?: string): string;
 /**
  * Resolve the description of an object.

package/dist/utils.js

@@ -26,16 +26,20 @@ function hasDescription(object) {
  * Resolve the description of an object.
  */
 export function resolveDescription(object) {
-    // If the object has items and has a description, we resolve the description from items
+    // Resolve description from the object first
+    if (hasDescription(object)) {
+        return 'x-gitbook-description-html' in object &&
+            typeof object['x-gitbook-description-html'] === 'string'
+            ? object['x-gitbook-description-html'].trim()
+            : typeof object.description === 'string'
+                ? object.description.trim()
+                : undefined;
+    }
+    // If the object has no description, try to resolve it from the items
     if ('items' in object && typeof object.items === 'object' && hasDescription(object.items)) {
         return resolveDescription(object.items);
     }
-    return 'x-gitbook-description-html' in object &&
-        typeof object['x-gitbook-description-html'] === 'string'
-        ? object['x-gitbook-description-html'].trim()
-        : typeof object.description === 'string'
-            ? object.description.trim()
-            : undefined;
+    return undefined;
 }
 /**
  * Extract descriptions from an object.

package/package.json

@@ -8,12 +8,12 @@
             "default": "./dist/index.js"
         }
     },
-    "version": "1.1.5",
+    "version": "1.1.7",
     "sideEffects": false,
     "dependencies": {
         "@gitbook/openapi-parser": "workspace:*",
-        "@scalar/api-client-react": "^1.1.36",
-        "@scalar/oas-utils": "^0.2.110",
+        "@scalar/api-client-react": "^1.2.5",
+        "@scalar/oas-utils": "^0.2.120",
         "clsx": "^2.1.1",
         "flatted": "^3.2.9",
         "json-xml-parse": "^1.3.0",

package/src/InteractiveSection.tsx

@@ -32,8 +32,6 @@ export function InteractiveSection(props: {
     defaultTab?: string;
     /** Content of the header */
     header?: React.ReactNode;
-    /** Body of the section */
-    children?: React.ReactNode;
     /** Children to display within the container */
     overlay?: React.ReactNode;
 }) {
@@ -45,7 +43,6 @@ export function InteractiveSection(props: {
         tabs = [],
         defaultTab = tabs[0]?.key,
         header,
-        children,
         overlay,
         toggleIcon = '▶',
     } = props;
@@ -83,7 +80,7 @@ export function InteractiveSection(props: {
                     className={className}
                 >
                     <SectionHeaderContent className={className}>
-                        {(children || selectedTab?.body) && toggeable ? (
+                        {selectedTab?.body && toggeable ? (
                             <button
                                 {...mergeProps(buttonProps, focusProps)}
                                 ref={triggerRef}
@@ -131,9 +128,8 @@ export function InteractiveSection(props: {
                     </div>
                 </SectionHeader>
             ) : null}
-            {(!toggeable || state.isExpanded) && (children || selectedTab?.body) ? (
+            {(!toggeable || state.isExpanded) && selectedTab?.body ? (
                 <SectionBody ref={panelRef} {...panelProps} className={className}>
-                    {children}
                     {selectedTab?.body}
                 </SectionBody>
             ) : null}

package/src/OpenAPICodeSample.tsx

@@ -1,14 +1,20 @@
 import type { OpenAPIV3 } from '@gitbook/openapi-parser';
+import {
+    OpenAPIMediaTypeExamplesBody,
+    OpenAPIMediaTypeExamplesSelector,
+} from './OpenAPICodeSampleInteractive';
 import { OpenAPITabs, OpenAPITabsList, OpenAPITabsPanels } from './OpenAPITabs';
 import { ScalarApiButton } from './ScalarApiButton';
 import { StaticSection } from './StaticSection';
-import { type CodeSampleInput, codeSampleGenerators } from './code-samples';
-import { generateMediaTypeExample, generateSchemaExample } from './generateSchemaExample';
+import { type CodeSampleGenerator, codeSampleGenerators } from './code-samples';
+import { generateMediaTypeExamples, generateSchemaExample } from './generateSchemaExample';
 import { stringifyOpenAPI } from './stringifyOpenAPI';
 import type { OpenAPIContextProps, OpenAPIOperationData } from './types';
 import { getDefaultServerURL } from './util/server';
 import { checkIsReference, createStateKey } from './utils';
 
+const CUSTOM_CODE_SAMPLES_KEYS = ['x-custom-examples', 'x-code-samples', 'x-codeSamples'] as const;
+
 /**
  * Display code samples to execute the operation.
  * It supports the Redocly custom syntax as well (https://redocly.com/docs/api-reference-docs/specification-extensions/x-code-samples/)
@@ -16,6 +22,43 @@ import { checkIsReference, createStateKey } from './utils';
 export function OpenAPICodeSample(props: {
     data: OpenAPIOperationData;
     context: OpenAPIContextProps;
+}) {
+    const { data } = props;
+
+    // If code samples are disabled at operation level, we don't display the code samples.
+    if (data.operation['x-codeSamples'] === false) {
+        return null;
+    }
+
+    const customCodeSamples = getCustomCodeSamples(props);
+
+    // If code samples are disabled at the top-level and not custom code samples are defined,
+    // we don't display the code samples.
+    if (data['x-codeSamples'] === false && !customCodeSamples) {
+        return null;
+    }
+
+    const samples = customCodeSamples ?? generateCodeSamples(props);
+
+    if (samples.length === 0) {
+        return null;
+    }
+
+    return (
+        <OpenAPITabs stateKey={createStateKey('codesample')} items={samples}>
+            <StaticSection header={<OpenAPITabsList />} className="openapi-codesample">
+                <OpenAPITabsPanels />
+            </StaticSection>
+        </OpenAPITabs>
+    );
+}
+
+/**
+ * Generate code samples for the operation.
+ */
+function generateCodeSamples(props: {
+    data: OpenAPIOperationData;
+    context: OpenAPIContextProps;
 }) {
     const { data, context } = props;
 
@@ -51,97 +94,111 @@ export function OpenAPICodeSample(props: {
     const requestBody = !checkIsReference(data.operation.requestBody)
         ? data.operation.requestBody
         : undefined;
-    const requestBodyContentEntries = requestBody?.content
-        ? Object.entries(requestBody.content)
-        : undefined;
-    const requestBodyContent = requestBodyContentEntries?.[0];
-
-    const input: CodeSampleInput = {
-        url:
-            getDefaultServerURL(data.servers) +
-            data.path +
-            (searchParams.size ? `?${searchParams.toString()}` : ''),
-        method: data.method,
-        body: requestBodyContent ? generateMediaTypeExample(requestBodyContent[1]) : undefined,
-        headers: {
-            ...getSecurityHeaders(data.securities),
-            ...headersObject,
-            ...(requestBodyContent
-                ? {
-                      'Content-Type': requestBodyContent[0],
-                  }
-                : undefined),
-        },
+
+    const url =
+        getDefaultServerURL(data.servers) +
+        data.path +
+        (searchParams.size ? `?${searchParams.toString()}` : '');
+
+    const genericHeaders = {
+        ...getSecurityHeaders(data.securities),
+        ...headersObject,
     };
 
-    const autoCodeSamples = codeSampleGenerators.map((generator) => ({
-        key: `default-${generator.id}`,
-        label: generator.label,
-        body: context.renderCodeBlock({
-            code: generator.generate(input),
-            syntax: generator.syntax,
-        }),
-        footer: <OpenAPICodeSampleFooter data={data} context={context} />,
-    }));
-
-    // Use custom samples if defined
-    let customCodeSamples: null | Array<{
-        key: string;
-        label: string;
-        body: React.ReactNode;
-    }> = null;
-    (['x-custom-examples', 'x-code-samples', 'x-codeSamples'] as const).forEach((key) => {
-        const customSamples = data.operation[key];
-        if (customSamples && Array.isArray(customSamples)) {
-            customCodeSamples = customSamples
-                .filter((sample) => {
-                    return (
-                        typeof sample.label === 'string' &&
-                        typeof sample.source === 'string' &&
-                        typeof sample.lang === 'string'
-                    );
-                })
-                .map((sample, index) => ({
-                    key: `redocly-${sample.lang}-${index}`,
-                    label: sample.label,
-                    body: context.renderCodeBlock({
-                        code: sample.source,
-                        syntax: sample.lang,
+    const mediaTypeRendererFactories = Object.entries(requestBody?.content ?? {}).map(
+        ([mediaType, mediaTypeObject]) => {
+            return (generator: CodeSampleGenerator) => {
+                const mediaTypeHeaders = {
+                    ...genericHeaders,
+                    'Content-Type': mediaType,
+                };
+                return {
+                    mediaType,
+                    element: context.renderCodeBlock({
+                        code: generator.generate({
+                            url,
+                            method: data.method,
+                            body: undefined,
+                            headers: mediaTypeHeaders,
+                        }),
+                        syntax: generator.syntax,
                     }),
-                    footer: <OpenAPICodeSampleFooter data={data} context={context} />,
-                }));
+                    examples: generateMediaTypeExamples(mediaTypeObject, {
+                        mode: 'write',
+                    }).map((example) => ({
+                        example,
+                        element: context.renderCodeBlock({
+                            code: generator.generate({
+                                url,
+                                method: data.method,
+                                body: example.value,
+                                headers: mediaTypeHeaders,
+                            }),
+                            syntax: generator.syntax,
+                        }),
+                    })),
+                } satisfies MediaTypeRenderer;
+            };
         }
-    });
-
-    // Code samples can be disabled at the top-level or at the operation level
-    // If code samples are defined at the operation level, it will override the top-level setting
-    const codeSamplesDisabled =
-        data['x-codeSamples'] === false || data.operation['x-codeSamples'] === false;
-    const samples = customCodeSamples ?? (!codeSamplesDisabled ? autoCodeSamples : []);
+    );
 
-    if (samples.length === 0) {
-        return null;
-    }
+    return codeSampleGenerators.map((generator) => {
+        if (mediaTypeRendererFactories.length > 0) {
+            const renderers = mediaTypeRendererFactories.map((generate) => generate(generator));
+            return {
+                key: `default-${generator.id}`,
+                label: generator.label,
+                body: (
+                    <OpenAPIMediaTypeExamplesBody
+                        method={data.method}
+                        path={data.path}
+                        renderers={renderers}
+                    />
+                ),
+                footer: (
+                    <OpenAPICodeSampleFooter renderers={renderers} data={data} context={context} />
+                ),
+            };
+        }
+        return {
+            key: `default-${generator.id}`,
+            label: generator.label,
+            body: context.renderCodeBlock({
+                code: generator.generate({
+                    url,
+                    method: data.method,
+                    body: undefined,
+                    headers: genericHeaders,
+                }),
+                syntax: generator.syntax,
+            }),
+            footer: <OpenAPICodeSampleFooter data={data} renderers={[]} context={context} />,
+        };
+    });
+}
 
-    return (
-        <OpenAPITabs stateKey={createStateKey('codesample')} items={samples}>
-            <StaticSection header={<OpenAPITabsList />} className="openapi-codesample">
-                <OpenAPITabsPanels />
-            </StaticSection>
-        </OpenAPITabs>
-    );
+export interface MediaTypeRenderer {
+    mediaType: string;
+    element: React.ReactNode;
+    examples: Array<{
+        example: OpenAPIV3.ExampleObject;
+        element: React.ReactNode;
+    }>;
 }
 
 function OpenAPICodeSampleFooter(props: {
     data: OpenAPIOperationData;
+    renderers: MediaTypeRenderer[];
     context: OpenAPIContextProps;
 }) {
-    const { data, context } = props;
+    const { data, context, renderers } = props;
     const { method, path } = data;
     const { specUrl } = context;
     const hideTryItPanel = data['x-hideTryItPanel'] || data.operation['x-hideTryItPanel'];
+    const hasMultipleMediaTypes =
+        renderers.length > 1 || renderers.some((renderer) => renderer.examples.length > 0);
 
-    if (hideTryItPanel) {
+    if (hideTryItPanel && !hasMultipleMediaTypes) {
         return null;
     }
 
@@ -151,11 +208,63 @@ function OpenAPICodeSampleFooter(props: {
 
     return (
         <div className="openapi-codesample-footer">
-            <ScalarApiButton method={method} path={path} specUrl={specUrl} />
+            {hasMultipleMediaTypes ? (
+                <OpenAPIMediaTypeExamplesSelector
+                    method={data.method}
+                    path={data.path}
+                    renderers={renderers}
+                />
+            ) : (
+                <span />
+            )}
+            {!hideTryItPanel && <ScalarApiButton method={method} path={path} specUrl={specUrl} />}
         </div>
     );
 }
 
+/**
+ * Get custom code samples for the operation.
+ */
+function getCustomCodeSamples(props: {
+    data: OpenAPIOperationData;
+    context: OpenAPIContextProps;
+}) {
+    const { data, context } = props;
+
+    let customCodeSamples: null | Array<{
+        key: string;
+        label: string;
+        body: React.ReactNode;
+    }> = null;
+
+    CUSTOM_CODE_SAMPLES_KEYS.forEach((key) => {
+        const customSamples = data.operation[key];
+        if (customSamples && Array.isArray(customSamples)) {
+            customCodeSamples = customSamples
+                .filter((sample) => {
+                    return (
+                        typeof sample.label === 'string' &&
+                        typeof sample.source === 'string' &&
+                        typeof sample.lang === 'string'
+                    );
+                })
+                .map((sample, index) => ({
+                    key: `custom-sample-${sample.lang}-${index}`,
+                    label: sample.label,
+                    body: context.renderCodeBlock({
+                        code: sample.source,
+                        syntax: sample.lang,
+                    }),
+                    footer: (
+                        <OpenAPICodeSampleFooter renderers={[]} data={data} context={context} />
+                    ),
+                }));
+        }
+    });
+
+    return customCodeSamples;
+}
+
 function getSecurityHeaders(securities: OpenAPIOperationData['securities']): {
     [key: string]: string;
 } {

package/src/OpenAPICodeSampleInteractive.tsx

@@ -0,0 +1,139 @@
+'use client';
+import clsx from 'clsx';
+import { useCallback } from 'react';
+import { useStore } from 'zustand';
+import type { MediaTypeRenderer } from './OpenAPICodeSample';
+import { getOrCreateTabStoreByKey } from './useSyncedTabsGlobalState';
+
+type MediaTypeState = {
+    mediaType: string;
+    setMediaType: (mediaType: string) => void;
+};
+
+function useMediaTypeState(
+    data: { method: string; path: string },
+    defaultKey: string
+): MediaTypeState {
+    const { method, path } = data;
+    const store = useStore(getOrCreateTabStoreByKey(`media-type-${method}-${path}`, defaultKey));
+    if (typeof store.tabKey !== 'string') {
+        throw new Error('Media type key is not a string');
+    }
+    return {
+        mediaType: store.tabKey,
+        setMediaType: useCallback((index: string) => store.setTabKey(index), [store.setTabKey]),
+    };
+}
+
+function useMediaTypeSampleIndexState(data: { method: string; path: string }, mediaType: string) {
+    const { method, path } = data;
+    const store = useStore(
+        getOrCreateTabStoreByKey(`media-type-sample-${mediaType}-${method}-${path}`, 0)
+    );
+    if (typeof store.tabKey !== 'number') {
+        throw new Error('Example key is not a number');
+    }
+    return {
+        index: store.tabKey,
+        setIndex: useCallback((index: number) => store.setTabKey(index), [store.setTabKey]),
+    };
+}
+
+export function OpenAPIMediaTypeExamplesSelector(props: {
+    method: string;
+    path: string;
+    renderers: MediaTypeRenderer[];
+}) {
+    const { method, path, renderers } = props;
+    if (!renderers[0]) {
+        throw new Error('No renderers provided');
+    }
+    const state = useMediaTypeState({ method, path }, renderers[0].mediaType);
+    const selected = renderers.find((r) => r.mediaType === state.mediaType) || renderers[0];
+
+    return (
+        <div className="openapi-codesample-selectors">
+            <MediaTypeSelector state={state} renderers={renderers} />
+            <ExamplesSelector method={method} path={path} renderer={selected} />
+        </div>
+    );
+}
+
+function MediaTypeSelector(props: {
+    state: MediaTypeState;
+    renderers: MediaTypeRenderer[];
+}) {
+    const { renderers, state } = props;
+
+    if (renderers.length < 2) {
+        return null;
+    }
+
+    return (
+        <select
+            className={clsx('openapi-select')}
+            value={state.mediaType}
+            onChange={(e) => state.setMediaType(e.target.value)}
+        >
+            {renderers.map((renderer) => (
+                <option key={renderer.mediaType} value={renderer.mediaType}>
+                    {renderer.mediaType}
+                </option>
+            ))}
+        </select>
+    );
+}
+
+function ExamplesSelector(props: {
+    method: string;
+    path: string;
+    renderer: MediaTypeRenderer;
+}) {
+    const { method, path, renderer } = props;
+    const state = useMediaTypeSampleIndexState({ method, path }, renderer.mediaType);
+    if (renderer.examples.length < 2) {
+        return null;
+    }
+
+    return (
+        <select
+            className={clsx('openapi-select')}
+            value={String(state.index)}
+            onChange={(e) => state.setIndex(Number(e.target.value))}
+        >
+            {renderer.examples.map((example, index) => (
+                <option key={index} value={index}>
+                    {example.example.summary || `Example ${index + 1}`}
+                </option>
+            ))}
+        </select>
+    );
+}
+
+export function OpenAPIMediaTypeExamplesBody(props: {
+    method: string;
+    path: string;
+    renderers: MediaTypeRenderer[];
+}) {
+    const { renderers, method, path } = props;
+    if (!renderers[0]) {
+        throw new Error('No renderers provided');
+    }
+    const mediaTypeState = useMediaTypeState({ method, path }, renderers[0].mediaType);
+    const selected =
+        renderers.find((r) => r.mediaType === mediaTypeState.mediaType) ?? renderers[0];
+    if (selected.examples.length === 0) {
+        return selected.element;
+    }
+    return <ExamplesBody method={method} path={path} renderer={selected} />;
+}
+
+function ExamplesBody(props: { method: string; path: string; renderer: MediaTypeRenderer }) {
+    const { method, path, renderer } = props;
+    const exampleState = useMediaTypeSampleIndexState({ method, path }, renderer.mediaType);
+    const example = renderer.examples[exampleState.index] ?? renderer.examples[0];
+    if (!example) {
+        throw new Error(`No example found for index ${exampleState.index}`);
+    }
+    return example.element;
+}

package/src/OpenAPICopyButton.tsx

@@ -6,10 +6,16 @@ import { Button, type ButtonProps, Tooltip, TooltipTrigger } from 'react-aria-co
 export function OpenAPICopyButton(
     props: ButtonProps & {
         value: string;
+        children: React.ReactNode;
+        label?: string;
+        /**
+         * Whether to show a tooltip.
+         * @default true
+         */
+        withTooltip?: boolean;
     }
 ) {
-    const { value } = props;
-    const { children, onPress, className } = props;
+    const { value, label, children, onPress, className, withTooltip = true } = props;
     const [copied, setCopied] = useState(false);
     const [isOpen, setIsOpen] = useState(false);
 
@@ -21,12 +27,19 @@ export function OpenAPICopyButton(
 
             setTimeout(() => {
                 setCopied(false);
+                setIsOpen(false);
             }, 2000);
         });
     };
 
     return (
-        <TooltipTrigger isOpen={isOpen} onOpenChange={setIsOpen} closeDelay={200} delay={200}>
+        <TooltipTrigger
+            isOpen={isOpen}
+            onOpenChange={setIsOpen}
+            isDisabled={!withTooltip}
+            closeDelay={200}
+            delay={200}
+        >
             <Button
                 type="button"
                 preventFocusOnPress
@@ -47,7 +60,7 @@ export function OpenAPICopyButton(
                 offset={4}
                 className="openapi-tooltip"
             >
-                {copied ? 'Copied' : 'Copy to clipboard'}{' '}
+                {copied ? 'Copied' : label || 'Copy to clipboard'}
             </Tooltip>
         </TooltipTrigger>
     );