@mintlify/common 1.0.42 → 1.0.44

package/dist/mdx/getMDXOptions.d.ts

@@ -0,0 +1,3 @@
+export declare const getMDXOptions: ({ data }: {
+    data?: Record<string, unknown> | undefined;
+}) => SerializeOptions;

package/dist/mdx/getMDXOptions.js

@@ -0,0 +1,32 @@
+import { rehypeCodeBlocks, rehypeLayouts, rehypeListRoles, rehypeMdxExtractExamples, rehypeMdxInjectEndpoint, rehypeRawComponents, rehypeZoomImages, remarkFrames, remarkMdxInjectRequire, remarkMdxInjectSnippets, remarkMdxRemoveJs, remarkMdxWrapDangerouslySetInnerHtml, remarkRemoveImports, remarkTableOfContents, } from './plugins/index.js';
+import rehypeMdxRemoveUnknownJsx from './plugins/rehype/rehypeMdxRemoveUnknownJsx/index.js';
+export const getMDXOptions = ({ data }) => {
+    return {
+        remarkPlugins: [
+            [remarkMdxInjectRequire, data === null || data === void 0 ? void 0 : data.subdomain],
+            [remarkMdxInjectSnippets, data === null || data === void 0 ? void 0 : data.snippetTreeMap],
+            remarkMdxRemoveJs,
+            remarkFrames,
+            remarkTableOfContents,
+            remarkRemoveImports,
+            remarkMdxWrapDangerouslySetInnerHtml,
+        ],
+        rehypePlugins: [
+            [
+                rehypeMdxRemoveUnknownJsx,
+                {
+                    allowedComponents: data === null || data === void 0 ? void 0 : data.allowedComponents,
+                },
+            ],
+            rehypeCodeBlocks,
+            rehypeListRoles,
+            rehypeMdxExtractExamples,
+            [rehypeMdxInjectEndpoint, data === null || data === void 0 ? void 0 : data.pageMetadata, data === null || data === void 0 ? void 0 : data.mintConfig],
+            rehypeRawComponents,
+            rehypeLayouts,
+            rehypeZoomImages,
+        ],
+        format: 'mdx',
+        useDynamicImport: true,
+    };
+};

package/dist/mdx/index.d.ts

@@ -1,3 +1,6 @@
 export * from './remark.js';
 export * from './snippets/index.js';
 export * from './utils.js';
+export * from './plugins/index.js';
+export * from './lib/index.js';
+export * from './getMDXOptions.js';

package/dist/mdx/index.js

@@ -1,3 +1,6 @@
 export * from './remark.js';
 export * from './snippets/index.js';
 export * from './utils.js';
+export * from './plugins/index.js';
+export * from './lib/index.js';
+export * from './getMDXOptions.js';

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

@@ -0,0 +1,2 @@
+import type { Node } from 'unist';
+export declare const findExportedNodes: (tree: Node, ...type: string[]) => string[];

package/dist/mdx/lib/findExportedNode.js

@@ -0,0 +1,30 @@
+import { visit } from 'unist-util-visit';
+import { nodeIncludesExport } from '../snippets/index.js';
+import { isExportNode } from '../utils.js';
+export const findExportedNodes = (tree, ...type) => {
+    const exports = [];
+    visit(tree, nodeIncludesExport, (node) => {
+        var _a;
+        const body = node.data.estree.body;
+        for (const bodyChild of body) {
+            if (isExportNode(bodyChild)) {
+                if (bodyChild.type === 'ExportAllDeclaration')
+                    continue;
+                if (((_a = bodyChild.declaration) === null || _a === void 0 ? void 0 : _a.type) !== 'VariableDeclaration')
+                    continue;
+                const declaration = bodyChild.declaration.declarations[0];
+                if (declaration == undefined)
+                    continue;
+                const init = declaration.init;
+                if (init == null)
+                    continue;
+                if (!type.includes(init.type))
+                    continue;
+                if (declaration.id.type !== 'Identifier')
+                    continue;
+                exports.push(declaration.id.name);
+            }
+        }
+    });
+    return exports;
+};

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

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

