@gitbook/react-openapi 0.7.1 → 1.0.0

package/dist/OpenAPIPath.jsx

@@ -0,0 +1,54 @@
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { ScalarApiButton } from './ScalarApiButton';
+/**
+ * Display the path of an operation.
+ */
+export function OpenAPIPath(props) {
+    var data = props.data, context = props.context;
+    var method = data.method, path = data.path;
+    var specUrl = context.specUrl;
+    return (<div className="openapi-path">
+            <div className={"openapi-method openapi-method-".concat(method)}>{method}</div>
+            <div className="openapi-path-title" data-deprecated={data.operation.deprecated}>
+                <p>{formatPath(path)}</p>
+            </div>
+            {data['x-hideTryItPanel'] || data.operation['x-hideTryItPanel'] ? null : (<ScalarApiButton method={method} path={path} specUrl={specUrl}/>)}
+        </div>);
+}
+// Format the path to highlight placeholders
+function formatPath(path) {
+    // Matches placeholders like {id}, {userId}, etc.
+    var regex = /\{(\w+)\}/g;
+    var parts = [];
+    var lastIndex = 0;
+    // Replace placeholders with <em> tags
+    path.replace(regex, function (match, key, offset) {
+        parts.push(path.slice(lastIndex, offset));
+        parts.push(<em key={key}>{"{".concat(key, "}")}</em>);
+        lastIndex = offset + match.length;
+        return match;
+    });
+    // Push remaining text after the last placeholder
+    parts.push(path.slice(lastIndex));
+    // Join parts with separators wrapped in <span>
+    var formattedPath = parts.reduce(function (acc, part, index) {
+        if (typeof part === 'string' && index > 0 && part === '/') {
+            return __spreadArray(__spreadArray([], acc, true), [
+                <span className="openapi-path-separator" key={"sep-".concat(index)}>
+                        /
+                    </span>,
+                part,
+            ], false);
+        }
+        return __spreadArray(__spreadArray([], acc, true), [part], false);
+    }, []);
+    return <span>{formattedPath}</span>;
+}

package/dist/OpenAPIRequestBody.d.ts

@@ -1,10 +1,9 @@
-import * as React from 'react';
-import { OpenAPIV3 } from 'openapi-types';
-import { OpenAPIClientContext } from './types';
+import type { OpenAPIV3 } from '@gitbook/openapi-parser';
+import type { OpenAPIClientContext } from './types';
 /**
  * Display an interactive request body.
  */
 export declare function OpenAPIRequestBody(props: {
     requestBody: OpenAPIV3.RequestBodyObject;
     context: OpenAPIClientContext;
-}): React.JSX.Element;
+}): import("react").JSX.Element;

package/dist/OpenAPIRequestBody.jsx

@@ -0,0 +1,19 @@
+import { OpenAPIRootSchema } from './OpenAPISchema';
+import { noReference } from './utils';
+import { InteractiveSection } from './InteractiveSection';
+/**
+ * Display an interactive request body.
+ */
+export function OpenAPIRequestBody(props) {
+    var _a;
+    var requestBody = props.requestBody, context = props.context;
+    return (<InteractiveSection header="Body" className="openapi-requestbody" tabs={Object.entries((_a = requestBody.content) !== null && _a !== void 0 ? _a : {}).map(function (_a) {
+            var _b;
+            var contentType = _a[0], mediaTypeObject = _a[1];
+            return {
+                key: contentType,
+                label: contentType,
+                body: (<OpenAPIRootSchema schema={(_b = noReference(mediaTypeObject.schema)) !== null && _b !== void 0 ? _b : {}} context={context}/>),
+            };
+        })}/>);
+}

package/dist/OpenAPIResponse.d.ts

