@mintlify/common 1.0.41 → 1.0.43

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

@@ -0,0 +1,93 @@
+import { generateExampleFromSchema } from '@mintlify/validation';
+import { visitParents } from 'unist-util-visit-parents';
+import { isMdxJsxFlowElementHast } from '../../../lib/mdx-utils.js';
+import { addExport } from '../../../lib/remark-utils.js';
+import { findParentSchema } from './findParentSchema.js';
+import { insertSchema } from './insertSchema.js';
+import { parseApiString, parseAuthMethod, parseField } from './parsers.js';
+export const rehypeMdxInjectEndpoint = (metadata, config) => {
+    return (tree) => {
+        var _a;
+        if (!(metadata &&
+            typeof metadata === 'object' &&
+            'api' in metadata &&
+            typeof metadata.api === 'string')) {
+            addExport(tree, 'endpoint', undefined);
+            return;
+        }
+        let parseResult = undefined;
+        try {
+            parseResult = parseApiString(metadata.api, config);
+        }
+        catch (_b) {
+            console.error(`error parsing api string: "${metadata.api}"`);
+            addExport(tree, 'endpoint', undefined);
+            return;
+        }
+        const { servers, path, method } = parseResult;
+        const authMethodString = 'authMethod' in metadata && typeof metadata.authMethod === 'string'
+            ? metadata.authMethod
+            : undefined;
+        const security = parseAuthMethod(authMethodString, config);
+        const endpoint = {
+            path,
+            servers,
+            method,
+            request: {
+                security,
+                parameters: {
+                    query: {},
+                    header: {},
+                    cookie: {},
+                    path: {},
+                },
+                body: {},
+            },
+            response: {},
+            deprecated: false,
+        };
+        const requestContentType = 'contentType' in metadata && typeof metadata.contentType === 'string'
+            ? metadata.contentType
+            : 'application/json';
+        const nodeToSchema = new Map();
+        visitParents(tree, isMdxJsxFlowElementHast, (node, parents) => {
+            if (node.name === 'Param' || node.name === 'ParamField' || node.name === 'ResponseField') {
+                const parentSchema = findParentSchema(node.name, parents, nodeToSchema);
+                // we only want ParamFields/ResponseFields that are nested in others of the same type, or at the top level
+                if (parentSchema === undefined && parents.length > 1) {
+                    console.error(`${node.name} tags must occur at the top level or inside another ${node.name} tag`);
+                    return 'skip';
+                }
+                const parsedParamField = parseField(node);
+                if (parsedParamField === undefined) {
+                    console.error('param field conversion failed');
+                    return 'skip';
+                }
+                const insertSuccessful = insertSchema({
+                    name: parsedParamField.name,
+                    location: parsedParamField.location,
+                    schema: parsedParamField.schema,
+                    deepestSchema: parsedParamField.deepestSchema,
+                    endpoint,
+                    node,
+                    parentSchema,
+                    nodeToSchema,
+                    requestContentType,
+                });
+                if (!insertSuccessful) {
+                    return 'skip';
+                }
+            }
+        });
+        const content = endpoint.request.body[requestContentType];
+        if (content) {
+            content.examples['example'] = { value: generateExampleFromSchema(content.schemaArray[0]) };
+        }
+        const response = (_a = endpoint.response['200']) === null || _a === void 0 ? void 0 : _a['application/json'];
+        if (response) {
+            response.examples['example'] = { value: generateExampleFromSchema(response.schemaArray[0]) };
+        }
+        addExport(tree, 'endpoint', endpoint);
+        return tree;
+    };
+};

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

