@redocly/openapi-docs 3.24.0 → 3.24.1

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

@@ -0,0 +1,29 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from '@testing-library/react';
+import { ResponseSamples } from '../ResponseSamples.js';
+import { normalizeOptions, OpenAPIParser } from '../../../services/index.js';
+import { getOperation } from '../../../models/index.js';
+import { withTestProviders } from '../../../testProviders.js';
+import museum from './fixtures/museum.json';
+import definitionWithContent from './fixtures/operationDefinitionWithContent.json';
+import definitionWithoutContent from './fixtures/operationDefinitionWithoutContent.json';
+describe('ResponseSamples', () => {
+    let operation;
+    const options = normalizeOptions({});
+    const parser = new OpenAPIParser(museum, undefined, options);
+    it('renders PayloadSamples when response has a sample', () => {
+        operation = getOperation(parser, definitionWithContent, undefined, options, '');
+        const { container } = render(withTestProviders(_jsx(ResponseSamples, { operation: operation, activeResponseTab: "200", onTabChange: vi.fn() }), {
+            definition: parser.definition,
+        }));
+        expect(container).toHaveTextContent('2023-09-11');
+    });
+    it('renders StyledCodeBlock when response does not have a sample', () => {
+        operation = getOperation(parser, definitionWithoutContent, undefined, options, '');
+        const { container } = render(withTestProviders(_jsx(ResponseSamples, { operation: operation, activeResponseTab: "200", onTabChange: vi.fn() }), {
+            definition: parser.definition,
+        }));
+        expect(container).toHaveTextContent('No content');
+    });
+});
+//# sourceMappingURL=ResponseSamples.test.js.map

package/lib/components/Responses/__tests__/OperationResponseList.test.d.ts

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

package/lib/components/Responses/__tests__/OperationResponseList.test.js

@@ -0,0 +1,89 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render, screen, fireEvent } from '@testing-library/react';
+import { OperationResponseList } from '../OperationResponseList.js';
+import { getMediaContent } from '../../../models/index.js';
+import { normalizeOptions, OpenAPIParser } from '../../../services/index.js';
+import { withTestProviders, TestMemoryRouter } from '../../../testProviders.js';
+const OPERATION_POINTER = '#/paths/~1pets/get';
+// Wide enough that the second expansion level (45 * 45 = 2025 rows) blows the
+// 2000-row budget, so computeExpandAllDepth returns 1 for this schema.
+const WIDTH = 45;
+function makeWideProperties(prefix, value) {
+    return Object.fromEntries(Array.from({ length: WIDTH }, (_, i) => [`${prefix}_${i}`, { ...value }]));
+}
+const definition = {
+    openapi: '3.0.0',
+    info: { title: 'test', version: '0' },
+    paths: {},
+    components: {
+        schemas: {
+            Small: {
+                type: 'object',
+                properties: {
+                    nested: {
+                        type: 'object',
+                        properties: { leaf: { type: 'string' } },
+                    },
+                },
+            },
+            Big: {
+                type: 'object',
+                properties: makeWideProperties('big', { $ref: '#/components/schemas/BigLeaf' }),
+            },
+            BigLeaf: {
+                type: 'object',
+                properties: makeWideProperties('leaf', { type: 'string' }),
+            },
+        },
+    },
+};
+// The probe replaces the heavy ResponseDetails tree: it renders a real SubSchema
+// (like the schema tree does) so the test observes the depth actually applied to
+// nested nodes after the active response tab changes.
+vi.mock('../ResponseDetails.js', async () => {
+    const { SubSchema } = await import('../../Schema/SubSchema.js');
+    return {
+        ResponseDetails: () => (_jsx(SubSchema, { expandByDefault: false, expandable: true, level: 2, propertyLength: WIDTH, deepLink: `${OPERATION_POINTER}/t=response`, operationPointer: OPERATION_POINTER, children: _jsx("div", { "data-testid": "nested-content" }) })),
+    };
+});
+const options = normalizeOptions({});
+const parser = new OpenAPIParser(definition, undefined, options);
+function makeResponse(code, schemaRef) {
+    return {
+        code,
+        expanded: false,
+        type: 'GET',
+        summary: '',
+        description: '',
+        headers: [],
+        toggle: vi.fn(),
+        expand: vi.fn(),
+        content: getMediaContent({
+            parser,
+            info: { 'application/json': { schema: { $ref: schemaRef } } },
+            isRequestType: false,
+            options,
+            data: { operation: { pointer: OPERATION_POINTER } },
+        }),
+    };
+}
+describe('OperationResponseList expand-all depth', () => {
+    it('recomputes the expand-all depth when the active response tab changes', () => {
+        const responses = [
+            makeResponse('200', '#/components/schemas/Small'),
+            makeResponse('500', '#/components/schemas/Big'),
+        ];
+        render(withTestProviders(_jsx(TestMemoryRouter, { children: _jsx(OperationResponseList, { responses: responses, operationId: "getPets", operationPointer: OPERATION_POINTER, callbackId: "" }) }), { definition }));
+        // Expand all while the small 200 schema is active: its depth is the ceiling,
+        // so the level-2 probe node expands.
+        fireEvent.click(screen.getByRole('button', { name: /expand all/i }));
+        expect(screen.getByTestId('nested-content')).toBeInTheDocument();
+        // Switch to the 500 tab with the DAG-shaped schema. The budgeted depth for it
+        // is 1, so the level-2 node must NOT auto-expand even though expandedAll is
+        // still on — otherwise the stale depth reintroduces the page freeze.
+        fireEvent.click(screen.getByText('500'));
+        expect(screen.getByRole('button', { name: /collapse all/i })).toBeInTheDocument();
+        expect(screen.queryByTestId('nested-content')).not.toBeInTheDocument();
+    });
+});
+//# sourceMappingURL=OperationResponseList.test.js.map

