@gitbook/react-openapi 0.7.1 → 1.0.1

package/dist/OpenAPISecurities.jsx

@@ -0,0 +1,55 @@
+import { InteractiveSection } from './InteractiveSection';
+import { Markdown } from './Markdown';
+import { OpenAPISchemaName } from './OpenAPISchemaName';
+import { resolveDescription } from './utils';
+/**
+ * Present securities authorization that can be used for this operation.
+ */
+export function OpenAPISecurities(props) {
+    var securities = props.securities, context = props.context;
+    if (securities.length === 0) {
+        return null;
+    }
+    return (<InteractiveSection header="Authorizations" toggeable defaultOpened={false} toggleIcon={context.icons.chevronRight} className="openapi-securities" tabs={securities.map(function (_a) {
+            var key = _a[0], security = _a[1];
+            var description = resolveDescription(security);
+            return {
+                key: key,
+                label: key,
+                body: (<div className="openapi-schema-body">
+                            <div className="openapi-schema-presentation">
+                                {getLabelForType(security)}
+
+                                {description ? (<Markdown source={description} className="openapi-securities-description"/>) : null}
+                            </div>
+                        </div>),
+            };
+        })}/>);
+}
+function getLabelForType(security) {
+    var _a;
+    switch (security.type) {
+        case 'apiKey':
+            return (<OpenAPISchemaName propertyName={(_a = security.name) !== null && _a !== void 0 ? _a : 'apiKey'} type="string" required/>);
+        case 'http':
+            if (security.scheme === 'basic') {
+                return <OpenAPISchemaName propertyName="Authorization" type="string" required/>;
+            }
+            if (security.scheme == 'bearer') {
+                var description = resolveDescription(security);
+                return (<>
+                        <OpenAPISchemaName propertyName="Authorization" type="string" required/>
+                        {/** Show a default description if none is provided */}
+                        {!description ? (<Markdown source={"Bearer authentication header of the form Bearer ".concat("&lt;token&gt;", ".")} className="openapi-securities-description"/>) : null}
+                    </>);
+            }
+            return <OpenAPISchemaName propertyName="HTTP" required/>;
+        case 'oauth2':
+            return <OpenAPISchemaName propertyName="OAuth2" required/>;
+        case 'openIdConnect':
+            return <OpenAPISchemaName propertyName="OpenID Connect" required/>;
+        default:
+            // @ts-ignore
+            return security.type;
+    }
+}

package/dist/OpenAPIServerURL.d.ts

@@ -1,11 +1,10 @@
-import * as React from 'react';
-import { OpenAPIV3 } from 'openapi-types';
+import type { OpenAPIV3 } from '@gitbook/openapi-parser';
 /**
  * Show the url of the server with variables replaced by their default values.
  */
 export declare function OpenAPIServerURL(props: {
     servers: OpenAPIV3.ServerObject[];
-}): React.JSX.Element;
+}): import("react").JSX.Element | null;
 /**
  * Get the default URL for the server.
  */

package/dist/OpenAPIServerURL.jsx

@@ -0,0 +1,67 @@
+import { OpenAPIServerURLVariable } from './OpenAPIServerURLVariable';
+/**
+ * Show the url of the server with variables replaced by their default values.
+ */
+export function OpenAPIServerURL(props) {
+    var _a;
+    var servers = props.servers;
+    var server = servers[0];
+    if (!server) {
+        return null;
+    }
+    var parts = parseServerURL((_a = server === null || server === void 0 ? void 0 : server.url) !== null && _a !== void 0 ? _a : '');
+    return (<span>
+            {parts.map(function (part, i) {
+            var _a;
+            if (part.kind === 'text') {
+                return <span key={i}>{part.text}</span>;
+            }
+            else {
+                var variable = (_a = server.variables) === null || _a === void 0 ? void 0 : _a[part.name];
+                if (!variable) {
+                    return <span key={i}>{"{".concat(part.name, "}")}</span>;
+                }
+                return (<OpenAPIServerURLVariable key={i} name={part.name} variable={variable}/>);
+            }
+        })}
+        </span>);
+}
+/**
+ * Get the default URL for the server.
+ */
+export function getServersURL(servers) {
+    var _a;
+    var server = servers[0];
+    if (!server) {
+        return '';
+    }
+    var parts = parseServerURL((_a = server === null || server === void 0 ? void 0 : server.url) !== null && _a !== void 0 ? _a : '');
+    return parts
+        .map(function (part) {
+        var _a, _b, _c;
+        if (part.kind === 'text') {
+            return part.text;
+        }
+        else {
+            return (_c = (_b = (_a = server.variables) === null || _a === void 0 ? void 0 : _a[part.name]) === null || _b === void 0 ? void 0 : _b.default) !== null && _c !== void 0 ? _c : "{".concat(part.name, "}");
+        }
+    })
+        .join('');
+}
+function parseServerURL(url) {
+    var parts = url.split(/{([^}]+)}/g);
+    var result = [];
+    for (var i = 0; i < parts.length; i++) {
+        var part = parts[i];
+        if (!part) {
+            continue;
+        }
+        if (i % 2 === 0) {
+            result.push({ kind: 'text', text: part });
+        }
+        else {
+            result.push({ kind: 'variable', name: part });
+        }
+    }
+    return result;
+}

