@redocly/openapi-docs 3.24.0 → 3.24.1

package/lib/components/SchemaCatalogLink/__tests__/SchemaCatalogLink.test.js

@@ -0,0 +1,95 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render, fireEvent } from '@testing-library/react';
+import * as Jotai from 'jotai';
+import { ClipboardService } from '@redocly/theme/core/openapi';
+import { SchemaCatalogLink } from '../SchemaCatalogLink.js';
+vi.mock('jotai', async () => ({
+    ...(await vi.importActual('jotai')),
+    useAtomValue: vi.fn(),
+}));
+vi.mock('../../../utils/dom', async () => ({
+    ...(await vi.importActual('../../../utils/dom')),
+    IS_BROWSER: true,
+}));
+vi.mock('@redocly/theme/core/openapi', async () => {
+    const actual = await vi.importActual('@redocly/theme/core/openapi');
+    const actualClipboard = actual.ClipboardService;
+    return {
+        ...actual,
+        ClipboardService: {
+            ...actualClipboard,
+            copyCustom: vi.fn(),
+        },
+    };
+});
+describe('SchemaCatalogLink', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.useFakeTimers();
+        Object.defineProperty(global, 'navigator', {
+            value: {
+                clipboard: {
+                    writeText: vi.fn(),
+                },
+            },
+            writable: true,
+        });
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    it('should render correctly', () => {
+        vi.spyOn(Jotai, 'useAtomValue').mockReturnValue({
+            parser: {
+                definition: {
+                    'x-schema-catalog-link': '/_bundle/test.yaml',
+                },
+            },
+        });
+        const result = render(_jsx(SchemaCatalogLink, { schemaRef: "#/components/schemas/test" }));
+        expect(result.baseElement).toMatchSnapshot();
+    });
+    it('should not render if x-schema-catalog-link is not defined', () => {
+        vi.spyOn(Jotai, 'useAtomValue').mockReturnValue({
+            parser: {
+                definition: {},
+            },
+        });
+        const result = render(_jsx(SchemaCatalogLink, { schemaRef: "#/components/schemas/test" }));
+        expect(result.baseElement).toMatchSnapshot();
+    });
+    it('should render correctly on server', async () => {
+        vi.doMock('../../../utils/dom', async () => ({
+            ...(await vi.importActual('../../../utils/dom')),
+            IS_BROWSER: vi.fn().mockReturnValue(false),
+        }));
+        vi.spyOn(Jotai, 'useAtomValue').mockReturnValue({
+            parser: {
+                definition: {
+                    'x-schema-catalog-link': '/_bundle/test.yaml',
+                },
+            },
+        });
+        const result = render(_jsx(SchemaCatalogLink, { schemaRef: "#/components/schemas/test" }));
+        expect(result.baseElement).toMatchSnapshot();
+    });
+    it('should copy link to clipboard when copy button is clicked', async () => {
+        vi.doMock('../../../utils/dom', async () => ({
+            ...(await vi.importActual('../../../utils/dom')),
+            IS_BROWSER: vi.fn().mockReturnValue(true),
+        }));
+        vi.spyOn(Jotai, 'useAtomValue').mockReturnValue({
+            parser: {
+                definition: {
+                    'x-schema-catalog-link': '/_bundle/test.yaml',
+                },
+            },
+        });
+        const result = render(_jsx(SchemaCatalogLink, { schemaRef: "#/components/schemas/test" }));
+        // Find the copy button by role
+        const copyButton = result.getByRole('button');
+        fireEvent.click(copyButton);
+        expect(ClipboardService.copyCustom).toHaveBeenCalled();
+    });
+});
+//# sourceMappingURL=SchemaCatalogLink.test.js.map

package/lib/components/Security/__tests__/Security.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/components/Security/__tests__/Security.test.js

