@gitbook/react-openapi 1.4.3 → 1.5.2

package/dist/OpenAPIResponses.jsx

@@ -1,77 +0,0 @@
-'use client';
-import clsx from 'clsx';
-import { Markdown } from './Markdown';
-import { OpenAPIDisclosureGroup } from './OpenAPIDisclosureGroup';
-import { OpenAPIResponse } from './OpenAPIResponse';
-import { useResponseExamplesState } from './OpenAPIResponseExampleContent';
-import { StaticSection } from './StaticSection';
-import { t } from './translate';
-import { createStateKey, getStatusCodeClassName, getStatusCodeDefaultLabel, resolveDescription, } from './utils';
-/**
- * Display an interactive response body.
- */
-export function OpenAPIResponses(props) {
-    var _a;
-    var responses = props.responses, context = props.context;
-    var groups = Object.entries(responses)
-        .filter(function (_a) {
-        var _ = _a[0], response = _a[1];
-        return response && typeof response === 'object';
-    })
-        .map(function (_a) {
-        var statusCode = _a[0], response = _a[1];
-        var tabs = (function () {
-            var _a;
-            // If there is no content, but there are headers, we need to show the headers
-            if ((!response.content || !Object.keys(response.content).length) &&
-                response.headers &&
-                Object.keys(response.headers).length) {
-                return [
-                    {
-                        key: 'default',
-                        label: '',
-                        body: (<OpenAPIResponse response={response} mediaType={{}} context={context}/>),
-                    },
-                ];
-            }
-            if (!response.content) {
-                return [
-                    {
-                        key: 'default',
-                        label: '',
-                        body: (<pre className="openapi-example-empty">
-                                    <p>{t(context.translation, 'no_content')}</p>
-                                </pre>),
-                    },
-                ];
-            }
-            return Object.entries((_a = response.content) !== null && _a !== void 0 ? _a : {}).map(function (_a) {
-                var contentType = _a[0], mediaType = _a[1];
-                return ({
-                    key: contentType,
-                    label: contentType,
-                    body: (<OpenAPIResponse response={response} mediaType={mediaType} context={context}/>),
-                });
-            });
-        })();
-        var description = resolveDescription(response);
-        return {
-            key: statusCode,
-            label: (<div className="openapi-response-tab-content">
-                        <span className={clsx('openapi-statuscode', "openapi-statuscode-".concat(getStatusCodeClassName(statusCode)))}>
-                            {statusCode}
-                        </span>
-                        {description ? (<Markdown source={description} className="openapi-response-description"/>) : (getStatusCodeDefaultLabel(statusCode, context))}
-                    </div>),
-            tabs: tabs,
-        };
-    });
-    var state = useResponseExamplesState(context.blockKey, (_a = groups[0]) === null || _a === void 0 ? void 0 : _a.key);
-    return (<StaticSection header={t(context.translation, 'responses')} className="openapi-responses">
-            <OpenAPIDisclosureGroup icon={context.icons.chevronRight} expandedKeys={state.key ? new Set([state.key]) : new Set()} onExpandedChange={function (keys) {
-            var _a;
-            var key = (_a = keys.values().next().value) !== null && _a !== void 0 ? _a : null;
-            state.setKey(key);
-        }} groups={groups} selectIcon={context.icons.chevronDown} selectStateKey={createStateKey('response-media-types', context.blockKey)}/>
-        </StaticSection>);
-}

package/dist/OpenAPISchema.d.ts

@@ -1,27 +0,0 @@
-import type { OpenAPIV3 } from '@gitbook/openapi-parser';
-import type { OpenAPIClientContext } from './context';
-export interface OpenAPISchemaPropertyEntry {
-    propertyName?: string;
-    required?: boolean | null;
-    schema: OpenAPIV3.SchemaObject;
-}
-export declare function OpenAPISchemaPropertiesFromServer(props: {
-    id?: string;
-    properties: string;
-    context: OpenAPIClientContext;
-}): import("react").JSX.Element;
-export declare function OpenAPIRootSchemaFromServer(props: {
-    schema: string;
-    context: OpenAPIClientContext;
-}): import("react").JSX.Element;
-/**
- * Render the top row of a schema. e.g: name, type, and required status.
- */
-export declare function OpenAPISchemaPresentation(props: {
-    property: OpenAPISchemaPropertyEntry;
-    context: OpenAPIClientContext;
-}): import("react").JSX.Element;
-/**
- * Get the alternatives to display for a schema.
- */
-export declare function getSchemaAlternatives(schema: OpenAPIV3.SchemaObject, ancestors?: Set<OpenAPIV3.SchemaObject>): OpenAPIV3.SchemaObject[] | null;

