@gitbook/react-openapi 1.4.2 → 1.5.1

package/src/OpenAPIRequestBodyHeaderType.tsx

@@ -1,36 +0,0 @@
-'use client';
-
-import type { OpenAPIV3 } from '@gitbook/openapi-parser';
-import { useSelectState } from './OpenAPISelect';
-import { getSchemaTitle } from './utils';
-
-/**
- * Display the type of a request body. It only displays the type if the selected content is an array.
- */
-export function OpenAPIRequestBodyHeaderType(props: {
-    requestBody: OpenAPIV3.RequestBodyObject;
-    stateKey: string;
-}) {
-    const { requestBody, stateKey } = props;
-    const content = requestBody.content ?? {};
-    const state = useSelectState(stateKey, Object.keys(content)[0]);
-
-    const selectedContentMediaType = Object.entries(content).find(
-        ([contentType]) => contentType === state.key
-    )?.[1];
-
-    // If the selected content is not an array, we don't display the type
-    if (
-        !selectedContentMediaType ||
-        !selectedContentMediaType.schema?.type ||
-        selectedContentMediaType.schema.type !== 'array'
-    ) {
-        return null;
-    }
-
-    return (
-        <span className="openapi-requestbody-header-type">
-            {`${getSchemaTitle(selectedContentMediaType.schema)}`}
-        </span>
-    );
-}

package/src/OpenAPIResponse.tsx

@@ -1,82 +0,0 @@
-import type { OpenAPIV3 } from '@gitbook/openapi-parser';
-import { OpenAPIDisclosure } from './OpenAPIDisclosure';
-import { OpenAPISchemaPresentation } from './OpenAPISchema';
-import { OpenAPISchemaProperties } from './OpenAPISchemaServer';
-import type { OpenAPIClientContext } from './context';
-import { tString } from './translate';
-import { parameterToProperty, resolveDescription } from './utils';
-
-/**
- * Display an interactive response body.
- */
-export function OpenAPIResponse(props: {
-    response: OpenAPIV3.ResponseObject;
-    mediaType: OpenAPIV3.MediaTypeObject | null;
-    context: OpenAPIClientContext;
-}) {
-    const { response, context, mediaType } = props;
-    const headers = Object.entries(response.headers ?? {}).map(
-        ([name, header]) => [name, header ?? {}] as const
-    );
-    const content = Object.entries(mediaType?.schema ?? {});
-
-    const description = resolveDescription(response);
-
-    if (content.length === 0 && !description && headers.length === 0) {
-        return null;
-    }
-
-    return (
-        <div className="openapi-response-body">
-            {headers.length > 0 ? (
-                <OpenAPIDisclosure
-                    header={
-                        <OpenAPISchemaPresentation
-                            context={context}
-                            property={{
-                                propertyName: tString(context.translation, 'headers'),
-                                schema: {
-                                    type: 'object',
-                                },
-                                required: null,
-                            }}
-                        />
-                    }
-                    icon={context.icons.plus}
-                    label={(isExpanded) =>
-                        tString(
-                            context.translation,
-                            isExpanded ? 'hide' : 'show',
-                            tString(
-                                context.translation,
-                                headers.length === 1 ? 'header' : 'headers'
-                            )
-                        )
-                    }
-                >
-                    <OpenAPISchemaProperties
-                        properties={headers.map(([name, header]) =>
-                            parameterToProperty({ name, ...header })
-                        )}
-                        context={context}
-                    />
-                </OpenAPIDisclosure>
-            ) : null}
-            {mediaType?.schema && (
-                <div className="openapi-responsebody">
-                    <OpenAPISchemaProperties
-                        id={`response-${context.blockKey}`}
-                        properties={[
-                            {
-                                schema: mediaType.schema,
-                                propertyName: tString(context.translation, 'response'),
-                                required: null,
-                            },
-                        ]}
-                        context={context}
-                    />
-                </div>
-            )}
-        </div>
-    );
-}

