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

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

@@ -1,109 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { buildNestedTagsItems } from '../tags.js';
-import { normalizeOptions } from '../../config-options/index.js';
-import { DEFAULT_WEBHOOKS_TAG_NAME } from '../../../constants.js';
-vi.mock('../operation.js', async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        getOperationsItems: vi.fn((_parent, tag) => {
-            if (tag.operations && tag.operations.length > 0) {
-                return [
-                    {
-                        id: 'test-operation',
-                        type: 'operation',
-                        name: 'Test Operation',
-                        httpVerb: tag.operations[0].httpVerb || 'get',
-                        path: tag.operations[0].pathName || '/test',
-                        depth: 1,
-                        items: [],
-                        deprecated: false,
-                        isWebhook: tag.operations[0].isWebhook || false,
-                        isAdditionalOperation: tag.operations[0].isAdditionalOperation || false,
-                        operationDefinition: tag.operations[0],
-                        href: '/test-operation',
-                    },
-                ];
-            }
-            return [];
-        }),
-    };
-});
-vi.mock('../markdown.js', () => ({
-    addMarkdownItems: vi.fn(() => []),
-}));
-describe('buildNestedTagsItems', () => {
-    let parser;
-    let options;
-    let tagsMap;
-    beforeEach(() => {
-        parser = {
-            definition: {
-                components: {
-                    schemas: {},
-                },
-            },
-        };
-        options = normalizeOptions({});
-        tagsMap = {};
-    });
-    it('should filter tags by kind (only include undefined or nav)', () => {
-        tagsMap = {
-            tag1: { name: 'tag1', operations: [] },
-            tag2: { name: 'tag2', operations: [], kind: 'nav' },
-            tag3: { name: 'tag3', operations: [], kind: 'badge' },
-        };
-        const result = buildNestedTagsItems(parser, tagsMap, undefined, options);
-        const tagNames = result.map((item) => item.name);
-        expect(tagNames).toContain('tag1');
-        expect(tagNames).toContain('tag2');
-        expect(tagNames).not.toContain('tag3');
-    });
-    it('should build nested structure with parent-child relationships', () => {
-        tagsMap = {
-            parent: { name: 'parent', operations: [] },
-            child: { name: 'child', operations: [], parent: 'parent' },
-        };
-        const result = buildNestedTagsItems(parser, tagsMap, undefined, options);
-        expect(result).toHaveLength(1);
-        expect(result[0].name).toBe('parent');
-        expect(result[0].items.some((item) => item.name === 'child')).toBe(true);
-    });
-    it('should respect MAX_NESTING_LEVELS limit', () => {
-        tagsMap = {
-            level1: { name: 'level1', operations: [] },
-            level2: { name: 'level2', operations: [], parent: 'level1' },
-            level3: { name: 'level3', operations: [], parent: 'level2' },
-            level4: { name: 'level4', operations: [], parent: 'level3' },
-            level5: { name: 'level5', operations: [], parent: 'level4' },
-            level6: { name: 'level6', operations: [], parent: 'level5' },
-        };
-        const result = buildNestedTagsItems(parser, tagsMap, undefined, options);
-        const findTagByName = (items, name) => {
-            for (const item of items) {
-                if (item.name === name)
-                    return item;
-                if (item.items) {
-                    const found = findTagByName(item.items, name);
-                    if (found)
-                        return found;
-                }
-            }
-            return null;
-        };
-        expect(findTagByName(result, 'level1')).toBeDefined();
-        expect(findTagByName(result, 'level5')).toBeDefined();
-        expect(findTagByName(result, 'level6')).toBeNull();
-    });
-    it('should filter out default webhooks tag if it has no items', () => {
-        tagsMap = {
-            [DEFAULT_WEBHOOKS_TAG_NAME]: { name: DEFAULT_WEBHOOKS_TAG_NAME, operations: [] },
-            regularTag: { name: 'regularTag', operations: [] },
-        };
-        const result = buildNestedTagsItems(parser, tagsMap, undefined, options);
-        const webhookTag = result.find((item) => item.name === DEFAULT_WEBHOOKS_TAG_NAME);
-        expect(webhookTag).toBeUndefined();
-        expect(result.some((item) => item.name === 'regularTag')).toBe(true);
-    });
-});
-//# sourceMappingURL=buildNestedTagsItems.test.js.map