package/dist/mdx/lib/index.js

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

package/dist/mdx/lib/mdx-utils.d.ts

@@ -0,0 +1,8 @@
+import { MdxJsxAttribute, MdxJsxExpressionAttribute, MdxJsxFlowElementHast } from 'mdast-util-mdx-jsx';
+import { Node } from 'unist';
+export declare const isMdxJsxFlowElementHast: (node: Node) => node is MdxJsxFlowElementHast;
+export declare const isMdxJsxAttribute: (attribute: MdxJsxAttribute | MdxJsxExpressionAttribute) => attribute is MdxJsxAttribute;
+export declare const paramFieldLocations: readonly ["body", "query", "auth", "cookie", "path", "header"];
+export type ParamFieldLocation = (typeof paramFieldLocations)[number];
+export type FieldLocation = ParamFieldLocation | 'response';
+export declare const isParamFieldLocation: (str: string | undefined) => str is "query" | "header" | "cookie" | "path" | "body" | "auth";

package/dist/mdx/lib/mdx-utils.js

@@ -0,0 +1,8 @@
+export const isMdxJsxFlowElementHast = (node) => {
+    return node.type === 'mdxJsxFlowElement';
+};
+export const isMdxJsxAttribute = (attribute) => attribute.type === 'mdxJsxAttribute';
+export const paramFieldLocations = ['body', 'query', 'auth', 'cookie', 'path', 'header'];
+export const isParamFieldLocation = (str) => {
+    return paramFieldLocations.includes(str);
+};

package/dist/mdx/lib/remark-utils.d.ts

@@ -0,0 +1,13 @@
+export function addImportString(tree: any, jsx: any): void;
+export function addImport(tree: any, mod: any, name: any): string;
+export function addDefaultImport(tree: any, mod: any, name: any): string;
+export function addExport(tree: any, name: any, value: any): void;
+export function normalizeTokens(tokens: any): any[][];
+export function simplifyToken(token: any): string | any[];
+export function createMdxJsxAttribute(key: any, value: any): {
+    type: string;
+    name: any;
+    value: any;
+};
+export function toMdxJsxFlowElement(input: any): import("mdast").Content | undefined;
+export function getEsmNode(input: any): import("mdast").Content | undefined;

package/dist/mdx/lib/remark-utils.js

