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

package/lib/services/menu/__tests__/tags.test.js

@@ -0,0 +1,71 @@
+import { processOperation } from '../tags.js';
+describe('processOperation', () => {
+    let parser;
+    let tagsMap;
+    beforeEach(() => {
+        parser = {
+            definition: {},
+            deref: vi.fn().mockReturnValue({ resolved: {} }),
+        };
+        tagsMap = {};
+    });
+    it('adds operation to existing tag', () => {
+        const operationInfo = { summary: 'Test op', tags: ['tag1'] };
+        tagsMap['tag1'] = { name: 'tag1', operations: [] };
+        processOperation(parser, 'get', operationInfo, '/path', {}, tagsMap);
+        expect(tagsMap['tag1'].operations).toHaveLength(1);
+        expect(tagsMap['tag1'].operations[0].summary).toBe('Test op');
+    });
+    it('creates tag if it does not exist', () => {
+        const operationInfo = { summary: 'New op', tags: ['newTag'] };
+        processOperation(parser, 'post', operationInfo, '/path', {}, tagsMap);
+        expect(tagsMap['newTag']).toBeDefined();
+        expect(tagsMap['newTag'].operations[0].summary).toBe('New op');
+    });
+    it('assigns empty tag if operation has no tags', () => {
+        const operationInfo = { summary: 'No tag op' };
+        processOperation(parser, 'put', operationInfo, '/path', {}, tagsMap);
+        expect(tagsMap['']).toBeDefined();
+        expect(tagsMap[''].operations[0].httpVerb).toBe('put');
+    });
+    it('assigns default webhook tag if isWebhook is true and no tags', () => {
+        const operationInfo = { summary: 'Webhook op' };
+        processOperation(parser, 'post', operationInfo, '/webhook', {}, tagsMap, true);
+        expect(tagsMap['webhooks']).toBeDefined();
+        expect(tagsMap['webhooks'].operations[0].isWebhook).toBe(true);
+    });
+    it('skips operations with x-traitTag', () => {
+        const operationInfo = { summary: 'Trait op', tags: ['traitTag'] };
+        tagsMap['traitTag'] = { name: 'traitTag', operations: [], 'x-traitTag': true };
+        processOperation(parser, 'get', operationInfo, '/path', {}, tagsMap);
+        expect(tagsMap['traitTag'].operations).toHaveLength(0);
+    });
+    it('processes additionalOperations correctly', () => {
+        const path = {
+            additionalOperations: {
+                test: { summary: 'Additional op', tags: ['tag2'] },
+            },
+        };
+        tagsMap['tag2'] = { name: 'tag2', operations: [] };
+        processOperation(parser, 'test', path.additionalOperations.test, '/path', path, tagsMap, false, true);
+        expect(tagsMap['tag2'].operations).toHaveLength(1);
+        expect(tagsMap['tag2'].operations[0].isAdditionalOperation).toBe(true);
+    });
+    it('assigns query tag if operation is x-query', () => {
+        const operationInfo = { summary: 'Query op', tags: ['query'] };
+        const path = { 'x-query': operationInfo };
+        tagsMap['query'] = { name: 'query', operations: [] };
+        processOperation(parser, 'x-query', operationInfo, '/path', path, tagsMap);
+        expect(tagsMap['query'].operations).toHaveLength(1);
+        expect(tagsMap['query'].operations[0].httpVerb).toBe('query');
+    });
+    it('keeps httpVerb as query if operation name is query (OpenAPI 3.2.0)', () => {
+        const operationInfo = { summary: 'Query op', tags: ['query'] };
+        const path = { query: operationInfo };
+        tagsMap['query'] = { name: 'query', operations: [] };
+        processOperation(parser, 'query', operationInfo, '/path', path, tagsMap);
+        expect(tagsMap['query'].operations).toHaveLength(1);
+        expect(tagsMap['query'].operations[0].httpVerb).toBe('query');
+    });
+});
+//# sourceMappingURL=tags.test.js.map

package/lib/telemetry/RedocTelemetry.js

