@mintlify/common 1.0.1110 → 1.0.1112

package/dist/mdx/snippets/resolveImport/resolveComponentWithContent.js

@@ -7,6 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+import { jsx, toJs } from 'estree-util-to-js';
 import { walk } from 'estree-walker';
 import { visit } from 'unist-util-visit';
 import { removeFrontmatterFromAST } from '../../astUtils.js';
@@ -63,28 +64,85 @@ const replaceVariablesWithProps = (node, treeToInject, exportMap, snippetExportM
     const variableNameMap = {};
     const variablesMap = {};
     const propValues = getSnippetPropValues(node);
+    const passedProps = new Set(node.attributes.flatMap((attribute) => attribute.type === 'mdxJsxAttribute' ? [attribute.name] : []));
     replaceCodePlaceholdersWithProps(treeToInject, propValues);
+    const getUniqueName = (name) => {
+        const existing = variableNameMap[name];
+        if (existing != undefined)
+            return existing;
+        let id = 0;
+        let uniqueName = createUniqueVariableName(name, id);
+        while (exportMap[uniqueName]) {
+            id += 1;
+            uniqueName = createUniqueVariableName(name, id);
+        }
+        variablesMap[uniqueName] = { type: 'unknown', value: 'undefined' };
+        variableNameMap[name] = uniqueName;
+        return uniqueName;
+    };
+    /**
+     * Rename every free identifier in an expression's estree to its unique name and
+     * regenerate the expression source from the estree so the two never disagree.
+     * (Replacing the first textual occurrence only — the previous behaviour — corrupted any
+     * expression that referenced the same prop twice, e.g. `a === "x" ? 1 : a === "y" ? 2 : 3`.)
+     */
+    const renamed = new WeakSet();
+    const scopeIdentifiers = (estree) => {
+        walk(estree, {
+            enter(jsNode, parent) {
+                if (jsNode.type !== 'Identifier')
+                    return;
+                if (renamed.has(jsNode))
+                    return;
+                if (snippetExportMap[jsNode.name] != undefined)
+                    return;
+                // `JSON.stringify(...)`, `Math.max(...)`: a global is only a prop when the tag passes it
+                if (!passedProps.has(jsNode.name) && isGlobalName(jsNode.name))
+                    return;
+                // `obj.prop` and `{ key: value }` — the property name is not a variable reference
+                if ((parent === null || parent === void 0 ? void 0 : parent.type) === 'MemberExpression' && parent.property === jsNode && !parent.computed)
+                    return;
+                if ((parent === null || parent === void 0 ? void 0 : parent.type) === 'Property' && parent.key === jsNode && !parent.computed) {
+                    if (!parent.shorthand)
+                        return;
+                    // `{ prop }` → `{ prop: prop_0 }`
+                    parent.shorthand = false;
+                    const value = Object.assign(Object.assign({}, jsNode), { name: getUniqueName(jsNode.name) });
+                    renamed.add(value);
+                    parent.value = value;
+                    return;
+                }
+                jsNode.name = getUniqueName(jsNode.name);
+                renamed.add(jsNode);
+            },
+        });
+        return generate(estree);
+    };
+    const scopeSpreadAttribute = (estree) => {
+        scopeIdentifiers(estree);
+        const spread = getSpreadElement(estree);
+        return spread ? `...${generate(toProgram(spread.argument))}` : generate(estree);
+    };
     visit(treeToInject, (node) => {
-        var _a;
+        var _a, _b, _c;
         if ((node.type === 'mdxTextExpression' || node.type === 'mdxFlowExpression') &&
             ((_a = node.data) === null || _a === void 0 ? void 0 : _a.estree)) {
-            node.data.estree = walk(node.data.estree, {
-                enter(jsNode) {
-                    if (jsNode.type === 'Identifier' && snippetExportMap[jsNode.name] == undefined) {
-                        let id = 0;
-                        let uniqueName = createUniqueVariableName(jsNode.name, id);
-                        while (exportMap[uniqueName]) {
-                            id += 1;
-                            uniqueName = createUniqueVariableName(jsNode.name, id);
-                        }
-                        // Replace node value with unique name
-                        node.value = node.value.replace(jsNode.name, uniqueName);
-                        variablesMap[uniqueName] = { type: 'unknown', value: 'undefined' };
-                        variableNameMap[jsNode.name] = uniqueName;
-                        jsNode.name = uniqueName;
-                    }
-                },
-            });
+            node.value = scopeIdentifiers(node.data.estree);
+            return;
+        }
+        // props referenced inside JSX attributes of the snippet, e.g. `<Card title={variant === "x" ? "a" : "b"}>`
+        if (node.type === 'mdxJsxFlowElement' || node.type === 'mdxJsxTextElement') {
+            for (const attribute of node.attributes) {
+                if (attribute.type === 'mdxJsxExpressionAttribute' && ((_b = attribute.data) === null || _b === void 0 ? void 0 : _b.estree)) {
+                    attribute.value = scopeSpreadAttribute(attribute.data.estree);
+                }
+                else if (attribute.type === 'mdxJsxAttribute' &&
+                    attribute.value &&
+                    typeof attribute.value === 'object' &&
+                    ((_c = attribute.value.data) === null || _c === void 0 ? void 0 : _c.estree)) {
+                    attribute.value.value = scopeIdentifiers(attribute.value.data.estree);
+                }
+            }
         }
     });
     node.attributes.forEach((attribute) => {
@@ -100,7 +158,9 @@ const replaceVariablesWithProps = (node, treeToInject, exportMap, snippetExportM
     });
     const variableDeclarationNodes = [];
     Object.entries(variablesMap).map(([variable, value]) => {
-        const statement = `export const ${variable} = ${value.type === 'string' ? `"${value.value}"` : value.value}`;
+        // JSON.stringify escapes quotes, backslashes and newlines so a prop value can never break
+        // out of the generated string literal
+        const statement = `export const ${variable} = ${value.type === 'string' ? JSON.stringify(value.value) : value.value}`;
         exportMap[variable] = statement;
         variableDeclarationNodes.push(...getAST(statement).children);
     });
@@ -109,6 +169,25 @@ const replaceVariablesWithProps = (node, treeToInject, exportMap, snippetExportM
         snippetNodesToInject: treeToInject.children,
     };
 };
+const generate = (estree) => toJs(estree, { handlers: jsx }).value.replace(/;\s*$/, '');
+const toProgram = (expression) => ({
+    type: 'Program',
+    sourceType: 'module',
+    body: [{ type: 'ExpressionStatement', expression }],
+    comments: [],
+});
+const getSpreadElement = (estree) => {
+    const [statement] = estree.body;
+    if ((statement === null || statement === void 0 ? void 0 : statement.type) !== 'ExpressionStatement')
+        return undefined;
+    const { expression } = statement;
+    if (expression.type !== 'ObjectExpression' || expression.properties.length !== 1)
+        return undefined;
+    const [property] = expression.properties;
+    return (property === null || property === void 0 ? void 0 : property.type) === 'SpreadElement' ? property : undefined;
+};
+const BROWSER_GLOBALS = new Set(['window', 'document', 'navigator', 'location', 'localStorage']);
+const isGlobalName = (name) => name in globalThis || BROWSER_GLOBALS.has(name);
 const getSnippetPropValues = (node) => {
     const propValues = {};
     node.attributes.forEach((attribute) => {

package/dist/mdx/utils.js

@@ -87,6 +87,7 @@ export const allowedComponents = [
     'Heading',
     'Info',
     'Icon',
+    'MDX',
     'Link',
     'MDXContentController',
     'ResponseField',