@gitbook/react-openapi 1.5.1 → 1.5.3

package/dist/json2xml.js

@@ -0,0 +1,12 @@
+import { jsXml } from "json-xml-parse";
+
+//#region src/json2xml.ts
+/**
+* This function converts an object to XML.
+*/
+function json2xml(data) {
+	return jsXml.toXmlString(data, { beautify: true });
+}
+
+//#endregion
+export { json2xml };

package/dist/resolveOpenAPIOperation.d.ts

@@ -0,0 +1,15 @@
+import { OpenAPIOperationData } from "./types.js";
+import { Filesystem, OpenAPIV3xDocument } from "@gitbook/openapi-parser";
+import "flatted";
+
+//#region src/resolveOpenAPIOperation.d.ts
+
+/**
+ * Resolve an OpenAPI operation in a file and compile it to a more usable format.
+ */
+declare function resolveOpenAPIOperation(filesystem: Filesystem<OpenAPIV3xDocument>, operationDescriptor: {
+  path: string;
+  method: string;
+}): Promise<OpenAPIOperationData | null>;
+//#endregion
+export { resolveOpenAPIOperation };

package/dist/resolveOpenAPIOperation.js

@@ -0,0 +1,105 @@
+import { checkIsReference } from "./utils.js";
+import { dereferenceFilesystem } from "./dereference.js";
+import "flatted";
+
+//#region src/resolveOpenAPIOperation.ts
+/**
+* Resolve an OpenAPI operation in a file and compile it to a more usable format.
+*/
+async function resolveOpenAPIOperation(filesystem, operationDescriptor) {
+	const { path, method } = operationDescriptor;
+	const schema = await dereferenceFilesystem(filesystem);
+	let operation = getOperationByPathAndMethod(schema, path, method);
+	if (!operation) return null;
+	const commonParameters = getPathObjectParameter(schema, path);
+	if (commonParameters) operation = {
+		...operation,
+		parameters: [...commonParameters, ...operation.parameters ?? []]
+	};
+	const servers = "servers" in schema ? schema.servers ?? [] : [];
+	const schemaSecurity = Array.isArray(schema.security) ? schema.security : schema.security ? [schema.security] : [];
+	const security = operation.security ?? schemaSecurity;
+	const isOptionalSecurity = security.some((entry) => Object.keys(entry).length === 0);
+	const flatSecurities = flattenSecurities(security);
+	const securities = [];
+	for (const entry of flatSecurities) {
+		const [securityKey, operationScopes] = Object.entries(entry)[0] ?? [];
+		if (securityKey) {
+			const securityScheme = schema.components?.securitySchemes?.[securityKey];
+			const scopes = resolveSecurityScopes({
+				securityScheme,
+				operationScopes
+			});
+			securities.push([securityKey, {
+				...securityScheme,
+				required: !isOptionalSecurity,
+				scopes
+			}]);
+		}
+	}
+	return {
+		servers,
+		operation: {
+			...operation,
+			security
+		},
+		method,
+		path,
+		securities,
+		"x-codeSamples": typeof schema["x-codeSamples"] === "boolean" ? schema["x-codeSamples"] : void 0,
+		"x-hideTryItPanel": typeof schema["x-hideTryItPanel"] === "boolean" ? schema["x-hideTryItPanel"] : void 0
+	};
+}
+/**
+* Get a path object from its path.
+*/
+function getPathObject(schema, path) {
+	return schema.paths?.[path] || null;
+}
+/**
+* Resolve parameters from a path in an OpenAPI schema.
+*/
+function getPathObjectParameter(schema, path) {
+	const pathObject = getPathObject(schema, path);
+	if (pathObject?.parameters) return pathObject.parameters;
+	return null;
+}
+/**
+* Get an operation by its path and method.
+*/
+function getOperationByPathAndMethod(schema, path, method) {
+	const pathObject = getPathObject(schema, path);
+	if (!pathObject) return null;
+	const normalizedMethod = method.toLowerCase();
+	if (!pathObject[normalizedMethod]) return null;
+	return pathObject[normalizedMethod];
+}
+/**
+* Flatten security objects in case they are nested.
+* @example [{bearerAuth:[], basicAuth:[]}] => [{ bearerAuth: [] }, { basicAuth: [] }]
+*/
+function flattenSecurities(security) {
+	if (!Array.isArray(security) || security.length === 0) return [];
+	return security.flatMap((securityObject) => {
+		return Object.entries(securityObject).map(([authType, config]) => ({ [authType]: config }));
+	});
+}
+/**
+* Resolve the scopes for a security scheme.
+*/
+function resolveSecurityScopes({ securityScheme, operationScopes }) {
+	if (!operationScopes?.length || !securityScheme || checkIsReference(securityScheme)) return null;
+	if (isOAuthSecurityScheme(securityScheme)) return (securityScheme.flows ? Object.entries(securityScheme.flows) : []).flatMap(([_, flow]) => {
+		return Object.entries(flow.scopes ?? {}).filter(([scope]) => operationScopes.includes(scope));
+	});
+	return operationScopes.map((scope) => [scope, void 0]);
+}
+/**
+* Check if a security scheme is an OAuth or OpenID Connect security scheme.
+*/
+function isOAuthSecurityScheme(securityScheme) {
+	return securityScheme.type === "oauth2";
+}
+
+//#endregion
+export { resolveOpenAPIOperation };