@@ -1 +1,31 @@
-import{Telemetry as o}from"@redocly/redoc-opentelemetry";import c from"../../package.json"with{type:"json"};const p="https://otel.cloud.redocly.com/v1/traces";class n extends o{specType;constructor(e){super(),this.specType=e.specType,this.init({otel:{isProd:process.env.NODE_ENV==="production"||process.env.ENABLE_LOCAL_TELEMETRY==="true",serviceVersion:e.serviceVersion||`${c.name}@${c.version}`,version:"1.0.0",collectorTraceUrl:e.collectorUrl||p,serviceName:e.serviceName||"redoc-ce",tracerName:"client-telemetry"},disabled:e.disabled||!1})}send(e,r){r&&Array.isArray(r)&&r.length>0&&(r=r.map(s=>s&&typeof s=="object"?{...s,specType:this.specType}:s)),super.send(e,r,{env:process.env.NODE_ENV})}}export{n as RedocTelemetry};
+import { Telemetry } from '@redocly/redoc-opentelemetry';
+import pkg from '../../package.json' with { type: 'json' };
+const OTEL_TRACES_URL = 'https://otel.cloud.redocly.com/v1/traces';
+export class RedocTelemetry extends Telemetry {
+    specType;
+    constructor(config) {
+        super();
+        this.specType = config.specType;
+        this.init({
+            otel: {
+                isProd: process.env.NODE_ENV === 'production' || process.env.ENABLE_LOCAL_TELEMETRY === 'true',
+                serviceVersion: config.serviceVersion || `${pkg.name}@${pkg.version}`,
+                version: '1.0.0',
+                collectorTraceUrl: config.collectorUrl || OTEL_TRACES_URL,
+                serviceName: config.serviceName || 'redoc-ce',
+                tracerName: 'client-telemetry',
+            },
+            disabled: config.disabled || false,
+        });
+    }
+    // TODO: remove this once we have a proper way to enrich the data
+    send(event, data) {
+        if (data && Array.isArray(data) && data.length > 0) {
+            data = data.map((item) => item && typeof item === 'object' ? { ...item, specType: this.specType } : item);
+        }
+        super.send(event, data, {
+            env: process.env.NODE_ENV,
+        });
+    }
+}
+//# sourceMappingURL=RedocTelemetry.js.map

package/lib/telemetry/__tests__/RedocTelemetry.test.d.ts

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

package/lib/telemetry/__tests__/RedocTelemetry.test.js

