@gitbook/react-openapi 0.7.1 → 1.0.0

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.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 {};

package/dist/resolveOpenAPIPath.test.js

@@ -1,39 +0,0 @@
-import { it, expect } from 'bun:test';
-import { resolveOpenAPIPath } from './resolveOpenAPIPath';
-const createFetcherForSchema = (schema) => {
-    return {
-        fetch: async (url) => {
-            return schema;
-        },
-    };
-};
-it('should resolve a simple path through objects', async () => {
-    const resolved = await resolveOpenAPIPath('https://test.com', ['a', 'b', 'c'], createFetcherForSchema({
-        a: {
-            b: {
-                c: 'hello',
-            },
-        },
-    }));
-    expect(resolved).toBe('hello');
-});
-it('should return undefined if the last part of the path does not exists', async () => {
-    const resolved = await resolveOpenAPIPath('https://test.com', ['a', 'b', 'c'], createFetcherForSchema({
-        a: {
-            b: {
-                d: 'hello',
-            },
-        },
-    }));
-    expect(resolved).toBe(undefined);
-});
-it('should return undefined if a middle part of the path does not exists', async () => {
-    const resolved = await resolveOpenAPIPath('https://test.com', ['a', 'x', 'c'], createFetcherForSchema({
-        a: {
-            b: {
-                c: 'hello',
-            },
-        },
-    }));
-    expect(resolved).toBe(undefined);
-});

package/src/fetchOpenAPIOperation.test.ts

@@ -1,185 +0,0 @@
-import { it, expect } from 'bun:test';
-
-import { fetchOpenAPIOperation, parseOpenAPIV3 } from './fetchOpenAPIOperation';
-import { OpenAPIFetcher } from './types';
-
-const fetcher: OpenAPIFetcher = {
-    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'],
-                        },
-                    },
-                },
-            },
-        },
-    });
-});