@mintlify/common 1.0.1033 → 1.0.1034

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');