package/dist/OpenAPISchema.jsx

@@ -1,400 +0,0 @@
-'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);
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-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 { useId } from 'react';
-import clsx from 'clsx';
-import { Markdown } from './Markdown';
-import { OpenAPICopyButton } from './OpenAPICopyButton';
-import { OpenAPIDisclosure } from './OpenAPIDisclosure';
-import { OpenAPISchemaName } from './OpenAPISchemaName';
-import { retrocycle } from './decycle';
-import { getDisclosureLabel } from './getDisclosureLabel';
-import { stringifyOpenAPI } from './stringifyOpenAPI';
-import { tString } from './translate';
-import { checkIsReference, getSchemaTitle, resolveDescription, resolveFirstExample } from './utils';
-/**
- * Render a property of an OpenAPI schema.
- */
-function OpenAPISchemaProperty(props) {
-    var parentCircularRefs = props.circularRefs, context = props.context, className = props.className, property = props.property, rest = __rest(props, ["circularRefs", "context", "className", "property"]);
-    var schema = property.schema;
-    var id = useId();
-    var circularRefId = parentCircularRefs.get(schema);
-    // Avoid recursing infinitely, and instead render a link to the parent schema
-    if (circularRefId) {
-        return <OpenAPISchemaCircularRef id={circularRefId} schema={schema}/>;
-    }
-    var circularRefs = new Map(parentCircularRefs);
-    circularRefs.set(schema, id);
-    var properties = getSchemaProperties(schema);
-    var ancestors = new Set(circularRefs.keys());
-    var alternatives = getSchemaAlternatives(schema, ancestors);
-    var header = <OpenAPISchemaPresentation context={context} property={property}/>;
-    var content = (function () {
-        if (properties === null || properties === void 0 ? void 0 : properties.length) {
-            return (<OpenAPISchemaProperties properties={properties} circularRefs={circularRefs} context={context}/>);
-        }
-        if (alternatives) {
-            return (<div className="openapi-schema-alternatives">
-                    {alternatives.map(function (alternativeSchema, index) { return (<div key={index} className="openapi-schema-alternative">
-                            <OpenAPISchemaAlternative schema={alternativeSchema} circularRefs={circularRefs} context={context}/>
-                            {index < alternatives.length - 1 ? (<OpenAPISchemaAlternativeSeparator schema={schema} context={context}/>) : null}
-                        </div>); })}
-                </div>);
-        }
-        return null;
-    })();
-    if (properties === null || properties === void 0 ? void 0 : properties.length) {
-        return (<OpenAPIDisclosure icon={context.icons.plus} className={clsx('openapi-schema', className)} header={header} label={function (isExpanded) { return getDisclosureLabel({ schema: schema, isExpanded: isExpanded, context: context }); }} {...rest}>
-                {content}
-            </OpenAPIDisclosure>);
-    }
-    return (<div id={id} {...rest} className={clsx('openapi-schema', className)}>
-            {header}
-            {content}
-        </div>);
-}
-/**
- * Render a set of properties of an OpenAPI schema.
- */
-function OpenAPISchemaProperties(props) {
-    var id = props.id, properties = props.properties, _a = props.circularRefs, circularRefs = _a === void 0 ? new Map() : _a, context = props.context;
-    return (<div id={id} className="openapi-schema-properties">
-            {properties.map(function (property, index) {
-            return (<OpenAPISchemaProperty key={index} circularRefs={circularRefs} property={property} context={context} style={{ animationDelay: "".concat(index * 0.02, "s") }}/>);
-        })}
-        </div>);
-}
-export function OpenAPISchemaPropertiesFromServer(props) {
-    return (<OpenAPISchemaProperties id={props.id} properties={JSON.parse(props.properties, retrocycle())} context={props.context}/>);
-}
-/**
- * Render a root schema (such as the request body or response body).
- */
-function OpenAPIRootSchema(props) {
-    var schema = props.schema, context = props.context, _a = props.circularRefs, parentCircularRefs = _a === void 0 ? new Map() : _a;
-    var id = useId();
-    var properties = getSchemaProperties(schema);
-    var description = resolveDescription(schema);
-    if (properties === null || properties === void 0 ? void 0 : properties.length) {
-        var circularRefs = new Map(parentCircularRefs);
-        circularRefs.set(schema, id);
-        return (<>
-                {description ? (<Markdown source={description} className="openapi-schema-root-description"/>) : null}
-                <OpenAPISchemaProperties properties={properties} circularRefs={circularRefs} context={context}/>
-            </>);
-    }
-    return (<OpenAPISchemaProperty className="openapi-schema-root" property={{ schema: schema }} context={context} circularRefs={parentCircularRefs}/>);
-}
-export function OpenAPIRootSchemaFromServer(props) {
-    return (<OpenAPIRootSchema schema={JSON.parse(props.schema, retrocycle())} context={props.context}/>);
-}
-/**
- * Render a tab for an alternative schema.
- * It renders directly the properties if relevant;
- * for primitives, it renders the schema itself.
- */
-function OpenAPISchemaAlternative(props) {
-    var schema = props.schema, circularRefs = props.circularRefs, context = props.context;
-    var properties = getSchemaProperties(schema);
-    return (properties === null || properties === void 0 ? void 0 : properties.length) ? (<OpenAPIDisclosure icon={context.icons.plus} header={<OpenAPISchemaPresentation property={{ schema: schema }} context={context}/>} label={function (isExpanded) { return getDisclosureLabel({ schema: schema, isExpanded: isExpanded, context: context }); }}>
-            <OpenAPISchemaProperties properties={properties} circularRefs={circularRefs} context={context}/>
-        </OpenAPIDisclosure>) : (<OpenAPISchemaProperty property={{ schema: schema }} circularRefs={circularRefs} context={context}/>);
-}
-function OpenAPISchemaAlternativeSeparator(props) {
-    var _a, _b, _c;
-    var schema = props.schema, context = props.context;
-    var anyOf = schema.anyOf || ((_a = schema.items) === null || _a === void 0 ? void 0 : _a.anyOf);
-    var oneOf = schema.oneOf || ((_b = schema.items) === null || _b === void 0 ? void 0 : _b.oneOf);
-    var allOf = schema.allOf || ((_c = schema.items) === null || _c === void 0 ? void 0 : _c.allOf);
-    if (!anyOf && !oneOf && !allOf) {
-        return null;
-    }
-    return (<span className="openapi-schema-alternative-separator">
-            {(anyOf || oneOf) && tString(context.translation, 'or')}
-            {allOf && tString(context.translation, 'and')}
-        </span>);
-}
-/**
- * Render a circular reference to a schema.
- */
-function OpenAPISchemaCircularRef(props) {
-    var id = props.id, schema = props.schema;
-    return (<div className="openapi-schema-circular">
-            Circular reference to <a href={"#".concat(id)}>{getSchemaTitle(schema)}</a>{' '}
-            <span className="openapi-schema-circular-glyph">↩</span>
-        </div>);
-}
-/**
- * Render the enum value for a schema.
- */
-function OpenAPISchemaEnum(props) {
-    var schema = props.schema, context = props.context;
-    var enumValues = (function () {
-        var _a;
-        // Render x-gitbook-enum first, as it has a different format
-        if (schema['x-gitbook-enum']) {
-            return Object.entries(schema['x-gitbook-enum']).map(function (_a) {
-                var name = _a[0], description = _a[1].description;
-                return {
-                    value: name,
-                    description: description,
-                };
-            });
-        }
-        if (schema['x-enumDescriptions']) {
-            return Object.entries(schema['x-enumDescriptions']).map(function (_a) {
-                var value = _a[0], description = _a[1];
-                return {
-                    value: value,
-                    description: description,
-                };
-            });
-        }
-        return (_a = schema.enum) === null || _a === void 0 ? void 0 : _a.map(function (value) {
-            return {
-                value: value,
-                description: undefined,
-            };
-        });
-    })();
-    if (!(enumValues === null || enumValues === void 0 ? void 0 : enumValues.length)) {
-        return null;
-    }
-    return (<span className="openapi-schema-enum">
-            {tString(context.translation, 'possible_values')}:{' '}
-            {enumValues.map(function (item, index) { return (<span key={index} className="openapi-schema-enum-value">
-                    <OpenAPICopyButton value={item.value} label={item.description} withTooltip={!!item.description} context={context}>
-                        <code>{"".concat(item.value)}</code>
-                    </OpenAPICopyButton>
-                </span>); })}
-        </span>);
-}
-/**
- * Render the top row of a schema. e.g: name, type, and required status.
- */
-export function OpenAPISchemaPresentation(props) {
-    var _a = props.property, schema = _a.schema, propertyName = _a.propertyName, required = _a.required, context = props.context;
-    var description = resolveDescription(schema);
-    var example = resolveFirstExample(schema);
-    return (<div className="openapi-schema-presentation">
-            <OpenAPISchemaName schema={schema} type={getSchemaTitle(schema)} propertyName={propertyName} required={required} context={context}/>
-            {typeof schema['x-deprecated-sunset'] === 'string' ? (<div className="openapi-deprecated-sunset openapi-schema-description openapi-markdown">
-                    Sunset date:{' '}
-                    <span className="openapi-deprecated-sunset-date">
-                        {schema['x-deprecated-sunset']}
-                    </span>
-                </div>) : null}
-            {description ? (<Markdown source={description} className="openapi-schema-description"/>) : null}
-            {schema.default !== undefined ? (<span className="openapi-schema-default">
-                    Default:{' '}
-                    <code>
-                        {typeof schema.default === 'string' && schema.default
-                ? schema.default
-                : stringifyOpenAPI(schema.default)}
-                    </code>
-                </span>) : null}
-            {typeof example === 'string' ? (<span className="openapi-schema-example">
-                    Example: <code>{example}</code>
-                </span>) : null}
-            {schema.pattern ? (<span className="openapi-schema-pattern">
-                    Pattern: <code>{schema.pattern}</code>
-                </span>) : null}
-            <OpenAPISchemaEnum schema={schema} context={context}/>
-        </div>);
-}
-/**
- * Get the sub-properties of a schema.
- */
-function getSchemaProperties(schema) {
-    // check array AND schema.items as this is sometimes null despite what the type indicates
-    if (schema.type === 'array' && schema.items && !checkIsReference(schema.items)) {
-        var items = schema.items;
-        var itemProperties = getSchemaProperties(items);
-        if (itemProperties) {
-            return itemProperties;
-        }
-        // If the items are a primitive type, we don't need to display them
-        if ((items.type === 'string' ||
-            items.type === 'number' ||
-            items.type === 'boolean' ||
-            items.type === 'integer') &&
-            !items.enum) {
-            return null;
-        }
-        return [{ propertyName: 'items', schema: items }];
-    }
-    if (schema.type === 'object' || schema.properties) {
-        var result_1 = [];
-        if (schema.properties) {
-            Object.entries(schema.properties).forEach(function (_a) {
-                var propertyName = _a[0], propertySchema = _a[1];
-                if (checkIsReference(propertySchema)) {
-                    return;
-                }
-                result_1.push({
-                    propertyName: propertyName,
-                    required: Array.isArray(schema.required)
-                        ? schema.required.includes(propertyName)
-                        : undefined,
-                    schema: propertySchema,
-                });
-            });
-        }
-        if (schema.additionalProperties && !checkIsReference(schema.additionalProperties)) {
-            result_1.push({
-                propertyName: 'Other properties',
-                schema: schema.additionalProperties === true ? {} : schema.additionalProperties,
-            });
-        }
-        return result_1;
-    }
-    return null;
-}
-/**
- * Get the alternatives to display for a schema.
- */
-export function getSchemaAlternatives(schema, ancestors) {
-    if (ancestors === void 0) { ancestors = new Set(); }
-    // Search for alternatives in the items property if it exists
-    if (schema.items &&
-        ('oneOf' in schema.items || 'allOf' in schema.items || 'anyOf' in schema.items)) {
-        return getSchemaAlternatives(schema.items, ancestors);
-    }
-    var alternatives = (function () {
-        if (schema.anyOf) {
-            return ['anyOf', schema.anyOf];
-        }
-        if (schema.oneOf) {
-            return ['oneOf', schema.oneOf];
-        }
-        if (schema.allOf) {
-            return ['allOf', schema.allOf];
-        }
-        return null;
-    })();
-    if (!alternatives) {
-        return null;
-    }
-    var type = alternatives[0], schemas = alternatives[1];
-    return mergeAlternatives(type, flattenAlternatives(type, schemas, new Set(ancestors).add(schema)));
-}
-/**
- * Merge alternatives of the same type into a single schema.
- * - Merge string enums
- */
-function mergeAlternatives(alternativeType, schemasOrRefs) {
-    switch (alternativeType) {
-        case 'oneOf': {
-            return schemasOrRefs.reduce(function (acc, schemaOrRef) {
-                var latest = acc.at(-1);
-                if (latest &&
-                    latest.type === 'string' &&
-                    latest.enum &&
-                    schemaOrRef.type === 'string' &&
-                    schemaOrRef.enum) {
-                    latest.enum = Array.from(new Set(__spreadArray(__spreadArray([], latest.enum, true), schemaOrRef.enum, true)));
-                    latest.nullable = latest.nullable || schemaOrRef.nullable;
-                    return acc;
-                }
-                acc.push(schemaOrRef);
-                return acc;
-            }, []);
-        }
-        case 'allOf': {
-            return schemasOrRefs.reduce(function (acc, schemaOrRef) {
-                var latest = acc.at(-1);
-                if (latest &&
-                    latest.type === 'string' &&
-                    latest.enum &&
-                    schemaOrRef.type === 'string' &&
-                    schemaOrRef.enum) {
-                    var keys = Object.keys(schemaOrRef);
-                    if (keys.every(function (key) { return ['type', 'enum', 'nullable'].includes(key); })) {
-                        latest.enum = Array.from(new Set(__spreadArray(__spreadArray([], latest.enum, true), schemaOrRef.enum, true)));
-                        latest.nullable = latest.nullable || schemaOrRef.nullable;
-                        return acc;
-                    }
-                }
-                if (latest && latest.type === 'object' && schemaOrRef.type === 'object') {
-                    var keys = Object.keys(schemaOrRef);
-                    if (keys.every(function (key) {
-                        return ['type', 'properties', 'required', 'nullable'].includes(key);
-                    })) {
-                        latest.properties = __assign(__assign({}, latest.properties), schemaOrRef.properties);
-                        latest.required = Array.from(new Set(__spreadArray(__spreadArray([], (Array.isArray(latest.required) ? latest.required : []), true), (Array.isArray(schemaOrRef.required)
-                            ? schemaOrRef.required
-                            : []), true)));
-                        latest.nullable = latest.nullable || schemaOrRef.nullable;
-                        return acc;
-                    }
-                }
-                acc.push(schemaOrRef);
-                return acc;
-            }, []);
-        }
-        default:
-            return schemasOrRefs;
-    }
-}
-function flattenAlternatives(alternativeType, schemasOrRefs, ancestors) {
-    // Get the parent schema's required fields from the most recent ancestor
-    var latestAncestor = Array.from(ancestors).pop();
-    return schemasOrRefs.reduce(function (acc, schemaOrRef) {
-        if (checkIsReference(schemaOrRef)) {
-            return acc;
-        }
-        if (schemaOrRef[alternativeType] && !ancestors.has(schemaOrRef)) {
-            var schemas = getSchemaAlternatives(schemaOrRef, ancestors);
-            if (schemas) {
-                acc.push.apply(acc, schemas.map(function (schema) { return (__assign(__assign({}, schema), { required: mergeRequiredFields(schema, latestAncestor) })); }));
-            }
-            return acc;
-        }
-        // For direct schemas, handle required fields
-        var schema = __assign(__assign({}, schemaOrRef), { required: mergeRequiredFields(schemaOrRef, latestAncestor) });
-        acc.push(schema);
-        return acc;
-    }, []);
-}
-/**
- * Merge the required fields of a schema with the required fields of its latest ancestor.
- */
-function mergeRequiredFields(schemaOrRef, latestAncestor) {
-    if (!schemaOrRef.required && !(latestAncestor === null || latestAncestor === void 0 ? void 0 : latestAncestor.required)) {
-        return undefined;
-    }
-    if (checkIsReference(schemaOrRef)) {
-        return latestAncestor === null || latestAncestor === void 0 ? void 0 : latestAncestor.required;
-    }
-    return Array.from(new Set(__spreadArray(__spreadArray([], ((latestAncestor === null || latestAncestor === void 0 ? void 0 : latestAncestor.required) || []), true), (schemaOrRef.required || []), true)));
-}

