@mintlify/common 1.0.1023 → 1.0.1024

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

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

package/dist/navigation/scopeProductNav.test.js

@@ -0,0 +1,288 @@
+import { describe, expect, it } from 'vitest';
+import { isEqualIgnoringLeadingSlash } from '../paths/isEqualIgnoringLeadingSlash.js';
+import { filterDivisions } from './filterDivisions.js';
+import { getAllPathsInDecoratedNav } from './getAllPathsInDecoratedNav.js';
+import { getScopedNavForPath } from './scopeNavToPath.js';
+const productVersionNav = {
+    products: [
+        {
+            product: 'Database',
+            versions: [
+                {
+                    version: 'v2',
+                    default: true,
+                    tabs: [
+                        {
+                            tab: 'Docs',
+                            groups: [
+                                {
+                                    group: 'Get started',
+                                    pages: [
+                                        { title: 'Intro', href: '/db/v2/intro' },
+                                        { title: 'Only in v2', href: '/db/v2/only' },
+                                    ],
+                                },
+                            ],
+                        },
+                        {
+                            tab: 'Reference',
+                            pages: [{ title: 'SQL v2', href: '/db/v2/sql' }],
+                        },
+                    ],
+                },
+                {
+                    version: 'v1',
+                    tabs: [
+                        {
+                            tab: 'Docs',
+                            groups: [
+                                {
+                                    group: 'Get started',
+                                    pages: [{ title: 'Intro', href: '/db/v1/intro' }],
+                                },
+                                {
+                                    group: 'Legacy',
+                                    pages: [{ title: 'Migrate', href: '/db/v1/migrate' }],
+                                },
+                            ],
+                        },
+                    ],
+                },
+            ],
+        },
+        {
+            product: 'Cloud',
+            languages: [
+                {
+                    language: 'en',
+                    default: true,
+                    tabs: [
+                        { tab: 'Guides', pages: [{ title: 'Cloud intro', href: '/cloud/en/intro' }] },
+                        { tab: 'API', pages: [{ title: 'Cloud API', href: '/cloud/en/api' }] },
+                    ],
+                },
+                {
+                    language: 'es',
+                    tabs: [{ tab: 'Guides', pages: [{ title: 'Cloud intro es', href: '/cloud/es/intro' }] }],
+                },
+            ],
+        },
+        {
+            product: 'Releases',
+            pages: [{ title: 'Notes', href: '/releases/notes' }],
+        },
+    ],
+};
+const sharedPathProductNav = {
+    products: [
+        {
+            product: 'Database',
+            versions: [
+                {
+                    version: 'v2',
+                    default: true,
+                    pages: [
+                        { title: 'Shared setup', href: '/shared/setup' },
+                        { title: 'Deploy v2', href: '/db/v2/deploy' },
+                    ],
+                },
+                {
+                    version: 'v1',
+                    pages: [
+                        { title: 'Shared setup', href: '/shared/setup' },
+                        { title: 'Migrate v1', href: '/db/v1/migrate' },
+                    ],
+                },
+            ],
+        },
+        {
+            product: 'Cloud',
+            pages: [
+                { title: 'Shared setup', href: '/shared/setup' },
+                { title: 'Cloud intro', href: '/cloud/intro' },
+            ],
+        },
+    ],
+};
+const nestedProductNav = {
+    languages: [
+        {
+            language: 'en',
+            default: true,
+            products: [
+                {
+                    product: 'Database',
+                    versions: [
+                        {
+                            version: 'v2',
+                            default: true,
+                            pages: [
+                                { title: 'Shared setup', href: '/en/shared/setup' },
+                                { title: 'Deploy v2', href: '/en/db/v2/deploy' },
+                            ],
+                        },
+                        {
+                            version: 'v1',
+                            pages: [
+                                { title: 'Shared setup', href: '/en/shared/setup' },
+                                { title: 'Migrate v1', href: '/en/db/v1/migrate' },
+                            ],
+                        },
+                    ],
+                },
+                {
+                    product: 'Cloud',
+                    pages: [
+                        { title: 'Shared setup', href: '/en/shared/setup' },
+                        { title: 'Cloud intro', href: '/en/cloud/intro' },
+                    ],
+                },
+            ],
+        },
+        {
+            language: 'es',
+            products: [
+                {
+                    product: 'Database',
+                    pages: [{ title: 'Intro es', href: '/es/db/intro' }],
+                },
+            ],
+        },
+    ],
+};
+function allProductNamesOf(nav) {
+    const names = new Set();
+    const walk = (node) => {
+        if (Array.isArray(node)) {
+            node.forEach(walk);
+        }
+        else if (node && typeof node === 'object') {
+            const record = node;
+            if (typeof record.product === 'string')
+                names.add(record.product);
+            Object.values(record).forEach(walk);
+        }
+    };
+    walk(nav);
+    return [...names];
+}
+function sessionProductsOf(nav) {
+    return [undefined, ...allProductNamesOf(nav)];
+}
+function filterWith(decoratedNav, currentPath, currentVersion, currentProduct) {
+    return filterDivisions({
+        currentPath,
+        decoratedNav,
+        userGroups: new Set(),
+        currentVersion,
+        currentLanguage: undefined,
+        currentProduct,
+        shouldUseDivisionMatch: true,
+        cache: { dropdownCache: new Map() },
+    });
+}
+function divisionSummary(result) {
+    return {
+        tabs: result.tabs.map(({ name, href, isActive }) => ({ name, href, isActive })),
+        anchors: result.anchors.map(({ name, href, isActive }) => ({ name, href, isActive })),
+        versions: result.versions.map(({ name, isActive }) => ({ name, isActive })),
+        languages: result.languages.map(({ name, isActive }) => ({ name, isActive })),
+        products: result.products.map(({ name, isActive }) => ({ name, isActive })),
+    };
+}
+function mapHrefs(map) {
+    return new Map([...map.entries()].map(([key, value]) => [key, value.href]));
+}
+function collectHrefs(node, hrefs = []) {
+    if (Array.isArray(node)) {
+        node.forEach((entry) => collectHrefs(entry, hrefs));
+    }
+    else if (node && typeof node === 'object') {
+        const record = node;
+        if (typeof record.href === 'string')
+            hrefs.push(record.href);
+        Object.values(record).forEach((value) => collectHrefs(value, hrefs));
+    }
+    return hrefs;
+}
+function productsContaining(nav, currentPath) {
+    const names = new Set();
+    const walk = (node) => {
+        if (Array.isArray(node)) {
+            node.forEach(walk);
+        }
+        else if (node && typeof node === 'object') {
+            const record = node;
+            if (typeof record.product === 'string' &&
+                collectHrefs(record).some((href) => isEqualIgnoringLeadingSlash(href, currentPath))) {
+                names.add(record.product);
+            }
+            Object.values(record).forEach(walk);
+        }
+    };
+    walk(nav);
+    return names.size;
+}
+function assertInvariantForEveryPathAndProduct(nav) {
+    const paths = getAllPathsInDecoratedNav(nav);
+    expect(paths.length).toBeGreaterThan(0);
+    for (const path of paths) {
+        const currentPath = `/${path.replace(/^\//, '')}`;
+        const scoped = getScopedNavForPath({ decoratedNav: nav, currentPath });
+        const ambiguous = productsContaining(nav, currentPath) > 1;
+        for (const sessionProduct of sessionProductsOf(nav)) {
+            const label = `${currentPath} (product: ${sessionProduct})`;
+            const full = filterWith(nav, currentPath, scoped.currentVersion, sessionProduct);
+            const rescoped = filterWith(scoped.scopedNav, currentPath, scoped.currentVersion, sessionProduct);
+            expect(rescoped.groupsOrPages, label).toEqual(full.groupsOrPages);
+            expect(divisionSummary(rescoped), label).toEqual(divisionSummary(full));
+            expect(mapHrefs(rescoped.firstHrefInVersion), label).toEqual(mapHrefs(full.firstHrefInVersion));
+            expect(mapHrefs(rescoped.firstHrefInLanguage), label).toEqual(mapHrefs(full.firstHrefInLanguage));
+            expect(mapHrefs(scoped.firstHrefInVersion), label).toEqual(ambiguous ? new Map() : mapHrefs(full.firstHrefInVersion));
+            expect(mapHrefs(scoped.firstHrefInLanguage), label).toEqual(ambiguous ? new Map() : mapHrefs(full.firstHrefInLanguage));
+        }
+    }
+}
+describe('scoped nav on product navigations', () => {
+    it('filters identically for every path and session product in a product+version nav', () => {
+        assertInvariantForEveryPathAndProduct(productVersionNav);
+    });
+    it('filters identically when the same path lives in multiple products', () => {
+        assertInvariantForEveryPathAndProduct(sharedPathProductNav);
+    });
+    it('filters identically for products nested under languages', () => {
+        assertInvariantForEveryPathAndProduct(nestedProductNav);
+    });
+    it('handles ambiguity for products nested under languages', () => {
+        const scoped = getScopedNavForPath({
+            decoratedNav: nestedProductNav,
+            currentPath: '/en/shared/setup',
+        });
+        expect(scoped.firstHrefInVersion.size).toBe(0);
+        const serialized = JSON.stringify(scoped.scopedNav);
+        expect(serialized).toContain('/en/db/v1/migrate');
+        expect(serialized).toContain('/en/db/v2/deploy');
+    });
+    it('keeps version divisions whole on product-ambiguous paths instead of baking stubs', () => {
+        const scoped = getScopedNavForPath({
+            decoratedNav: sharedPathProductNav,
+            currentPath: '/shared/setup',
+        });
+        expect(scoped.firstHrefInVersion.size).toBe(0);
+        const serialized = JSON.stringify(scoped.scopedNav);
+        expect(serialized).toContain('/db/v1/migrate');
+        expect(serialized).toContain('/db/v2/deploy');
+    });
+    it('bakes equivalent-page targets into off-path version stubs inside a product', () => {
+        var _a;
+        const scoped = getScopedNavForPath({
+            decoratedNav: productVersionNav,
+            currentPath: '/db/v2/intro',
+        });
+        expect(scoped.currentVersion).toBe('v2');
+        expect((_a = scoped.firstHrefInVersion.get('v1')) === null || _a === void 0 ? void 0 : _a.href).toBe('/db/v1/intro');
+        const serialized = JSON.stringify(scoped.scopedNav);
+        expect(serialized).not.toContain('/db/v1/migrate');
+        expect(serialized).toContain('/cloud/en/intro');
+    });
+});

