@redocly/openapi-docs 3.24.1 → 3.25.0-next.1

package/lib/utils/__tests__/hasNestedFields.test.d.ts

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

package/lib/utils/__tests__/hasNestedFields.test.js

@@ -1,147 +0,0 @@
-import { hasNestedFields } from '../hasNestedFields.js';
-const createMockField = (isPrimitive, isCircular = false) => ({
-    schema: {
-        isPrimitive,
-        isCircular,
-    },
-    name: 'mockField',
-    required: false,
-    description: 'Mock field',
-    deprecated: false,
-    kind: 'field',
-    explode: false,
-    deps: {},
-});
-const createMockSchema = (fields, oneOf) => ({
-    fields,
-    oneOf,
-    isPrimitive: false,
-    isCircular: false,
-});
-describe('hasNestedFields', () => {
-    describe('when schema is undefined or null', () => {
-        it('should return false for undefined schema', () => {
-            expect(hasNestedFields(undefined)).toBe(false);
-        });
-        it('should return false for null schema', () => {
-            expect(hasNestedFields(null)).toBe(false);
-        });
-    });
-    describe('when schema has no fields', () => {
-        it('should return false for schema with undefined fields', () => {
-            const schema = createMockSchema();
-            expect(hasNestedFields(schema)).toBe(false);
-        });
-        it('should return false for schema with empty fields array', () => {
-            const schema = createMockSchema([]);
-            expect(hasNestedFields(schema)).toBe(false);
-        });
-    });
-    describe('when schema has only primitive fields', () => {
-        it('should return false for schema with only primitive fields', () => {
-            const primitiveField1 = createMockField(true);
-            const primitiveField2 = createMockField(true);
-            const schema = createMockSchema([primitiveField1, primitiveField2]);
-            expect(hasNestedFields(schema)).toBe(false);
-        });
-    });
-    describe('when schema has circular fields', () => {
-        it('should return false for schema with only circular fields', () => {
-            const circularField = createMockField(false, true);
-            const schema = createMockSchema([circularField]);
-            expect(hasNestedFields(schema)).toBe(false);
-        });
-        it('should return false for schema with primitive and circular fields', () => {
-            const primitiveField = createMockField(true);
-            const circularField = createMockField(false, true);
-            const schema = createMockSchema([primitiveField, circularField]);
-            expect(hasNestedFields(schema)).toBe(false);
-        });
-    });
-    describe('when schema has non-primitive, non-circular fields', () => {
-        it('should return true for schema with one non-primitive, non-circular field', () => {
-            const nestedField = createMockField(false, false);
-            const schema = createMockSchema([nestedField]);
-            expect(hasNestedFields(schema)).toBe(true);
-        });
-        it('should return true for schema with mixed field types including nested', () => {
-            const primitiveField = createMockField(true);
-            const circularField = createMockField(false, true);
-            const nestedField = createMockField(false, false);
-            const schema = createMockSchema([primitiveField, circularField, nestedField]);
-            expect(hasNestedFields(schema)).toBe(true);
-        });
-    });
-    describe('when schema has oneOf variants', () => {
-        it('should return false for oneOf variants with only primitive fields', () => {
-            const primitiveField = createMockField(true);
-            const variant1 = createMockSchema([primitiveField]);
-            const variant2 = createMockSchema([primitiveField]);
-            const schema = createMockSchema([], [variant1, variant2]);
-            expect(hasNestedFields(schema)).toBe(false);
-        });
-        it('should return false for oneOf variants with only circular fields', () => {
-            const circularField = createMockField(false, true);
-            const variant1 = createMockSchema([circularField]);
-            const variant2 = createMockSchema([circularField]);
-            const schema = createMockSchema([], [variant1, variant2]);
-            expect(hasNestedFields(schema)).toBe(false);
-        });
-        it('should return true for oneOf variants with nested fields', () => {
-            const nestedField = createMockField(false, false);
-            const variant1 = createMockSchema([nestedField]);
-            const schema = createMockSchema([], [variant1]);
-            expect(hasNestedFields(schema)).toBe(true);
-        });
-        it('should return true when one oneOf variant has nested fields', () => {
-            const primitiveField = createMockField(true);
-            const nestedField = createMockField(false, false);
-            const variant1 = createMockSchema([primitiveField]);
-            const variant2 = createMockSchema([nestedField]);
-            const schema = createMockSchema([], [variant1, variant2]);
-            expect(hasNestedFields(schema)).toBe(true);
-        });
-        it('should return false for oneOf variants with no fields', () => {
-            const variant1 = createMockSchema([]);
-            const variant2 = createMockSchema();
-            const schema = createMockSchema([], [variant1, variant2]);
-            expect(hasNestedFields(schema)).toBe(false);
-        });
-    });
-    describe('when schema has both direct fields and oneOf variants', () => {
-        it('should return true when direct fields have nested fields', () => {
-            const nestedField = createMockField(false, false);
-            const primitiveField = createMockField(true);
-            const variant = createMockSchema([primitiveField]);
-            const schema = createMockSchema([nestedField], [variant]);
-            expect(hasNestedFields(schema)).toBe(true);
-        });
-        it('should return true when oneOf variants have nested fields', () => {
-            const primitiveField = createMockField(true);
-            const nestedField = createMockField(false, false);
-            const variant = createMockSchema([nestedField]);
-            const schema = createMockSchema([primitiveField], [variant]);
-            expect(hasNestedFields(schema)).toBe(true);
-        });
-        it('should return false when both direct fields and oneOf variants have only primitive/circular fields', () => {
-            const primitiveField = createMockField(true);
-            const circularField = createMockField(false, true);
-            const variant = createMockSchema([primitiveField]);
-            const schema = createMockSchema([circularField], [variant]);
-            expect(hasNestedFields(schema)).toBe(false);
-        });
-    });
-    describe('edge cases', () => {
-        it('should handle empty oneOf array', () => {
-            const primitiveField = createMockField(true);
-            const schema = createMockSchema([primitiveField], []);
-            expect(hasNestedFields(schema)).toBe(false);
-        });
-        it('should handle oneOf variants with undefined fields', () => {
-            const variant = createMockSchema();
-            const schema = createMockSchema([], [variant]);
-            expect(hasNestedFields(schema)).toBe(false);
-        });
-    });
-});
-//# sourceMappingURL=hasNestedFields.test.js.map

