@mintlify/common 1.0.1069 → 1.0.1071

package/dist/navigation/accessiblePagesTraversal.test.d.ts

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

package/dist/navigation/accessiblePagesTraversal.test.js

@@ -0,0 +1,126 @@
+import { filterDivisions } from './filterDivisions.js';
+const baseArgs = {
+    userGroups: new Set(),
+    currentVersion: undefined,
+    currentLanguage: undefined,
+    shouldUseDivisionMatch: true,
+    cache: { dropdownCache: new Map() },
+};
+const run = (decoratedNav, currentPath, overrides = {}) => filterDivisions(Object.assign(Object.assign(Object.assign({}, baseArgs), { decoratedNav, currentPath }), overrides));
+describe('accessible page traversal', () => {
+    it('returns the accessible siblings for a match late in a long page list', () => {
+        const nav = {
+            pages: [
+                { title: 'Public one', href: '/public-one' },
+                { title: 'Gated', href: '/gated', groups: ['admin'] },
+                { title: 'Public two', href: '/public-two' },
+                { title: 'Target', href: '/target' },
+            ],
+        };
+        const result = run(nav, '/target');
+        expect(result.groupsOrPages).toEqual([
+            { title: 'Public one', href: '/public-one' },
+            { title: 'Public two', href: '/public-two' },
+            { title: 'Target', href: '/target' },
+        ]);
+    });
+    it('returns the same accessible siblings whichever page in the list matches', () => {
+        const nav = {
+            pages: [
+                { title: 'First', href: '/first' },
+                { title: 'Gated', href: '/gated', groups: [] },
+                { title: 'Last', href: '/last' },
+            ],
+        };
+        const first = run(nav, '/first');
+        const last = run(nav, '/last');
+        expect(first.groupsOrPages).toEqual(last.groupsOrPages);
+        expect(first.groupsOrPages).toEqual([
+            { title: 'First', href: '/first' },
+            { title: 'Last', href: '/last' },
+        ]);
+    });
+    it('includes pages the user has access to through their groups', () => {
+        const nav = {
+            pages: [
+                { title: 'Admin only', href: '/admin-only', groups: ['admin'] },
+                { title: 'Sales only', href: '/sales-only', groups: ['sales'] },
+                { title: 'Target', href: '/target' },
+            ],
+        };
+        const result = run(nav, '/target', { userGroups: new Set(['admin']) });
+        expect(result.groupsOrPages).toEqual([
+            { title: 'Admin only', href: '/admin-only', groups: ['admin'] },
+            { title: 'Target', href: '/target' },
+        ]);
+    });
+    it('keeps gated siblings in preview', () => {
+        const nav = {
+            pages: [
+                { title: 'Gated', href: '/gated', groups: ['admin'] },
+                { title: 'Target', href: '/target' },
+            ],
+        };
+        const result = run(nav, '/target', { isPreview: true });
+        expect(result.groupsOrPages).toEqual([
+            { title: 'Gated', href: '/gated', groups: ['admin'] },
+            { title: 'Target', href: '/target' },
+        ]);
+    });
+    it('prefers parent groups over the sibling list when nested', () => {
+        const nav = {
+            groups: [
+                {
+                    group: 'Outer',
+                    pages: [
+                        { title: 'Inner one', href: '/inner-one' },
+                        { title: 'Inner two', href: '/inner-two' },
+                    ],
+                },
+            ],
+        };
+        const result = run(nav, '/inner-two');
+        expect(result.groupsOrPages).toEqual([
+            {
+                group: 'Outer',
+                pages: [
+                    { title: 'Inner one', href: '/inner-one' },
+                    { title: 'Inner two', href: '/inner-two' },
+                ],
+            },
+        ]);
+    });
+    it('resolves a root page against its filtered siblings', () => {
+        const nav = {
+            groups: [
+                {
+                    group: 'Outer',
+                    root: { title: 'Root', href: '/root' },
+                    pages: [
+                        { title: 'Gated', href: '/gated', groups: [] },
+                        { title: 'Visible', href: '/visible' },
+                    ],
+                },
+            ],
+        };
+        const result = run(nav, '/root');
+        expect(result.groupsOrPages).toEqual([
+            {
+                group: 'Outer',
+                root: { title: 'Root', href: '/root' },
+                pages: [{ title: 'Visible', href: '/visible' }],
+            },
+        ]);
+    });
+    it('does not mutate the navigation it is given', () => {
+        const nav = {
+            pages: [
+                { title: 'Gated', href: '/gated', groups: [] },
+                { title: 'Target', href: '/target' },
+            ],
+        };
+        const before = JSON.stringify(nav);
+        run(nav, '/target');
+        expect(JSON.stringify(nav)).toBe(before);
+    });
+});

