@gitbook/react-openapi 0.7.1 → 1.0.1

package/dist/OpenAPISecurities.js

@@ -1,42 +0,0 @@
-import * as React from 'react';
-import { InteractiveSection } from './InteractiveSection';
-import { Markdown } from './Markdown';
-/**
- * Present securities authorization that can be used for this operation.
- */
-export function OpenAPISecurities(props) {
-    const { securities, context } = props;
-    if (securities.length === 0) {
-        return null;
-    }
-    return (React.createElement(InteractiveSection, { header: "Authorization", className: "openapi-securities", toggeable: true, defaultOpened: false, toggleCloseIcon: context.icons.chevronDown, toggleOpenIcon: context.icons.chevronRight, tabs: securities.map(([key, security]) => {
-            return {
-                key: key,
-                label: key,
-                body: (React.createElement(React.Fragment, null,
-                    React.createElement("p", { className: "openapi-securities-label" }, getLabelForType(security)),
-                    security.description ? (React.createElement(Markdown, { source: security.description, className: "openapi-securities-description" })) : null)),
-            };
-        }) }));
-}
-function getLabelForType(security) {
-    switch (security.type) {
-        case 'apiKey':
-            return 'API Key';
-        case 'http':
-            if (security.scheme === 'basic') {
-                return 'Basic Auth';
-            }
-            if (security.scheme == 'bearer') {
-                return `Bearer Token ${security.bearerFormat ? `(${security.bearerFormat})` : ''}`;
-            }
-            return 'HTTP';
-        case 'oauth2':
-            return 'OAuth2';
-        case 'openIdConnect':
-            return 'OpenID Connect';
-        default:
-            // @ts-ignore
-            return security.type;
-    }
-}

package/dist/OpenAPIServerURL.js

@@ -1,51 +0,0 @@
-import * as React from 'react';
-import { OpenAPIServerURLVariable } from './OpenAPIServerURLVariable';
-/**
- * Show the url of the server with variables replaced by their default values.
- */
-export function OpenAPIServerURL(props) {
-    const { servers } = props;
-    const server = servers[0];
-    const parts = parseServerURL(server?.url ?? '');
-    return (React.createElement("span", null, parts.map((part, i) => {
-        if (part.kind === 'text') {
-            return React.createElement("span", { key: i }, part.text);
-        }
-        else {
-            if (!server.variables?.[part.name]) {
-                return React.createElement("span", { key: i }, `{${part.name}}`);
-            }
-            return (React.createElement(OpenAPIServerURLVariable, { key: i, name: part.name, variable: server.variables[part.name] }));
-        }
-    })));
-}
-/**
- * Get the default URL for the server.
- */
-export function getServersURL(servers) {
-    const server = servers[0];
-    const parts = parseServerURL(server?.url ?? '');
-    return parts
-        .map((part) => {
-        if (part.kind === 'text') {
-            return part.text;
-        }
-        else {
-            return server.variables?.[part.name]?.default ?? `{${part.name}}`;
-        }
-    })
-        .join('');
-}
-function parseServerURL(url) {
-    const parts = url.split(/{([^}]+)}/g);
-    const result = [];
-    for (let i = 0; i < parts.length; i++) {
-        if (i % 2 === 0) {
-            result.push({ kind: 'text', text: parts[i] });
-        }
-        else {
-            result.push({ kind: 'variable', name: parts[i] });
-        }
-    }
-    return result;
-}

package/dist/OpenAPIServerURLVariable.js

@@ -1,10 +0,0 @@
-'use client';
-import * as React from 'react';
-import classNames from 'classnames';
-/**
- * Interactive component to show the value of a server variable and let the user change it.
- */
-export function OpenAPIServerURLVariable(props) {
-    const { variable } = props;
-    return React.createElement("span", { className: classNames('openapi-url-var') }, variable.default);
-}

package/dist/OpenAPISpec.js