package/dist/OpenAPIServerURLVariable.d.ts

@@ -1,9 +1,8 @@
-import * as React from 'react';
-import { OpenAPIV3 } from 'openapi-types';
+import type { OpenAPIV3 } from '@gitbook/openapi-parser';
 /**
  * Interactive component to show the value of a server variable and let the user change it.
  */
 export declare function OpenAPIServerURLVariable(props: {
     name: string;
     variable: OpenAPIV3.ServerVariableObject;
-}): React.JSX.Element;
+}): import("react").JSX.Element;

package/dist/OpenAPIServerURLVariable.jsx

@@ -0,0 +1,8 @@
+'use client';
+/**
+ * Interactive component to show the value of a server variable and let the user change it.
+ */
+export function OpenAPIServerURLVariable(props) {
+    var variable = props.variable;
+    return <span className="openapi-url-var">{variable.default}</span>;
+}

package/dist/OpenAPISpec.d.ts

@@ -1,5 +1,4 @@
-import * as React from 'react';
-import { OpenAPIClientContext } from './types';
+import type { OpenAPIClientContext, OpenAPIOperationData } from './types';
 /**
  * Client component to render the spec for the request and response.
  *
@@ -7,6 +6,6 @@ import { OpenAPIClientContext } from './types';
  * (the entire schema is rendered at once, while the client component only renders the visible part)
  */
 export declare function OpenAPISpec(props: {
-    rawData: any;
+    data: OpenAPIOperationData;
     context: OpenAPIClientContext;
-}): React.JSX.Element;
+}): import("react").JSX.Element;

package/dist/OpenAPISpec.jsx