@@ -0,0 +1,107 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+const initMock = vi.fn();
+const sendMock = vi.fn();
+vi.mock('@redocly/redoc-opentelemetry', () => ({
+    Telemetry: class Telemetry {
+        init(config) {
+            initMock(config);
+        }
+        send(event, data) {
+            sendMock(event, data);
+        }
+    },
+}));
+import { RedocTelemetry } from '../RedocTelemetry.js';
+describe('RedocTelemetry', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('constructor', () => {
+        it('calls init with default collector URL and service name when not provided', () => {
+            new RedocTelemetry({
+                specType: 'openapi',
+                serviceVersion: '1.0.0',
+            });
+            expect(initMock).toHaveBeenCalledTimes(1);
+            expect(initMock).toHaveBeenCalledWith(expect.objectContaining({
+                otel: expect.objectContaining({
+                    collectorTraceUrl: 'https://otel.cloud.redocly.com/v1/traces',
+                    serviceName: 'redoc-ce',
+                    serviceVersion: '1.0.0',
+                }),
+            }));
+        });
+        it('calls init with custom collectorUrl and serviceName when provided', () => {
+            new RedocTelemetry({
+                specType: 'asyncapi',
+                serviceVersion: '2.0.0',
+                collectorUrl: 'https://custom.example.com/v1/traces',
+                serviceName: 'custom-service',
+            });
+            expect(initMock).toHaveBeenCalledWith(expect.objectContaining({
+                otel: expect.objectContaining({
+                    collectorTraceUrl: 'https://custom.example.com/v1/traces',
+                    serviceName: 'custom-service',
+                    serviceVersion: '2.0.0',
+                }),
+            }));
+        });
+        it('calls init with disabled when config.disabled is true', () => {
+            new RedocTelemetry({
+                specType: 'graphql',
+                serviceVersion: '1.0.0',
+                disabled: true,
+            });
+            expect(initMock).toHaveBeenCalledWith(expect.objectContaining({
+                disabled: true,
+            }));
+        });
+    });
+    describe('send', () => {
+        it('calls super.send with event and undefined when data is omitted', () => {
+            const telemetry = new RedocTelemetry({
+                specType: 'openapi',
+                serviceVersion: '1.0.0',
+            });
+            telemetry.send('Viewed');
+            expect(sendMock).toHaveBeenCalledTimes(1);
+            expect(sendMock).toHaveBeenCalledWith('Viewed', undefined);
+        });
+        it('calls super.send with event and data when data is not an array', () => {
+            const telemetry = new RedocTelemetry({
+                specType: 'openapi',
+                serviceVersion: '1.0.0',
+            });
+            const data = { foo: 'bar' };
+            telemetry.send('Viewed', data);
+            expect(sendMock).toHaveBeenCalledWith('Viewed', data);
+        });
+        it('enriches each object in array data with specType and calls super.send', () => {
+            const telemetry = new RedocTelemetry({
+                specType: 'asyncapi',
+                serviceVersion: '1.0.0',
+            });
+            const data = [{ id: 'a' }, { id: 'b' }];
+            telemetry.send('Viewed', data);
+            expect(sendMock).toHaveBeenCalledWith('Viewed', [
+                { id: 'a', specType: 'asyncapi' },
+                { id: 'b', specType: 'asyncapi' },
+            ]);
+        });
+        it('passes through non-object array items unchanged', () => {
+            const telemetry = new RedocTelemetry({
+                specType: 'openapi',
+                serviceVersion: '1.0.0',
+            });
+            const data = [{ id: 'a' }, null, 'string', 42];
+            telemetry.send('Viewed', data);
+            expect(sendMock).toHaveBeenCalledWith('Viewed', [
+                { id: 'a', specType: 'openapi' },
+                null,
+                'string',
+                42,
+            ]);
+        });
+    });
+});
+//# sourceMappingURL=RedocTelemetry.test.js.map

package/lib/testProviders.d.ts

@@ -0,0 +1,6 @@
+import type { ReactNode, ReactElement } from 'react';
+import type { StoreProviderProps } from './components';
+import type { BrowserRouterProps, MemoryRouterProps } from 'react-router';
+export declare function TestBrowserRouter({ children, ...props }: BrowserRouterProps): ReactElement;
+export declare function TestMemoryRouter({ children, ...props }: MemoryRouterProps): ReactElement;
+export declare function withTestProviders(children: ReactNode, store?: StoreProviderProps): ReactElement;

package/lib/testProviders.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Children } from 'react';
+import { BrowserRouter, MemoryRouter } from 'react-router';
+import { StoreProvider } from './components';
+export function TestBrowserRouter({ children, ...props }) {
+    return _jsx(BrowserRouter, { ...props, children: children });
+}
+export function TestMemoryRouter({ children, ...props }) {
+    return _jsx(MemoryRouter, { ...props, children: children });
+}
+export function withTestProviders(children, store) {
+    return (_jsx(StoreProvider, { ...(store || { definition: { openapi: '3.0.0' } }), children: Children.only(children) }));
+}
+//# sourceMappingURL=testProviders.js.map

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

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

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

