@gitbook/react-openapi 1.4.3 → 1.5.1

package/src/schemas/resolveOpenAPISchemas.test.ts

@@ -1,174 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-
-import { parseOpenAPI, traverse } from '@gitbook/openapi-parser';
-import { resolveOpenAPISchemas } from './resolveOpenAPISchemas';
-
-async function fetchFilesystem(url: string) {
-    const response = await fetch(url);
-    const text = await response.text();
-    const { filesystem } = await parseOpenAPI({ value: text, rootURL: url });
-    const transformedFs = await traverse(filesystem, async (node) => {
-        if ('description' in node && typeof node.description === 'string' && node.description) {
-            node['x-gitbook-description-html'] = node.description;
-        }
-        return node;
-    });
-    return transformedFs;
-}
-
-describe('#resolveOpenAPISchemas', () => {
-    it('should resolve refs', async () => {
-        const filesystem = await fetchFilesystem(
-            'https://petstore3.swagger.io/api/v3/openapi.json'
-        );
-        const resolved = await resolveOpenAPISchemas(filesystem, { schemas: ['Pet', 'Tag'] });
-
-        expect(resolved).toMatchObject({
-            schemas: [
-                {
-                    name: 'Pet',
-                    schema: {
-                        properties: {
-                            tags: {
-                                type: 'array',
-                                items: {
-                                    type: 'object',
-                                    properties: {
-                                        id: {
-                                            format: 'int64',
-                                            type: 'integer',
-                                        },
-                                        name: {
-                                            type: 'string',
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-                {
-                    name: 'Tag',
-                    schema: {
-                        type: 'object',
-                        properties: {
-                            id: {
-                                type: 'integer',
-                                format: 'int64',
-                            },
-                            name: {
-                                type: 'string',
-                            },
-                        },
-                        xml: {
-                            name: 'tag',
-                        },
-                    },
-                },
-            ],
-        });
-    });
-
-    it('should support yaml', async () => {
-        const filesystem = await fetchFilesystem(
-            'https://petstore3.swagger.io/api/v3/openapi.yaml'
-        );
-        const resolved = await resolveOpenAPISchemas(filesystem, { schemas: ['Pet'] });
-
-        expect(resolved).toMatchObject({
-            schemas: [
-                {
-                    name: 'Pet',
-                    schema: {
-                        properties: {
-                            tags: {
-                                type: 'array',
-                                items: {
-                                    properties: {
-                                        id: {
-                                            format: 'int64',
-                                            type: 'integer',
-                                        },
-                                        name: {
-                                            type: 'string',
-                                        },
-                                    },
-                                    type: 'object',
-                                },
-                            },
-                        },
-                    },
-                },
-            ],
-        });
-    });
-
-    it('should resolve circular refs', async () => {
-        const filesystem = await fetchFilesystem('https://api.gitbook.com/openapi.json');
-        const resolved = await resolveOpenAPISchemas(filesystem, {
-            schemas: ['DocumentBlockTabs'],
-        });
-
-        expect(resolved).toMatchObject({
-            schemas: [
-                {
-                    name: 'DocumentBlockTabs',
-                    schema: {
-                        type: 'object',
-                        properties: {
-                            object: {
-                                type: 'string',
-                                enum: ['block'],
-                            },
-                        },
-                    },
-                },
-            ],
-        });
-    });
-
-    it('should resolve to null if the schema does not exist', async () => {
-        const filesystem = await fetchFilesystem(
-            'https://petstore3.swagger.io/api/v3/openapi.json'
-        );
-        const resolved = await resolveOpenAPISchemas(filesystem, {
-            schemas: ['NonExistentSchema'],
-        });
-
-        expect(resolved).toBe(null);
-    });
-
-    it('should parse Swagger 2.0', async () => {
-        const filesystem = await fetchFilesystem('https://petstore.swagger.io/v2/swagger.json');
-        const resolved = await resolveOpenAPISchemas(filesystem, {
-            schemas: ['Pet'],
-        });
-
-        expect(resolved).toMatchObject({
-            schemas: [
-                {
-                    name: 'Pet',
-                    schema: {
-                        properties: {
-                            tags: {
-                                type: 'array',
-                                items: {
-                                    properties: {
-                                        id: {
-                                            format: 'int64',
-                                            type: 'integer',
-                                        },
-                                        name: {
-                                            type: 'string',
-                                        },
-                                    },
-                                    type: 'object',
-                                },
-                            },
-                        },
-                    },
-                },
-            ],
-        });
-    });
-});

package/src/schemas/resolveOpenAPISchemas.ts

@@ -1,28 +0,0 @@
-import type { Filesystem, OpenAPISchema, OpenAPIV3xDocument } from '@gitbook/openapi-parser';
-import { filterSelectedOpenAPISchemas } from '@gitbook/openapi-parser';
-import { dereferenceFilesystem } from '../dereference';
-
-/**
- * Resolve an OpenAPI schemas from a file and compile it to a more usable format.
- * Schemas are extracted from the OpenAPI components.schemas
- */
-export async function resolveOpenAPISchemas(
-    filesystem: Filesystem<OpenAPIV3xDocument>,
-    options: {
-        schemas: string[];
-    }
-): Promise<{
-    schemas: OpenAPISchema[];
-} | null> {
-    const { schemas: selectedSchemas } = options;
-
-    const schema = await dereferenceFilesystem(filesystem);
-
-    const schemas = filterSelectedOpenAPISchemas(schema, selectedSchemas);
-
-    if (schemas.length === 0) {
-        return null;
-    }
-
-    return { schemas };
-}

package/src/stringifyOpenAPI.ts

@@ -1,25 +0,0 @@
-/**
- * Stringify an OpenAPI object. Same API as JSON.stringify.
- */
-export function stringifyOpenAPI(
-    value: any,
-    replacer?: ((this: any, key: string, value: any) => any) | null,
-    space?: string | number
-): string {
-    return JSON.stringify(
-        value,
-        (key, value) => {
-            // Ignore internal keys
-            if (key.startsWith('x-gitbook-')) {
-                return undefined;
-            }
-
-            if (replacer) {
-                return replacer(key, value);
-            }
-
-            return value;
-        },
-        space
-    );
-}

package/src/translate.tsx

@@ -1,80 +0,0 @@
-import React from 'react';
-
-import type { Translation, TranslationKey } from './translations';
-
-/**
- * Translate a string.
- */
-export function t(
-    translation: Translation,
-    id: TranslationKey,
-    ...args: React.ReactNode[]
-): React.ReactNode {
-    const string = translation[id];
-    if (!string) {
-        throw new Error(`Translation not found for "${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)
-    const parts: React.ReactNode[] = [];
-    let currentStringToReplace: string = 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 === undefined || partToReplace === undefined) {
-                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.
- */
-export function tString(
-    translation: Translation,
-    id: TranslationKey,
-    ...args: React.ReactNode[]
-): string {
-    const result = t(translation, id, ...args);
-    return reactToString(result);
-}
-
-function reactToString(el: React.ReactNode): string {
-    if (typeof el === 'string' || typeof el === 'number' || typeof el === 'boolean') {
-        return `${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 ${typeof el}`);
-}

package/src/translations/de.ts

@@ -1,43 +0,0 @@
-export 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',
-    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',
-};

package/src/translations/en.ts

@@ -1,43 +0,0 @@
-export 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',
-    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',
-};

package/src/translations/es.ts

@@ -1,43 +0,0 @@
-export 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',
-    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',
-};

package/src/translations/fr.ts

@@ -1,43 +0,0 @@
-export 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',
-    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',
-    available_scopes: 'Scopes disponibles',
-    properties: 'Propriétés',
-    or: 'ou',
-    and: 'et',
-    possible_values: 'Valeurs possibles',
-};

package/src/translations/index.ts

@@ -1,33 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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: 'ヘッダー',
-    header: 'ヘッダー',
-    authorizations: '認可',
-    responses: 'レスポンス',
-    response: 'レスポンス',
-    path_parameters: 'パスパラメータ',
-    query_parameters: 'クエリパラメータ',
-    header_parameters: 'ヘッダーパラメータ',
-    attributes: '属性',
-    test_it: 'テストする',
-    information: '情報',
-    success: '成功',
-    redirect: 'リダイレクト',
-    error: 'エラー',
-    show: '${1}を表示',
-    hide: '${1}を非表示',
-    available_items: '利用可能なアイテム',
-    available_scopes: '利用可能なスコープ',
-    properties: 'プロパティ',
-    or: 'または',
-    and: 'かつ',
-    possible_values: '可能な値',
-};

package/src/translations/nl.ts

@@ -1,43 +0,0 @@
-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',
-    header: 'Header',
-    authorizations: 'Autorisaties',
-    responses: 'Reacties',
-    response: 'Reactie',
-    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 ${1}',
-    hide: 'Verberg ${1}',
-    available_items: 'Beschikbare items',
-    available_scopes: 'Beschikbare scopes',
-    properties: 'Eigenschappen',
-    or: 'of',
-    and: 'en',
-    possible_values: 'Mogelijke waarden',
-};

package/src/translations/no.ts

@@ -1,43 +0,0 @@
-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: 'Headers',
-    header: 'Header',
-    authorizations: 'Autorisasjoner',
-    responses: 'Responser',
-    response: 'Respons',
-    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 ${1}',
-    hide: 'Skjul ${1}',
-    available_items: 'Tilgjengelige elementer',
-    available_scopes: 'Tilgjengelige scopes',
-    properties: 'Egenskaper',
-    or: 'eller',
-    and: 'og',
-    possible_values: 'Mulige verdier',
-};