package/lib/components/Responses/__tests__/ResponseDetails.test.d.ts

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

package/lib/components/Responses/__tests__/ResponseDetails.test.js

@@ -0,0 +1,111 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from '@testing-library/react';
+import * as Jotai from 'jotai';
+import { ResponseDetails } from '../ResponseDetails.js';
+import { normalizeOptions, OpenAPIParser } from '../../../services/index.js';
+import { getField, getMediaContent } from '../../../models/index.js';
+import { globalOptionsAtom, globalStoreAtom } from '../../../jotai/store.js';
+import { activeMimeNameAtom } from '../../../jotai/app.js';
+import { TestMemoryRouter } from '../../../testProviders.js';
+const info = {
+    'application/json': {
+        schema: {
+            additionalProperties: {
+                format: 'int32',
+            },
+        },
+        examples: {
+            bee: {
+                mime: 'application/json',
+                value: {
+                    category: {
+                        id: 0,
+                        name: 'string',
+                    },
+                    honeyPerDay: 3.14,
+                    id: 0,
+                    petType: 'bee',
+                    status: 'available',
+                },
+            },
+            cat: {
+                mime: 'application/json',
+                value: {
+                    category: {
+                        id: 0,
+                        name: 'string',
+                    },
+                    huntingSkill: 'adventurous',
+                    id: 0,
+                    petType: 'cat',
+                    status: 'available',
+                },
+            },
+        },
+    },
+    'application/xml': {
+        schema: {
+            additionalProperties: {
+                format: 'int32',
+            },
+        },
+    },
+};
+const options = normalizeOptions({});
+const parser = new OpenAPIParser({ openapi: '3.0', info: { title: 'test', version: '0' }, paths: {} }, undefined, options);
+const response = {
+    expanded: false,
+    code: '200',
+    summary: `summary`,
+    description: `***\n**su*mm*ary**\n[link](/link)`,
+    type: 'GET',
+    headers: [
+        getField(parser, {
+            name: 'test',
+            in: 'path',
+            content: {
+                'application/json': {
+                    schema: {
+                        $ref: '#/components/testProperties/readOnlyInContent',
+                    },
+                },
+            },
+        }, '', options, { operation: {} }),
+    ],
+    toggle: vi.fn(),
+    expand: vi.fn(),
+    content: getMediaContent({
+        parser,
+        info,
+        isRequestType: true,
+        options,
+        data: { operation: {} },
+    }),
+};
+vi.mock('jotai', async () => ({
+    ...(await vi.importActual('jotai')),
+    useAtomValue: vi.fn(),
+}));
+describe('ResponseDetails component', () => {
+    vi.spyOn(Jotai, 'useAtomValue').mockImplementation((atom) => {
+        if (atom === globalOptionsAtom) {
+            return options;
+        }
+        if (atom === globalStoreAtom)
+            return { options, parser };
+        if (atom === activeMimeNameAtom)
+            return ['application/json', vi.fn()];
+        return {};
+    });
+    it('should renders correctly', () => {
+        const { container } = render(_jsx(TestMemoryRouter, { children: _jsx(ResponseDetails, { response: response, operationId: " " }) }));
+        expect(container.childNodes.length).toEqual(5);
+    });
+    it('should render description as markdown', () => {
+        const expectedTags = ['p'];
+        const { container } = render(_jsx(TestMemoryRouter, { children: _jsx(ResponseDetails, { response: { ...response, headers: [] }, operationId: "" }) }));
+        const markdownContainer = container.querySelector('.redoc-markdown');
+        expect(markdownContainer?.querySelectorAll(expectedTags.join(','))).toHaveLength(expectedTags.length);
+    });
+});
+//# sourceMappingURL=ResponseDetails.test.js.map