@@ -0,0 +1,136 @@
+import * as acorn from 'acorn';
+import { fromMarkdown } from 'mdast-util-from-markdown';
+import { mdxJsxFromMarkdown } from 'mdast-util-mdx-jsx';
+import { mdxjsEsmFromMarkdown } from 'mdast-util-mdxjs-esm';
+import { mdxJsx } from 'micromark-extension-mdx-jsx';
+import { mdxjsEsm } from 'micromark-extension-mdxjs-esm';
+export const createMdxJsxAttribute = (key, value) => {
+    return {
+        type: 'mdxJsxAttribute',
+        name: key,
+        value,
+    };
+};
+export const toMdxJsxFlowElement = (input) => {
+    const tree = fromMarkdown(input, {
+        extensions: [mdxJsx({ acorn: acorn, addResult: true })],
+        mdastExtensions: [mdxJsxFromMarkdown()],
+    });
+    return tree.children[0];
+};
+export const getEsmNode = (input) => {
+    const tree = fromMarkdown(input, {
+        extensions: [mdxjsEsm({ acorn, addResult: true })],
+        mdastExtensions: [mdxjsEsmFromMarkdown],
+    });
+    return tree.children[0];
+};
+export function addImportString(tree, jsx) {
+    tree.children.unshift(getEsmNode(jsx));
+}
+export function addImport(tree, mod, name) {
+    const jsx = `import { ${name} as _${name} } from '${mod}'`;
+    tree.children.unshift(getEsmNode(jsx));
+    return `_${name}`;
+}
+export function addDefaultImport(tree, mod, name) {
+    const jsx = `import _${name} from '${mod}'`;
+    tree.children.unshift(getEsmNode(jsx));
+    return `_${name}`;
+}
+export function addExport(tree, name, value) {
+    const jsx = `export const ${name} = ${JSON.stringify(value)}`;
+    tree.children.push(getEsmNode(jsx));
+}
+const newlineRe = /\r\n|\r|\n/;
+// Empty lines need to contain a single empty token, denoted with { empty: true }
+function normalizeEmptyLines(line) {
+    if (line.length === 0) {
+        line.push({
+            types: ['plain'],
+            content: '',
+            empty: true,
+        });
+    }
+    else if (line.length === 1 && line[0].content === '') {
+        line[0].empty = true;
+    }
+}
+function appendTypes(types, add) {
+    const typesSize = types.length;
+    if (typesSize > 0 && types[typesSize - 1] === add) {
+        return types;
+    }
+    return types.concat(add);
+}
+// Takes an array of Prism's tokens and groups them by line, turning plain
+// strings into tokens as well. Tokens can become recursive in some cases,
+// which means that their types are concatenated. Plain-string tokens however
+// are always of type "plain".
+// This is not recursive to avoid exceeding the call-stack limit, since it's unclear
+// how nested Prism's tokens can become
+export function normalizeTokens(tokens) {
+    const typeArrStack = [[]];
+    const tokenArrStack = [tokens];
+    const tokenArrIndexStack = [0];
+    const tokenArrSizeStack = [tokens.length];
+    let i = 0;
+    let stackIndex = 0;
+    let currentLine = [];
+    const acc = [currentLine];
+    while (stackIndex > -1) {
+        while ((i = tokenArrIndexStack[stackIndex]++) < tokenArrSizeStack[stackIndex]) {
+            let content;
+            let types = typeArrStack[stackIndex];
+            const tokenArr = tokenArrStack[stackIndex];
+            const token = tokenArr[i];
+            // Determine content and append type to types if necessary
+            if (typeof token === 'string') {
+                types = stackIndex > 0 ? types : ['plain'];
+                content = token;
+            }
+            else {
+                types = appendTypes(types, token.type);
+                if (token.alias) {
+                    types = appendTypes(types, token.alias);
+                }
+                content = token.content;
+            }
+            // If token.content is an array, increase the stack depth and repeat this while-loop
+            if (typeof content !== 'string') {
+                stackIndex++;
+                typeArrStack.push(types);
+                tokenArrStack.push(content);
+                tokenArrIndexStack.push(0);
+                tokenArrSizeStack.push(content.length);
+                continue;
+            }
+            // Split by newlines
+            const splitByNewlines = content.split(newlineRe);
+            const newlineCount = splitByNewlines.length;
+            currentLine.push({ types, content: splitByNewlines[0] });
+            // Create a new line for each string on a new line
+            for (let i = 1; i < newlineCount; i++) {
+                normalizeEmptyLines(currentLine);
+                acc.push((currentLine = []));
+                currentLine.push({ types, content: splitByNewlines[i] });
+            }
+        }
+        // Decreate the stack depth
+        stackIndex--;
+        typeArrStack.pop();
+        tokenArrStack.pop();
+        tokenArrIndexStack.pop();
+        tokenArrSizeStack.pop();
+    }
+    normalizeEmptyLines(currentLine);
+    return acc;
+}
+export function simplifyToken(token) {
+    if (typeof token === 'string')
+        return token;
+    return [
+        token.type,
+        Array.isArray(token.content) ? token.content.map(simplifyToken) : token.content,
+    ];
+}

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

@@ -0,0 +1,2 @@
+export * from './rehype/index.js';
+export * from './remark/index.js';