@@ -1,10 +1,10 @@
-import * as React from 'react';
-import { OpenAPIV3 } from 'openapi-types';
-import { OpenAPIClientContext } from './types';
+import type { OpenAPIV3 } from '@gitbook/openapi-parser';
+import type { OpenAPIClientContext } from './types';
 /**
  * Display an interactive response body.
  */
 export declare function OpenAPIResponse(props: {
     response: OpenAPIV3.ResponseObject;
+    mediaType: OpenAPIV3.MediaTypeObject;
     context: OpenAPIClientContext;
-}): React.JSX.Element | null;
+}): import("react").JSX.Element | null;

package/dist/OpenAPIResponse.jsx

@@ -0,0 +1,49 @@
+import { OpenAPISchemaProperties } from './OpenAPISchema';
+import { checkIsReference, noReference, resolveDescription } from './utils';
+import { OpenAPIDisclosure } from './OpenAPIDisclosure';
+/**
+ * Display an interactive response body.
+ */
+export function OpenAPIResponse(props) {
+    var _a, _b, _c;
+    var response = props.response, context = props.context, mediaType = props.mediaType;
+    var headers = Object.entries((_a = response.headers) !== null && _a !== void 0 ? _a : {}).map(function (_a) {
+        var _b;
+        var name = _a[0], header = _a[1];
+        return [name, (_b = noReference(header)) !== null && _b !== void 0 ? _b : {}];
+    });
+    var content = Object.entries((_b = mediaType.schema) !== null && _b !== void 0 ? _b : {});
+    var description = resolveDescription(response);
+    if (content.length === 0 && !description && headers.length === 0) {
+        return null;
+    }
+    return (<div className="openapi-response-body">
+            {headers.length > 0 ? (<OpenAPIDisclosure context={context} label={'Headers'}>
+                    <OpenAPISchemaProperties properties={headers.map(function (_a) {
+                var _b;
+                var name = _a[0], header = _a[1];
+                return ({
+                    propertyName: name,
+                    schema: (_b = noReference(header.schema)) !== null && _b !== void 0 ? _b : {},
+                    required: header.required,
+                });
+            })} context={context}/>
+                </OpenAPIDisclosure>) : null}
+            <div className="openapi-responsebody">
+                <OpenAPISchemaProperties id={"response-".concat(context.blockKey)} properties={[
+            {
+                schema: (_c = handleUnresolvedReference(mediaType.schema)) !== null && _c !== void 0 ? _c : {},
+            },
+        ]} context={context}/>
+            </div>
+        </div>);
+}
+function handleUnresolvedReference(input) {
+    var isReference = checkIsReference(input);
+    if (isReference || input === undefined) {
+        // If we find a reference that wasn't resolved or needed to be resolved externally, do not try to render it.
+        // Instead we render `any`
+        return {};
+    }
+    return input;
+}

package/dist/OpenAPIResponseExample.d.ts

@@ -1,10 +1,8 @@
-import * as React from 'react';
-import { OpenAPIOperationData } from './fetchOpenAPIOperation';
-import { OpenAPIContextProps } from './types';
+import type { OpenAPIContextProps, OpenAPIOperationData } from './types';
 /**
  * Display an example of the response content.
  */
 export declare function OpenAPIResponseExample(props: {
     data: OpenAPIOperationData;
     context: OpenAPIContextProps;
-}): React.JSX.Element | null;
+}): import("react").JSX.Element | null;

package/dist/OpenAPIResponseExample.jsx