package/lib/components/Responses/__tests__/ResponsesHeaders.test.d.ts

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

package/lib/components/Responses/__tests__/ResponsesHeaders.test.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from '@testing-library/react';
+import { ResponseHeaders } from '../ResponseHeaders.js';
+import { PropertiesTable } from '../../common/index.js';
+vi.mock('../../common', () => ({
+    PropertiesTable: vi.fn(() => _jsx("div", { "data-testid": "properties-table" })),
+}));
+vi.mock('../../PropertyDetails', () => ({
+    Field: vi.fn(() => _jsx("div", { "data-testid": "property-details" })),
+}));
+describe('ResponseHeaders', () => {
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    test('renders nothing if headers are not defined', () => {
+        const { container } = render(_jsx(ResponseHeaders, { headers: undefined }));
+        expect(container.firstChild).toBeNull();
+        expect(PropertiesTable).not.toHaveBeenCalled();
+    });
+    test('renders nothing if headers array is empty', () => {
+        const { container } = render(_jsx(ResponseHeaders, { headers: [] }));
+        expect(container.firstChild).toBeNull();
+        expect(PropertiesTable).not.toHaveBeenCalled();
+    });
+});
+//# sourceMappingURL=ResponsesHeaders.test.js.map

package/lib/components/Schema/__tests__/ArraySchema.test.d.ts

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

package/lib/components/Schema/__tests__/ArraySchema.test.js