@@ -0,0 +1,17 @@
+import { DataSchema, Endpoint } from '@mintlify/validation';
+import { MdxJsxFlowElementHast } from 'mdast-util-mdx-jsx';
+import type { Node } from 'unist';
+import { FieldLocation } from '../../../lib/mdx-utils.js';
+type InsertSchemaParams = {
+    location: FieldLocation;
+    name: string;
+    node: MdxJsxFlowElementHast;
+    schema: DataSchema;
+    deepestSchema: DataSchema;
+    parentSchema: DataSchema | undefined;
+    nodeToSchema: Map<Node, DataSchema>;
+    endpoint: Endpoint;
+    requestContentType: string;
+};
+export declare const insertSchema: ({ location, name, node, schema, deepestSchema, parentSchema, nodeToSchema, endpoint, requestContentType, }: InsertSchemaParams) => boolean;
+export {};

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

@@ -0,0 +1,83 @@
+export const insertSchema = ({ location, name, node, schema, deepestSchema, parentSchema, nodeToSchema, endpoint, requestContentType, }) => {
+    var _a, _b, _c;
+    if (parentSchema === undefined) {
+        switch (location) {
+            case 'body':
+                const bodyObjectSchema = (_a = endpoint.request.body[requestContentType]) === null || _a === void 0 ? void 0 : _a.schemaArray[0];
+                if (bodyObjectSchema) {
+                    bodyObjectSchema.properties[name] = [schema];
+                }
+                else {
+                    endpoint.request.body[requestContentType] = {
+                        schemaArray: [
+                            {
+                                type: 'object',
+                                properties: {
+                                    [name]: [schema],
+                                },
+                            },
+                        ],
+                        examples: {},
+                    };
+                }
+                break;
+            case 'response':
+                const responseObjectSchema = (_c = (_b = endpoint.response['200']) === null || _b === void 0 ? void 0 : _b['application/json']) === null || _c === void 0 ? void 0 : _c.schemaArray[0];
+                if (responseObjectSchema) {
+                    responseObjectSchema.properties[name] = [schema];
+                }
+                else {
+                    endpoint.response['200'] = {
+                        'application/json': {
+                            schemaArray: [
+                                {
+                                    type: 'object',
+                                    properties: {
+                                        [name]: [schema],
+                                    },
+                                },
+                            ],
+                            examples: {},
+                        },
+                    };
+                }
+                break;
+            case 'auth':
+                if (!endpoint.request.security[0]) {
+                    endpoint.request.security = [
+                        {
+                            title: 'Security',
+                            parameters: {
+                                cookie: {},
+                                header: { [name]: { type: 'apiKey' } },
+                                query: {},
+                            },
+                        },
+                    ];
+                }
+                else {
+                    endpoint.request.security[0].parameters.header[name] = { type: 'apiKey' };
+                }
+                break;
+            case 'cookie':
+            case 'header':
+            case 'path':
+            case 'query':
+                endpoint.request.parameters[location][name] = { schema: [schema] };
+                break;
+        }
+    }
+    else {
+        if (location === 'auth') {
+            console.error('complex types are not allowed in the auth section');
+            return false;
+        }
+        if (parentSchema.type !== 'object') {
+            console.error(`cannot add property "${name}" to non-object`);
+            return false;
+        }
+        parentSchema.properties[name] = [schema];
+    }
+    nodeToSchema.set(node, deepestSchema);
+    return true;
+};

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

@@ -0,0 +1,24 @@
+import { MintConfig } from '@mintlify/models';
+import { DataSchema, HttpMethod, SecurityOption, Server } from '@mintlify/validation';
+import { MdxJsxFlowElementHast } from 'mdast-util-mdx-jsx';
+import type { FieldLocation } from '../../../lib/mdx-utils.js';
+export declare const parseApiString: (apiString: string, config?: MintConfig) => {
+    servers?: Server[] | undefined;
+    path: string;
+    method: HttpMethod;
+};
+export declare const parseAuthMethod: (authMethodString: string | undefined, config?: MintConfig) => SecurityOption[];
+type ParseFieldType = {
+    location: FieldLocation;
+    name: string;
+    schema: DataSchema;
+    deepestSchema: DataSchema;
+};
+export declare const parseField: (node: MdxJsxFlowElementHast) => ParseFieldType | undefined;
+export declare const parseDescription: (node: MdxJsxFlowElementHast) => string | undefined;
+type ParseTypeStringType = {
+    schema: DataSchema;
+    deepestSchema: DataSchema;
+};
+export declare const parseTypeString: (typeString: string) => ParseTypeStringType;
+export {};

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

