@mintlify/common 1.0.41 → 1.0.43

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/topologicalSort.d.ts

@@ -0,0 +1,4 @@
+export type Graph = {
+    [key: string]: string[];
+};
+export declare function topologicalSort(graph: Graph): string[];

package/dist/topologicalSort.js

@@ -0,0 +1,19 @@
+export function topologicalSort(graph) {
+    const visited = new Set();
+    const stack = [];
+    function dfs(node) {
+        visited.add(node);
+        for (const neighbor of graph[node] || []) {
+            if (!visited.has(neighbor)) {
+                dfs(neighbor);
+            }
+        }
+        stack.push(node);
+    }
+    for (const node in graph) {
+        if (!visited.has(node)) {
+            dfs(node);
+        }
+    }
+    return stack.reverse();
+}