@@ -0,0 +1,93 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from '@testing-library/react';
+import * as Jotai from 'jotai';
+import { normalizeOptions, OpenAPIParser } from '../../../services/index.js';
+import { getSchema } from '../../../models/index.js';
+import schemasExpansionLevel from './fixtures/schemaExpansionLevel.json';
+import { Schema } from '../Schema.js';
+import { TestBrowserRouter } from '../../../testProviders.js';
+const options = normalizeOptions({});
+vi.mock('jotai', async () => ({
+    ...(await vi.importActual('jotai')),
+    useAtomValue: vi.fn(),
+}));
+describe('ArraySchema', () => {
+    it("should render Schema with Array when schemasExpansionLevel is 'all'", async () => {
+        vi.spyOn(Jotai, 'useAtomValue').mockReturnValue(normalizeOptions({ schemasExpansionLevel: 'all' }));
+        const parser = new OpenAPIParser(schemasExpansionLevel, undefined, options);
+        const schema = getSchema({
+            parser,
+            schemaOrRef: schemasExpansionLevel.components.schemas.User,
+            pointer: '',
+            options,
+            deps: {
+                operation: {
+                    pointer: 'schemasExpansionLevel',
+                },
+            },
+        });
+        const { getByText } = render(_jsx(Schema, { schema: schema }), {
+            wrapper: TestBrowserRouter,
+        });
+        expect(getByText('Dumb Property 3')).toBeInTheDocument();
+    });
+    it("should render Schema with Array when schemasExpansionLevel is '3'", async () => {
+        vi.spyOn(Jotai, 'useAtomValue').mockReturnValue(normalizeOptions({ schemasExpansionLevel: '3' }));
+        const parser = new OpenAPIParser(schemasExpansionLevel, undefined, options);
+        const schema = getSchema({
+            parser,
+            schemaOrRef: schemasExpansionLevel.components.schemas.User,
+            pointer: '',
+            options,
+            deps: {
+                operation: {
+                    pointer: 'schemasExpansionLevel',
+                },
+            },
+        });
+        const { getByText, queryByText } = render(_jsx(Schema, { schema: schema }), {
+            wrapper: TestBrowserRouter,
+        });
+        expect(getByText('Dumb Property 1')).toBeInTheDocument();
+        expect(queryByText('Dumb Property 2')).toBeInTheDocument();
+    });
+    it('should automatically expand nested array when parent element is expanded', async () => {
+        vi.spyOn(Jotai, 'useAtomValue').mockReturnValue(normalizeOptions({ schemasExpansionLevel: '4' }));
+        const parser = new OpenAPIParser(schemasExpansionLevel, undefined, options);
+        const schema = getSchema({
+            parser,
+            schemaOrRef: schemasExpansionLevel.components.schemas.User,
+            pointer: '',
+            options,
+            deps: {
+                operation: {
+                    pointer: 'schemasExpansionLevel',
+                },
+            },
+        });
+        const { getByText } = render(_jsx(Schema, { schema: schema }), {
+            wrapper: TestBrowserRouter,
+        });
+        expect(getByText('Dumb Property 1 in nested array')).toBeInTheDocument();
+    });
+    it("should not render inner Schema with Array when schemasExpansionLevel is '0'", async () => {
+        vi.spyOn(Jotai, 'useAtomValue').mockReturnValue(normalizeOptions({ schemasExpansionLevel: '0' }));
+        const parser = new OpenAPIParser(schemasExpansionLevel, undefined, options);
+        const schema = getSchema({
+            parser,
+            schemaOrRef: schemasExpansionLevel.components.schemas.User,
+            pointer: '',
+            options,
+            deps: {
+                operation: {
+                    pointer: 'schemasExpansionLevel',
+                },
+            },
+        });
+        const { queryByText } = render(_jsx(Schema, { schema: schema }), {
+            wrapper: TestBrowserRouter,
+        });
+        expect(queryByText('Dumb Property')).toBeNull();
+    });
+});
+//# sourceMappingURL=ArraySchema.test.js.map

package/lib/components/Schema/__tests__/ObjectSchema.test.d.ts

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

package/lib/components/Schema/__tests__/ObjectSchema.test.js

