@mintlify/common 1.0.1228 → 1.0.1230

package/dist/navigation/scopeNavToPath.test.js

@@ -43,6 +43,43 @@ describe('scopeDecoratedNavToPath', () => {
         expect(es.pages).toEqual([{ title: 'es', href: '/es/get-started/intro' }]);
         expect(fr.pages).toEqual([{ title: 'fr', href: '/fr/other/page' }]);
     });
+    it('keeps a regional language division active on its own pages', () => {
+        const regionalNav = {
+            languages: [
+                { language: 'en', default: true, pages: [page('/intro'), page('/install')] },
+                { language: 'en-GB', pages: [page('/en-gb/intro'), page('/en-gb/install')] },
+            ],
+        };
+        const [en, enGB] = loose(scopeDecoratedNavToPath(regionalNav, '/en-gb/intro')).languages;
+        if (!en || !enGB)
+            throw new Error('missing languages');
+        expect(enGB.pages).toEqual([page('/en-gb/intro'), page('/en-gb/install')]);
+        expect(en.pages).toEqual([{ title: 'en', href: '/intro' }]);
+    });
+    it('stubs a regional language division with the same page under its prefix', () => {
+        const regionalNav = {
+            languages: [
+                { language: 'en', default: true, pages: [page('/intro'), page('/install')] },
+                { language: 'en-GB', pages: [page('/en-gb/intro'), page('/en-gb/install')] },
+            ],
+        };
+        const [, enGB] = loose(scopeDecoratedNavToPath(regionalNav, '/install')).languages;
+        expect(enGB === null || enGB === void 0 ? void 0 : enGB.pages).toEqual([{ title: 'en-GB', href: '/en-gb/install' }]);
+    });
+    it('ignores a page field named language when finding configured languages', () => {
+        const nav = {
+            languages: [
+                {
+                    language: 'en',
+                    default: true,
+                    pages: [{ title: 'Setup', href: '/hi-fi/setup', language: 'hi-fi' }],
+                },
+                { language: 'de', pages: [page('/de/setup'), page('/de/hi-fi/setup')] },
+            ],
+        };
+        const [, de] = loose(scopeDecoratedNavToPath(nav, '/hi-fi/setup')).languages;
+        expect(de === null || de === void 0 ? void 0 : de.pages).toEqual([{ title: 'de', href: '/de/hi-fi/setup' }]);
+    });
     it('falls back to the default division when the path is not found', () => {
         const scoped = scopeDecoratedNavToPath(decoratedNav, '/does/not/exist');
         const [en, es] = loose(scoped).languages;

package/dist/navigation/updateFirstHrefInDivision.d.ts

@@ -28,4 +28,4 @@ export declare function updateFirstHrefInDivision({ type, currentPath, entry, pa
     activeGroupNames?: Set<string>;
     activeDivisionOwner?: object;
 }): void;
-export declare function pathsDifferByOneSegment(a: string, b: string, type: 'version' | 'language'): boolean;
+export declare function pathsDifferByOneSegment(a: string, b: string, type: 'version' | 'language', languages?: readonly string[]): boolean;

package/dist/navigation/updateFirstHrefInDivision.js

@@ -1,4 +1,4 @@
-import { locales } from '@mintlify/models';
+import { isKnownLocale } from '@mintlify/models';
 import { divisions, } from '@mintlify/validation';
 import { readObjectArrayProperty } from '../divisions/iterateObjectArrayProperty.js';
 import { isEqualIgnoringLeadingSlash } from '../paths/isEqualIgnoringLeadingSlash.js';
@@ -209,29 +209,30 @@ function findActiveGroupNames(entry, currentPath, activeGroupNames = new Set())
     }
     return activeGroupNames;
 }