@@ -0,0 +1,33 @@
+import { areArraysEqual } from '../areArraysEqual.js';
+describe('areArraysEqual', () => {
+    it('should return true for two empty arrays', () => {
+        expect(areArraysEqual([], [])).toBe(true);
+    });
+    it('should return true for two identical arrays of primitives', () => {
+        expect(areArraysEqual([1, 2, 3], [1, 2, 3])).toBe(true);
+    });
+    it('should return false for arrays of different lengths', () => {
+        expect(areArraysEqual([1, 2, 3], [1, 2])).toBe(false);
+    });
+    it('should return false for arrays with the same length but different values', () => {
+        expect(areArraysEqual([1, 2, 3], [1, 2, 4])).toBe(false);
+    });
+    it('should return true for two identical arrays of strings', () => {
+        expect(areArraysEqual(['a', 'b', 'c'], ['a', 'b', 'c'])).toBe(true);
+    });
+    it('should return false for arrays with different types', () => {
+        expect(areArraysEqual([1, '2', 3], [1, 2, 3])).toBe(false);
+    });
+    it('should handle arrays with undefined and null values correctly', () => {
+        expect(areArraysEqual([undefined, null], [undefined, null])).toBe(true);
+        expect(areArraysEqual([undefined, null], [null, undefined])).toBe(false);
+    });
+    it('should handle arrays with objects and arrays by reference equality', () => {
+        const obj1 = { a: 1 };
+        const obj2 = { a: 1 };
+        expect(areArraysEqual([obj1], [obj1])).toBe(true);
+        expect(areArraysEqual([obj1], [obj2])).toBe(false);
+        expect(areArraysEqual([[1, 2]], [[1, 2]])).toBe(false);
+    });
+});
+//# sourceMappingURL=areArraysEqual.test.js.map

package/lib/utils/__tests__/argValuesHelpers.d.ts

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

package/lib/utils/__tests__/argValuesHelpers.js

@@ -0,0 +1,56 @@
+import { argValueToBoolean, argValueToExpandLevel, argValueToInt, argValueToNumber, } from '../argValuesHelpers';
+describe('argValuesHelpers tests', () => {
+    describe('argValueToBoolean function test', () => {
+        it('should return true when passing boolean value', () => {
+            const result = argValueToBoolean(true);
+            expect(result).toBe(true);
+        });
+        it('should return false value when nothing passing', () => {
+            const result = argValueToBoolean();
+            expect(result).toBe(false);
+        });
+        it('should return true whe passing some string', () => {
+            const result = argValueToBoolean('test');
+            expect(result).toBe(true);
+        });
+        it('should return false whe passing some `false` string', () => {
+            const result = argValueToBoolean('false');
+            expect(result).toBe(false);
+        });
+    });
+    describe('argValueToExpandLevel function test', () => {
+        it('should return Infinity when passing `all`', () => {
+            const result = argValueToExpandLevel('all');
+            expect(result).toBe(Infinity);
+        });
+        it('should return undefined when call without arguments', () => {
+            const result = argValueToExpandLevel();
+            expect(result).toBe(undefined);
+        });
+    });
+    describe('argValueToInt function test', () => {
+        it('should convert string number to number', () => {
+            const result = argValueToInt('22');
+            expect(result).toBe(22);
+        });
+        it('should Math.ceil number', () => {
+            const result = argValueToInt(22.4);
+            expect(result).toBe(23);
+        });
+    });
+    describe('argValueToNumber function test', () => {
+        it('should return exact number', () => {
+            const result = argValueToNumber(22);
+            expect(result).toBe(22);
+        });
+        it('should parse string to number', () => {
+            const result = argValueToNumber('22');
+            expect(result).toBe(22);
+        });
+        it('should return default value', () => {
+            expect(argValueToNumber(undefined)).toBe(0);
+            expect(argValueToNumber(undefined, 2)).toBe(2);
+        });
+    });
+});
+//# sourceMappingURL=argValuesHelpers.js.map

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

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

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