package/lib/services/menu/__tests__/builder.test.d.ts

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

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

@@ -1,307 +0,0 @@
-import { normalizeOptions } from '../../config-options/index.js';
-import { OpenAPIParser } from '../../OpenAPIParser.js';
-import { buildMenuStructure } from '../builder.js';
-import { addMarkdownItems } from '../markdown.js';
-const opts = normalizeOptions({});
-describe('Menu', () => {
-    describe('builder', () => {
-        let parser;
-        test('should resolve pathItems', async () => {
-            const spec = (await import('./fixtures/pathItems.json'))
-                .default;
-            parser = new OpenAPIParser(spec, undefined, opts);
-            const contentItems = buildMenuStructure(parser, opts);
-            expect(contentItems).toHaveLength(3);
-            expect(contentItems[1].items).toHaveLength(1);
-            expect(contentItems[1].id).toEqual('pet2');
-            expect(contentItems[1].name).toEqual('pet2');
-            expect(contentItems[1].type).toEqual('tag');
-            expect(contentItems[2].items).toHaveLength(1);
-            expect(contentItems[2].id).toEqual('pet');
-            expect(contentItems[2].name).toEqual('pet');
-            expect(contentItems[2].type).toEqual('tag');
-        });
-        test('should include operations from additionalOperations', () => {
-            const spec = {
-                openapi: '3.2.0',
-                info: { title: 'Test API', version: '1.0.0' },
-                tags: [{ name: 'operations' }],
-                paths: {
-                    '/test': {
-                        get: {
-                            summary: 'Get test',
-                            tags: ['operations'],
-                            responses: { '200': { description: 'Success' } },
-                        },
-                        additionalOperations: {
-                            test: {
-                                summary: 'Custom TEST method',
-                                tags: ['operations'],
-                                responses: { '200': { description: 'Success' } },
-                            },
-                        },
-                    },
-                },
-            };
-            parser = new OpenAPIParser(spec, undefined, opts);
-            const contentItems = buildMenuStructure(parser, opts);
-            const operationsTag = contentItems.find((item) => item.id === 'operations');
-            expect(operationsTag).toBeDefined();
-            expect(operationsTag?.items).toHaveLength(2);
-            const getOperation = operationsTag?.items.find((item) => item.type === 'operation' && item.httpVerb === 'get');
-            expect(getOperation).toBeDefined();
-            expect(getOperation.type).toBe('operation');
-            const testOperation = operationsTag?.items.find((item) => item.type === 'operation' && item.httpVerb === 'test');
-            expect(testOperation).toBeDefined();
-            expect(testOperation.type).toBe('operation');
-            expect(testOperation.name).toContain('TEST');
-        });
-        test('should handle paths with only additionalOperations', () => {
-            const spec = {
-                openapi: '3.2.0',
-                info: { title: 'Test API', version: '1.0.0' },
-                tags: [{ name: 'custom' }],
-                paths: {
-                    '/custom-only': {
-                        additionalOperations: {
-                            greet: {
-                                summary: 'Custom GREET method',
-                                tags: ['custom'],
-                                responses: { '200': { description: 'Success' } },
-                            },
-                            wave: {
-                                summary: 'Custom WAVE method',
-                                tags: ['custom'],
-                                responses: { '200': { description: 'Success' } },
-                            },
-                        },
-                    },
-                },
-            };
-            parser = new OpenAPIParser(spec, undefined, opts);
-            const contentItems = buildMenuStructure(parser, opts);
-            const customTag = contentItems.find((item) => item.id === 'custom');
-            expect(customTag).toBeDefined();
-            expect(customTag?.items).toHaveLength(2);
-            const greetOperation = customTag?.items.find((item) => item.type === 'operation' && item.httpVerb === 'greet');
-            expect(greetOperation).toBeDefined();
-            const waveOperation = customTag?.items.find((item) => item.type === 'operation' && item.httpVerb === 'wave');
-            expect(waveOperation).toBeDefined();
-        });
-        test('should not fail when additionalOperations is empty', () => {
-            const spec = {
-                openapi: '3.2.0',
-                info: { title: 'Test API', version: '1.0.0' },
-                tags: [{ name: 'operations' }],
-                paths: {
-                    '/test': {
-                        get: {
-                            summary: 'Get test',
-                            tags: ['operations'],
-                            responses: { '200': { description: 'Success' } },
-                        },
-                        additionalOperations: {},
-                    },
-                },
-            };
-            parser = new OpenAPIParser(spec, undefined, opts);
-            const contentItems = buildMenuStructure(parser, opts);
-            const operationsTag = contentItems.find((item) => item.id === 'operations');
-            expect(operationsTag).toBeDefined();
-            expect(operationsTag?.items).toHaveLength(1);
-        });
-        describe('hasNestedTags logic', () => {
-            test('should use buildNestedTagsItems when tags have parent property', () => {
-                const spec = {
-                    openapi: '3.2.0',
-                    info: { title: 'Test API', version: '1.0.0' },
-                    tags: [{ name: 'parent-tag' }, { name: 'child-tag', parent: 'parent-tag' }],
-                    paths: {
-                        '/parent': {
-                            get: {
-                                summary: 'Parent operation',
-                                tags: ['parent-tag'],
-                                responses: { '200': { description: 'Success' } },
-                            },
-                        },
-                        '/child': {
-                            get: {
-                                summary: 'Child operation',
-                                tags: ['child-tag'],
-                                responses: { '200': { description: 'Success' } },
-                            },
-                        },
-                    },
-                };
-                parser = new OpenAPIParser(spec, undefined, opts);
-                const contentItems = buildMenuStructure(parser, opts);
-                const parentTag = contentItems.find((item) => item.id === 'parent-tag');
-                expect(parentTag).toBeDefined();
-                expect(parentTag?.type).toBe('tag');
-                const childTagInParent = parentTag?.items?.find((item) => item.id === 'parent-tag/child-tag');
-                expect(childTagInParent).toBeDefined();
-                expect(childTagInParent?.type).toBe('tag');
-            });
-            test('should use getTagGroupsItems when tags do not have parent property but x-tagGroups exists', () => {
-                const spec = {
-                    openapi: '3.2.0',
-                    info: { title: 'Test API', version: '1.0.0' },
-                    tags: [{ name: 'tag1' }, { name: 'tag2' }],
-                    'x-tagGroups': [
-                        {
-                            name: 'Group 1',
-                            tags: ['tag1', 'tag2'],
-                        },
-                    ],
-                    paths: {
-                        '/test1': {
-                            get: {
-                                summary: 'Test 1',
-                                tags: ['tag1'],
-                                responses: { '200': { description: 'Success' } },
-                            },
-                        },
-                        '/test2': {
-                            get: {
-                                summary: 'Test 2',
-                                tags: ['tag2'],
-                                responses: { '200': { description: 'Success' } },
-                            },
-                        },
-                    },
-                };
-                parser = new OpenAPIParser(spec, undefined, opts);
-                const contentItems = buildMenuStructure(parser, opts);
-                const group = contentItems.find((item) => item.name === 'Group 1');
-                expect(group).toBeDefined();
-                expect(group?.type).toBe('group');
-                const tag1 = group?.items?.find((item) => item.id === 'tag1');
-                const tag2 = group?.items?.find((item) => item.id === 'tag2');
-                expect(tag1).toBeDefined();
-                expect(tag1?.type).toBe('tag');
-                expect(tag2).toBeDefined();
-                expect(tag2?.type).toBe('tag');
-            });
-            test('should use getTagsItems when tags do not have parent property and no x-tagGroups', () => {
-                const spec = {
-                    openapi: '3.2.0',
-                    info: { title: 'Test API', version: '1.0.0' },
-                    tags: [{ name: 'tag1' }, { name: 'tag2' }],
-                    paths: {
-                        '/test1': {
-                            get: {
-                                summary: 'Test 1',
-                                tags: ['tag1'],
-                                responses: { '200': { description: 'Success' } },
-                            },
-                        },
-                        '/test2': {
-                            get: {
-                                summary: 'Test 2',
-                                tags: ['tag2'],
-                                responses: { '200': { description: 'Success' } },
-                            },
-                        },
-                    },
-                };
-                parser = new OpenAPIParser(spec, undefined, opts);
-                const contentItems = buildMenuStructure(parser, opts);
-                const tag1 = contentItems.find((item) => item.id === 'tag1');
-                const tag2 = contentItems.find((item) => item.id === 'tag2');
-                expect(tag1).toBeDefined();
-                expect(tag1?.type).toBe('tag');
-                expect(tag2).toBeDefined();
-                expect(tag2?.type).toBe('tag');
-                expect(tag1?.items?.some((item) => item.id === 'tag2')).toBeFalsy();
-            });
-            test('should prioritize nested tags over x-tagGroups when both exist', () => {
-                const spec = {
-                    openapi: '3.2.0',
-                    info: { title: 'Test API', version: '1.0.0' },
-                    tags: [{ name: 'parent-tag' }, { name: 'child-tag', parent: 'parent-tag' }],
-                    'x-tagGroups': [
-                        {
-                            name: 'Group 1',
-                            tags: ['parent-tag', 'child-tag'],
-                        },
-                    ],
-                    paths: {
-                        '/parent': {
-                            get: {
-                                summary: 'Parent operation',
-                                tags: ['parent-tag'],
-                                responses: { '200': { description: 'Success' } },
-                            },
-                        },
-                        '/child': {
-                            get: {
-                                summary: 'Child operation',
-                                tags: ['child-tag'],
-                                responses: { '200': { description: 'Success' } },
-                            },
-                        },
-                    },
-                };
-                parser = new OpenAPIParser(spec, undefined, opts);
-                const contentItems = buildMenuStructure(parser, opts);
-                const parentTag = contentItems.find((item) => item.id === 'parent-tag');
-                expect(parentTag).toBeDefined();
-                expect(parentTag?.type).toBe('tag');
-                const group = contentItems.find((item) => item.name === 'Group 1');
-                expect(group).toBeUndefined();
-                const childTagInParent = parentTag?.items?.find((item) => item.id === 'parent-tag/child-tag');
-                expect(childTagInParent).toBeDefined();
-                expect(childTagInParent?.type).toBe('tag');
-            });
-        });
-    });
-    describe('addMarkdownItems', () => {
-        test('should resolve heading with children', () => {
-            const markdown = `# [Petstore sample](http://petstore.swagger.io/) provided by [swagger.io](http://swagger.io) team `;
-            const contentItems = addMarkdownItems(markdown, undefined, 1);
-            expect(contentItems[0].name).toEqual('Petstore sample');
-        });
-        test('should resolve headings with custom id', () => {
-            const markdown = `# Petstore sample team {% #my-id %}`;
-            const contentItems = addMarkdownItems(markdown, undefined, 1);
-            expect(contentItems[0].name).toEqual('Petstore sample team ');
-            expect(contentItems[0].id).toEqual('my-id');
-        });
-        test('should create a menu item from a level 2 header', () => {
-            const markdown = `## Custom section 1 \n Nullam pretium erat ut augue mollis, id varius orci pretium.`;
-            const contentItems = addMarkdownItems(markdown, {
-                id: 'pet',
-                type: 'tag',
-                items: [],
-                name: 'user',
-                level: 1,
-                depth: 1,
-                href: 'pet',
-            }, 2);
-            expect(contentItems[0]?.['ast']?.length).toEqual(2);
-        });
-        test.each([['# Users'], ['## Users'], ['### Users'], ['#### Users'], ['##### Users']])('should handle identical headers of different levels across different tag descriptions %s', (markdown) => {
-            const resultA = addMarkdownItems(markdown, {
-                id: 'tag-a',
-                type: 'tag',
-                items: [],
-                name: 'Tag A',
-                level: 1,
-                depth: 1,
-                href: 'tag-a',
-            }, 0);
-            const resultB = addMarkdownItems(markdown, {
-                id: 'tag-b',
-                type: 'tag',
-                items: [],
-                name: 'Tag B',
-                level: 1,
-                depth: 1,
-                href: 'tag-b',
-            }, 0);
-            expect(resultA[0].id).toEqual('tag-a/users');
-            expect(resultB[0].id).toEqual('tag-b/users');
-        });
-    });
-});
-//# sourceMappingURL=builder.test.js.map

