@mintlify/common 1.0.1170 → 1.0.1171

package/dist/navigation/scopePrecomputedTargets.test.js

@@ -0,0 +1,175 @@
+import { locales } from '@mintlify/models';
+import { describe, expect, it } from 'vitest';
+import { filterDivisions } from './filterDivisions.js';
+import { getAllPathsInDecoratedNav } from './getAllPathsInDecoratedNav.js';
+import { getScopedNavForPath } from './scopeNavToPath.js';
+const page = (href) => ({ title: href, href });
+const versionedItem = (item, v3, v2) => ({
+    item,
+    versions: [
+        { version: 'v3', default: true, groups: [{ group: `${item} v3`, pages: v3.map(page) }] },
+        { version: 'v2', groups: [{ group: `${item} v2`, pages: v2.map(page) }] },
+    ],
+});
+const crossListedVersionNav = {
+    tabs: [
+        {
+            tab: 'Docs',
+            menu: [
+                { item: 'Home', pages: [page('/home')] },
+                versionedItem('Studio', ['/studio/v3/a', '/studio/v3/b'], ['/studio/v2/a', '/shared']),
+                versionedItem('Engine', ['/engine/v3/a', '/shared', '/engine/v3/c'], ['/engine/v2/a']),
+                versionedItem('Solver', ['/solver/v3/a'], ['/solver/v2/a']),
+            ],
+        },
+        { tab: 'Other', pages: [page('/other')] },
+    ],
+};
+const pathSimilarVersionNav = {
+    tabs: [
+        {
+            tab: 'Docs',
+            menu: [
+                versionedItem('Studio', ['/studio/v3/a'], ['/studio/v2/a', '/shared']),
+                versionedItem('Engine', ['/engine/v3/a', '/shared'], ['/engine/v2/intro', '/v2/shared']),
+            ],
+        },
+    ],
+};
+const dropdownVersionNav = {
+    tabs: [
+        {
+            tab: 'Docs',
+            menu: [
+                versionedItem('Studio', ['/studio/v3/a'], ['/studio/v2/a', '/shared']),
+                {
+                    item: 'Engine',
+                    versions: [
+                        { version: 'v3', default: true, pages: [page('/engine/v3/a'), page('/shared')] },
+                        {
+                            version: 'v2',
+                            dropdowns: [
+                                { dropdown: 'Guides', pages: [page('/engine/v2/guides')] },
+                                { dropdown: 'Reference', pages: [page('/engine/v2/reference')] },
+                            ],
+                        },
+                    ],
+                },
+            ],
+        },
+    ],
+};
+const localizedItem = (item, en, fr) => ({
+    item,
+    languages: [
+        {
+            language: 'en',
+            default: true,
+            groups: [{ group: `${item} en`, pages: en.map(page) }],
+        },
+        { language: 'fr', groups: [{ group: `${item} fr`, pages: fr.map(page) }] },
+    ],
+});
+const crossListedLanguageNav = {
+    tabs: [
+        {
+            tab: 'Docs',
+            menu: [
+                localizedItem('Studio', ['/studio/en'], ['/studio/fr', '/shared']),
+                localizedItem('Engine', ['/engine/en', '/shared'], ['/engine/fr']),
+                localizedItem('Solver', ['/solver/en'], ['/solver/fr']),
+            ],
+        },
+    ],
+};
+const toLocale = (value) => locales.find((locale) => locale === value);
+function sessionValuesContaining(node, href, key, current) {
+    const found = new Set();
+    if (Array.isArray(node)) {
+        for (const entry of node) {
+            sessionValuesContaining(entry, href, key, current).forEach((value) => found.add(value));
+        }
+        return found;
+    }
+    if (typeof node !== 'object' || node === null)
+        return found;
+    const value = key in node ? Reflect.get(node, key) : undefined;
+    const scope = typeof value === 'string' ? value : current;
+    if (Reflect.get(node, 'href') === href)
+        found.add(scope);
+    for (const child of Object.values(node)) {
+        if (typeof child === 'object' && child !== null) {
+            sessionValuesContaining(child, href, key, scope).forEach((entry) => found.add(entry));
+        }
+    }
+    return found;
+}
+function filterWith(decoratedNav, currentPath, currentVersion, currentLanguage) {
+    return filterDivisions({
+        currentPath,
+        decoratedNav,
+        userGroups: new Set(),
+        currentVersion,
+        currentLanguage,
+        shouldUseDivisionMatch: true,
+        cache: { dropdownCache: new Map() },
+        isPreview: false,
+    });
+}
+function chromeSummary(result) {
+    return {
+        tabs: result.tabs.map(({ name, href, isActive, menu }) => ({
+            name,
+            href,
+            isActive,
+            menu: menu === null || menu === void 0 ? void 0 : menu.map((item) => ({ name: item.name, href: item.href, isActive: item.isActive })),
+        })),
+        versions: result.versions.map(({ name, isActive }) => ({ name, isActive })),
+        languages: result.languages.map(({ name, isActive }) => ({ name, isActive })),
+    };
+}
+function mapHrefs(map) {
+    return Object.fromEntries([...map].map(([key, value]) => [String(key), value.href]));
+}
+function assertChromeInvariantForEverySession(nav, key, compareJumpMaps = true) {
+    for (const path of getAllPathsInDecoratedNav(nav)) {
+        const currentPath = `/${path.replace(/^\//, '')}`;
+        const scoped = getScopedNavForPath({ decoratedNav: nav, currentPath });
+        for (const value of sessionValuesContaining(nav, currentPath, key)) {
+            const version = key === 'version' ? value : scoped.currentVersion;
+            const language = key === 'language' ? toLocale(value) : scoped.currentLanguage;
+            const label = `${currentPath} ${key}=${value !== null && value !== void 0 ? value : '-'}`;
+            const full = filterWith(nav, currentPath, version, language);
+            const rescoped = filterWith(scoped.scopedNav, currentPath, version, language);
+            expect(rescoped.groupsOrPages, label).toEqual(full.groupsOrPages);
+            expect(chromeSummary(rescoped), label).toEqual(chromeSummary(full));
+            if (!compareJumpMaps)
+                continue;
+            expect(mapHrefs(rescoped.firstHrefInVersion), label).toEqual(mapHrefs(full.firstHrefInVersion));
+            expect(mapHrefs(rescoped.firstHrefInLanguage), label).toEqual(mapHrefs(full.firstHrefInLanguage));
+        }
+    }
+}
+describe('precomputed switch targets on cross-listed pages', () => {
+    it('keeps every menu href identical to the full nav for every session version', () => {
+        assertChromeInvariantForEverySession(crossListedVersionNav, 'version');
+    });
+    it('keeps menu hrefs on the first page when a later page resembles the current path', () => {
+        assertChromeInvariantForEverySession(pathSimilarVersionNav, 'version');
+    });
+    it('keeps menu hrefs on the first dropdown page of a sibling version', () => {
+        assertChromeInvariantForEverySession(dropdownVersionNav, 'version', false);
+    });
+    it('keeps every menu href identical to the full nav for every session language', () => {
+        assertChromeInvariantForEverySession(crossListedLanguageNav, 'language');
+    });
+    it('points a containing sibling at its own version, not the shared page elsewhere', () => {
+        var _a, _b;
+        const { scopedNav } = getScopedNavForPath({
+            decoratedNav: crossListedVersionNav,
+            currentPath: '/shared',
+        });
+        const menu = (_a = filterWith(scopedNav, '/shared', 'v2', undefined).tabs[0]) === null || _a === void 0 ? void 0 : _a.menu;
+        expect((_b = menu === null || menu === void 0 ? void 0 : menu.find((item) => item.name === 'Engine')) === null || _b === void 0 ? void 0 : _b.href).toBe('/engine/v2/a');
+    });
+});