@gitbook/react-openapi 1.1.10 → 1.2.1

package/dist/resolveOpenAPIWebhook.js

@@ -0,0 +1,127 @@
+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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+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 { fromJSON, toJSON } from 'flatted';
+import { dereferenceFilesystem } from './dereference';
+export { fromJSON, toJSON };
+/**
+ * Resolve an OpenAPI webhook in a file and compile it to a more usable format.
+ */
+export function resolveOpenAPIWebhook(filesystem, webhookDescriptor) {
+    return __awaiter(this, void 0, void 0, function () {
+        var name, method, schema, operation, commonParameters, servers;
+        var _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    name = webhookDescriptor.name, method = webhookDescriptor.method;
+                    return [4 /*yield*/, dereferenceFilesystem(filesystem)];
+                case 1:
+                    schema = _c.sent();
+                    operation = getWebhookByNameAndMethod(schema, name, method);
+                    if (!operation) {
+                        return [2 /*return*/, null];
+                    }
+                    commonParameters = getPathObjectParameter(schema, name);
+                    if (commonParameters) {
+                        operation = __assign(__assign({}, operation), { parameters: __spreadArray(__spreadArray([], commonParameters, true), ((_a = operation.parameters) !== null && _a !== void 0 ? _a : []), true) });
+                    }
+                    servers = 'servers' in schema ? ((_b = schema.servers) !== null && _b !== void 0 ? _b : []) : [];
+                    return [2 /*return*/, {
+                            servers: servers,
+                            operation: operation,
+                            method: method,
+                            name: name,
+                        }];
+            }
+        });
+    });
+}
+/**
+ * Get a path object from its path.
+ */
+function getPathObject(schema, name) {
+    var _a;
+    if ((_a = schema.webhooks) === null || _a === void 0 ? void 0 : _a[name]) {
+        return schema.webhooks[name];
+    }
+    return null;
+}
+/**
+ * Resolve parameters from a path in an OpenAPI schema.
+ */
+function getPathObjectParameter(schema, path) {
+    var pathObject = getPathObject(schema, path);
+    if (pathObject === null || pathObject === void 0 ? void 0 : pathObject.parameters) {
+        return pathObject.parameters;
+    }
+    return null;
+}
+/**
+ * Get an operation by its path and method.
+ */
+function getWebhookByNameAndMethod(schema, name, method) {
+    // Types are buffy for OpenAPIV3_1.OperationObject, so we use v3
+    var pathObject = getPathObject(schema, name);
+    if (!pathObject) {
+        return null;
+    }
+    var normalizedMethod = method.toLowerCase();
+    if (!pathObject[normalizedMethod]) {
+        return null;
+    }
+    return pathObject[normalizedMethod];
+}

package/dist/schemas/OpenAPISchemas.d.ts

@@ -1,12 +1,12 @@
 import type { OpenAPISchema } from '@gitbook/openapi-parser';