package/src/OpenAPIResponseExample.tsx

@@ -1,151 +0,0 @@
-import type { OpenAPIV3 } from '@gitbook/openapi-parser';
-import { Markdown } from './Markdown';
-import { OpenAPIEmptyExample, OpenAPIExample } from './OpenAPIExample';
-import { OpenAPIMediaTypeContent } from './OpenAPIMediaType';
-import { OpenAPIResponseExampleContent } from './OpenAPIResponseExampleContent';
-import { type OpenAPIContext, getOpenAPIClientContext } from './context';
-import type { OpenAPIOperationData, OpenAPIWebhookData } from './types';
-import { getExampleFromReference, getExamples } from './util/example';
-import { createStateKey, getStatusCodeDefaultLabel, resolveDescription } from './utils';
-import { checkIsReference } from './utils';
-
-/**
- * Display an example of the response content.
- */
-export function OpenAPIResponseExample(props: {
-    data: OpenAPIOperationData | OpenAPIWebhookData;
-    context: OpenAPIContext;
-}) {
-    const { data, context } = props;
-
-    // if there are no responses defined for the operation
-    if (!data.operation.responses) {
-        return null;
-    }
-
-    const responses = Object.entries(data.operation.responses);
-    // Sort response to get 200, and 2xx first
-    responses.sort(([a], [b]) => {
-        if (a === 'default') {
-            return 1;
-        }
-        if (b === 'default') {
-            return -1;
-        }
-        if (a === '200') {
-            return -1;
-        }
-        if (b === '200') {
-            return 1;
-        }
-        return Number(a) - Number(b);
-    });
-
-    const tabs = responses
-        .filter(
-            ([_, responseObject]) =>
-                responseObject &&
-                typeof responseObject === 'object' &&
-                // Make sure the response is not hidden
-                !responseObject['x-hideSample']
-        )
-        .map(([key, responseObject]) => {
-            const description = resolveDescription(responseObject);
-            const label = description ? (
-                <Markdown key={`response-description-${key}`} source={description} />
-            ) : (
-                getStatusCodeDefaultLabel(key, context)
-            );
-
-            if (checkIsReference(responseObject)) {
-                return {
-                    key: key,
-                    label,
-                    statusCode: key,
-                    body: (
-                        <OpenAPIExample
-                            example={getExampleFromReference(responseObject, context)}
-                            context={context}
-                            syntax="json"
-                        />
-                    ),
-                };
-            }
-
-            if (!responseObject.content || Object.keys(responseObject.content).length === 0) {
-                return {
-                    key: key,
-                    label,
-                    statusCode: key,
-                    body: <OpenAPIEmptyExample context={context} />,
-                };
-            }
-
-            return {
-                key: key,
-                label,
-                statusCode: key,
-                body: <OpenAPIResponse context={context} content={responseObject.content} />,
-            };
-        });
-
-    if (tabs.length === 0) {
-        return null;
-    }
-
-    return (
-        <OpenAPIResponseExampleContent
-            selectIcon={context.icons.chevronDown}
-            blockKey={context.blockKey}
-            items={tabs}
-        />
-    );
-}
-
-function OpenAPIResponse(props: {
-    context: OpenAPIContext;
-    content: {
-        [media: string]: OpenAPIV3.MediaTypeObject | null;
-    };
-}) {
-    const { context, content } = props;
-
-    const entries = Object.entries(content);
-    const firstEntry = entries[0];
-
-    if (!firstEntry) {
-        throw new Error('One media type is required');
-    }
-
-    const tabs = entries.map((entry) => {
-        const [mediaType, mediaTypeObject] = entry;
-
-        if (!mediaTypeObject) {
-            return {
-                key: mediaType,
-                label: mediaType,
-                body: <OpenAPIEmptyExample context={context} />,
-            };
-        }
-
-        return {
-            key: mediaType,
-            label: mediaType,
-            body: <></>,
-            examples: getExamples({
-                mediaTypeObject,
-                mediaType,
-                context,
-            }),
-        };
-    });
-
-    return (
-        <OpenAPIMediaTypeContent
-            selectIcon={context.icons.chevronDown}
-            stateKey={createStateKey('response-media-types', context.blockKey)}
-            items={tabs}
-            context={getOpenAPIClientContext(context)}
-        />
-    );
-}

