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

package/lib/components/__tests__/mocks/examples.js

@@ -0,0 +1,115 @@
+export const examples = {
+    cat: {
+        mime: 'application/json',
+        value: {
+            category: {
+                name: 'string',
+                sub: {
+                    prop1: 'string',
+                },
+            },
+            name: 'Guru',
+            photoUrls: ['string'],
+            friend: {},
+            tags: [
+                {
+                    name: 'string',
+                },
+            ],
+            cvv_check: 'string',
+            status: 'available',
+            petType: 'cat',
+            huntingSkill: 'adventurous',
+        },
+        rawValue: {},
+    },
+    dog: {
+        mime: 'application/json',
+        value: {
+            category: {
+                name: 'string',
+                sub: {
+                    prop1: 'string',
+                },
+            },
+            name: 'Guru',
+            photoUrls: ['string'],
+            friend: {},
+            tags: [
+                {
+                    name: 'string',
+                },
+            ],
+            cvv_check: 'string',
+            status: 'available',
+            petType: 'dog',
+            packSize: 1,
+        },
+        rawValue: {},
+    },
+    bee: {
+        mime: 'application/json',
+        value: {
+            category: {
+                name: 'string',
+                sub: {
+                    prop1: 'string',
+                },
+            },
+            name: 'Guru',
+            photoUrls: ['string'],
+            friend: {},
+            tags: [
+                {
+                    name: 'string',
+                },
+            ],
+            cvv_check: 'string',
+            status: 'available',
+            petType: 'bee',
+            honeyPerDay: 3.14,
+        },
+        rawValue: {},
+    },
+};
+export const examplesJSON = {
+    foo: {
+        mime: 'application/json',
+        value: {
+            foo: 'bar',
+        },
+        rawValue: {
+            foo: 'bar',
+        },
+        summary: 'A foo example',
+    },
+    bar: {
+        mime: 'application/json',
+        value: {
+            bar: 'baz',
+        },
+        rawValue: {
+            bar: 'baz',
+        },
+        summary: 'A bar example',
+    },
+};
+export const exampleXML = {
+    xmlExample: {
+        rawValue: undefined,
+        value: undefined,
+        mime: 'application/xml',
+        summary: 'This is an example in XML',
+    },
+    foo: {
+        mime: 'application/xml',
+        value: {
+            foo: 'bar',
+        },
+        rawValue: {
+            foo: 'bar',
+        },
+        summary: 'A foo example',
+    },
+};
+//# sourceMappingURL=examples.js.map

package/lib/components/common/LinkToField.js