package/lib/utils/__tests__/helpers.test.d.ts

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

package/lib/utils/__tests__/helpers.test.js

@@ -1,174 +0,0 @@
-import { appendToMdHeading, deleteEmptyArrayItem, useSchemaTitle, isArrayOfObjects, mapWithLast, titleize, isLastInArray, isLastProperty, getValueFromMdParsedExtension, } from '../helpers.js';
-describe('Utils', () => {
-    describe('helpers', () => {
-        test('mapWithLast', () => {
-            const arr = [1, 2, 3];
-            const fn = (...args) => args;
-            const actual = mapWithLast(arr, fn);
-            const expected = [
-                [1, false],
-                [2, false],
-                [3, true],
-            ];
-            expect(actual).toEqual(expected);
-        });
-        test('mapWithLast for empty array', () => {
-            const arr = [];
-            const fn = (...args) => args;
-            const actual = mapWithLast(arr, fn);
-            const expected = [];
-            expect(actual).toEqual(expected);
-        });
-        test('appendToMdHeading heading exists not last', () => {
-            const val = appendToMdHeading('# Authentication\n Hello\n# Next heading', 'Authentication', '<test>');
-            expect(val).toEqual('# Authentication\n Hello\n\n<test>\n\n# Next heading');
-        });
-        test('appendToMdHeading heading exists last', () => {
-            const val = appendToMdHeading('# Authentication\n Hello', 'Authentication', '<test>');
-            expect(val).toEqual('# Authentication\n Hello\n\n<test>\n');
-        });
-        test('appendToMdHeading empty string', () => {
-            const val = appendToMdHeading('', 'Authentication', '<test>');
-            expect(val).toEqual('# Authentication\n\n<test>');
-        });
-        describe('titleize', () => {
-            test('should return the string with the first letter capitalized', () => {
-                expect(titleize('my title')).toEqual('My title');
-            });
-        });
-        describe('isArrayOfObjects', () => {
-            test('should return true if the array contains object', () => {
-                expect(isArrayOfObjects([{ test: 'string' }])).toEqual(true);
-            });
-            test('should return false if the array does not include object', () => {
-                expect(isArrayOfObjects(['string'])).toEqual(false);
-            });
-            test('should return false if the array with only null', () => {
-                expect(isArrayOfObjects([null])).toEqual(false);
-            });
-            test('should return false if props is string', () => {
-                expect(isArrayOfObjects('[null]')).toEqual(false);
-            });
-            test('should return true if the array contains at least one object', () => {
-                expect(isArrayOfObjects([null, 'string', { test: 'string' }])).toEqual(true);
-            });
-        });
-        describe('deleteEmptyArrayItem', () => {
-            test('should delete null and undefined items', () => {
-                expect(deleteEmptyArrayItem([null, undefined, 'string'])).toEqual(['string']);
-            });
-            test('should delete empty items', () => {
-                const array = new Array(3);
-                array.push('string');
-                expect(deleteEmptyArrayItem(array)).toEqual(['string']);
-            });
-        });
-        describe('isLastInArray', () => {
-            const array = [1, 2, 3];
-            test('should return true for last index', () => {
-                expect(isLastInArray(array, array.length - 1)).toEqual(true);
-            });
-            test('should return false for not last index', () => {
-                expect(isLastInArray(array, array.length - 2)).toEqual(false);
-            });
-        });
-        describe('isLastProperty', () => {
-            const object = {
-                a: 'a',
-                b: 'b',
-                c: 'c',
-            };
-            test('should return true for last key', () => {
-                expect(isLastProperty(object, 'c')).toEqual(true);
-            });
-            test('should return false for not last key', () => {
-                expect(isLastProperty(object, 'b')).toEqual(false);
-            });
-        });
-    });
-    describe('useSchemaTitle', () => {
-        test('should return the title if it is defined', () => {
-            expect(useSchemaTitle('#/components/schemas/Call', 'Pet')).toEqual('Pet');
-        });
-        test('should return the def name if title is undefined', () => {
-            expect(useSchemaTitle('#/components/schemas/Call')).toEqual('Call');
-        });
-        test('should return the empty string', () => {
-            expect(useSchemaTitle('#/test/path/Call')).toEqual('');
-        });
-    });
-    describe('getValueFromMdParsedExtension', () => {
-        it('should return undefined when no value exists', () => {
-            const item = {};
-            expect(getValueFromMdParsedExtension(item, 'description')).toBeUndefined();
-        });
-        it('should return regular value when no parsed markdown exists', () => {
-            const item = {
-                description: 'regular text',
-            };
-            expect(getValueFromMdParsedExtension(item, 'description')).toBe('regular text');
-        });
-        it('should return parsed markdown value when available', () => {
-            const item = {
-                description: 'original text',
-                'x-parsed-md-description': {
-                    result: 'parsed text',
-                },
-            };
-            expect(getValueFromMdParsedExtension(item, 'description')).toEqual({
-                result: 'parsed text',
-                raw: 'original text',
-            });
-        });
-        it('should handle x-enumDescriptions specially', () => {
-            const item = {
-                'x-enumDescriptions': {
-                    value1: 'desc 1',
-                    value2: 'desc 2',
-                    'x-parsed-md-value1': 'desc 1',
-                    'x-parsed-md-value2': 'desc 2',
-                },
-            };
-            expect(getValueFromMdParsedExtension(item, 'x-enumDescriptions')).toEqual({
-                value1: 'desc 1',
-                value2: 'desc 2',
-            });
-        });
-        it('should return original x-enumDescriptions if no parsed values exist', () => {
-            const originalEnum = {
-                value1: 'desc 1',
-                value2: 'desc 2',
-            };
-            const item = {
-                'x-enumDescriptions': originalEnum,
-            };
-            expect(getValueFromMdParsedExtension(item, 'x-enumDescriptions')).toEqual(originalEnum);
-        });
-        it('should handle summary field', () => {
-            const item = {
-                summary: 'original summary',
-                'x-parsed-md-summary': {
-                    result: 'parsed summary',
-                    raw: 'original summary',
-                },
-            };
-            expect(getValueFromMdParsedExtension(item, 'summary')).toEqual({
-                result: 'parsed summary',
-                raw: 'original summary',
-            });
-        });
-        it('should normalize markdown value with only result property', () => {
-            const item = {
-                'x-parsed-md-description': {
-                    result: 'parsed text',
-                },
-                description: 'original text',
-            };
-            expect(getValueFromMdParsedExtension(item, 'description')).toEqual({
-                result: 'parsed text',
-                raw: 'original text',
-            });
-        });
-    });
-});
-//# sourceMappingURL=helpers.test.js.map

