@mintlify/common 1.0.1264 → 1.0.1266

package/dist/navigation/filterDivisions.d.ts

@@ -10,6 +10,7 @@ export type FilterDivisionsParams = {
     userGroups: Set<string>;
     isPreview?: boolean;
     shouldUseDivisionMatch: boolean;
+    skipDivisionTargets?: boolean;
     cache: {
         dropdownCache: Map<string, string>;
     };
@@ -54,7 +55,7 @@ export type NavigationDivisions = {
     products: Array<ProductsResult>;
     menu: Array<MenuResult>;
 };
-export declare const filterDivisions: ({ currentPath, currentVersion, currentLanguage, currentProduct, decoratedNav, userGroups, shouldUseDivisionMatch, cache, isPreview, }: FilterDivisionsParams) => FilterDivisionsResult;
+export declare const filterDivisions: ({ currentPath, currentVersion, currentLanguage, currentProduct, decoratedNav, userGroups, shouldUseDivisionMatch, skipDivisionTargets, cache, isPreview, }: FilterDivisionsParams) => FilterDivisionsResult;
 /**
  * TODO: we should add cache for versions and languages in the future
  * Generate a cache key for the dropdowns

package/dist/navigation/filterDivisions.js

@@ -34,7 +34,7 @@ function reorderForCurrentProduct(items, currentProduct) {
         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, }) => {
+export const filterDivisions = ({ currentPath, currentVersion, currentLanguage, currentProduct, decoratedNav, userGroups, shouldUseDivisionMatch = true, skipDivisionTargets = false, cache, isPreview = false, }) => {
     var _a, _b, _c;
     let navigationDivisions = {
         tabs: [],
@@ -204,7 +204,7 @@ export const filterDivisions = ({ currentPath, currentVersion, currentLanguage,
     }
     if (filteredGroupsOrPages && filteredGroupsOrPages.length)
         groups = filteredGroupsOrPages;
-    if (navigationDivisions.versions.length) {
+    if (!skipDivisionTargets && navigationDivisions.versions.length) {
         updateFirstHrefInDivision({
             type: 'version',
             currentPath,
@@ -221,7 +221,7 @@ export const filterDivisions = ({ currentPath, currentVersion, currentLanguage,
             activeDivisionOwner: activeVersionsOwner,
         });
     }
-    if (navigationDivisions.languages.length) {
+    if (!skipDivisionTargets && navigationDivisions.languages.length) {
         updateFirstHrefInDivision({
             type: 'language',
             currentPath,

package/dist/navigation/isCommonPage.js

@@ -13,15 +13,16 @@ export function isCommonPage(entry, path) {
     isCommonPageRecursive(entry, path, occurrences);
     return occurrences.value > 1;
 }
+const CHILD_KEYS = [...divisions, 'groups', 'pages'];
 function isCommonPageRecursive(entry, path, occurrences) {
-    if (typeof entry !== 'object')
+    if (typeof entry !== 'object' || occurrences.value > 1)
         return;
     if (isPage(entry)) {
         if (isEqualIgnoringLeadingSlash(entry.href, path)) {
             occurrences.value++;
         }
     }
-    for (const key of [...divisions, 'groups', 'pages']) {
+    for (const key of CHILD_KEYS) {
         if (key === 'pages' && 'root' in entry && typeof entry.root === 'object') {
             // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- root is a DecoratedNavigationPage
             isCommonPageRecursive(entry.root, path, occurrences);

package/dist/navigation/pathsDifferByOneSegment.test.js

@@ -149,3 +149,11 @@ describe('pathsDifferByOneSegment', () => {
         });
     });
 });
+describe('pathsDifferByOneSegment configured languages', () => {
+    it('sees languages added to the same array in place', () => {
+        const languages = ['zz'];
+        expect(pathsDifferByOneSegment('/tlh/guide', '/guide', 'language', languages)).toBe(false);
+        languages.push('tlh');
+        expect(pathsDifferByOneSegment('/tlh/guide', '/guide', 'language', languages)).toBe(true);
+    });
+});

package/dist/navigation/scopeNavToPath.js

@@ -592,6 +592,7 @@ export function getScopedNavForPath({ decoratedNav, currentPath, userGroups = ne
         currentLanguage: undefined,
         currentProduct,
         shouldUseDivisionMatch: false,
+        skipDivisionTargets: true,
         cache: { dropdownCache: new Map() },
         isPreview,
     });

package/dist/navigation/updateFirstHrefInDivision.js

@@ -107,7 +107,7 @@ export function updateFirstHrefInDivision({ type, currentPath, entry, parentGrou
             });
         }
     }
-    for (const key of [...divisions, 'groups']) {
+    for (const key of divisions) {
         const subDivisions = readObjectArrayProperty(entry, key);
         if (!subDivisions)
             continue;
@@ -165,10 +165,7 @@ export function updateFirstHrefInDivision({ type, currentPath, entry, parentGrou
                 type,
                 currentPath,
                 entry: subDivision,
-                parentGroups: key === 'groups' && 'groups' in entry
-                    ? // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                        entry.groups
-                    : parentGroups,
+                parentGroups,
                 nearestDivisionValue: divisionValue !== null && divisionValue !== void 0 ? divisionValue : nearestDivisionValue,
                 isActiveGroup,
                 inActiveDivision: inActiveDivision,
@@ -220,14 +217,37 @@ function findActiveGroupNames(entry, currentPath, activeGroupNames = new Set())
     }
     return activeGroupNames;
 }
+const NO_LANGUAGES = [];
+let lastLanguageSet;
+function getLowerCaseLanguageSet(languages) {
+    const cached = lastLanguageSet;
+    if ((cached === null || cached === void 0 ? void 0 : cached.languages.length) === languages.length &&
+        cached.languages.every((language, i) => language === languages[i])) {
+        return cached.set;
+    }
+    const set = new Set(languages.map((language) => language.toLowerCase()));
+    lastLanguageSet = { languages: [...languages], set };
+    return set;
+}
 const isLanguageSegment = (segment, languages) => {
     if (segment === undefined)
         return false;
-    if (isKnownLocale(segment))
-        return true;
-    const lowerCaseSegment = segment.toLowerCase();
-    return languages.some((language) => language.toLowerCase() === lowerCaseSegment);
+    return isKnownLocale(segment) || languages.has(segment.toLowerCase());
 };
+const toSegments = (path) => path.split('/').filter(Boolean);
+let lastTarget;
+function getTarget(path, languages) {
+    if ((lastTarget === null || lastTarget === void 0 ? void 0 : lastTarget.path) !== path || lastTarget.languages !== languages) {
+        const segments = toSegments(path);
+        lastTarget = {
+            path,
+            languages,
+            segments,
+            languagePath: parseLanguagePath(segments, languages),
+        };
+    }
+    return lastTarget;
+}
 function parseLanguagePath(segments, languages) {
     let index = 0;
     let locale;
@@ -340,19 +360,21 @@ function maybeUpdateFirstHrefInDivision(type, href, finalVersion, inActiveGroup,
         }
     }
 }
-export function pathsDifferByOneSegment(a, b, type, languages = []) {
+export function pathsDifferByOneSegment(a, b, type, languages = NO_LANGUAGES) {
     var _a, _b;
-    const aSegments = a.split('/').filter(Boolean);
-    const bSegments = b.split('/').filter(Boolean);
+    const languageSet = getLowerCaseLanguageSet(languages);
+    const aSegments = toSegments(a);
+    const target = getTarget(b, languageSet);
+    const bSegments = target.segments;
     // For language switching, we need to be more strict - paths should be identical except for the language segment
     // once normalized, content segments should be identical and only locale prefix may differ.
     if (type === 'language') {
-        const aPath = parseLanguagePath(aSegments, languages);
-        const bPath = parseLanguagePath(bSegments, languages);
+        const aPath = parseLanguagePath(aSegments, languageSet);
+        const bPath = target.languagePath;
         if (aPath.hasDocsBase !== bPath.hasDocsBase)
             return false;
         if (!aPath.locale && !bPath.locale) {
-            return differByOneLocaleSegment(aPath.contentSegments, bPath.contentSegments, languages);
+            return differByOneLocaleSegment(aPath.contentSegments, bPath.contentSegments, languageSet);
         }
         // For language switching, the content parts (including version segments) must be identical.
         if (aPath.contentSegments.length !== bPath.contentSegments.length)