@@ -1,4 +1,4 @@
-import{jsx as c}from"react/jsx-runtime";import{css as p}from"styled-components";import{useLocation as l}from"react-router-dom";import{LinkIcon as r}from"@redocly/theme/icons/LinkIcon/LinkIcon";import{encodeBackSlashes as m}from"../../utils/string.js";import{constructFieldDeepFragment as d,joinWithSeparator as n}from"../../services/history/helpers.js";import{ShareLink as f}from"./linkify.js";import{styled as h}from"../../styled-components.js";function F(i,s){const o=i.deps.operation,e=d(i,s);if(!o?.id&&!o.isCallback)return"#"+e.toLowerCase();const t=n(o.href,n(o.id,e),"#");return m(t.toLowerCase())}const S=({to:i,className:s})=>{const o=i,e=l(),t=o?.split("#")[1],a=e?e.hash===`#${t}`:!1;return c(k,{ariaLabel:`link  to ${o}`,className:s,isActive:a,to:o,id:t})},k=h(f)`
+import{jsx as c}from"react/jsx-runtime";import{css as p}from"styled-components";import{useLocation as l}from"react-router";import{LinkIcon as r}from"@redocly/theme/icons/LinkIcon/LinkIcon";import{encodeBackSlashes as m}from"../../utils/string.js";import{constructFieldDeepFragment as d,joinWithSeparator as n}from"../../services/history/helpers.js";import{ShareLink as f}from"./linkify.js";import{styled as h}from"../../styled-components.js";function F(i,s){const o=i.deps.operation,e=d(i,s);if(!o?.id&&!o.isCallback)return"#"+e.toLowerCase();const t=n(o.href,n(o.id,e),"#");return m(t.toLowerCase())}const S=({to:i,className:s})=>{const o=i,e=l(),t=o?.split("#")[1],a=e?e.hash===`#${t}`:!1;return c(k,{ariaLabel:`link  to ${o}`,className:s,isActive:a,to:o,id:t})},k=h(f)`
   display: flex;
   ${r} {
     visibility: hidden;

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

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

package/lib/components/common/__tests__/Dropdown.test.js

@@ -0,0 +1,129 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render, fireEvent, screen } from '@testing-library/react';
+import { Dropdown } from '../Dropdown/index.js';
+describe('DropdownComponent', () => {
+    const options = [
+        { value: 'option1', label: 'Option 1' },
+        { value: 'option2', label: 'Option 2' },
+        { value: 'option3', label: 'Option 3' },
+    ];
+    const value = 'option1';
+    const onChange = vi.fn();
+    const defaultProps = {
+        options,
+        value,
+        onChange,
+        className: 'custom-dropdown',
+    };
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('renders dropdown options correctly', () => {
+        const { getAllByText, getByRole } = render(_jsx(Dropdown, { ...defaultProps }));
+        fireEvent.click(getByRole('button'));
+        options.forEach((option) => {
+            const elements = getAllByText(option.label);
+            expect(elements.length).toBeGreaterThan(0);
+        });
+    });
+    it('calls onChange callback when an option is clicked', () => {
+        const { getByText, getByRole } = render(_jsx(Dropdown, { ...defaultProps }));
+        fireEvent.click(getByRole('button'));
+        fireEvent.click(getByText('Option 2'));
+        expect(onChange).toHaveBeenCalledWith(options[1]);
+    });
+    it('calls onChange callback when Enter key is pressed on an option', () => {
+        const { getByText, getByRole } = render(_jsx(Dropdown, { ...defaultProps }));
+        fireEvent.click(getByRole('button'));
+        fireEvent.keyDown(getByText('Option 3'), { key: 'Enter' });
+        expect(onChange).toHaveBeenCalledWith(options[2]);
+    });
+    it('renders title correctly', () => {
+        const { getAllByText } = render(_jsx(Dropdown, { ...defaultProps }));
+        expect(getAllByText('Option 1')[0]).toBeInTheDocument();
+    });
+    it('renders title when there is only one option', () => {
+        const singleOption = [{ value: 'option1', label: 'Option 1' }];
+        const singleOptionProps = {
+            options: singleOption,
+            value: 'option1',
+            onChange,
+            className: 'custom-dropdown',
+        };
+        const { getByText } = render(_jsx(Dropdown, { ...singleOptionProps }));
+        expect(getByText('Option 1')).toBeInTheDocument();
+    });
+    describe('search functionality (auto-enabled with 7+ options)', () => {
+        const searchOptions = [
+            { value: 'apple', label: 'Apple' },
+            { value: 'banana', label: 'Banana' },
+            { value: 'cherry', label: 'Cherry' },
+            { value: 'date', label: 'Date' },
+            { value: 'elderberry', label: 'Elderberry' },
+            { value: 'fig', label: 'Fig' },
+            { value: 'grape', label: 'Grape' },
+        ];
+        const searchProps = {
+            options: searchOptions,
+            value: 'apple',
+            onChange,
+        };
+        it('renders search input when there are 7 or more options', () => {
+            render(_jsx(Dropdown, { ...searchProps }));
+            fireEvent.click(screen.getByRole('button'));
+            const searchInput = screen.getByPlaceholderText('Search items');
+            expect(searchInput).toBeInTheDocument();
+        });
+        it('does not render search input when there are fewer than 7 options', () => {
+            render(_jsx(Dropdown, { ...defaultProps }));
+            fireEvent.click(screen.getByRole('button'));
+            const searchInput = screen.queryByPlaceholderText('Search items');
+            expect(searchInput).not.toBeInTheDocument();
+        });
+        it('filters options based on search input', () => {
+            render(_jsx(Dropdown, { ...searchProps }));
+            fireEvent.click(screen.getByRole('button'));
+            const searchInput = screen.getByPlaceholderText('Search items');
+            fireEvent.change(searchInput, { target: { value: 'an' } });
+            const menu = screen.getByTestId('dropdown-menu');
+            expect(menu).toHaveTextContent('Banana');
+            const menuItems = screen.getAllByRole('menuitem');
+            const menuItemTexts = menuItems.map((item) => item.textContent);
+            expect(menuItemTexts.some((text) => text?.includes('Banana'))).toBe(true);
+            expect(menuItemTexts.filter((text) => text?.includes('Cherry'))).toHaveLength(0);
+        });
+        it('filters options case-insensitively', () => {
+            render(_jsx(Dropdown, { ...searchProps }));
+            fireEvent.click(screen.getByRole('button'));
+            const searchInput = screen.getByPlaceholderText('Search items');
+            fireEvent.change(searchInput, { target: { value: 'banana' } });
+            const menu = screen.getByTestId('dropdown-menu');
+            expect(menu).toHaveTextContent('Banana');
+            const menuItems = screen.getAllByRole('menuitem');
+            const fruitItems = menuItems.filter((item) => !item.querySelector('input'));
+            expect(fruitItems).toHaveLength(1);
+            expect(fruitItems[0]).toHaveTextContent('Banana');
+        });
+        it('shows "No items found" when no options match search', () => {
+            render(_jsx(Dropdown, { ...searchProps }));
+            fireEvent.click(screen.getByRole('button'));
+            const searchInput = screen.getByPlaceholderText('Search items');
+            fireEvent.change(searchInput, { target: { value: 'xyz' } });
+            expect(screen.getByText('No items found')).toBeInTheDocument();
+            const menuItems = screen.getAllByRole('menuitem');
+            const fruitItems = menuItems.filter((item) => !item.querySelector('input') && !item.textContent?.includes('No items found'));
+            expect(fruitItems).toHaveLength(0);
+        });
+        it('handles empty search input correctly', () => {
+            render(_jsx(Dropdown, { ...searchProps }));
+            fireEvent.click(screen.getByRole('button'));
+            const searchInput = screen.getByPlaceholderText('Search items');
+            fireEvent.change(searchInput, { target: { value: '' } });
+            const menu = screen.getByTestId('dropdown-menu');
+            searchOptions.forEach((option) => {
+                expect(menu).toHaveTextContent(option.label);
+            });
+        });
+    });
+});
+//# sourceMappingURL=Dropdown.test.js.map

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

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