package/dist/navigation/activeDivisionMatching.test.d.ts

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

package/dist/navigation/activeDivisionMatching.test.js

@@ -0,0 +1,245 @@
+import { filterDivisions, isActiveDivision } from './filterDivisions.js';
+const baseArgs = {
+    userGroups: new Set(),
+    currentVersion: undefined,
+    currentLanguage: undefined,
+    shouldUseDivisionMatch: false,
+    cache: { dropdownCache: new Map() },
+};
+const run = (decoratedNav, currentPath, overrides = {}) => filterDivisions(Object.assign(Object.assign(Object.assign({}, baseArgs), { decoratedNav, currentPath }), overrides));
+const pages = (prefix) => [
+    { title: 'First', href: `${prefix}/first` },
+    { title: 'Second', href: `${prefix}/second` },
+];
+describe('active division matching', () => {
+    it('marks only the tab containing the path active when sibling names are unique', () => {
+        const nav = {
+            tabs: [
+                { tab: 'Guides', pages: pages('/guides') },
+                { tab: 'Reference', pages: pages('/reference') },
+                { tab: 'Support', pages: pages('/support') },
+            ],
+        };
+        const result = run(nav, '/reference/second');
+        expect(result.tabs.map((tab) => tab.tab)).toEqual(['Guides', 'Reference', 'Support']);
+        expect(result.tabs.filter(isActiveDivision).map((tab) => tab.tab)).toEqual(['Reference']);
+    });
+    it('marks a single version active and preserves sibling order', () => {
+        const nav = {
+            versions: [
+                { version: 'v3', default: true, pages: pages('/v3') },
+                { version: 'v2', pages: pages('/v2') },
+                { version: 'v1', pages: pages('/v1') },
+            ],
+        };
+        const result = run(nav, '/v2/first');
+        expect(result.versions.map((version) => version.version)).toEqual(['v3', 'v2', 'v1']);
+        expect(result.versions.filter(isActiveDivision).map((version) => version.version)).toEqual([
+            'v2',
+        ]);
+    });
+    it('keeps every byte-identical sibling division active', () => {
+        var _a;
+        const duplicated = { tab: 'Duplicated', pages: pages('/duplicated') };
+        const nav = {
+            tabs: [
+                structuredClone(duplicated),
+                structuredClone(duplicated),
+                { tab: 'Other', pages: pages('/other') },
+            ],
+        };
+        const result = run(nav, '/duplicated/first');
+        expect(result.tabs.filter(isActiveDivision).map((tab) => tab.tab)).toEqual([
+            'Duplicated',
+            'Duplicated',
+        ]);
+        expect((_a = result.tabs.find((tab) => tab.tab === 'Other')) === null || _a === void 0 ? void 0 : _a.isActive).toBe(false);
+    });
+    it('keeps every byte-identical sibling version active', () => {
+        const duplicated = { version: 'v1', pages: pages('/v1') };
+        const nav = {
+            versions: [structuredClone(duplicated), structuredClone(duplicated)],
+        };
+        const result = run(nav, '/v1/first');
+        expect(result.versions.filter(isActiveDivision)).toHaveLength(2);
+    });
+    it('marks one division active when siblings share a name but differ in content', () => {
+        var _a;
+        const nav = {
+            tabs: [
+                { tab: 'Shared', pages: pages('/left') },
+                { tab: 'Shared', pages: pages('/right') },
+            ],
+        };
+        const result = run(nav, '/right/first');
+        const active = result.tabs.filter(isActiveDivision);
+        expect(active).toHaveLength(1);
+        expect((_a = active[0]) === null || _a === void 0 ? void 0 : _a.href).toBe('/right/first');
+    });
+    it('marks one division active when siblings share content but differ in name', () => {
+        const shared = pages('/shared');
+        const nav = {
+            tabs: [
+                { tab: 'One', pages: structuredClone(shared) },
+                { tab: 'Two', pages: structuredClone(shared) },
+            ],
+        };
+        const result = run(nav, '/shared/first');
+        expect(result.tabs.filter(isActiveDivision).map((tab) => tab.tab)).toEqual(['One']);
+    });
+    it('drops hidden siblings while keeping the active division', () => {
+        const nav = {
+            tabs: [
+                { tab: 'Visible', pages: pages('/visible') },
+                { tab: 'Hidden', hidden: true, pages: pages('/hidden') },
+            ],
+        };
+        const result = run(nav, '/visible/first');
+        expect(result.tabs.map((tab) => tab.tab)).toEqual(['Visible']);
+    });
+    it('keeps a hidden division when it is the active one', () => {
+        const nav = {
+            tabs: [
+                { tab: 'Visible', pages: pages('/visible') },
+                { tab: 'Hidden', hidden: true, pages: pages('/hidden') },
+            ],
+        };
+        const result = run(nav, '/hidden/first');
+        expect(result.tabs.filter(isActiveDivision).map((tab) => tab.tab)).toEqual(['Hidden']);
+    });
+    it('resolves the active product when the iteration order is reordered for currentProduct', () => {
+        const nav = {
+            products: [
+                { product: 'alpha', pages: pages('/alpha') },
+                { product: 'beta', pages: pages('/beta') },
+                { product: 'gamma', pages: pages('/gamma') },
+            ],
+        };
+        const result = run(nav, '/gamma/first', { currentProduct: 'gamma' });
+        expect(result.products.map((product) => product.product)).toEqual(['alpha', 'beta', 'gamma']);
+        expect(result.products.filter(isActiveDivision).map((product) => product.product)).toEqual([
+            'gamma',
+        ]);
+    });
+    it('resolves the active version when shouldUseDivisionMatch narrows to currentVersion', () => {
+        const nav = {
+            versions: [
+                { version: 'v2', default: true, pages: [{ title: 'Shared', href: '/shared' }] },
+                { version: 'v1', pages: [{ title: 'Shared', href: '/shared' }] },
+            ],
+        };
+        const result = run(nav, '/shared', {
+            currentVersion: 'v1',
+            shouldUseDivisionMatch: true,
+        });
+        expect(result.versions.filter(isActiveDivision).map((version) => version.version)).toEqual([
+            'v1',
+        ]);
+    });
+    it('falls back to the default chrome for a path that is not in the navigation', () => {
+        const nav = {
+            tabs: [
+                { tab: 'Guides', pages: pages('/guides') },
+                { tab: 'Reference', pages: pages('/reference') },
+            ],
+        };
+        const result = run(nav, '/nothing/here');
+        expect(result.tabs.map((tab) => tab.tab)).toEqual(['Guides', 'Reference']);
+        expect(result.tabs.filter(isActiveDivision).map((tab) => tab.tab)).toEqual(['Guides']);
+    });
+    it('resolves the nearest divisions for an out-of-nav path sharing a prefix', () => {
+        const nav = {
+            versions: [
+                { version: 'v2', default: true, pages: pages('/v2/guides') },
+                { version: 'v1', pages: pages('/v1/guides') },
+            ],
+        };
+        const result = run(nav, '/v1/guides/missing');
+        expect(result.versions.map((version) => version.version)).toEqual(['v2', 'v1']);
+    });
+    it('does not mutate the navigation it is given', () => {
+        const nav = {
+            tabs: [
+                { tab: 'Guides', pages: pages('/guides') },
+                { tab: 'Reference', pages: pages('/reference') },
+            ],
+        };
+        const before = JSON.stringify(nav);
+        run(nav, '/reference/first');
+        expect(JSON.stringify(nav)).toBe(before);
+    });
+    it('marks the active anchor', () => {
+        const nav = {
+            anchors: [
+                { anchor: 'Home', pages: pages('/home') },
+                { anchor: 'API', pages: pages('/api') },
+            ],
+        };
+        const result = run(nav, '/api/second');
+        expect(result.anchors.filter(isActiveDivision).map((anchor) => anchor.anchor)).toEqual(['API']);
+    });
+    it('marks the active dropdown', () => {
+        const nav = {
+            dropdowns: [
+                { dropdown: 'Cloud', pages: pages('/cloud') },
+                { dropdown: 'Self host', pages: pages('/self-host') },
+            ],
+        };
+        const result = run(nav, '/self-host/first');
+        expect(result.dropdowns.filter(isActiveDivision).map((dropdown) => dropdown.dropdown)).toEqual([
+            'Self host',
+        ]);
+    });
+    it('marks the active menu item within a tab', () => {
+        var _a, _b;
+        const nav = {
+            tabs: [
+                {
+                    tab: 'Products',
+                    menu: [
+                        { item: 'Alpha', pages: pages('/alpha') },
+                        { item: 'Beta', pages: pages('/beta') },
+                    ],
+                },
+            ],
+        };
+        const result = run(nav, '/beta/first');
+        expect((_b = (_a = result.tabs[0]) === null || _a === void 0 ? void 0 : _a.menu) === null || _b === void 0 ? void 0 : _b.filter(isActiveDivision).map((entry) => entry.item)).toEqual([
+            'Beta',
+        ]);
+    });
+    it('marks the active language', () => {
+        const nav = {
+            languages: [
+                { language: 'en', default: true, pages: pages('/en') },
+                { language: 'es', pages: pages('/es') },
+            ],
+        };
+        const result = run(nav, '/es/first');
+        expect(result.languages.filter(isActiveDivision).map((language) => language.language)).toEqual([
+            'es',
+        ]);
+    });
+    it('keeps every byte-identical sibling anchor active', () => {
+        const duplicated = { anchor: 'Duplicated', pages: pages('/duplicated') };
+        const nav = {
+            anchors: [structuredClone(duplicated), structuredClone(duplicated)],
+        };
+        const result = run(nav, '/duplicated/second');
+        expect(result.anchors.filter(isActiveDivision)).toHaveLength(2);
+    });
+    it('resolves divisions whose siblings expose no name', () => {
+        var _a;
+        const nav = {
+            tabs: [
+                { tab: 'Named', pages: pages('/named') },
+                { tab: '', pages: pages('/unnamed-first') },
+                { tab: '', pages: pages('/unnamed-second') },
+            ],
+        };
+        const result = run(nav, '/unnamed-second/first');
+        const active = result.tabs.filter(isActiveDivision);
+        expect(active).toHaveLength(1);
+        expect((_a = active[0]) === null || _a === void 0 ? void 0 : _a.href).toBe('/unnamed-second/first');
+    });
+});