@@ -1,70 +0,0 @@
-'use client';
-import * as React from 'react';
-import { fromJSON } from './fetchOpenAPIOperation';
-import { InteractiveSection } from './InteractiveSection';
-import { OpenAPIRequestBody } from './OpenAPIRequestBody';
-import { OpenAPIResponses } from './OpenAPIResponses';
-import { OpenAPISchemaProperties } from './OpenAPISchema';
-import { OpenAPISecurities } from './OpenAPISecurities';
-import { noReference } from './utils';
-/**
- * Client component to render the spec for the request and response.
- *
- * We use a client component as rendering recursive JSON schema in the server is expensive
- * (the entire schema is rendered at once, while the client component only renders the visible part)
- */
-export function OpenAPISpec(props) {
-    const { rawData, context } = props;
-    const parsedData = fromJSON(rawData);
-    const { operation, securities } = parsedData;
-    const parameterGroups = groupParameters((operation.parameters || []).map(noReference));
-    return (React.createElement(React.Fragment, null,
-        securities.length > 0 ? (React.createElement(OpenAPISecurities, { securities: securities, context: context })) : null,
-        parameterGroups.map((group) => (React.createElement(InteractiveSection, { key: group.key, className: "openapi-parameters", toggeable: true, toggleOpenIcon: context.icons.chevronRight, toggleCloseIcon: context.icons.chevronDown, header: group.label, defaultOpened: group.key === 'path' || context.defaultInteractiveOpened },
-            React.createElement(OpenAPISchemaProperties, { properties: group.parameters.map((parameter) => ({
-                    propertyName: parameter.name,
-                    schema: {
-                        // Description of the parameter is defined at the parameter level
-                        // we use display it if the schema doesn't override it
-                        description: parameter.description,
-                        example: parameter.example,
-                        ...(noReference(parameter.schema) ?? {}),
-                    },
-                    required: parameter.required,
-                })), context: context })))),
-        operation.requestBody ? (React.createElement(OpenAPIRequestBody, { requestBody: noReference(operation.requestBody), context: context })) : null,
-        operation.responses ? (React.createElement(OpenAPIResponses, { responses: noReference(operation.responses), context: context })) : null));
-}
-function groupParameters(parameters) {
-    const sorted = ['path', 'query', 'header'];
-    const groups = [];
-    parameters.forEach((parameter) => {
-        const key = parameter.in;
-        const label = getParameterGroupName(parameter.in);
-        const group = groups.find((group) => group.key === key);
-        if (group) {
-            group.parameters.push(parameter);
-        }
-        else {
-            groups.push({
-                key,
-                label,
-                parameters: [parameter],
-            });
-        }
-    });
-    groups.sort((a, b) => sorted.indexOf(a.key) - sorted.indexOf(b.key));
-    return groups;
-}
-function getParameterGroupName(paramIn) {
-    switch (paramIn) {
-        case 'path':
-            return 'Path parameters';
-        case 'query':
-            return 'Query parameters';
-        case 'header':
-            return 'Header parameters';
-        default:
-            return paramIn;
-    }
-}

package/dist/ScalarApiButton.js

@@ -1,14 +0,0 @@
-'use client';
-import { useApiClientModal } from '@scalar/api-client-react';
-import React from 'react';
-/**
- * Button which launches the Scalar API Client
- */
-export function ScalarApiButton({ method, path }) {
-    const client = useApiClientModal();
-    return (React.createElement("div", { className: "scalar scalar-activate" },
-        React.createElement("button", { className: "scalar-activate-button", onClick: () => client?.open({ method, path }) },
-            React.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", width: "10", height: "12", fill: "none" },
-                React.createElement("path", { stroke: "currentColor", strokeWidth: "1.5", d: "M1 10.05V1.43c0-.2.2-.31.37-.22l7.26 4.08c.17.1.17.33.01.43l-7.26 4.54a.25.25 0 0 1-.38-.21Z" })),
-            "Test it")));
-}

package/dist/fetchOpenAPIOperation.d.ts