package/lib/utils/__tests__/isMobile.test.d.ts

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

package/lib/utils/__tests__/isMobile.test.js

@@ -1,28 +0,0 @@
-import { isMobile } from '../isMobile.js';
-describe('isMobile', () => {
-    it('should return true for mobile user agent', () => {
-        const userAgent = 'Mozilla/5.0 (iPhone; CPU iPhone OS 15_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.0 Mobile/15E148 Safari/604.1';
-        Object.defineProperty(window.navigator, 'userAgent', {
-            value: userAgent,
-            configurable: true,
-        });
-        expect(isMobile()).toBe(true);
-    });
-    it('should return true for tablet user agent when tablet option is provided', () => {
-        const userAgent = 'Mozilla/5.0 (iPad; CPU OS 15_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.0 Mobile/15E148 Safari/604.1';
-        Object.defineProperty(window.navigator, 'userAgent', {
-            value: userAgent,
-            configurable: true,
-        });
-        expect(isMobile({ tablet: true })).toBe(true);
-    });
-    it('should return false for tablet user agent when tablet option is not provided', () => {
-        const userAgent = 'Mozilla/5.0 (iPad; CPU OS 15_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.0 Mobile/15E148 Safari/604.1';
-        Object.defineProperty(window.navigator, 'userAgent', {
-            value: userAgent,
-            configurable: true,
-        });
-        expect(isMobile()).toBe(false);
-    });
-});
-//# sourceMappingURL=isMobile.test.js.map