package/dist/mdx/plugins/index.js

@@ -0,0 +1,2 @@
+export * from './rehype/index.js';
+export * from './remark/index.js';

package/dist/mdx/plugins/rehype/index.d.ts

@@ -0,0 +1,8 @@
+export * from './rehypeMdxInjectEndpoint/index.js';
+export * from './rehypeMdxRemoveUnknownJsx/index.js';
+export * from './rehypeMdxExtractExamples.js';
+export * from './rehypeCodeBlocks.js';
+export * from './rehypeLayouts.js';
+export * from './rehypeListRoles.js';
+export * from './rehypeRawComponents.js';
+export * from './rehypeZoomImages.js';

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

@@ -0,0 +1,8 @@
+export * from './rehypeMdxInjectEndpoint/index.js';
+export * from './rehypeMdxRemoveUnknownJsx/index.js';
+export * from './rehypeMdxExtractExamples.js';
+export * from './rehypeCodeBlocks.js';
+export * from './rehypeLayouts.js';
+export * from './rehypeListRoles.js';
+export * from './rehypeRawComponents.js';
+export * from './rehypeZoomImages.js';

package/dist/mdx/plugins/rehype/rehypeCodeBlocks.d.ts

@@ -0,0 +1,4 @@
+import type { Parent } from 'unist';
+declare function addCodeBlocks<T extends Parent>(tree: T): void;
+export declare function rehypeCodeBlocks(): typeof addCodeBlocks;
+export {};

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

@@ -0,0 +1,44 @@
+import { visit } from 'unist-util-visit';
+const exampleNames = ['RequestExample', 'ResponseExample'];
+const flowElementType = 'mdxJsxFlowElement';
+function isElement(node, key = 'type', element = 'element') {
+    return node != undefined && node[key] === element;
+}
+function addCodeBlocks(tree) {
+    const preTree = { children: [] };
+    visit(tree, (node, i, parent) => {
+        var _a, _b;
+        if (parent == null || i == null || !isElement(node) || !isElement(node, 'tagName', 'pre')) {
+            return;
+        }
+        const code = node.children[0];
+        if (!isElement(code, 'tagName', 'code'))
+            return;
+        let filename = undefined;
+        const isFlowElement = isElement(parent, 'type', flowElementType);
+        const parentName = isFlowElement ? parent.name : undefined;
+        if (parentName && exampleNames.includes(parentName)) {
+            const parentType = parentName.slice(0, -7);
+            filename = i === 0 ? parentType : `${parentType} ${i + 1}`;
+            if (!((_a = code.data) === null || _a === void 0 ? void 0 : _a.meta)) {
+                code.data = Object.assign(Object.assign({}, code.data), { meta: filename });
+            }
+        }
+        if (((_b = code.data) === null || _b === void 0 ? void 0 : _b.meta) && typeof code.data.meta === 'string') {
+            filename = code.data.meta;
+        }
+        const wrap = {
+            type: flowElementType,
+            name: 'CodeBlock',
+            attributes: [{ type: 'mdxJsxAttribute', name: 'filename', value: filename !== null && filename !== void 0 ? filename : '' }],
+            data: { _mdxExplicitJsx: true },
+            children: [],
+        };
+        wrap.children = [node];
+        parent.children[i] = wrap;
+    });
+    tree.children = [...preTree.children, ...tree.children];
+}
+export function rehypeCodeBlocks() {
+    return addCodeBlocks;
+}

package/dist/mdx/plugins/rehype/rehypeLayouts.d.ts

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

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