@@ -1,72 +0,0 @@
-import { toJSON, fromJSON } from 'flatted';
-import { OpenAPIV3 } from 'openapi-types';
-import { OpenAPIFetcher } from './types';
-export interface OpenAPIOperationData extends OpenAPICustomSpecProperties {
-    path: string;
-    method: string;
-    /** Servers to be used for this operation */
-    servers: OpenAPIV3.ServerObject[];
-    /** Spec of the operation */
-    operation: OpenAPIV3.OperationObject & OpenAPICustomOperationProperties;
-    /** Securities that should be used for this operation */
-    securities: [string, OpenAPIV3.SecuritySchemeObject][];
-}
-/**
- * Custom properties that can be defined at the entire spec level.
- */
-export interface OpenAPICustomSpecProperties {
-    /**
-     * If `true`, code samples will not be displayed.
-     * This option can be used to hide code samples for the entire spec.
-     */
-    'x-codeSamples'?: boolean;
-    /**
-     * If `true`, the "Try it" button will not be displayed.
-     * This option can be used to hide code samples for the entire spec.
-     */
-    'x-hideTryItPanel'?: boolean;
-}
-/**
- * Custom properties that can be defined at the operation level.
- * These properties are not part of the OpenAPI spec.
- */
-export interface OpenAPICustomOperationProperties {
-    'x-code-samples'?: OpenAPICustomCodeSample[];
-    'x-codeSamples'?: OpenAPICustomCodeSample[] | false;
-    'x-custom-examples'?: OpenAPICustomCodeSample[];
-    /**
-     * If `true`, the "Try it" button will not be displayed.
-     * https://redocly.com/docs/api-reference-docs/specification-extensions/x-hidetryitpanel/
-     */
-    'x-hideTryItPanel'?: boolean;
-}
-/**
- * Custom code samples that can be defined at the operation level.
- * It follows the spec defined by Redocly.
- * https://redocly.com/docs/api-reference-docs/specification-extensions/x-code-samples/
- */
-export interface OpenAPICustomCodeSample {
-    lang: string;
-    label: string;
-    source: string;
-}
-export { toJSON, fromJSON };
-/**
- * Resolve an OpenAPI operation in a file and compile it to a more usable format.
- */
-export declare function fetchOpenAPIOperation(input: {
-    url: string;
-    path: string;
-    method: string;
-}, rawFetcher: OpenAPIFetcher): Promise<OpenAPIOperationData | null>;
-/**
- * Parse a raw string into an OpenAPI document.
- * It will also convert Swagger 2.0 to OpenAPI 3.0.
- * It can throw an `OpenAPIFetchError` if the document is invalid.
- */
-export declare function parseOpenAPIV3(url: string, text: string): Promise<OpenAPIV3.Document>;
-export declare class OpenAPIFetchError extends Error {
-    readonly url: string;
-    name: string;
-    constructor(message: string, url: string);
-}

package/dist/fetchOpenAPIOperation.js