package/dist/resolveOpenAPIWebhook.d.ts

@@ -0,0 +1,15 @@
+import { OpenAPIWebhookData } from "./types.js";
+import { Filesystem, OpenAPIV3xDocument } from "@gitbook/openapi-parser";
+import "flatted";
+
+//#region src/resolveOpenAPIWebhook.d.ts
+
+/**
+ * Resolve an OpenAPI webhook in a file and compile it to a more usable format.
+ */
+declare function resolveOpenAPIWebhook(filesystem: Filesystem<OpenAPIV3xDocument>, webhookDescriptor: {
+  name: string;
+  method: string;
+}): Promise<OpenAPIWebhookData | null>;
+//#endregion
+export { resolveOpenAPIWebhook };

package/dist/resolveOpenAPIWebhook.js

@@ -0,0 +1,52 @@
+import { dereferenceFilesystem } from "./dereference.js";
+import "flatted";
+
+//#region src/resolveOpenAPIWebhook.ts
+/**
+* Resolve an OpenAPI webhook in a file and compile it to a more usable format.
+*/
+async function resolveOpenAPIWebhook(filesystem, webhookDescriptor) {
+	const { name, method } = webhookDescriptor;
+	const schema = await dereferenceFilesystem(filesystem);
+	let operation = getWebhookByNameAndMethod(schema, name, method);
+	if (!operation) return null;
+	const commonParameters = getPathObjectParameter(schema, name);
+	if (commonParameters) operation = {
+		...operation,
+		parameters: [...commonParameters, ...operation.parameters ?? []]
+	};
+	return {
+		servers: "servers" in schema ? schema.servers ?? [] : [],
+		operation,
+		method,
+		name
+	};
+}
+/**
+* Get a path object from its path.
+*/
+function getPathObject(schema, name) {
+	if (schema.webhooks?.[name]) return schema.webhooks[name];
+	return null;
+}
+/**
+* Resolve parameters from a path in an OpenAPI schema.
+*/
+function getPathObjectParameter(schema, path) {
+	const pathObject = getPathObject(schema, path);
+	if (pathObject?.parameters) return pathObject.parameters;
+	return null;
+}
+/**
+* Get an operation by its path and method.
+*/
+function getWebhookByNameAndMethod(schema, name, method) {
+	const pathObject = getPathObject(schema, name);
+	if (!pathObject) return null;
+	const normalizedMethod = method.toLowerCase();
+	if (!pathObject[normalizedMethod]) return null;
+	return pathObject[normalizedMethod];
+}
+
+//#endregion
+export { resolveOpenAPIWebhook };

package/dist/schemas/OpenAPISchemaItem.js

