@gitbook/react-openapi 1.4.3 → 1.5.2

package/dist/util/example.jsx

@@ -1,103 +0,0 @@
-import { OpenAPIExample } from '../OpenAPIExample';
-import { generateSchemaExample } from '../generateSchemaExample';
-import { tString } from '../translate';
-import { checkIsReference } from '../utils';
-/**
- * Generate an example from a reference object.
- */
-export function getExampleFromReference(ref, context) {
-    return {
-        summary: tString(context.translation, 'unresolved_reference'),
-        value: { $ref: ref.$ref },
-    };
-}
-/**
- * Get examples from a media type object.
- */
-export function getExamplesFromMediaTypeObject(args) {
-    var _a;
-    var _b, _c;
-    var mediaTypeObject = args.mediaTypeObject, mediaType = args.mediaType, context = args.context;
-    if (mediaTypeObject.examples) {
-        return Object.entries(mediaTypeObject.examples).map(function (_a) {
-            var key = _a[0], example = _a[1];
-            return {
-                key: key,
-                example: checkIsReference(example)
-                    ? getExampleFromReference(example, context)
-                    : example,
-            };
-        });
-    }
-    if (mediaTypeObject.example) {
-        return [{ key: 'default', example: { value: mediaTypeObject.example } }];
-    }
-    if (mediaTypeObject.schema) {
-        if (mediaType === 'application/xml') {
-            // @TODO normally we should use the name of the schema but we don't have it
-            // fix it when we got the reference name
-            var root = (_c = (_b = mediaTypeObject.schema.xml) === null || _b === void 0 ? void 0 : _b.name) !== null && _c !== void 0 ? _c : 'object';
-            return [
-                {
-                    key: 'default',
-                    example: {
-                        value: (_a = {},
-                            _a[root] = generateSchemaExample(mediaTypeObject.schema, {
-                                xml: mediaType === 'application/xml',
-                                mode: 'read',
-                            }),
-                            _a),
-                    },
-                },
-            ];
-        }
-        return [
-            {
-                key: 'default',
-                example: {
-                    value: generateSchemaExample(mediaTypeObject.schema, {
-                        mode: 'read',
-                    }),
-                },
-            },
-        ];
-    }
-    return [];
-}
-/**
- * Get example from a schema object.
- */
-export function getExampleFromSchema(args) {
-    var schema = args.schema;
-    if (schema.example) {
-        return { value: schema.example };
-    }
-    return { value: generateSchemaExample(schema, { mode: 'read' }) };
-}
-/**
- * Get the examples from a media type object.
- */
-export function getExamples(props) {
-    var mediaTypeObject = props.mediaTypeObject, mediaType = props.mediaType, context = props.context;
-    var examples = getExamplesFromMediaTypeObject({ mediaTypeObject: mediaTypeObject, mediaType: mediaType, context: context });
-    var syntax = getSyntaxFromMediaType(mediaType);
-    return examples.map(function (example) {
-        return {
-            key: example.key,
-            label: example.example.summary || example.key,
-            body: (<OpenAPIExample example={example.example} context={props.context} syntax={syntax}/>),
-        };
-    });
-}
-/**
- * Get the syntax from a media type.
- */
-function getSyntaxFromMediaType(mediaType) {
-    if (mediaType.includes('json')) {
-        return 'json';
-    }
-    if (mediaType === 'application/xml') {
-        return 'xml';
-    }
-    return 'text';
-}

package/dist/util/server.d.ts

@@ -1,9 +0,0 @@
-import type { OpenAPIV3 } from '@gitbook/openapi-parser';
-/**
- * Get the default URL for the server.
- */
-export declare function getDefaultServerURL(servers: OpenAPIV3.ServerObject[]): string;
-/**
- * Interpolate the server URL with the default values of the variables.
- */
-export declare function interpolateServerURL(server: OpenAPIV3.ServerObject): string;

package/dist/util/tryit-prefill.d.ts

@@ -1,20 +0,0 @@
-import type { ApiClientConfiguration } from '@scalar/types';
-import type { PrefillInputContextData } from '../OpenAPIPrefillContextProvider';
-import type { OpenAPIOperationData } from '../types';
-export interface TryItPrefillConfiguration {
-    authentication?: ApiClientConfiguration['authentication'];
-    servers?: ApiClientConfiguration['servers'];
-}
-/**
- * Resolve the Scalar API client prefill configuration for a given OpenAPI operation.
- */
-export declare function resolveTryItPrefillForOperation(args: {
-    /**
-     * The parsed OpenAPI operation.
-     */
-    operation: Pick<OpenAPIOperationData, 'securities' | 'servers'>;
-    /**
-     * Prefill input context data.
-     */
-    prefillInputContext: PrefillInputContextData | null;
-}): TryItPrefillConfiguration;