@@ -0,0 +1,115 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from '@testing-library/react';
+import * as Jotai from 'jotai';
+import { normalizeOptions, OpenAPIParser } from '../../../services/index.js';
+import { getSchema } from '../../../models/index.js';
+import schemasExpansionLevel from './fixtures/schemaExpansionLevel.json';
+import requiredField from './fixtures/requiredField.json';
+import { Schema } from '../Schema.js';
+import { TestBrowserRouter } from '../../../testProviders.js';
+const options = normalizeOptions({});
+vi.mock('jotai', async () => ({
+    ...(await vi.importActual('jotai')),
+    useAtomValue: vi.fn(),
+}));
+describe('ObjectSchema', () => {
+    it("should render Schema when schemasExpansionLevel is 'all'", async () => {
+        vi.spyOn(Jotai, 'useAtomValue').mockReturnValue(normalizeOptions({ schemasExpansionLevel: 'all' }));
+        const parser = new OpenAPIParser(schemasExpansionLevel, undefined, options);
+        const schema = getSchema({
+            parser,
+            schemaOrRef: schemasExpansionLevel.components.schemas.Pet,
+            pointer: '',
+            options,
+            deps: {
+                operation: {
+                    pointer: 'schemasExpansionLevel',
+                },
+            },
+        });
+        const { getByText } = render(_jsx(Schema, { schema: schema }), {
+            wrapper: TestBrowserRouter,
+        });
+        expect(getByText('Dumb Property 6')).toBeInTheDocument();
+    });
+    it("should render Schema when schemasExpansionLevel is '3'", async () => {
+        vi.spyOn(Jotai, 'useAtomValue').mockReturnValue(normalizeOptions({ schemasExpansionLevel: '3' }));
+        const parser = new OpenAPIParser(schemasExpansionLevel, undefined, options);
+        const schema = getSchema({
+            parser,
+            schemaOrRef: schemasExpansionLevel.components.schemas.Pet,
+            pointer: '',
+            options,
+            deps: {
+                operation: {
+                    pointer: 'schemasExpansionLevel',
+                },
+            },
+        });
+        const { getByText, queryByText } = render(_jsx(Schema, { schema: schema }), {
+            wrapper: TestBrowserRouter,
+        });
+        expect(getByText('Dumb Property 3')).toBeInTheDocument();
+        expect(queryByText('Dumb Property 4')).toBeNull();
+    });
+    it("should not render inner Schema when schemasExpansionLevel is '0'", async () => {
+        vi.spyOn(Jotai, 'useAtomValue').mockReturnValue(normalizeOptions({ schemasExpansionLevel: '0' }));
+        const parser = new OpenAPIParser(schemasExpansionLevel, undefined, options);
+        const schema = getSchema({
+            parser,
+            schemaOrRef: schemasExpansionLevel.components.schemas.Pet,
+            pointer: '',
+            options,
+            deps: {
+                operation: {
+                    pointer: 'schemasExpansionLevel',
+                },
+            },
+        });
+        const { queryByText } = render(_jsx(Schema, { schema: schema }), {
+            wrapper: TestBrowserRouter,
+        });
+        expect(queryByText('Test Sub Category')).toBeNull();
+    });
+    it("should render Schema when required is 'category' -> 'sub'", async () => {
+        vi.spyOn(Jotai, 'useAtomValue').mockReturnValue(normalizeOptions({}));
+        const parser = new OpenAPIParser(requiredField, undefined, options);
+        const schema = getSchema({
+            parser,
+            schemaOrRef: requiredField.components.schemas.Pet,
+            pointer: '',
+            options,
+            deps: {
+                operation: {
+                    pointer: 'schemasExpansionLevel',
+                },
+            },
+        });
+        const { getByText, queryByText } = render(_jsx(Schema, { schema: schema }), {
+            wrapper: TestBrowserRouter,
+        });
+        expect(getByText('Dumb Property 2')).toBeInTheDocument();
+        expect(queryByText('Dumb Property 3')).toBeNull();
+    });
+    it("should render Schema when required is 'tags' -> 'sub' at Array schema", async () => {
+        vi.spyOn(Jotai, 'useAtomValue').mockReturnValue(normalizeOptions({}));
+        const parser = new OpenAPIParser(requiredField, undefined, options);
+        const schema = getSchema({
+            parser,
+            schemaOrRef: requiredField.components.schemas.User,
+            pointer: '',
+            options,
+            deps: {
+                operation: {
+                    pointer: 'schemasExpansionLevel',
+                },
+            },
+        });
+        const { getByText, queryByText } = render(_jsx(Schema, { schema: schema }), {
+            wrapper: TestBrowserRouter,
+        });
+        expect(getByText('Dumb Property 1')).toBeInTheDocument();
+        expect(queryByText('Dumb Property 2')).toBeNull();
+    });
+});
+//# sourceMappingURL=ObjectSchema.test.js.map

package/lib/components/Schema/__tests__/OneOfSchema.test.d.ts

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

package/lib/components/Schema/__tests__/OneOfSchema.test.js

@@ -0,0 +1,33 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from '@testing-library/react';
+import { normalizeOptions, OpenAPIParser } from '../../../services/index.js';
+import { getSchema } from '../../../models/index.js';
+import oneOfWithDiscriminator from './fixtures/oneOfWithDiscriminator.json';
+import { Schema } from '../Schema.js';
+import { TestBrowserRouter } from '../../../testProviders.js';
+const options = normalizeOptions({});
+describe('OneOfSchema', () => {
+    it('should render correct oneOf and discriminator based on deep link', () => {
+        const parser = new OpenAPIParser(oneOfWithDiscriminator, undefined, options);
+        const schema = getSchema({
+            parser,
+            schemaOrRef: { $ref: '#/components/schemas/OneOfSchema' },
+            pointer: '',
+            options,
+            deps: {
+                operation: {
+                    pointer: '/paths/schema',
+                },
+            },
+            absolutePointer: '/paths/schema',
+        });
+        history.pushState({}, '', 'user/createuser#user/createuser/t=request&path=pet&oneof=1&d=1&oneof=0');
+        const { getByText } = render(_jsx(Schema, { schema: schema }), {
+            wrapper: TestBrowserRouter,
+        });
+        expect(getByText('Type of the shape - Shape')).toBeInTheDocument();
+        expect(getByText('Whether or not the triangle is equilateral')).toBeInTheDocument();
+        expect(getByText('Perimeter of the Equilateral')).toBeInTheDocument();
+    });
+});
+//# sourceMappingURL=OneOfSchema.test.js.map

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

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

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