@@ -0,0 +1,26 @@
+'use client';
+
+
+import { OpenAPIDisclosure } from "../OpenAPIDisclosure.js";
+import { getDisclosureLabel } from "../getDisclosureLabel.js";
+import { OpenAPIRootSchema } from "../OpenAPISchemaServer.js";
+import { Section, SectionBody } from "../StaticSection.js";
+
+//#region src/schemas/OpenAPISchemaItem.tsx
+function OpenAPISchemaItem(props) {
+	const { schema, context, name } = props;
+	return <OpenAPIDisclosure className="openapi-schemas-disclosure" key={name} icon={context.icons.plus} header={name} label={(isExpanded) => getDisclosureLabel({
+		schema,
+		isExpanded,
+		context
+	})}>
+            <Section className="openapi-section-schemas">
+                <SectionBody>
+                    <OpenAPIRootSchema schema={schema} context={context} />
+                </SectionBody>
+            </Section>
+        </OpenAPIDisclosure>;
+}
+
+//#endregion
+export { OpenAPISchemaItem };

package/dist/schemas/OpenAPISchemas.d.ts

@@ -0,0 +1,19 @@
+import { OpenAPIContextInput } from "../context.js";
+import * as react2 from "react";
+import { OpenAPISchema } from "@gitbook/openapi-parser";
+
+//#region src/schemas/OpenAPISchemas.d.ts
+/**
+ * OpenAPI Schemas component.
+ */
+declare function OpenAPISchemas(props: {
+  className?: string;
+  schemas: OpenAPISchema[];
+  context: OpenAPIContextInput;
+  /**
+   * Whether to show the schema directly if there is only one.
+   */
+  grouped?: boolean;
+}): react2.JSX.Element | null;
+//#endregion
+export { OpenAPISchemas };

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

@@ -0,0 +1,15 @@
+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
+ */
+declare function resolveOpenAPISchemas(filesystem: Filesystem<OpenAPIV3xDocument>, options: {
+  schemas: string[];
+}): Promise<{
+  schemas: OpenAPISchema[];
+} | null>;
+//#endregion
+export { resolveOpenAPISchemas };

package/dist/schemas/resolveOpenAPISchemas.js

@@ -0,0 +1,17 @@
+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
+*/
+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

@@ -0,0 +1,14 @@
+//#region src/stringifyOpenAPI.ts
+/**
+* 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, { isValidElement } 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 (isValidElement(el)) return el.props.children.map(reactToString).join("");
+	throw new Error(`Unsupported type ${typeof el}`);
+}
+
+//#endregion
+export { t, tString };

package/dist/translations/de.js

@@ -0,0 +1,50 @@
+//#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",
+	required_scopes_description: "Dieser Endpunkt erfordert die folgenden Scopes:",
+	available_scopes: "Verfügbare Scopes:",
+	properties: "Eigenschaften",
+	or: "oder",
+	and: "und",
+	possible_values: "Mögliche Werte"
+};
+
+//#endregion
+export { de };

package/dist/translations/en.d.ts

@@ -0,0 +1,49 @@
+//#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;
+  required_scopes_description: string;
+  available_scopes: string;
+  possible_values: string;
+  properties: string;
+  or: string;
+  and: string;
+};
+//#endregion
+export { en };

package/dist/translations/en.js

@@ -0,0 +1,50 @@
+//#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",
+	required_scopes_description: "This endpoint requires the following scopes:",
+	available_scopes: "Available scopes:",
+	possible_values: "Possible values",
+	properties: "Properties",
+	or: "or",
+	and: "and"
+};
+
+//#endregion
+export { en };

package/dist/translations/es.js

@@ -0,0 +1,50 @@
+//#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",
+	required_scopes_description: "Este endpoint requiere los siguientes scopes:",
+	available_scopes: "Scopes disponibles:",
+	properties: "Propiedades",
+	or: "o",
+	and: "y",
+	possible_values: "Valores posibles"
+};
+
+//#endregion
+export { es };

package/dist/translations/fr.js

@@ -0,0 +1,50 @@
+//#region src/translations/fr.ts
+const 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",
+	discriminator: "Discriminateur",
+	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: "Headers",
+	header: "Header",
+	authorizations: "Autorisations",
+	responses: "Réponses",
+	response: "Réponse",
+	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 ${1}",
+	hide: "Masquer ${1}",
+	available_items: "Éléments disponibles",
+	required_scopes: "Scopes requis",
+	required_scopes_description: "Cet endpoint nécessite les scopes suivants:",
+	available_scopes: "Scopes disponibles:",
+	properties: "Propriétés",
+	or: "ou",
+	and: "et",
+	possible_values: "Valeurs possibles"
+};
+
+//#endregion
+export { fr };