@@ -0,0 +1,251 @@
+import isAbsoluteUrl from 'is-absolute-url';
+import { getSecurityOptionsForAuthMethod } from '../../../../index.js';
+import { isMdxJsxAttribute, isParamFieldLocation } from '../../../lib/mdx-utils.js';
+export const parseApiString = (apiString, config) => {
+    const components = apiString.trim().split(/\s+/);
+    if (!components[0] || !components[1] || components.length > 2) {
+        throw new Error('improperly formatted api string');
+    }
+    const [upperMethod, endpointStr] = components;
+    const method = upperMethod.toLowerCase();
+    if (!['get', 'put', 'post', 'delete', 'patch', 'options', 'head', 'trace'].includes(method)) {
+        throw new Error('invalid http method');
+    }
+    const { origin, path } = parseEndpoint(endpointStr);
+    const servers = origin ? [{ url: origin }] : parseServers(config);
+    return {
+        path,
+        method: method,
+        servers,
+    };
+};
+const parseEndpoint = (endpoint) => {
+    if (!isAbsoluteUrl(endpoint)) {
+        return {
+            origin: undefined,
+            path: endpoint,
+        };
+    }
+    const url = new URL(endpoint);
+    return {
+        origin: decodeURI(url.origin),
+        path: decodeURI(url.pathname),
+    };
+};
+const parseServers = (config) => {
+    var _a;
+    const baseUrl = (_a = config === null || config === void 0 ? void 0 : config.api) === null || _a === void 0 ? void 0 : _a.baseUrl;
+    if (!baseUrl) {
+        return undefined;
+    }
+    if (typeof baseUrl === 'string') {
+        return [{ url: baseUrl }];
+    }
+    const servers = baseUrl.filter(Boolean).map((url) => ({ url }));
+    return servers.length > 0 ? servers : undefined;
+};
+export const parseAuthMethod = (authMethodString, config) => {
+    var _a, _b, _c, _d;
+    const method = authMethodString !== null && authMethodString !== void 0 ? authMethodString : (_b = (_a = config === null || config === void 0 ? void 0 : config.api) === null || _a === void 0 ? void 0 : _a.auth) === null || _b === void 0 ? void 0 : _b.method;
+    const name = (_d = (_c = config === null || config === void 0 ? void 0 : config.api) === null || _c === void 0 ? void 0 : _c.auth) === null || _d === void 0 ? void 0 : _d.name;
+    return getSecurityOptionsForAuthMethod(method, name);
+};
+export const parseField = (node) => {
+    let locationAndName;
+    let schemaInfo;
+    let required = undefined;
+    for (const { name: attrName, value } of node.attributes.filter(isMdxJsxAttribute)) {
+        if (node.name !== 'ResponseField' && isParamFieldLocation(attrName)) {
+            // if ParamField or Param, parameter name comes from the `body`, `header`, etc attribute
+            if (locationAndName) {
+                console.error('multiple location/name pairs specified');
+                return;
+            }
+            if (typeof value !== 'string') {
+                console.error(`invalid parameter name: "${value}"`);
+                return;
+            }
+            locationAndName = {
+                location: attrName,
+                name: value,
+            };
+        }
+        else if (node.name === 'ResponseField' && attrName === 'name') {
+            // if ResponseField, parameter name comes from the `name` attribute
+            if (locationAndName) {
+                console.error('multiple names specified');
+                return;
+            }
+            if (typeof value !== 'string') {
+                console.error(`invalid response field name: "${value}"`);
+                return;
+            }
+            locationAndName = {
+                location: 'response',
+                name: value,
+            };
+        }
+        else if (attrName === 'type') {
+            if (typeof value !== 'string') {
+                console.error(`invalid type string: "${value}"`);
+                return;
+            }
+            schemaInfo = parseTypeString(value);
+        }
+        else if (attrName === 'required') {
+            if (value === null || (typeof value === 'object' && value.value.trim() === 'true')) {
+                required = true;
+            }
+        }
+    }
+    if (locationAndName === undefined) {
+        console.error('no parameter name specified');
+        return;
+    }
+    if (schemaInfo === undefined) {
+        console.error(`no type specified for parameter "${locationAndName.name}"`);
+        return;
+    }
+    schemaInfo.schema.description = parseDescription(node);
+    schemaInfo.schema.required = required;
+    return Object.assign(Object.assign({}, locationAndName), schemaInfo);
+};
+export const parseDescription = (node) => {
+    const descriptionFragments = node.children.flatMap((child) => {
+        var _a;
+        if (child.type === 'text') {
+            return [child.value];
+        }
+        else if (child.type === 'element' &&
+            child.tagName === 'p' &&
+            ((_a = child.children[0]) === null || _a === void 0 ? void 0 : _a.type) === 'text') {
+            return [child.children[0].value];
+        }
+        return [];
+    });
+    return descriptionFragments.length > 0 ? descriptionFragments.join('\n') : undefined;
+};
+const typeStringToSchemaType = {
+    // string
+    str: 'string',
+    string: 'string',
+    date: 'string',
+    text: 'string',
+    url: 'string',
+    uuid: 'string',
+    hash: 'string',
+    bytes: 'string',
+    // integer
+    int: 'integer',
+    integer: 'integer',
+    // number
+    num: 'number',
+    number: 'number',
+    float: 'number',
+    decimal: 'number',
+    long: 'number',
+    double: 'number',
+    // boolean
+    bool: 'boolean',
+    boolean: 'boolean',
+    // object
+    obj: 'object',
+    object: 'object',
+    record: 'object',
+    dict: 'object',
+    dictionary: 'object',
+    map: 'object',
+    // array
+    arr: 'array',
+    array: 'array',
+    list: 'array',
+    // file
+    file: 'file',
+    // any
+    any: 'any',
+    json: 'any',
+    // null
+    null: 'null',
+};
+const genericStringRegex = /^(\w+)<(.*)>$/;
+export const parseTypeString = (typeString) => {
+    const lowerTypeString = typeString.toLowerCase();
+    const simpleSchemaType = typeStringToSchemaType[lowerTypeString];
+    // catch all standard type strings
+    if (simpleSchemaType) {
+        return generateSchemaWithTypeString(simpleSchemaType);
+    }
+    // catch type strings that end with []
+    if (lowerTypeString.endsWith('[]')) {
+        // recursively determine the type of the rest of the string
+        const subschemaInfo = parseTypeString(lowerTypeString.slice(0, lowerTypeString.length - 2));
+        return {
+            schema: {
+                type: 'array',
+                items: [subschemaInfo.schema],
+            },
+            deepestSchema: subschemaInfo.deepestSchema,
+        };
+    }
+    // catch type strings like foo<bar>
+    const regexMatch = genericStringRegex.exec(lowerTypeString);
+    if (regexMatch !== null) {
+        // unpack capture group 1 (foo) and 2 (bar)
+        const [_, superType, subType] = regexMatch;
+        if (superType && subType && typeStringToSchemaType[superType] === 'array') {
+            // catches type strings like array<bar>
+            // recursively determine the type of everything within the angle brackets
+            const subschemaInfo = parseTypeString(subType);
+            return {
+                schema: {
+                    type: 'array',
+                    items: [subschemaInfo.schema],
+                },
+                deepestSchema: subschemaInfo.deepestSchema,
+            };
+        }
+    }
+    // for any unrecognized typestring, default to object
+    return generateSchemaWithTypeString('object');
+};
+const generateSchemaWithTypeString = (type) => {
+    switch (type) {
+        case 'string':
+        case 'number':
+        case 'integer':
+        case 'boolean':
+        case 'file':
+        case 'null':
+        case 'any': {
+            const schema = { type };
+            return {
+                schema,
+                deepestSchema: schema,
+            };
+        }
+        case 'object': {
+            const schema = {
+                type: 'object',
+                properties: {},
+            };
+            return {
+                schema,
+                deepestSchema: schema,
+            };
+        }
+        case 'array': {
+            const itemsSchema = {
+                type: 'object',
+                properties: {},
+            };
+            const schema = {
+                type: 'array',
+                items: [itemsSchema],
+            };
+            return {
+                schema,
+                deepestSchema: itemsSchema,
+            };
+        }
+    }
+};

