@redocly/openapi-docs 3.24.0-next.9 → 3.24.1

package/lib/components/PropertyDetails/__tests__/FieldDetails.test.js

@@ -0,0 +1,191 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render, screen } from '@testing-library/react';
+import * as Jotai from 'jotai';
+import { normalizeOptions, OpenAPIParser } from '../../../services/index.js';
+import { FieldDetails } from '../FieldDetails.js';
+import { getField } from '../../../models/index.js';
+import spec from './fixtures/fields.json';
+import { TestBrowserRouter } from '../../../testProviders.js';
+vi.mock('jotai', async () => ({
+    ...(await vi.importActual('jotai')),
+    useAtomValue: vi.fn(),
+}));
+describe('FieldDetails', () => {
+    const options = normalizeOptions({});
+    const parser = new OpenAPIParser(spec, undefined, options);
+    const deps = { operation: { pointer: 'defaultPointer' } };
+    vi.spyOn(Jotai, 'useAtomValue').mockReturnValue(options);
+    it('should render FieldDetails with enum', async () => {
+        options.showAccessMode = true;
+        const field = getField(parser, {
+            name: 'test',
+            in: 'path',
+            content: {
+                'application/json': {
+                    schema: {
+                        $ref: '#/components/testProperties/fieldWithEnum',
+                    },
+                },
+            },
+        }, '', options, deps);
+        render(_jsx(FieldDetails, { field: field }), { wrapper: TestBrowserRouter });
+        expect(screen.getByText('Enum')).toBeInTheDocument();
+        expect(screen.getByText('"foo"')).toBeInTheDocument();
+        expect(screen.getByText('"bar"')).toBeInTheDocument();
+    });
+    it('should render FieldDetails with enum and x-enumDescriptions', async () => {
+        const field = getField(parser, {
+            name: 'test',
+            in: 'path',
+            content: {
+                'application/json': {
+                    schema: {
+                        $ref: '#/components/testProperties/fieldWithEnumDescription',
+                    },
+                },
+            },
+        }, '', options, deps);
+        render(_jsx(FieldDetails, { field: field }), { wrapper: TestBrowserRouter });
+        expect(screen.getByText('Enum Value')).toBeInTheDocument();
+        expect(screen.getByText('foo')).toBeInTheDocument();
+        expect(screen.getByText('bar')).toBeInTheDocument();
+        expect(screen.getByText('Description foo')).toBeInTheDocument();
+        expect(screen.getByText('Description bar')).toBeInTheDocument();
+    });
+    it('should render FieldDetails with enum and x-enumDescription with hiding value', async () => {
+        vi.spyOn(Jotai, 'useAtomValue').mockReturnValue(normalizeOptions({ maxDisplayedEnumValues: 1 }));
+        const field = getField(parser, {
+            name: 'test',
+            in: 'path',
+            content: {
+                'application/json': {
+                    schema: {
+                        $ref: '#/components/testProperties/fieldWithEnumDescription',
+                    },
+                },
+            },
+        }, '', options, deps);
+        render(_jsx(FieldDetails, { field: field }), { wrapper: TestBrowserRouter });
+        expect(screen.getByText('Value')).toBeInTheDocument();
+        expect(screen.getByText('foo')).toBeInTheDocument();
+        expect(screen.getByText('Description foo')).toBeInTheDocument();
+        expect(screen.getByText('+1 more')).toBeInTheDocument();
+    });
+    it('should not render duplicate descriptions for anyOf schemas', async () => {
+        const field = getField(parser, {
+            name: 'testAnyOf',
+            content: {
+                'application/json': {
+                    schema: {
+                        $ref: '#/components/anyOfSchemaWithDescription',
+                    },
+                },
+            },
+        }, '', options, deps);
+        render(_jsx(FieldDetails, { field: field }), { wrapper: TestBrowserRouter });
+        const descriptions = screen.queryAllByText('This is a test anyOf schema with description');
+        expect(descriptions).toHaveLength(0);
+        const plainTextDescriptions = screen.queryAllByText('A plain text value');
+        expect(plainTextDescriptions).toHaveLength(0);
+        const numberDescriptions = screen.queryAllByText('A number value');
+        expect(numberDescriptions).toHaveLength(0);
+    });
+    it('should keep only array-level info on the array field row when items have their own documentation', () => {
+        vi.spyOn(Jotai, 'useAtomValue').mockReturnValue(options);
+        const field = getField(parser, {
+            name: 'owners',
+            required: true,
+            schema: {
+                type: 'array',
+                minItems: 1,
+                maxItems: 20,
+                description: 'List of ACL groups.',
+                items: {
+                    type: 'string',
+                    format: 'email',
+                    maxLength: 256,
+                    pattern: '^\\S+@\\S+$',
+                    description: 'ACL group formatted as an email.',
+                },
+            },
+        }, '', options, deps);
+        render(_jsx(FieldDetails, { field: field }), { wrapper: TestBrowserRouter });
+        expect(screen.getByText('owners')).toBeInTheDocument();
+        expect(screen.getByText('Array of strings')).toBeInTheDocument();
+        expect(screen.getByText('[ 1 .. 20 ] items')).toBeInTheDocument();
+        expect(screen.getByText('List of ACL groups.')).toBeInTheDocument();
+        // the items info is rendered in the nested items row instead
+        expect(screen.queryByText('(email)')).not.toBeInTheDocument();
+        expect(screen.queryByText('<= 256 characters')).not.toBeInTheDocument();
+        expect(screen.queryByText('^\\S+@\\S+$')).not.toBeInTheDocument();
+        expect(screen.queryByText('ACL group formatted as an email.')).not.toBeInTheDocument();
+    });
+    it('should hoist format of trivial items on the array field row', () => {
+        vi.spyOn(Jotai, 'useAtomValue').mockReturnValue(options);
+        const field = getField(parser, {
+            name: 'emails',
+            schema: {
+                type: 'array',
+                items: {
+                    type: 'string',
+                    format: 'email',
+                },
+            },
+        }, '', options, deps);
+        render(_jsx(FieldDetails, { field: field }), { wrapper: TestBrowserRouter });
+        expect(screen.getByText('Array of strings')).toBeInTheDocument();
+        expect(screen.getByText('(email)')).toBeInTheDocument();
+    });
+    it('should render object property example pretty-printed with JSON highlighting', () => {
+        vi.spyOn(Jotai, 'useAtomValue').mockReturnValue(options);
+        const field = getField(parser, {
+            name: 'postal_address',
+            schema: {
+                type: 'object',
+                example: {
+                    name: 'John Alfred Smith',
+                    street: '123 Main Street',
+                    city: 'San Francisco',
+                },
+            },
+        }, '', options, deps);
+        render(_jsx(FieldDetails, { field: field }), { wrapper: TestBrowserRouter });
+        expect(screen.getByText('Example:')).toBeInTheDocument();
+        const viewer = screen.getByTestId('json-viewer');
+        // pretty-printed on multiple lines instead of a single-line JSON.stringify blob
+        expect(viewer.textContent).toContain('"John Alfred Smith"');
+        expect(viewer.textContent).toContain('\n');
+        expect(screen.queryByText(JSON.stringify(field.example))).not.toBeInTheDocument();
+        // syntax highlighting via code theme token spans
+        expect(viewer.querySelector('.token.string')).not.toBeNull();
+    });
+    it('should keep scalar property example inline without JSON viewer', () => {
+        vi.spyOn(Jotai, 'useAtomValue').mockReturnValue(options);
+        const field = getField(parser, {
+            name: 'custom_id',
+            schema: { type: 'string', example: 'HRIS-27' },
+        }, '', options, deps);
+        render(_jsx(FieldDetails, { field: field }), { wrapper: TestBrowserRouter });
+        expect(screen.getByText('"HRIS-27"')).toBeInTheDocument();
+        expect(screen.queryByTestId('json-viewer')).toBeNull();
+    });
+    it('should render x-badges with before position, no position, and after position', () => {
+        const field = getField(parser, {
+            name: 'experimentalFlag',
+            in: 'query',
+            required: false,
+            schema: { type: 'boolean' },
+            'x-badges': [
+                { name: 'Beta', position: 'before' },
+                { name: 'Experimental default' },
+                { name: 'Experimental', position: 'after' },
+            ],
+        }, '#/components/parameters/paramWithBadges', options, deps);
+        render(_jsx(FieldDetails, { field: field }), { wrapper: TestBrowserRouter });
+        expect(screen.getByText('Beta')).toBeInTheDocument();
+        expect(screen.getByText('Experimental default')).toBeInTheDocument();
+        expect(screen.getByText('Experimental')).toBeInTheDocument();
+        expect(screen.getByText('experimentalFlag')).toBeInTheDocument();
+    });
+});
+//# sourceMappingURL=FieldDetails.test.js.map

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

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

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