@@ -0,0 +1,133 @@
+export const rehypeLayouts = () => {
+    return (tree) => {
+        tree.children.push({
+            type: 'mdxjsEsm',
+            value: `export default (props) => <MDXContentController {...props} tableOfContents={tableOfContents} userDefinedExamples={userDefinedExamples} endpoint={endpoint} pageMetadata={pageMetadata}>{props.children}</MDXContentController>`,
+            data: {
+                estree: {
+                    type: 'Program',
+                    sourceType: 'module',
+                    body: [
+                        {
+                            type: 'ExportDefaultDeclaration',
+                            declaration: {
+                                type: 'ArrowFunctionExpression',
+                                async: false,
+                                expression: true,
+                                generator: false,
+                                id: null,
+                                body: {
+                                    type: 'JSXElement',
+                                    children: [
+                                        {
+                                            type: 'JSXExpressionContainer',
+                                            expression: {
+                                                type: 'MemberExpression',
+                                                computed: false,
+                                                optional: false,
+                                                object: {
+                                                    name: 'props',
+                                                    type: 'Identifier',
+                                                },
+                                                property: {
+                                                    name: 'children',
+                                                    type: 'Identifier',
+                                                },
+                                            },
+                                        },
+                                    ],
+                                    closingElement: {
+                                        type: 'JSXClosingElement',
+                                        name: {
+                                            type: 'JSXIdentifier',
+                                            name: 'MDXContentController',
+                                        },
+                                    },
+                                    openingElement: {
+                                        type: 'JSXOpeningElement',
+                                        selfClosing: false,
+                                        name: {
+                                            type: 'JSXIdentifier',
+                                            name: 'MDXContentController',
+                                        },
+                                        attributes: [
+                                            {
+                                                type: 'JSXSpreadAttribute',
+                                                argument: {
+                                                    type: 'Identifier',
+                                                    name: 'props',
+                                                },
+                                            },
+                                            {
+                                                type: 'JSXAttribute',
+                                                name: {
+                                                    type: 'JSXIdentifier',
+                                                    name: 'tableOfContents',
+                                                },
+                                                value: {
+                                                    type: 'JSXExpressionContainer',
+                                                    expression: {
+                                                        type: 'Identifier',
+                                                        name: 'tableOfContents',
+                                                    },
+                                                },
+                                            },
+                                            {
+                                                type: 'JSXAttribute',
+                                                name: {
+                                                    type: 'JSXIdentifier',
+                                                    name: 'userDefinedExamples',
+                                                },
+                                                value: {
+                                                    type: 'JSXExpressionContainer',
+                                                    expression: {
+                                                        type: 'Identifier',
+                                                        name: 'userDefinedExamples',
+                                                    },
+                                                },
+                                            },
+                                            {
+                                                type: 'JSXAttribute',
+                                                name: {
+                                                    type: 'JSXIdentifier',
+                                                    name: 'endpoint',
+                                                },
+                                                value: {
+                                                    type: 'JSXExpressionContainer',
+                                                    expression: {
+                                                        type: 'Identifier',
+                                                        name: 'endpoint',
+                                                    },
+                                                },
+                                            },
+                                            {
+                                                type: 'JSXAttribute',
+                                                name: {
+                                                    type: 'JSXIdentifier',
+                                                    name: 'pageMetadata',
+                                                },
+                                                value: {
+                                                    type: 'JSXExpressionContainer',
+                                                    expression: {
+                                                        type: 'Identifier',
+                                                        name: 'pageMetadata',
+                                                    },
+                                                },
+                                            },
+                                        ],
+                                    },
+                                },
+                                params: [
+                                    {
+                                        type: 'Identifier',
+                                        name: 'props',
+                                    },
+                                ],
+                            },
+                        },
+                    ],
+                },
+            },
+        });
+    };
+};

package/dist/mdx/plugins/rehype/rehypeListRoles.d.ts

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

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

@@ -0,0 +1,10 @@
+import { visit } from 'unist-util-visit';
+export const rehypeListRoles = () => {
+    return (tree) => {
+        visit(tree, 'element', (element) => {
+            if (['ol', 'ul'].includes(element.tagName)) {
+                element.properties.role = 'list';
+            }
+        });
+    };
+};

