@gitbook/react-openapi 1.1.9 → 1.2.0

package/src/translations/index.ts

@@ -0,0 +1,33 @@
+import { de } from './de';
+import { en } from './en';
+import { es } from './es';
+import { fr } from './fr';
+import { ja } from './ja';
+import { nl } from './nl';
+import { no } from './no';
+import { pt_br } from './pt-br';
+import type { Translation } from './types';
+import { zh } from './zh';
+
+export * from './types';
+
+export const translations = {
+    en,
+    de,
+    es,
+    fr,
+    ja,
+    nl,
+    no,
+    'pt-br': pt_br,
+    zh,
+} satisfies Record<string, Translation>;
+
+export type TranslationLocale = keyof typeof translations;
+
+/**
+ * Check if the locale is valid.
+ */
+export function checkIsValidLocale(locale: string): locale is TranslationLocale {
+    return Object.prototype.hasOwnProperty.call(translations, locale);
+}

package/src/translations/ja.ts

@@ -0,0 +1,37 @@
+export const ja = {
+    required: '必須',
+    deprecated: '非推奨',
+    deprecated_and_sunset_on: 'この操作は非推奨であり、${1}に廃止されます。',
+    stability_experimental: '実験的',
+    stability_alpha: 'アルファ',
+    stability_beta: 'ベータ',
+    copy_to_clipboard: 'クリップボードにコピー',
+    copied: 'コピー済み',
+    no_content: 'コンテンツなし',
+    unresolved_reference: '未解決の参照',
+    circular_reference: '循環参照',
+    read_only: '読み取り専用',
+    write_only: '書き込み専用',
+    optional: 'オプション',
+    min: '最小',
+    max: '最大',
+    nullable: 'ヌル許容',
+    body: '本文',
+    payload: 'ペイロード',
+    headers: 'ヘッダー',
+    authorizations: '認可',
+    responses: 'レスポンス',
+    path_parameters: 'パスパラメータ',
+    query_parameters: 'クエリパラメータ',
+    header_parameters: 'ヘッダーパラメータ',
+    attributes: '属性',
+    test_it: 'テストする',
+    information: '情報',
+    success: '成功',
+    redirect: 'リダイレクト',
+    error: 'エラー',
+    show: '表示',
+    hide: '非表示',
+    available_items: '利用可能なアイテム',
+    child_attributes: '子属性',
+};

package/src/translations/nl.ts

@@ -0,0 +1,37 @@
+export const nl = {
+    required: 'Vereist',
+    deprecated: 'Verouderd',
+    deprecated_and_sunset_on: 'Deze bewerking is verouderd en wordt op ${1} beëindigd.',
+    stability_experimental: 'Experimenteel',
+    stability_alpha: 'Alfa',
+    stability_beta: 'Bèta',
+    copy_to_clipboard: 'Kopiëren naar klembord',
+    copied: 'Gekopieerd',
+    no_content: 'Geen inhoud',
+    unresolved_reference: 'Onopgeloste verwijzing',
+    circular_reference: 'Circulaire verwijzing',
+    read_only: 'Alleen lezen',
+    write_only: 'Alleen schrijven',
+    optional: 'Optioneel',
+    min: 'Min',
+    max: 'Max',
+    nullable: 'Null toegestaan',
+    body: 'Body',
+    payload: 'Payload',
+    headers: 'Headers',
+    authorizations: 'Autorisaties',
+    responses: 'Reacties',
+    path_parameters: 'Padparameters',
+    query_parameters: 'Queryparameters',
+    header_parameters: 'Headerparameters',
+    attributes: 'Attributen',
+    test_it: 'Test het',
+    information: 'Informatie',
+    success: 'Succes',
+    redirect: 'Omleiding',
+    error: 'Fout',
+    show: 'Toon',
+    hide: 'Verbergen',
+    available_items: 'Beschikbare items',
+    child_attributes: 'Kindattributen',
+};

package/src/translations/no.ts