package/src/OpenAPIResponseExampleContent.tsx

@@ -1,125 +0,0 @@
-'use client';
-
-import clsx from 'clsx';
-import type { Key } from 'react-aria';
-import { OpenAPISelect, OpenAPISelectItem, useSelectState } from './OpenAPISelect';
-import { StaticSection } from './StaticSection';
-import { createStateKey, getStatusCodeClassName } from './utils';
-
-type OpenAPIResponseExampleItem = OpenAPISelectItem & {
-    statusCode: string;
-    body: React.ReactNode;
-};
-
-/**
- * Get the state of the response examples select.
- */
-export function useResponseExamplesState(
-    blockKey: string | undefined,
-    initialKey: Key = 'default'
-) {
-    return useSelectState(getResponseExampleStateKey(blockKey), initialKey);
-}
-
-export function OpenAPIResponseExampleContent(props: {
-    items: OpenAPIResponseExampleItem[];
-    blockKey?: string;
-    selectIcon?: React.ReactNode;
-}) {
-    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>
-    );
-}
-
-function OpenAPIResponseExampleHeader(props: {
-    items: OpenAPIResponseExampleItem[];
-    blockKey?: string;
-    selectIcon?: React.ReactNode;
-}) {
-    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 (
-        <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>
-    );
-}
-
-function OpenAPIResponseExampleItem(props: {
-    item: OpenAPIResponseExampleItem;
-}) {
-    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>
-        </>
-    );
-}
-
-function OpenAPIResponseExampleBody(props: {
-    items: OpenAPIResponseExampleItem[];
-    blockKey?: string;
-}) {
-    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 the state key for the response examples.
- */
-function getResponseExampleStateKey(blockKey: string | undefined) {
-    return createStateKey('openapi-responses', blockKey);
-}

package/src/OpenAPIResponses.tsx

@@ -1,125 +0,0 @@
-'use client';
-
-import type { OpenAPIV3, OpenAPIV3_1 } from '@gitbook/openapi-parser';
-import clsx from 'clsx';
-import { Markdown } from './Markdown';
-import { OpenAPIDisclosureGroup } from './OpenAPIDisclosureGroup';
-import { OpenAPIResponse } from './OpenAPIResponse';
-import { useResponseExamplesState } from './OpenAPIResponseExampleContent';
-import { StaticSection } from './StaticSection';
-import type { OpenAPIClientContext } from './context';
-import { t } from './translate';
-import {
-    createStateKey,
-    getStatusCodeClassName,
-    getStatusCodeDefaultLabel,
-    resolveDescription,
-} from './utils';
-
-/**
- * Display an interactive response body.
- */
-export function OpenAPIResponses(props: {
-    responses: OpenAPIV3.ResponsesObject | OpenAPIV3_1.ResponsesObject;
-    context: OpenAPIClientContext;
-}) {
-    const { responses, context } = props;
-
-    const groups = Object.entries(responses)
-        .filter(([_, response]) => response && typeof response === 'object')
-        .map(([statusCode, response]: [string, OpenAPIV3.ResponseObject]) => {
-            const tabs = (() => {
-                // If there is no content, but there are headers, we need to show the headers
-                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}
-                                />
-                            ),
-                        },
-                    ];
-                }
-
-                if (!response.content) {
-                    return [
-                        {
-                            key: 'default',
-                            label: '',
-                            body: (
-                                <pre className="openapi-example-empty">
-                                    <p>{t(context.translation, 'no_content')}</p>
-                                </pre>
-                            ),
-                        },
-                    ];
-                }
-
-                return Object.entries(response.content ?? {}).map(([contentType, mediaType]) => ({
-                    key: contentType,
-                    label: contentType,
-                    body: (
-                        <OpenAPIResponse
-                            response={response}
-                            mediaType={mediaType}
-                            context={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>
-                ),
-                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]) : 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>
-    );
-}

package/src/OpenAPISchema.test.ts

@@ -1,172 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-import type { OpenAPIV3 } from '@gitbook/openapi-parser';
-import { getSchemaAlternatives } from './OpenAPISchema';
-
-describe('getSchemaAlternatives', () => {
-    it('should flatten oneOf', () => {
-        expect(
-            getSchemaAlternatives({
-                oneOf: [
-                    {
-                        oneOf: [
-                            {
-                                type: 'number',
-                            },
-                            {
-                                type: 'boolean',
-                            },
-                        ],
-                    },
-                    {
-                        type: 'string',
-                    },
-                ],
-            })
-        ).toEqual([
-            {
-                type: 'number',
-            },
-            {
-                type: 'boolean',
-            },
-            {
-                type: 'string',
-            },
-        ]);
-    });
-
-    it('merges string enum', () => {
-        expect(
-            getSchemaAlternatives({
-                oneOf: [
-                    {
-                        oneOf: [
-                            {
-                                type: 'string',
-                                enum: ['a', 'b'],
-                            },
-                            {
-                                type: 'string',
-                                enum: ['c', 'd'],
-                                nullable: true,
-                            },
-                        ],
-                    },
-                ],
-            })
-        ).toEqual([
-            {
-                type: 'string',
-                enum: ['a', 'b', 'c', 'd'],
-                nullable: true,
-            },
-        ]);
-    });
-
-    it('merges objects with allOf', () => {
-        expect(
-            getSchemaAlternatives({
-                allOf: [
-                    {
-                        type: 'object',
-                        properties: {
-                            name: {
-                                type: 'string',
-                            },
-                            map: {
-                                type: 'string',
-                            },
-                            description: {
-                                type: 'string',
-                            },
-                        },
-                        required: ['name'],
-                    },
-                    {
-                        type: 'object',
-                        properties: {
-                            externalId: {
-                                type: 'string',
-                            },
-                        },
-                        required: ['map', 'externalId'],
-                    },
-                ],
-            })
-        ).toEqual([
-            {
-                type: 'object',
-                properties: {
-                    name: {
-                        type: 'string',
-                    },
-                    map: {
-                        type: 'string',
-                    },
-                    description: {
-                        type: 'string',
-                    },
-                    externalId: {
-                        type: 'string',
-                    },
-                },
-                required: ['name', 'map', 'externalId'],
-            },
-        ]);
-    });
-
-    it('should not flatten oneOf and allOf', () => {
-        expect(
-            getSchemaAlternatives({
-                oneOf: [
-                    {
-                        allOf: [
-                            {
-                                type: 'number',
-                            },
-                            {
-                                type: 'boolean',
-                            },
-                        ],
-                    },
-                    {
-                        type: 'string',
-                    },
-                ],
-            })
-        ).toEqual([
-            {
-                allOf: [
-                    {
-                        type: 'number',
-                    },
-                    {
-                        type: 'boolean',
-                    },
-                ],
-            },
-            {
-                type: 'string',
-            },
-        ]);
-    });
-
-    it('should stop at circular references', () => {
-        const a: OpenAPIV3.SchemaObject = {
-            anyOf: [
-                {
-                    type: 'string',
-                },
-            ],
-        };
-
-        a.anyOf?.push(a);
-
-        expect(getSchemaAlternatives(a)).toEqual([
-            {
-                type: 'string',
-            },
-            a,
-        ]);
-    });
-});