package/lib/components/common/__tests__/LinkToField.test.js

@@ -0,0 +1,39 @@
+import { generateDeepLink } from '../LinkToField.js';
+import { normalizeOptions, OpenAPIParser } from '../../../services/index.js';
+import { getField } from '../../../models/index.js';
+import spec from './fixtures/simpleOpenAPI.json';
+const options = normalizeOptions({});
+describe('generateDeepLink', () => {
+    const parser = new OpenAPIParser(spec, undefined, options);
+    const deps = {
+        type: 'request',
+        operation: {
+            id: 'paths/~1pets/post',
+            pointer: '/paths/~1pets/post',
+            href: '/paths/~1pets/post',
+        },
+    };
+    const field = getField(parser, {
+        name: 'name',
+        required: false,
+        schema: {
+            type: 'string',
+        },
+    }, '/properties/name', options, deps);
+    it('generates a deep link for a field without an operation', () => {
+        const field = getField(parser, {
+            name: 'name',
+            required: false,
+            schema: {
+                type: 'string',
+            },
+        }, '/properties/name', options, { ...deps, operation: {} });
+        const deepLink = generateDeepLink(field);
+        expect(deepLink).toBe('#t=request&path=name');
+    });
+    it('generates a deep link with the default deepLinkPrefix', () => {
+        const deepLink = generateDeepLink(field);
+        expect(deepLink).toBe('/paths/~1pets/post#paths/~1pets/post/t=request&path=name');
+    });
+});
+//# sourceMappingURL=LinkToField.test.js.map