@@ -0,0 +1,37 @@
+export const no = {
+    required: 'Påkrevd',
+    deprecated: 'Foreldet',
+    deprecated_and_sunset_on: 'Denne operasjonen er foreldet og vil bli avviklet den ${1}.',
+    stability_experimental: 'Eksperimentell',
+    stability_alpha: 'Alfa',
+    stability_beta: 'Beta',
+    copy_to_clipboard: 'Kopier til utklippstavle',
+    copied: 'Kopiert',
+    no_content: 'Ingen innhold',
+    unresolved_reference: 'Uavklart referanse',
+    circular_reference: 'Sirkulær referanse',
+    read_only: 'Skrivebeskyttet',
+    write_only: 'Kun skriving',
+    optional: 'Valgfri',
+    min: 'Min',
+    max: 'Maks',
+    nullable: 'Kan være null',
+    body: 'Brødtekst',
+    payload: 'Nyttelast',
+    headers: 'Overskrifter',
+    authorizations: 'Autorisasjoner',
+    responses: 'Responser',
+    path_parameters: 'Sti-parametere',
+    query_parameters: 'Forespørselsparametere',
+    header_parameters: 'Header-parametere',
+    attributes: 'Attributter',
+    test_it: 'Test det',
+    information: 'Informasjon',
+    success: 'Suksess',
+    redirect: 'Viderekobling',
+    error: 'Feil',
+    show: 'Vis',
+    hide: 'Skjul',
+    available_items: 'Tilgjengelige elementer',
+    child_attributes: 'Barneattributter',
+};

package/src/translations/pt-br.ts

@@ -0,0 +1,37 @@
+export const pt_br = {
+    required: 'Obrigatório',
+    deprecated: 'Obsoleto',
+    deprecated_and_sunset_on: 'Esta operação está obsoleta e será descontinuada em ${1}.',
+    stability_experimental: 'Experimental',
+    stability_alpha: 'Alfa',
+    stability_beta: 'Beta',
+    copy_to_clipboard: 'Copiar para a área de transferência',
+    copied: 'Copiado',
+    no_content: 'Sem conteúdo',
+    unresolved_reference: 'Referência não resolvida',
+    circular_reference: 'Referência circular',
+    read_only: 'Somente leitura',
+    write_only: 'Somente escrita',
+    optional: 'Opcional',
+    min: 'Mín',
+    max: 'Máx',
+    nullable: 'Nulo',
+    body: 'Corpo',
+    payload: 'Carga útil',
+    headers: 'Cabeçalhos',
+    authorizations: 'Autorizações',
+    responses: 'Respostas',
+    path_parameters: 'Parâmetros de rota',
+    query_parameters: 'Parâmetros de consulta',
+    header_parameters: 'Parâmetros de cabeçalho',
+    attributes: 'Atributos',
+    test_it: 'Testar',
+    information: 'Informação',
+    success: 'Sucesso',
+    redirect: 'Redirecionamento',
+    error: 'Erro',
+    show: 'Mostrar',
+    hide: 'Ocultar',
+    available_items: 'Itens disponíveis',
+    child_attributes: 'Atributos filhos',
+};

package/src/translations/types.ts

@@ -0,0 +1,7 @@
+import type { en } from './en';
+
+export type TranslationKey = keyof typeof en;
+
+export type Translation = {
+    [key in TranslationKey]: string;
+};

package/src/translations/zh.ts