@@ -0,0 +1,38 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { act, fireEvent, render } from '@testing-library/react';
+import { Security } from '../Security.js';
+vi.mock('jotai', async () => ({
+    ...(await vi.importActual('jotai')),
+    useAtomValue: vi.fn(() => ({ options: { hideSecuritySection: false } })),
+}));
+vi.mock('../SecurityModal', async () => ({
+    SecurityModal: vi.fn(() => _jsx("div", { children: "Mocked SecurityModal" })),
+}));
+describe('Security Component', () => {
+    it('should not renders SecurityButton initially when securities is empty', () => {
+        const { queryByText } = render(_jsx(Security, { securities: [] }));
+        expect(queryByText('Security')).not.toBeInTheDocument();
+    });
+    it('renders SecurityModal when SecurityButton is clicked', async () => {
+        const securities = [
+            {
+                schemes: [
+                    {
+                        description: 'For this sample, you can use the api key `special-key` to test the authorization filters.\n',
+                        type: 'apiKey',
+                        name: 'api_key',
+                        in: 'header',
+                        id: 'api_key',
+                        sectionId: 'api_key',
+                        scopes: ['write:pets', 'read:pets'],
+                    },
+                ],
+            },
+        ];
+        const { getByRole, getByText } = render(_jsx(Security, { securities: securities }));
+        fireEvent.click(getByRole('button', { name: 'View details' }));
+        await act(async () => { });
+        expect(getByText('Mocked SecurityModal')).toBeInTheDocument();
+    });
+});
+//# sourceMappingURL=Security.test.js.map

package/lib/components/Security/__tests__/SecurityButton.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/components/Security/__tests__/SecurityButton.test.js

@@ -0,0 +1,92 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { fireEvent, render } from '@testing-library/react';
+import { SecurityButton } from '../SecurityButton.js';
+describe('SecurityButton Component', () => {
+    const securities = [
+        { schemes: [{ id: 'scheme1' }] },
+        { schemes: [{ id: 'scheme2' }, { id: 'scheme3' }] },
+    ];
+    it('should render the button with `View details` text', () => {
+        const { getByRole } = render(_jsx(SecurityButton, { securities: [securities[0]], onClick: () => { } }));
+        expect(getByRole('button', { name: 'View details' })).toBeInTheDocument();
+    });
+    it('should render the panel with correct text for a single security scheme', () => {
+        const { getByTestId } = render(_jsx(SecurityButton, { securities: [securities[0]], onClick: () => { } }));
+        expect(getByTestId('panel-body')).toHaveTextContent('scheme1');
+    });
+    it('should render the panel with correct text for multiple Authentication Types', () => {
+        const schemas = [
+            [{ schemes: [{ id: 'A' }] }, { schemes: [{ id: 'B' }] }], // Should render "A or B"
+            [{ schemes: [{ id: 'A' }, { id: 'B' }] }], // Should render "A and B"
+            [{ schemes: [{ id: 'A' }, { id: 'B' }] }, { schemes: [{ id: 'C' }, { id: 'D' }] }], // Should render "(A and B) or (C and D)"
+        ];
+        const { getAllByTestId } = render(_jsxs(_Fragment, { children: [_jsx(SecurityButton, { securities: schemas[0], onClick: () => { } }), _jsx(SecurityButton, { securities: schemas[1], onClick: () => { } }), _jsx(SecurityButton, { securities: schemas[2], onClick: () => { } })] }));
+        const panelBodies = getAllByTestId('panel-body');
+        expect(panelBodies[0]).toHaveTextContent('A or B');
+        expect(panelBodies[1]).toHaveTextContent('A and B');
+        expect(panelBodies[2]).toHaveTextContent('(A and B) or (C and D)');
+    });
+    it('shows required scopes for oauth2 schemes (truncated with +N)', () => {
+        const securities = [
+            {
+                schemes: [
+                    {
+                        id: 'OAuth2',
+                        type: 'oauth2',
+                        scopes: ['read:users', 'write:users', 'admin:users', 'delete:users', 'sudo:users'],
+                    },
+                ],
+            },
+        ];
+        const { getByTestId } = render(_jsx(SecurityButton, { securities: securities, onClick: () => { } }));
+        const body = getByTestId('panel-body');
+        expect(body).toHaveTextContent('OAuth2');
+        expect(body).toHaveTextContent('Required scopes');
+        expect(body).toHaveTextContent('read:users');
+        expect(body).toHaveTextContent('write:users');
+        expect(body).toHaveTextContent('admin:users');
+        expect(body).toHaveTextContent('delete:users');
+        expect(body).toHaveTextContent('+1');
+    });
+    it('allows focusing the +N scope tag with keyboard', () => {
+        const securities = [
+            {
+                schemes: [
+                    {
+                        id: 'OAuth2',
+                        type: 'oauth2',
+                        scopes: ['read:users', 'write:users', 'admin:users', 'delete:users', 'sudo:users'],
+                    },
+                ],
+            },
+        ];
+        const { getByText } = render(_jsx(SecurityButton, { securities: securities, onClick: () => { } }));
+        const plusOne = getByText('+1');
+        const focusable = plusOne.closest('[role="button"]');
+        expect(focusable).not.toBeNull();
+        expect(focusable).toHaveAttribute('tabindex', '0');
+    });
+    it('show truncated scope names for oauth2 schemes', () => {
+        const securities = [
+            {
+                schemes: [
+                    {
+                        id: 'OAuth2',
+                        type: 'oauth2',
+                        scopes: ['scope:verylongscopenameforoauthsecurityscheme'],
+                    },
+                ],
+            },
+        ];
+        const { getByTestId } = render(_jsx(SecurityButton, { securities: securities, onClick: () => { } }));
+        const body = getByTestId('panel-body');
+        expect(body).toHaveTextContent('scope:verylongscopenameforoauths..');
+    });
+    it('calls the onClick callback when the button is clicked', () => {
+        const onClickMock = vi.fn();
+        const { getByRole } = render(_jsx(SecurityButton, { securities: securities, onClick: onClickMock }));
+        fireEvent.click(getByRole('button', { name: 'View details' }));
+        expect(onClickMock).toHaveBeenCalled();
+    });
+});
+//# sourceMappingURL=SecurityButton.test.js.map

