@mintlify/common 1.0.1220 → 1.0.1222

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

@@ -11,15 +11,35 @@ import { serialize } from '@mintlify/mdx/server';
 import { getTailwindSelectors } from '../../css/tailwind.js';
 import { getMDXOptions, remarkMdxRemoveJs, remarkExpandContent, remarkSplitCodeGroup, remarkSplitTabs, remarkWrapCodeBlocks, remarkValidateAccordions, remarkValidateSteps, remarkValidateVisibility, remarkValidateTabs, remarkValidateApiExamples, } from '../../index.js';
 import { codeStylingToThemeOrThemes } from '../getCodeStyling.js';
+import { MINT_ISLAND_COMPONENT } from '../islands/packageImports.js';
+import { PackageIslandsError, parsePackageIslands, preprocessPageContent, } from '../islands/remarkPackageIslands.js';
 import { preprocessCustomHeadingIds } from '../preprocessCustomHeadingIds.js';
 import { preprocessMdxFragmentCode } from '../preprocessMdxFragmentCode.js';
 import { replaceVariables } from '../replaceVariables.js';
 import { createSnippetTreeMap } from './getMdx/snippets.js';
 import { getSerializeExtras } from './getSerializeExtras.js';
+const PACKAGE_BASE_URL = /^\/_mintlify\/pkg\/[A-Za-z0-9_-]+(?:\/[A-Za-z0-9_-]+)*$/;
+const getPackageIslandOptions = (packageBuild, pagePath, processedContent, snippetTreeMap) => {
+    if (!PACKAGE_BASE_URL.test(packageBuild.baseUrl)) {
+        throw new Error(`packageBuild.baseUrl must be a /_mintlify/pkg/ path: ${packageBuild.baseUrl}`);
+    }
+    const options = Object.assign({ packageNames: new Set(packageBuild.packageNames), pagePath }, (packageBuild.packageSnippets && {
+        packageSnippets: new Set(packageBuild.packageSnippets),
+    }));
+    let plan;
+    try {
+        plan = parsePackageIslands(processedContent, options, snippetTreeMap);
+    }
+    catch (_a) {
+        plan = undefined;
+    }
+    return Object.assign(Object.assign({}, options), { plan, islandHtml: packageBuild.islands, baseUrl: packageBuild.baseUrl });
+};
 export function getMdx(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ path, content, metadata, snippets, subdomain, codeStyling, config, tailwindSelectors = undefined, pageType = 'default', trace = undefined, customLanguages = [], variables = undefined, rehypePlugins = [], remarkPlugins = [], earlyRemarkPlugins = [], allowedComponents = [], singlePass = true, }) {
+    return __awaiter(this, arguments, void 0, function* ({ path, content, metadata, snippets, subdomain, codeStyling, config, tailwindSelectors = undefined, pageType = 'default', trace = undefined, customLanguages = [], variables = undefined, rehypePlugins = [], remarkPlugins = [], earlyRemarkPlugins = [], allowedComponents = [], packageBuild = undefined, singlePass = true, }) {
+        var _b, _c;
         const traceFn = trace !== null && trace !== void 0 ? trace : ((_name, fn) => fn());
-        const processedContent = preprocessCustomHeadingIds(preprocessMdxFragmentCode(replaceVariables(content, variables)));
+        const processedContent = preprocessPageContent(content, variables);
         const processedSnippets = snippets.map((snippet) => (Object.assign(Object.assign({}, snippet), { content: preprocessCustomHeadingIds(preprocessMdxFragmentCode(replaceVariables(snippet.content, variables))) })));
         if (!tailwindSelectors)
             tailwindSelectors = yield traceFn('getMdx.getTailwindSelectors', () => __awaiter(this, void 0, void 0, function* () { return getTailwindSelectors({ content: processedContent }); }));
@@ -33,6 +53,13 @@ export function getMdx(_a) {
             tailwindSelectors,
             path,
         };
+        const packageIslands = packageBuild &&
+            (yield traceFn('getMdx.packageIslands', () => __awaiter(this, void 0, void 0, function* () { return getPackageIslandOptions(packageBuild, path, processedContent, snippetTreeMap); })));
+        if (packageBuild)
+            allowedComponents = [...allowedComponents, MINT_ISLAND_COMPONENT];
+        const planErrors = (_c = (_b = packageIslands === null || packageIslands === void 0 ? void 0 : packageIslands.plan) === null || _b === void 0 ? void 0 : _b.errors) !== null && _c !== void 0 ? _c : [];
+        const planFailure = planErrors.length > 0 ? new PackageIslandsError(path, planErrors) : undefined;
+        const compiledIslands = planFailure ? undefined : packageIslands;
         let mdxExtracts = {};
         let plugins = [
             remarkValidateSteps,
@@ -55,24 +82,30 @@ export function getMdx(_a) {
         // detector sits exactly where remarkMdxRemoveJs sits in the no-js pass, so it
         // sees the identical tree state and applies the identical decisions
         const jsDetection = { hasJs: true };
-        const mdxOptions = getMDXOptions({
-            data: mdxOptionsData,
-            remarkPlugins: plugins,
-            earlyRemarkPlugins,
-            rehypePlugins,
-            mdxExtracts,
-            detectJs: jsDetection,
-            allowedComponents,
-            fragmentPlugins: getSerializeExtras(syntaxHighlightingOptions),
-        });
-        const mdxOptionsNoJs = getMDXOptions({
-            data: mdxOptionsData,
-            remarkPlugins: [remarkMdxRemoveJs, ...plugins],
-            earlyRemarkPlugins,
-            rehypePlugins,
-            allowedComponents,
-            fragmentPlugins: getSerializeExtras(syntaxHighlightingOptions),
+        const buildMdxOptions = (islands) => ({
+            mdxOptions: getMDXOptions({
+                data: mdxOptionsData,
+                remarkPlugins: plugins,
+                earlyRemarkPlugins,
+                rehypePlugins,
+                mdxExtracts,
+                allowedComponents,
+                fragmentPlugins: getSerializeExtras(syntaxHighlightingOptions),
+                detectJs: jsDetection,
+                packageIslands: islands,
+            }),
+            mdxOptionsNoJs: getMDXOptions({
+                data: mdxOptionsData,
+                remarkPlugins: [remarkMdxRemoveJs, ...plugins],
+                earlyRemarkPlugins,
+                rehypePlugins,
+                allowedComponents,
+                fragmentPlugins: getSerializeExtras(syntaxHighlightingOptions),
+                packageIslands: islands,
+            }),
         });
+        const { mdxOptions, mdxOptionsNoJs } = buildMdxOptions(compiledIslands);
+        const withoutIslands = compiledIslands ? buildMdxOptions() : { mdxOptions, mdxOptionsNoJs };
         const scope = {
             codeStyling,
             config,
@@ -81,14 +114,16 @@ export function getMdx(_a) {
         const { mdxSource, mdxSourceWithNoJs, parseFailed: mainParseFailed, } = yield traceFn('getMdx.compileMdx.mainContent', () => __awaiter(this, void 0, void 0, function* () {
             return compileMdx({
                 content: processedContent,
+                failure: planFailure,
                 scope,
                 mdxOptions,
                 mdxOptionsNoJs,
+                fallbackOptions: withoutIslands,
                 codeStyling,
                 path,
                 traceFn,
                 customLanguages,
-                skipNoJs: singlePass ? { detection: jsDetection, mdxExtracts } : undefined,
+                skipNoJs: singlePass && !compiledIslands ? { detection: jsDetection, mdxExtracts } : undefined,
             });
         }));
         let parseFailed = mainParseFailed;
@@ -98,16 +133,10 @@ export function getMdx(_a) {
         if (mdxExtracts.panel && mdxExtracts.panel.content) {
             const panelContent = mdxExtracts.panel.content;
             const compiledMdx = yield traceFn('getMdx.compileMdx.panelContent', () => __awaiter(this, void 0, void 0, function* () {
-                return compileMdx({
-                    content: panelContent,
-                    scope,
-                    mdxOptions,
-                    mdxOptionsNoJs,
-                    codeStyling,
+                return compileMdx(Object.assign(Object.assign({ content: panelContent, scope }, withoutIslands), { codeStyling,
                     path,
                     traceFn,
-                    customLanguages,
-                });
+                    customLanguages }));
             }));
             panelMdxSource = compiledMdx.mdxSource;
             panelMdxSourceWithNoJs = compiledMdx.mdxSourceWithNoJs;
@@ -128,12 +157,14 @@ export function getMdx(_a) {
     });
 }
 function compileMdx(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ content, scope, mdxOptions, mdxOptionsNoJs, codeStyling, path, traceFn, customLanguages, skipNoJs, }) {
+    return __awaiter(this, arguments, void 0, function* ({ content, failure, scope, mdxOptions, mdxOptionsNoJs, fallbackOptions, codeStyling, path, traceFn, customLanguages, skipNoJs, }) {
         const withJs = yield traceFn('compileMdx.withJs', () => __awaiter(this, void 0, void 0, function* () {
             return getCompiledMdxWithFallback({
                 source: content,
+                failure,
                 scope,
                 mdxOptions,
+                fallbackMdxOptions: fallbackOptions === null || fallbackOptions === void 0 ? void 0 : fallbackOptions.mdxOptions,
                 codeStyling,
                 path,
                 traceFn,
@@ -159,8 +190,10 @@ function compileMdx(_a) {
         const withoutJs = yield traceFn('compileMdx.withoutJs', () => __awaiter(this, void 0, void 0, function* () {
             return getCompiledMdxWithFallback({
                 source: content,
+                failure,
                 scope,
                 mdxOptions: mdxOptionsNoJs,
+                fallbackMdxOptions: fallbackOptions === null || fallbackOptions === void 0 ? void 0 : fallbackOptions.mdxOptionsNoJs,
                 codeStyling,
                 path,
                 traceFn,
@@ -175,9 +208,11 @@ function compileMdx(_a) {
     });
 }
 function getCompiledMdxWithFallback(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ source, scope, mdxOptions, codeStyling, path, traceFn, customLanguages, }) {
+    return __awaiter(this, arguments, void 0, function* ({ source, failure, scope, mdxOptions, fallbackMdxOptions = mdxOptions, codeStyling, path, traceFn, customLanguages, }) {
         const themeOrThemes = codeStylingToThemeOrThemes(codeStyling);
         try {
+            if (failure)
+                throw failure;
             const result = yield traceFn('getCompiledMdxWithFallback.serialize', () => __awaiter(this, void 0, void 0, function* () {
                 return serialize({
                     source,
@@ -200,7 +235,7 @@ function getCompiledMdxWithFallback(_a) {
                 return serialize({
                     source: '🚧 A parsing error occured. Please contact the owner of this website. They can use the Mintlify CLI to test this website locally and see the errors that occur.',
                     scope,
-                    mdxOptions,
+                    mdxOptions: fallbackMdxOptions,
                     syntaxHighlightingOptions: Object.assign(Object.assign({}, themeOrThemes), { customLanguages }),
                 });
             }));

package/dist/mdx/server-only/index.d.ts

@@ -1,2 +1,2 @@
-export { createSnippetTreeMap, getMdx, type GetMdxType, type Snippet } from './getMdx.js';
+export { createSnippetTreeMap, getMdx, type GetMdxType, type PackageBuildInput, type Snippet, } from './getMdx.js';
 export { getSerializeExtras } from './getSerializeExtras.js';

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

@@ -1,2 +1,2 @@
-export { createSnippetTreeMap, getMdx } from './getMdx.js';
+export { createSnippetTreeMap, getMdx, } from './getMdx.js';
 export { getSerializeExtras } from './getSerializeExtras.js';

package/dist/mdx/snippets/resolveAllImports.d.ts

@@ -1,11 +1,13 @@
 import type { Root } from 'mdast';
 import type { FileType, FileWithImports } from '../../types/mdx/index.js';
+import { type PackageImportOptions } from '../islands/packageImports.js';
 export type ResolveImportsWarning = {
-    type: 'invalid-import-path' | 'missing-file' | 'import-resolution-error' | 'default-import-no-default-export' | 'export-collision';
+    type: 'invalid-import-path' | 'missing-file' | 'import-resolution-error' | 'default-import-no-default-export' | 'export-collision' | 'undeclared-package' | 'package-import-conflict';
     message: string;
 };
 export declare const resolveAllImports: (params: {
     snippets: FileType[];
     fileWithImports: FileWithImports;
     onWarning?: (warning: ResolveImportsWarning) => void;
+    packages?: PackageImportOptions;
 }) => Promise<Root>;

package/dist/mdx/snippets/resolveAllImports.js

@@ -7,16 +7,60 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+import { remove } from 'unist-util-remove';
+import { visit } from 'unist-util-visit';
 import { MdxImportSpecifier } from '../../types/mdx/snippets/import.js';
+import { createImportNode, isDeclaredPackageImport, isNonHostBareImport, mergeImports, } from '../islands/packageImports.js';
+import { estreeIsProgram, isImportDeclaration, isMdxJsEsm } from '../utils.js';
+import { findAndRemoveImports } from './findAndRemoveImports.js';
 import { getExportMapFromTree } from './getExportMap.js';
+import { getSpecifierPackageName } from './isBareSpecifier.js';
 import { resolveImport } from './resolveImport/index.js';
+import { injectToTopOfFileOfTree } from './resolveImport/injectToTopOfFile.js';
 import { resolveImportPath } from './resolveImportPath.js';
+const hasImportDeclaration = (node) => isMdxJsEsm(node) && estreeIsProgram(node) && node.data.estree.body.some(isImportDeclaration);
+const takeImports = (tree) => __awaiter(void 0, void 0, void 0, function* () {
+    const carriers = new Set();
+    visit(tree, (node) => {
+        if (hasImportDeclaration(node))
+            carriers.add(node);
+    });
+    if (carriers.size === 0)
+        return {};
+    const { importMap, tree: rest } = yield findAndRemoveImports({
+        type: 'root',
+        children: [...carriers],
+    });
+    const remaining = new Set(rest.children);
+    remove(tree, { cascade: false }, (node) => carriers.has(node) && !remaining.has(node));
+    return importMap;
+});
 export const resolveAllImports = (params) => __awaiter(void 0, void 0, void 0, function* () {
-    const { snippets, fileWithImports, onWarning } = params;
+    var _a, _b, _c, _d;
+    const { snippets, fileWithImports, onWarning, packages } = params;
     let ast = fileWithImports.tree;
     const exportMap = getExportMapFromTree(ast);
+    const kept = [];
     for (const source of Object.keys(fileWithImports.importMap)) {
         const resolvedPath = resolveImportPath(source, fileWithImports.filename);
+        if (packages && resolvedPath == null && isNonHostBareImport(source)) {
+            if (isDeclaredPackageImport(source, packages.packageNames)) {
+                kept.push([source, (_a = fileWithImports.importMap[source]) !== null && _a !== void 0 ? _a : []]);
+                continue;
+            }
+            const message = `Package ${(_b = getSpecifierPackageName(source)) !== null && _b !== void 0 ? _b : source} imported in ${fileWithImports.filename} is not declared in package.json dependencies.`;
+            if (onWarning) {
+                onWarning({ type: 'undeclared-package', message });
+            }
+            else {
+                console.log(message);
+            }
+            continue;
+        }
+        if (resolvedPath != null && ((_c = packages === null || packages === void 0 ? void 0 : packages.packageSnippets) === null || _c === void 0 ? void 0 : _c.has(resolvedPath))) {
+            kept.push([resolvedPath, (_d = fileWithImports.importMap[source]) !== null && _d !== void 0 ? _d : []]);
+            continue;
+        }
         if (resolvedPath == null) {
             const message = `Invalid import path ${source} in ${fileWithImports.filename}. Only local imports are supported.`;
             if (onWarning) {
@@ -73,5 +117,25 @@ export const resolveAllImports = (params) => __awaiter(void 0, void 0, void 0, f
             }
         }
     }
+    if (packages)
+        kept.push(...Object.entries(yield takeImports(ast)));
+    if (!packages || kept.length === 0)
+        return ast;
+    const { imports, conflicts } = mergeImports(kept.filter(([source, specifiers]) => {
+        var _a;
+        return specifiers.length > 0 ||
+            isDeclaredPackageImport(source, packages.packageNames) ||
+            ((_a = packages.packageSnippets) === null || _a === void 0 ? void 0 : _a.has(source));
+    }));
+    for (const { local, first, second } of conflicts) {
+        const message = `${local} is imported twice in ${fileWithImports.filename}, as ${first} and as ${second}. Snippets inlined into a page share its imports, so import one of them under another name.`;
+        if (onWarning) {
+            onWarning({ type: 'package-import-conflict', message });
+        }
+        else {
+            console.log(message);
+        }
+    }
+    injectToTopOfFileOfTree(ast, [createImportNode(imports)]);
     return ast;
 });

package/dist/mdx/static-object-keys.d.ts

@@ -0,0 +1 @@
+export declare const UNSAFE_OBJECT_KEYS: Set<string>;

package/dist/mdx/static-object-keys.js

@@ -0,0 +1 @@
+export const UNSAFE_OBJECT_KEYS = new Set(['__proto__', 'constructor', 'prototype']);