@mintlify/common 1.0.1022 → 1.0.1024

package/dist/navigation/filterDivisions.js

@@ -0,0 +1,697 @@
+import { divisions, } from '@mintlify/validation';
+/* eslint-disable @typescript-eslint/consistent-type-assertions */
+import { readObjectArrayProperty } from '../divisions/iterateObjectArrayProperty.js';
+import { optionallyAddLeadingSlash } from '../fs/optionallySlash.js';
+import { isAbsoluteUrl } from '../isAbsoluteUrl.js';
+import { isEqualIgnoringLeadingSlash } from '../paths/isEqualIgnoringLeadingSlash.js';
+import { checkNavAccess } from './checkNavAccess.js';
+import { getFirstPageFromNavigation } from './getFirstPageFromNavigation.js';
+import { isPage } from './isPage.js';
+import { updateFirstHrefInDivision } from './updateFirstHrefInDivision.js';
+const DIVISION_NAME_MAP = {
+    tabs: 'tab',
+    anchors: 'anchor',
+    versions: 'version',
+    languages: 'language',
+    dropdowns: 'dropdown',
+    menu: 'item',
+    products: 'product',
+};
+export const isActiveDivision = (item) => 'isActive' in item && item.isActive === true;
+/**
+ * Reorders product items so that the item matching `currentProduct` is tried first,
+ * preserving the relative order of remaining items.
+ * Only meaningful when called with product division configs.
+ */
+function reorderForCurrentProduct(items, currentProduct) {
+    if (!currentProduct)
+        return items;
+    const idx = items.findIndex((item) => 'product' in item && item.product === currentProduct);
+    if (idx <= 0)
+        return items;
+    const match = items[idx];
+    if (!match)
+        return items;
+    return [match, ...items.slice(0, idx), ...items.slice(idx + 1)];
+}
+export const filterDivisions = ({ currentPath, currentVersion, currentLanguage, currentProduct, decoratedNav, userGroups, shouldUseDivisionMatch = true, cache, isPreview = false, }) => {
+    var _a, _b, _c;
+    let navigationDivisions = {
+        tabs: [],
+        anchors: [],
+        versions: [],
+        languages: [],
+        dropdowns: [],
+        menu: [],
+        products: [],
+    };
+    const firstHrefInVersion = new Map();
+    const firstHrefInLanguage = new Map();
+    function findPageInNavigation({ currentPath, entry, parentGroups, isPreview = false, ancestorDivisionNames = [], }) {
+        if (typeof entry !== 'object') {
+            return { page: undefined, groupsOrPages: undefined };
+        }
+        if (isPage(entry)) {
+            return checkNavAccess(entry, userGroups, isPreview) &&
+                isEqualIgnoringLeadingSlash(entry.href, currentPath)
+                ? {
+                    page: entry,
+                    groupsOrPages: parentGroups,
+                }
+                : { page: undefined, groupsOrPages: undefined };
+        }
+        if ('pages' in entry) {
+            if ('root' in entry && typeof entry.root === 'object') {
+                const filteredParentGroups = parentGroups.length
+                    ? parentGroups
+                    : entry.pages
+                        .map((page) => filterInaccessiblePagesRecursive(page, userGroups, isPreview))
+                        .filter((page) => page !== undefined);
+                const { page: foundPage, groupsOrPages } = findPageInNavigation({
+                    currentPath,
+                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- root is a DecoratedNavigationPage
+                    entry: entry.root,
+                    parentGroups: filteredParentGroups,
+                    isPreview,
+                    ancestorDivisionNames,
+                });
+                if (foundPage) {
+                    return { page: foundPage, groupsOrPages };
+                }
+            }
+            for (const page of entry.pages) {
+                if (typeof page === 'object') {
+                    const filteredPages = entry.pages
+                        .map((page) => filterInaccessiblePagesRecursive(page, userGroups, isPreview))
+                        .filter((page) => page !== undefined);
+                    const { page: foundPage, groupsOrPages } = findPageInNavigation({
+                        currentPath,
+                        entry: page,
+                        parentGroups: parentGroups.length
+                            ? parentGroups
+                            : filteredPages,
+                        isPreview,
+                        ancestorDivisionNames,
+                    });
+                    if (foundPage) {
+                        return { page: foundPage, groupsOrPages };
+                    }
+                }
+            }
+        }
+        if ('groups' in entry) {
+            const newParentGroups = filterInaccessiblePages(entry.groups, userGroups, isPreview);
+            for (const group of newParentGroups) {
+                const { page, groupsOrPages } = findPageInNavigation({
+                    currentPath,
+                    entry: group,
+                    parentGroups: newParentGroups,
+                    isPreview,
+                    ancestorDivisionNames,
+                });
+                if (page) {
+                    return { page, groupsOrPages };
+                }
+            }
+        }
+        for (const key of divisions) {
+            const subDivisions = readObjectArrayProperty(entry, key);
+            if (!subDivisions)
+                continue;
+            const iterationOrder = key === 'products' ? reorderForCurrentProduct(subDivisions, currentProduct) : subDivisions;
+            for (const subDivision of iterationOrder) {
+                if (shouldUseDivisionMatch &&
+                    shouldSkipDivisionMatch({
+                        subDivision,
+                        key,
+                        currentVersion,
+                        currentLanguage,
+                        subDivisions,
+                    }))
+                    continue;
+                const subDivisionName = findDivisionName(subDivision);
+                const newAncestorNames = subDivisionName
+                    ? [...ancestorDivisionNames, subDivisionName]
+                    : ancestorDivisionNames;
+                const { page, groupsOrPages, menuDivision } = findPageInNavigation({
+                    currentPath,
+                    entry: subDivision,
+                    parentGroups,
+                    isPreview,
+                    ancestorDivisionNames: newAncestorNames,
+                });
+                if (page) {
+                    const filteredSubDivisions = subDivisions
+                        .filter((division) => isDivisionAccessible(division, userGroups, isPreview))
+                        .map((item) => {
+                        const isActive = compareDivisions(item, subDivision);
+                        if ('hidden' in item && item.hidden && !isActive)
+                            return undefined;
+                        return buildDivisionItem({
+                            item,
+                            isActive,
+                            cache,
+                            currentVersion,
+                            currentLanguage,
+                            userGroups,
+                            divisionKey: key,
+                            menuDivision,
+                            isPreview,
+                            parentDivisionNames: ancestorDivisionNames,
+                        });
+                    })
+                        .filter(Boolean);
+                    if ('global' in subDivision) {
+                        upsertGlobalDivisions(navigationDivisions, subDivision.global);
+                    }
+                    if (filteredSubDivisions.length) {
+                        navigationDivisions[key].push(...filteredSubDivisions);
+                        return {
+                            page,
+                            groupsOrPages,
+                            menuDivision: key === 'menu' ? filteredSubDivisions : undefined,
+                        };
+                    }
+                }
+            }
+        }
+        return { page: undefined, groupsOrPages: undefined };
+    }
+    let groups = [];
+    const { page: page, groupsOrPages: filteredGroupsOrPages } = findPageInNavigation({
+        currentPath: currentPath === '/' || currentPath === ''
+            ? ((_a = getFirstPageFromNavigation(decoratedNav)) === null || _a === void 0 ? void 0 : _a.href) || ''
+            : currentPath,
+        entry: decoratedNav,
+        parentGroups: [],
+        isPreview,
+    });
+    if (!page && decoratedNav) {
+        const { divisions, groupsOrPages } = findMostRelevantDivisions(currentPath, decoratedNav, currentVersion, currentLanguage, currentProduct, userGroups, shouldUseDivisionMatch, cache, isPreview);
+        navigationDivisions = divisions;
+        groups = groupsOrPages;
+    }
+    if (filteredGroupsOrPages && filteredGroupsOrPages.length)
+        groups = filteredGroupsOrPages;
+    if (navigationDivisions.versions.length) {
+        updateFirstHrefInDivision({
+            type: 'version',
+            currentPath,
+            entry: decoratedNav,
+            parentGroups: [],
+            nearestDivisionValue: undefined,
+            isActiveGroup: false,
+            inActiveDivision: false,
+            currentDivisionValue: (_b = navigationDivisions.versions.find((version) => version.isActive)) === null || _b === void 0 ? void 0 : _b.name,
+            allDivisionValues: navigationDivisions.versions.map((version) => version.name),
+            firstHrefInDivision: firstHrefInVersion,
+            navigationDivisions,
+            isHiddenPage: page === undefined,
+        });
+    }
+    if (navigationDivisions.languages.length) {
+        updateFirstHrefInDivision({
+            type: 'language',
+            currentPath,
+            entry: decoratedNav,
+            parentGroups: [],
+            nearestDivisionValue: undefined,
+            isActiveGroup: false,
+            inActiveDivision: false,
+            currentDivisionValue: (_c = navigationDivisions.languages.find((language) => language.isActive)) === null || _c === void 0 ? void 0 : _c.language,
+            allDivisionValues: navigationDivisions.languages.map((language) => language.language),
+            firstHrefInDivision: firstHrefInLanguage,
+            navigationDivisions,
+            isHiddenPage: page === undefined,
+        });
+    }
+    if (decoratedNav && 'global' in decoratedNav && decoratedNav.global) {
+        upsertGlobalDivisions(navigationDivisions, decoratedNav.global);
+    }
+    return {
+        tabs: navigationDivisions.tabs,
+        anchors: navigationDivisions.anchors,
+        versions: navigationDivisions.versions,
+        languages: navigationDivisions.languages,
+        dropdowns: navigationDivisions.dropdowns,
+        products: navigationDivisions.products,
+        groupsOrPages: groups,
+        firstHrefInVersion,
+        firstHrefInLanguage,
+    };
+};
+function upsertGlobalDivisions(navigationDivisions, globalConfig) {
+    if (!globalConfig)
+        return;
+    Object.entries(navigationDivisions).forEach(([key, items]) => {
+        if (key in globalConfig) {
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- TODO: Please fix this violation when you can!
+            const globalItems = globalConfig[key];
+            if (globalItems) {
+                const filteredGlobalItems = globalItems.filter((item) => !item.hidden);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                items.push(...filteredGlobalItems.map((item) => (Object.assign(Object.assign({ name: findDivisionName(item) }, item), { href: item.href, isActive: false, isGlobal: true }))));
+            }
+        }
+    });
+}
+function buildDivisionItem(param) {
+    var _a;
+    const { item, isActive, cache, currentVersion, currentLanguage, userGroups, divisionKey, menuDivision, isPreview = false, parentDivisionNames = [], } = param;
+    const { dropdownCache } = cache;
+    let href = '';
+    // TODO: support this for other divisions (versions, languages, etc.)
+    // check if items's subdivisions are dropdowns
+    if (dropdownCache.size && 'dropdowns' in item) {
+        const dropdowns = item.dropdowns;
+        const itemName = findDivisionName(item);
+        const parentContext = [...parentDivisionNames, itemName].filter(Boolean).join(':');
+        const dropdownKey = generateCacheKey(dropdowns, parentContext || undefined);
+        const dropdownHref = dropdownCache.get(dropdownKey);
+        if (!!dropdownKey && dropdownHref) {
+            href = optionallyAddLeadingSlash(dropdownHref);
+        }
+    }
+    const page = (_a = getFirstPageFromCurrentDivisions(item, currentVersion, currentLanguage, userGroups !== null && userGroups !== void 0 ? userGroups : new Set(), isPreview)) !== null && _a !== void 0 ? _a : getFirstPageFromNavigation(item, userGroups, true, isPreview);
+    const keysToDrop = [...divisions, 'groups', 'pages'];
+    const divisionItem = Object.fromEntries(Object.entries(item).filter(([key]) => !keysToDrop.includes(key)));
+    // if href is absolute url, use it, otherwise use the href from the first page
+    if (!href) {
+        const isUserDefinedHref = 'href' in item && isAbsoluteUrl(item.href);
+        href = isUserDefinedHref ? item.href : (page === null || page === void 0 ? void 0 : page.href) || '/';
+        // when users switch languages, we should stay on the same page
+        // instead of switching to the first page in the new language
+        if (!isUserDefinedHref && divisionKey === 'languages') {
+            href = '';
+        }
+    }
+    const baseResult = Object.assign(Object.assign({ name: findDivisionName(item) }, divisionItem), { href: href, isActive, isGlobal: false });
+    // handle dropdowns for tabs and products with menu
+    if ((divisionKey === 'tabs' || divisionKey === 'products') && 'menu' in item) {
+        if (isActive && (menuDivision === null || menuDivision === void 0 ? void 0 : menuDivision.length)) {
+            return Object.assign(Object.assign({}, baseResult), { menu: menuDivision });
+        }
+        // non-active menu divisions
+        const parentDivisionName = findDivisionName(item);
+        const nonActiveMenu = item.menu
+            .filter((menuItem) => isDivisionAccessible(menuItem, userGroups || new Set(), isPreview))
+            .map((menuItem) => {
+            if (menuItem.hidden)
+                return undefined;
+            return buildDivisionItem({
+                item: menuItem,
+                isActive: false, // menu items are not active by default
+                cache,
+                currentVersion,
+                currentLanguage,
+                userGroups,
+                divisionKey: 'menu',
+                isPreview,
+                parentDivisionNames: [
+                    ...parentDivisionNames,
+                    ...(parentDivisionName ? [parentDivisionName] : []),
+                ],
+            });
+        })
+            .filter((menuItem) => menuItem !== undefined);
+        return Object.assign(Object.assign({}, baseResult), { menu: nonActiveMenu });
+    }
+    return baseResult;
+}
+function getFirstPageFromCurrentDivisions(item, currentVersion, currentLanguage, userGroups, isPreview = false) {
+    var _a, _b;
+    if ('versions' in item && currentVersion) {
+        const selectedVersion = item.versions.find((version) => version.version === currentVersion && isDivisionAccessible(version, userGroups, isPreview));
+        if (selectedVersion) {
+            const selectedVersionNavigation = getNavigationFromDivision(selectedVersion);
+            if (!selectedVersionNavigation)
+                return undefined;
+            return ((_a = getFirstPageFromCurrentDivisions(selectedVersionNavigation, currentVersion, currentLanguage, userGroups, isPreview)) !== null && _a !== void 0 ? _a : getFirstPageFromNavigation(selectedVersionNavigation, userGroups, true, isPreview));
+        }
+    }
+    if ('languages' in item && currentLanguage) {
+        const selectedLanguage = item.languages.find((language) => language.language === currentLanguage &&
+            isDivisionAccessible(language, userGroups, isPreview));
+        if (selectedLanguage) {
+            const selectedLanguageNavigation = getNavigationFromDivision(selectedLanguage);
+            if (!selectedLanguageNavigation)
+                return undefined;
+            return ((_b = getFirstPageFromCurrentDivisions(selectedLanguageNavigation, currentVersion, currentLanguage, userGroups, isPreview)) !== null && _b !== void 0 ? _b : getFirstPageFromNavigation(selectedLanguageNavigation, userGroups, true, isPreview));
+        }
+    }
+    return undefined;
+}
+function getNavigationFromDivision(item) {
+    for (const key of Object.keys(DIVISION_NAME_MAP)) {
+        if (key in item) {
+            return {
+                [key]: item[key],
+            };
+        }
+    }
+    if ('groups' in item)
+        return { groups: item.groups };
+    if ('pages' in item)
+        return { pages: item.pages };
+    return undefined;
+}
+function findDivisionName(node) {
+    if ('name' in node && typeof node.name === 'string')
+        return node.name;
+    const divisionName = Object.values(DIVISION_NAME_MAP).find((value) => value in node);
+    if (divisionName) {
+        const name = node[divisionName];
+        if (typeof name === 'string')
+            return name;
+    }
+    return '';
+}
+function filterInaccessiblePages(groups, userGroups, isPreview = false) {
+    if (!Array.isArray(groups) || !groups.length)
+        return [];
+    return groups
+        .map((group) => filterInaccessiblePagesRecursive(group, userGroups, isPreview))
+        .filter((group) => group !== undefined && !group.hidden);
+}
+function filterInaccessiblePagesRecursive(nav, userGroups, isPreview = false) {
+    if (typeof nav !== 'object')
+        return undefined;
+    if (isPage(nav)) {
+        return checkNavAccess(nav, userGroups, isPreview) ? nav : undefined;
+    }
+    if (nav.hidden)
+        return undefined;
+    const newNav = Object.assign({}, nav);
+    if ('pages' in nav) {
+        const filteredPages = nav.pages
+            .map((page) => filterInaccessiblePagesRecursive(page, userGroups, isPreview))
+            .filter((page) => page !== undefined);
+        let hasAccessibleRoot = false;
+        if ('root' in nav && typeof nav.root === 'object') {
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- root is a DecoratedNavigationPage
+            const rootPage = nav.root;
+            if (!filterInaccessiblePagesRecursive(rootPage, userGroups, isPreview)) {
+                newNav.root = undefined;
+            }
+            else {
+                hasAccessibleRoot = true;
+            }
+        }
+        if (filteredPages.length === 0 && !hasAccessibleRoot)
+            return undefined;
+        newNav.pages = filteredPages;
+    }
+    return newNav;
+}
+/**
+ * Return true if checkNavAccess passes on some page in provided entry and also groups or pages are not empty
+ */
+function isDivisionAccessible(entry, userGroups, isPreview = false) {
+    if (isPreview)
+        return true;
+    if (typeof entry !== 'object')
+        return false;
+    if (isPage(entry)) {
+        return checkNavAccess(entry, userGroups, isPreview);
+    }
+    if ('pages' in entry) {
+        if ('root' in entry && typeof entry.root === 'object') {
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- root is a DecoratedNavigationPage
+            const rootPage = entry.root;
+            if (isDivisionAccessible(rootPage, userGroups, isPreview)) {
+                return true;
+            }
+        }
+        if (entry.pages.length === 0)
+            return false;
+        let hasAccessiblePage = false;
+        for (const page of entry.pages) {
+            if (typeof page === 'object') {
+                const isAccessible = isDivisionAccessible(page, userGroups, isPreview);
+                if (isAccessible) {
+                    hasAccessiblePage = true;
+                    break;
+                }
+            }
+        }
+        if (!hasAccessiblePage)
+            return false;
+    }
+    if ('groups' in entry) {
+        if (entry.groups.length === 0)
+            return false;
+        if (entry.groups.every((group) => group.hidden))
+            return false;
+        let hasAccessibleGroup = false;
+        for (const group of entry.groups) {
+            const isAccessible = isDivisionAccessible(group, userGroups, isPreview);
+            if (isAccessible) {
+                hasAccessibleGroup = true;
+                break;
+            }
+        }
+        if (!hasAccessibleGroup)
+            return false;
+    }
+    for (const key of divisions) {
+        const subDivisions = readObjectArrayProperty(entry, key);
+        if (!subDivisions)
+            continue;
+        if (subDivisions.every((item) => item.hidden))
+            return false;
+        if (!subDivisions.some((subDivision) => isDivisionAccessible(subDivision, userGroups, isPreview)))
+            return false;
+    }
+    return true;
+}
+/**
+ * This function will find all most relevant divisions and groups or pages
+ * for the current path if the current path directs to a page that is not listed in the navigation.
+ *
+ * Logic:
+ * 1. find the most relevant groups or pages
+ * 2. find the most relevant divisions based on the most relevant groups or pages
+ * 3. if there is no most relevant divisions, default to the first division
+ *
+ * Example:
+ * if the current path is 1-1-3, it should return all groups under "anchor" and
+ * return all divisions on the top level
+ * - divisions
+ * - [division_name]: "anchor"
+ * - groups:
+ * - group: "1"
+ * - pages: ["1-1", "1-2"]
+ *
+ * - group: "1-1"
+ * - pages: ["1-1-1", "1-1-2"]
+ *
+ * - group: "2"
+ * - pages: ["2-1", "2-2"]
+ */
+function findMostRelevantDivisions(currentPath, decoratedNav, currentVersion, currentLanguage, currentProduct, userGroups, shouldUseDivisionMatch, cache, isPreview = false) {
+    const navigationDivisions = {
+        tabs: [],
+        anchors: [],
+        versions: [],
+        languages: [],
+        dropdowns: [],
+        menu: [],
+        products: [],
+    };
+    let mostSpecificGroups;
+    let maxMatchedPrefix;
+    let isPageAccessible = true;
+    function findMostRelevantGroupsHelper(entry, parentGroups) {
+        if (typeof entry !== 'object')
+            return;
+        if (isPage(entry)) {
+            if (!isEqualIgnoringLeadingSlash(currentPath, entry.href) &&
+                checkNavAccess(entry, userGroups, isPreview)) {
+                const matchedPrefix = findMaxMatchingPrefix(currentPath, entry.href);
+                const isNewMaxPrefix = matchedPrefix.length > ((maxMatchedPrefix === null || maxMatchedPrefix === void 0 ? void 0 : maxMatchedPrefix.length) || 0);
+                const isSameMaxPrefix = matchedPrefix === maxMatchedPrefix;
+                if (isNewMaxPrefix) {
+                    maxMatchedPrefix = matchedPrefix;
+                    mostSpecificGroups = parentGroups;
+                }
+                else if (isSameMaxPrefix && maxMatchedPrefix === '/' && !mostSpecificGroups) {
+                    mostSpecificGroups = parentGroups;
+                }
+            }
+            else if (isEqualIgnoringLeadingSlash(currentPath, entry.href)) {
+                isPageAccessible = checkNavAccess(entry, userGroups, isPreview, false);
+            }
+        }
+        if ('pages' in entry && Array.isArray(entry.pages)) {
+            const resolvedParentGroups = parentGroups.length
+                ? parentGroups
+                : entry.pages
+                    .map((page) => filterInaccessiblePagesRecursive(page, userGroups, isPreview))
+                    .filter((page) => page !== undefined);
+            if ('root' in entry && typeof entry.root === 'object') {
+                findMostRelevantGroupsHelper(
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- root is a DecoratedNavigationPage
+                entry.root, resolvedParentGroups);
+            }
+            for (const page of entry.pages) {
+                if (typeof page === 'object') {
+                    findMostRelevantGroupsHelper(page, resolvedParentGroups);
+                }
+            }
+        }
+        if ('groups' in entry && !isPage(entry)) {
+            const newParentGroups = filterInaccessiblePages(entry.groups, userGroups, isPreview);
+            for (const group of entry.groups) {
+                findMostRelevantGroupsHelper(group, newParentGroups);
+            }
+        }
+        for (const key of divisions) {
+            const subDivisions = readObjectArrayProperty(entry, key);
+            if (!subDivisions)
+                continue;
+            for (const subDivision of subDivisions) {
+                if (shouldUseDivisionMatch &&
+                    shouldSkipDivisionMatch({
+                        subDivision,
+                        key,
+                        currentVersion,
+                        currentLanguage,
+                        subDivisions,
+                    }))
+                    continue;
+                findMostRelevantGroupsHelper(subDivision, parentGroups);
+            }
+        }
+    }
+    findMostRelevantGroupsHelper(decoratedNav, []);
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    mostSpecificGroups = isPageAccessible ? mostSpecificGroups : [];
+    if (mostSpecificGroups) {
+        const isStrictlyEqual = (entry) => {
+            return (JSON.stringify(structuredClone(mostSpecificGroups)) ===
+                JSON.stringify(structuredClone(entry)));
+        };
+        // look for divisions based on the most specific groups
+        function findMostRelevantDivisionsHelper(entry, parentGroups, ancestorDivisionNames = []) {
+            if (typeof entry !== 'object')
+                return false;
+            if ('pages' in entry && Array.isArray(entry.pages)) {
+                return isStrictlyEqual(parentGroups.length
+                    ? parentGroups
+                    : entry.pages
+                        .map((page) => filterInaccessiblePagesRecursive(page, userGroups, isPreview))
+                        .filter((page) => page !== undefined));
+            }
+            if ('groups' in entry && !isPage(entry)) {
+                const newParentGroups = filterInaccessiblePages(entry.groups, userGroups, isPreview);
+                return isStrictlyEqual(newParentGroups);
+            }
+            for (const key of divisions) {
+                const subDivisions = readObjectArrayProperty(entry, key);
+                if (!subDivisions)
+                    continue;
+                const iterationOrder = key === 'products'
+                    ? reorderForCurrentProduct(subDivisions, currentProduct)
+                    : subDivisions;
+                for (const subDivision of iterationOrder) {
+                    if (shouldUseDivisionMatch &&
+                        shouldSkipDivisionMatch({
+                            subDivision,
+                            key,
+                            currentVersion,
+                            currentLanguage,
+                            subDivisions,
+                        }))
+                        continue;
+                    const subDivisionName = findDivisionName(subDivision);
+                    const newAncestorNames = subDivisionName
+                        ? [...ancestorDivisionNames, subDivisionName]
+                        : ancestorDivisionNames;
+                    const founded = findMostRelevantDivisionsHelper(subDivision, parentGroups, newAncestorNames);
+                    /**
+                     * display divisions if
+                     * - the page is not accessible and we need to display all accessible divisions
+                     * OR
+                     * - the specific group has been found in the division
+                     */
+                    if (founded || !isPageAccessible) {
+                        const filteredSubDivisions = subDivisions
+                            .filter((division) => isDivisionAccessible(division, userGroups, isPreview))
+                            .map((item) => {
+                            const isActive = compareDivisions(item, subDivision) && isPageAccessible === true;
+                            if (item.hidden && !isActive)
+                                return undefined;
+                            return buildDivisionItem({
+                                item,
+                                isActive,
+                                cache,
+                                currentVersion,
+                                currentLanguage,
+                                userGroups,
+                                divisionKey: key,
+                                isPreview,
+                                parentDivisionNames: ancestorDivisionNames,
+                            });
+                        })
+                            .filter(Boolean);
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        navigationDivisions[key].push(...filteredSubDivisions);
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+        findMostRelevantDivisionsHelper(decoratedNav, [], []);
+    }
+    return {
+        divisions: navigationDivisions,
+        groupsOrPages: mostSpecificGroups || [],
+    };
+}
+function findMaxMatchingPrefix(path1, path2) {
+    const minLength = Math.min(path1.length, path2.length);
+    let matchingLength = 0;
+    for (let i = 0; i < minLength; i++) {
+        if (path1[i] !== path2[i]) {
+            break;
+        }
+        matchingLength++;
+    }
+    return path1.substring(0, matchingLength);
+}
+const compareDivisions = (item, subDivision) => {
+    return JSON.stringify(structuredClone(item)) === JSON.stringify(structuredClone(subDivision));
+};
+function shouldSkipDivisionMatch({ subDivision, key, currentVersion, currentLanguage, subDivisions, }) {
+    const isVersionsConfig = key === 'versions' && !!currentVersion;
+    const isLanguagesConfig = key === 'languages' && !!currentLanguage;
+    if (isVersionsConfig) {
+        const versionConfig = subDivision;
+        const availableVersions = subDivisions.map((d) => d.version);
+        return versionConfig.version !== currentVersion && availableVersions.includes(currentVersion);
+    }
+    if (isLanguagesConfig) {
+        const languageConfig = subDivision;
+        const availableLanguages = subDivisions.map((d) => d.language);
+        return (languageConfig.language !== currentLanguage && availableLanguages.includes(currentLanguage));
+    }
+    return false;
+}
+/**
+ * TODO: we should add cache for versions and languages in the future
+ * Generate a cache key for the dropdowns
+ * @param dropdowns - the dropdowns to generate a cache key for
+ * @param parentContext - optional parent context to make the key unique across different parent divisions
+ * @returns the cache key
+ */
+export function generateCacheKey(divisions, parentContext) {
+    const firstDivision = divisions[0];
+    if (!firstDivision)
+        return '';
+    const divisionName = Object.values(DIVISION_NAME_MAP).find((value) => value in firstDivision);
+    if (!divisionName)
+        return '';
+    const key = divisions.reduce((acc, division) => acc + division[divisionName], '');
+    return parentContext ? `${parentContext}:${key}` : key;
+}