@mintlify/common 1.0.1324 → 1.0.1326

package/dist/mdx/server-only/emit/rewrite.d.ts

@@ -0,0 +1,28 @@
+import type { Expression, Node as EstreeNode, Statement } from 'estree-jsx';
+export type FunctionInfo = {
+    tags: Set<string>;
+    components: Set<string>;
+    objects: Set<string>;
+    references: Map<string, boolean>;
+    invalid: Map<string, string>;
+};
+export declare const newInfo: () => FunctionInfo;
+export declare function addPartialReferences(info: FunctionInfo): void;
+export declare class Rewriter {
+    visitors: import("estree-util-scope").Visitors;
+    missingReference: boolean;
+    provides: boolean;
+    usesFragment: boolean;
+    usesJsxs: boolean;
+    dynamicImport: boolean;
+    importMetaUrl: boolean;
+    private stack;
+    inScope(id: string): boolean;
+    enterContent(info: FunctionInfo): void;
+    exportedNames(statement: EstreeNode): string[];
+    resolveImports<T extends EstreeNode>(root: T): T;
+    rewrite(root: EstreeNode): void;
+    private finishFunction;
+    build(node: Statement): Statement;
+    build(node: Expression): Expression;
+}

package/dist/mdx/server-only/emit/rewrite.js