@@ -0,0 +1,108 @@
+import { generateSchemaExample } from './generateSchemaExample';
+import { checkIsReference, noReference, resolveDescription } from './utils';
+import { stringifyOpenAPI } from './stringifyOpenAPI';
+import { OpenAPITabs, OpenAPITabsList, OpenAPITabsPanels } from './OpenAPITabs';
+import { InteractiveSection } from './InteractiveSection';
+/**
+ * Display an example of the response content.
+ */
+export function OpenAPIResponseExample(props) {
+    var data = props.data, context = props.context;
+    // if there are no responses defined for the operation
+    if (!data.operation.responses) {
+        return null;
+    }
+    var responses = Object.entries(data.operation.responses);
+    // Sort response to get 200, and 2xx first
+    responses.sort(function (_a, _b) {
+        var a = _a[0];
+        var b = _b[0];
+        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);
+    });
+    var examples = responses
+        .map(function (_a) {
+        var key = _a[0], value = _a[1];
+        var responseObject = noReference(value);
+        var mediaTypeObject = (function () {
+            var _a;
+            if (!responseObject.content) {
+                return null;
+            }
+            var key = Object.keys(responseObject.content)[0];
+            return ((_a = responseObject.content['application/json']) !== null && _a !== void 0 ? _a : (key ? responseObject.content[key] : null));
+        })();
+        if (!mediaTypeObject) {
+            return {
+                key: key,
+                label: key,
+                description: resolveDescription(responseObject),
+                body: <OpenAPIEmptyResponseExample />,
+            };
+        }
+        var example = handleUnresolvedReference((function () {
+            var examples = mediaTypeObject.examples, example = mediaTypeObject.example;
+            if (examples) {
+                var key_1 = Object.keys(examples)[0];
+                if (key_1) {
+                    // @TODO handle multiple examples
+                    var firstExample = noReference(examples[key_1]);
+                    if (firstExample) {
+                        return firstExample;
+                    }
+                }
+            }
+            if (example) {
+                return { value: example };
+            }
+            var schema = noReference(mediaTypeObject.schema);
+            if (!schema) {
+                return null;
+            }
+            return { value: generateSchemaExample(schema) };
+        })());
+        return {
+            key: key,
+            label: key,
+            description: resolveDescription(responseObject),
+            body: (example === null || example === void 0 ? void 0 : example.value) ? (<context.CodeBlock code={typeof example.value === 'string'
+                    ? example.value
+                    : stringifyOpenAPI(example.value, null, 2)} syntax="json"/>) : (<OpenAPIEmptyResponseExample />),
+        };
+    })
+        .filter(function (val) {
+        return Boolean(val);
+    });
+    if (examples.length === 0) {
+        return null;
+    }
+    return (<OpenAPITabs items={examples}>
+            <InteractiveSection header={<OpenAPITabsList />} className="openapi-response-example">
+                <OpenAPITabsPanels />
+            </InteractiveSection>
+        </OpenAPITabs>);
+}
+function OpenAPIEmptyResponseExample() {
+    return (<pre className="openapi-response-example-empty">
+            <p>No body</p>
+        </pre>);
+}
+function handleUnresolvedReference(input) {
+    var isReference = checkIsReference(input === null || input === void 0 ? void 0 : input.value);
+    if (isReference) {
+        // If we find a reference that wasn't resolved or needed to be resolved externally, render out the URL
+        return { value: input.value.$ref };
+    }
+    return input;
+}

package/dist/OpenAPIResponses.d.ts

@@ -1,10 +1,9 @@
-import * as React from 'react';
-import { OpenAPIV3 } from 'openapi-types';
+import type { OpenAPIV3, OpenAPIV3_1 } from '@gitbook/openapi-parser';
 import { OpenAPIClientContext } from './types';
 /**
  * Display an interactive response body.
  */
 export declare function OpenAPIResponses(props: {
-    responses: OpenAPIV3.ResponsesObject;
+    responses: OpenAPIV3.ResponsesObject | OpenAPIV3_1.ResponsesObject;
     context: OpenAPIClientContext;
-}): React.JSX.Element;
+}): import("react").JSX.Element;

package/dist/OpenAPIResponses.jsx

