@gitbook/react-openapi 1.4.3 → 1.5.2

package/dist/schemas/OpenAPISchemas.js

@@ -0,0 +1,57 @@
+import { t } from "../translate.js";
+import { OpenAPIExample } from "../OpenAPIExample.js";
+import { OpenAPIRootSchema } from "../OpenAPISchemaServer.js";
+import { StaticSection } from "../StaticSection.js";
+import { getOpenAPIClientContext, resolveOpenAPIContext } from "../context.js";
+import { getExampleFromSchema } from "../util/example.js";
+import { OpenAPISchemaItem } from "./OpenAPISchemaItem.js";
+import clsx from "classnames";
+
+//#region src/schemas/OpenAPISchemas.tsx
+/**
+* OpenAPI Schemas component.
+*/
+function OpenAPISchemas(props) {
+	const { schemas, context: contextInput, grouped, className } = props;
+	const firstSchema = schemas[0];
+	if (!firstSchema) return null;
+	const context = resolveOpenAPIContext(contextInput);
+	const clientContext = getOpenAPIClientContext(context);
+	if (schemas.length === 1 && !grouped) {
+		const title = `The ${firstSchema.name} object`;
+		return <div className={clsx("openapi-schemas", className)}>
+                <div className="openapi-summary" id={context.id}>
+                    {context.renderHeading({
+			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={t(context.translation, "attributes")}>
+                            <OpenAPIRootSchema schema={firstSchema.schema} context={clientContext} />
+                        </StaticSection>
+                    </div>
+                    <div className="openapi-column-preview">
+                        <div className="openapi-column-preview-body">
+                            <div className="openapi-panel">
+                                <h4 className="openapi-panel-heading">{title}</h4>
+                                <div className="openapi-panel-body">
+                                    <OpenAPIExample example={getExampleFromSchema({ schema: firstSchema.schema })} context={context} syntax="json" />
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>;
+	}
+	return <div className={clsx("openapi-schemas", className)}>
+            {schemas.map(({ name, schema }) => {
+		return <OpenAPISchemaItem key={name} name={name} context={clientContext} schema={schema} />;
+	})}
+        </div>;
+}
+
+//#endregion
+export { OpenAPISchemas };

package/dist/schemas/resolveOpenAPISchemas.d.ts

@@ -1,10 +1,15 @@
-import type { Filesystem, OpenAPISchema, OpenAPIV3xDocument } from '@gitbook/openapi-parser';
+import { Filesystem, OpenAPISchema, OpenAPIV3xDocument } from "@gitbook/openapi-parser";
+
+//#region src/schemas/resolveOpenAPISchemas.d.ts
+
 /**
  * Resolve an OpenAPI schemas from a file and compile it to a more usable format.
  * Schemas are extracted from the OpenAPI components.schemas
  */
-export declare function resolveOpenAPISchemas(filesystem: Filesystem<OpenAPIV3xDocument>, options: {
-    schemas: string[];
+declare function resolveOpenAPISchemas(filesystem: Filesystem<OpenAPIV3xDocument>, options: {
+  schemas: string[];
 }): Promise<{
-    schemas: OpenAPISchema[];
+  schemas: OpenAPISchema[];
 } | null>;
+//#endregion
+export { resolveOpenAPISchemas };

package/dist/schemas/resolveOpenAPISchemas.js

@@ -1,61 +1,17 @@
-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 };
-    }
-};
-import { filterSelectedOpenAPISchemas } from '@gitbook/openapi-parser';
-import { dereferenceFilesystem } from '../dereference';
+import { dereferenceFilesystem } from "../dereference.js";
+import { filterSelectedOpenAPISchemas } from "@gitbook/openapi-parser";
+
+//#region src/schemas/resolveOpenAPISchemas.ts
 /**
- * Resolve an OpenAPI schemas from a file and compile it to a more usable format.
- * Schemas are extracted from the OpenAPI components.schemas
- */
-export function resolveOpenAPISchemas(filesystem, options) {
-    return __awaiter(this, void 0, void 0, function () {
-        var selectedSchemas, schema, schemas;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    selectedSchemas = options.schemas;
-                    return [4 /*yield*/, dereferenceFilesystem(filesystem)];
-                case 1:
-                    schema = _a.sent();
-                    schemas = filterSelectedOpenAPISchemas(schema, selectedSchemas);
-                    if (schemas.length === 0) {
-                        return [2 /*return*/, null];
-                    }
-                    return [2 /*return*/, { schemas: schemas }];
-            }
-        });
-    });
+* Resolve an OpenAPI schemas from a file and compile it to a more usable format.
+* Schemas are extracted from the OpenAPI components.schemas
+*/
+async function resolveOpenAPISchemas(filesystem, options) {
+	const { schemas: selectedSchemas } = options;
+	const schemas = filterSelectedOpenAPISchemas(await dereferenceFilesystem(filesystem), selectedSchemas);
+	if (schemas.length === 0) return null;
+	return { schemas };
 }
+
+//#endregion
+export { resolveOpenAPISchemas };

package/dist/stringifyOpenAPI.js

@@ -1,15 +1,14 @@
+//#region src/stringifyOpenAPI.ts
 /**
- * Stringify an OpenAPI object. Same API as JSON.stringify.
- */
-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;
-    }, space);
+* Stringify an OpenAPI object. Same API as JSON.stringify.
+*/
+function stringifyOpenAPI(value, replacer, space) {
+	return JSON.stringify(value, (key, value$1) => {
+		if (key.startsWith("x-gitbook-")) return;
+		if (replacer) return replacer(key, value$1);
+		return value$1;
+	}, space);
 }