@@ -0,0 +1,91 @@
+'use client';
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { InteractiveSection } from './InteractiveSection';
+import { OpenAPIRequestBody } from './OpenAPIRequestBody';
+import { OpenAPIResponses } from './OpenAPIResponses';
+import { OpenAPISchemaProperties } from './OpenAPISchema';
+import { OpenAPISecurities } from './OpenAPISecurities';
+import { resolveDescription } 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) {
+    var _a;
+    var data = props.data, context = props.context;
+    var operation = data.operation, securities = data.securities;
+    var parameters = (_a = operation.parameters) !== null && _a !== void 0 ? _a : [];
+    var parameterGroups = groupParameters(parameters);
+    return (<>
+            {securities.length > 0 ? (<OpenAPISecurities securities={securities} context={context}/>) : null}
+
+            {parameterGroups.map(function (group) {
+            return (<InteractiveSection key={group.key} className="openapi-parameters" header={group.label}>
+                        <OpenAPISchemaProperties properties={group.parameters.map(function (parameter) {
+                    var _a;
+                    var description = resolveDescription(parameter);
+                    return {
+                        propertyName: parameter.name,
+                        schema: __assign({ 
+                            // Description of the parameter is defined at the parameter level
+                            // we use display it if the schema doesn't override it
+                            description: description, example: parameter.example, 
+                            // Deprecated can be defined at the parameter level
+                            deprecated: parameter.deprecated }, ((_a = parameter.schema) !== null && _a !== void 0 ? _a : {})),
+                        required: parameter.required,
+                    };
+                })} context={context}/>
+                    </InteractiveSection>);
+        })}
+
+            {operation.requestBody ? (<OpenAPIRequestBody requestBody={operation.requestBody} context={context}/>) : null}
+            {operation.responses ? (<OpenAPIResponses responses={operation.responses} context={context}/>) : null}
+        </>);
+}
+function groupParameters(parameters) {
+    var sorted = ['path', 'query', 'header'];
+    var groups = [];
+    parameters
+        .filter(function (parameter) { return parameter.in; })
+        .forEach(function (parameter) {
+        var key = parameter.in;
+        var label = getParameterGroupName(parameter.in);
+        var group = groups.find(function (group) { return group.key === key; });
+        if (group) {
+            group.parameters.push(parameter);
+        }
+        else {
+            groups.push({
+                key: key,
+                label: label,
+                parameters: [parameter],
+            });
+        }
+    });
+    groups.sort(function (a, b) { return 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/OpenAPITabs.d.ts

@@ -0,0 +1,26 @@
+import { Key, TabsProps } from 'react-aria-components';
+export type Tab = {
+    key: Key;
+    label: string;
+    body: React.ReactNode;
+    description?: string;
+};
+/**
+ * The OpenAPI Tabs wrapper component.
+ */
+export declare function OpenAPITabs(props: React.PropsWithChildren<TabsProps & {
+    items: Tab[];
+    stateKey?: string;
+}>): import("react").JSX.Element;
+/**
+ * The OpenAPI Tabs list component.
+ * This component should be used as a child of the OpenAPITabs component.
+ * It renders the list of tabs.
+ */
+export declare function OpenAPITabsList(): import("react").JSX.Element;
+/**
+ * The OpenAPI Tabs panels component.
+ * This component should be used as a child of the OpenAPITabs component.
+ * It renders the content of the selected tab.
+ */
+export declare function OpenAPITabsPanels(): import("react").JSX.Element | null;

package/dist/OpenAPITabs.jsx

@@ -0,0 +1,103 @@
+'use client';
+import { createContext, useContext, useEffect, useMemo, useState } from 'react';
+import { Tab, TabList, TabPanel, Tabs } from 'react-aria-components';
+import { Markdown } from './Markdown';
+import { useSyncedTabsGlobalState } from './useSyncedTabsGlobalState';
+import { useIntersectionObserver } from 'usehooks-ts';
+var OpenAPITabsContext = createContext(null);
+function useOpenAPITabsContext() {
+    var context = useContext(OpenAPITabsContext);
+    if (!context) {
+        throw new Error('OpenAPITabsContext is missing');
+    }
+    return context;
+}
+/**
+ * The OpenAPI Tabs wrapper component.
+ */
+export function OpenAPITabs(props) {
+    var children = props.children, items = props.items, stateKey = props.stateKey;
+    var isVisible = stateKey
+        ? useIntersectionObserver({
+            threshold: 0.1,
+            rootMargin: '200px',
+        })
+        : true;
+    var defaultTab = items[0];
+    var _a = useSyncedTabsGlobalState(), syncedTabs = _a[0], setSyncedTabs = _a[1];
+    var _b = useState(function () {
+        var _a, _b, _c;
+        if (isVisible && stateKey && syncedTabs && syncedTabs.has(stateKey)) {
+            var tabFromState = syncedTabs.get(stateKey);
+            return (_a = tabFromState === null || tabFromState === void 0 ? void 0 : tabFromState.key) !== null && _a !== void 0 ? _a : (_b = items[0]) === null || _b === void 0 ? void 0 : _b.key;
+        }
+        return (_c = items[0]) === null || _c === void 0 ? void 0 : _c.key;
+    }), selectedTabKey = _b[0], setSelectedTabKey = _b[1];
+    var _c = useState(defaultTab), selectedTab = _c[0], setSelectedTab = _c[1];
+    var handleSelectionChange = function (key) {
+        setSelectedTabKey(key);
+        if (stateKey) {
+            var tab_1 = items.find(function (item) { return item.key === key; });
+            if (!tab_1) {
+                return;
+            }
+            setSyncedTabs(function (state) {
+                var newState = new Map(state);
+                newState.set(stateKey, tab_1);
+                return newState;
+            });
+        }
+    };
+    useEffect(function () {
+        if (isVisible && stateKey && syncedTabs && syncedTabs.has(stateKey)) {
+            var tabFromState_1 = syncedTabs.get(stateKey);
+            if (!items.some(function (item) { return item.key === (tabFromState_1 === null || tabFromState_1 === void 0 ? void 0 : tabFromState_1.key); })) {
+                return;
+            }
+            if (tabFromState_1 && (tabFromState_1 === null || tabFromState_1 === void 0 ? void 0 : tabFromState_1.key) !== (selectedTab === null || selectedTab === void 0 ? void 0 : selectedTab.key)) {
+                setSelectedTab(tabFromState_1);
+            }
+        }
+    }, [isVisible, stateKey, syncedTabs, selectedTabKey]);
+    var contextValue = useMemo(function () { return ({ items: items, selectedTab: selectedTab }); }, [items, selectedTab]);
+    return (<OpenAPITabsContext.Provider value={contextValue}>
+            <Tabs className="openapi-tabs" onSelectionChange={handleSelectionChange} selectedKey={selectedTab === null || selectedTab === void 0 ? void 0 : selectedTab.key}>
+                {children}
+            </Tabs>
+        </OpenAPITabsContext.Provider>);
+}
+/**
+ * The OpenAPI Tabs list component.
+ * This component should be used as a child of the OpenAPITabs component.
+ * It renders the list of tabs.
+ */
+export function OpenAPITabsList() {
+    var items = useOpenAPITabsContext().items;
+    return (<TabList className="openapi-tabs-list">
+            {items.map(function (tab) { return (<Tab style={function (_a) {
+                var isFocusVisible = _a.isFocusVisible;
+                return ({
+                    outline: isFocusVisible
+                        ? '2px solid rgb(var(--primary-color-500)/0.4)'
+                        : 'none',
+                });
+            }} className="openapi-tabs-tab" key={"Tab-".concat(tab.key)} id={tab.key}>
+                    {tab.label}
+                </Tab>); })}
+        </TabList>);
+}
+/**
+ * The OpenAPI Tabs panels component.
+ * This component should be used as a child of the OpenAPITabs component.
+ * It renders the content of the selected tab.
+ */
+export function OpenAPITabsPanels() {
+    var selectedTab = useOpenAPITabsContext().selectedTab;
+    if (!selectedTab) {
+        return null;
+    }
+    return (<TabPanel key={"TabPanel-".concat(selectedTab.key)} id={selectedTab.key.toString()} className="openapi-tabs-panel">
+            {selectedTab.body}
+            {selectedTab.description ? (<Markdown source={selectedTab.description} className="openapi-tabs-footer"/>) : null}
+        </TabPanel>);
+}

package/dist/ScalarApiButton.d.ts

@@ -1,8 +1,8 @@
-import React from 'react';
 /**
  * Button which launches the Scalar API Client
  */
-export declare function ScalarApiButton({ method, path }: {
+export declare function ScalarApiButton({ method, path, specUrl, }: {
     method: string;
     path: string;
-}): React.JSX.Element;
+    specUrl: string;
+}): import("react").JSX.Element;

package/dist/ScalarApiButton.jsx

@@ -0,0 +1,51 @@
+'use client';
+import { ApiClientModalProvider, useApiClientModal } from '@scalar/api-client-react';
+import { useEffect, useImperativeHandle, useRef, useState } from 'react';
+import { createPortal } from 'react-dom';
+import { useOpenAPIOperationContext } from './OpenAPIOperationContext';
+import { useEventCallback } from 'usehooks-ts';
+/**
+ * Button which launches the Scalar API Client
+ */
+export function ScalarApiButton(_a) {
+    var method = _a.method, path = _a.path, specUrl = _a.specUrl;
+    var _b = useState(false), isOpen = _b[0], setIsOpen = _b[1];
+    var controllerRef = useRef(null);
+    return (<div className="scalar scalar-activate">
+            <button className="scalar-activate-button button" onClick={function () {
+            var _a, _b;
+            (_b = (_a = controllerRef.current) === null || _a === void 0 ? void 0 : _a.openClient) === null || _b === void 0 ? void 0 : _b.call(_a);
+            setIsOpen(true);
+        }}>
+                <svg xmlns="http://www.w3.org/2000/svg" width="10" height="12" fill="none">
+                    <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"/>
+                </svg>
+                Test it
+            </button>
+
+            {isOpen &&
+            createPortal(<ScalarModal controllerRef={controllerRef} method={method} path={path} specUrl={specUrl}/>, document.body)}
+        </div>);
+}
+function ScalarModal(props) {
+    return (<ApiClientModalProvider configuration={{ spec: { url: props.specUrl } }} initialRequest={{ path: props.path, method: props.method }}>
+            <ScalarModalController method={props.method} path={props.path} controllerRef={props.controllerRef}/>
+        </ApiClientModalProvider>);
+}
+function ScalarModalController(props) {
+    var client = useApiClientModal();
+    var openClient = client === null || client === void 0 ? void 0 : client.open;
+    useImperativeHandle(props.controllerRef, function () { return ({ openClient: openClient ? function () { return openClient(); } : undefined }); }, [openClient]);
+    // Open the client when the component is mounted.
+    var onOpenClient = useOpenAPIOperationContext().onOpenClient;
+    var trackOpening = useEventCallback(function () {
+        onOpenClient({ method: props.method, path: props.path });
+    });
+    useEffect(function () {
+        if (openClient) {
+            openClient();
+            trackOpening();
+        }
+    }, [openClient]);
+    return null;
+}

package/dist/code-samples.d.ts

@@ -11,4 +11,8 @@ interface CodeSampleGenerator {
     generate: (operation: CodeSampleInput) => string;
 }
 export declare const codeSampleGenerators: CodeSampleGenerator[];
+export declare function parseHostAndPath(url: string): {
+    host: string | undefined;
+    path: string;
+};
 export {};

package/dist/code-samples.js

@@ -1,69 +1,134 @@
-export const codeSampleGenerators = [
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { stringifyOpenAPI } from './stringifyOpenAPI';
+export var codeSampleGenerators = [
     {
-        id: 'javascript',
-        label: 'JavaScript',
-        syntax: 'javascript',
-        generate: ({ method, url, headers, body }) => {
-            let code = '';
-            code += `const response = await fetch('${url}', {
-    method: '${method.toUpperCase()}',\n`;
+        id: 'curl',
+        label: 'cURL',
+        syntax: 'bash',
+        generate: function (_a) {
+            var method = _a.method, url = _a.url, headers = _a.headers, body = _a.body;
+            var separator = ' \\\n';
+            var lines = ['curl -L'];
+            if (method.toUpperCase() !== 'GET') {
+                lines.push("--request ".concat(method.toUpperCase()));
+            }
+            lines.push("--url '".concat(url, "'"));
             if (headers) {
-                code += indent(`headers: ${JSON.stringify(headers, null, 2)},\n`, 4);
+                Object.entries(headers).forEach(function (_a) {
+                    var key = _a[0], value = _a[1];
+                    lines.push("--header '".concat(key, ": ").concat(value, "'"));
+                });
             }
-            if (body) {
-                code += indent(`body: JSON.stringify(${JSON.stringify(body, null, 2)}),\n`, 4);
+            if (body && Object.keys(body).length > 0) {
+                lines.push("--data '".concat(stringifyOpenAPI(body), "'"));
             }
-            code += `});\n`;
-            code += `const data = await response.json();`;
-            return code;
+            return lines.map(function (line, index) { return (index > 0 ? indent(line, 2) : line); }).join(separator);
         },
     },
     {
-        id: 'curl',
-        label: 'Curl',
-        syntax: 'bash',
-        generate: ({ method, url, headers, body }) => {
-            const separator = ' \\\n';
-            const lines = ['curl -L'];
-            if (method.toUpperCase() !== 'GET') {
-                lines.push(`-X ${method.toUpperCase()}`);
-            }
+        id: 'javascript',
+        label: 'JavaScript',
+        syntax: 'javascript',
+        generate: function (_a) {
+            var method = _a.method, url = _a.url, headers = _a.headers, body = _a.body;
+            var code = '';
+            code += "const response = await fetch('".concat(url, "', {\n    method: '").concat(method.toUpperCase(), "',\n");
             if (headers) {
-                Object.entries(headers).forEach(([key, value]) => {
-                    lines.push(`-H '${key}: ${value}'`);
-                });
+                code += indent("headers: ".concat(stringifyOpenAPI(headers, null, 2), ",\n"), 4);
             }
-            lines.push(`'${url}'`);
             if (body) {
-                lines.push(`-d '${JSON.stringify(body)}'`);
+                code += indent("body: JSON.stringify(".concat(stringifyOpenAPI(body, null, 2), "),\n"), 4);
             }
-            return lines.map((line, index) => (index > 0 ? indent(line, 2) : line)).join(separator);
+            code += "});\n";
+            code += "const data = await response.json();";
+            return code;
         },
     },
     {
         id: 'python',
         label: 'Python',
         syntax: 'python',
-        generate: ({ method, url, headers, body }) => {
-            let code = 'import requests\n\n';
-            code += `response = requests.${method.toLowerCase()}(\n`;
-            code += indent(`"${url}",\n`, 4);
+        generate: function (_a) {
+            var method = _a.method, url = _a.url, headers = _a.headers, body = _a.body;
+            var code = 'import requests\n\n';
+            code += "response = requests.".concat(method.toLowerCase(), "(\n");
+            code += indent("\"".concat(url, "\",\n"), 4);
             if (headers) {
-                code += indent(`headers=${JSON.stringify(headers)},\n`, 4);
+                code += indent("headers=".concat(stringifyOpenAPI(headers), ",\n"), 4);
             }
             if (body) {
-                code += indent(`json=${JSON.stringify(body)}\n`, 4);
+                code += indent("json=".concat(stringifyOpenAPI(body), "\n"), 4);
             }
             code += ')\n';
-            code += `data = response.json()`;
+            code += "data = response.json()";
             return code;
         },
     },
+    {
+        id: 'http',
+        label: 'HTTP',
+        syntax: 'bash',
+        generate: function (_a) {
+            var method = _a.method, url = _a.url, _b = _a.headers, headers = _b === void 0 ? {} : _b, body = _a.body;
+            var _c = parseHostAndPath(url), host = _c.host, path = _c.path;
+            if (body) {
+                // if we had a body add a content length header
+                var bodyContent = body ? stringifyOpenAPI(body) : '';
+                // handle unicode chars with a text encoder
+                var encoder = new TextEncoder();
+                headers = __assign(__assign({}, headers), { 'Content-Length': encoder.encode(bodyContent).length.toString() });
+            }
+            if (!headers.hasOwnProperty('Accept')) {
+                headers.Accept = '*/*';
+            }
+            var headerString = headers
+                ? Object.entries(headers)
+                    .map(function (_a) {
+                    var key = _a[0], value = _a[1];
+                    return key.toLowerCase() !== 'host' ? "".concat(key, ": ").concat(value) : "";
+                })
+                    .join('\n') + '\n'
+                : '';
+            var bodyString = body ? "\n".concat(stringifyOpenAPI(body, null, 2)) : '';
+            var httpRequest = "".concat(method.toUpperCase(), " ").concat(decodeURI(path), " HTTP/1.1\nHost: ").concat(host, "\n").concat(headerString).concat(bodyString);
+            return httpRequest;
+        },
+    },
 ];
 function indent(code, spaces) {
-    const indent = ' '.repeat(spaces);
+    var indent = ' '.repeat(spaces);
     return code
         .split('\n')
-        .map((line) => (line ? indent + line : ''))
+        .map(function (line) { return (line ? indent + line : ''); })
         .join('\n');
 }
+export function parseHostAndPath(url) {
+    try {
+        var urlObj = new URL(url);
+        var path = urlObj.pathname || '/';
+        return { host: urlObj.host, path: path };
+    }
+    catch (e) {
+        // If the URL was invalid do our best to parse the URL.
+        // Check for the protocol part and pull it off to grab the host
+        var splitted = url.split('//');
+        var fullUrl = splitted[1] ? splitted[1] : url;
+        // separate paths from the first element (host)
+        var parts = fullUrl.split('/');
+        // pull off the host (mutates)
+        var host = parts.shift();
+        // add a leading slash and join the paths again
+        var path = '/' + parts.join('/');
+        return { host: host, path: path };
+    }
+}

package/dist/generateSchemaExample.d.ts

@@ -1,4 +1,4 @@
-import { OpenAPIV3 } from 'openapi-types';
+import type { OpenAPIV3 } from '@gitbook/openapi-parser';
 type JSONValue = string | number | boolean | null | JSONValue[] | {
     [key: string]: JSONValue;
 };
@@ -7,7 +7,7 @@ type JSONValue = string | number | boolean | null | JSONValue[] | {
  */
 export declare function generateSchemaExample(schema: OpenAPIV3.SchemaObject, options?: {
     onlyRequired?: boolean;
-}, ancestors?: Set<OpenAPIV3.SchemaObject>): JSONValue | undefined;
+}): JSONValue | undefined;
 /**
  * Generate an example for a media type.
  */