@@ -0,0 +1,365 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render, fireEvent, screen, act } from '@testing-library/react';
+import * as Jotai from 'jotai';
+import { PropertyDetails } from '../PropertyDetails.js';
+import { normalizeOptions, OpenAPIParser } from '../../../services/index.js';
+import { getField } from '../../../models/index.js';
+import spec from './fixtures/fields.json';
+import { TestBrowserRouter } from '../../../testProviders.js';
+vi.mock('jotai', async () => ({
+    ...(await vi.importActual('jotai')),
+    useAtomValue: vi.fn(),
+}));
+describe('Components', () => {
+    const options = normalizeOptions({});
+    const parser = new OpenAPIParser(spec, undefined, options);
+    const deps = { operation: { pointer: 'defaultPointer' } };
+    vi.spyOn(Jotai, 'useAtomValue').mockReturnValue(options);
+    it('should render FieldDetails without duplicate content', () => {
+        const field = getField(parser, {
+            $ref: '#/components/schemas/primitiveSchema',
+        }, '', options, deps);
+        render(_jsx(PropertyDetails, { field: field }), {
+            wrapper: TestBrowserRouter,
+        });
+        const occurrences = screen.getAllByText('any');
+        expect(occurrences.length).toBe(1);
+    });
+    it('should render FieldDetails with object schema', () => {
+        const field = getField(parser, {
+            $ref: '#/components/objectSchema',
+        }, '', options, deps);
+        const { getAllByText, queryByText, getByText } = render(_jsx(PropertyDetails, { field: field }), {
+            wrapper: TestBrowserRouter,
+        });
+        expect(queryByText('Show 2 properties')).not.toBeNull();
+        act(() => {
+            queryByText('Show 2 properties')?.click();
+        });
+        expect(getByText('status')).toBeInTheDocument();
+        expect(getByText('name')).toBeInTheDocument();
+        expect(getAllByText('string').length).toBe(2);
+        act(() => {
+            fireEvent.click(getByText('-'));
+        });
+        expect(getAllByText('Show 2 properties').length).toBe(1);
+    });
+    it('should render FieldDetails with Array of string schema', () => {
+        const field = getField(parser, {
+            $ref: '#/components/arraySchema',
+            name: 'test',
+        }, '', options, deps);
+        const { getByText } = render(_jsx(PropertyDetails, { field: field }), {
+            wrapper: TestBrowserRouter,
+        });
+        expect(getByText('Array of strings')).toBeInTheDocument();
+    });
+    it('should render FieldDetails with Array of object schema', () => {
+        const field = getField(parser, {
+            $ref: '#/components/arrayOfObjectsSchema',
+            name: 'test',
+        }, '', options, deps);
+        const { getByText, container } = render(_jsx(PropertyDetails, { field: field, level: 2 }), {
+            wrapper: TestBrowserRouter,
+        });
+        expect(getByText('Array of objects')).toBeInTheDocument();
+        expect(getByText('Show 2 array properties')).toBeInTheDocument();
+        act(() => {
+            fireEvent.click(getByText('Show 2 array properties'));
+        });
+        expect(getByText('status')).toBeInTheDocument();
+        expect(getByText('name')).toBeInTheDocument();
+        expect(container.textContent.includes('test[].\u200Bname')).toBe(true);
+        expect(container.textContent.includes('test[].\u200Bstatus')).toBe(true);
+    });
+    it('should render array of primitive items with own documentation as a nested items row', () => {
+        const field = getField(parser, {
+            name: 'owners',
+            schema: {
+                type: 'array',
+                minItems: 1,
+                maxItems: 20,
+                description: 'List of ACL groups.',
+                items: {
+                    type: 'string',
+                    format: 'email',
+                    maxLength: 256,
+                    pattern: '^\\S+@\\S+$',
+                    description: 'ACL group formatted as an email.',
+                    example: 'john@example.com',
+                },
+            },
+        }, '', options, deps);
+        const { getByText, queryByText, container } = render(_jsx(PropertyDetails, { field: field, level: 2 }), {
+            wrapper: TestBrowserRouter,
+        });
+        expect(getByText('Array of strings')).toBeInTheDocument();
+        expect(getByText('[ 1 .. 20 ] items')).toBeInTheDocument();
+        expect(getByText('List of ACL groups.')).toBeInTheDocument();
+        // items info is collapsed into the nested items row, including the items example
+        expect(queryByText('ACL group formatted as an email.')).not.toBeInTheDocument();
+        expect(queryByText('Example:')).not.toBeInTheDocument();
+        expect(getByText('Show array items')).toBeInTheDocument();
+        act(() => {
+            fireEvent.click(getByText('Show array items'));
+        });
+        expect(getByText('ACL group formatted as an email.')).toBeInTheDocument();
+        expect(getByText('<= 256 characters')).toBeInTheDocument();
+        expect(getByText('(email)')).toBeInTheDocument();
+        expect(getByText('"john@example.com"')).toBeInTheDocument();
+        // the items row is labeled `owners.[i]`, not `owners[].[i]`
+        expect(container.textContent.includes('owners.\u200B[i]')).toBe(true);
+        expect(container.textContent.includes('owners[]')).toBe(false);
+    });
+    it('should render a single deprecated badge for a deprecated primitive oneOf variant', () => {
+        const field = getField(parser, {
+            name: 'value',
+            schema: {
+                oneOf: [
+                    { type: 'string', deprecated: true, description: 'Legacy plain text value.' },
+                    { type: 'number' },
+                ],
+            },
+        }, '', options, deps);
+        const { getAllByText } = render(_jsx(PropertyDetails, { field: field, level: 2 }), {
+            wrapper: TestBrowserRouter,
+        });
+        // OneOfSchema renders the badge for the active variant; the fallback row must not repeat it
+        expect(getAllByText('Deprecated')).toHaveLength(1);
+    });
+    it('should keep the items docs on the nested items row inside a oneOf variant', () => {
+        const field = getField(parser, {
+            name: 'value',
+            schema: {
+                oneOf: [
+                    {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                            maxLength: 256,
+                            description: 'ACL group formatted as an email.',
+                            example: 'john@example.com',
+                        },
+                    },
+                    { type: 'string' },
+                ],
+            },
+        }, '', options, deps);
+        const { getByText } = render(_jsx(PropertyDetails, { field: field, level: 2 }), {
+            wrapper: TestBrowserRouter,
+        });
+        act(() => {
+            fireEvent.click(getByText('Show array items'));
+        });
+        expect(getByText('ACL group formatted as an email.')).toBeInTheDocument();
+        expect(getByText('"john@example.com"')).toBeInTheDocument();
+    });
+    it('should index prefixItems rows without the [] marker on the parent name', () => {
+        const tupleParser = new OpenAPIParser({
+            openapi: '3.1.0',
+            components: {
+                schemas: {
+                    AclGroup: {
+                        type: 'string',
+                        maxLength: 256,
+                        description: 'OSDU Access Control List (ACL) group that controls data access.',
+                    },
+                },
+            },
+        }, undefined, options);
+        const field = getField(tupleParser, {
+            name: 'owners',
+            schema: {
+                type: 'array',
+                minItems: 1,
+                maxItems: 20,
+                description: 'Description for property.',
+                example: ['data.default.owners@opendes.testing.slb.com'],
+                prefixItems: [
+                    {
+                        $ref: '#/components/schemas/AclGroup',
+                        description: 'Sibling description for items 111.',
+                    },
+                    { type: 'number', description: 'Description for second item. 222.' },
+                ],
+                items: {
+                    type: 'array',
+                    description: 'Description for additional items.',
+                    minItems: 2,
+                    prefixItems: [
+                        { type: 'number', description: 'Description for first item. 111.' },
+                        { type: 'string', description: 'Description for second item. 222.' },
+                    ],
+                    items: {
+                        type: 'string',
+                        description: 'Description for first item 333.',
+                        maxLength: 256,
+                    },
+                },
+            },
+        }, '', options, deps);
+        const { getByText, queryByText, container } = render(_jsx(PropertyDetails, { field: field, level: 2 }), {
+            wrapper: TestBrowserRouter,
+        });
+        expect(getByText('Array of items')).toBeInTheDocument();
+        expect(getByText('[ 1 .. 20 ] items')).toBeInTheDocument();
+        expect(getByText('Description for property.')).toBeInTheDocument();
+        // the array example is distributed across the item rows, not repeated on the array row
+        expect(screen.queryByTestId('json-viewer')).toBeNull();
+        act(() => {
+            fireEvent.click(getByText('Show 3 properties'));
+        });
+        expect(getByText('"data.default.owners@opendes.testing.slb.com"')).toBeInTheDocument();
+        // tuple members are indexed on the parent name without the [] marker
+        expect(container.textContent.includes('owners.\u200B[0]')).toBe(true);
+        expect(container.textContent.includes('owners.\u200B[1]')).toBe(true);
+        expect(container.textContent.includes('owners.\u200B[2...]')).toBe(true);
+        expect(container.textContent.includes('owners[]')).toBe(false);
+        // the $ref sibling description wins on the prefix item row
+        expect(getByText('Sibling description for items 111.')).toBeInTheDocument();
+        expect(queryByText('OSDU Access Control List (ACL) group that controls data access.')).not.toBeInTheDocument();
+        expect(getByText('(AclGroup)')).toBeInTheDocument();
+        expect(getByText('<= 256 characters')).toBeInTheDocument();
+        expect(getByText('Description for additional items.')).toBeInTheDocument();
+        // the additional items schema is a tuple itself; its rows are indexed the same way
+        act(() => {
+            fireEvent.click(getByText('Show 3 properties'));
+        });
+        expect(container.textContent.includes('owners.\u200B[2...].\u200B[0]')).toBe(true);
+        expect(container.textContent.includes('owners.\u200B[2...].\u200B[1]')).toBe(true);
+        expect(container.textContent.includes('owners.\u200B[2...].\u200B[2...]')).toBe(true);
+        expect(getByText('Description for first item 333.')).toBeInTheDocument();
+    });
+    it('should render nested tuples with empty and items-less member schemas', () => {
+        // mirrors the OpenAPI 3.2 nested multipart/mixed example
+        const field = getField(parser, {
+            name: 'parts',
+            schema: {
+                type: 'array',
+                prefixItems: [
+                    { type: 'array' },
+                    {
+                        type: 'array',
+                        prefixItems: [{ type: 'object' }, { type: 'string' }, {}],
+                    },
+                ],
+            },
+        }, '', options, deps);
+        const { getByText, container } = render(_jsx(PropertyDetails, { field: field, level: 2 }), {
+            wrapper: TestBrowserRouter,
+        });
+        expect(getByText('Array of items')).toBeInTheDocument();
+        act(() => {
+            fireEvent.click(getByText('Show 2 properties'));
+        });
+        // an items-less array member accepts any items
+        expect(container.textContent.includes('parts.\u200B[0]')).toBe(true);
+        expect(getByText('Array of any')).toBeInTheDocument();
+        expect(container.textContent.includes('parts.\u200B[1]')).toBe(true);
+        act(() => {
+            fireEvent.click(getByText('Show 3 properties'));
+        });
+        expect(container.textContent.includes('parts.\u200B[1].\u200B[0]')).toBe(true);
+        expect(getByText('object')).toBeInTheDocument();
+        expect(container.textContent.includes('parts.\u200B[1].\u200B[1]')).toBe(true);
+        expect(getByText('string')).toBeInTheDocument();
+        // an empty {} member schema accepts anything
+        expect(container.textContent.includes('parts.\u200B[1].\u200B[2]')).toBe(true);
+        expect(getByText('any')).toBeInTheDocument();
+        expect(container.textContent.includes('parts[]')).toBe(false);
+    });
+    it('should render FieldDetails with oneOf schema with object schema', () => {
+        const field = getField(parser, {
+            $ref: '#/components/oneOfSchemaWithObjectSchema',
+            name: 'test',
+        }, '', options, deps);
+        const { getByText, container } = render(_jsx(PropertyDetails, { field: field, level: 2 }), {
+            wrapper: TestBrowserRouter,
+        });
+        expect(getByText('Show 2 properties')).toBeInTheDocument();
+        act(() => {
+            fireEvent.click(getByText('Show 2 properties'));
+        });
+        expect(getByText('status')).toBeInTheDocument();
+        expect(getByText('name')).toBeInTheDocument();
+        expect(container.textContent.includes('test.\u200Bname')).toBe(true);
+        expect(container.textContent.includes('test.\u200Bstatus')).toBe(true);
+    });
+    it('should render FieldDetails with a oneOf schema at the first level without nesting', () => {
+        const field = getField(parser, {
+            $ref: '#/components/oneOfSchemaWithObjectSchema',
+            name: 'test',
+        }, '', options, deps);
+        const { getByText, container } = render(_jsx(PropertyDetails, { field: field, level: 2 }), {
+            wrapper: TestBrowserRouter,
+        });
+        expect(getByText('Show 2 properties')).toBeInTheDocument();
+        act(() => {
+            fireEvent.click(getByText('Show 2 properties'));
+        });
+        expect(getByText('status')).toBeInTheDocument();
+        expect(getByText('name')).toBeInTheDocument();
+        expect(container.textContent.includes('test.\u200Bname')).toBe(true);
+        expect(container.textContent.includes('test.\u200Bstatus')).toBe(true);
+    });
+    it('the read-only field should be displayed', () => {
+        const field = getField(parser, {
+            $ref: '#/components/testProperties/readOnlyInSchema',
+        }, '', options, deps);
+        const { container } = render(_jsx(PropertyDetails, { field: field }), {
+            wrapper: TestBrowserRouter,
+        });
+        expect(container).toHaveTextContent(/read-only/);
+    });
+    it('the write-only field should be displayed', () => {
+        const field = getField(parser, {
+            $ref: '#/components/testProperties/writeOnlyInSchema',
+        }, '', options, deps);
+        const { container } = render(_jsx(PropertyDetails, { field: field }), {
+            wrapper: TestBrowserRouter,
+        });
+        expect(container).toHaveTextContent(/write-only/);
+    });
+    describe('PropertyDetails', () => {
+        it('PropertyDetails with read-only should renders correctly', () => {
+            options.showAccessMode = true;
+            const field = getField(parser, {
+                $ref: '#/components/testProperties/readOnlyInSchema',
+            }, '', options, deps);
+            const { container } = render(_jsx(PropertyDetails, { field: field }), {
+                wrapper: TestBrowserRouter,
+            });
+            expect(container).toHaveTextContent(/read-only/);
+        });
+        it('Field with write-only should renders correctly', () => {
+            options.showAccessMode = true;
+            const field = getField(parser, {
+                $ref: '#/components/testProperties/writeOnlyInSchema',
+            }, '', options, deps);
+            const { container } = render(_jsx(PropertyDetails, { field: field }), {
+                wrapper: TestBrowserRouter,
+            });
+            expect(container).toHaveTextContent(/write-only/);
+        });
+        it('Fields with read-only and write-only in content should renders correctly', async () => {
+            options.showAccessMode = true;
+            const field = getField(parser, {
+                name: 'test',
+                in: 'path',
+                content: {
+                    'application/json': {
+                        schema: {
+                            $ref: '#/components/testProperties/readOnlyInContent',
+                        },
+                    },
+                },
+            }, '', options, deps);
+            const { container } = render(_jsx(PropertyDetails, { field: field }), {
+                wrapper: TestBrowserRouter,
+            });
+            fireEvent.click(await screen.getByText('Show 2 properties'));
+            expect(container).toHaveTextContent(/read-only/);
+        });
+    });
+});
+//# sourceMappingURL=PropertyDetails.test.js.map

