@mintlify/common 1.0.42 → 1.0.44

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

@@ -0,0 +1,26 @@
+import { removePosition } from 'unist-util-remove-position';
+import { visit, SKIP } from 'unist-util-visit';
+export const remarkMdxInjectSnippets = (snippetTreeMap) => {
+    return (tree, file) => {
+        visit(tree, (node, index, parent) => {
+            if (parent && index !== null && node.type === 'mdxJsxFlowElement') {
+                const mdxJsxFlowElement = node;
+                if (mdxJsxFlowElement.name === 'Snippet') {
+                    const fileAttr = mdxJsxFlowElement.attributes.find((attr) => attr.type === 'mdxJsxAttribute' && attr.name === 'file');
+                    const name = fileAttr === null || fileAttr === void 0 ? void 0 : fileAttr.value;
+                    if (typeof name === 'string') {
+                        const snippet = snippetTreeMap[name];
+                        if (snippet) {
+                            const fragment = removePosition(structuredClone(snippet));
+                            parent.children.splice(index, 1, ...fragment.children);
+                            return [SKIP, index];
+                        }
+                        else {
+                            file.message('Cannot expand missing snippet `' + name + '`', node, 'remark-mdx-inject-snippets');
+                        }
+                    }
+                }
+            }
+        });
+    };
+};

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

@@ -0,0 +1,2 @@
+import type { Node } from 'unist';
+export declare const remarkMdxRemoveJs: () => (tree: Node) => void;

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

@@ -0,0 +1,20 @@
+import { remove } from 'unist-util-remove';
+import { findExportedNodes } from '../../../lib/index.js';
+import { estreeIsProgram } from '../../../utils.js';
+export const remarkMdxRemoveJs = () => (tree) => {
+    const exportedVariables = findExportedNodes(tree, 'Literal', 'JSXElement');
+    remove(tree, (node) => {
+        if (!nodeIsMdxFlowExpression(node) || !estreeIsProgram(node))
+            return false;
+        if (node.data.estree.body[0] == undefined || node.data.estree.body.length > 1)
+            return false;
+        if (node.data.estree.body[0].type !== 'ExpressionStatement')
+            return false;
+        if (node.data.estree.body[0].expression.type !== 'Identifier')
+            return false;
+        if (exportedVariables.includes(node.data.estree.body[0].expression.name))
+            return false;
+        return true;
+    });
+};
+const nodeIsMdxFlowExpression = (node) => node.type === 'mdxFlowExpression';

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

@@ -0,0 +1,2 @@
+import type { Parent } from 'unist';
+export declare const remarkMdxWrapDangerouslySetInnerHtml: () => (tree: Parent) => void;

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

@@ -0,0 +1,28 @@
+import { visit } from 'unist-util-visit';
+export const remarkMdxWrapDangerouslySetInnerHtml = () => {
+    return (tree) => {
+        visit(tree, (node, i, parent) => {
+            if (node.type === 'mdxJsxFlowElement') {
+                const mdxJsxFlowElement = node;
+                const attributesExist = mdxJsxFlowElement.attributes.length >= 1;
+                if (mdxJsxFlowElement.name === 'div' && attributesExist) {
+                    const dangerouslySetInnerHTML = mdxJsxFlowElement.attributes.find((attr) => attr.type === 'mdxJsxAttribute' && attr.name === 'dangerouslySetInnerHTML');
+                    if (dangerouslySetInnerHTML &&
+                        dangerouslySetInnerHTML.value &&
+                        typeof dangerouslySetInnerHTML.value === 'object' &&
+                        dangerouslySetInnerHTML.value.value.includes('quartoRawHtml')) {
+                        const wrap = {
+                            type: 'mdxJsxFlowElement',
+                            name: 'DynamicCustomComponent',
+                            attributes: [],
+                            data: { _mdxExplicitJsx: true },
+                            children: [node],
+                        };
+                        if (parent && i)
+                            parent.children[i] = wrap;
+                    }
+                }
+            }
+        });
+    };
+};

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

@@ -0,0 +1,2 @@
+import type { Node } from 'unist';
+export declare const remarkRemoveImports: () => <T extends Node<import("unist").Data>>(tree: T) => T;

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

@@ -0,0 +1,11 @@
+import { remove } from 'unist-util-remove';
+export const remarkRemoveImports = () => (tree) => {
+    remove(tree, (node) => {
+        if (node.type === 'mdxjsEsm') {
+            const mdxjsEsm = node;
+            return mdxjsEsm.value.startsWith('import');
+        }
+        return false;
+    });
+    return tree;
+};

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

@@ -0,0 +1 @@
+export function remarkTableOfContents(): (tree: any) => void;

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