package/dist/utils.d.ts

@@ -1,50 +0,0 @@
-import type { AnyObject, OpenAPIV3, OpenAPIV3_1 } from '@gitbook/openapi-parser';
-import type { OpenAPIUniversalContext } from './context';
-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.
- */
-export declare function resolveDescription(object: OpenAPIV3.SchemaObject | AnyObject): string | undefined;
-/**
- * Extract descriptions from an object.
- */
-export declare function extractDescriptions(object: AnyObject): {
-    description: any;
-    'x-gitbook-description-html': any;
-};
-/**
- * Resolve the first example from an object.
- */
-export declare function resolveFirstExample(object: AnyObject): string | undefined;
-/**
- * Resolve the schema of a parameter.
- * Extract the description, example and deprecated from parameter.
- */
-export declare function resolveParameterSchema(parameter: OpenAPIV3.ParameterBaseObject): OpenAPIV3.SchemaObject;
-/**
- * Transform a parameter object to a property object.
- */
-export declare function parameterToProperty(parameter: OpenAPIV3.ParameterObject | OpenAPIV3.ReferenceObject | OpenAPIV3_1.ReferenceObject): {
-    propertyName: string | undefined;
-    schema: OpenAPIV3.SchemaObject;
-    required: boolean | undefined;
-};
-/**
- * Get the class name for a status code.
- * 1xx: informational
- * 2xx: success
- * 3xx: redirect
- * 4xx, 5xx: error
- */
-export declare function getStatusCodeClassName(statusCode: number | string): string;
-/**
- * Get a default label for a status code.
- * This is used when there is no label provided in the OpenAPI spec.
- * 1xx: Information
- * 2xx: Success
- * 3xx: Redirect
- * 4xx, 5xx: Error
- */
-export declare function getStatusCodeDefaultLabel(statusCode: number | string, context: OpenAPIUniversalContext): string;
-export declare function getSchemaTitle(schema: OpenAPIV3.SchemaObject): string;

package/src/InteractiveSection.tsx