package/dist/OpenAPISchemaName.d.ts

@@ -1,16 +0,0 @@
-import type { OpenAPIV3 } from '@gitbook/openapi-parser';
-import type React from 'react';
-import type { OpenAPIClientContext } from './context';
-interface OpenAPISchemaNameProps {
-    schema?: OpenAPIV3.SchemaObject;
-    propertyName?: string | React.JSX.Element;
-    required?: boolean | null;
-    type?: string;
-    context: OpenAPIClientContext;
-}
-/**
- * Display the schema name row.
- * It includes the property name, type, required and deprecated status.
- */
-export declare function OpenAPISchemaName(props: OpenAPISchemaNameProps): React.JSX.Element;
-export {};

package/dist/OpenAPISchemaName.jsx

@@ -1,43 +0,0 @@
-import { t, tString } from './translate';
-/**
- * Display the schema name row.
- * It includes the property name, type, required and deprecated status.
- */
-export function OpenAPISchemaName(props) {
-    var schema = props.schema, type = props.type, propertyName = props.propertyName, required = props.required, context = props.context;
-    var additionalItems = schema && getAdditionalItems(schema, context);
-    return (<span className="openapi-schema-name">
-            {propertyName ? (<span data-deprecated={schema === null || schema === void 0 ? void 0 : schema.deprecated} className="openapi-schema-propertyname">
-                    {propertyName}
-                </span>) : null}
-            {type || additionalItems ? (<span>
-                    {type ? <span className="openapi-schema-type">{type}</span> : null}
-                    {additionalItems ? (<span className="openapi-schema-type">{additionalItems}</span>) : null}
-                </span>) : null}
-            {(schema === null || schema === void 0 ? void 0 : schema.readOnly) ? (<span className="openapi-schema-readonly">
-                    {t(context.translation, 'read_only')}
-                </span>) : null}
-            {(schema === null || schema === void 0 ? void 0 : schema.writeOnly) ? (<span className="openapi-schema-writeonly">
-                    {t(context.translation, 'write_only')}
-                </span>) : null}
-            {required === null ? null : required ? (<span className="openapi-schema-required">
-                    {t(context.translation, 'required')}
-                </span>) : (<span className="openapi-schema-optional">
-                    {t(context.translation, 'optional')}
-                </span>)}
-            {(schema === null || schema === void 0 ? void 0 : schema.deprecated) ? (<span className="openapi-deprecated">{t(context.translation, 'deprecated')}</span>) : null}
-        </span>);
-}
-function getAdditionalItems(schema, context) {
-    var additionalItems = '';
-    if (schema.minimum || schema.minLength || schema.minItems) {
-        additionalItems += " \u00B7 ".concat(tString(context.translation, 'min').toLowerCase(), ": ").concat(schema.minimum || schema.minLength || schema.minItems);
-    }
-    if (schema.maximum || schema.maxLength || schema.maxItems) {
-        additionalItems += " \u00B7 ".concat(tString(context.translation, 'max').toLowerCase(), ": ").concat(schema.maximum || schema.maxLength || schema.maxItems);
-    }
-    if (schema.nullable) {
-        additionalItems = " | ".concat(tString(context.translation, 'nullable').toLowerCase());
-    }
-    return additionalItems;
-}