package/lib/components/common/linkify.js

@@ -1,4 +1,4 @@
-import{jsx as a,jsxs as c}from"react/jsx-runtime";import{useAtomValue as m}from"jotai";import{Link as h}from"react-router-dom";import{LinkIcon as o}from"@redocly/theme/icons/LinkIcon/LinkIcon";import{globalOptionsAtom as d}from"../../jotai/store.js";import{tryDecodeURIComponent as f}from"../../utils/index.js";import{styled as k}from"../../styled-components.js";import{joinWithSeparator as e}from"../../services/history/helpers.js";function u(i){const{routingBasePath:n,onDeepLinkClick:r}=m(d),t=i.to,l=r&&{onClick:s=>{s.preventDefault(),r(e(n||"",t))}};return t?a(h,{"aria-label":i["aria-label"]||`link to ${t}`,id:f(i.id||""),className:i.className||"",to:t?.startsWith("#")?t:e(n||"",t),...l,children:i.children}):i.children?c("span",{"aria-label":i["aria-label"]||`link to ${t}`,className:i.className,children:[" ",i.children," "]}):null}const b=k(u)`
+import{jsx as a,jsxs as c}from"react/jsx-runtime";import{useAtomValue as m}from"jotai";import{Link as h}from"react-router";import{LinkIcon as o}from"@redocly/theme/icons/LinkIcon/LinkIcon";import{globalOptionsAtom as d}from"../../jotai/store.js";import{tryDecodeURIComponent as f}from"../../utils/index.js";import{styled as k}from"../../styled-components.js";import{joinWithSeparator as e}from"../../services/history/helpers.js";function u(i){const{routingBasePath:n,onDeepLinkClick:r}=m(d),t=i.to,l=r&&{onClick:s=>{s.preventDefault(),r(e(n||"",t))}};return t?a(h,{"aria-label":i["aria-label"]||`link to ${t}`,id:f(i.id||""),className:i.className||"",to:t?.startsWith("#")?t:e(n||"",t),...l,children:i.children}):i.children?c("span",{"aria-label":i["aria-label"]||`link to ${t}`,className:i.className,children:[" ",i.children," "]}):null}const b=k(u)`
   position: absolute;
   top: 50%;
   left: 0;

package/lib/hooks/useRouter.js

@@ -1 +1 @@
-import{BrowserRouter as s,HashRouter as a,MemoryRouter as n}from"react-router-dom";const m={history:s,memory:n,hash:a},R=(e,o)=>{const r=m[e],t={...e!=="memory"&&{basename:o,feature:{v7_startTransition:!1,v7_relativeSplatPath:!1}}};return{Router:r,routerProps:t}};export{R as useRouter};
+import{BrowserRouter as s,HashRouter as a,MemoryRouter as n}from"react-router";const m={history:s,memory:n,hash:a},R=(e,o)=>{const r=m[e],t={...e!=="memory"&&{basename:o,feature:{v7_startTransition:!1,v7_relativeSplatPath:!1}}};return{Router:r,routerProps:t}};export{R as useRouter};

package/lib/hooks/useUppercase2LowercaseRedirect.js

@@ -1 +1 @@
-import{useEffect as t}from"react";import{useLocation as o,useNavigate as r}from"react-router-dom";function p(){const a=r(),e=o();t(()=>{e.pathname.toLowerCase()!==e.pathname&&a(e.pathname.toLowerCase(),{replace:!0})},[e.pathname,a])}export{p as useUppercase2LowercaseRedirect};
+import{useEffect as t}from"react";import{useLocation as o,useNavigate as r}from"react-router";function p(){const a=r(),e=o();t(()=>{e.pathname.toLowerCase()!==e.pathname&&a(e.pathname.toLowerCase(),{replace:!0})},[e.pathname,a])}export{p as useUppercase2LowercaseRedirect};

package/lib/jotai/__tests__/app.test.d.ts

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

package/lib/jotai/__tests__/app.test.js