@@ -0,0 +1,312 @@
+import { buildJsx } from 'estree-util-build-jsx';
+import { name as isIdentifierName } from 'estree-util-is-identifier-name';
+import { createVisitors } from 'estree-util-scope';
+import { walk } from 'estree-walker';
+export const newInfo = () => ({
+    tags: new Set(),
+    components: new Set(),
+    objects: new Set(),
+    references: new Map(),
+    invalid: new Map(),
+});
+const isFunction = (node) => node.type === 'ArrowFunctionExpression' ||
+    node.type === 'FunctionDeclaration' ||
+    node.type === 'FunctionExpression';
+const CONTENT_FUNCTION = { type: 'FunctionDeclaration', id: { name: '_createMdxContent' } };
+function idOrMember(ids) {
+    let object;
+    for (const name of ids) {
+        const id = isIdentifierName(name)
+            ? { type: 'Identifier', name }
+            : { type: 'Literal', value: name };
+        object = object
+            ? {
+                type: 'MemberExpression',
+                object,
+                property: id,
+                computed: id.type === 'Literal',
+                optional: false,
+            }
+            : id;
+    }
+    return object;
+}
+function jsxIdOrMember(ids) {
+    let object;
+    for (const name of ids) {
+        const id = { type: 'JSXIdentifier', name };
+        object = object ? { type: 'JSXMemberExpression', object, property: id } : id;
+    }
+    return object;
+}
+export function addPartialReferences(info) {
+    for (const name of [...info.references.keys()]) {
+        const parts = name.split('.');
+        for (let index = 1; index < parts.length; index++) {
+            const partial = parts.slice(0, index).join('.');
+            if (!info.references.has(partial))
+                info.references.set(partial, false);
+        }
+    }
+}
+export class Rewriter {
+    constructor() {
+        this.visitors = createVisitors();
+        this.missingReference = false;
+        this.provides = false;
+        this.usesFragment = false;
+        this.usesJsxs = false;
+        this.dynamicImport = false;
+        this.importMetaUrl = false;
+        this.stack = [];
+    }
+    inScope(id) {
+        const scopes = this.visitors.scopes;
+        for (let index = scopes.length - 1; index >= 0; index--) {
+            if (scopes[index].defined.includes(id))
+                return true;
+        }
+        return false;
+    }
+    enterContent(info) {
+        const scopes = this.visitors.scopes;
+        scopes[0].defined.push('_createMdxContent');
+        scopes.push({ block: false, defined: ['props'] }, { block: true, defined: [] });
+        this.stack = [{ node: CONTENT_FUNCTION, info }];
+    }
+    exportedNames(statement) {
+        const visitors = createVisitors();
+        walk(statement, {
+            enter(node) {
+                visitors.enter(node);
+                if (isFunction(node)) {
+                    this.skip();
+                    visitors.exit(node);
+                }
+            },
+            leave: (node) => visitors.exit(node),
+        });
+        return visitors.scopes[0].defined;
+    }
+    resolveImports(root) {
+        const flag = (name) => (this[name] = true);
+        return walk(root, {
+            enter(raw) {
+                const node = raw;
+                if (node.type === 'ImportExpression') {
+                    flag('dynamicImport');
+                    node.source = {
+                        type: 'CallExpression',
+                        callee: { type: 'Identifier', name: '_resolveDynamicMdxSpecifier' },
+                        arguments: [node.source],
+                        optional: false,
+                    };
+                    return;
+                }
+                if (node.type === 'MemberExpression' &&
+                    node.object.type === 'MetaProperty' &&
+                    node.property.type === 'Identifier' &&
+                    node.object.meta.name === 'import' &&
+                    node.object.property.name === 'meta' &&
+                    node.property.name === 'url') {
+                    flag('importMetaUrl');
+                    this.replace({ type: 'Identifier', name: '_importMetaUrl' });
+                }
+            },
+        });
+    }
+    rewrite(root) {
+        const visitors = this.visitors;
+        const stack = this.stack;
+        const inScope = (id) => this.inScope(id);
+        const finish = (frame, node) => this.finishFunction(frame, node);
+        walk(root, {
+            enter(raw) {
+                var _a, _b, _c;
+                const node = raw;
+                visitors.enter(node);
+                if (isFunction(node))
+                    stack.push({ node, info: newInfo() });
+                const frame = stack[0];
+                if (!frame || node.type !== 'JSXElement')
+                    return;
+                const info = frame.info;
+                let name = node.openingElement.name;
+                if (name.type === 'JSXMemberExpression') {
+                    const ids = [];
+                    while (name.type === 'JSXMemberExpression') {
+                        ids.unshift(name.property.name);
+                        name = name.object;
+                    }
+                    ids.unshift(name.name);
+                    const fullId = ids.join('.');
+                    const id = name.name;
+                    const isInScope = inScope(id);
+                    if (!info.references.has(fullId) &&
+                        (!isInScope ||
+                            (stack.length === 1 &&
+                                ((_a = stack[0]) === null || _a === void 0 ? void 0 : _a.node.type) === 'FunctionDeclaration' &&
+                                ((_b = stack[0].node.id) === null || _b === void 0 ? void 0 : _b.name) === '_createMdxContent')))
+                        info.references.set(fullId, true);
+                    if (!isInScope)
+                        info.objects.add(id);
+                }
+                else if (name.type === 'JSXNamespacedName') {
+                    return;
+                }
+                else if (isIdentifierName(name.name) && !/^[a-z]/.test(name.name)) {
+                    const id = name.name;
+                    if (!inScope(id)) {
+                        if (id !== 'MDXLayout' && !info.references.has(id))
+                            info.references.set(id, true);
+                        info.components.add(id);
+                    }
+                }
+                else if ((_c = node.data) === null || _c === void 0 ? void 0 : _c._mdxExplicitJsx) {
+                    return;
+                }
+                else {
+                    const id = name.name;
+                    info.tags.add(id);
+                    let ids = ['_components', id];
+                    if (!isIdentifierName(id)) {
+                        let invalid = info.invalid.get(id);
+                        if (invalid === undefined) {
+                            invalid = `_component${info.invalid.size}`;
+                            info.invalid.set(id, invalid);
+                        }
+                        ids = [invalid];
+                    }
+                    node.openingElement.name = jsxIdOrMember(ids);
+                    if (node.closingElement)
+                        node.closingElement.name = jsxIdOrMember(ids);
+                }
+            },
+            leave(raw) {
+                const node = raw;
+                visitors.exit(node);
+                if (!isFunction(node))
+                    return;
+                const frame = stack[stack.length - 1];
+                finish(frame, node);
+                stack.pop();
+            },
+        });
+    }
+    finishFunction(frame, node) {
+        const { info } = frame;
+        const statements = [];
+        const defaults = [...info.tags].sort().map((name) => ({
+            type: 'Property',
+            kind: 'init',
+            key: isIdentifierName(name) ? { type: 'Identifier', name } : { type: 'Literal', value: name },
+            value: { type: 'Literal', value: name },
+            method: false,
+            shorthand: false,
+            computed: false,
+        }));
+        const actual = [...info.components];
+        for (const name of info.objects)
+            if (!actual.includes(name))
+                actual.push(name);
+        actual.sort();
+        if (defaults.length > 0 || actual.length > 0 || info.invalid.size > 0) {
+            this.provides = true;
+            const provider = {
+                type: 'CallExpression',
+                callee: { type: 'Identifier', name: '_provideComponents' },
+                arguments: [],
+                optional: false,
+            };
+            if (defaults.length > 0)
+                defaults.push({ type: 'SpreadElement', argument: provider });
+            let init = defaults.length > 0
+                ? { type: 'ObjectExpression', properties: defaults }
+                : {
+                    type: 'LogicalExpression',
+                    operator: '||',
+                    left: provider,
+                    right: { type: 'ObjectExpression', properties: [] },
+                };
+            const declarations = [];
+            if (info.tags.size > 0) {
+                declarations.push({
+                    type: 'VariableDeclarator',
+                    id: { type: 'Identifier', name: '_components' },
+                    init,
+                });
+                init = { type: 'Identifier', name: '_components' };
+            }
+            if (actual.length > 0)
+                declarations.push({
+                    type: 'VariableDeclarator',
+                    id: {
+                        type: 'ObjectPattern',
+                        properties: actual.map((name) => ({
+                            type: 'Property',
+                            kind: 'init',
+                            key: { type: 'Identifier', name },
+                            value: { type: 'Identifier', name },
+                            method: false,
+                            shorthand: true,
+                            computed: false,
+                        })),
+                    },
+                    init,
+                });
+            if (declarations.length > 0)
+                statements.push({ type: 'VariableDeclaration', kind: 'const', declarations });
+        }
+        addPartialReferences(info);
+        for (const id of [...info.references.keys()].sort()) {
+            this.missingReference = true;
+            statements.push({
+                type: 'IfStatement',
+                test: {
+                    type: 'UnaryExpression',
+                    operator: '!',
+                    prefix: true,
+                    argument: idOrMember(id.split('.')),
+                },
+                consequent: {
+                    type: 'ExpressionStatement',
+                    expression: {
+                        type: 'CallExpression',
+                        callee: { type: 'Identifier', name: '_missingMdxReference' },
+                        arguments: [
+                            { type: 'Literal', value: id },
+                            { type: 'Literal', value: info.references.get(id) },
+                        ],
+                        optional: false,
+                    },
+                },
+                alternate: undefined,
+            });
+        }
+        if (statements.length === 0)
+            return;
+        if (node.body.type !== 'BlockStatement')
+            node.body = {
+                type: 'BlockStatement',
+                body: [{ type: 'ReturnStatement', argument: node.body }],
+            };
+        node.body.body.unshift(...statements);
+    }
+    build(node) {
+        const expression = !/(Statement|Declaration)$/.test(node.type);
+        const statement = (expression ? { type: 'ExpressionStatement', expression: node } : node);
+        const program = { type: 'Program', sourceType: 'module', body: [statement] };
+        buildJsx(program, { runtime: 'automatic', importSource: 'react' });
+        const first = program.body[0];
+        if ((first === null || first === void 0 ? void 0 : first.type) === 'ImportDeclaration') {
+            for (const specifier of first.specifiers) {
+                if (specifier.local.name === '_Fragment')
+                    this.usesFragment = true;
+                else if (specifier.local.name === '_jsxs')
+                    this.usesJsxs = true;
+            }
+        }
+        const last = program.body[program.body.length - 1];
+        return expression ? last.expression : last;
+    }
+}

