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

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

@@ -0,0 +1,109 @@
+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

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

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

@@ -0,0 +1,307 @@
+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

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

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

@@ -0,0 +1,240 @@
+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

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