package/dist/mdx/plugins/rehype/rehypeMdxExtractExamples.d.ts

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

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

@@ -0,0 +1,64 @@
+import { toHtml } from 'hast-util-to-html';
+import { visit } from 'unist-util-visit';
+import { addExport, isMdxJsxFlowElementHast } from '../../lib/index.js';
+const langFilename = (className) => {
+    switch (className) {
+        case 'language-shell':
+            return 'Bash';
+        case 'language-json':
+            return 'JSON';
+        case 'language-js':
+            return 'JavaScript';
+        default:
+            const language = className.substring(9);
+            return language.charAt(0).toUpperCase() + language.slice(1);
+    }
+};
+export const rehypeMdxExtractExamples = () => {
+    return (tree) => {
+        let request;
+        let response;
+        visit(tree, isMdxJsxFlowElementHast, (node, i, parent) => {
+            if (node.name === 'RequestExample') {
+                request = request !== null && request !== void 0 ? request : {
+                    type: node.name,
+                    children: parseChildren(node),
+                };
+                if (parent && i !== null)
+                    parent.children.splice(i, 1);
+            }
+            else if (node.name === 'ResponseExample') {
+                response = response !== null && response !== void 0 ? response : {
+                    type: node.name,
+                    children: parseChildren(node),
+                };
+                if (parent && i !== null)
+                    parent.children.splice(i, 1);
+            }
+        });
+        addExport(tree, 'userDefinedExamples', { request, response });
+        return tree;
+    };
+};
+const parseChildren = (node) => {
+    return node.children.filter(isMdxJsxFlowElementHast).flatMap((child) => {
+        var _a, _b, _c;
+        const preComponent = child.children[0];
+        if ((preComponent === null || preComponent === void 0 ? void 0 : preComponent.type) !== 'element')
+            return [];
+        const html = toHtml(preComponent);
+        let filename = Array.isArray((_a = preComponent.properties) === null || _a === void 0 ? void 0 : _a.className) &&
+            typeof ((_b = preComponent.properties) === null || _b === void 0 ? void 0 : _b.className[0]) === 'string'
+            ? langFilename(preComponent.properties.className[0])
+            : '';
+        if ('attributes' in child && typeof ((_c = child.attributes[0]) === null || _c === void 0 ? void 0 : _c.value) === 'string') {
+            filename = child.attributes[0].value;
+        }
+        return [
+            {
+                filename,
+                html,
+            },
+        ];
+    });
+};

package/dist/mdx/plugins/rehype/rehypeMdxInjectEndpoint/findParentSchema.d.ts

@@ -0,0 +1,3 @@
+import { DataSchema } from '@mintlify/validation';
+import type { Node } from 'unist';
+export declare const findParentSchema: (tagName: string, parents: Node[], nodeToSchema: Map<Node, DataSchema>) => DataSchema | undefined;

package/dist/mdx/plugins/rehype/rehypeMdxInjectEndpoint/findParentSchema.js

@@ -0,0 +1,9 @@
+export const findParentSchema = (tagName, parents, nodeToSchema) => {
+    // find the nearest parent node that has an associated DataSchema
+    const parentField = parents.findLast((node) => nodeToSchema.has(node));
+    // we only want parents that have the same tag name (e.g. ParamField)
+    if (parentField === undefined || parentField.name !== tagName) {
+        return undefined;
+    }
+    return nodeToSchema.get(parentField);
+};

package/dist/mdx/plugins/rehype/rehypeMdxInjectEndpoint/index.d.ts

@@ -0,0 +1,3 @@
+import { MintConfig } from '@mintlify/models';
+import type { Node } from 'unist';
+export declare const rehypeMdxInjectEndpoint: (metadata: unknown, config: MintConfig | undefined) => <T extends Node<import("unist").Data>>(tree: T) => T | undefined;