package/dist/mdx/server-only/getMdx/fastCompile.d.ts

@@ -0,0 +1,7 @@
+import type { Root as HastRoot } from 'hast';
+import type { Processor } from 'unified';
+export declare function remarkMdasticParser(this: Processor): void;
+export type EmittedProgram = {
+    code?: string;
+};
+export declare function rehypeEmitProgram(output: EmittedProgram): (tree: HastRoot) => HastRoot;

package/dist/mdx/server-only/getMdx/fastCompile.js

@@ -0,0 +1,24 @@
+import { parse } from 'mdastic';
+import { gfm } from 'mdastic/gfm';
+import { math } from 'mdastic/math';
+import { mdx } from 'mdastic/mdx';
+import { emitProgram } from '../emit/emit.js';
+const syntax = [
+    gfm({ singleTilde: true }),
+    mdx({ estree: true }),
+    math({ singleDollarTextMath: true }),
+];
+export function remarkMdasticParser() {
+    this.parser = (document) => {
+        const tree = parse(document, { syntax });
+        if (tree instanceof Error)
+            throw tree;
+        return tree;
+    };
+}
+export function rehypeEmitProgram(output) {
+    return (tree) => {
+        output.code = emitProgram(tree);
+        return { type: 'root', children: [] };
+    };
+}