package/lib/components/Security/__tests__/SecurityModal.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/components/Security/__tests__/SecurityModal.test.js

@@ -0,0 +1,172 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render, fireEvent, act } from '@testing-library/react';
+import { SecurityModal } from '../SecurityModal.js';
+describe('SecurityModal Component', () => {
+    const securities = [
+        {
+            schemes: [
+                {
+                    id: 'B',
+                    description: 'Test description scheme B',
+                    type: 'http',
+                    bearerFormat: 'password',
+                    scopes: [],
+                },
+                {
+                    id: 'C',
+                    description: 'Test description scheme C',
+                    type: 'http',
+                    bearerFormat: 'password',
+                    scopes: [],
+                },
+            ],
+        },
+        {
+            schemes: [
+                {
+                    id: 'A',
+                    description: 'Test description scheme A',
+                    type: 'apiKey',
+                    in: 'header',
+                    name: 'api_key',
+                    scopes: [],
+                },
+            ],
+        },
+        {
+            schemes: [
+                {
+                    id: 'D',
+                    description: 'Test description scheme D',
+                    type: 'oauth2',
+                    flows: {
+                        authorizationCode: {
+                            authorizationUrl: 'https://example.com/authorization',
+                            tokenUrl: 'https://example.com/token',
+                            scopes: {
+                                'read:pets': 'read your pets',
+                                'write:pets': 'modify pets in your account',
+                            },
+                        },
+                    },
+                    scopes: ['read:pets'],
+                },
+            ],
+        },
+    ];
+    it('renders the SecurityModal with the correct number of SegmentedItems', () => {
+        const { getByText } = render(_jsx(SecurityModal, { securities: securities, onClose: () => { } }));
+        expect(getByText('A')).toBeInTheDocument();
+        expect(getByText('B and C')).toBeInTheDocument();
+    });
+    it('renders the SecurityModal with the correct number of SecurityFlows and Dividers', () => {
+        const { getByText, getAllByText } = render(_jsx(SecurityModal, { securities: securities, onClose: () => { } }));
+        expect(getByText('Test description scheme B')).toBeInTheDocument();
+        expect(getByText('Test description scheme C')).toBeInTheDocument();
+        expect(getByText('and')).toBeInTheDocument();
+        expect(getAllByText('HTTP Authorization Scheme').length).toEqual(2);
+        expect(getAllByText('http').length).toEqual(2);
+    });
+    it('should update active security scheme on click and display relevant information', async () => {
+        const { getByText } = render(_jsx(SecurityModal, { securities: securities, onClose: () => { } }));
+        fireEvent.click(getByText('A'));
+        await act(async () => { });
+        expect(getByText('Test description scheme A')).toBeInTheDocument();
+        expect(getByText('Header parameter name:')).toBeInTheDocument();
+        expect(getByText('api_key')).toBeInTheDocument();
+    });
+    it('should display details for OAuth2 scheme D including initial optional scopes toggle', async () => {
+        const { getByText, getAllByText } = render(_jsx(SecurityModal, { securities: securities, onClose: () => { } }));
+        fireEvent.click(getByText('D'));
+        await act(async () => { });
+        expect(getByText('Test description scheme D')).toBeInTheDocument();
+        expect(getByText('Required scopes')).toBeInTheDocument();
+        expect(getByText('Show optional scopes')).toBeInTheDocument();
+        const readPetsScopes = getAllByText('read:pets');
+        expect(readPetsScopes.length).toBe(1);
+        const writePetsScopes = getAllByText('write:pets');
+        expect(writePetsScopes.length).toBe(1);
+    });
+    it('should toggle optional scopes visibility for OAuth2 scheme D', async () => {
+        const { getByText, queryByText } = render(_jsx(SecurityModal, { securities: securities, onClose: () => { } }));
+        fireEvent.click(getByText('D'));
+        await act(async () => { });
+        fireEvent.click(getByText('Show optional scopes'));
+        await act(async () => { });
+        expect(getByText('Hide optional scopes')).toBeInTheDocument();
+        expect(queryByText('Show optional scopes')).toBeNull();
+    });
+    it('calls onClose callback when the Close button is clicked', () => {
+        const onCloseMock = vi.fn();
+        const { getByTestId } = render(_jsx(SecurityModal, { securities: securities, onClose: onCloseMock }));
+        fireEvent.click(getByTestId('close'));
+        expect(onCloseMock).toHaveBeenCalled();
+    });
+    it('should display required scopes from scopes array if there are no flows', () => {
+        const securities = [
+            {
+                schemes: [
+                    {
+                        id: 'D',
+                        description: 'Test description scheme D',
+                        type: 'oauth2',
+                        flows: {},
+                        scopes: ['read:pets'],
+                    },
+                ],
+            },
+        ];
+        const { getByText } = render(_jsx(SecurityModal, { securities: securities, onClose: () => { } }));
+        expect(getByText('read:pets')).toBeInTheDocument();
+    });
+    it('should exlcude required scopes from optional scopes', async () => {
+        const { getByText, getAllByText } = render(_jsx(SecurityModal, { securities: securities, onClose: () => { } }));
+        fireEvent.click(getByText('D'));
+        await act(async () => { });
+        fireEvent.click(getByText('Show optional scopes'));
+        await act(async () => { });
+        expect(getAllByText('read:pets').length).toBe(1);
+        expect(getAllByText('write:pets').length).toBe(1);
+    });
+    it('should render required scopes once per scheme and optional scopes per flow when there are multiple flows', async () => {
+        const securities = [
+            {
+                schemes: [
+                    {
+                        id: 'D',
+                        description: 'Test description scheme D',
+                        type: 'oauth2',
+                        flows: {
+                            authorizationCode: {
+                                authorizationUrl: 'https://example.com/authorization',
+                                tokenUrl: 'https://example.com/token',
+                                scopes: {
+                                    'read:pets': 'read your pets',
+                                    'write:pets': 'modify pets in your account',
+                                },
+                            },
+                            clientCredentials: {
+                                tokenUrl: 'https://example.com/token',
+                                scopes: {
+                                    'read:pets': 'read your pets',
+                                    'write:pets': 'modify pets in your account',
+                                },
+                            },
+                        },
+                        scopes: ['read:pets'],
+                    },
+                ],
+            },
+        ];
+        const { getByText, getAllByText } = render(_jsx(SecurityModal, { securities: securities, onClose: () => { } }));
+        // Required is per scheme
+        expect(getAllByText('Required scopes').length).toBe(1);
+        expect(getAllByText('read:pets').length).toBe(1);
+        // Each flow gets its own optional scopes block
+        expect(getByText('authorizationCode')).toBeInTheDocument();
+        expect(getByText('clientCredentials')).toBeInTheDocument();
+        expect(getAllByText('Show optional scopes').length).toBe(2);
+        expect(getAllByText('write:pets').length).toBe(2);
+    });
+});
+//# sourceMappingURL=SecurityModal.test.js.map