@@ -0,0 +1,36 @@
+import { createStateKey, resolveDescription } from './utils';
+import { OpenAPIResponse } from './OpenAPIResponse';
+import { InteractiveSection } from './InteractiveSection';
+import { OpenAPIDisclosureGroup } from './OpenAPIDisclosureGroup';
+import { Markdown } from './Markdown';
+/**
+ * Display an interactive response body.
+ */
+export function OpenAPIResponses(props) {
+    var responses = props.responses, context = props.context;
+    return (<InteractiveSection stateKey={createStateKey('response', context.blockKey)} header="Responses" className="openapi-responses">
+            <OpenAPIDisclosureGroup allowsMultipleExpanded icon={context.icons.chevronRight} groups={Object.entries(responses).map(function (_a) {
+            var _b;
+            var statusCode = _a[0], response = _a[1];
+            var content = Object.entries((_b = response.content) !== null && _b !== void 0 ? _b : {});
+            var description = resolveDescription(response);
+            return {
+                id: statusCode,
+                label: (<div className="openapi-response-tab-content" key={"response-".concat(statusCode)}>
+                                    <span className="openapi-response-statuscode">
+                                        {statusCode}
+                                    </span>
+                                    {description ? (<Markdown source={description} className="openapi-response-description"/>) : null}
+                                </div>),
+                tabs: content.map(function (_a) {
+                    var contentType = _a[0], mediaType = _a[1];
+                    return ({
+                        id: contentType,
+                        label: contentType,
+                        body: (<OpenAPIResponse key={"$response-".concat(statusCode, "-").concat(contentType)} response={response} mediaType={mediaType} context={context}/>),
+                    });
+                }),
+            };
+        })}/>
+        </InteractiveSection>);
+}

package/dist/OpenAPISchema.d.ts

@@ -1,8 +1,7 @@
-import { OpenAPIV3 } from 'openapi-types';
-import React from 'react';
-import { OpenAPIClientContext } from './types';
+import type { OpenAPIV3 } from '@gitbook/openapi-parser';
+import type { OpenAPIClientContext } from './types';
 type CircularRefsIds = Map<OpenAPIV3.SchemaObject, string>;
-interface OpenAPISchemaPropertyEntry {
+export interface OpenAPISchemaPropertyEntry {
     propertyName?: string;
     required?: boolean;
     schema: OpenAPIV3.SchemaObject;
@@ -15,7 +14,7 @@ export declare function OpenAPISchemaProperty(props: OpenAPISchemaPropertyEntry
     circularRefs?: CircularRefsIds;
     context: OpenAPIClientContext;
     className?: string;
-}): React.JSX.Element;
+}): import("react").JSX.Element;
 /**
  * Render a set of properties of an OpenAPI schema.
  */
@@ -24,22 +23,26 @@ export declare function OpenAPISchemaProperties(props: {
     properties: OpenAPISchemaPropertyEntry[];
     circularRefs?: CircularRefsIds;
     context: OpenAPIClientContext;
-}): React.JSX.Element | null;
+}): import("react").JSX.Element | null;
 /**
  * Render a root schema (such as the request body or response body).
  */
 export declare function OpenAPIRootSchema(props: {
     schema: OpenAPIV3.SchemaObject;
     context: OpenAPIClientContext;
-}): React.JSX.Element;
+}): import("react").JSX.Element;
 /**
  * Render the enum value for a schema.
  */
 export declare function OpenAPISchemaEnum(props: {
     enumValues: any[];
-}): React.JSX.Element;
+}): import("react").JSX.Element;
+export declare function OpenAPISchemaPresentation(props: OpenAPISchemaPropertyEntry): import("react").JSX.Element;
 /**
  * Get the alternatives to display for a schema.
  */
 export declare function getSchemaAlternatives(schema: OpenAPIV3.SchemaObject, ancestors?: Set<OpenAPIV3.SchemaObject>): null | [OpenAPIV3.SchemaObject[], OpenAPIV3.DiscriminatorObject | undefined];
+export declare function getSchemaTitle(schema: OpenAPIV3.SchemaObject, 
+/** If the title is inferred in a oneOf with discriminator, we can use it to optimize the title */
+discriminator?: OpenAPIV3.DiscriminatorObject): string;
 export {};