@@ -0,0 +1,53 @@
+import { act, renderHook } from '@testing-library/react';
+import { useAtomValue, useSetAtom } from 'jotai';
+import { 
+// @community-ignore
+environmentAtom, 
+// @community-ignore-end
+appStore, appStoreOverrideAtom, } from '../app.js';
+describe('jotai atoms', () => {
+    describe('environmentAtom', () => {
+        test('should return default values with empty state', () => {
+            const { result: { current: [env, envName], }, } = renderHook(() => useAtomValue(environmentAtom));
+            expect(envName).toEqual('');
+            expect(env).toEqual({});
+        });
+        test('should return first environment if non-existing is selected', () => {
+            const { result: { current: setApp }, } = renderHook(() => useSetAtom(appStore));
+            act(() => {
+                setApp({
+                    environments: {
+                        Default: { foo: 'bar', baz: 'qux' },
+                    },
+                    environment: 'non-existing',
+                });
+            });
+            const { result: { current: [env, envName], }, } = renderHook(() => useAtomValue(environmentAtom));
+            expect(envName).toEqual('Default');
+            expect(env).toEqual({ foo: 'bar', baz: 'qux' });
+        });
+        test('should work with override data', () => {
+            const { result: { current: setApp }, } = renderHook(() => useSetAtom(appStore));
+            const { result: { current: setOverride }, } = renderHook(() => useSetAtom(appStoreOverrideAtom));
+            act(() => {
+                setApp({
+                    environments: {
+                        Mock: {},
+                        Default: { foo: 'bar', baz: 'qux' },
+                    },
+                    environment: 'non-existing',
+                });
+                setOverride({
+                    environments: {
+                        Default: { foo: '123', secret: 'password' },
+                    },
+                    environment: 'Default',
+                });
+            });
+            const { result: { current: [env, envName], }, } = renderHook(() => useAtomValue(environmentAtom));
+            expect(envName).toEqual('Default');
+            expect(env).toEqual({ foo: '123', baz: 'qux', secret: 'password' });
+        });
+    });
+});
+//# sourceMappingURL=app.test.js.map

package/lib/models/__tests__/Callback.test.d.ts

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

package/lib/models/__tests__/Callback.test.js

@@ -0,0 +1,15 @@
+import { getCallback } from '../callback.js';
+import { normalizeOptions, OpenAPIParser } from '../../services/index.js';
+import spec from './fixtures/callback.json';
+const opts = normalizeOptions({});
+describe('Models', () => {
+    describe('CallbackModel', () => {
+        const parser = new OpenAPIParser(spec, undefined, opts);
+        test('basic callback details', () => {
+            const callback = getCallback(parser, 'Test.Callback', { $ref: '#/components/callbacks/Test' }, '', opts, '');
+            expect(callback.name).toEqual('Test.Callback');
+            expect(callback.operations.length).toEqual(0);
+        });
+    });
+});
+//# sourceMappingURL=Callback.test.js.map

package/lib/models/__tests__/FieldModel.test.d.ts

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

package/lib/models/__tests__/FieldModel.test.js

