@mintlify/common 1.0.1032 → 1.0.1034

package/dist/mdx/plugins/rehype/rehypeParamFieldIds.js

@@ -4,31 +4,59 @@ export function generateParamFieldId(name, count) {
     const suffix = count > 0 ? `_${count}` : '';
     return slugify(`param-${name}${suffix}`, { decamelize: true, separator: '-' });
 }
+const PARAM_FIELD_COMPONENTS = ['ParamField', 'Param', 'ResponseField'];
+const PARAM_NAME_PRECEDENCE = ['query', 'path', 'body', 'header'];
+const getStringAttribute = (element, attrName) => {
+    const attr = element.attributes.find((attr) => 'name' in attr && attr.name === attrName);
+    return attr && typeof attr.value === 'string' && attr.value ? attr.value : undefined;
+};
+const hasIdAttribute = (element) => element.attributes.some((attr) => 'name' in attr && attr.name === 'id');
+const getFieldName = (element) => {
+    if (element.name === 'ResponseField')
+        return getStringAttribute(element, 'name');
+    for (const attrName of PARAM_NAME_PRECEDENCE) {
+        const value = getStringAttribute(element, attrName);
+        if (value)
+            return value;
+    }
+    return undefined;
+};
 export const rehypeParamFieldIds = () => {
     return (tree) => {
-        const paramCounts = new Map();
+        const claimedIds = new Set();
+        const slugCounts = new Map();
+        visit(tree, 'mdxJsxFlowElement', (element) => {
+            if (!element.name || !PARAM_FIELD_COMPONENTS.includes(element.name))
+                return;
+            if (!hasIdAttribute(element))
+                return;
+            const explicitId = getStringAttribute(element, 'id');
+            if (explicitId)
+                claimedIds.add(explicitId);
+        });
         visit(tree, 'mdxJsxFlowElement', (element) => {
             var _a;
-            if (element.name === 'ParamField' ||
-                element.name === 'Param' ||
-                element.name === 'ResponseField') {
-                const nameAttr = element.attributes.find((attr) => 'name' in attr &&
-                    (attr.name === 'query' ||
-                        attr.name === 'path' ||
-                        attr.name === 'body' ||
-                        attr.name === 'header' ||
-                        attr.name === 'name'));
-                if (nameAttr && typeof nameAttr.value === 'string' && nameAttr.value) {
-                    const currentCount = (_a = paramCounts.get(nameAttr.value)) !== null && _a !== void 0 ? _a : 0;
-                    paramCounts.set(nameAttr.value, currentCount + 1);
-                    const id = generateParamFieldId(nameAttr.value, currentCount);
-                    element.attributes.push({
-                        type: 'mdxJsxAttribute',
-                        name: 'id',
-                        value: id,
-                    });
-                }
+            if (!element.name || !PARAM_FIELD_COMPONENTS.includes(element.name))
+                return;
+            if (hasIdAttribute(element))
+                return;
+            const name = getFieldName(element);
+            if (!name)
+                return;
+            const baseSlug = generateParamFieldId(name, 0);
+            let count = (_a = slugCounts.get(baseSlug)) !== null && _a !== void 0 ? _a : 0;
+            let id = generateParamFieldId(name, count);
+            while (claimedIds.has(id)) {
+                count += 1;
+                id = generateParamFieldId(name, count);
             }
+            slugCounts.set(baseSlug, count + 1);
+            claimedIds.add(id);
+            element.attributes.push({
+                type: 'mdxJsxAttribute',
+                name: 'id',
+                value: id,
+            });
         });
         return tree;
     };

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

@@ -93,31 +93,31 @@ export const remarkComponentIds = (pageMetadata) => (tree) => {
     const processTabsRecursively = (node) => {
         if (node.type === 'mdxJsxFlowElement' && node.name === 'Tab') {
             const slug = tabSlugs.get(node);
-            if (!slug)
-                return;
-            // `slug` already equals the explicit `id` when one was provided, so only
-            // add the attribute when the Tab doesn't already have one.
-            const hasId = node.attributes.some((attr) => 'name' in attr && attr.name === 'id');
-            if (!hasId) {
-                node.attributes.push(createMdxJsxAttribute('id', slug));
-            }
-            const childTabIds = [];
-            for (const child of node.children) {
-                const childIds = collectDirectChildIds(child, 'Tab');
-                childTabIds.push(...childIds);
-            }
-            if (childTabIds.length > 0) {
-                try {
-                    node.attributes.push(createMdxJsxAttribute(CHILD_TAB_IDS_ATTRIBUTE, JSON.stringify(childTabIds)));
+            if (slug) {
+                // `slug` already equals the explicit `id` when one was provided, so only
+                // add the attribute when the Tab doesn't already have one.
+                const hasId = node.attributes.some((attr) => 'name' in attr && attr.name === 'id');
+                if (!hasId) {
+                    node.attributes.push(createMdxJsxAttribute('id', slug));
                 }
-                catch (_a) { }
-            }
-            const childHeadingIds = collectDirectChildIds(node, 'Heading');
-            if (childHeadingIds.length > 0) {
-                try {
-                    node.attributes.push(createMdxJsxAttribute(CHILD_HEADING_IDS_ATTRIBUTE, JSON.stringify(childHeadingIds)));
+                const childTabIds = [];
+                for (const child of node.children) {
+                    const childIds = collectDirectChildIds(child, 'Tab');
+                    childTabIds.push(...childIds);
+                }
+                if (childTabIds.length > 0) {
+                    try {
+                        node.attributes.push(createMdxJsxAttribute(CHILD_TAB_IDS_ATTRIBUTE, JSON.stringify(childTabIds)));
+                    }
+                    catch (_a) { }
+                }
+                const childHeadingIds = collectDirectChildIds(node, 'Heading');
+                if (childHeadingIds.length > 0) {
+                    try {
+                        node.attributes.push(createMdxJsxAttribute(CHILD_HEADING_IDS_ATTRIBUTE, JSON.stringify(childHeadingIds)));
+                    }
+                    catch (_b) { }
                 }
-                catch (_b) { }
             }
             for (const child of node.children) {
                 processTabsRecursively(child);

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

@@ -21,11 +21,20 @@ export function remarkExtractChangelogFilters(mdxExtracts) {
             if (!Array.isArray(tags)) {
                 continue;
             }
-            tags.forEach((tag) => {
-                if (!!tag.trim()) {
-                    tagCounts.set(tag, (tagCounts.get(tag) || 0) + 1);
+            const nodeTags = new Set();
+            for (const tag of tags) {
+                if (typeof tag !== 'string') {
+                    console.warn(`Invalid tag ${JSON.stringify(tag)} in <Update> tags — tags must be strings. Skipping it.`);
+                    continue;
                 }
-            });
+                const trimmed = tag.trim();
+                if (trimmed) {
+                    nodeTags.add(trimmed);
+                }
+            }
+            for (const tag of nodeTags) {
+                tagCounts.set(tag, (tagCounts.get(tag) || 0) + 1);
+            }
         }
         const filters = Array.from(tagCounts.entries())
             .map(([tag, count]) => ({

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

@@ -28,9 +28,13 @@ export const remarkExtractTableOfContents = (mdxExtracts, pageMetadata) => {
         seenSlugs.set(slug, count + 1);
         if (count === 0)
             return slug;
-        const suffixed = `${slug}-${count + 1}`;
-        if (!seenSlugs.has(suffixed))
-            seenSlugs.set(suffixed, 0);
+        let suffix = count + 1;
+        let suffixed = `${slug}-${suffix}`;
+        while (seenSlugs.has(suffixed)) {
+            suffix += 1;
+            suffixed = `${slug}-${suffix}`;
+        }
+        seenSlugs.set(suffixed, 1);
         return suffixed;
     };
     return (tree) => {

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

@@ -1,36 +1,107 @@
 import remarkStringify from 'remark-stringify';
 import { unified } from 'unified';
-import { visit } from 'unist-util-visit';
+import { SKIP, visit } from 'unist-util-visit';
 import { coreRemarkMdxPlugins } from '../../remark.js';
+const COMMENT_ONLY = /^\s*(?:\/\*[\s\S]*?\*\/\s*)*$/;
 export const remarkMdxExtractPanel = (mdxExtracts) => {
     return (tree) => {
         let esmContent = '';
         let panelContent;
+        const sanitizeNode = (node) => {
+            const sanitized = Object.assign({}, node);
+            if ('attributes' in sanitized && Array.isArray(sanitized.attributes)) {
+                sanitized.attributes = sanitized.attributes.map((attr) => {
+                    if (attr.type === 'mdxJsxAttribute' && typeof attr.value === 'number') {
+                        const value = {
+                            type: 'mdxJsxAttributeValueExpression',
+                            value: String(attr.value),
+                        };
+                        return Object.assign(Object.assign({}, attr), { value });
+                    }
+                    return attr;
+                });
+            }
+            if ('children' in sanitized && Array.isArray(sanitized.children)) {
+                sanitized.children = sanitized.children.map(sanitizeNode);
+            }
+            return sanitized;
+        };
         const stringifyNode = (node) => {
             try {
-                return unified().use(coreRemarkMdxPlugins).use(remarkStringify).stringify(node);
+                return unified()
+                    .use(coreRemarkMdxPlugins)
+                    .use(remarkStringify)
+                    .stringify(sanitizeNode(node));
             }
             catch (error) {
                 console.error('Error converting MDX content to markdown:', error);
-                return '';
+                return null;
             }
         };
+        const isBlankNode = (node) => {
+            if (node.type === 'text')
+                return node.value.trim() === '';
+            if (node.type === 'mdxFlowExpression' || node.type === 'mdxTextExpression') {
+                return COMMENT_ONLY.test(node.value);
+            }
+            return false;
+        };
+        const isEmptyExtract = (children) => children.every(isBlankNode);
+        const isPanelElement = (node) => node.type === 'mdxJsxFlowElement' && node.name === 'Panel';
+        // The extracted content is recompiled through this same pipeline, so any
+        // nested <Panel> markup left in it would be stripped on the second pass and
+        // its body lost. Flatten every nested Panel into its own children (and warn)
+        // so the extract carries no Panel markup and the content renders inline.
+        let nestedPanelFlattened = false;
+        const unwrapNestedPanels = (children) => children.flatMap((child) => {
+            if (isPanelElement(child)) {
+                nestedPanelFlattened = true;
+                return unwrapNestedPanels(child.children);
+            }
+            if ('children' in child && Array.isArray(child.children)) {
+                const container = child;
+                return [
+                    Object.assign(Object.assign({}, container), { children: unwrapNestedPanels(container.children) }),
+                ];
+            }
+            return [child];
+        });
         visit(tree, 'mdxjsEsm', (node) => {
-            esmContent += stringifyNode({
-                type: 'root',
-                children: [node],
-            });
+            const stringified = stringifyNode({ type: 'root', children: [node] });
+            if (stringified)
+                esmContent += stringified;
         });
+        let canonicalHandled = false;
         visit(tree, 'mdxJsxFlowElement', (node, i, parent) => {
-            if (node.name === 'Panel') {
-                panelContent = stringifyNode({
-                    type: 'root',
-                    children: node.children,
-                });
+            if (node.name !== 'Panel')
+                return;
+            const removeSelf = () => {
                 if (parent && i != null) {
                     parent.children.splice(i, 1);
+                    return [SKIP, i];
                 }
+                return SKIP;
+            };
+            if (canonicalHandled) {
+                console.warn('Only one <Panel> is supported per page — the extra <Panel> was removed. Move its content into the single panel.');
+                return removeSelf();
+            }
+            // An empty or comment-only Panel contributes no side panel, so it must not
+            // claim the single canonical slot — remove it and let a later non-empty
+            // Panel become the page's panel.
+            if (isEmptyExtract(node.children)) {
+                return removeSelf();
+            }
+            const content = stringifyNode({ type: 'root', children: unwrapNestedPanels(node.children) });
+            if (content == null) {
+                return SKIP;
+            }
+            if (nestedPanelFlattened) {
+                console.warn('A nested <Panel> was flattened into the page panel — <Panel> components cannot be nested.');
             }
+            canonicalHandled = true;
+            panelContent = content;
+            return removeSelf();
         });
         if (esmContent || panelContent) {
             const content = [esmContent, panelContent].filter((content) => !!content).join('\n');

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

@@ -1,4 +1,12 @@
 import { visit } from 'unist-util-visit';
+import { isMdxJsxFlowElement } from '../../utils.js';
+const countTabs = (children) => children.reduce((count, child) => {
+    if (!isMdxJsxFlowElement(child))
+        return count;
+    if (child.name == null)
+        return count + countTabs(child.children);
+    return child.name === 'Tab' ? count + 1 : count;
+}, 0);
 export const remarkSplitTabs = () => (tree) => {
     const tabsToProcess = [];
     visit(tree, 'mdxJsxFlowElement', (node, index, parent) => {
@@ -9,7 +17,7 @@ export const remarkSplitTabs = () => (tree) => {
     // process in reverse document order so splices don't shift the saved
     // indices of earlier siblings or clone-before-split nested Tabs
     for (const { node, index, parent } of tabsToProcess.reverse()) {
-        const numberOfTabs = node.children.length;
+        const numberOfTabs = countTabs(node.children);
         if (numberOfTabs <= 1)
             continue;
         const newNodes = [];

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

@@ -1,11 +1,19 @@
-import { visit } from 'unist-util-visit';
+import { visitParents } from 'unist-util-visit-parents';
+import { isMdxJsxFlowElement, isMdxJsxFragment } from '../../utils.js';
 export const remarkValidateTabs = () => (tree) => {
-    visit(tree, 'mdxJsxFlowElement', (node, _idx, parent) => {
-        if (node.name === 'Tab') {
-            const parentElement = parent;
-            if (!parentElement || parentElement.name !== 'Tabs') {
-                console.warn('Please ensure that all <Tab> components are direct children of <Tabs>.');
-            }
+    visitParents(tree, 'mdxJsxFlowElement', (node, ancestors) => {
+        var _a;
+        if (node.name !== 'Tab')
+            return;
+        const meaningfulAncestors = ancestors.filter((ancestor) => !isMdxJsxFragment(ancestor));
+        const parent = meaningfulAncestors[meaningfulAncestors.length - 1];
+        const parentIsTabs = parent !== undefined && isMdxJsxFlowElement(parent) && parent.name === 'Tabs';
+        if (!parentIsTabs) {
+            console.warn('Please ensure that all <Tab> components are direct children of <Tabs>.');
+        }
+        const title = (_a = node.attributes.find((attr) => 'name' in attr && attr.name === 'title')) === null || _a === void 0 ? void 0 : _a.value;
+        if (title === '') {
+            console.warn('<Tab> has an empty title — the tab has no accessible name and cannot deep-link. Add a descriptive title.');
         }
     });
 };

package/dist/rss/index.js

@@ -1,6 +1,7 @@
 import slugify from '@sindresorhus/slugify';
 import { stringifyTree } from '../mdx/index.js';
 import { getArrayExpressionStringProperties, getObjectExpressionStringProperty, } from '../mdx/utils.js';
+import { safeCleanHeadingId } from '../slugify.js';
 export const isFrontmatter = (node) => {
     return (node === null || node === void 0 ? void 0 : node.type) === 'yaml';
 };
@@ -85,6 +86,17 @@ export const getRssPropsData = (updateComponent) => {
     const description = getObjectExpressionStringProperty('description', rssData);
     return { rssTitle: title, rssDescription: description };
 };
+const getUpdateAnchorId = (updateComponent) => {
+    const idAttribute = updateComponent.attributes.find((attribute) => attribute.type === 'mdxJsxAttribute' &&
+        attribute.name === 'id' &&
+        typeof attribute.value === 'string');
+    if (typeof (idAttribute === null || idAttribute === void 0 ? void 0 : idAttribute.value) !== 'string')
+        return undefined;
+    // Match the page's id pipeline (Update.tsx uses safeCleanHeadingId) so feed
+    // fragment links point at the same DOM id the page renders; the RSS pipeline
+    // never runs the ToC plugin, so the cleaning must happen here.
+    return safeCleanHeadingId(idAttribute.value) || undefined;
+};
 export const getUpdateTitle = (updateComponent) => {
     var _a;
     const attributes = updateComponent.attributes;
@@ -313,7 +325,7 @@ export const processUpdatePerNode = ({ updateNode, date, title, description, })
         return [];
     }
     const rssTitle = title || label;
-    const anchor = slugify(label);
+    const anchor = getUpdateAnchorId(updateNode) || slugify(label);
     const categories = getTags(updateNode);
     const contentNodes = updateNode.children.filter((child) => isNormalMarkdown(child));
     const contentString = stringifyTreeForRSS({