@mintlify/common 1.0.1331 → 1.0.1332

package/dist/mdx/plugins/remark/remarkVisibilityForMarkdown.js

@@ -1,7 +1,7 @@
 import { getAST, stringifyTree } from '../../remark-core.js';
 import { BLOCK_LINK_LABEL, BLOCK_MARKERS } from './firstPartyMarkdownComponents.js';
 import { evaluateStatic } from './staticEvaluator.js';
-import { chargeUnfoldBudget, chargeUnfoldCall, collectMarkdownComponentContext, collectUsageProps, containsJsx, createUnfoldBudget, definitionGatesContent, DROP_ELEMENTS, FORM_CONTROL_ELEMENTS, dropPairedDarkOnly, escapeInterpolatedText, HEADING_ELEMENTS, isPresentationalAttribute, UNWRAP_BLOCK_ELEMENTS, UNWRAP_INLINE_ELEMENTS, escapeLinkLabel, extractProgramExpression, FAILED_SPREAD, markdownLinkDestination, MAX_UNFOLD_DEPTH, GFM_ALERT_PATTERN, HEADLINE_ATTRIBUTES, KEEP_TAG_COMPONENTS, materializeComponent, serializeExpressionJsx, } from './unfoldComponentsForMarkdown.js';
+import { chargeUnfoldBudget, chargeUnfoldCall, collectMarkdownComponentContext, collectUsageProps, containsJsx, createUnfoldBudget, definitionGatesContent, DROP_ELEMENTS, FORM_CONTROL_ELEMENTS, dropPairedDarkOnly, escapeInterpolatedText, HEADING_ELEMENTS, isPresentationalAttribute, UNWRAP_BLOCK_ELEMENTS, UNWRAP_INLINE_ELEMENTS, escapeLinkLabel, extractProgramExpression, FAILED_SPREAD, fillJsxPropSlots, markdownLinkDestination, MAX_UNFOLD_DEPTH, GFM_ALERT_PATTERN, HEADLINE_ATTRIBUTES, KEEP_TAG_COMPONENTS, materializeComponent, serializeExpressionJsx, slotJsxUsageProps, } from './unfoldComponentsForMarkdown.js';
 import { toVisibilityGroups, toVisibilityGroupsRule, } from './visibility-auth-rule.js';
 export function isVisibilityElement(node) {
     return ((node.type === 'mdxJsxFlowElement' || node.type === 'mdxJsxTextElement') &&
@@ -401,17 +401,22 @@ function unfoldUsage(node, name, ctx) {
         props.delete('children');
         failedProps.delete('children');
     }
+    const slots = slotJsxUsageProps(node, ctx, props, failedProps);
     const trustedFailed = new Set();
     const trustedProps = collectUsageProps(node, Object.assign(Object.assign({}, ctx), { moduleScope: ctx.literalScope }), trustedFailed);
     if (bodyChildren.length > 0)
         trustedProps.delete('children');
-    const markdown = materializeComponent(def, name, props, childrenMarkdown, ctx, failedProps, bodyExpressionValue(bodyChildren, ctx), { props: trustedProps, failedProps: trustedFailed });
-    if (markdown === undefined) {
+    const materialized = materializeComponent(def, name, props, childrenMarkdown, ctx, failedProps, bodyExpressionValue(bodyChildren, ctx), { props: trustedProps, failedProps: trustedFailed });
+    if (materialized === undefined) {
         if (definitionGatesContent(def, ctx.defs))
             return [];
         // Same fallback as inside definitions: headline and description props still render
         return ((_a = unfoldForeignUsage(node, name, ctx, transformedChildren)) !== null && _a !== void 0 ? _a : wrapPhrasingRuns(transformedChildren));
     }
+    const markdown = fillJsxPropSlots(materialized, slots, ctx.budget);
+    if (markdown === undefined) {
+        return definitionGatesContent(def, ctx.defs) ? [] : wrapPhrasingRuns(transformedChildren);
+    }
     if (markdown.trim() === '')
         return [];
     if (!chargeUnfoldBudget(ctx, markdown.length)) {

package/dist/mdx/plugins/remark/unfoldComponentsForMarkdown.d.ts

@@ -59,6 +59,9 @@ export declare function escapeInterpolatedText(value: string): string;
 export declare function markdownLinkDestination(url: string): string;
 /** Escapes brackets outside code spans and images, so a label cannot end its link early. */
 export declare function escapeLinkLabel(text: string): string;
+export type JsxPropSlots = Map<string, string>;
+export declare function slotJsxUsageProps(node: MdxUsageElement, ctx: UnfoldContext, props: StaticScope, failed: Set<string>): JsxPropSlots;
+export declare function fillJsxPropSlots(markdown: string, slots: JsxPropSlots, budget: UnfoldBudget): string | undefined;
 export declare function materializeComponent(def: ComponentDef, name: string, props: StaticScope, childrenMarkdown: string, ctx: UnfoldContext, failedProps?: ReadonlySet<string>, bodyValue?: {
     value: StaticValue;
 }, trusted?: TrustedProps): string | undefined;

package/dist/mdx/plugins/remark/unfoldComponentsForMarkdown.js

@@ -1029,6 +1029,7 @@ function serializeComponentElement(node, name, ctx) {
         if (withinLimits) {
             const failedProps = new Set();
             const props = collectStaticProps(node, ctx, failedProps);
+            const slots = slotJsxStaticProps(node, ctx, props, failedProps);
             let childrenMarkdown = serializeJsxChildren(node.children, ctx).trim();
             let bodyValue;
             // Body children replace any children attribute or spread, even when they render nothing
@@ -1043,9 +1044,10 @@ function serializeComponentElement(node, name, ctx) {
             }
             const trustedFailed = new Set();
             const trustedProps = collectStaticProps(node, Object.assign(Object.assign({}, ctx), trustedEnv(ctx)), trustedFailed);
-            const markdown = materializeComponent(def, name, props, childrenMarkdown, ctx, failedProps, bodyValue, { props: trustedProps, failedProps: trustedFailed });
-            if (markdown !== undefined) {
-                if (chargeUnfoldBudget(ctx, markdown.length))
+            const materialized = materializeComponent(def, name, props, childrenMarkdown, ctx, failedProps, bodyValue, { props: trustedProps, failedProps: trustedFailed });
+            if (materialized !== undefined) {
+                const markdown = fillJsxPropSlots(materialized, slots, ctx.budget);
+                if (markdown !== undefined && chargeUnfoldBudget(ctx, markdown.length))
                     return markdown;
                 return definitionGatesContent(def, ctx.defs) ? '' : childrenMarkdown;
             }
@@ -1060,6 +1062,72 @@ function setKnownProp(props, failed, name, value) {
     if (name !== FAILED_SPREAD)
         failed === null || failed === void 0 ? void 0 : failed.delete(name);
 }
+let nextJsxPropSlot = 0;
+function jsxValueExpression(expression) {
+    let value = expression;
+    while (isObject(value) &&
+        typeof value.type === 'string' &&
+        TRANSPARENT_WRAPPERS.has(value.type)) {
+        value = value.expression;
+    }
+    return isObject(value) && (value.type === 'JSXElement' || value.type === 'JSXFragment')
+        ? value
+        : undefined;
+}
+function slotJsxProp(props, failed, name, markdown, slots) {
+    const placeholder = `\uE000${nextJsxPropSlot++}\uE000`;
+    slots.set(placeholder, markdown);
+    setKnownProp(props, failed, name, placeholder);
+}
+export function slotJsxUsageProps(node, ctx, props, failed) {
+    var _a;
+    const slots = new Map();
+    for (const attribute of node.attributes) {
+        if (attribute.type !== 'mdxJsxAttribute' || !failed.has(attribute.name))
+            continue;
+        if (attribute.value === null || typeof attribute.value !== 'object')
+            continue;
+        const expression = jsxValueExpression(extractProgramExpression((_a = attribute.value.data) === null || _a === void 0 ? void 0 : _a.estree));
+        if (expression === undefined)
+            continue;
+        const markdown = serializeExpressionJsx(expression, ctx);
+        if (markdown !== undefined)
+            slotJsxProp(props, failed, attribute.name, markdown.trim(), slots);
+    }
+    return slots;
+}
+function slotJsxStaticProps(node, ctx, props, failed) {
+    const slots = new Map();
+    for (const attribute of jsxAttributes(node)) {
+        if (attribute.type !== 'JSXAttribute')
+            continue;
+        const attrName = attribute.name;
+        if (!isObject(attrName) || typeof attrName.name !== 'string')
+            continue;
+        if (!failed.has(attrName.name))
+            continue;
+        const value = attribute.value;
+        const expression = jsxValueExpression(nodeType(value) === 'JSXExpressionContainer' && isObject(value) ? value.expression : value);
+        if (expression === undefined)
+            continue;
+        const markdown = serializeJsxExpression(expression, ctx).trim();
+        slotJsxProp(props, failed, attrName.name, markdown, slots);
+    }
+    return slots;
+}
+export function fillJsxPropSlots(markdown, slots, budget) {
+    let filledLength = markdown.length;
+    for (const [placeholder, value] of slots) {
+        const occurrences = markdown.split(placeholder).length - 1;
+        filledLength += occurrences * (value.length - placeholder.length);
+    }
+    if (filledLength > budget.remainingBytes)
+        return undefined;
+    let filled = markdown;
+    for (const [placeholder, value] of slots)
+        filled = filled.replaceAll(placeholder, () => value);
+    return filled;
+}
 function setFailedProp(props, failed, name) {
     props.delete(name);
     failed === null || failed === void 0 ? void 0 : failed.add(name);

package/dist/navigation/getVersionOrLanguageFromPath.js

@@ -18,6 +18,7 @@ export function getVersionOrLanguageFromPath(type, entry, path, defaultValue, in
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- TODO: Please fix this violation when you can!
     return (result || backupResult);
 }
+const CHILD_KEYS = [...divisions, 'groups', 'pages'];
 function getDivisionFromPathHelper(type, entry, parentEntry, path, defaultValue, nearestDivisionValue) {
     var _a, _b;
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- TODO: Please fix this violation when you can!
@@ -26,10 +27,9 @@ function getDivisionFromPathHelper(type, entry, parentEntry, path, defaultValue,
         return undefinedResult;
     if (isPage(entry)) {
         if (isEqualIgnoringLeadingSlash(entry.href, path)) {
-            const isCommon = isCommonPage(parentEntry, path);
             // logic: if this pages was shared in multiple divisions, we should use the default one,
             // if the page was not shared and only used in one division, we should use the nearest division
-            if (isCommon && defaultValue && defaultValue !== nearestDivisionValue)
+            if (defaultValue && defaultValue !== nearestDivisionValue && isCommonPage(parentEntry, path))
                 return undefinedResult;
             // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- TODO: Please fix this violation when you can!
             return (type === 'version' ? ((_a = entry.version) !== null && _a !== void 0 ? _a : nearestDivisionValue) : nearestDivisionValue);
@@ -38,7 +38,7 @@ function getDivisionFromPathHelper(type, entry, parentEntry, path, defaultValue,
             return undefinedResult;
         }
     }
-    for (const key of [...divisions, 'groups', 'pages']) {
+    for (const key of CHILD_KEYS) {
         let subDivisions = (_b = readObjectArrayProperty(entry, key)) !== null && _b !== void 0 ? _b : [];
         if (key === 'pages' && 'root' in entry && typeof entry.root === 'object') {
             // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- root is a DecoratedNavigationPage

package/dist/navigation/pathsDifferByOneSegment.test.js

@@ -157,3 +157,16 @@ describe('pathsDifferByOneSegment configured languages', () => {
         expect(pathsDifferByOneSegment('/tlh/guide', '/guide', 'language', languages)).toBe(true);
     });
 });
+describe('pathsDifferByOneSegment when the target ends in a locale or index segment', () => {
+    it('matches language variants whose last segment differs', () => {
+        expect(pathsDifferByOneSegment('/guide/fr', '/guide/ja', 'language')).toBe(true);
+        expect(pathsDifferByOneSegment('/fr', '/ja', 'language')).toBe(true);
+        expect(pathsDifferByOneSegment('/guide', '/guide/ja', 'language')).toBe(true);
+        expect(pathsDifferByOneSegment('/guide/ja', '/guide', 'language')).toBe(true);
+        expect(pathsDifferByOneSegment('/fr/guide/index', '/ja/guide', 'language')).toBe(true);
+    });
+    it('matches version variants ending in index', () => {
+        expect(pathsDifferByOneSegment('/v1/guide/index', '/v2/guide/index', 'version')).toBe(true);
+        expect(pathsDifferByOneSegment('/v1/guide', '/v2/other', 'version')).toBe(false);
+    });
+});

package/dist/navigation/scopeNavToPath.js

@@ -13,7 +13,7 @@ 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';
+import { isEqualIgnoringLeadingSlash, normalizeComparablePath, } from '../paths/isEqualIgnoringLeadingSlash.js';
 import { filterDivisions } from './filterDivisions.js';
 import { getFirstPageFromNavigation } from './getFirstPageFromNavigation.js';
 import { getVersionOrLanguageFromPath } from './getVersionOrLanguageFromPath.js';
@@ -125,10 +125,29 @@ function collectPageCandidates(node, candidates, inHiddenSubtree = false) {
         }
     }
 }
+function containsComparablePath(node, path) {
+    if (Array.isArray(node))
+        return node.some((entry) => containsComparablePath(entry, path));
+    if (!isNavNode(node))
+        return false;
+    if (isDecoratedPageNode(node))
+        return normalizeComparablePath(node.href) === path;
+    for (const [key, value] of Object.entries(node)) {
+        if (key === 'pages' && Array.isArray(value)) {
+            const found = value.some((entry) => typeof entry === 'string'
+                ? normalizeComparablePath(entry) === path
+                : containsComparablePath(entry, path));
+            if (found)
+                return true;
+        }
+        else if ((Array.isArray(value) || isNavNode(value)) && containsComparablePath(value, path)) {
+            return true;
+        }
+    }
+    return false;
+}
 function divisionContainsPath(division, currentPath) {
-    const candidates = [];
-    collectPageCandidates(division, candidates);
-    return candidates.some((candidate) => isEqualIgnoringLeadingSlash(candidate.href, currentPath));
+    return containsComparablePath(division, normalizeComparablePath(currentPath));
 }
 function collectContainingProductNames(node, currentPath, names) {
     if (Array.isArray(node)) {
@@ -261,6 +280,15 @@ function containsDivision(node, keys) {
 const containsStatefulDivision = (node) => containsDivision(node, STATEFUL_DIVISION_KEYS);
 const PRODUCT_KEYS = new Set(['products']);
 const containsProducts = (node) => containsDivision(node, PRODUCT_KEYS);
+const navHasProductsCache = new WeakMap();
+function navHasProducts(nav) {
+    const cached = navHasProductsCache.get(nav);
+    if (cached !== undefined)
+        return cached;
+    const result = containsProducts(nav);
+    navHasProductsCache.set(nav, result);
+    return result;
+}
 // mirrors buildDivisionItem's anonymous href resolution (first page in
 // getFirstPageFromNavigation order that is neither hidden nor group-gated);
 // falls back to the first raw candidate so a division with no anonymously
@@ -575,13 +603,39 @@ function cachedPathToLanguageDict(decoratedNav) {
     pathToLanguageDictCache.set(decoratedNav, dict);
     return dict;
 }
+const comparableHrefsCache = new WeakMap();
+function addComparableHrefs(node, hrefs) {
+    if (Array.isArray(node)) {
+        for (const entry of node)
+            addComparableHrefs(entry, hrefs);
+        return;
+    }
+    if (!isNavNode(node))
+        return;
+    if (typeof node.href === 'string')
+        hrefs.add(normalizeComparablePath(node.href));
+    for (const value of Object.values(node))
+        addComparableHrefs(value, hrefs);
+}
+function comparableHrefs(nav) {
+    const cached = comparableHrefsCache.get(nav);
+    if (cached)
+        return cached;
+    const hrefs = new Set();
+    addComparableHrefs(nav, hrefs);
+    comparableHrefsCache.set(nav, hrefs);
+    return hrefs;
+}
+const EMPTY_NAV = { pages: [] };
 export function getScopedNavForPath({ decoratedNav, currentPath, userGroups = new Set(), isPreview = false, includeProductVersionMetadata = false, }) {
     var _a, _b, _c, _d;
     var _e, _f, _g;
     const containingProductNames = new Set();
-    collectContainingProductNames(
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- structural nav traversal over the zod union types
-    decoratedNav, currentPath, containingProductNames);
+    if (navHasProducts(decoratedNav)) {
+        collectContainingProductNames(
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- structural nav traversal over the zod union types
+        decoratedNav, currentPath, containingProductNames);
+    }
     const soleProductName = containingProductNames.size === 1 ? [...containingProductNames][0] : undefined;
     const currentProduct = typeof soleProductName === 'string' ? soleProductName : undefined;
     const productAmbiguous = containingProductNames.size > 1;
@@ -606,11 +660,14 @@ export function getScopedNavForPath({ decoratedNav, currentPath, userGroups = ne
         const dictVersion = cachedPathToVersionDict(decoratedNav).get(strippedPath);
         const dictLanguage = cachedPathToLanguageDict(decoratedNav).get(strippedPath);
         const localeFromDict = dictLanguage && isLocale(dictLanguage) ? dictLanguage : undefined;
+        const lookupNav = comparableHrefs(decoratedNav).has(normalizeComparablePath(currentPath))
+            ? decoratedNav
+            : EMPTY_NAV;
         currentVersion =
             dictVersion ||
-                getVersionOrLanguageFromPath('version', decoratedNav, currentPath, defaultVersion, (_e = (_c = initial.versions[0]) === null || _c === void 0 ? void 0 : _c.name) !== null && _e !== void 0 ? _e : '') ||
+                getVersionOrLanguageFromPath('version', lookupNav, currentPath, defaultVersion, (_e = (_c = initial.versions[0]) === null || _c === void 0 ? void 0 : _c.name) !== null && _e !== void 0 ? _e : '') ||
                 undefined;
-        currentLanguage = (_g = localeFromDict !== null && localeFromDict !== void 0 ? localeFromDict : getVersionOrLanguageFromPath('language', decoratedNav, currentPath, defaultLanguage, (_f = (_d = initial.languages[0]) === null || _d === void 0 ? void 0 : _d.language) !== null && _f !== void 0 ? _f : undefined)) !== null && _g !== void 0 ? _g : undefined;
+        currentLanguage = (_g = localeFromDict !== null && localeFromDict !== void 0 ? localeFromDict : getVersionOrLanguageFromPath('language', lookupNav, currentPath, defaultLanguage, (_f = (_d = initial.languages[0]) === null || _d === void 0 ? void 0 : _d.language) !== null && _f !== void 0 ? _f : undefined)) !== null && _g !== void 0 ? _g : undefined;
     }
     const filtered = filterDivisions({
         currentPath,

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

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