-import type { OpenAPIContext } from '../types';
+import { type OpenAPIContextInput } from '../context';
 /**
  * OpenAPI Schemas component.
  */
 export declare function OpenAPISchemas(props: {
     className?: string;
     schemas: OpenAPISchema[];
-    context: OpenAPIContext;
+    context: OpenAPIContextInput;
     /**
      * Whether to show the schema directly if there is only one.
      */

package/dist/schemas/OpenAPISchemas.jsx

@@ -1,18 +1,21 @@
 import clsx from 'clsx';
-import { OpenAPIDisclosureGroup } from '../OpenAPIDisclosureGroup';
-import { OpenAPIExample, getExampleFromSchema } from '../OpenAPIExample';
+import { OpenAPIDisclosure } from '../OpenAPIDisclosure';
+import { OpenAPIExample } from '../OpenAPIExample';
 import { OpenAPIRootSchema } from '../OpenAPISchemaServer';
 import { Section, SectionBody, StaticSection } from '../StaticSection';
-import { getOpenAPIClientContext } from '../context';
+import { getOpenAPIClientContext, resolveOpenAPIContext, } from '../context';
+import { t } from '../translate';
+import { getExampleFromSchema } from '../util/example';
 /**
  * OpenAPI Schemas component.
  */
 export function OpenAPISchemas(props) {
-    var schemas = props.schemas, context = props.context, grouped = props.grouped, className = props.className;
+    var schemas = props.schemas, contextInput = props.context, grouped = props.grouped, className = props.className;
     var firstSchema = schemas[0];
     if (!firstSchema) {
         return null;
     }
+    var context = resolveOpenAPIContext(contextInput);
     var clientContext = getOpenAPIClientContext(context);
     // If there is only one model and we are not grouping, we show it directly.
     if (schemas.length === 1 && !grouped) {
@@ -21,11 +24,13 @@ export function OpenAPISchemas(props) {
                 <div className="openapi-summary" id={context.id}>
                     {context.renderHeading({
                 title: title,
+                deprecated: Boolean(firstSchema.schema.deprecated),
+                stability: firstSchema.schema['x-stability'],
             })}
                 </div>
                 <div className="openapi-columns">
                     <div className="openapi-column-spec">
-                        <StaticSection className="openapi-parameters" header="Attributes">
+                        <StaticSection className="openapi-parameters" header={t(context.translation, 'attributes')}>
                             <OpenAPIRootSchema schema={firstSchema.schema} context={clientContext}/>
                         </StaticSection>
                     </div>
@@ -46,24 +51,15 @@ export function OpenAPISchemas(props) {
     }
     // If there are multiple schemas, we use a disclosure group to show them all.
     return (<div className={clsx('openapi-schemas', className)}>
-            <OpenAPIDisclosureGroup allowsMultipleExpanded icon={context.icons.chevronRight} groups={schemas.map(function (_a) {
+            {schemas.map(function (_a) {
             var name = _a.name, schema = _a.schema;
-            return ({
-                id: name,
-                label: (<div className="openapi-response-tab-content" key={"model-".concat(name)}>
-                            <span className="openapi-response-statuscode">{name}</span>
-                        </div>),
-                tabs: [
-                    {
-                        id: 'model',
-                        body: (<Section className="openapi-section-schemas">
-                                    <SectionBody>
-                                        <OpenAPIRootSchema schema={schema} context={clientContext}/>
-                                    </SectionBody>
-                                </Section>),
-                    },
-                ],
-            });
-        })}/>
+            return (<OpenAPIDisclosure className="openapi-schemas-disclosure" key={name} icon={context.icons.chevronRight} label={name}>
+                        <Section className="openapi-section-schemas">
+                            <SectionBody>
+                                <OpenAPIRootSchema schema={schema} context={clientContext}/>
+                            </SectionBody>
+                        </Section>
+                    </OpenAPIDisclosure>);
+        })}
         </div>);
 }

package/dist/stringifyOpenAPI.d.ts

@@ -1,4 +1,4 @@
 /**
  * Stringify an OpenAPI object. Same API as JSON.stringify.
  */
-export declare function stringifyOpenAPI(body: unknown, _?: null, indent?: number): string;
+export declare function stringifyOpenAPI(value: any, replacer?: ((this: any, key: string, value: any) => any) | null, space?: string | number): string;

package/dist/stringifyOpenAPI.js

@@ -1,12 +1,15 @@
 /**
  * Stringify an OpenAPI object. Same API as JSON.stringify.
  */
-export function stringifyOpenAPI(body, _, indent) {
-    return JSON.stringify(body, function (key, value) {
+export function stringifyOpenAPI(value, replacer, space) {
+    return JSON.stringify(value, function (key, value) {
         // Ignore internal keys
         if (key.startsWith('x-gitbook-')) {
             return undefined;
         }
+        if (replacer) {
+            return replacer(key, value);
+        }
         return value;
-    }, indent);
+    }, space);
 }

package/dist/translate.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { Translation, TranslationKey } from './translations';
+/**
+ * Translate a string.
+ */
+export declare function t(translation: Translation, id: TranslationKey, ...args: React.ReactNode[]): React.ReactNode;
+/**
+ * Version of `t` that returns a string.
+ */
+export declare function tString(translation: Translation, id: TranslationKey, ...args: React.ReactNode[]): string;

package/dist/translate.jsx

@@ -0,0 +1,75 @@
+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 React from 'react';
+/**
+ * Translate a string.
+ */
+export function t(translation, id) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    var string = translation[id];
+    if (!string) {
+        throw new Error("Translation not found for \"".concat(id, "\""));
+    }
+    // Now we are going to replace the arguments
+    // but we want to return a string as long as it's possible
+    // (eg. if there isn't any argument that is a ReactNode)
+    var parts = [];
+    var currentStringToReplace = string;
+    args.forEach(function (arg, i) {
+        if (typeof arg === 'string') {
+            currentStringToReplace = currentStringToReplace.replace("${".concat(i + 1, "}"), arg);
+        }
+        else {
+            var _a = currentStringToReplace.split("${".concat(i + 1, "}")), partToPush = _a[0], partToReplace = _a[1];
+            if (partToPush === undefined || partToReplace === undefined) {
+                throw new Error("Invalid translation \"".concat(id, "\""));
+            }
+            parts.push(<React.Fragment key={"string-".concat(i)}>{partToPush}</React.Fragment>);
+            parts.push(<React.Fragment key={"arg-".concat(i)}>{arg}</React.Fragment>);
+            currentStringToReplace = partToReplace;
+        }
+    });
+    if (!parts.length) {
+        return currentStringToReplace;
+    }
+    return (<>
+            {parts}
+            {currentStringToReplace}
+        </>);
+}
+/**
+ * Version of `t` that returns a string.
+ */
+export function tString(translation, id) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    var result = t.apply(void 0, __spreadArray([translation, id], args, false));
+    return reactToString(result);
+}
+function reactToString(el) {
+    if (typeof el === 'string' || typeof el === 'number' || typeof el === 'boolean') {
+        return "".concat(el);
+    }
+    if (el === null || el === undefined) {
+        return '';
+    }
+    if (Array.isArray(el)) {
+        return el.map(reactToString).join('');
+    }
+    if (typeof el === 'object' && 'props' in el) {
+        return el.props.children.map(reactToString).join('');
+    }
+    throw new Error("Unsupported type ".concat(typeof el));
+}

package/dist/translations/de.d.ts

@@ -0,0 +1,37 @@
+export declare const de: {
+    required: string;
+    deprecated: string;
+    deprecated_and_sunset_on: string;
+    stability_experimental: string;
+    stability_alpha: string;
+    stability_beta: string;
+    copy_to_clipboard: string;
+    copied: string;
+    no_content: string;
+    unresolved_reference: string;
+    circular_reference: string;
+    read_only: string;
+    write_only: string;
+    optional: string;
+    min: string;
+    max: string;
+    nullable: string;
+    body: string;
+    payload: string;
+    headers: string;
+    authorizations: string;
+    responses: string;
+    path_parameters: string;
+    query_parameters: string;
+    header_parameters: string;
+    attributes: string;
+    test_it: string;
+    information: string;
+    success: string;
+    redirect: string;
+    error: string;
+    show: string;
+    hide: string;
+    available_items: string;
+    child_attributes: string;
+};

package/dist/translations/de.js

@@ -0,0 +1,37 @@
+export var de = {
+    required: 'Erforderlich',
+    deprecated: 'Veraltet',
+    deprecated_and_sunset_on: 'Diese Operation ist veraltet und wird am ${1} eingestellt.',
+    stability_experimental: 'Experimentell',
+    stability_alpha: 'Alpha',
+    stability_beta: 'Beta',
+    copy_to_clipboard: 'In die Zwischenablage kopieren',
+    copied: 'Kopiert',
+    no_content: 'Kein Inhalt',
+    unresolved_reference: 'Nicht aufgelöste Referenz',
+    circular_reference: 'Zirkuläre Referenz',
+    read_only: 'Nur lesen',
+    write_only: 'Nur schreiben',
+    optional: 'Optional',
+    min: 'Min',
+    max: 'Max',
+    nullable: 'Nullfähig',
+    body: 'Rumpf',
+    payload: 'Nutzlast',
+    headers: 'Kopfzeilen',
+    authorizations: 'Autorisierungen',
+    responses: 'Antworten',
+    path_parameters: 'Pfadparameter',
+    query_parameters: 'Abfrageparameter',
+    header_parameters: 'Header-Parameter',
+    attributes: 'Attribute',
+    test_it: 'Teste es',
+    information: 'Information',
+    success: 'Erfolg',
+    redirect: 'Umleitung',
+    error: 'Fehler',
+    show: 'Anzeigen',
+    hide: 'Verstecken',
+    available_items: 'Verfügbare Elemente',
+    child_attributes: 'Unterattribute',
+};

package/dist/translations/en.d.ts

@@ -0,0 +1,37 @@
+export declare const en: {
+    required: string;
+    deprecated: string;
+    deprecated_and_sunset_on: string;
+    stability_experimental: string;
+    stability_alpha: string;
+    stability_beta: string;
+    copy_to_clipboard: string;
+    copied: string;
+    no_content: string;
+    unresolved_reference: string;
+    circular_reference: string;
+    read_only: string;
+    write_only: string;
+    optional: string;
+    min: string;
+    max: string;
+    nullable: string;
+    body: string;
+    payload: string;
+    headers: string;
+    authorizations: string;
+    responses: string;
+    path_parameters: string;
+    query_parameters: string;
+    header_parameters: string;
+    attributes: string;
+    test_it: string;
+    information: string;
+    success: string;
+    redirect: string;
+    error: string;
+    show: string;
+    hide: string;
+    available_items: string;
+    child_attributes: string;
+};

package/dist/translations/en.js

@@ -0,0 +1,37 @@
+export var en = {
+    required: 'Required',
+    deprecated: 'Deprecated',
+    deprecated_and_sunset_on: 'This operation is deprecated and will be sunset on ${1}.',
+    stability_experimental: 'Experimental',
+    stability_alpha: 'Alpha',
+    stability_beta: 'Beta',
+    copy_to_clipboard: 'Copy to clipboard',
+    copied: 'Copied',
+    no_content: 'No content',
+    unresolved_reference: 'Unresolved reference',
+    circular_reference: 'Circular reference',
+    read_only: 'Read-only',
+    write_only: 'Write-only',
+    optional: 'Optional',
+    min: 'Min',
+    max: 'Max',
+    nullable: 'Nullable',
+    body: 'Body',
+    payload: 'Payload',
+    headers: 'Headers',
+    authorizations: 'Authorizations',
+    responses: 'Responses',
+    path_parameters: 'Path parameters',
+    query_parameters: 'Query parameters',
+    header_parameters: 'Header parameters',
+    attributes: 'Attributes',
+    test_it: 'Test it',
+    information: 'Information',
+    success: 'Success',
+    redirect: 'Redirect',
+    error: 'Error',
+    show: 'Show',
+    hide: 'Hide',
+    available_items: 'Available items',
+    child_attributes: 'Child attributes',
+};

package/dist/translations/es.d.ts

@@ -0,0 +1,37 @@
+export declare const es: {
+    required: string;
+    deprecated: string;
+    deprecated_and_sunset_on: string;
+    stability_experimental: string;
+    stability_alpha: string;
+    stability_beta: string;
+    copy_to_clipboard: string;
+    copied: string;
+    no_content: string;
+    unresolved_reference: string;
+    circular_reference: string;
+    read_only: string;
+    write_only: string;
+    optional: string;
+    min: string;
+    max: string;
+    nullable: string;
+    body: string;
+    payload: string;
+    headers: string;
+    authorizations: string;
+    responses: string;
+    path_parameters: string;
+    query_parameters: string;
+    header_parameters: string;
+    attributes: string;
+    test_it: string;
+    information: string;
+    success: string;
+    redirect: string;
+    error: string;
+    show: string;
+    hide: string;
+    available_items: string;
+    child_attributes: string;
+};

package/dist/translations/es.js

@@ -0,0 +1,37 @@
+export var es = {
+    required: 'Requerido',
+    deprecated: 'Obsoleto',
+    deprecated_and_sunset_on: 'Esta operación está obsoleta y se retirará el ${1}.',
+    stability_experimental: 'Experimental',
+    stability_alpha: 'Alfa',
+    stability_beta: 'Beta',
+    copy_to_clipboard: 'Copiar al portapapeles',
+    copied: 'Copiado',
+    no_content: 'Sin contenido',
+    unresolved_reference: 'Referencia no resuelta',
+    circular_reference: 'Referencia circular',
+    read_only: 'Solo lectura',
+    write_only: 'Solo escritura',
+    optional: 'Opcional',
+    min: 'Mín',
+    max: 'Máx',
+    nullable: 'Nulo',
+    body: 'Cuerpo',
+    payload: 'Caga útil',
+    headers: 'Encabezados',
+    authorizations: 'Autorizaciones',
+    responses: 'Respuestas',
+    path_parameters: 'Parámetros de ruta',
+    query_parameters: 'Parámetros de consulta',
+    header_parameters: 'Parámetros de encabezado',
+    attributes: 'Atributos',
+    test_it: 'Pruébalo',
+    information: 'Información',
+    success: 'Éxito',
+    redirect: 'Redirección',
+    error: 'Error',
+    show: 'Mostrar',
+    hide: 'Ocultar',
+    available_items: 'Elementos disponibles',
+    child_attributes: 'Atributos secundarios',
+};

package/dist/translations/fr.d.ts

@@ -0,0 +1,37 @@
+export declare const fr: {
+    required: string;
+    deprecated: string;
+    deprecated_and_sunset_on: string;
+    stability_experimental: string;
+    stability_alpha: string;
+    stability_beta: string;
+    copy_to_clipboard: string;
+    copied: string;
+    no_content: string;
+    unresolved_reference: string;
+    circular_reference: string;
+    read_only: string;
+    write_only: string;
+    optional: string;
+    min: string;
+    max: string;
+    nullable: string;
+    body: string;
+    payload: string;
+    headers: string;
+    authorizations: string;
+    responses: string;
+    path_parameters: string;
+    query_parameters: string;
+    header_parameters: string;
+    attributes: string;
+    test_it: string;
+    information: string;
+    success: string;
+    redirect: string;
+    error: string;
+    show: string;
+    hide: string;
+    available_items: string;
+    child_attributes: string;
+};

package/dist/translations/fr.js

@@ -0,0 +1,37 @@
+export var fr = {
+    required: 'Requis',
+    deprecated: 'Obsolète',
+    deprecated_and_sunset_on: 'Cette opération est obsolète et sera supprimée le ${1}.',
+    stability_experimental: 'Expérimental',
+    stability_alpha: 'Alpha',
+    stability_beta: 'Bêta',
+    copy_to_clipboard: 'Copier dans le presse-papiers',
+    copied: 'Copié',
+    no_content: 'Aucun contenu',
+    unresolved_reference: 'Référence non résolue',
+    circular_reference: 'Référence circulaire',
+    read_only: 'Lecture seule',
+    write_only: 'Écriture seule',
+    optional: 'Optionnel',
+    min: 'Min',
+    max: 'Max',
+    nullable: 'Nullable',
+    body: 'Corps',
+    payload: 'Charge utile',
+    headers: 'En-têtes',
+    authorizations: 'Autorisations',
+    responses: 'Réponses',
+    path_parameters: 'Paramètres de chemin',
+    query_parameters: 'Paramètres de requête',
+    header_parameters: 'Paramètres d’en-tête',
+    attributes: 'Attributs',
+    test_it: 'Tester',
+    information: 'Information',
+    success: 'Succès',
+    redirect: 'Redirection',
+    error: 'Erreur',
+    show: 'Afficher',
+    hide: 'Masquer',
+    available_items: 'Éléments disponibles',
+    child_attributes: 'Attributs enfants',
+};