package/dist/mdx/plugins/rehype/rehypeMdxRemoveUnknownJsx/createCommentNode.d.ts

@@ -0,0 +1,15 @@
+export declare const createCommentNode: (componentName: string) => {
+    type: string;
+    value: string;
+    data: {
+        estree: {
+            type: string;
+            body: never[];
+            comments: {
+                type: string;
+                value: string;
+            }[];
+            sourceType: string;
+        };
+    };
+};

package/dist/mdx/plugins/rehype/rehypeMdxRemoveUnknownJsx/createCommentNode.js

@@ -0,0 +1,20 @@
+export const createCommentNode = (componentName) => {
+    const comment = ` Component ${componentName} does not exist. `;
+    return {
+        type: 'mdxFlowExpression',
+        value: `/* ${comment} */`,
+        data: {
+            estree: {
+                type: 'Program',
+                body: [],
+                comments: [
+                    {
+                        type: 'Block',
+                        value: comment,
+                    },
+                ],
+                sourceType: 'module',
+            },
+        },
+    };
+};

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

@@ -0,0 +1,5 @@
+import type { Node } from 'unist';
+declare const rehypeMdxRemoveUnknownJsx: (options: {
+    allowedComponents?: string[];
+}) => (tree: Node) => Node<import("unist").Data>;
+export default rehypeMdxRemoveUnknownJsx;

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