package/dist/OpenAPISchemaServer.d.ts

@@ -1,12 +0,0 @@
-import type { OpenAPIV3 } from '@gitbook/openapi-parser';
-import { type OpenAPISchemaPropertyEntry } from './OpenAPISchema';
-import type { OpenAPIClientContext } from './context';
-export declare function OpenAPISchemaProperties(props: {
-    id?: string;
-    properties: OpenAPISchemaPropertyEntry[];
-    context: OpenAPIClientContext;
-}): import("react").JSX.Element;
-export declare function OpenAPIRootSchema(props: {
-    schema: OpenAPIV3.SchemaObject;
-    context: OpenAPIClientContext;
-}): import("react").JSX.Element;

package/dist/OpenAPISchemaServer.jsx

@@ -1,8 +0,0 @@
-import { OpenAPIRootSchemaFromServer, OpenAPISchemaPropertiesFromServer, } from './OpenAPISchema';
-import { decycle } from './decycle';
-export function OpenAPISchemaProperties(props) {
-    return (<OpenAPISchemaPropertiesFromServer id={props.id} properties={JSON.stringify(props.properties, decycle())} context={props.context}/>);
-}
-export function OpenAPIRootSchema(props) {
-    return (<OpenAPIRootSchemaFromServer schema={JSON.stringify(props.schema, decycle())} context={props.context}/>);
-}

package/dist/OpenAPISecurities.d.ts

@@ -1,9 +0,0 @@
-import type { OpenAPIClientContext } from './context';
-import type { OpenAPIOperationData } from './types';
-/**
- * Present securities authorization that can be used for this operation.
- */
-export declare function OpenAPISecurities(props: {
-    securities: OpenAPIOperationData['securities'];
-    context: OpenAPIClientContext;
-}): import("react").JSX.Element | null;