package/dist/navigation/filterDivisions.js

@@ -79,17 +79,20 @@ export const filterDivisions = ({ currentPath, currentVersion, currentLanguage,
                     return { page: foundPage, groupsOrPages };
                 }
             }
+            // the accessible-page list depends only on the entry, so it is built once for
+            // the whole loop, and lazily so an entry holding no page objects never pays for it
+            let accessiblePages;
             for (const page of entry.pages) {
                 if (typeof page === 'object') {
-                    const filteredPages = entry.pages
-                        .map((page) => filterInaccessiblePagesRecursive(page, userGroups, isPreview))
-                        .filter((page) => page !== undefined);
+                    accessiblePages !== null && accessiblePages !== void 0 ? accessiblePages : (accessiblePages = parentGroups.length
+                        ? parentGroups
+                        : entry.pages
+                            .map((entryPage) => filterInaccessiblePagesRecursive(entryPage, userGroups, isPreview))
+                            .filter((entryPage) => entryPage !== undefined));
                     const { page: foundPage, groupsOrPages } = findPageInNavigation({
                         currentPath,
                         entry: page,
-                        parentGroups: parentGroups.length
-                            ? parentGroups
-                            : filteredPages,
+                        parentGroups: accessiblePages,
                         isPreview,
                         ancestorDivisionNames,
                     });
@@ -141,10 +144,11 @@ export const filterDivisions = ({ currentPath, currentVersion, currentLanguage,
                     ancestorDivisionNames: newAncestorNames,
                 });
                 if (page) {
+                    const isSameDivision = createDivisionMatcher(subDivisions);
                     const filteredSubDivisions = subDivisions
                         .filter((division) => isDivisionAccessible(division, userGroups, isPreview))
                         .map((item) => {
-                        const isActive = compareDivisions(item, subDivision);
+                        const isActive = isSameDivision(item, subDivision);
                         if ('hidden' in item && item.hidden && !isActive)
                             return undefined;
                         return buildDivisionItem({
@@ -568,8 +572,7 @@ function findMostRelevantDivisions(currentPath, decoratedNav, currentVersion, cu
     mostSpecificGroups = isPageAccessible ? mostSpecificGroups : [];
     if (mostSpecificGroups) {
         const isStrictlyEqual = (entry) => {
-            return (JSON.stringify(structuredClone(mostSpecificGroups)) ===
-                JSON.stringify(structuredClone(entry)));
+            return JSON.stringify(mostSpecificGroups) === JSON.stringify(entry);
         };
         // look for divisions based on the most specific groups
         function findMostRelevantDivisionsHelper(entry, parentGroups, ancestorDivisionNames = []) {
@@ -615,10 +618,11 @@ function findMostRelevantDivisions(currentPath, decoratedNav, currentVersion, cu
                      * - the specific group has been found in the division
                      */
                     if (founded || !isPageAccessible) {
+                        const isSameDivision = createDivisionMatcher(subDivisions);
                         const filteredSubDivisions = subDivisions
                             .filter((division) => isDivisionAccessible(division, userGroups, isPreview))
                             .map((item) => {
-                            const isActive = compareDivisions(item, subDivision) && isPageAccessible === true;
+                            const isActive = isSameDivision(item, subDivision) && isPageAccessible === true;
                             if (item.hidden && !isActive)
                                 return undefined;
                             return buildDivisionItem({
@@ -660,9 +664,17 @@ function findMaxMatchingPrefix(path1, path2) {
     }
     return path1.substring(0, matchingLength);
 }
-const compareDivisions = (item, subDivision) => {
-    return JSON.stringify(structuredClone(item)) === JSON.stringify(structuredClone(subDivision));
-};
+// both arguments always come from the same subDivisions array, so identity is the
+// question this is really asking. sharing a name is the only way two distinct
+// entries can serialize equally, so only those fall back to the deep comparison,
+// which keeps the existing behaviour of marking every identical sibling active
+function createDivisionMatcher(subDivisions) {
+    const names = subDivisions.map(findDivisionName);
+    if (new Set(names).size === names.length) {
+        return (item, subDivision) => item === subDivision;
+    }
+    return (item, subDivision) => item === subDivision || JSON.stringify(item) === JSON.stringify(subDivision);
+}
 function shouldSkipDivisionMatch({ subDivision, key, currentVersion, currentLanguage, subDivisions, }) {
     const isVersionsConfig = key === 'versions' && !!currentVersion;
     const isLanguagesConfig = key === 'languages' && !!currentLanguage;

package/dist/navigation/scopeNavDictCache.test.d.ts

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

package/dist/navigation/scopeNavDictCache.test.js

@@ -0,0 +1,68 @@
+import { generatePathToLanguageDict, generatePathToVersionDict } from '../divisions/index.js';
+import { getScopedNavForPath } from './scopeNavToPath.js';
+const navWithVersions = (versions) => ({
+    versions: versions.map((version, index) => ({
+        version,
+        default: index === 0,
+        groups: [
+            {
+                group: 'Guides',
+                pages: [
+                    { title: 'Overview', href: `/${version}/overview` },
+                    { title: 'Shared', href: '/shared' },
+                ],
+            },
+        ],
+    })),
+});
+describe('scoped nav path dictionaries', () => {
+    it('returns identical output across repeated calls with the same nav object', () => {
+        const nav = navWithVersions(['v2', 'v1']);
+        const first = getScopedNavForPath({ decoratedNav: nav, currentPath: '/v1/overview' });
+        const second = getScopedNavForPath({ decoratedNav: nav, currentPath: '/v1/overview' });
+        expect(JSON.stringify(second.scopedNav)).toBe(JSON.stringify(first.scopedNav));
+        expect(second.currentVersion).toBe(first.currentVersion);
+        expect([...second.firstHrefInVersion]).toEqual([...first.firstHrefInVersion]);
+    });
+    it('resolves different paths correctly after the dictionaries are warm', () => {
+        const nav = navWithVersions(['v2', 'v1']);
+        getScopedNavForPath({ decoratedNav: nav, currentPath: '/v2/overview' });
+        const scoped = getScopedNavForPath({ decoratedNav: nav, currentPath: '/v1/overview' });
+        expect(scoped.currentVersion).toBe('v1');
+    });
+    it('does not share dictionaries between distinct nav objects', () => {
+        const first = navWithVersions(['v2', 'v1']);
+        const second = navWithVersions(['v9', 'v8']);
+        expect(getScopedNavForPath({ decoratedNav: first, currentPath: '/v1/overview' }).currentVersion).toBe('v1');
+        expect(getScopedNavForPath({ decoratedNav: second, currentPath: '/v8/overview' }).currentVersion).toBe('v8');
+        expect(getScopedNavForPath({ decoratedNav: first, currentPath: '/v2/overview' }).currentVersion).toBe('v2');
+    });
+    it('does not share dictionaries between structurally identical nav objects', () => {
+        const original = navWithVersions(['v2', 'v1']);
+        const clone = structuredClone(original);
+        const fromOriginal = getScopedNavForPath({
+            decoratedNav: original,
+            currentPath: '/v1/overview',
+        });
+        const fromClone = getScopedNavForPath({ decoratedNav: clone, currentPath: '/v1/overview' });
+        expect(fromClone.currentVersion).toBe(fromOriginal.currentVersion);
+        expect(JSON.stringify(fromClone.scopedNav)).toBe(JSON.stringify(fromOriginal.scopedNav));
+    });
+    it('keeps the exported dictionary builders returning fresh maps', () => {
+        const nav = navWithVersions(['v2', 'v1']);
+        const versionDict = generatePathToVersionDict(nav);
+        const languageDict = generatePathToLanguageDict(nav);
+        versionDict.set('poisoned', 'nope');
+        languageDict.set('poisoned', 'nope');
+        expect(generatePathToVersionDict(nav).has('poisoned')).toBe(false);
+        expect(generatePathToLanguageDict(nav).has('poisoned')).toBe(false);
+        expect(getScopedNavForPath({ decoratedNav: nav, currentPath: '/v1/overview' }).currentVersion).toBe('v1');
+    });
+    it('does not mutate the navigation it is given', () => {
+        const nav = navWithVersions(['v2', 'v1']);
+        const before = JSON.stringify(nav);
+        getScopedNavForPath({ decoratedNav: nav, currentPath: '/v1/overview' });
+        getScopedNavForPath({ decoratedNav: nav, currentPath: '/shared' });
+        expect(JSON.stringify(nav)).toBe(before);
+    });
+});

package/dist/navigation/scopeNavToPath.js

@@ -475,8 +475,26 @@ export function scopeDocsConfigNavToPath(docsConfig, currentPath) {
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- structural nav traversal over the zod union types
         navigation: scopeNode(docsConfig.navigation, { currentPath }) });
 }
+const pathToVersionDictCache = new WeakMap();
+const pathToLanguageDictCache = new WeakMap();
+function cachedPathToVersionDict(decoratedNav) {
+    const cached = pathToVersionDictCache.get(decoratedNav);
+    if (cached)
+        return cached;
+    const dict = generatePathToVersionDict(decoratedNav);
+    pathToVersionDictCache.set(decoratedNav, dict);
+    return dict;
+}
+function cachedPathToLanguageDict(decoratedNav) {
+    const cached = pathToLanguageDictCache.get(decoratedNav);
+    if (cached)
+        return cached;
+    const dict = generatePathToLanguageDict(decoratedNav);
+    pathToLanguageDictCache.set(decoratedNav, dict);
+    return dict;
+}
 export function getScopedNavForPath({ decoratedNav, currentPath, userGroups = new Set(), isPreview = false, includeProductVersionMetadata = false, }) {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
+    var _a, _b, _c, _d, _e, _f, _g;
     const containingProductNames = new Set();
     collectContainingProductNames(
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- structural nav traversal over the zod union types
@@ -500,14 +518,16 @@ export function getScopedNavForPath({ decoratedNav, currentPath, userGroups = ne
     if (initial.versions.length || initial.languages.length) {
         const defaultVersion = (_a = initial.versions.find((version) => version.default)) === null || _a === void 0 ? void 0 : _a.version;
         const defaultLanguage = (_b = initial.languages.find((language) => language.default)) === null || _b === void 0 ? void 0 : _b.language;
-        const initialVersion = getVersionOrLanguageFromPath('version', decoratedNav, currentPath, defaultVersion, (_d = (_c = initial.versions[0]) === null || _c === void 0 ? void 0 : _c.name) !== null && _d !== void 0 ? _d : '');
-        const initialLanguage = getVersionOrLanguageFromPath('language', decoratedNav, currentPath, defaultLanguage, (_f = (_e = initial.languages[0]) === null || _e === void 0 ? void 0 : _e.language) !== null && _f !== void 0 ? _f : undefined);
         const strippedPath = optionallyRemoveLeadingSlash(currentPath);
-        const dictLanguage = generatePathToLanguageDict(decoratedNav).get(strippedPath);
+        const dictVersion = cachedPathToVersionDict(decoratedNav).get(strippedPath);
+        const dictLanguage = cachedPathToLanguageDict(decoratedNav).get(strippedPath);
+        const localeFromDict = locales.find((locale) => locale === dictLanguage);
         currentVersion =
-            generatePathToVersionDict(decoratedNav).get(strippedPath) || initialVersion || undefined;
+            dictVersion ||
+                getVersionOrLanguageFromPath('version', decoratedNav, currentPath, defaultVersion, (_d = (_c = initial.versions[0]) === null || _c === void 0 ? void 0 : _c.name) !== null && _d !== void 0 ? _d : '') ||
+                undefined;
         currentLanguage =
-            (_h = (_g = locales.find((locale) => locale === dictLanguage)) !== null && _g !== void 0 ? _g : initialLanguage) !== null && _h !== void 0 ? _h : undefined;
+            (_g = localeFromDict !== null && localeFromDict !== void 0 ? localeFromDict : getVersionOrLanguageFromPath('language', decoratedNav, currentPath, defaultLanguage, (_f = (_e = initial.languages[0]) === null || _e === void 0 ? void 0 : _e.language) !== null && _f !== void 0 ? _f : undefined)) !== null && _g !== void 0 ? _g : undefined;
     }
     const filtered = filterDivisions({
         currentPath,

package/dist/navigation/versionLanguageResolution.test.d.ts

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