+
+//#endregion
+export { stringifyOpenAPI };

package/dist/translate.js

@@ -0,0 +1,43 @@
+import React from "react";
+
+//#region src/translate.tsx
+/**
+* Translate a string.
+*/
+function t(translation, id, ...args) {
+	const string = translation[id];
+	if (!string) throw new Error(`Translation not found for "${id}"`);
+	const parts = [];
+	let currentStringToReplace = string;
+	args.forEach((arg, i) => {
+		if (typeof arg === "string") currentStringToReplace = currentStringToReplace.replace(`\${${i + 1}}`, arg);
+		else {
+			const [partToPush, partToReplace] = currentStringToReplace.split(`\${${i + 1}}`);
+			if (partToPush === void 0 || partToReplace === void 0) throw new Error(`Invalid translation "${id}"`);
+			parts.push(<React.Fragment key={`string-${i}`}>{partToPush}</React.Fragment>);
+			parts.push(<React.Fragment key={`arg-${i}`}>{arg}</React.Fragment>);
+			currentStringToReplace = partToReplace;
+		}
+	});
+	if (!parts.length) return currentStringToReplace;
+	return <>
+            {parts}
+            {currentStringToReplace}
+        </>;
+}
+/**
+* Version of `t` that returns a string.
+*/
+function tString(translation, id, ...args) {
+	return reactToString(t(translation, id, ...args));
+}
+function reactToString(el) {
+	if (typeof el === "string" || typeof el === "number" || typeof el === "boolean") return `${el}`;
+	if (el === null || el === void 0) 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 ${typeof el}`);
+}
+
+//#endregion
+export { t, tString };

package/dist/translations/de.js

@@ -1,43 +1,48 @@
-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: 'Header',
-    header: 'Header',
-    authorizations: 'Autorisierungen',
-    responses: 'Antworten',
-    response: 'Antwort',
-    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: 'Zeige ${1}',
-    hide: 'Verstecke ${1}',
-    available_items: 'Verfügbare Elemente',
-    available_scopes: 'Verfügbare scopes',
-    properties: 'Eigenschaften',
-    or: 'oder',
-    and: 'und',
-    possible_values: 'Mögliche Werte',
+//#region src/translations/de.ts
+const 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",
+	discriminator: "Diskriminator",
+	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: "Header",
+	header: "Header",
+	authorizations: "Autorisierungen",
+	responses: "Antworten",
+	response: "Antwort",
+	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: "Zeige ${1}",
+	hide: "Verstecke ${1}",
+	available_items: "Verfügbare Elemente",
+	required_scopes: "Erforderliche Scopes",
+	properties: "Eigenschaften",
+	or: "oder",
+	and: "und",
+	possible_values: "Mögliche Werte"
 };
+
+//#endregion
+export { de };

package/dist/translations/en.d.ts

@@ -1,43 +1,47 @@
-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;
-    header: string;
-    authorizations: string;
-    responses: string;
-    response: 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;
-    available_scopes: string;
-    possible_values: string;
-    properties: string;
-    or: string;
-    and: string;
+//#region src/translations/en.d.ts
+declare const en: {
+  required: string;
+  deprecated: string;
+  deprecated_and_sunset_on: string;
+  stability_experimental: string;
+  stability_alpha: string;
+  stability_beta: string;
+  discriminator: 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;
+  header: string;
+  authorizations: string;
+  responses: string;
+  response: 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;
+  required_scopes: string;
+  possible_values: string;
+  properties: string;
+  or: string;
+  and: string;
 };
+//#endregion
+export { en };

package/dist/translations/en.js

@@ -1,43 +1,48 @@
-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',
-    header: 'Header',
-    authorizations: 'Authorizations',
-    responses: 'Responses',
-    response: 'Response',
-    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 ${1}',
-    hide: 'Hide ${1}',
-    available_items: 'Available items',
-    available_scopes: 'Available scopes',
-    possible_values: 'Possible values',
-    properties: 'Properties',
-    or: 'or',
-    and: 'and',
+//#region src/translations/en.ts
+const 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",
+	discriminator: "Discriminator",
+	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",
+	header: "Header",
+	authorizations: "Authorizations",
+	responses: "Responses",
+	response: "Response",
+	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 ${1}",
+	hide: "Hide ${1}",
+	available_items: "Available items",
+	required_scopes: "Required scopes",
+	possible_values: "Possible values",
+	properties: "Properties",
+	or: "or",
+	and: "and"
 };
+
+//#endregion
+export { en };

package/dist/translations/es.js

@@ -1,43 +1,48 @@
-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: 'Headers',
-    header: 'Header',
-    authorizations: 'Autorizaciones',
-    responses: 'Respuestas',
-    response: 'Respuesta',
-    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 ${1}',
-    hide: 'Ocultar ${1}',
-    available_items: 'Elementos disponibles',
-    available_scopes: 'Scopes disponibles',
-    properties: 'Propiedades',
-    or: 'o',
-    and: 'y',
-    possible_values: 'Valores posibles',
+//#region src/translations/es.ts
+const 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",
+	discriminator: "Discriminador",
+	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: "Headers",
+	header: "Header",
+	authorizations: "Autorizaciones",
+	responses: "Respuestas",
+	response: "Respuesta",
+	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 ${1}",
+	hide: "Ocultar ${1}",
+	available_items: "Elementos disponibles",
+	required_scopes: "Scopes requeridos",
+	properties: "Propiedades",
+	or: "o",
+	and: "y",
+	possible_values: "Valores posibles"
 };
+
+//#endregion
+export { es };