@@ -1,147 +0,0 @@
-'use client';
-
-import clsx from 'clsx';
-import { useRef } from 'react';
-import { mergeProps, useButton, useDisclosure, useFocusRing } from 'react-aria';
-import { useDisclosureState } from 'react-stately';
-import { OpenAPISelect, OpenAPISelectItem, useSelectState } from './OpenAPISelect';
-import { Section, SectionBody, SectionHeader, SectionHeaderContent } from './StaticSection';
-
-interface InteractiveSectionTab {
-    key: string;
-    label: string;
-    body: React.ReactNode;
-}
-
-/**
- * To optimize rendering, most of the components are server-components,
- * and the interactiveness is mainly handled by a few key components like this one.
- */
-export function InteractiveSection(props: {
-    id?: string;
-    /** Class name to be set on the section, sub-elements will use it as prefix */
-    className: string;
-    /** If true, the content can be toggeable */
-    toggeable?: boolean;
-    /** Default state of the toggle */
-    defaultOpened?: boolean;
-    /** Icon to display for the toggle */
-    toggleIcon?: React.ReactNode;
-    /** Tabs of content to display */
-    tabs?: Array<InteractiveSectionTab>;
-    /** Default tab to have opened */
-    defaultTab?: string;
-    /** Content of the header */
-    header?: React.ReactNode;
-    /** Children to display within the container */
-    overlay?: React.ReactNode;
-    /** State key to use with a store */
-    stateKey?: string;
-    /** Icon for the tabs select */
-    selectIcon?: React.ReactNode;
-}) {
-    const {
-        id,
-        className,
-        toggeable = false,
-        defaultOpened = true,
-        tabs = [],
-        defaultTab = tabs[0]?.key,
-        header,
-        overlay,
-        toggleIcon = '▶',
-        selectIcon,
-        stateKey = 'interactive-section',
-    } = props;
-    const state = useDisclosureState({
-        defaultExpanded: defaultOpened,
-    });
-    const panelRef = useRef<HTMLDivElement | null>(null);
-    const triggerRef = useRef<HTMLButtonElement | null>(null);
-    const { buttonProps: triggerProps, panelProps } = useDisclosure({}, state, panelRef);
-    const { buttonProps } = useButton(triggerProps, triggerRef);
-    const { isFocusVisible, focusProps } = useFocusRing();
-    const store = useSelectState(stateKey, defaultTab);
-
-    const selectedTab: InteractiveSectionTab | undefined =
-        tabs.find((tab) => tab.key === store.key) ?? tabs[0];
-
-    return (
-        <Section
-            id={id}
-            className={clsx(
-                'openapi-section',
-                toggeable ? 'openapi-section-toggeable' : null,
-                className,
-                toggeable ? `${className}-${state.isExpanded ? 'opened' : 'closed'}` : null
-            )}
-        >
-            {header ? (
-                <SectionHeader
-                    onClick={() => {
-                        if (toggeable) {
-                            state.toggle();
-                        }
-                    }}
-                    className={className}
-                >
-                    <SectionHeaderContent className={className}>
-                        {selectedTab?.body && toggeable ? (
-                            <button
-                                {...mergeProps(buttonProps, focusProps)}
-                                ref={triggerRef}
-                                className={clsx('openapi-section-toggle', `${className}-toggle`)}
-                                style={{
-                                    outline: isFocusVisible
-                                        ? '2px solid rgb(var(--primary-color-500) / 0.4)'
-                                        : 'none',
-                                }}
-                            >
-                                {toggleIcon}
-                            </button>
-                        ) : null}
-                        {header}
-                    </SectionHeaderContent>
-                    {/* biome-ignore lint/a11y/useKeyWithClickEvents: we prevent default here */}
-                    <div
-                        className={clsx(
-                            'openapi-section-header-controls',
-                            `${className}-header-controls`
-                        )}
-                        onClick={(event) => {
-                            event.stopPropagation();
-                        }}
-                    >
-                        {tabs.length > 0 ? (
-                            <OpenAPISelect
-                                stateKey={stateKey}
-                                items={tabs}
-                                onSelectionChange={() => {
-                                    state.expand();
-                                }}
-                                icon={selectIcon}
-                                placement="bottom end"
-                            >
-                                {tabs.map((tab) => (
-                                    <OpenAPISelectItem key={tab.key} id={tab.key} value={tab}>
-                                        {tab.label}
-                                    </OpenAPISelectItem>
-                                ))}
-                            </OpenAPISelect>
-                        ) : null}
-                    </div>
-                </SectionHeader>
-            ) : null}
-            {(!toggeable || state.isExpanded) && selectedTab?.body ? (
-                <SectionBody ref={panelRef} {...panelProps} className={className}>
-                    {selectedTab?.body}
-                </SectionBody>
-            ) : null}
-            {overlay ? (
-                <div className={clsx('openapi-section-overlay', `${className}-overlay`)}>
-                    {overlay}
-                </div>
-            ) : null}
-        </Section>
-    );
-}

package/src/Markdown.tsx

@@ -1,12 +0,0 @@
-import clsx from 'clsx';
-
-export function Markdown(props: { source: string; className?: string }) {
-    const { source, className } = props;
-
-    return (
-        <div
-            className={clsx('openapi-markdown', className)}
-            dangerouslySetInnerHTML={{ __html: source }}
-        />
-    );
-}

package/src/OpenAPICodeSample.tsx