-function parseLanguagePath(segments) {
+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);
+};
+function parseLanguagePath(segments, languages) {
     let index = 0;
     let locale;
     let hasDocsBase = false;
     const firstSegment = segments[0];
     const firstIsDocsBase = !!firstSegment && ACCEPTED_BASE_PATHS.includes(firstSegment);
-    const firstIsLocale = !!firstSegment &&
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- TODO: Please fix this violation when you can!
-        locales.includes(firstSegment);
     if (firstIsDocsBase) {
         hasDocsBase = true;
         index = 1;
         const maybeLocale = segments[index];
-        if (maybeLocale &&
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- TODO: Please fix this violation when you can!
-            locales.includes(maybeLocale)) {
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- TODO: Please fix this violation when you can!
+        if (isLanguageSegment(maybeLocale, languages)) {
             locale = maybeLocale;
             index++;
         }
     }
-    else if (firstIsLocale) {
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- TODO: Please fix this violation when you can!
+    else if (isLanguageSegment(firstSegment, languages)) {
         locale = firstSegment;
         index = 1;
         const maybeDocsBase = segments[index];
@@ -283,8 +284,9 @@ function maybeUpdateFirstHrefInDivision(type, href, finalVersion, inActiveGroup,
     // we make the BOLD assumption that href is a different version of the same page
     if (currentVersion !== undefined && finalVersion !== undefined) {
         const existingRef = firstHrefInDivision.get(finalVersion);
+        const languages = type === 'language' ? versionStrings : undefined;
         if ((existingRef === undefined || DivisionMatchLevel.PATH < existingRef.matchLevel) &&
-            pathsDifferByOneSegment(href, currentPath, type)) {
+            pathsDifferByOneSegment(href, currentPath, type, languages)) {
             firstHrefInDivision.set(finalVersion, { href, matchLevel: DivisionMatchLevel.PATH });
         }
     }
@@ -316,18 +318,19 @@ function maybeUpdateFirstHrefInDivision(type, href, finalVersion, inActiveGroup,
         }
     }
 }
-export function pathsDifferByOneSegment(a, b, type) {
+export function pathsDifferByOneSegment(a, b, type, languages = []) {
+    var _a, _b;
     const aSegments = a.split('/').filter(Boolean);
     const bSegments = b.split('/').filter(Boolean);
     // 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);
-        const bPath = parseLanguagePath(bSegments);
+        const aPath = parseLanguagePath(aSegments, languages);
+        const bPath = parseLanguagePath(bSegments, languages);
         if (aPath.hasDocsBase !== bPath.hasDocsBase)
             return false;
         if (!aPath.locale && !bPath.locale) {
-            return differByOneLocaleSegment(aPath.contentSegments, bPath.contentSegments);
+            return differByOneLocaleSegment(aPath.contentSegments, bPath.contentSegments, languages);
         }
         // For language switching, the content parts (including version segments) must be identical.
         if (aPath.contentSegments.length !== bPath.contentSegments.length)
@@ -340,7 +343,7 @@ export function pathsDifferByOneSegment(a, b, type) {
         // The paths are language variants if locale presence/value differs.
         if (!aPath.locale && !bPath.locale)
             return false;
-        return aPath.locale !== bPath.locale;
+        return ((_a = aPath.locale) === null || _a === void 0 ? void 0 : _a.toLowerCase()) !== ((_b = bPath.locale) === null || _b === void 0 ? void 0 : _b.toLowerCase());
     }
     const aStartsWithDocs = aSegments[0] && ACCEPTED_BASE_PATHS.includes(aSegments[0]);
     const bStartsWithDocs = bSegments[0] && ACCEPTED_BASE_PATHS.includes(bSegments[0]);
@@ -377,22 +380,22 @@ export function pathsDifferByOneSegment(a, b, type) {
     }
     return true;
 }
-function isLocale(segment) {
-    return locales.some((locale) => locale === segment);
-}
-function differByOneLocaleSegment(a, b) {
+function differByOneLocaleSegment(a, b, languages) {
     if (a.length === b.length) {
         const mismatches = a.flatMap((segment, i) => (segment === b[i] ? [] : [i]));
         if (mismatches.length !== 1)
             return false;
         const [index] = mismatches;
-        return index !== undefined && isLocale(a[index]) && isLocale(b[index]);
+        return (index !== undefined &&
+            isLanguageSegment(a[index], languages) &&
+            isLanguageSegment(b[index], languages));
     }
     const [longer, shorter] = a.length > b.length ? [a, b] : [b, a];
     if (longer.length !== shorter.length + 1)
         return false;
     const index = longer.findIndex((segment, i) => segment !== shorter[i]);
-    return (isLocale(longer[index]) && longer.slice(index + 1).every((s, i) => s === shorter[index + i]));
+    return (isLanguageSegment(longer[index], languages) &&
+        longer.slice(index + 1).every((s, i) => s === shorter[index + i]));
 }
 function checkActiveGroup(group, currentPath) {
     if (isPage(group)) {