@@ -0,0 +1,37 @@
+export const zh = {
+    required: '必填',
+    deprecated: '已弃用',
+    deprecated_and_sunset_on: '此操作已弃用，将于 ${1} 停止使用。',
+    stability_experimental: '实验性',
+    stability_alpha: 'Alpha',
+    stability_beta: 'Beta',
+    copy_to_clipboard: '复制到剪贴板',
+    copied: '已复制',
+    no_content: '无内容',
+    unresolved_reference: '未解析的引用',
+    circular_reference: '循环引用',
+    read_only: '只读',
+    write_only: '只写',
+    optional: '可选',
+    min: '最小值',
+    max: '最大值',
+    nullable: '可为 null',
+    body: '请求体',
+    payload: '有效载荷',
+    headers: '头部信息',
+    authorizations: '授权',
+    responses: '响应',
+    path_parameters: '路径参数',
+    query_parameters: '查询参数',
+    header_parameters: '头参数',
+    attributes: '属性',
+    test_it: '测试一下',
+    information: '信息',
+    success: '成功',
+    redirect: '重定向',
+    error: '错误',
+    show: '显示',
+    hide: '隐藏',
+    available_items: '可用项',
+    child_attributes: '子属性',
+};

package/src/types.ts

@@ -1,51 +1,10 @@
 import type {
     OpenAPICustomOperationProperties,
     OpenAPICustomSpecProperties,
-    OpenAPISchema,
     OpenAPIV3,
 } from '@gitbook/openapi-parser';
 