package/lib/services/menu/__tests__/operation.test.d.ts

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

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

@@ -1,240 +0,0 @@
-import { getOperationsItems } from '../operation.js';
-vi.mock('../../../utils/index.js', () => ({
-    encodeBackSlashes: vi.fn((str) => str.toLowerCase()),
-    getOperationId: vi.fn((operation, parent) => `${parent?.id || 'root'}-${operation.httpVerb}-${operation.pathName}`),
-    getOperationName: vi.fn((operation) => operation.summary || `${operation.httpVerb.toUpperCase()} ${operation.pathName}`),
-}));
-describe('getOperationsItems sorting logic', () => {
-    const mockParent = {
-        id: 'test-tag',
-        name: 'Test Tag',
-        type: 'tag',
-        items: [],
-        depth: 1,
-        level: 1,
-        href: '/test-tag',
-    };
-    const createMockOperation = (overrides = {}) => ({
-        httpVerb: 'get',
-        pathName: '/test',
-        summary: 'Test operation',
-        deprecated: false,
-        isAdditionalOperation: false,
-        isWebhook: false,
-        operationId: 'test-operation',
-        'x-badges': [],
-        ...overrides,
-    });
-    const createMockTag = (operations) => ({
-        name: 'test-tag',
-        operations,
-    });
-    test('should sort non-deprecated operations before deprecated ones', () => {
-        const operations = [
-            createMockOperation({ httpVerb: 'post', summary: 'Deprecated POST', deprecated: true }),
-            createMockOperation({ httpVerb: 'get', summary: 'Active GET', deprecated: false }),
-            createMockOperation({ httpVerb: 'put', summary: 'Deprecated PUT', deprecated: true }),
-            createMockOperation({ httpVerb: 'delete', summary: 'Active DELETE', deprecated: false }),
-        ];
-        const tag = createMockTag(operations);
-        const result = getOperationsItems(mockParent, tag, 1);
-        expect(result).toHaveLength(4);
-        expect(result[0].httpVerb).toBe('get');
-        expect(result[0].deprecated).toBe(false);
-        expect(result[1].httpVerb).toBe('delete');
-        expect(result[1].deprecated).toBe(false);
-        expect(result[2].httpVerb).toBe('post');
-        expect(result[2].deprecated).toBe(true);
-        expect(result[3].httpVerb).toBe('put');
-        expect(result[3].deprecated).toBe(true);
-    });
-    test('should apply combined sorting: non-deprecated regular, non-deprecated additional, deprecated regular, deprecated additional', () => {
-        const operations = [
-            createMockOperation({
-                httpVerb: 'deprecated-additional',
-                summary: 'Deprecated additional operation',
-                isAdditionalOperation: true,
-                deprecated: true,
-            }),
-            createMockOperation({
-                httpVerb: 'active-regular',
-                summary: 'Active regular operation',
-                isAdditionalOperation: false,
-                deprecated: false,
-            }),
-            createMockOperation({
-                httpVerb: 'deprecated-regular',
-                summary: 'Deprecated regular operation',
-                isAdditionalOperation: false,
-                deprecated: true,
-            }),
-            createMockOperation({
-                httpVerb: 'active-additional',
-                summary: 'Active additional operation',
-                isAdditionalOperation: true,
-                deprecated: false,
-            }),
-        ];
-        const tag = createMockTag(operations);
-        const result = getOperationsItems(mockParent, tag, 1);
-        expect(result).toHaveLength(4);
-        expect(result[0].httpVerb).toBe('active-regular');
-        expect(result[0].deprecated).toBe(false);
-        expect(result[0].isAdditionalOperation).toBe(false);
-        expect(result[1].httpVerb).toBe('active-additional');
-        expect(result[1].deprecated).toBe(false);
-        expect(result[1].isAdditionalOperation).toBe(true);
-        expect(result[2].httpVerb).toBe('deprecated-regular');
-        expect(result[2].deprecated).toBe(true);
-        expect(result[2].isAdditionalOperation).toBe(false);
-        expect(result[3].httpVerb).toBe('deprecated-additional');
-        expect(result[3].deprecated).toBe(true);
-        expect(result[3].isAdditionalOperation).toBe(true);
-    });
-});
-describe('getOperationsItems badge tags functionality', () => {
-    const mockParent = {
-        id: 'test-tag',
-        name: 'Test Tag',
-        type: 'tag',
-        items: [],
-        depth: 1,
-        level: 1,
-        href: '/test-tag',
-    };
-    const createMockOperation = (overrides = {}) => ({
-        httpVerb: 'get',
-        pathName: '/test',
-        summary: 'Test operation',
-        deprecated: false,
-        isAdditionalOperation: false,
-        isWebhook: false,
-        operationId: 'test-operation',
-        'x-badges': [],
-        ...overrides,
-    });
-    const createMockTag = (operations) => ({
-        name: 'test-tag',
-        operations,
-    });
-    test('should collect badge tags from tagsMap when kind is badge', () => {
-        const tagsMap = {
-            'beta-tag': {
-                name: 'beta-tag',
-                kind: 'badge',
-                summary: 'Beta Feature',
-                operations: [],
-            },
-            'regular-tag': {
-                name: 'regular-tag',
-                operations: [],
-            },
-        };
-        const operation = createMockOperation({ tags: ['beta-tag'] });
-        const tag = createMockTag([operation]);
-        const result = getOperationsItems(mockParent, tag, 1, tagsMap);
-        expect(result).toHaveLength(1);
-        expect(result[0].badges).toEqual([
-            {
-                name: 'Beta Feature',
-                color: 'blue',
-                position: 'after',
-                icon: undefined,
-            },
-        ]);
-    });
-    test('should collect badge tags from tagsMap when kind is audience', () => {
-        const tagsMap = {
-            'developers-tag': {
-                name: 'developers-tag',
-                kind: 'audience',
-                summary: 'For Developers',
-                operations: [],
-            },
-        };
-        const operation = createMockOperation({ tags: ['developers-tag'] });
-        const tag = createMockTag([operation]);
-        const result = getOperationsItems(mockParent, tag, 1, tagsMap);
-        expect(result).toHaveLength(1);
-        expect(result[0].badges).toEqual([
-            {
-                name: 'For Developers',
-                color: 'grey',
-                position: 'after',
-                icon: 'user-group',
-            },
-        ]);
-    });
-    test('should preserve existing x-badges and add tag-based badges', () => {
-        const tagsMap = {
-            'beta-tag': {
-                name: 'beta-tag',
-                kind: 'badge',
-                summary: 'Beta Feature',
-                operations: [],
-            },
-        };
-        const existingBadges = [
-            {
-                name: 'Custom Badge',
-                color: 'green',
-                position: 'before',
-            },
-        ];
-        const operation = createMockOperation({
-            tags: ['beta-tag'],
-            'x-badges': existingBadges,
-        });
-        const tag = createMockTag([operation]);
-        const result = getOperationsItems(mockParent, tag, 1, tagsMap);
-        expect(result).toHaveLength(1);
-        expect(result[0].badges).toEqual([
-            {
-                name: 'Custom Badge',
-                color: 'green',
-                position: 'before',
-            },
-            {
-                name: 'Beta Feature',
-                color: 'blue',
-                position: 'after',
-                icon: undefined,
-            },
-        ]);
-    });
-    test('should add multiple badges when operation has multiple matching tags', () => {
-        const tagsMap = {
-            'beta-tag': {
-                name: 'beta-tag',
-                kind: 'badge',
-                summary: 'Beta Feature',
-                operations: [],
-            },
-            'developers-tag': {
-                name: 'developers-tag',
-                kind: 'audience',
-                summary: 'For Developers',
-                operations: [],
-            },
-        };
-        const operation = createMockOperation({ tags: ['beta-tag', 'developers-tag'] });
-        const tag = createMockTag([operation]);
-        const result = getOperationsItems(mockParent, tag, 1, tagsMap);
-        expect(result).toHaveLength(1);
-        expect(result[0].badges).toEqual([
-            {
-                name: 'Beta Feature',
-                position: 'after',
-                color: 'blue',
-                icon: undefined,
-            },
-            {
-                name: 'For Developers',
-                position: 'after',
-                color: 'grey',
-                icon: 'user-group',
-            },
-        ]);
-    });
-});
-//# sourceMappingURL=operation.test.js.map

package/lib/services/menu/__tests__/tags.test.d.ts

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