package/lib/components/PropertyDetails/__tests__/cycleColorsByLevel.test.d.ts

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

package/lib/components/PropertyDetails/__tests__/cycleColorsByLevel.test.js

@@ -0,0 +1,23 @@
+import { cycleColorsByLevel } from '../cycleColorsByLevel.js';
+describe('fieldColorByLevel', () => {
+    it('returns the correct color for a given level', () => {
+        const levelColors = [
+            '#9D00FF',
+            '#615CEA',
+            '#147DF5',
+            '#08BFCC',
+            '#08CC7A',
+            '#81CC08',
+            '#E5BE00',
+            '#FF8700',
+            '#FF00B8',
+        ];
+        for (let i = 0; i < levelColors.length; i++) {
+            expect(cycleColorsByLevel(i)).toBe(levelColors[i]);
+        }
+        expect(cycleColorsByLevel(levelColors.length)).toBe(levelColors[0]);
+        expect(cycleColorsByLevel(levelColors.length + 1)).toBe(levelColors[1]);
+        expect(cycleColorsByLevel(levelColors.length * 2)).toBe(levelColors[0]);
+    });
+});
+//# sourceMappingURL=cycleColorsByLevel.test.js.map

package/lib/components/RedoclyOpenAPIDocs/__tests__/AppProvider.test.d.ts

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

package/lib/components/RedoclyOpenAPIDocs/__tests__/AppProvider.test.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from '@testing-library/react';
+import { StoreProvider } from '../Providers.js';
+describe('ProStoreProvider', () => {
+    test('StoreProvider should run onInit hook', async () => {
+        const { findByTestId } = render(_jsx(StoreProvider, { options: {}, definition: {
+                openapi: '3.0.0',
+                info: {
+                    version: '1.0',
+                    title: 'Foo',
+                },
+            }, children: _jsx("div", { "data-testid": "test" }) }));
+        expect(await findByTestId('test')).toBeInTheDocument();
+    });
+});
+//# sourceMappingURL=AppProvider.test.js.map

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

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