-export interface OpenAPIContextProps extends OpenAPIClientContext {
-    /**
-     * Render a code block.
-     */
-    renderCodeBlock: (props: { code: string; syntax: string }) => React.ReactNode;
-    /**
-     * Render the heading of the operation.
-     */
-    renderHeading: (props: {
-        deprecated: boolean;
-        title: string;
-        stability?: string;
-    }) => React.ReactNode;
-    /**
-     * Render the document of the operation.
-     */
-    renderDocument: (props: { document: object }) => React.ReactNode;
-
-    /** Spec url for the Scalar Api Client */
-    specUrl: string;
-}
-
-export interface OpenAPIClientContext {
-    icons: {
-        chevronDown: React.ReactNode;
-        chevronRight: React.ReactNode;
-        plus: React.ReactNode;
-    };
-
-    /**
-     * Force all sections to be opened by default.
-     * @default false
-     */
-    defaultInteractiveOpened?: boolean;
-    /**
-     * The key of the block
-     */
-    blockKey?: string;
-    /** Optional id attached to the OpenAPI Operation heading and used as an anchor */
-    id?: string;
-}
+export type OpenAPISecurityWithRequired = OpenAPIV3.SecuritySchemeObject & { required?: boolean };
 
 export interface OpenAPIOperationData extends OpenAPICustomSpecProperties {
     path: string;
@@ -58,10 +17,16 @@ export interface OpenAPIOperationData extends OpenAPICustomSpecProperties {
     operation: OpenAPIV3.OperationObject<OpenAPICustomOperationProperties>;
 
     /** Securities that should be used for this operation */
-    securities: [string, OpenAPIV3.SecuritySchemeObject][];
+    securities: [string, OpenAPISecurityWithRequired][];
 }
 
-export interface OpenAPISchemasData {
-    /** Components schemas to be used for schemas */
-    schemas: OpenAPISchema[];
+export interface OpenAPIWebhookData extends OpenAPICustomSpecProperties {
+    name: string;
+    method: string;
+
+    /** Servers to be used for this operation */
+    servers: OpenAPIV3.ServerObject[];
+
+    /** Spec of the webhook */
+    operation: OpenAPIV3.OperationObject<OpenAPICustomOperationProperties>;
 }

package/src/util/example.tsx

@@ -0,0 +1,129 @@
+import type { OpenAPIV3 } from '@gitbook/openapi-parser';
+import { OpenAPIExample } from '../OpenAPIExample';
+import type { OpenAPIContext } from '../context';
+import { generateSchemaExample } from '../generateSchemaExample';
+import { tString } from '../translate';
+import { checkIsReference } from '../utils';
+
+/**
+ * Generate an example from a reference object.
+ */
+export function getExampleFromReference(
+    ref: OpenAPIV3.ReferenceObject,
+    context: OpenAPIContext
+): OpenAPIV3.ExampleObject {
+    return {
+        summary: tString(context.translation, 'unresolved_reference'),
+        value: { $ref: ref.$ref },
+    };
+}
+
+/**
+ * Get examples from a media type object.
+ */
+export function getExamplesFromMediaTypeObject(args: {
+    mediaType: string;
+    mediaTypeObject: OpenAPIV3.MediaTypeObject;
+    context: OpenAPIContext;
+}): { key: string; example: OpenAPIV3.ExampleObject }[] {
+    const { mediaTypeObject, mediaType, context } = args;
+    if (mediaTypeObject.examples) {
+        return Object.entries(mediaTypeObject.examples).map(([key, example]) => {
+            return {
+                key,
+                example: checkIsReference(example)
+                    ? getExampleFromReference(example, context)
+                    : example,
+            };
+        });
+    }
+
+    if (mediaTypeObject.example) {
+        return [{ key: 'default', example: { value: mediaTypeObject.example } }];
+    }
+
+    if (mediaTypeObject.schema) {
+        if (mediaType === 'application/xml') {
+            // @TODO normally we should use the name of the schema but we don't have it
+            // fix it when we got the reference name
+            const root = mediaTypeObject.schema.xml?.name ?? 'object';
+            return [
+                {
+                    key: 'default',
+                    example: {
+                        value: {
+                            [root]: generateSchemaExample(mediaTypeObject.schema, {
+                                xml: mediaType === 'application/xml',
+                                mode: 'read',
+                            }),
+                        },
+                    },
+                },
+            ];
+        }
+        return [
+            {
+                key: 'default',
+                example: {
+                    value: generateSchemaExample(mediaTypeObject.schema, {
+                        mode: 'read',
+                    }),
+                },
+            },
+        ];
+    }
+    return [];
+}
+
+/**
+ * Get example from a schema object.
+ */
+export function getExampleFromSchema(args: {
+    schema: OpenAPIV3.SchemaObject;
+}): OpenAPIV3.ExampleObject {
+    const { schema } = args;
+
+    if (schema.example) {
+        return { value: schema.example };
+    }
+
+    return { value: generateSchemaExample(schema, { mode: 'read' }) };
+}
+
+/**
+ * Get the examples from a media type object.
+ */
+export function getExamples(props: {
+    mediaTypeObject: OpenAPIV3.MediaTypeObject;
+    mediaType: string;
+    context: OpenAPIContext;
+}) {
+    const { mediaTypeObject, mediaType, context } = props;
+    const examples = getExamplesFromMediaTypeObject({ mediaTypeObject, mediaType, context });
+    const syntax = getSyntaxFromMediaType(mediaType);
+
+    return examples.map((example) => {
+        return {
+            key: example.key,
+            label: example.example.summary || example.key,
+            body: (
+                <OpenAPIExample example={example.example} context={props.context} syntax={syntax} />
+            ),
+        };
+    });
+}
+
+/**
+ * Get the syntax from a media type.
+ */
+function getSyntaxFromMediaType(mediaType: string): string {
+    if (mediaType.includes('json')) {
+        return 'json';
+    }
+
+    if (mediaType === 'application/xml') {
+        return 'xml';
+    }
+
+    return 'text';
+}

package/src/utils.ts

@@ -1,5 +1,7 @@
 import type { AnyObject, OpenAPIV3, OpenAPIV3_1 } from '@gitbook/openapi-parser';
+import type { OpenAPIUniversalContext } from './context';
 import { stringifyOpenAPI } from './stringifyOpenAPI';
+import { tString } from './translate';
 
 export function checkIsReference(input: unknown): input is OpenAPIV3.ReferenceObject {
     return typeof input === 'object' && !!input && '$ref' in input;
@@ -149,3 +151,68 @@ function shouldDisplayExample(schema: OpenAPIV3.SchemaObject): boolean {
             Object.keys(schema.example).length > 0)
     );
 }
+
+/**
+ * Get the class name for a status code.
+ * 1xx: informational
+ * 2xx: success
+ * 3xx: redirect
+ * 4xx, 5xx: error
+ */
+export function getStatusCodeClassName(statusCode: number | string): string {
+    const category = getStatusCodeCategory(statusCode);
+    switch (category) {
+        case 1:
+            return 'informational';
+        case 2:
+            return 'success';
+        case 3:
+            return 'redirect';
+        case 4:
+        case 5:
+            return 'error';
+        default:
+            return 'unknown';
+    }
+}
+
+/**
+ * Get a default label for a status code.
+ * This is used when there is no label provided in the OpenAPI spec.
+ * 1xx: Information
+ * 2xx: Success
+ * 3xx: Redirect
+ * 4xx, 5xx: Error
+ */
+export function getStatusCodeDefaultLabel(
+    statusCode: number | string,
+    context: OpenAPIUniversalContext
+): string {
+    const category = getStatusCodeCategory(statusCode);
+    switch (category) {
+        case 1:
+            return tString(context.translation, 'information');
+        case 2:
+            return tString(context.translation, 'success');
+        case 3:
+            return tString(context.translation, 'redirect');
+        case 4:
+        case 5:
+            return tString(context.translation, 'error');
+        default:
+            return '';
+    }
+}
+
+function getStatusCodeCategory(statusCode: number | string): number | string {
+    const code = typeof statusCode === 'string' ? Number.parseInt(statusCode, 10) : statusCode;
+
+    if (Number.isNaN(code) || code < 100 || code >= 600) {
+        return 'unknown';
+    }
+
+    // Determine the category of the status code based on the first digit
+    const category = Math.floor(code / 100);
+
+    return category;
+}

package/dist/useSyncedTabsGlobalState.d.ts

@@ -1,10 +0,0 @@
-type Key = string | number;
-type TabState = {
-    tabKey: Key | null;
-};
-type TabActions = {
-    setTabKey: (tab: Key | null) => void;
-};
-type TabStore = TabState & TabActions;
-export declare const getOrCreateTabStoreByKey: (storeKey: string, initialKey?: Key) => import("zustand").StoreApi<TabStore>;
-export {};

package/dist/useSyncedTabsGlobalState.js

@@ -1,20 +0,0 @@
-'use client';
-import { createStore } from 'zustand';
-var createTabStore = function (initialTab) {
-    return createStore()(function (set) { return ({
-        tabKey: initialTab !== null && initialTab !== void 0 ? initialTab : null,
-        setTabKey: function (tabKey) {
-            set(function () { return ({ tabKey: tabKey }); });
-        },
-    }); });
-};
-var defaultTabStores = new Map();
-var createTabStoreFactory = function (stores) {
-    return function (storeKey, initialKey) {
-        if (!stores.has(storeKey)) {
-            stores.set(storeKey, createTabStore(initialKey));
-        }
-        return stores.get(storeKey);
-    };
-};
-export var getOrCreateTabStoreByKey = createTabStoreFactory(defaultTabStores);

package/src/useSyncedTabsGlobalState.ts

@@ -1,35 +0,0 @@
-'use client';
-
-import { createStore } from 'zustand';
-
-type Key = string | number;
-
-type TabState = {
-    tabKey: Key | null;
-};
-
-type TabActions = { setTabKey: (tab: Key | null) => void };
-
-type TabStore = TabState & TabActions;
-
-const createTabStore = (initialTab?: Key) => {
-    return createStore<TabStore>()((set) => ({
-        tabKey: initialTab ?? null,
-        setTabKey: (tabKey) => {
-            set(() => ({ tabKey }));
-        },
-    }));
-};
-
-const defaultTabStores = new Map<string, ReturnType<typeof createTabStore>>();
-
-const createTabStoreFactory = (stores: typeof defaultTabStores) => {
-    return (storeKey: string, initialKey?: Key) => {
-        if (!stores.has(storeKey)) {
-            stores.set(storeKey, createTabStore(initialKey));
-        }
-        return stores.get(storeKey)!;
-    };
-};
-
-export const getOrCreateTabStoreByKey = createTabStoreFactory(defaultTabStores);