package/dist/mdx/server-only/getMdx.js

@@ -17,6 +17,7 @@ import { PackageIslandsError, parsePackageIslands, preprocessPageContent, } from
 import { preprocessCustomHeadingIds } from '../preprocessCustomHeadingIds.js';
 import { preprocessMdxFragmentCode } from '../preprocessMdxFragmentCode.js';
 import { replaceVariables } from '../replaceVariables.js';
+import { rehypeEmitProgram, remarkMdasticParser, } from './getMdx/fastCompile.js';
 import { createSnippetTreeMap } from './getMdx/snippets.js';
 import { getSerializeExtras } from './getSerializeExtras.js';
 const getPackageIslandOptions = (packageBuild, pagePath, processedContent) => {
@@ -231,6 +232,17 @@ function compileMdx(_a) {
         };
     });
 }
+function serializeFast(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        var _c, _d;
+        const emitted = {};
+        const result = yield serialize(Object.assign(Object.assign({}, args), { mdxOptions: Object.assign(Object.assign({}, args.mdxOptions), { remarkPlugins: [remarkMdasticParser, ...((_c = (_a = args.mdxOptions) === null || _a === void 0 ? void 0 : _a.remarkPlugins) !== null && _c !== void 0 ? _c : [])], rehypePlugins: [...((_d = (_b = args.mdxOptions) === null || _b === void 0 ? void 0 : _b.rehypePlugins) !== null && _d !== void 0 ? _d : []), [rehypeEmitProgram, emitted]] }) })).catch(() => undefined);
+        if (!result || 'error' in result || emitted.code === undefined)
+            return serialize(args);
+        return Object.assign(Object.assign({}, result), { compiledSource: emitted.code });
+    });
+}
 function getCompiledMdxWithFallback(_a) {
     return __awaiter(this, arguments, void 0, function* ({ source, failure, scope, mdxOptions, fallbackMdxOptions = mdxOptions, codeStyling, path, traceFn, customLanguages, }) {
         const themeOrThemes = codeStylingToThemeOrThemes(codeStyling);
@@ -238,7 +250,7 @@ function getCompiledMdxWithFallback(_a) {
             if (failure)
                 throw failure;
             const result = yield traceFn('getCompiledMdxWithFallback.serialize', () => __awaiter(this, void 0, void 0, function* () {
-                return serialize({
+                return serializeFast({
                     source,
                     path,
                     scope,