@@ -0,0 +1,117 @@
+import { getField } from '../field.js';
+import { normalizeOptions, OpenAPIParser } from '../../services/index.js';
+import spec from './fixtures/fields.json';
+const opts = normalizeOptions({});
+const deps = { operation: { pointer: 'testFieldModel' } };
+describe('Models', () => {
+    describe('FieldModel', () => {
+        const parser = new OpenAPIParser(spec, undefined, opts);
+        test('basic field details', () => {
+            const field = getField(parser, {
+                $ref: '#/components/parameters/testParam',
+            }, '#/components/parameters/testParam', opts, deps);
+            expect(field.name).toEqual('test_name');
+            expect(field.in).toEqual('path');
+            expect(field.required).toEqual(false);
+            expect(field.schema.type).toEqual('string');
+        });
+        test('field details relevant for parameter serialization', () => {
+            const field = getField(parser, {
+                $ref: '#/components/parameters/serializationParam',
+            }, '#/components/parameters/serializationParam', opts, deps);
+            expect(field.name).toEqual('serialization_test_name');
+            expect(field.in).toEqual('query');
+            expect(field.schema.type).toEqual('array');
+            expect(field.style).toEqual('form');
+            expect(field.explode).toEqual(true);
+        });
+        test('field details relevant for default path param serialization', () => {
+            const field = getField(parser, {
+                $ref: '#/components/parameters/pathParamWithNoStyle',
+            }, '#/components/parameters/pathParamWithNoStyle', opts, deps);
+            expect(field.name).toEqual('serialization_test_name');
+            expect(field.in).toEqual('path');
+            expect(field.schema.type).toEqual('array');
+            expect(field.style).toEqual('simple');
+            expect(field.explode).toEqual(false);
+        });
+        test('field details relevant for default query parameter serialization', () => {
+            const field = getField(parser, {
+                $ref: '#/components/parameters/queryParamWithNoStyle',
+            }, '#/components/parameters/queryParamWithNoStyle', opts, deps);
+            expect(field.name).toEqual('serialization_test_name');
+            expect(field.in).toEqual('query');
+            expect(field.schema.type).toEqual('array');
+            expect(field.style).toEqual('form');
+            expect(field.explode).toEqual(true);
+        });
+        test('field details relevant for default cookie parameter serialization', () => {
+            const field = getField(parser, {
+                $ref: '#/components/parameters/queryParamWithNoStyle',
+            }, '#/components/parameters/queryParamWithNoStyle', opts, deps);
+            expect(field.name).toEqual('serialization_test_name');
+            expect(field.in).toEqual('query');
+            expect(field.schema.type).toEqual('array');
+            expect(field.style).toEqual('form');
+            expect(field.explode).toEqual(true);
+        });
+        test('field name should populated from name even if $ref (headers)', () => {
+            const field = getField(parser, {
+                $ref: '#/components/headers/testHeader',
+                name: 'Test-Header',
+            }, '#/components/headers/testHeader', opts, deps);
+            expect(field.name).toEqual('Test-Header');
+        });
+        test('param example should be override the example provided by the schema', () => {
+            const field = getField(parser, {
+                $ref: '#/components/parameters/queryParamExample',
+            }, '', opts, deps);
+            expect(field.example).toEqual({ id: 'main example' });
+            expect(field.schema.example).toEqual({ id: 'main example' });
+            expect(field.schema.schema.example).toEqual({ id: 'main example' });
+        });
+        test('content example should be override the example provided by the schema', () => {
+            const field = getField(parser, {
+                $ref: '#/components/parameters/queryParamWithContentExample',
+            }, '', opts, deps);
+            expect(field.example).toEqual({ id: 'content example' });
+            expect(field.schema.example).toEqual({ id: 'content example' });
+            expect(field.schema.schema.example).toEqual({ id: 'content example' });
+        });
+        test('field includes allowReserved when parameter has allowReserved', () => {
+            const field = getField(parser, {
+                $ref: '#/components/parameters/allowReservedParam',
+            }, '#/components/parameters/allowReservedParam', opts, deps);
+            expect(field.name).toEqual('filter');
+            expect(field.in).toEqual('query');
+            expect(field.allowReserved).toEqual(true);
+        });
+        test('should include badges from x-badges on parameter', () => {
+            const field = getField(parser, { $ref: '#/components/parameters/paramWithBadges' }, '#/components/parameters/paramWithBadges', opts, deps);
+            expect(field.name).toEqual('experimentalFlag');
+            expect(field.badges).toEqual([
+                { name: 'Experimental', position: 'after' },
+                { name: 'Beta', position: 'before', color: 'blue' },
+            ]);
+        });
+        test('should include badges from x-badges on schema property', () => {
+            const field = getField(parser, {
+                name: 'quantityFilled',
+                required: false,
+                schema: {
+                    type: 'integer',
+                    description: 'Filled quantity (experimental).',
+                    'x-badges': [{ name: 'Experimental' }],
+                },
+            }, '#/components/schemas/schemaWithBadgeProperty/properties/quantityFilled', opts, deps);
+            expect(field.name).toEqual('quantityFilled');
+            expect(field.badges).toEqual([{ name: 'Experimental' }]);
+        });
+        test('should include badges from x-badges on schema when parameter schema is a $ref', () => {
+            const field = getField(parser, { $ref: '#/components/parameters/paramWithSchemaRefBadges' }, '#/components/parameters/paramWithSchemaRefBadges', opts, deps);
+            expect(field.name).toEqual('statusFilter');
+            expect(field.badges).toEqual([{ name: 'From ref schema', position: 'after' }]);
+        });
+    });
+});
+//# sourceMappingURL=FieldModel.test.js.map