package/lib/utils/__tests__/loadAndBundleSpec.test.d.ts

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

package/lib/utils/__tests__/loadAndBundleSpec.test.js

@@ -1,22 +0,0 @@
-import * as yaml from 'js-yaml';
-import { readFileSync } from 'fs';
-import { resolve } from 'path';
-import { loadAndBundleDefinition } from '../loadAndBundleSpec.js';
-describe('#loadAndBundleDefinition', () => {
-    it('should load and bundle spec petstore.yaml', async () => {
-        const spec = yaml.load(readFileSync(resolve(__dirname, '../../../playground/openapi/petstore.yaml'), 'utf-8'));
-        const bundledSpec = await loadAndBundleDefinition(spec);
-        expect(bundledSpec).toMatchSnapshot();
-    });
-    it('should load and bundle spec rebilly.yaml', async () => {
-        const spec = yaml.load(readFileSync(resolve(__dirname, '../../../playground/openapi/rebilly.yaml'), 'utf-8'));
-        const bundledSpec = await loadAndBundleDefinition(spec);
-        expect(bundledSpec).toMatchSnapshot();
-    });
-    it('should load And Bundle Spec openapi-3-1.yaml', async () => {
-        const spec = yaml.load(readFileSync(resolve(__dirname, '../../../playground/openapi/openapi-3-1.yaml'), 'utf-8'));
-        const bundledSpec = await loadAndBundleDefinition(spec);
-        expect(bundledSpec).toMatchSnapshot();
-    });
-});
-//# sourceMappingURL=loadAndBundleSpec.test.js.map

package/lib/utils/__tests__/local-storage.test.d.ts

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