@@ -0,0 +1,119 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { calculateMaxLength } from '../calculateMaxLength.js';
+describe('calculateMaxLength', () => {
+    let measureEl;
+    beforeEach(() => {
+        measureEl = {
+            textContent: '',
+            scrollWidth: 0,
+        };
+    });
+    it('should return BREADCRUMB_MIN_LENGTH (10) when breadcrumbs array is empty', () => {
+        const result = calculateMaxLength([], 500, false, measureEl);
+        expect(result).toBe(10);
+    });
+    it('should return BREADCRUMB_MIN_LENGTH when availableWidth is zero or negative', () => {
+        const breadcrumbs = [
+            { name: 'Home', href: '/' },
+            { name: 'Products', href: '/products' },
+        ];
+        expect(calculateMaxLength(breadcrumbs, 0, false, measureEl)).toBe(10);
+        expect(calculateMaxLength(breadcrumbs, -100, false, measureEl)).toBe(10);
+    });
+    it('should account for DROPDOWN_TRIGGER_WIDTH (40) when collapsed', () => {
+        const breadcrumbs = [
+            { name: 'Short', href: '/' },
+            { name: 'Name', href: '/name' },
+        ];
+        let callCount = 0;
+        Object.defineProperty(measureEl, 'scrollWidth', {
+            get() {
+                callCount++;
+                if (callCount === 1)
+                    return 5;
+                return this.textContent.length * 8;
+            },
+            configurable: true,
+        });
+        const collapsedResult = calculateMaxLength(breadcrumbs, 200, true, measureEl);
+        callCount = 0;
+        const expandedResult = calculateMaxLength(breadcrumbs, 200, false, measureEl);
+        expect(collapsedResult).toBeLessThanOrEqual(expandedResult);
+    });
+    it('should return max name length when breadcrumbs fit comfortably', () => {
+        const breadcrumbs = [
+            { name: 'Home', href: '/' },
+            { name: 'Products', href: '/products' },
+            { name: 'Electronics', href: '/electronics' },
+        ];
+        Object.defineProperty(measureEl, 'scrollWidth', {
+            get() {
+                return this.textContent === '/' ? 5 : this.textContent.length * 8;
+            },
+            configurable: true,
+        });
+        const result = calculateMaxLength(breadcrumbs, 1000, false, measureEl);
+        const maxNameLength = Math.max(...breadcrumbs.map((b) => b.name.length));
+        expect(result).toBe(maxNameLength);
+    });
+    it('should limit max length when available width is constrained', () => {
+        const breadcrumbs = [
+            { name: 'VeryLongBreadcrumbName', href: '/' },
+            { name: 'AnotherLongName', href: '/another' },
+        ];
+        Object.defineProperty(measureEl, 'scrollWidth', {
+            get() {
+                return this.textContent === '/' ? 5 : this.textContent.length * 8;
+            },
+            configurable: true,
+        });
+        const result = calculateMaxLength(breadcrumbs, 150, false, measureEl);
+        expect(result).toBeLessThan(breadcrumbs[0].name.length);
+        expect(result).toBeGreaterThanOrEqual(10);
+    });
+    it('should handle breadcrumbs with varying name lengths', () => {
+        const breadcrumbs = [
+            { name: 'Short', href: '/' },
+            { name: 'MediumLength', href: '/medium' },
+            { name: 'VeryVeryLongBreadcrumbName', href: '/long' },
+        ];
+        Object.defineProperty(measureEl, 'scrollWidth', {
+            get() {
+                return this.textContent === '/' ? 5 : this.textContent.length * 8;
+            },
+            configurable: true,
+        });
+        const result = calculateMaxLength(breadcrumbs, 300, false, measureEl);
+        expect(result).toBeGreaterThanOrEqual(10);
+        expect(result).toBeLessThanOrEqual(breadcrumbs[2].name.length);
+    });
+    it('should handle many breadcrumbs with limited width', () => {
+        const breadcrumbs = Array.from({ length: 10 }, (_, i) => ({
+            name: `Level${i + 1}`,
+            href: `/level${i + 1}`,
+        }));
+        Object.defineProperty(measureEl, 'scrollWidth', {
+            get() {
+                return this.textContent === '/' ? 5 : this.textContent.length * 8;
+            },
+            configurable: true,
+        });
+        const result = calculateMaxLength(breadcrumbs, 400, false, measureEl);
+        expect(result).toBeGreaterThanOrEqual(10);
+    });
+    it('should enforce minimum length even with very constrained space', () => {
+        const breadcrumbs = [
+            { name: 'A', href: '/' },
+            { name: 'B', href: '/b' },
+        ];
+        Object.defineProperty(measureEl, 'scrollWidth', {
+            get() {
+                return this.textContent === '/' ? 50 : this.textContent.length * 100;
+            },
+            configurable: true,
+        });
+        const result = calculateMaxLength(breadcrumbs, 50, false, measureEl);
+        expect(result).toBe(10);
+    });
+});
+//# sourceMappingURL=calculateMaxLength.test.js.map

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

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