@mintlify/common 1.0.1245 → 1.0.1247

package/dist/mdx/lib/index.d.ts

@@ -1,3 +1,4 @@
 export * from './mdx-utils.js';
 export * from './remark-utils.js';
 export * from './findExportedNode.js';
+export * from './node-text.js';

package/dist/mdx/lib/index.js

@@ -1,3 +1,4 @@
 export * from './mdx-utils.js';
 export * from './remark-utils.js';
 export * from './findExportedNode.js';
+export * from './node-text.js';

package/dist/mdx/lib/node-text.d.ts

@@ -0,0 +1,9 @@
+import type { ElementContent } from 'hast';
+type ValueTree = {
+    type: string;
+    value?: unknown;
+    children?: readonly ValueTree[];
+};
+export declare const mdastToText: (node: ValueTree) => string;
+export declare const hastToText: (node: ElementContent) => string;
+export {};

package/dist/mdx/lib/node-text.js

@@ -0,0 +1,14 @@
+export const mdastToText = (node) => {
+    if (typeof node.value === 'string')
+        return node.value;
+    if (!node.children)
+        return '';
+    return node.children.map(mdastToText).join('');
+};
+export const hastToText = (node) => {
+    if (node.type === 'text')
+        return node.value;
+    if (node.type === 'element')
+        return node.children.map(hastToText).join('');
+    return '';
+};

package/dist/mdx/plugins/rehype/rehypeTable.js

@@ -1,18 +1,7 @@
 import { u } from 'unist-builder';
 import { visit } from 'unist-util-visit';
+import { hastToText } from '../../lib/node-text.js';
 import { createMdxJsxAttribute } from '../../lib/remark-utils.js';
-const extractTextContent = (node) => {
-    let text = '';
-    for (const child of node.children) {
-        if (child.type === 'text') {
-            text += child.value;
-        }
-        else if (child.type === 'element') {
-            text += extractTextContent(child);
-        }
-    }
-    return text;
-};
 const PROCESS_NUMERIC_CELLS_THRESHOLD = 0.8;
 const UNITS = '(GiB|MiB|KiB|TiB|PiB|EiB|ZiB|' + // Storage (binary prefixes - IEC)
     'GB|MB|KB|TB|PB|EB|ZB|' + // Storage (decimal prefixes)
@@ -118,7 +107,7 @@ const isPrimarilyNumeric = (text) => {
 const processTableCells = (node) => {
     visit(node, 'element', (cellNode) => {
         if (cellNode.tagName === 'td') {
-            const textContent = extractTextContent(cellNode);
+            const textContent = hastToText(cellNode);
             if (isPrimarilyNumeric(textContent)) {
                 cellNode.properties['data-numeric'] = 'true';
             }

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

@@ -1,21 +1,16 @@
 import { visit } from 'unist-util-visit';
+import { mdastToText } from '../../lib/node-text.js';
 const isList = (node) => node.type === 'list';
 const isTreeItemElement = (node) => node.type === 'mdxJsxFlowElement' &&
     'name' in node &&
     (node.name === 'Tree.Folder' ||
         node.name === 'Tree.File');
 const isExpression = (node) => node.type === 'mdxFlowExpression' || node.type === 'mdxTextExpression';
-const getNodeText = (node) => {
-    var _a;
-    if (typeof node.value === 'string')
-        return node.value;
-    return ((_a = node.children) !== null && _a !== void 0 ? _a : []).map(getNodeText).join('');
-};
 const describeNode = (node) => {
     if (node.type === 'mdxJsxFlowElement' && 'name' in node && node.name) {
         return `<${String(node.name)}>`;
     }
-    const text = getNodeText(node).trim().replace(/\s+/g, ' ');
+    const text = mdastToText(node).trim().replace(/\s+/g, ' ');
     const preview = text.length > 40 ? `${text.slice(0, 40)}…` : text;
     return preview ? `Text ("${preview}")` : `A ${node.type} node`;
 };
@@ -23,7 +18,7 @@ const parseListItems = (list) => list.children.map((item) => {
     const nestedList = item.children.find(isList);
     const name = item.children
         .filter((child) => !isList(child))
-        .map(getNodeText)
+        .map(mdastToText)
         .join('')
         .trim();
     return {

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)