package/lib/components/ServerList/__tests__/ServerList.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/components/ServerList/__tests__/ServerList.test.js

@@ -0,0 +1,83 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render, screen } from '@testing-library/react';
+import * as Jotai from 'jotai';
+import { vi } from 'vitest';
+import { ServerList } from '../ServerList.js';
+import { normalizeOptions } from '../../../services/index.js';
+vi.mock('jotai', async () => ({
+    ...(await vi.importActual('jotai')),
+    useAtomValue: vi.fn(),
+}));
+describe('ServerList component', () => {
+    vi.spyOn(Jotai, 'useAtomValue').mockReturnValue(normalizeOptions({}));
+    const servers = [
+        {
+            url: 'http://petstore.swagger.io/v2',
+            description: 'Default server',
+            name: 'Default',
+        },
+        {
+            url: 'http://petstore.swagger.io/sandbox',
+            description: 'Sandbox server',
+        },
+        {
+            url: 'http://petstore.swagger.io/stage',
+            name: 'Stage server',
+        },
+    ];
+    const translateMock = vi.fn().mockImplementation((_, defaultValue) => defaultValue);
+    it('should render copy button', () => {
+        render(_jsx(ServerList, { servers: servers, path: "/pet", translate: translateMock }));
+        expect(screen.getAllByTestId('copy-button').length).toBe(3);
+    });
+    it('should render server description tooltip', () => {
+        render(_jsx(ServerList, { servers: servers, path: "/pet", translate: translateMock }));
+        expect(screen.getAllByTestId('server-item-description-tooltip').length).toBe(1);
+    });
+    it('should render server name', () => {
+        render(_jsx(ServerList, { servers: servers, path: "/pet", translate: translateMock }));
+        expect(screen.getAllByTestId('server-panel-item-name')[0]).toHaveTextContent('Default');
+        expect(screen.getAllByTestId('server-panel-item-name')[1]).toHaveTextContent('Sandbox server');
+        expect(screen.getAllByTestId('server-panel-item-name')[2]).toHaveTextContent('Stage server');
+    });
+    describe('Server variables', () => {
+        const serversWithVariables = [
+            {
+                url: 'http://petstore.swagger.io/{version}',
+                description: 'Default server with variables',
+                name: 'Default',
+                variables: {
+                    version: {
+                        default: 'v2',
+                        description: 'API version',
+                        enum: ['v1', 'v2'],
+                    },
+                },
+            },
+            {
+                url: 'http://petstore.swagger.io/{sandbox}/{version}',
+                description: 'Sandbox server with variables',
+                variables: {
+                    sandbox: {
+                        default: 'dev',
+                        description: 'Sandbox name',
+                    },
+                    version: {
+                        default: 'v2',
+                        description: 'API version',
+                        enum: ['v1', 'v2'],
+                    },
+                },
+            },
+        ];
+        it('should render view nested with one variable', () => {
+            render(_jsx(ServerList, { servers: [serversWithVariables[0]], path: "/pet", translate: translateMock }));
+            expect(screen.getByText('Show 1 variable')).toBeInTheDocument();
+        });
+        it('should render view nested with multiple variables', () => {
+            render(_jsx(ServerList, { servers: [serversWithVariables[1]], path: "/pet", translate: translateMock }));
+            expect(screen.getByText('Show 2 variables')).toBeInTheDocument();
+        });
+    });
+});
+//# sourceMappingURL=ServerList.test.js.map

