@mintlify/common 1.0.1132 → 1.0.1134

package/dist/mdx/getMDXOptions.js

@@ -21,13 +21,20 @@ export const getMDXOptions = ({ data, remarkPlugins = [], rehypePlugins = [], md
     // `knownComponents`: components the page defines (`export const X = …`, including snippet
     // imports resolved at prebuild). A fragment tree has no exports of its own, so without this the
     // unknown-JSX filter would strip `<X />` inside the fragment.
-    const buildPlugins = (extracts, { fragment = false, knownComponents = [], depth = 0, budget = undefined, } = {}) => ({
+    const buildPlugins = (extracts, { fragment = false, knownComponents = [], knownConstants = {}, depth = 0, budget = undefined, } = {}) => ({
         remarkPlugins: [
             // first, so `<Snippet file>` is injected on the page and inside every `<MDX>` fragment
             [remarkMdxInjectSnippets, data.snippetTreeMap],
             [
                 remarkMdxExpandExpressions,
-                { buildPlugins, extraPlugins: fragmentPlugins, knownComponents, depth, budget },
+                {
+                    buildPlugins,
+                    extraPlugins: fragmentPlugins,
+                    knownComponents,
+                    knownConstants,
+                    depth,
+                    budget,
+                },
             ],
             remarkMdxStyleStringToObject,
             [remarkResolveRelativeLinks, { path: data.path }],

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

@@ -10,6 +10,7 @@ export type RemarkMdxExpandExpressionsOptions = {
     buildPlugins: (mdxExtracts: MdxExtracts, options: {
         fragment: true;
         knownComponents: string[];
+        knownConstants: KnownConstants;
         depth: number;
         budget: FragmentBudget;
     }) => {
@@ -22,6 +23,8 @@ export type RemarkMdxExpandExpressionsOptions = {
      * fragments still know them; the page-level instance derives them from the tree.
      */
     knownComponents?: string[];
+    /** Literal `export const` values of the page (how prebuild writes snippet props); passed down to fragments. */
+    knownConstants?: KnownConstants;
     /** Nesting depth of the document being compiled: 0 for the page, +1 per enclosing fragment. */
     depth?: number;
     /** Expansion budget shared by a page compile and every fragment compiled for it. */
@@ -47,6 +50,14 @@ export type FragmentBudget = {
  */
 export declare const MAX_MDX_FRAGMENT_DEPTH = 8;
 export declare const MAX_MDX_FRAGMENTS_PER_PAGE = 500;
+/**
+ * A value a page exports and the evaluator can fold; `undefined` is a real value (a snippet prop
+ * that was not passed). Objects are only read through member access, never compared.
+ */
+export type KnownConstant = string | number | boolean | null | undefined | {
+    readonly [key: string]: KnownConstant;
+};
+export type KnownConstants = Record<string, KnownConstant>;
 /**
  * Compile-time expansion of `<MDX>` inside `{…}` expressions.
  *
@@ -92,9 +103,22 @@ export declare const MAX_MDX_FRAGMENTS_PER_PAGE = 500;
  * Table of contents: the fragment pipeline runs `remarkExtractTableOfContents` (it also rewrites
  * headings to `<Heading>`, so it cannot be skipped) into a fragment-scoped extracts object; the
  * headings are stored on the expression node as `data.tableOfContents` and merged into the page
- * TOC in document order by the page-level run. Headings of a branch that never renders are still
- * listed, and a fragment heading that repeats a page heading's title keeps its own id — a
- * render-time reconcile is the planned follow-up.
+ * TOC in document order by the page-level run. A branch whose condition folds to a page constant
+ * (`export const variant = "a"`, how prebuild writes a snippet prop) contributes no headings when
+ * it cannot render (`markReachability`); an unknown condition keeps every branch. The branch is
+ * still compiled, so a wrong verdict can only affect the TOC. A fragment heading that repeats a
+ * page heading's title keeps its own id — a render-time reconcile is the planned follow-up.
+ *
+ * The folding is a deliberately small evaluator, not a JS engine. It knows: identifiers bound by
+ * a page-level `export const` to a literal (string, number, boolean, null, `undefined`, a template
+ * without expressions) or to an object literal of such values; member access on those objects;
+ * `! - +`; `=== !== == != < <= > >=`; `&& || ??`; ternaries. Anything else — a function call, a
+ * `let`, a computed key, a comparison between objects — is unknown, and unknown keeps headings.
  */
 export declare const remarkMdxExpandExpressions: (options: RemarkMdxExpandExpressionsOptions) => (tree: Root) => Promise<void>;
+/**
+ * Literal `export const` values of the page. `let`/`var` may be reassigned and a non-literal
+ * initializer is not known, so both are left out, which keeps every branch's headings.
+ */
+export declare const getExportedConstants: (tree: Root) => KnownConstants;
 export declare const dedent: (text: string) => string;

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

@@ -38,6 +38,7 @@ const JSXParser = Parser.extend(jsx());
  */
 export const MAX_MDX_FRAGMENT_DEPTH = 8;
 export const MAX_MDX_FRAGMENTS_PER_PAGE = 500;
+const UNKNOWN = Symbol('unknown');
 /**
  * Compile-time expansion of `<MDX>` inside `{…}` expressions.
  *
@@ -83,12 +84,20 @@ export const MAX_MDX_FRAGMENTS_PER_PAGE = 500;
  * Table of contents: the fragment pipeline runs `remarkExtractTableOfContents` (it also rewrites
  * headings to `<Heading>`, so it cannot be skipped) into a fragment-scoped extracts object; the
  * headings are stored on the expression node as `data.tableOfContents` and merged into the page
- * TOC in document order by the page-level run. Headings of a branch that never renders are still
- * listed, and a fragment heading that repeats a page heading's title keeps its own id — a
- * render-time reconcile is the planned follow-up.
+ * TOC in document order by the page-level run. A branch whose condition folds to a page constant
+ * (`export const variant = "a"`, how prebuild writes a snippet prop) contributes no headings when
+ * it cannot render (`markReachability`); an unknown condition keeps every branch. The branch is
+ * still compiled, so a wrong verdict can only affect the TOC. A fragment heading that repeats a
+ * page heading's title keeps its own id — a render-time reconcile is the planned follow-up.
+ *
+ * The folding is a deliberately small evaluator, not a JS engine. It knows: identifiers bound by
+ * a page-level `export const` to a literal (string, number, boolean, null, `undefined`, a template
+ * without expressions) or to an object literal of such values; member access on those objects;
+ * `! - +`; `=== !== == != < <= > >=`; `&& || ??`; ternaries. Anything else — a function call, a
+ * `let`, a computed key, a comparison between objects — is unknown, and unknown keeps headings.
  */
 export const remarkMdxExpandExpressions = (options) => (tree) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b, _c;
+    var _a, _b, _c, _d, _e;
     const depth = (_a = options.depth) !== null && _a !== void 0 ? _a : 0;
     decodeFragmentCode(tree, depth > 0);
     const expressions = [];
@@ -110,12 +119,15 @@ export const remarkMdxExpandExpressions = (options) => (tree) => __awaiter(void
     const knownComponents = [
         ...new Set([...((_b = options.knownComponents) !== null && _b !== void 0 ? _b : []), ...getExportedFunctionNames(tree)]),
     ];
-    const budget = (_c = options.budget) !== null && _c !== void 0 ? _c : { remaining: MAX_MDX_FRAGMENTS_PER_PAGE };
+    // ESM inside a fragment is dropped when it is spliced back, so only the page's exports count
+    const knownConstants = depth === 0
+        ? Object.assign(Object.assign({}, ((_c = options.knownConstants) !== null && _c !== void 0 ? _c : {})), getExportedConstants(tree)) : Object.assign({}, ((_d = options.knownConstants) !== null && _d !== void 0 ? _d : {}));
+    const budget = (_e = options.budget) !== null && _e !== void 0 ? _e : { remaining: MAX_MDX_FRAGMENTS_PER_PAGE };
     for (const node of expressions) {
-        yield expandExpression(node, options, { knownComponents, depth, budget });
+        yield expandExpression(node, options, { knownComponents, knownConstants, depth, budget });
     }
 });
-const expandExpression = (node_1, options_1, _a) => __awaiter(void 0, [node_1, options_1, _a], void 0, function* (node, options, { knownComponents, depth, budget }) {
+const expandExpression = (node_1, options_1, _a) => __awaiter(void 0, [node_1, options_1, _a], void 0, function* (node, options, { knownComponents, knownConstants, depth, budget }) {
     var _b, _c, _d, _e;
     if (!node.value.includes('<MDX'))
         return;
@@ -132,6 +144,7 @@ const expandExpression = (node_1, options_1, _a) => __awaiter(void 0, [node_1, o
     const elements = collectMdxElements(expression);
     if (elements.length === 0)
         return;
+    const reachability = markReachability(expression, knownConstants);
     const headings = [];
     let changed = false;
     for (const element of elements) {
@@ -153,6 +166,7 @@ const expandExpression = (node_1, options_1, _a) => __awaiter(void 0, [node_1, o
         const { remarkPlugins, rehypePlugins } = options.buildPlugins(fragmentExtracts, {
             fragment: true,
             knownComponents,
+            knownConstants,
             depth: depth + 1,
             budget,
         });
@@ -181,7 +195,7 @@ const expandExpression = (node_1, options_1, _a) => __awaiter(void 0, [node_1, o
                 ? compiled.children
                 : [compiled];
         changed = true;
-        if (fragmentExtracts.tableOfContents) {
+        if (fragmentExtracts.tableOfContents && reachability.get(element) !== false) {
             headings.push(...fragmentExtracts.tableOfContents);
         }
     }
@@ -234,6 +248,247 @@ const collectMdxElements = (expression) => {
 const isMdxElement = (node) => node.type === 'JSXElement' &&
     node.openingElement.name.type === 'JSXIdentifier' &&
     node.openingElement.name.name === 'MDX';
+/**
+ * Literal `export const` values of the page. `let`/`var` may be reassigned and a non-literal
+ * initializer is not known, so both are left out, which keeps every branch's headings.
+ */
+export const getExportedConstants = (tree) => {
+    const constants = {};
+    visit(tree, 'mdxjsEsm', (node) => {
+        var _a, _b, _c, _d;
+        for (const statement of (_c = (_b = (_a = node.data) === null || _a === void 0 ? void 0 : _a.estree) === null || _b === void 0 ? void 0 : _b.body) !== null && _c !== void 0 ? _c : []) {
+            if (statement.type !== 'ExportNamedDeclaration')
+                continue;
+            if (((_d = statement.declaration) === null || _d === void 0 ? void 0 : _d.type) !== 'VariableDeclaration')
+                continue;
+            if (statement.declaration.kind !== 'const')
+                continue;
+            for (const { id, init } of statement.declaration.declarations) {
+                if (id.type !== 'Identifier' || !init)
+                    continue;
+                const value = evaluate(init, {});
+                if (value !== UNKNOWN)
+                    constants[id.name] = value;
+            }
+        }
+    });
+    return constants;
+};
+const isObject = (value) => typeof value === 'object' && value !== null;
+const compare = (operator, left, right) => {
+    // two object literals are distinct references at runtime; never fold their comparison
+    if (isObject(left) || isObject(right))
+        return UNKNOWN;
+    switch (operator) {
+        case '===':
+            return left === right;
+        case '!==':
+            return left !== right;
+        case '==':
+            // eslint-disable-next-line eqeqeq -- mirrors the author's loose comparison
+            return left == right;
+        case '!=':
+            // eslint-disable-next-line eqeqeq -- mirrors the author's loose comparison
+            return left != right;
+        default:
+            break;
+    }
+    const ordered = (typeof left === 'number' && typeof right === 'number') ||
+        (typeof left === 'string' && typeof right === 'string');
+    if (!ordered)
+        return UNKNOWN;
+    const l = left;
+    const r = right;
+    switch (operator) {
+        case '<':
+            return l < r;
+        case '<=':
+            return l <= r;
+        case '>':
+            return l > r;
+        case '>=':
+            return l >= r;
+        default:
+            return UNKNOWN;
+    }
+};
+/** Static value of an expression given the page's constants, or UNKNOWN. */
+const evaluate = (node, constants) => {
+    // acorn emits this node only with `preserveParens`; the estree types do not list it
+    if (node.type === 'ParenthesizedExpression') {
+        return evaluate(node.expression, constants);
+    }
+    switch (node.type) {
+        case 'Literal':
+            return 'regex' in node || 'bigint' in node ? UNKNOWN : node.value;
+        case 'TemplateLiteral':
+            return node.expressions.length === 0
+                ? node.quasis.map((quasi) => { var _a; return (_a = quasi.value.cooked) !== null && _a !== void 0 ? _a : quasi.value.raw; }).join('')
+                : UNKNOWN;
+        case 'Identifier':
+            if (node.name === 'undefined')
+                return undefined;
+            return Object.hasOwn(constants, node.name) ? constants[node.name] : UNKNOWN;
+        case 'ObjectExpression': {
+            const object = {};
+            for (const property of node.properties) {
+                if (property.type !== 'Property' || property.kind !== 'init' || property.computed) {
+                    return UNKNOWN;
+                }
+                const key = property.key.type === 'Identifier'
+                    ? property.key.name
+                    : property.key.type === 'Literal'
+                        ? String(property.key.value)
+                        : undefined;
+                if (key === undefined)
+                    return UNKNOWN;
+                const value = evaluate(property.value, constants);
+                if (value === UNKNOWN)
+                    return UNKNOWN;
+                object[key] = value;
+            }
+            return object;
+        }
+        case 'MemberExpression': {
+            const object = evaluate(node.object, constants);
+            if (object === UNKNOWN || !isObject(object))
+                return UNKNOWN;
+            const key = node.computed
+                ? evaluate(node.property, constants)
+                : node.property.type === 'Identifier'
+                    ? node.property.name
+                    : UNKNOWN;
+            if (typeof key !== 'string' && typeof key !== 'number')
+                return UNKNOWN;
+            return Object.hasOwn(object, String(key)) ? object[String(key)] : undefined;
+        }
+        case 'UnaryExpression': {
+            const argument = evaluate(node.argument, constants);
+            if (argument === UNKNOWN)
+                return UNKNOWN;
+            if (node.operator === '!')
+                return !argument;
+            if (typeof argument === 'number' && node.operator === '-')
+                return -argument;
+            if (typeof argument === 'number' && node.operator === '+')
+                return argument;
+            return UNKNOWN;
+        }
+        case 'BinaryExpression': {
+            const left = evaluate(node.left, constants);
+            const right = evaluate(node.right, constants);
+            return left === UNKNOWN || right === UNKNOWN ? UNKNOWN : compare(node.operator, left, right);
+        }
+        case 'LogicalExpression': {
+            const left = evaluate(node.left, constants);
+            if (left === UNKNOWN)
+                return UNKNOWN;
+            if (node.operator === '&&')
+                return left ? evaluate(node.right, constants) : left;
+            if (node.operator === '||')
+                return left ? left : evaluate(node.right, constants);
+            return left != null ? left : evaluate(node.right, constants);
+        }
+        default:
+            return UNKNOWN;
+    }
+};
+/**
+ * Names a function binds: parameters and every declaration in its body. Over-approximate on
+ * purpose (a destructuring key counts too): a shadowed name becomes unknown, which keeps headings.
+ */
+const collectFunctionBindings = (fn) => {
+    const names = new Set();
+    const addIdentifiers = (pattern) => {
+        if (pattern) {
+            walk(pattern, {
+                enter(jsNode) {
+                    if (jsNode.type === 'Identifier')
+                        names.add(jsNode.name);
+                },
+            });
+        }
+    };
+    walk(fn, {
+        enter(jsNode) {
+            if (isFunction(jsNode)) {
+                for (const param of jsNode.params)
+                    addIdentifiers(param);
+                if (jsNode.type === 'FunctionDeclaration')
+                    addIdentifiers(jsNode.id);
+            }
+            else if (jsNode.type === 'VariableDeclarator')
+                addIdentifiers(jsNode.id);
+            else if (jsNode.type === 'ClassDeclaration')
+                addIdentifiers(jsNode.id);
+            else if (jsNode.type === 'CatchClause')
+                addIdentifiers(jsNode.param);
+        },
+    });
+    return names;
+};
+const isFunction = (node) => node.type === 'ArrowFunctionExpression' ||
+    node.type === 'FunctionExpression' ||
+    node.type === 'FunctionDeclaration';
+const NON_CHILD_KEYS = new Set(['type', 'start', 'end', 'loc', 'range', 'comments']);
+/**
+ * Whether each `<MDX>` element in `expression` can render: `false` only when a guarding
+ * conditional or logical operator folds to the other branch, `true` on a taken branch or when
+ * any guard is unknown. Names a function binds shadow constants inside it.
+ */
+const markReachability = (expression, constants) => {
+    const reachability = new Map();
+    const visitNode = (value, reachable, scope) => {
+        if (!value || typeof value !== 'object')
+            return;
+        if (Array.isArray(value)) {
+            for (const child of value)
+                visitNode(child, reachable, scope);
+            return;
+        }
+        const node = value;
+        if (typeof node.type !== 'string')
+            return;
+        if (isMdxElement(node)) {
+            reachability.set(node, reachable);
+            return;
+        }
+        if (node.type === 'ConditionalExpression') {
+            const test = evaluate(node.test, scope);
+            visitNode(node.consequent, reachable && (test === UNKNOWN || Boolean(test)), scope);
+            visitNode(node.alternate, reachable && (test === UNKNOWN || !test), scope);
+            return;
+        }
+        if (node.type === 'LogicalExpression') {
+            const left = evaluate(node.left, scope);
+            visitNode(node.left, reachable, scope);
+            let rightReachable = reachable;
+            if (left !== UNKNOWN) {
+                if (node.operator === '&&')
+                    rightReachable = reachable && Boolean(left);
+                else if (node.operator === '||')
+                    rightReachable = reachable && !left;
+                else
+                    rightReachable = reachable && left == null;
+            }
+            visitNode(node.right, rightReachable, scope);
+            return;
+        }
+        let childScope = scope;
+        if (isFunction(node)) {
+            childScope = Object.assign({}, scope);
+            for (const name of collectFunctionBindings(node))
+                delete childScope[name];
+        }
+        for (const key of Object.keys(node)) {
+            if (NON_CHILD_KEYS.has(key))
+                continue;
+            visitNode(node[key], reachable, childScope);
+        }
+    };
+    visitNode(expression, true, constants);
+    return reachability;
+};
 export const dedent = (text) => {
     var _a, _b;
     const lines = text.split('\n');

package/dist/mdx/snippets/resolveAllImports.d.ts

@@ -1,7 +1,7 @@
 import type { Root } from 'mdast';
 import type { FileType, FileWithImports } from '../../types/mdx/index.js';
 export type ResolveImportsWarning = {
-    type: 'invalid-import-path' | 'missing-file' | 'import-resolution-error' | 'default-import-no-default-export';
+    type: 'invalid-import-path' | 'missing-file' | 'import-resolution-error' | 'default-import-no-default-export' | 'export-collision';
     message: string;
 };
 export declare const resolveAllImports: (params: {

package/dist/mdx/snippets/resolveAllImports.js

@@ -56,7 +56,7 @@ export const resolveAllImports = (params) => __awaiter(void 0, void 0, void 0, f
                 }
             }
             try {
-                const contentWithResolvedImport = yield resolveImport(specifier, ast, importedSnippet.tree, exportMap);
+                const contentWithResolvedImport = yield resolveImport(specifier, ast, importedSnippet.tree, exportMap, onWarning !== null && onWarning !== void 0 ? onWarning : ((warning) => console.log(warning.message)));
                 if (contentWithResolvedImport == undefined) {
                     throw new Error('Import failed to resolve');
                 }

package/dist/mdx/snippets/resolveImport/exportCollision.d.ts

@@ -0,0 +1,7 @@
+export type ExportCollisionWarning = {
+    type: 'export-collision';
+    message: string;
+};
+export type OnExportCollision = (warning: ExportCollisionWarning) => void;
+/** Same name, different code: the first declaration wins, so say so instead of failing silently. */
+export declare const warnOnExportCollision: (name: string, existing: string, incoming: string, onWarning?: OnExportCollision) => void;

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

@@ -0,0 +1,10 @@
+const normalizeStatement = (statement) => statement.replace(/\s+/g, ' ').trim();
+/** Same name, different code: the first declaration wins, so say so instead of failing silently. */
+export const warnOnExportCollision = (name, existing, incoming, onWarning) => {
+    if (normalizeStatement(existing) === normalizeStatement(incoming))
+        return;
+    onWarning === null || onWarning === void 0 ? void 0 : onWarning({
+        type: 'export-collision',
+        message: `"${name}" is declared twice with different definitions; the first one is kept. Import one of them under another name: import { ${name} as Other${name} } from '…'`,
+    });
+};

package/dist/mdx/snippets/resolveImport/index.d.ts

@@ -1,5 +1,7 @@
 import type { Root } from 'mdast';
 import type { ImportSpecifier } from '../../../types/mdx/snippets/import.js';
+import { type OnExportCollision } from './exportCollision.js';
+export { type ExportCollisionWarning, type OnExportCollision } from './exportCollision.js';
 export { findExport } from './findExport.js';
 export { injectToTopOfFileOfTree } from './injectToTopOfFile.js';
 /**
@@ -9,4 +11,4 @@ export { injectToTopOfFileOfTree } from './injectToTopOfFile.js';
  * @param importedFileContent The content of the file we are importing from
  * @returns
  */
-export declare const resolveImport: (importSpecifier: ImportSpecifier, destinationPageContent: Root, importedFileContent: Root, exportMap: Record<string, string>) => Promise<Root | undefined>;
+export declare const resolveImport: (importSpecifier: ImportSpecifier, destinationPageContent: Root, importedFileContent: Root, exportMap: Record<string, string>, onWarning?: OnExportCollision) => Promise<Root | undefined>;

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

@@ -9,6 +9,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { MdxImportSpecifier } from '../../../types/mdx/snippets/import.js';
 import { getAST } from '../../remark.js';
+import { getExportMapFromTree } from '../getExportMap.js';
+import { warnOnExportCollision } from './exportCollision.js';
 import { findExport } from './findExport.js';
 import { injectToTopOfFileOfTree } from './injectToTopOfFile.js';
 import { resolveComponentWithContent } from './resolveComponentWithContent.js';
@@ -29,25 +31,33 @@ const OTHER_SPECIFIERS = [
  * @param importedFileContent The content of the file we are importing from
  * @returns
  */
-export const resolveImport = (importSpecifier, destinationPageContent, importedFileContent, exportMap) => __awaiter(void 0, void 0, void 0, function* () {
+export const resolveImport = (importSpecifier, destinationPageContent, importedFileContent, exportMap, onWarning) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
     if (VALID_SPECIFIERS.includes(importSpecifier.type)) {
         // normal import: import { Component } from '/snippets/Component.mdx' or jsx file
-        if ((importSpecifier.renamedName && exportMap[importSpecifier.renamedName]) ||
-            exportMap[importSpecifier.name]) {
-            // TODO: Handle collisions
-            return destinationPageContent;
-        }
         // find "Component" in "/snippets/Component.mdx" or jsx files
         const exportContent = findExport(importSpecifier.name, importedFileContent, importSpecifier.renamedName);
         if (exportContent == undefined)
             throw new Error(`Could not find export ${importSpecifier.name} in snippet`);
-        // Inject "export const Component = `...`" into the top of the destination page
-        injectToTopOfFileOfTree(destinationPageContent, getAST(exportContent).children);
+        // `import { X as Y }` binds Y; an existing declaration of that name wins
+        const localName = (_a = importSpecifier.renamedName) !== null && _a !== void 0 ? _a : importSpecifier.name;
+        const existing = exportMap[localName];
+        if (existing !== undefined) {
+            warnOnExportCollision(localName, existing, exportContent, onWarning);
+            return destinationPageContent;
+        }
+        // Inject "export const Component = `...`" into the top of the destination page and record
+        // every name it declares so a later import or inlined snippet dedupes against it
+        const injected = getAST(exportContent);
+        injectToTopOfFileOfTree(destinationPageContent, injected.children);
+        for (const [declared, statement] of Object.entries(getExportMapFromTree(injected))) {
+            (_b = exportMap[declared]) !== null && _b !== void 0 ? _b : (exportMap[declared] = statement);
+        }
         return destinationPageContent;
     }
     else if (OTHER_SPECIFIERS.includes(importSpecifier.type)) {
         // default export: import DefaultComponent from '/snippets/DefaultComponent.mdx'
         // replace every instance of DefaultComponent with the content of the imported file
-        return yield resolveComponentWithContent(destinationPageContent, importSpecifier.name, importedFileContent, exportMap);
+        return yield resolveComponentWithContent(destinationPageContent, importSpecifier.name, importedFileContent, exportMap, onWarning);
     }
 });

package/dist/mdx/snippets/resolveImport/resolveComponentWithContent.d.ts

@@ -1,4 +1,5 @@
 import type { Root } from 'mdast';
+import { type OnExportCollision } from './exportCollision.js';
 /**
  *
  * @param tree The tree to inject into
@@ -6,4 +7,4 @@ import type { Root } from 'mdast';
  * @param snippet The snippet to inject in place of the component
  * @param exportMap The export map of the snippet
  */
-export declare const resolveComponentWithContent: (tree: Root, componentName: string, snippet: Root, exportMap: Record<string, string>) => Promise<Root>;
+export declare const resolveComponentWithContent: (tree: Root, componentName: string, snippet: Root, exportMap: Record<string, string>, onWarning?: OnExportCollision) => Promise<Root>;

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

@@ -16,6 +16,7 @@ import { removeFrontmatterFromAST } from '../../astUtils.js';
 import { getAST } from '../../remark.js';
 import { createUniqueVariableName, isMdxJsxFlowElement } from '../../utils.js';
 import { findAndRemoveExports } from '../findAndRemoveExports.js';
+import { warnOnExportCollision } from './exportCollision.js';
 import { injectToTopOfFileOfTree } from './injectToTopOfFile.js';
 /**
  *
@@ -24,7 +25,7 @@ import { injectToTopOfFileOfTree } from './injectToTopOfFile.js';
  * @param snippet The snippet to inject in place of the component
  * @param exportMap The export map of the snippet
  */
-export const resolveComponentWithContent = (tree, componentName, snippet, exportMap) => __awaiter(void 0, void 0, void 0, function* () {
+export const resolveComponentWithContent = (tree, componentName, snippet, exportMap, onWarning) => __awaiter(void 0, void 0, void 0, function* () {
     const clonedSnippet = structuredClone(snippet);
     removeFrontmatterFromAST(clonedSnippet);
     const snippetExportMap = findAndRemoveExports(clonedSnippet);
@@ -51,7 +52,7 @@ export const resolveComponentWithContent = (tree, componentName, snippet, export
             treeToInject = treeToInjectClone;
         }
     });
-    reinsertExports(tree, exportMap, snippetExportMap);
+    reinsertExports(tree, exportMap, snippetExportMap, onWarning);
     return tree;
 });
 /**
@@ -272,15 +273,18 @@ const replaceCodePlaceholdersWithProps = (tree, propValues) => {
         });
     });
 };
-const reinsertExports = (content, exportMap, snippetExportMap) => {
+const reinsertExports = (content, exportMap, snippetExportMap, onWarning) => {
     const nodesToInject = [];
     for (const [key, value] of Object.entries(snippetExportMap)) {
-        // TODO: handle duplicate exports
-        if (exportMap[key] == undefined) {
+        const existing = exportMap[key];
+        if (existing == undefined) {
             const exportAST = getAST(value);
             nodesToInject.push(...exportAST.children);
             exportMap[key] = value;
         }
+        else {
+            warnOnExportCollision(key, existing, value, onWarning);
+        }
     }
     if (nodesToInject.length > 0) {
         injectToTopOfFileOfTree(content, nodesToInject);