package/dist/navigation/updateFirstHrefInDivision.d.ts

@@ -0,0 +1,29 @@
+import { DecoratedNavigationConfig, DecoratedPageOrGroupConfig, DecoratedGroupConfig } from '@mintlify/validation';
+import { NavigationDivisions } from './filterDivisions.js';
+export declare enum DivisionMatchLevel {
+    EXACT = 0,
+    PATH = 1,
+    GROUP = 2,
+    DIVISION = 3,
+    NONE = 4
+}
+export type DivisionMatch = {
+    href: string;
+    matchLevel: DivisionMatchLevel;
+};
+export declare function updateFirstHrefInDivision({ type, currentPath, entry, parentGroups, nearestDivisionValue, isActiveGroup, inActiveDivision, currentDivisionValue, allDivisionValues, firstHrefInDivision, navigationDivisions, isHiddenPage, activeGroupNames, }: {
+    type: 'version' | 'language';
+    currentPath: string;
+    entry: DecoratedNavigationConfig | DecoratedPageOrGroupConfig;
+    parentGroups: DecoratedGroupConfig[];
+    nearestDivisionValue: string | undefined;
+    isActiveGroup: boolean;
+    inActiveDivision: boolean;
+    currentDivisionValue: string | undefined;
+    allDivisionValues: string[] | undefined;
+    firstHrefInDivision: Map<string | undefined, DivisionMatch>;
+    navigationDivisions: NavigationDivisions;
+    isHiddenPage: boolean;
+    activeGroupNames?: Set<string>;
+}): void;
+export declare function pathsDifferByOneSegment(a: string, b: string, type: 'version' | 'language'): boolean;