package/lib/components/Tabs/__tests__/Tabs.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/components/Tabs/__tests__/Tabs.test.js

@@ -0,0 +1,27 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { render, fireEvent } from '@testing-library/react';
+import { Tabs } from '../Tabs.js';
+import { useTabsState } from '../useTabsState.js';
+describe('Tabs', () => {
+    const TestComponent = () => {
+        const tabs = [
+            { key: 'tab1', title: 'Tab 1' },
+            { key: 'tab2', title: 'Tab 2' },
+        ];
+        const { activeTab, handleTabChange } = useTabsState({ tabs });
+        return (_jsxs("div", { children: [_jsx(Tabs, { tabs: tabs, activeTab: tabs[0], onChange: handleTabChange }), _jsx("div", { children: activeTab === tabs[0].key ? 'Content 1' : 'Content 2' })] }));
+    };
+    test('should render tab list and content components', () => {
+        const { getByText } = render(_jsx(TestComponent, {}));
+        expect(getByText('Tab 1')).toBeInTheDocument();
+        expect(getByText('Tab 2')).toBeInTheDocument();
+        expect(getByText(/Content 1/)).toBeInTheDocument();
+    });
+    test('should switch active tab when clicking on a Tab', () => {
+        const { getByText } = render(_jsx(TestComponent, {}));
+        const tab2 = getByText('Tab 2');
+        fireEvent.click(tab2);
+        expect(getByText(/Content 2/)).toBeInTheDocument();
+    });
+});
+//# sourceMappingURL=Tabs.test.js.map

