@mintlify/common 1.0.786 → 1.0.788

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

@@ -1,4 +1,3 @@
-import { walk } from 'estree-walker';
 import { remove } from 'unist-util-remove';
 import { CONTINUE, visit } from 'unist-util-visit';
 import { isMdxJsEsm } from '../../utils.js';
@@ -231,35 +230,92 @@ export function rebuildStyleValue(properties) {
     });
     return `{ ${parts.join(', ')} }`;
 }
-function isFunction(estree) {
-    if (!estree.body.length)
-        return false;
-    let hasFunctionDeclaration = false;
-    walk(estree, {
-        enter(node) {
-            if (node.type === 'FunctionDeclaration' ||
-                node.type === 'ArrowFunctionExpression' ||
-                node.type === 'FunctionExpression') {
-                hasFunctionDeclaration = true;
-                return this.skip();
-            }
-            if (node.type === 'ExportDefaultDeclaration' &&
-                (node.declaration.type === 'FunctionDeclaration' ||
-                    node.declaration.type === 'FunctionExpression' ||
-                    node.declaration.type === 'ArrowFunctionExpression')) {
-                hasFunctionDeclaration = true;
-                return this.skip();
-            }
-            if (node.type === 'VariableDeclaration' &&
-                node.declarations.some((decl) => decl.init &&
-                    (decl.init.type === 'ArrowFunctionExpression' ||
-                        decl.init.type === 'FunctionExpression'))) {
-                hasFunctionDeclaration = true;
-                return this.skip();
+function collectExportedNames(estree) {
+    var _a, _b;
+    const names = [];
+    for (const node of estree.body) {
+        if (node.type !== 'ExportNamedDeclaration')
+            continue;
+        const decl = node.declaration;
+        if (!decl)
+            continue;
+        if (decl.type === 'FunctionDeclaration' && decl.id) {
+            names.push({ name: decl.id.name, isFunction: true });
+        }
+        else if (decl.type === 'VariableDeclaration') {
+            for (const declarator of decl.declarations) {
+                if (declarator.id.type !== 'Identifier')
+                    continue;
+                const isFn = ((_a = declarator.init) === null || _a === void 0 ? void 0 : _a.type) === 'ArrowFunctionExpression' ||
+                    ((_b = declarator.init) === null || _b === void 0 ? void 0 : _b.type) === 'FunctionExpression';
+                names.push({ name: declarator.id.name, isFunction: isFn });
             }
+        }
+    }
+    return names;
+}
+function buildStubEsmNode(names) {
+    const sourceLines = [];
+    const body = [];
+    for (const { name, isFunction } of names) {
+        if (isFunction) {
+            sourceLines.push(`export const ${name} = () => null;`);
+            body.push({
+                type: 'ExportNamedDeclaration',
+                declaration: {
+                    type: 'VariableDeclaration',
+                    declarations: [
+                        {
+                            type: 'VariableDeclarator',
+                            id: { type: 'Identifier', name },
+                            init: {
+                                type: 'ArrowFunctionExpression',
+                                params: [],
+                                body: { type: 'Literal', value: null, raw: 'null' },
+                                expression: true,
+                                async: false,
+                                generator: false,
+                            },
+                        },
+                    ],
+                    kind: 'const',
+                },
+                specifiers: [],
+                source: null,
+            });
+        }
+        else {
+            sourceLines.push(`export const ${name} = undefined;`);
+            body.push({
+                type: 'ExportNamedDeclaration',
+                declaration: {
+                    type: 'VariableDeclaration',
+                    declarations: [
+                        {
+                            type: 'VariableDeclarator',
+                            id: { type: 'Identifier', name },
+                            init: { type: 'Identifier', name: 'undefined' },
+                        },
+                    ],
+                    kind: 'const',
+                },
+                specifiers: [],
+                source: null,
+            });
+        }
+    }
+    return {
+        type: 'mdxjsEsm',
+        value: sourceLines.join('\n'),
+        data: {
+            estree: {
+                type: 'Program',
+                body,
+                sourceType: 'module',
+                comments: [],
+            },
         },
-    });
-    return hasFunctionDeclaration;
+    };
 }
 function isArrayOfStringLiterals(estree) {
     const stmt = estree.body[0];
@@ -272,16 +328,19 @@ function isArrayOfStringLiterals(estree) {
 export function remarkMdxRemoveJs() {
     return (tree) => {
         remove(tree, ['mdxTextExpression', 'mdxFlowExpression']);
-        remove(tree, (node) => {
+        // Collect exported names before stripping ESM so we can inject stubs
+        const exportedNames = [];
+        visit(tree, (node) => {
             var _a;
-            if (!isMdxJsEsm(node))
-                return false;
-            if (((_a = node.data) === null || _a === void 0 ? void 0 : _a.estree) && !isFunction(node.data.estree))
-                return false;
-            const value = node.value;
-            const containsReact = REACT_HOOKS.some((hook) => value.includes(hook) || value.includes('React.' + hook.toLowerCase()));
-            return containsReact;
+            if (isMdxJsEsm(node) && ((_a = node.data) === null || _a === void 0 ? void 0 : _a.estree)) {
+                exportedNames.push(...collectExportedNames(node.data.estree));
+            }
         });
+        remove(tree, (node) => isMdxJsEsm(node));
+        // Inject stub declarations for stripped exports to prevent ReferenceErrors
+        if (exportedNames.length > 0) {
+            tree.children.unshift(buildStubEsmNode(exportedNames));
+        }
         visit(tree, (node) => {
             if (!('attributes' in node))
                 return CONTINUE;