@mintlify/common 1.0.1241 → 1.0.1243

package/dist/navigation/hidden-tab-navigation.test.d.ts

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

package/dist/navigation/hidden-tab-navigation.test.js

@@ -0,0 +1,122 @@
+import { generatePathToHiddenDict } from '../divisions/generatePathToHiddenDict.js';
+import { generatePathToHiddenFromSearchDict } from '../divisions/generatePathToHiddenFromSearchDict.js';
+import { filterDivisions, isActiveDivision } from './filterDivisions.js';
+import { getScopedNavForPath } from './scopeNavToPath.js';
+function sidebar(group, path) {
+    return [
+        {
+            group,
+            pages: [
+                { title: 'Overview', href: path },
+                { title: 'Setup', href: `${path}/setup` },
+            ],
+        },
+    ];
+}
+function languageFixture(language) {
+    const menus = [
+        { item: 'Control', path: `/${language}/control` },
+        { item: 'Analytics', path: `/${language}/analytics` },
+    ].map(({ item, path }) => ({ item, path, groups: sidebar(item, path) }));
+    const products = [
+        { tab: 'Storage', path: `/${language}/control/storage` },
+        { tab: 'Object Storage', path: `/${language}/control/storage/objects` },
+        { tab: 'Networking', path: `/${language}/control/networking` },
+    ].map(({ tab, path }) => ({ tab, path, groups: sidebar(tab, path) }));
+    const config = {
+        language,
+        tabs: [
+            {
+                tab: 'Platform',
+                menu: menus.map(({ item, groups }) => ({ item, groups })),
+            },
+            ...products.map(({ tab, groups }) => ({
+                tab,
+                hidden: true,
+                searchable: true,
+                groups,
+            })),
+            {
+                tab: 'Internal',
+                hidden: true,
+                groups: sidebar('Internal', `/${language}/internal`),
+            },
+        ],
+    };
+    const cases = [
+        ...menus.flatMap(({ item, path, groups }) => [path, `${path}/setup`].map((currentPath) => ({
+            language,
+            currentPath,
+            activeTab: 'Platform',
+            activeMenu: item,
+            sidebar: groups,
+        }))),
+        ...products.flatMap(({ tab, path, groups }) => [path, `${path}/setup`].map((currentPath) => ({
+            language,
+            currentPath,
+            activeTab: tab,
+            sidebar: groups,
+        }))),
+    ];
+    return { config, cases };
+}
+const languages = ['en', 'es'];
+const fixtures = languages.map(languageFixture);
+const decoratedNav = {
+    languages: fixtures.map(({ config }) => config),
+};
+const cases = fixtures.flatMap((fixture) => fixture.cases);
+describe.each(['full navigation', 'scoped navigation'])('hidden tabs with %s', (mode) => {
+    it.each(cases)('$currentPath resolves to its own tab and complete sidebar', ({ language, currentPath, activeTab, activeMenu, sidebar }) => {
+        var _a, _b;
+        let nav = decoratedNav;
+        if (mode === 'scoped navigation') {
+            const scoped = getScopedNavForPath({ decoratedNav, currentPath });
+            expect(scoped.currentLanguage).toBe(language);
+            nav = scoped.scopedNav;
+        }
+        const result = filterDivisions({
+            decoratedNav: nav,
+            currentPath,
+            currentLanguage: language,
+            currentVersion: undefined,
+            userGroups: new Set(),
+            shouldUseDivisionMatch: true,
+            cache: { dropdownCache: new Map() },
+        });
+        const expectedTabs = [{ tab: 'Platform', isActive: activeTab === 'Platform' }];
+        if (activeTab !== 'Platform') {
+            expectedTabs.push({ tab: activeTab, isActive: true });
+        }
+        expect(result.tabs.map(({ tab, isActive }) => ({ tab, isActive }))).toEqual(expectedTabs);
+        expect(result.tabs.filter(isActiveDivision).map(({ tab }) => tab)).toEqual([activeTab]);
+        expect(result.languages.filter(isActiveDivision).map(({ language }) => language)).toEqual([
+            language,
+        ]);
+        expect(result.groupsOrPages).toEqual(sidebar);
+        expect((_b = (_a = result.tabs
+            .find(({ tab }) => tab === 'Platform')) === null || _a === void 0 ? void 0 : _a.menu) === null || _b === void 0 ? void 0 : _b.map(({ item, href, isActive }) => ({ item, href, isActive }))).toEqual([
+            { item: 'Control', href: `/${language}/control`, isActive: activeMenu === 'Control' },
+            { item: 'Analytics', href: `/${language}/analytics`, isActive: activeMenu === 'Analytics' },
+        ]);
+    });
+});
+describe('hidden tab indexing', () => {
+    it('keeps searchable products hidden in navigation while eligible for indexing', () => {
+        const hiddenFromNav = generatePathToHiddenDict(decoratedNav);
+        const hiddenFromSearch = generatePathToHiddenFromSearchDict(decoratedNav);
+        for (const { currentPath, activeTab } of cases) {
+            const path = currentPath.slice(1);
+            expect(hiddenFromNav.has(path), currentPath).toBe(activeTab !== 'Platform');
+            expect(hiddenFromSearch.has(path), currentPath).toBe(false);
+        }
+    });
+    it('keeps hidden tabs without searchable excluded from indexing', () => {
+        const expected = new Map();
+        for (const language of languages) {
+            expected.set(`${language}/internal`, true);
+            expected.set(`${language}/internal/setup`, true);
+        }
+        expect(generatePathToHiddenFromSearchDict(decoratedNav)).toEqual(expected);
+    });
+});