@@ -1,124 +0,0 @@
-import { toJSON, fromJSON } from 'flatted';
-import YAML from 'yaml';
-import swagger2openapi from 'swagger2openapi';
-import { resolveOpenAPIPath } from './resolveOpenAPIPath';
-export { toJSON, fromJSON };
-/**
- * Resolve an OpenAPI operation in a file and compile it to a more usable format.
- */
-export async function fetchOpenAPIOperation(input, rawFetcher) {
-    const fetcher = cacheFetcher(rawFetcher);
-    let operation = await resolveOpenAPIPath(input.url, ['paths', input.path, input.method], fetcher);
-    if (!operation) {
-        return null;
-    }
-    const specData = await fetcher.fetch(input.url);
-    // Resolve common parameters
-    const commonParameters = await resolveOpenAPIPath(input.url, ['paths', input.path, 'parameters'], fetcher);
-    if (commonParameters) {
-        operation = {
-            ...operation,
-            parameters: [...commonParameters, ...(operation.parameters ?? [])],
-        };
-    }
-    // Resolve servers
-    const servers = await resolveOpenAPIPath(input.url, ['servers'], fetcher);
-    // Resolve securities
-    const securities = [];
-    for (const security of operation.security ?? []) {
-        const securityKey = Object.keys(security)[0];
-        const securityScheme = await resolveOpenAPIPath(input.url, ['components', 'securitySchemes', securityKey], fetcher);
-        if (securityScheme) {
-            securities.push([securityKey, securityScheme]);
-        }
-    }
-    return {
-        servers: servers ?? [],
-        operation,
-        method: input.method,
-        path: input.path,
-        securities,
-        'x-codeSamples': typeof specData['x-codeSamples'] === 'boolean' ? specData['x-codeSamples'] : undefined,
-        'x-hideTryItPanel': typeof specData['x-hideTryItPanel'] === 'boolean'
-            ? specData['x-hideTryItPanel']
-            : undefined,
-    };
-}
-function cacheFetcher(fetcher) {
-    const cache = new Map();
-    return {
-        async fetch(url) {
-            if (cache.has(url)) {
-                return cache.get(url);
-            }
-            const promise = fetcher.fetch(url);
-            cache.set(url, promise);
-            return promise;
-        },
-        parseMarkdown: fetcher.parseMarkdown,
-    };
-}
-/**
- * Parse a raw string into an OpenAPI document.
- * It will also convert Swagger 2.0 to OpenAPI 3.0.
- * It can throw an `OpenAPIFetchError` if the document is invalid.
- */
-export async function parseOpenAPIV3(url, text) {
-    // Parse the JSON or YAML
-    let data;
-    // Try with JSON
-    try {
-        data = JSON.parse(text);
-    }
-    catch (jsonError) {
-        try {
-            // Try with YAML
-            data = YAML.parse(text);
-        }
-        catch (yamlError) {
-            if (yamlError instanceof Error && yamlError.name.startsWith('YAML')) {
-                throw new OpenAPIFetchError('Failed to parse YAML: ' + yamlError.message, url);
-            }
-            else {
-                throw yamlError;
-            }
-        }
-    }
-    // Convert Swagger 2.0 to OpenAPI 3.0
-    // @ts-ignore
-    if (data && data.swagger) {
-        try {
-            // Convert Swagger 2.0 to OpenAPI 3.0
-            // @ts-ignore
-            const result = (await swagger2openapi.convertObj(data, {
-                resolve: false,
-                resolveInternal: false,
-                laxDefaults: true,
-                laxurls: true,
-                lint: false,
-                prevalidate: false,
-                anchors: true,
-                patch: true,
-            }));
-            data = result.openapi;
-        }
-        catch (error) {
-            if (error.name === 'S2OError') {
-                throw new OpenAPIFetchError('Failed to convert Swagger 2.0 to OpenAPI 3.0: ' + error.message, url);
-            }
-            else {
-                throw error;
-            }
-        }
-    }
-    // @ts-ignore
-    return data;
-}
-export class OpenAPIFetchError extends Error {
-    url;
-    name = 'OpenAPIFetchError';
-    constructor(message, url) {
-        super(message);
-        this.url = url;
-    }
-}

package/dist/fetchOpenAPIOperation.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/fetchOpenAPIOperation.test.js