@@ -0,0 +1,18 @@
+import { map } from 'unist-util-map';
+import { findExportedNodes, isMdxJsxFlowElementHast } from '../../../lib/index.js';
+import { createCommentNode } from './createCommentNode.js';
+const rehypeMdxRemoveUnknownJsx = (options) => (tree) => {
+    const exportedComponentNames = findExportedNodes(tree, 'ArrowFunctionExpression');
+    return map(tree, (node) => {
+        var _a;
+        if (isMdxJsxFlowElementHast(node)) {
+            if (node.name &&
+                !((_a = options.allowedComponents) === null || _a === void 0 ? void 0 : _a.includes(node.name)) &&
+                !exportedComponentNames.includes(node.name)) {
+                return createCommentNode(node.name);
+            }
+        }
+        return node;
+    });
+};
+export default rehypeMdxRemoveUnknownJsx;

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

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

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

@@ -0,0 +1,12 @@
+import { fromHtml } from 'hast-util-from-html';
+import { visit } from 'unist-util-visit';
+export const rehypeRawComponents = () => {
+    return (tree) => {
+        visit(tree, 'raw', (raw, i, parent) => {
+            const rawAst = fromHtml(raw.value, { fragment: true });
+            if (parent && i) {
+                parent.children[i] = rawAst;
+            }
+        });
+    };
+};

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

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

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

@@ -0,0 +1,15 @@
+import { u } from 'unist-builder';
+import { visit } from 'unist-util-visit';
+export const rehypeZoomImages = () => (tree) => {
+    visit(tree, 'mdxJsxFlowElement', (node, index, parent) => {
+        const element = node;
+        if (element.name === 'img' || element.name === 'picture' || element.name === 'figure') {
+            const noZoom = element.attributes.find((attr) => 'name' in attr && attr.name === 'noZoom');
+            if (!noZoom && parent && index != null) {
+                parent.children.splice(index, 1, u('element', {
+                    tagName: 'ZoomImage',
+                }, [node]));
+            }
+        }
+    });
+};

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

