@mintlify/common 1.0.1246 → 1.0.1248

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

@@ -1,12 +1,15 @@
 import type { Root } from 'mdast';
 import type { FileType, FileWithImports } from '../../types/mdx/index.js';
+import type { ImportMap } from '../../types/mdx/snippets/import.js';
 import { type PackageImportOptions } from '../islands/packageImports.js';
 export type ResolveImportsWarning = {
     type: 'invalid-import-path' | 'missing-file' | 'import-resolution-error' | 'default-import-no-default-export' | 'export-collision' | 'undeclared-package' | 'package-import-conflict';
     message: string;
 };
 export declare const resolveAllImports: (params: {
-    snippets: FileType[];
+    snippets: (FileType & {
+        importMap?: ImportMap;
+    })[];
     fileWithImports: FileWithImports;
     onWarning?: (warning: ResolveImportsWarning) => void;
     packages?: PackageImportOptions;

package/dist/mdx/snippets/resolveAllImports.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 { remove } from 'unist-util-remove';
 import { visit } from 'unist-util-visit';
 import { MdxImportSpecifier } from '../../types/mdx/snippets/import.js';
@@ -35,12 +36,90 @@ const takeImports = (tree) => __awaiter(void 0, void 0, void 0, function* () {
     remove(tree, { cascade: false }, (node) => carriers.has(node) && !remaining.has(node));
     return importMap;
 });
+const splitTopLevelImports = (tree) => __awaiter(void 0, void 0, void 0, function* () {
+    const carriers = tree.children.filter(hasImportDeclaration);
+    if (carriers.length === 0)
+        return { tree: Object.assign(Object.assign({}, tree), { children: [...tree.children] }), importMap: {} };
+    const { importMap } = yield findAndRemoveImports({
+        type: 'root',
+        children: structuredClone(carriers),
+    });
+    const taken = new Set(carriers);
+    return {
+        tree: Object.assign(Object.assign({}, tree), { children: tree.children.filter((node) => !taken.has(node)) }),
+        importMap,
+    };
+});
+const exportName = (name) => 'value' in name ? String(name.value) : name.name;
+const toImportSpecifier = ({ local, exported }) => {
+    const imported = exportName(local);
+    const bound = exportName(exported);
+    if (bound === 'default')
+        return undefined;
+    if (imported === 'default')
+        return { type: MdxImportSpecifier.ImportDefaultSpecifier, name: bound };
+    if (imported === bound)
+        return { type: MdxImportSpecifier.ImportSpecifier, name: imported };
+    return { type: MdxImportSpecifier.RenamedImportSpecifier, name: imported, renamedName: bound };
+};
+const isPackageReExport = (statement, packageNames) => {
+    var _a;
+    return statement.type === 'ExportNamedDeclaration' &&
+        typeof ((_a = statement.source) === null || _a === void 0 ? void 0 : _a.value) === 'string' &&
+        isNonHostBareImport(statement.source.value) &&
+        isDeclaredPackageImport(statement.source.value, packageNames);
+};
+const takePackageReExports = (tree, packageNames) => {
+    const reExports = [];
+    tree.children = tree.children.flatMap((node) => {
+        var _a;
+        if (!isMdxJsEsm(node) || !estreeIsProgram(node))
+            return [node];
+        const statements = node.data.estree.body;
+        const reExported = statements.filter((statement) => isPackageReExport(statement, packageNames));
+        for (const statement of reExported) {
+            if (statement.type !== 'ExportNamedDeclaration' ||
+                typeof ((_a = statement.source) === null || _a === void 0 ? void 0 : _a.value) !== 'string')
+                continue;
+            reExports.push([
+                statement.source.value,
+                statement.specifiers.flatMap((s) => { var _a; return (_a = toImportSpecifier(s)) !== null && _a !== void 0 ? _a : []; }),
+            ]);
+        }
+        const rest = statements.filter((statement) => !reExported.includes(statement));
+        if (rest.length === statements.length)
+            return [node];
+        if (rest.length === 0)
+            return [];
+        const estree = Object.assign(Object.assign({}, node.data.estree), { body: rest });
+        return [
+            Object.assign(Object.assign({}, node), { value: toJs(estree, { handlers: jsx }).value, data: Object.assign(Object.assign({}, node.data), { estree }) }),
+        ];
+    });
+    return reExports;
+};
+const declaredPackageImports = (snippet, packages) => {
+    var _a;
+    return Object.entries((_a = snippet.importMap) !== null && _a !== void 0 ? _a : {}).flatMap(([source, specifiers]) => {
+        var _a;
+        const resolvedPath = resolveImportPath(source, snippet.filename);
+        if (resolvedPath == null) {
+            return isNonHostBareImport(source) && isDeclaredPackageImport(source, packages.packageNames)
+                ? [[source, specifiers]]
+                : [];
+        }
+        return ((_a = packages.packageSnippets) === null || _a === void 0 ? void 0 : _a.has(resolvedPath)) ? [[resolvedPath, specifiers]] : [];
+    });
+};
 export const resolveAllImports = (params) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e;
     const { snippets, fileWithImports, onWarning, packages } = params;
     let ast = fileWithImports.tree;
+    const kept = packages && /\.mdx?$/.test(fileWithImports.filename)
+        ? takePackageReExports(ast, packages.packageNames)
+        : [];
     const exportMap = getExportMapFromTree(ast);
-    const kept = [];
+    const strippedSnippets = new Map();
     for (const source of Object.keys(fileWithImports.importMap)) {
         const resolvedPath = resolveImportPath(source, fileWithImports.filename);
         if (packages && resolvedPath == null && isNonHostBareImport(source)) {
@@ -71,8 +150,8 @@ export const resolveAllImports = (params) => __awaiter(void 0, void 0, void 0, f
             }
             continue;
         }
-        const importedSnippet = snippets.find((snippet) => snippet.filename === resolvedPath);
-        if (importedSnippet == undefined) {
+        const foundSnippet = snippets.find((snippet) => snippet.filename === resolvedPath);
+        if (foundSnippet == undefined) {
             const message = `Could not find file ${resolvedPath} - imported from ${fileWithImports.filename}`;
             if (onWarning) {
                 onWarning({ type: 'missing-file', message });
@@ -82,6 +161,16 @@ export const resolveAllImports = (params) => __awaiter(void 0, void 0, void 0, f
             }
             continue;
         }
+        let importedSnippet = (_e = strippedSnippets.get(foundSnippet)) !== null && _e !== void 0 ? _e : foundSnippet;
+        if (packages && !strippedSnippets.has(foundSnippet)) {
+            const { tree, importMap } = yield splitTopLevelImports(foundSnippet.tree);
+            importedSnippet = Object.assign(Object.assign({}, foundSnippet), { tree });
+            strippedSnippets.set(foundSnippet, importedSnippet);
+            kept.push(...Object.entries(importMap), ...declaredPackageImports(foundSnippet, packages));
+            if (/\.mdx?$/.test(foundSnippet.filename)) {
+                kept.push(...takePackageReExports(tree, packages.packageNames));
+            }
+        }
         const snippetExportMap = getExportMapFromTree(importedSnippet.tree);
         const specifiers = fileWithImports.importMap[source];
         if (specifiers == undefined)