@@ -1,152 +0,0 @@
-import { it, expect } from 'bun:test';
-import { fetchOpenAPIOperation, parseOpenAPIV3 } from './fetchOpenAPIOperation';
-const fetcher = {
-    fetch: async (url) => {
-        const response = await fetch(url);
-        return parseOpenAPIV3(url, await response.text());
-    },
-};
-it('should resolve refs', async () => {
-    const resolved = await fetchOpenAPIOperation({
-        url: 'https://petstore3.swagger.io/api/v3/openapi.json',
-        method: 'put',
-        path: '/pet',
-    }, fetcher);
-    expect(resolved).toMatchObject({
-        servers: [
-            {
-                url: '/api/v3',
-            },
-        ],
-        operation: {
-            tags: ['pet'],
-            summary: 'Update an existing pet',
-            description: 'Update an existing pet by Id',
-            requestBody: {
-                content: {
-                    'application/json': {
-                        schema: {
-                            type: 'object',
-                            required: ['name', 'photoUrls'],
-                        },
-                    },
-                },
-            },
-        },
-    });
-});
-it('should support yaml', async () => {
-    const resolved = await fetchOpenAPIOperation({
-        url: 'https://petstore3.swagger.io/api/v3/openapi.yaml',
-        method: 'put',
-        path: '/pet',
-    }, fetcher);
-    expect(resolved).toMatchObject({
-        servers: [
-            {
-                url: '/api/v3',
-            },
-        ],
-        operation: {
-            tags: ['pet'],
-            summary: 'Update an existing pet',
-            description: 'Update an existing pet by Id',
-            requestBody: {
-                content: {
-                    'application/json': {
-                        schema: {
-                            type: 'object',
-                            required: ['name', 'photoUrls'],
-                        },
-                    },
-                },
-            },
-        },
-    });
-});
-it('should resolve circular refs', async () => {
-    const resolved = await fetchOpenAPIOperation({
-        url: 'https://api.gitbook.com/openapi.json',
-        method: 'post',
-        path: '/search/ask',
-    }, fetcher);
-    expect(resolved).toMatchObject({
-        servers: [
-            {
-                url: '{host}/v1',
-            },
-        ],
-        operation: {
-            operationId: 'askQuery',
-        },
-    });
-});
-it('should resolve to null if the method is not supported', async () => {
-    const resolved = await fetchOpenAPIOperation({
-        url: 'https://petstore3.swagger.io/api/v3/openapi.json',
-        method: 'dontexist',
-        path: '/pet',
-    }, fetcher);
-    expect(resolved).toBe(null);
-});
-it('should parse Swagger 2.0', async () => {
-    const resolved = await fetchOpenAPIOperation({
-        url: 'https://petstore.swagger.io/v2/swagger.json',
-        method: 'put',
-        path: '/pet',
-    }, fetcher);
-    expect(resolved).toMatchObject({
-        servers: [
-            {
-                url: 'https://petstore.swagger.io/v2',
-            },
-            {
-                url: 'http://petstore.swagger.io/v2',
-            },
-        ],
-        operation: {
-            tags: ['pet'],
-            summary: 'Update an existing pet',
-            description: '',
-            requestBody: {
-                content: {
-                    'application/json': {
-                        schema: {
-                            type: 'object',
-                            required: ['name', 'photoUrls'],
-                        },
-                    },
-                },
-            },
-        },
-    });
-});
-it('should resolve a ref with whitespace', async () => {
-    const resolved = await fetchOpenAPIOperation({
-        url: ' https://petstore3.swagger.io/api/v3/openapi.json',
-        method: 'put',
-        path: '/pet',
-    }, fetcher);
-    expect(resolved).toMatchObject({
-        servers: [
-            {
-                url: '/api/v3',
-            },
-        ],
-        operation: {
-            tags: ['pet'],
-            summary: 'Update an existing pet',
-            description: 'Update an existing pet by Id',
-            requestBody: {
-                content: {
-                    'application/json': {
-                        schema: {
-                            type: 'object',
-                            required: ['name', 'photoUrls'],
-                        },
-                    },
-                },
-            },
-        },
-    });
-});

package/dist/resolveOpenAPIPath.d.ts

@@ -1,7 +0,0 @@
-import { OpenAPIFetcher } from './types';
-export declare const SYMBOL_REF_RESOLVED = "__$refResolved";
-/**
- * Resolve a path in a OpenAPI file.
- * It resolves any reference needed to resolve the path, ignoring other references outside the path.
- */
-export declare function resolveOpenAPIPath<T>(url: string, dataPath: string[], fetcher: OpenAPIFetcher): Promise<T | undefined>;