@@ -0,0 +1,7 @@
+export * from './remarkMdxInjectRequire.js';
+export * from './remarkMdxInjectSnippets.js';
+export * from './remarkMdxWrapDangerouslySetInnerHtml.js';
+export * from './remarkFrames.js';
+export * from './remarkRemoveImports.js';
+export * from './remarkTableOfContents.js';
+export * from './remarkMdxRemoveJs/index.js';

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

@@ -0,0 +1,7 @@
+export * from './remarkMdxInjectRequire.js';
+export * from './remarkMdxInjectSnippets.js';
+export * from './remarkMdxWrapDangerouslySetInnerHtml.js';
+export * from './remarkFrames.js';
+export * from './remarkRemoveImports.js';
+export * from './remarkTableOfContents.js';
+export * from './remarkMdxRemoveJs/index.js';

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

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

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

@@ -0,0 +1,37 @@
+import { toMdxJsxFlowElement } from '../../lib/remark-utils.js';
+export const remarkFrames = () => {
+    return (tree) => {
+        let preTree = { children: [] };
+        tree.children = tree.children.map((node) => {
+            // Start of horizontal block: -- block
+            if (node.type === 'paragraph' &&
+                node.children.length === 1 &&
+                node.children[0].value === '-- block') {
+                node.type = 'jsx';
+                node.value = `<div className='grid md:grid-cols-2 md:gap-8'><div>`;
+            }
+            // Start a new column: -- column
+            if (node.type === 'paragraph' &&
+                node.children.length === 1 &&
+                node.children[0].value === '-- column') {
+                node.type = 'jsx';
+                node.value = `</div><div>`;
+            }
+            // End of horizontal block: -- /block
+            if (node.type === 'paragraph' &&
+                node.children.length === 1 &&
+                node.children[0].value === '-- /block') {
+                node.type = 'jsx';
+                node.value = `</div></div>`;
+            }
+            if (node.type === 'mdxJsxFlowElement' && (node.name === 'Example' || node.name === 'Frame')) {
+                node.name = 'Frame';
+            }
+            if (node.type === 'jsx') {
+                node = toMdxJsxFlowElement(node.value);
+            }
+            return node;
+        });
+        tree.children = [...preTree.children, ...tree.children];
+    };
+};

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

@@ -0,0 +1,3 @@
+import type { MdxJsxFlowElement } from 'mdast-util-mdx';
+import type { Parent } from 'unist';
+export declare const remarkMdxInjectRequire: (subdomain: string) => (tree: Parent<MdxJsxFlowElement>) => void;

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

@@ -0,0 +1,23 @@
+// TODO - this is a hack to inject requirejs into the docs to generate Nixtla's graphs.
+// Create a more sustainable solution for this.
+export const remarkMdxInjectRequire = (subdomain) => {
+    return (tree) => {
+        if (subdomain === 'nixtla-docs' || subdomain === 'nixtla') {
+            tree.children.push({
+                type: 'mdxJsxFlowElement',
+                name: 'script',
+                children: [],
+                data: {
+                    _mdxExplicitJsx: true,
+                },
+                attributes: [
+                    {
+                        type: 'mdxJsxAttribute',
+                        name: 'src',
+                        value: 'https://requirejs.org/docs/release/2.3.6/minified/require.js',
+                    },
+                ],
+            });
+        }
+    };
+};

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

@@ -0,0 +1,3 @@
+import { Parent } from 'unist';
+import { VFile } from 'vfile';
+export declare const remarkMdxInjectSnippets: <T extends Parent<import("unist").Node<import("unist").Data>, import("unist").Data>>(snippetTreeMap: Record<string, T>) => (tree: Parent, file: VFile) => void;