@@ -0,0 +1,57 @@
+import { slugifyWithCounter } from '@sindresorhus/slugify';
+import { addExport, createMdxJsxAttribute } from '../../lib/remark-utils.js';
+const getTOCTitle = (node, i = 1, a = []) => {
+    var _a, _b;
+    if ((node.type === 'text' &&
+        (((_a = a[i - 1]) === null || _a === void 0 ? void 0 : _a.type) !== 'mdxJsxFlowElement' || !((_b = a[i - 1]) === null || _b === void 0 ? void 0 : _b.value.startsWith('<small')))) ||
+        node.type === 'inlineCode') {
+        return node.value;
+    }
+    if (node.children) {
+        let title = '';
+        node.children.forEach((node, i, a) => {
+            title += getTOCTitle(node, i, a);
+        });
+        return title;
+    }
+    return '';
+};
+export const remarkTableOfContents = () => {
+    // slugifyWithCounter adds a counter (eg. slug, slug-2, slug-3) to the end of the slug if the header
+    // already exists. No counter is added for the first occurence.
+    const slugify = slugifyWithCounter();
+    return (tree) => {
+        const contents = [];
+        let hasTopLayer = false;
+        for (let nodeIndex = 0; nodeIndex < tree.children.length; nodeIndex++) {
+            let node = tree.children[nodeIndex];
+            if ((node.type === 'heading' && [1, 2, 3, 4].includes(node.depth)) ||
+                (node.type === 'mdxJsxFlowElement' && ['h1', 'h2', 'h3', 'h4'].includes(node.name))) {
+                let level = node.depth ? node.depth : node.name.split('')[1];
+                let title = getTOCTitle(node);
+                const slug = slugify(title, { decamelize: false });
+                let mdxJsxAttributes = [
+                    createMdxJsxAttribute('level', level),
+                    createMdxJsxAttribute('id', slug),
+                ];
+                node.attributes = mdxJsxAttributes;
+                node.type = 'mdxJsxFlowElement';
+                node.name = 'Heading';
+                const depth = node.depth;
+                if (level <= 2) {
+                    hasTopLayer = true;
+                    contents.push({ title, slug, depth, children: [] });
+                }
+                else {
+                    // Account if there is no first layer
+                    let arrToPushInto = contents;
+                    if (hasTopLayer) {
+                        arrToPushInto = contents[contents.length - 1].children;
+                    }
+                    arrToPushInto.push({ title, slug, depth, children: [] });
+                }
+            }
+        }
+        addExport(tree, 'tableOfContents', contents);
+    };
+};

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

@@ -7,11 +7,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+import { walk } from 'estree-walker';
 import matter from 'gray-matter';
 import { remark } from 'remark';
 import { visit } from 'unist-util-visit';
 import { coreRemarkMdxPlugins, getAST } from '../../remark.js';
-import { isMdxJsxFlowElement } from '../../utils.js';
+import { createUniqueVariableName, isMdxJsxFlowElement } from '../../utils.js';
 /**
  *
  * @param content The content to inject into
@@ -28,17 +29,73 @@ export const resolveComponentWithContent = (content, componentName, contentToInj
     return String(convertedContent);
 });
 /**
- * Everywhere where there is a component with the name `componentName`, replace it with the `treeToInject`
+ * Everywhere where there is a component with the name `componentName`, replace it with the `treeToInject`.
+ * New variables are also exported to be used for the variables. Additional mutations are made to support duplicated snippets
+ *
  * This function is used to resolve default imports
  * @param treeToInject
  * @param componentName
  * @returns
  */
 const remarkMdxResolveComponentWithContent = (treeToInject, componentName) => () => (tree) => {
+    let id = 0;
     visit(tree, isMdxJsxFlowElement, (node, i, parent) => {
+        var _a;
         if (node.name === componentName && parent && i != null) {
+            // Creating clone to restore treeToInject with default values at the end of operations
+            const treeToInjectClone = structuredClone(treeToInject);
             node.name = null;
-            parent.children.splice(i, 1, ...treeToInject.children);
+            const { variableDeclarationNodes, snippetNodesToInject } = replaceVariablesWithProps(node, treeToInject, id);
+            parent.children.splice(i, 1, ...snippetNodesToInject);
+            tree.children.splice(((_a = tree.children[0]) === null || _a === void 0 ? void 0 : _a.type) === 'yaml' ? 1 : 0, 0, ...variableDeclarationNodes);
+            treeToInject = treeToInjectClone;
+            id += 1;
+        }
+    });
+};
+/**
+ * Replace the variables with value provided from the props by defining the variable before the snippet
+ * Also prevents duplicates by attaching a unique identifier to every variable (var to var_1)
+ *
+ * @param node
+ * @param treeToInject
+ * @param id a unique ID used to target the variable to prevent duplicated variable declarations
+ * @returns
+ */
+const replaceVariablesWithProps = (node, treeToInject, id) => {
+    const variablesMap = {};
+    visit(treeToInject, (node) => {
+        var _a;
+        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') {
+                        const 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' };
+                        jsNode.name = uniqueName;
+                    }
+                },
+            });
         }
     });
+    node.attributes.forEach((attribute) => {
+        if (attribute.type === 'mdxJsxAttribute' && attribute.value) {
+            variablesMap[createUniqueVariableName(attribute.name, id)] =
+                typeof attribute.value === 'string'
+                    ? { type: 'string', value: attribute.value }
+                    : { type: 'unknown', value: attribute.value.value };
+        }
+    });
+    const variableDeclarationNodes = [];
+    Object.entries(variablesMap).map(([variable, value]) => {
+        const statement = `export const ${variable} = ${value.type === 'string' ? `"${value.value}"` : value.value}`;
+        variableDeclarationNodes.push(...getAST(statement).children);
+    });
+    return {
+        variableDeclarationNodes,
+        snippetNodesToInject: treeToInject.children,
+    };
 };

package/dist/mdx/utils.d.ts

@@ -10,3 +10,4 @@ export declare const isImportDeclaration: (bodyChild: MdxNodeBodyChildType) => b
 export declare const isExport: (type: string) => boolean;
 export declare const isExportNode: (bodyChild: MdxNodeBodyChildType) => bodyChild is ExportNamedDeclaration | ExportDefaultDeclaration | ExportAllDeclaration;
 export declare const isMdxJsxFlowElement: (node: Node) => node is MdxJsxFlowElement;
+export declare const createUniqueVariableName: (variableName: string, id: number) => string;

package/dist/mdx/utils.js

@@ -14,3 +14,4 @@ export const isExport = (type) => [
 ].includes(type);
 export const isExportNode = (bodyChild) => isExport(bodyChild.type);
 export const isMdxJsxFlowElement = (node) => node.type === 'mdxJsxFlowElement';
+export const createUniqueVariableName = (variableName, id) => `${variableName}_${id}`;