@mintlify/common 1.0.1229 → 1.0.1230

package/dist/navigation/filterDivisions.test.js

@@ -270,6 +270,29 @@ describe(filterDivisions, () => {
         });
     });
 });
+describe('filterDivisions with regional languages', () => {
+    it('matches the same page in a regional language whose prefix is lower case', () => {
+        const page = (href) => ({ title: href, href });
+        const result = filterDivisions({
+            currentPath: '/quickstart',
+            userGroups: new Set(),
+            currentVersion: undefined,
+            currentLanguage: 'en',
+            shouldUseDivisionMatch: false,
+            cache: { dropdownCache: new Map() },
+            decoratedNav: {
+                languages: [
+                    { language: 'en', default: true, pages: [page('/index'), page('/quickstart')] },
+                    { language: 'en-GB', pages: [page('/en-gb/index'), page('/en-gb/quickstart')] },
+                ],
+            },
+        });
+        expect(result.firstHrefInLanguage.get('en-GB')).toEqual({
+            href: '/en-gb/quickstart',
+            matchLevel: DivisionMatchLevel.PATH,
+        });
+    });
+});
 describe('filterDivisions with partial auth', () => {
     const defaultArgs = {
         decoratedNav: { groups: [] },

package/dist/navigation/pathsDifferByOneSegment.test.js

@@ -9,6 +9,23 @@ describe('pathsDifferByOneSegment', () => {
             expect(pathsDifferByOneSegment('/ja/getting-started', '/es/getting-started', 'language')).toBe(true);
             expect(pathsDifferByOneSegment('/fr/docs/intro', '/de/docs/intro', 'language')).toBe(true);
         });
+        it('treats configured regional language prefixes as locales, ignoring case', () => {
+            const languages = ['en', 'en-GB', 'es', 'es-MX'];
+            expect(pathsDifferByOneSegment('/en-gb/quickstart', '/quickstart', 'language', languages)).toBe(true);
+            expect(pathsDifferByOneSegment('/es-MX/quickstart', '/es/quickstart', 'language', languages)).toBe(true);
+        });
+        it('treats a configured regional language after a version segment as a locale', () => {
+            expect(pathsDifferByOneSegment('/v2/en-gb/quickstart', '/v2/quickstart', 'language', [
+                'en',
+                'en-GB',
+            ])).toBe(true);
+            expect(pathsDifferByOneSegment('/v2/hi-fi/quickstart', '/v2/quickstart', 'language')).toBe(false);
+        });
+        it('does not treat unconfigured code-like segments as locales', () => {
+            expect(pathsDifferByOneSegment('/en-gb/quickstart', '/quickstart', 'language')).toBe(false);
+            expect(pathsDifferByOneSegment('/hi-fi/setup', '/de/hi-fi/setup', 'language', ['en', 'de'])).toBe(true);
+            expect(pathsDifferByOneSegment('/hi-fi/setup', '/de/setup', 'language', ['en', 'de'])).toBe(false);
+        });
         it('returns false for paths with different content', () => {
             expect(pathsDifferByOneSegment('/ja/getting-started', '/ja/quickstart', 'language')).toBe(false);
             expect(pathsDifferByOneSegment('/getting-started', '/quickstart', 'language')).toBe(false);

package/dist/navigation/scopeNavToPath.d.ts

@@ -1,5 +1,5 @@
 import { LocaleType } from '@mintlify/models';
-import type { DecoratedNavigationConfig, DocsConfig } from '@mintlify/validation';
+import { type DecoratedNavigationConfig, type DocsConfig } from '@mintlify/validation';
 import { DivisionMatch } from './updateFirstHrefInDivision.js';
 export declare function scopeDecoratedNavToPath(nav: DecoratedNavigationConfig, currentPath: string, userGroups?: Set<string>): DecoratedNavigationConfig;
 export declare function scopeDocsConfigNavToPath(docsConfig: DocsConfig, currentPath: string): DocsConfig;

package/dist/navigation/scopeNavToPath.js

@@ -9,7 +9,8 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-import { locales } from '@mintlify/models';
+import { isLocale } from '@mintlify/models';
+import { divisions, } from '@mintlify/validation';
 import { generatePathToLanguageDict, generatePathToVersionDict } from '../divisions/index.js';
 import { optionallyRemoveLeadingSlash } from '../fs/optionallySlash.js';
 import { isEqualIgnoringLeadingSlash } from '../paths/isEqualIgnoringLeadingSlash.js';
@@ -49,6 +50,31 @@ const STUB_STRIPPED_KEYS = new Set([
 function isNavNode(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
+const LANGUAGE_CONTAINER_KEYS = [...divisions, 'global'];
+function addConfiguredLanguages(node, languages) {
+    if (Array.isArray(node)) {
+        for (const entry of node)
+            addConfiguredLanguages(entry, languages);
+        return;
+    }
+    if (!isNavNode(node))
+        return;
+    if (typeof node.language === 'string' && isLocale(node.language))
+        languages.add(node.language);
+    for (const key of LANGUAGE_CONTAINER_KEYS)
+        addConfiguredLanguages(node[key], languages);
+}
+const configuredLanguagesCache = new WeakMap();
+function getConfiguredLanguages(nav) {
+    const cached = configuredLanguagesCache.get(nav);
+    if (cached)
+        return cached;
+    const languages = new Set();
+    addConfiguredLanguages(nav, languages);
+    const result = [...languages];
+    configuredLanguagesCache.set(nav, result);
+    return result;
+}
 function isScopedDivisionKey(key) {
     return key === 'versions' || key === 'languages';
 }
@@ -143,7 +169,7 @@ function pickStubTarget(division, ctx, type) {
     const exact = pool.find((candidate) => isEqualIgnoringLeadingSlash(candidate.href, ctx.currentPath));
     if (exact)
         return exact;
-    const pathMatch = pool.find((candidate) => pathsDifferByOneSegment(candidate.href, ctx.currentPath, type));
+    const pathMatch = pool.find((candidate) => pathsDifferByOneSegment(candidate.href, ctx.currentPath, type, ctx.languages));
     return pathMatch !== null && pathMatch !== void 0 ? pathMatch : pool[0];
 }
 // carrying the target's hidden/groups keeps a division with no anonymously
@@ -517,13 +543,18 @@ function scopeNode(node, ctx) {
     return scoped;
 }
 export function scopeDecoratedNavToPath(nav, currentPath, userGroups) {
+    const ctx = { currentPath, userGroups, languages: getConfiguredLanguages(nav) };
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- structural nav traversal over the zod union types
-    return scopeNode(nav, { currentPath, userGroups });
+    return scopeNode(nav, ctx);
 }
 export function scopeDocsConfigNavToPath(docsConfig, currentPath) {
+    const ctx = {
+        currentPath,
+        languages: getConfiguredLanguages(docsConfig.navigation),
+    };
     return Object.assign(Object.assign({}, docsConfig), { 
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- structural nav traversal over the zod union types
-        navigation: scopeNode(docsConfig.navigation, { currentPath }) });
+        navigation: scopeNode(docsConfig.navigation, ctx) });
 }
 const pathToVersionDictCache = new WeakMap();
 const pathToLanguageDictCache = new WeakMap();
@@ -571,7 +602,7 @@ export function getScopedNavForPath({ decoratedNav, currentPath, userGroups = ne
         const strippedPath = optionallyRemoveLeadingSlash(currentPath);
         const dictVersion = cachedPathToVersionDict(decoratedNav).get(strippedPath);
         const dictLanguage = cachedPathToLanguageDict(decoratedNav).get(strippedPath);
-        const localeFromDict = locales.find((locale) => locale === dictLanguage);
+        const localeFromDict = dictLanguage && isLocale(dictLanguage) ? dictLanguage : undefined;
         currentVersion =
             dictVersion ||
                 getVersionOrLanguageFromPath('version', decoratedNav, currentPath, defaultVersion, (_d = (_c = initial.versions[0]) === null || _c === void 0 ? void 0 : _c.name) !== null && _d !== void 0 ? _d : '') ||
@@ -596,6 +627,7 @@ export function getScopedNavForPath({ decoratedNav, currentPath, userGroups = ne
         currentPath,
         currentVersion,
         currentLanguage,
+        languages: getConfiguredLanguages(decoratedNav),
         versionTargets: filtered.firstHrefInVersion,
         languageTargets: filtered.firstHrefInLanguage,
         userGroups,

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)) {