package/lib/components/ViewNested/__tests__/ViewNested.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/components/ViewNested/__tests__/ViewNested.test.js

@@ -0,0 +1,42 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render, screen } from '@testing-library/react';
+import { ViewNested } from '../ViewNested.js';
+describe('ViewNested', () => {
+    it('should render nested array content directly without show properties button', () => {
+        render(_jsx(ViewNested, { expandByDefault: false, isNestedArray: true, children: _jsx("div", { children: "Nested Array Content" }) }));
+        expect(screen.getByText('Nested Array Content')).toBeInTheDocument();
+        expect(screen.queryByText(/Show \d+ properties/)).toBeNull();
+    });
+    it('should auto-expand nested arrays', () => {
+        render(_jsx(ViewNested, { expandByDefault: false, isNestedArray: true, children: _jsx("div", { children: "Nested Content" }) }));
+        const nestedContent = screen.getByText('Nested Content');
+        expect(nestedContent).toBeVisible();
+    });
+    it('should expand via "Expand all" within the depth limit', () => {
+        render(_jsx(ViewNested, { expandByDefault: false, expandable: true, expandText: "Show 1 property", level: 5, expandedAll: true, children: _jsx("div", { children: "Deep Content" }) }));
+        expect(screen.getByText('Deep Content')).toBeInTheDocument();
+        expect(screen.queryByText('Show 1 property')).toBeNull();
+    });
+    it('should NOT auto-expand beyond the depth limit on "Expand all" (prevents freeze on DAG-shaped schemas)', () => {
+        render(_jsx(ViewNested, { expandByDefault: false, expandable: true, expandText: "Show 1 property", level: 50, expandedAll: true, children: _jsx("div", { children: "Very Deep Content" }) }));
+        // Stays collapsed: the node is still manually expandable, just not force-expanded.
+        expect(screen.queryByText('Very Deep Content')).toBeNull();
+        expect(screen.getByText('Show 1 property')).toBeInTheDocument();
+    });
+    it('should respect the adaptive expandAllDepth over the default ceiling', () => {
+        render(_jsx(ViewNested, { expandByDefault: false, expandable: true, expandText: "Show 1 property", level: 6, expandedAll: true, expandAllDepth: 5, children: _jsx("div", { children: "Adaptive Deep Content" }) }));
+        expect(screen.queryByText('Adaptive Deep Content')).toBeNull();
+        expect(screen.getByText('Show 1 property')).toBeInTheDocument();
+    });
+    it('should cap expandAllDepth by the ceiling even when the budget allows more', () => {
+        render(_jsx(ViewNested, { expandByDefault: false, expandable: true, expandText: "Show 1 property", level: 12, expandedAll: true, expandAllDepth: 15, children: _jsx("div", { children: "Beyond Ceiling Content" }) }));
+        expect(screen.queryByText('Beyond Ceiling Content')).toBeNull();
+        expect(screen.getByText('Show 1 property')).toBeInTheDocument();
+    });
+    it('should always collapse on "Collapse all" regardless of depth', () => {
+        render(_jsx(ViewNested, { expandByDefault: true, expandable: true, expandText: "Show 1 property", level: 50, expandedAll: false, children: _jsx("div", { children: "Deep Content To Collapse" }) }));
+        expect(screen.queryByText('Deep Content To Collapse')).toBeNull();
+        expect(screen.getByText('Show 1 property')).toBeInTheDocument();
+    });
+});
+//# sourceMappingURL=ViewNested.test.js.map