package/lib/utils/__tests__/local-storage.test.js

@@ -1,48 +0,0 @@
-import { toLocalStorage, fromLocalStorage } from '../local-storage.js';
-vi.mock('@redocly/theme/core/openapi', () => ({
-    IS_BROWSER: true,
-}));
-describe('local-storage', () => {
-    let mockLocalStorage;
-    beforeEach(() => {
-        mockLocalStorage = {};
-        Object.defineProperty(window, 'localStorage', {
-            value: {
-                setItem: vi.fn((key, value) => {
-                    mockLocalStorage[key] = value;
-                }),
-                getItem: vi.fn((key) => {
-                    return mockLocalStorage[key] || null;
-                }),
-            },
-            writable: true,
-        });
-    });
-    afterEach(() => {
-        vi.clearAllMocks();
-    });
-    describe('toLocalStorage', () => {
-        it('should store value with redoc prefix', () => {
-            toLocalStorage('test-key', 'test-value');
-            expect(window.localStorage.setItem).toHaveBeenCalledWith('redoc.test-key', 'test-value');
-        });
-    });
-    describe('fromLocalStorage', () => {
-        it('should retrieve value with redoc prefix', () => {
-            mockLocalStorage['redoc.test-key'] = 'test-value';
-            const result = fromLocalStorage('test-key');
-            expect(window.localStorage.getItem).toHaveBeenCalledWith('redoc.test-key');
-            expect(result).toBe('test-value');
-        });
-        it('should return empty string when key does not exist', () => {
-            const result = fromLocalStorage('non-existent-key');
-            expect(result).toBe('');
-        });
-        it('should return empty string when value is null', () => {
-            mockLocalStorage['redoc.test-key'] = null;
-            const result = fromLocalStorage('test-key');
-            expect(result).toBe('');
-        });
-    });
-});
-//# sourceMappingURL=local-storage.test.js.map

package/lib/utils/__tests__/object.test.d.ts

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

package/lib/utils/__tests__/object.test.js

@@ -1,45 +0,0 @@
-import { objectHas, objectSet } from '../object.js';
-describe('object utils', () => {
-    let obj;
-    beforeEach(() => {
-        obj = {
-            a: {
-                b: {
-                    c: {
-                        d: 'd',
-                    },
-                    c1: 'c1',
-                },
-                b1: 'b1',
-            },
-            a1: 'a1',
-        };
-    });
-    describe('objectHas function', () => {
-        it('should check if the obj has path as string', () => {
-            expect(objectHas(obj, 'a.b.c')).toBeTruthy();
-            expect(objectHas(obj, 'a.b.c1')).toBeTruthy();
-            expect(objectHas(obj, 'a.b.c.d')).toBeTruthy();
-            expect(objectHas(obj, 'a.b.c1.d')).toBeFalsy();
-        });
-        it('should check if the obj has path as array', () => {
-            expect(objectHas(obj, ['a', 'b', 'c'])).toBeTruthy();
-            expect(objectHas(obj, ['a', 'b', 'c1'])).toBeTruthy();
-            expect(objectHas(obj, ['a', 'b', 'c', 'd'])).toBeTruthy();
-            expect(objectHas(obj, ['a', 'b', 'c1', 'd'])).toBeFalsy();
-        });
-    });
-    describe('objectSet function', () => {
-        it('should set value by path as string', () => {
-            expect(objectHas(obj, 'a.b.c1.d')).toBeFalsy();
-            objectSet(obj, 'a.b.c1', { d: 'd' });
-            expect(objectHas(obj, 'a.b.c1.d')).toBeTruthy();
-        });
-        it('should set value by path as array', () => {
-            expect(objectHas(obj, ['a', 'b', 'c1', 'd'])).toBeFalsy();
-            objectSet(obj, ['a', 'b', 'c1'], { d: 'd' });
-            expect(objectHas(obj, ['a', 'b', 'c1', 'd'])).toBeTruthy();
-        });
-    });
-});
-//# sourceMappingURL=object.test.js.map

package/lib/utils/__tests__/openapi.test.d.ts

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