@@ -0,0 +1,67 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { act, fireEvent, render } from '@testing-library/react';
+import { normalizeOptions, OpenAPIParser } from '../../../services/index.js';
+import { getSchema } from '../../../models/index.js';
+import oneOfWithDiscriminator from './fixtures/oneOfWithDiscriminator.json';
+import singleOneOf from './fixtures/singleOneOf.json';
+import { Schema } from '../Schema.js';
+import { TestBrowserRouter } from '../../../testProviders.js';
+const options = normalizeOptions({});
+describe('SchemaView', () => {
+    describe('OneOf', () => {
+        it('should render oneOf with a single item and display its schema fields', () => {
+            const parser = new OpenAPIParser(singleOneOf, undefined, options);
+            const schema = getSchema({
+                parser,
+                schemaOrRef: singleOneOf.paths['/example'].get.responses['200'].content['application/json'].schema,
+                pointer: '',
+                options,
+                deps: {
+                    operation: {
+                        pointer: '/paths/example',
+                    },
+                },
+                absolutePointer: '/paths/example',
+            });
+            const { getByText } = render(_jsx(Schema, { schema: schema }), {
+                wrapper: TestBrowserRouter,
+            });
+            expect(getByText('One of:')).toBeInTheDocument();
+            expect(getByText('UserResponse')).toBeInTheDocument();
+            expect(getByText('type')).toBeInTheDocument();
+            expect(getByText('data')).toBeInTheDocument();
+        });
+        it('should render oneOf with a discriminator without affecting each other', () => {
+            const parser = new OpenAPIParser(oneOfWithDiscriminator, undefined, options);
+            const schema = getSchema({
+                parser,
+                schemaOrRef: { $ref: '#/components/schemas/OneOfSchema' },
+                pointer: '',
+                options,
+                deps: {
+                    operation: {
+                        pointer: '/paths/schema',
+                    },
+                },
+                absolutePointer: '/paths/schema',
+            });
+            const { getByText } = render(_jsx(Schema, { schema: schema }), {
+                wrapper: TestBrowserRouter,
+            });
+            expect(getByText('Shape')).toBeInTheDocument();
+            act(() => {
+                fireEvent.click(getByText('Shape'));
+            });
+            expect(getByText('Discriminator')).toBeInTheDocument();
+            expect(getByText('square')).toBeInTheDocument();
+            expect(getByText('triangle')).toBeInTheDocument();
+            expect(getByText('sideLength')).toBeInTheDocument();
+            act(() => {
+                fireEvent.click(getByText('triangle'));
+            });
+            expect(getByText('equilateral')).toBeInTheDocument();
+            expect(getByText('Whether or not the triangle is equilateral')).toBeInTheDocument();
+        });
+    });
+});
+//# sourceMappingURL=Schema.test.js.map

package/lib/components/Schema/__tests__/useOneOfLocationIdx.test.d.ts

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

package/lib/components/Schema/__tests__/useOneOfLocationIdx.test.js

@@ -0,0 +1,22 @@
+import { renderHook } from '@testing-library/react';
+import { useOneOfLocationIdx } from '../useOneOfLocationIdx.js';
+vi.mock('react-router', () => ({
+    useLocation: vi.fn().mockReturnValue({
+        hash: '#plans/postplan/t=request&path=&oneof=1/trial&oneof=0/period',
+    }),
+}));
+describe('useOneOfLocationIdx', () => {
+    it('should return the index of the oneOf item in the hash', () => {
+        const oneOf = [{}, {}, {}];
+        const level = 1;
+        const { result } = renderHook(() => useOneOfLocationIdx(oneOf, level));
+        expect(result.current).toBe(1);
+    });
+    it('should return -1 if the oneOf item is not found in the hash', () => {
+        const oneOf = [{}, {}, {}];
+        const level = 3;
+        const { result } = renderHook(() => useOneOfLocationIdx(oneOf, level));
+        expect(result.current).toBe(-1);
+    });
+});
+//# sourceMappingURL=useOneOfLocationIdx.test.js.map

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

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