package/lib/components/__tests__/Samples/ExampleSwitch.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/components/__tests__/Samples/ExampleSwitch.test.js

@@ -0,0 +1,45 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render, fireEvent } from '@testing-library/react';
+import { ExampleSwitch } from '../../Samples/index.js';
+import { exampleXML, examples } from '../mocks/examples.js';
+describe('ExampleSwitch', () => {
+    const exampleKey = 'cat';
+    it('should correctly render ExampleSwitch', () => {
+        const { getByTestId, getAllByRole } = render(_jsx(ExampleSwitch, { exampleKey: exampleKey, examples: examples, onChange: () => { } }));
+        expect(getByTestId('dropdown')).toBeInTheDocument();
+        const triggerButton = getByTestId('dropdown').querySelector('button');
+        if (triggerButton) {
+            fireEvent.click(triggerButton);
+        }
+        const menuItems = getAllByRole('menuitem');
+        expect(menuItems.length).toBe(3);
+    });
+    it('should correctly display ExampleSwitch with a different number of examples in the media type', () => {
+        let examplesObj = {
+            exampleKey: 'bee',
+            examples: examples,
+        };
+        const { getByTestId, getAllByRole, rerender } = render(_jsx(ExampleSwitch, { exampleKey: examplesObj.exampleKey, examples: examplesObj.examples, onChange: () => { } }));
+        expect(getByTestId('dropdown')).toBeInTheDocument();
+        let triggerButton = getByTestId('dropdown').querySelector('button');
+        if (triggerButton) {
+            fireEvent.click(triggerButton);
+        }
+        expect(getAllByRole('menuitem').length).toBe(3);
+        if (triggerButton) {
+            fireEvent.click(triggerButton);
+        }
+        examplesObj = {
+            exampleKey: 'foo',
+            examples: exampleXML,
+        };
+        rerender(_jsx(ExampleSwitch, { exampleKey: examplesObj.exampleKey, examples: examplesObj.examples, onChange: () => { } }));
+        expect(getByTestId('dropdown')).toBeInTheDocument();
+        triggerButton = getByTestId('dropdown').querySelector('button');
+        if (triggerButton) {
+            fireEvent.click(triggerButton);
+        }
+        expect(getAllByRole('menuitem').length).toBe(2);
+    });
+});
+//# sourceMappingURL=ExampleSwitch.test.js.map

package/lib/components/__tests__/Samples/use-example-key.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/components/__tests__/Samples/use-example-key.test.js

@@ -0,0 +1,28 @@
+import { renderHook } from '@testing-library/react';
+import { normalizeOptions, OpenAPIParser, } from '../../../services/index.js';
+import { getOperation } from '../../../models/index.js';
+import testDefinition from '../../MediaTypeSwitch/__tests__/fixtures/test-definition.json';
+import { useExampleKey } from '../../Samples/use-example-key.js';
+describe('useExampleKey method', () => {
+    const options = normalizeOptions({});
+    const parser = new OpenAPIParser(testDefinition, undefined, options);
+    test('should take firstKey as exampleKey if activeExampleName and defaultExampleName are missing', () => {
+        const operation = getOperation(parser, {
+            pointer: '#/paths/~1test/get',
+            pathName: '/test',
+            httpVerb: 'GET',
+            pathParameters: [],
+            pathServers: [],
+            isWebhook: false,
+            operationId: 'getPet',
+            ...testDefinition.paths['/test'].get,
+        }, undefined, options, '');
+        const { result } = renderHook(() => useExampleKey(operation, { key: 'test' }));
+        expect(result.current.exampleKey).toBe('key');
+    });
+    test('should not brake if no operation passed and should take firstKey as exampleKey', () => {
+        const { result } = renderHook(() => useExampleKey(undefined, { key: 'test' }));
+        expect(result.current.exampleKey).toBe('key');
+    });
+});
+//# sourceMappingURL=use-example-key.test.js.map

package/lib/components/__tests__/common/ClearButton.test.d.ts

@@ -0,0 +1 @@
+export {};