package/lib/models/__tests__/MediaContent.test.d.ts

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

package/lib/models/__tests__/MediaContent.test.js

@@ -0,0 +1,105 @@
+import { getMediaContent } from '../mediaContent.js';
+import { normalizeOptions, OpenAPIParser } from '../../services/index.js';
+import { MediaTypes } from '../../constants.js';
+const options = normalizeOptions({});
+const data = { operation: { pointer: 'testMediaContent' } };
+describe('Models', () => {
+    describe('mediaContent', () => {
+        let parser;
+        const info = {
+            [MediaTypes.JSON]: {
+                schema: {
+                    additionalProperties: {
+                        format: 'int32',
+                    },
+                },
+            },
+        };
+        beforeEach(() => {
+            parser = new OpenAPIParser({ openapi: '3.0.0' }, undefined, options);
+        });
+        test('should work with default arguments', () => {
+            const consoleError = vi.spyOn(global.console, 'error');
+            const mediaContentModel = getMediaContent({
+                parser,
+                info: {},
+                isRequestType: true,
+                options,
+                data,
+            });
+            expect(consoleError).not.toHaveBeenCalled();
+            expect(mediaContentModel).toEqual({
+                hasSample: false,
+                isRequestType: true,
+                mediaTypes: [],
+                ...data,
+            });
+        });
+        test('should handle isRequestType argument', () => {
+            const mediaContentModelWithRequestTypeTrue = getMediaContent({
+                parser,
+                info: {},
+                isRequestType: true,
+                options,
+                data,
+            });
+            const mediaContentModelWithRequestTypeFalse = getMediaContent({
+                parser,
+                info: {},
+                isRequestType: false,
+                options,
+                data,
+            });
+            expect(mediaContentModelWithRequestTypeTrue.isRequestType).toEqual(true);
+            expect(mediaContentModelWithRequestTypeFalse.isRequestType).toEqual(false);
+        });
+        test('should return mediaType', () => {
+            const mediaContentModel = getMediaContent({
+                parser,
+                info,
+                isRequestType: true,
+                options,
+                data,
+            });
+            const firstMediaType = mediaContentModel.mediaTypes[0];
+            expect(mediaContentModel.mediaTypes.length).toEqual(1);
+            expect(firstMediaType.name).toEqual(MediaTypes.JSON);
+        });
+        test('should preserve summary for each example when media type uses examples object', () => {
+            const infoWithExamples = {
+                [MediaTypes.JSON]: {
+                    schema: {
+                        type: 'object',
+                        properties: { publisherId: { type: 'string' } },
+                    },
+                    examples: {
+                        'example-0': {
+                            summary: 'First Example',
+                            value: { publisherId: '1' },
+                        },
+                        'example-1': {
+                            summary: 'Second Example',
+                            value: { publisherId: '2' },
+                        },
+                    },
+                },
+            };
+            const mediaContentModel = getMediaContent({
+                parser,
+                info: infoWithExamples,
+                isRequestType: true,
+                options,
+                data,
+            });
+            const examples = mediaContentModel.mediaTypes[0]?.examples;
+            expect(examples).toBeDefined();
+            expect(examples?.['example-0']).toBeDefined();
+            expect(examples?.['example-0']?.summary).toBe('First Example');
+            expect(examples?.['example-0']?.value).toEqual({ publisherId: '1' });
+            expect(examples?.['example-1']).toBeDefined();
+            expect(examples?.['example-1']?.summary).toBe('Second Example');
+            expect(examples?.['example-1']?.value).toEqual({ publisherId: '2' });
+        });
+    });
+});
+//# sourceMappingURL=MediaContent.test.js.map

package/lib/models/__tests__/Operation.test.d.ts

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