@mintlify/common 1.0.1144 → 1.0.1145

package/dist/mdx/lib/findExportedNode.js

@@ -14,17 +14,18 @@ export const findExportedNodes = (tree, ...type) => {
                     continue;
                 if (((_a = bodyChild.declaration) === null || _a === void 0 ? void 0 : _a.type) !== 'VariableDeclaration')
                     continue;
-                const declaration = bodyChild.declaration.declarations[0];
-                if (declaration == undefined)
-                    continue;
-                const init = declaration.init;
-                if (init == null)
-                    continue;
-                if (!type.includes(init.type))
-                    continue;
-                if (declaration.id.type !== 'Identifier')
-                    continue;
-                exports.push(declaration.id.name);
+                for (const declaration of bodyChild.declaration.declarations) {
+                    if (declaration == undefined)
+                        continue;
+                    const init = declaration.init;
+                    if (init == null)
+                        continue;
+                    if (!type.includes(init.type))
+                        continue;
+                    if (declaration.id.type !== 'Identifier')
+                        continue;
+                    exports.push(declaration.id.name);
+                }
             }
         }
     });

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

@@ -534,8 +534,62 @@ function buildStubEsmNode(names) {
         },
     };
 }
+function collectStringConstants(tree) {
+    const constants = new Map();
+    visit(tree, (node) => {
+        var _a;
+        if (!isMdxJsEsm(node) || !((_a = node.data) === null || _a === void 0 ? void 0 : _a.estree))
+            return;
+        for (const stmt of node.data.estree.body) {
+            if (stmt.type !== 'ExportNamedDeclaration')
+                continue;
+            const exportNode = stmt;
+            const decl = exportNode.declaration;
+            if (!decl || decl.type !== 'VariableDeclaration' || decl.kind !== 'const')
+                continue;
+            for (const declarator of decl.declarations) {
+                if (declarator.id.type !== 'Identifier' || !declarator.init)
+                    continue;
+                if (declarator.init.type === 'Literal' && typeof declarator.init.value === 'string') {
+                    constants.set(declarator.id.name, declarator.init.value);
+                }
+            }
+        }
+    });
+    return constants;
+}
+function tryResolveAsString(estree, constants) {
+    if (!estree)
+        return null;
+    const stmt = estree.body[0];
+    if ((stmt === null || stmt === void 0 ? void 0 : stmt.type) !== 'ExpressionStatement')
+        return null;
+    const expr = stmt.expression;
+    if (expr.type !== 'Identifier')
+        return null;
+    const val = constants.get(expr.name);
+    return val !== undefined ? val : null;
+}
 export function remarkMdxRemoveJs() {
     return (tree) => {
+        const constantStrings = collectStringConstants(tree);
+        if (constantStrings.size > 0) {
+            visit(tree, (node, index, parent) => {
+                var _a;
+                if (!parent || index == null)
+                    return CONTINUE;
+                if (node.type !== 'mdxTextExpression' && node.type !== 'mdxFlowExpression')
+                    return CONTINUE;
+                const exprNode = node;
+                const substitution = tryResolveAsString((_a = exprNode.data) === null || _a === void 0 ? void 0 : _a.estree, constantStrings);
+                if (substitution === null)
+                    return CONTINUE;
+                const replacement = node.type === 'mdxTextExpression'
+                    ? { type: 'text', value: substitution }
+                    : { type: 'paragraph', children: [{ type: 'text', value: substitution }] };
+                parent.children[index] = replacement;
+            });
+        }
         remove(tree, ['mdxTextExpression', 'mdxFlowExpression']);
         // Collect exported names before stripping ESM so we can inject stubs.
         // Map keyed by name deduplicates naturally.

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,120 @@
+import { fromMarkdown } from 'mdast-util-from-markdown';
+import { gfmFromMarkdown } from 'mdast-util-gfm';
+import { mdxFromMarkdown } from 'mdast-util-mdx';
+import { gfm } from 'micromark-extension-gfm';
+import { mdxjs } from 'micromark-extension-mdxjs';
+import { describe, expect, it } from 'vitest';
+import { remarkMdxRemoveJs } from './remarkMdxRemoveJs.js';
+function parse(mdx) {
+    return fromMarkdown(mdx, {
+        extensions: [gfm(), mdxjs()],
+        mdastExtensions: [gfmFromMarkdown(), mdxFromMarkdown()],
+    });
+}
+function extractText(node) {
+    if (node.type === 'text' && typeof node.value === 'string') {
+        return node.value;
+    }
+    if ('children' in node && Array.isArray(node.children)) {
+        return node.children
+            .map((child) => extractText(child))
+            .join('');
+    }
+    return '';
+}
+function applyPlugin(mdx) {
+    const tree = parse(mdx);
+    remarkMdxRemoveJs()(tree);
+    return tree;
+}
+describe('remarkMdxRemoveJs', () => {
+    describe('expression removal (existing behaviour)', () => {
+        it('removes arbitrary binary expressions', () => {
+            const tree = applyPlugin('Sum is {1 + 1} here.');
+            const text = extractText(tree);
+            expect(text).not.toContain('1 + 1');
+            expect(text).not.toContain('2');
+            expect(text).toContain('Sum is');
+            expect(text).toContain('here.');
+        });
+        it('removes function call expressions', () => {
+            const tree = applyPlugin('Items: {["a","b"].map(x => x)} end.');
+            const text = extractText(tree);
+            expect(text).not.toContain('map');
+            expect(text).toContain('Items:');
+            expect(text).toContain('end.');
+        });
+        it('removes template literals', () => {
+            const tree = applyPlugin('Val {`tpl-${1 + 1}`} end.');
+            const text = extractText(tree);
+            expect(text).not.toContain('tpl');
+            expect(text).toContain('Val');
+            expect(text).toContain('end.');
+        });
+    });
+    describe('string constant substitution (new behaviour)', () => {
+        it('substitutes a bare identifier that maps to an exported string constant', () => {
+            const mdx = `export const versions = "v1.2.3 and later";
+
+On {versions}, this feature requires opt-in.`;
+            const tree = applyPlugin(mdx);
+            const text = extractText(tree);
+            expect(text).toContain('v1.2.3 and later');
+            expect(text).toContain('On v1.2.3 and later, this feature requires opt-in.');
+        });
+        it('substitutes a page-level export const used inline', () => {
+            const mdx = `export const ver = "v5.5.5-CONSTVAL";
+
+Version {ver} here.`;
+            const tree = applyPlugin(mdx);
+            expect(extractText(tree)).toContain('Version v5.5.5-CONSTVAL here.');
+        });
+        it('substitutes multiple constants from separate export statements', () => {
+            const mdx = `export const a = "AAA";
+export const b = "BBB";
+
+{a} and {b}.`;
+            const tree = applyPlugin(mdx);
+            const text = extractText(tree);
+            expect(text).toContain('AAA');
+            expect(text).toContain('BBB');
+        });
+        it('substitutes all declarators in a multi-declarator const', () => {
+            const mdx = `export const a = "AAA", b = "BBB";
+
+{a} and {b}.`;
+            const tree = applyPlugin(mdx);
+            const text = extractText(tree);
+            expect(text).toContain('AAA');
+            expect(text).toContain('BBB');
+        });
+        it('does not substitute non-string (number) constants', () => {
+            const mdx = `export const count = 42;
+
+Value {count} here.`;
+            const tree = applyPlugin(mdx);
+            const text = extractText(tree);
+            expect(text).not.toContain('42');
+            expect(text).toContain('Value');
+            expect(text).toContain('here.');
+        });
+        it('does not substitute identifiers with no matching export', () => {
+            const tree = applyPlugin('Value {unknown} here.');
+            const text = extractText(tree);
+            expect(text).not.toContain('unknown');
+            expect(text).toContain('Value');
+            expect(text).toContain('here.');
+        });
+        it('substitutes the constant but still removes unresolvable expressions in the same page', () => {
+            const mdx = `export const x = "hello";
+
+Result {1 + 1} and {x} here.`;
+            const tree = applyPlugin(mdx);
+            const text = extractText(tree);
+            expect(text).toContain('hello');
+            expect(text).not.toContain('1 + 1');
+            expect(text).toContain('Result');
+            expect(text).toContain('and hello here.');
+        });
+    });
+});