@@ -1,330 +0,0 @@
-import type { OpenAPIV3 } from '@gitbook/openapi-parser';
-import {
-    OpenAPIMediaTypeExamplesBody,
-    OpenAPIMediaTypeExamplesSelector,
-} from './OpenAPICodeSampleInteractive';
-import { OpenAPICodeSampleBody } from './OpenAPICodeSampleSelector';
-import { ScalarApiButton } from './ScalarApiButton';
-import { type CodeSampleGenerator, codeSampleGenerators } from './code-samples';
-import { type OpenAPIContext, getOpenAPIClientContext } from './context';
-import { generateMediaTypeExamples, generateSchemaExample } from './generateSchemaExample';
-import { stringifyOpenAPI } from './stringifyOpenAPI';
-import type { OpenAPIOperationData } from './types';
-import { getDefaultServerURL } from './util/server';
-import { checkIsReference } 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/)
- */
-export function OpenAPICodeSample(props: {
-    data: OpenAPIOperationData;
-    context: OpenAPIContext;
-}) {
-    const { data, context } = 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 (
-        <OpenAPICodeSampleBody
-            context={getOpenAPIClientContext(context)}
-            data={data}
-            items={samples}
-            selectIcon={context.icons.chevronDown}
-        />
-    );
-}
-
-/**
- * Generate code samples for the operation.
- */
-function generateCodeSamples(props: {
-    data: OpenAPIOperationData;
-    context: OpenAPIContext;
-}) {
-    const { data, context } = props;
-
-    const searchParams = new URLSearchParams();
-    const headersObject: { [k: string]: string } = {};
-
-    // The parser can sometimes returns invalid parameters (an object instead of an array).
-    // It should get fixed in scalar, but in the meantime we just ignore the parameters in that case.
-    const params = Array.isArray(data.operation.parameters) ? data.operation.parameters : [];
-
-    params.forEach((param) => {
-        if (!param) {
-            return;
-        }
-
-        if (param.in === 'header' && param.required) {
-            const example = param.schema
-                ? generateSchemaExample(param.schema, { mode: 'write' })
-                : undefined;
-            if (example !== undefined && param.name) {
-                headersObject[param.name] =
-                    typeof example !== 'string' ? stringifyOpenAPI(example) : example;
-            }
-        } else if (param.in === 'query' && param.required) {
-            const example = param.schema
-                ? generateSchemaExample(param.schema, { mode: 'write' })
-                : undefined;
-            if (example !== undefined && param.name) {
-                searchParams.append(
-                    param.name,
-                    String(Array.isArray(example) ? example[0] : example)
-                );
-            }
-        }
-    });
-
-    const requestBody = !checkIsReference(data.operation.requestBody)
-        ? data.operation.requestBody
-        : undefined;
-
-    const url =
-        getDefaultServerURL(data.servers) +
-        data.path +
-        (searchParams.size ? `?${searchParams.toString()}` : '');
-
-    const genericHeaders = {
-        ...getSecurityHeaders(data.securities),
-        ...headersObject,
-    };
-
-    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,
-                    }),
-                    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;
-            };
-        }
-    );
-
-    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}
-                        blockKey={context.blockKey}
-                    />
-                ),
-                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} />,
-        };
-    });
-}
-
-export interface MediaTypeRenderer {
-    mediaType: string;
-    element: React.ReactNode;
-    examples: Array<{
-        example: OpenAPIV3.ExampleObject;
-        element: React.ReactNode;
-    }>;
-}
-
-function OpenAPICodeSampleFooter(props: {
-    data: OpenAPIOperationData;
-    renderers: MediaTypeRenderer[];
-    context: OpenAPIContext;
-}) {
-    const { data, context, renderers } = props;
-    const { method, path, securities, servers } = 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 && !hasMultipleMediaTypes) {
-        return null;
-    }
-
-    if (!validateHttpMethod(method)) {
-        return null;
-    }
-
-    return (
-        <div className="openapi-codesample-footer">
-            {hasMultipleMediaTypes ? (
-                <OpenAPIMediaTypeExamplesSelector
-                    method={data.method}
-                    path={data.path}
-                    renderers={renderers}
-                    selectIcon={context.icons.chevronDown}
-                    blockKey={context.blockKey}
-                />
-            ) : (
-                <span />
-            )}
-            {!hideTryItPanel && (
-                <ScalarApiButton
-                    context={getOpenAPIClientContext(context)}
-                    method={method}
-                    path={path}
-                    securities={securities}
-                    servers={servers}
-                    specUrl={specUrl}
-                />
-            )}
-        </div>
-    );
-}
-
-/**
- * Get custom code samples for the operation.
- */
-function getCustomCodeSamples(props: {
-    data: OpenAPIOperationData;
-    context: OpenAPIContext;
-}) {
-    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.source === 'string' && typeof sample.lang === 'string';
-                })
-                .map((sample, index) => ({
-                    key: `custom-sample-${sample.lang}-${index}`,
-                    label: sample.label || sample.lang,
-                    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;
-} {
-    const security = securities[0];
-
-    if (!security) {
-        return {};
-    }
-
-    switch (security[1].type) {
-        case 'http': {
-            let scheme = security[1].scheme;
-            let format = security[1].bearerFormat ?? 'YOUR_SECRET_TOKEN';
-
-            if (scheme?.includes('bearer')) {
-                scheme = 'Bearer';
-            } else if (scheme?.includes('basic')) {
-                scheme = 'Basic';
-                format = 'username:password';
-            } else if (scheme?.includes('token')) {
-                scheme = 'Token';
-            }
-
-            return {
-                Authorization: `${scheme} ${format}`,
-            };
-        }
-        case 'apiKey': {
-            if (security[1].in !== 'header') return {};
-
-            const name = security[1].name ?? 'Authorization';
-
-            return {
-                [name]: 'YOUR_API_KEY',
-            };
-        }
-        case 'oauth2': {
-            return {
-                Authorization: 'Bearer YOUR_OAUTH2_TOKEN',
-            };
-        }
-        default: {
-            return {};
-        }
-    }
-}
-
-function validateHttpMethod(method: string): method is OpenAPIV3.HttpMethods {
-    return ['get', 'post', 'put', 'delete', 'patch', 'head', 'options', 'trace'].includes(method);
-}