@mintlify/common 1.0.785 → 1.0.787

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

@@ -1,7 +1,7 @@
 import type { Program, Property } from 'estree-jsx';
 import type { Root } from 'mdast';
+export declare const REACT_HOOKS: string[];
 export declare function isStringSafe(value: string): boolean;
 export declare function filterStyleProperties(estree: Program): Program | null;
 export declare function rebuildStyleValue(properties: Property[]): string;
-export declare function isUnsafeEsm(estree: Program): boolean;
 export declare function remarkMdxRemoveJs(): (tree: Root) => void;

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';
@@ -136,6 +135,25 @@ const DEFAULT_PROP_EXPRESSIONS = {
     'x-hidden': { value: '"true"', estree: trueEstree },
     'x-excluded': { value: '"true"', estree: trueEstree },
 };
+export const REACT_HOOKS = [
+    'useState',
+    'useEffect',
+    'useRef',
+    'useCallback',
+    'useMemo',
+    'useReducer',
+    'useContext',
+    'useLayoutEffect',
+    'useImperativeHandle',
+    'useDebugValue',
+    'useDeferredValue',
+    'useTransition',
+    'useId',
+    'useSyncExternalStore',
+    'useInsertionEffect',
+    'useOptimistic',
+    'useActionState',
+];
 export function isStringSafe(value) {
     switch (true) {
         case value === 'true':
@@ -212,45 +230,92 @@ export function rebuildStyleValue(properties) {
     });
     return `{ ${parts.join(', ')} }`;
 }
-export function isUnsafeEsm(estree) {
-    if (!estree.body.length)
-        return false;
-    let hasUnsafeNode = false;
-    walk(estree, {
-        enter(node) {
-            switch (node.type) {
-                // Function/class definitions (could be used as executable components)
-                case 'FunctionDeclaration':
-                case 'FunctionExpression':
-                case 'ArrowFunctionExpression':
-                case 'ClassDeclaration':
-                case 'ClassExpression':
-                // Code execution
-                case 'CallExpression':
-                case 'NewExpression':
-                case 'ImportExpression':
-                case 'TaggedTemplateExpression':
-                case 'AwaitExpression':
-                case 'YieldExpression':
-                // Side effects
-                case 'AssignmentExpression':
-                case 'UpdateExpression':
-                // Property access (could read process.env, globalThis, etc.)
-                case 'MemberExpression':
-                    hasUnsafeNode = true;
-                    return this.skip();
-                // Re-exports pull in external modules (e.g. `export { readFileSync } from 'fs'`)
-                case 'ExportNamedDeclaration':
-                case 'ExportAllDeclaration':
-                    if ('source' in node && node.source != null) {
-                        hasUnsafeNode = true;
-                        return this.skip();
-                    }
-                    break;
+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 hasUnsafeNode;
+    };
 }
 function isArrayOfStringLiterals(estree) {
     const stmt = estree.body[0];
@@ -263,14 +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))
-                return false;
-            return isUnsafeEsm(node.data.estree);
+            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;