package/dist/resolveOpenAPIPath.js

@@ -1,112 +0,0 @@
-const SYMBOL_MARKDOWN_PARSED = '__$markdownParsed';
-export const SYMBOL_REF_RESOLVED = '__$refResolved';
-/**
- * Resolve a path in a OpenAPI file.
- * It resolves any reference needed to resolve the path, ignoring other references outside the path.
- */
-export async function resolveOpenAPIPath(url, dataPath, fetcher) {
-    const data = await fetcher.fetch(url);
-    let value = data;
-    if (!value) {
-        return undefined;
-    }
-    const lastKey = dataPath[dataPath.length - 1];
-    dataPath = dataPath.slice(0, -1);
-    for (const part of dataPath) {
-        // @ts-ignore
-        if (isRef(value[part])) {
-            await transformAll(url, value, part, fetcher);
-        }
-        // @ts-ignore
-        value = value[part];
-        // If any part along the path is undefined, return undefined.
-        if (typeof value !== 'object' || value === null) {
-            return undefined;
-        }
-    }
-    await transformAll(url, value, lastKey, fetcher);
-    // @ts-expect-error
-    return value[lastKey];
-}
-/**
- * Recursively process a part of the OpenAPI spec to resolve all references.
- */
-async function transformAll(url, data, key, fetcher) {
-    const value = data[key];
-    if (typeof value === 'string' &&
-        key === 'description' &&
-        fetcher.parseMarkdown &&
-        !data[SYMBOL_MARKDOWN_PARSED]) {
-        // Parse markdown
-        data[SYMBOL_MARKDOWN_PARSED] = true;
-        data[key] = await fetcher.parseMarkdown(value);
-    }
-    else if (typeof value === 'string' ||
-        typeof value === 'number' ||
-        typeof value === 'boolean' ||
-        value === null) {
-        // Primitives
-    }
-    else if (typeof value === 'object' && value !== null && SYMBOL_REF_RESOLVED in value) {
-        // Ref was already resolved
-    }
-    else if (isRef(value)) {
-        const ref = value.$ref;
-        // Delete the ref to avoid infinite loop with circular references
-        // @ts-ignore
-        delete value.$ref;
-        data[key] = await resolveReference(url, ref, fetcher);
-        if (data[key]) {
-            data[key][SYMBOL_REF_RESOLVED] = extractRefName(ref);
-        }
-    }
-    else if (Array.isArray(value)) {
-        // Recursively resolve all references in the array
-        await Promise.all(value.map((item, index) => transformAll(url, value, index, fetcher)));
-    }
-    else if (typeof value === 'object' && value !== null) {
-        // Recursively resolve all references in the object
-        const keys = Object.keys(value);
-        for (const key of keys) {
-            await transformAll(url, value, key, fetcher);
-        }
-    }
-}
-async function resolveReference(origin, ref, fetcher) {
-    const parsed = parseReference(origin, ref);
-    return resolveOpenAPIPath(parsed.url, parsed.dataPath, fetcher);
-}
-function parseReference(origin, ref) {
-    if (!ref) {
-        return {
-            url: origin,
-            dataPath: [],
-        };
-    }
-    if (ref.startsWith('#')) {
-        // Local references
-        const dataPath = ref.split('/').filter(Boolean).slice(1);
-        return {
-            url: origin,
-            dataPath,
-        };
-    }
-    // Absolute references
-    const url = new URL(ref, origin);
-    if (url.hash) {
-        const hash = url.hash;
-        url.hash = '';
-        return parseReference(url.toString(), hash);
-    }
-    return {
-        url: url.toString(),
-        dataPath: [],
-    };
-}
-function extractRefName(ref) {
-    const parts = ref.split('/');
-    return parts[parts.length - 1];
-}
-function isRef(ref) {
-    return typeof ref === 'object' && ref !== null && '$ref' in ref && ref.$ref;
-}

package/dist/resolveOpenAPIPath.test.d.ts

@@ -1 +0,0 @@
-export {};