@mintlify/common 1.0.1225 → 1.0.1226

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

@@ -1,4 +1,6 @@
 export * from './extractPackageIslands.js';
+export * from './package-json.js';
+export * from './package-sources.js';
 export * from './packageImports.js';
 export * from './remarkPackageIslands.js';
 export * from './sha256.js';

package/dist/mdx/islands/index.js

@@ -1,4 +1,6 @@
 export * from './extractPackageIslands.js';
+export * from './package-json.js';
+export * from './package-sources.js';
 export * from './packageImports.js';
 export * from './remarkPackageIslands.js';
 export * from './sha256.js';

package/dist/mdx/islands/package-json.d.ts

@@ -0,0 +1,5 @@
+export type PackageJsonDependencies = {
+    packageNames: Set<string>;
+    error?: string;
+};
+export declare const parsePackageJsonDependencies: (content: string) => PackageJsonDependencies;

package/dist/mdx/islands/package-json.js

@@ -0,0 +1,15 @@
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+export const parsePackageJsonDependencies = (content) => {
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { packageNames: new Set(), error: `is not valid JSON: ${message}` };
+    }
+    if (!isRecord(parsed))
+        return { packageNames: new Set(), error: 'is not a JSON object' };
+    const { dependencies } = parsed;
+    return { packageNames: new Set(isRecord(dependencies) ? Object.keys(dependencies) : []) };
+};

package/dist/mdx/islands/package-sources.d.ts

@@ -0,0 +1,59 @@
+import type { Root } from 'mdast';
+import type { IslandSpec } from './types.js';
+export type PackageSource = {
+    path: string;
+    content: string;
+};
+export type PackageImportSource = {
+    source: string;
+    line?: number;
+};
+export type ParsedPackageSource = PackageSource & {
+    tree: Root;
+    imports: PackageImportSource[];
+};
+export type PackageSourceProblem = {
+    file: string;
+    line?: number;
+    message: string;
+};
+export type PackageSourceCategory = 'page' | 'snippet' | 'legacySnippet' | 'other';
+export type ClassifyPackageSourcesOptions = {
+    packageNames: ReadonlySet<string>;
+    variables?: Record<string, string>;
+    normalizeImportSource?: (source: string, importer: string) => string;
+};
+export type ClassifiedPackageSources = {
+    pages: ParsedPackageSource[];
+    snippets: ParsedPackageSource[];
+    legacySnippets: ParsedPackageSource[];
+    unparsed: (PackageSource & {
+        category: PackageSourceCategory;
+    })[];
+    errors: PackageSourceProblem[];
+};
+export declare const sortPackageProblems: (problems: PackageSourceProblem[]) => PackageSourceProblem[];
+export declare const classifyPackageSources: (files: readonly PackageSource[], { packageNames, variables, normalizeImportSource, }: ClassifyPackageSourcesOptions) => ClassifiedPackageSources;
+export type ExtractPagePackageIslandsInput = {
+    path: string;
+    content: string;
+    packageNames: ReadonlySet<string>;
+    packageSnippets: ReadonlySet<string>;
+    variables?: Record<string, string>;
+    snippetTreeMap?: Record<string, Root>;
+    resolvedTree?: Root;
+};
+export type PagePackageIslands = {
+    islands: IslandSpec[];
+    ids: string[];
+    errors: PackageSourceProblem[];
+};
+export declare const packageIslandPagePath: (path: string) => string;
+export declare const extractPagePackageIslands: ({ path, content, packageNames, packageSnippets, variables, snippetTreeMap, resolvedTree, }: ExtractPagePackageIslandsInput) => PagePackageIslands;
+export type MergedPackageIslands = {
+    islands: IslandSpec[];
+    islandPages: Record<string, string[]>;
+};
+export declare const mergePackageIslands: (pages: Iterable<{
+    islands: readonly IslandSpec[];
+}>) => MergedPackageIslands;

package/dist/mdx/islands/package-sources.js

@@ -0,0 +1,155 @@
+import { getFileCategory } from '../../getFileCategory.js';
+import { getAST } from '../remark.js';
+import { replaceVariables } from '../replaceVariables.js';
+import { extractImportSources } from '../snippets/extractImportSources.js';
+import { getSpecifierPackageName } from '../snippets/isBareSpecifier.js';
+import { resolveImportPath } from '../snippets/resolveImportPath.js';
+import { isMdxJsEsm } from '../utils.js';
+import { extractPackageIslands } from './extractPackageIslands.js';
+import { isDeclaredPackageImport, isNonHostBareImport, isPackageSnippetPath, } from './packageImports.js';
+import { getPackageIslandsForContent } from './remarkPackageIslands.js';
+const IMPORT_SOURCE = /\bfrom\s*['"]([^'"\n]+)['"]|\bimport\s*['"]([^'"\n]+)['"]/g;
+const compare = (a, b) => {
+    if (a < b)
+        return -1;
+    if (a > b)
+        return 1;
+    return 0;
+};
+const messageOf = (error) => (error instanceof Error ? error.message : String(error));
+const parse = (content, path) => {
+    try {
+        return getAST(content, path);
+    }
+    catch (error) {
+        return messageOf(error);
+    }
+};
+const topLevelImports = (tree) => tree.children.flatMap((node) => {
+    var _a, _b, _c;
+    if (!isMdxJsEsm(node))
+        return [];
+    return ((_c = (_b = (_a = node.data) === null || _a === void 0 ? void 0 : _a.estree) === null || _b === void 0 ? void 0 : _b.body) !== null && _c !== void 0 ? _c : []).flatMap((statement) => {
+        var _a, _b, _c;
+        if (statement.type !== 'ImportDeclaration' || typeof statement.source.value !== 'string') {
+            return [];
+        }
+        return [
+            {
+                source: statement.source.value,
+                line: (_b = (_a = statement.loc) === null || _a === void 0 ? void 0 : _a.start.line) !== null && _b !== void 0 ? _b : (_c = node.position) === null || _c === void 0 ? void 0 : _c.start.line,
+            },
+        ];
+    });
+});
+export const sortPackageProblems = (problems) => [...problems].sort((a, b) => { var _a, _b; return compare(a.file, b.file) || ((_a = a.line) !== null && _a !== void 0 ? _a : 0) - ((_b = b.line) !== null && _b !== void 0 ? _b : 0); });
+export const classifyPackageSources = (files, { packageNames, variables, normalizeImportSource = (source) => source, }) => {
+    var _a;
+    const resolve = (source, importer) => resolveImportPath(normalizeImportSource(source, importer), importer);
+    const usesPackages = ({ path, content }) => [...replaceVariables(content, variables).matchAll(IMPORT_SOURCE)].some(([, from, bare]) => {
+        var _a;
+        const source = normalizeImportSource((_a = from !== null && from !== void 0 ? from : bare) !== null && _a !== void 0 ? _a : '', path);
+        if (isDeclaredPackageImport(source, packageNames))
+            return true;
+        const resolved = resolveImportPath(source, path);
+        return resolved !== null && isPackageSnippetPath(resolved);
+    });
+    const parsed = [];
+    const failed = [];
+    for (const file of [...files].sort((a, b) => compare(a.path, b.path))) {
+        const tree = parse(replaceVariables(file.content, variables), file.path);
+        if (typeof tree === 'string')
+            failed.push(Object.assign(Object.assign({}, file), { message: tree }));
+        else
+            parsed.push(Object.assign(Object.assign({}, file), { tree, imports: topLevelImports(tree) }));
+    }
+    const importedFiles = new Set();
+    for (const file of parsed) {
+        for (const source of extractImportSources(file.tree)) {
+            const resolved = resolve(source, file.path);
+            if (resolved !== null)
+                importedFiles.add(resolved.toLowerCase());
+        }
+    }
+    const categoryOf = (path) => {
+        const category = getFileCategory(path, { importedFiles });
+        if (category === 'page')
+            return 'page';
+        if (category === 'snippet-v2')
+            return 'snippet';
+        if (category === 'snippet')
+            return 'legacySnippet';
+        return 'other';
+    };
+    const result = {
+        pages: [],
+        snippets: [],
+        legacySnippets: [],
+        unparsed: [],
+        errors: [],
+    };
+    for (const file of failed) {
+        const category = categoryOf(file.path);
+        result.unparsed.push({ path: file.path, content: file.content, category });
+        if (usesPackages(file))
+            result.errors.push({ file: file.path, message: file.message });
+    }
+    for (const file of parsed) {
+        const category = categoryOf(file.path);
+        if (category === 'legacySnippet')
+            result.legacySnippets.push(file);
+        if (category !== 'page' && category !== 'snippet')
+            continue;
+        (category === 'page' ? result.pages : result.snippets).push(file);
+        for (const { source, line } of file.imports) {
+            const normalizedSource = normalizeImportSource(source, file.path);
+            if (!isNonHostBareImport(normalizedSource) ||
+                isDeclaredPackageImport(normalizedSource, packageNames)) {
+                continue;
+            }
+            result.errors.push(Object.assign(Object.assign({ file: file.path }, (line !== undefined && { line })), { message: `imports "${(_a = getSpecifierPackageName(normalizedSource)) !== null && _a !== void 0 ? _a : normalizedSource}", which isn't listed in package.json dependencies.` }));
+        }
+    }
+    return result;
+};
+export const packageIslandPagePath = (path) => path.replace(/\.mdx?$/, '');
+export const extractPagePackageIslands = ({ path, content, packageNames, packageSnippets, variables, snippetTreeMap, resolvedTree, }) => {
+    const options = { packageNames, packageSnippets, pagePath: packageIslandPagePath(path) };
+    let extraction;
+    try {
+        extraction = getPackageIslandsForContent(Object.assign(Object.assign({}, options), { content, variables, snippetTreeMap }));
+    }
+    catch (error) {
+        return {
+            islands: [],
+            ids: [],
+            errors: [
+                { file: path, message: `can't be parsed after resolving imports: ${messageOf(error)}` },
+            ],
+        };
+    }
+    const located = resolvedTree && extraction.errors.length > 0 && !extraction.errors.some((error) => error.code)
+        ? extractPackageIslands(resolvedTree, options).errors.filter((error) => !error.code)
+        : [];
+    return {
+        islands: extraction.islands,
+        ids: extraction.roots.map((root) => root.id),
+        errors: (located.length > 0 ? located : extraction.errors).map(({ line, message }) => (Object.assign(Object.assign({ file: path }, (line !== undefined && { line })), { message }))),
+    };
+};
+export const mergePackageIslands = (pages) => {
+    var _a;
+    const islands = new Map();
+    const islandPages = new Map();
+    for (const page of pages) {
+        for (const island of page.islands) {
+            if (!islands.has(island.id))
+                islands.set(island.id, island);
+            islandPages.set(island.id, ((_a = islandPages.get(island.id)) !== null && _a !== void 0 ? _a : new Set()).add(island.pagePath));
+        }
+    }
+    return {
+        islands: [...islands.values()],
+        islandPages: Object.fromEntries([...islandPages].map(([id, paths]) => [id, [...paths].sort(compare)])),
+    };
+};

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

@@ -1,3 +1,4 @@
 export { createSnippetTreeMap, getMdx, type GetMdxType, type PackageBuildInput, type Snippet, } from './getMdx.js';
 export { getSerializeExtras } from './getSerializeExtras.js';
+export { createPackageSnippetTreeMap } from './package-snippet-tree-map.js';
 export { packagePageBaseUrl, packagePageStylesheets } from '../islands/package-page-url.js';

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

@@ -1,3 +1,4 @@
 export { createSnippetTreeMap, getMdx, } from './getMdx.js';
 export { getSerializeExtras } from './getSerializeExtras.js';
+export { createPackageSnippetTreeMap } from './package-snippet-tree-map.js';
 export { packagePageBaseUrl, packagePageStylesheets } from '../islands/package-page-url.js';

package/dist/mdx/server-only/package-snippet-tree-map.d.ts

@@ -0,0 +1,3 @@
+import type { Root } from 'mdast';
+import type { PackageSource } from '../islands/package-sources.js';
+export declare const createPackageSnippetTreeMap: (legacySnippets: readonly PackageSource[], variables: Record<string, string> | undefined) => Promise<Record<string, Root>>;

package/dist/mdx/server-only/package-snippet-tree-map.js

@@ -0,0 +1,6 @@
+import { preprocessPageContent } from '../islands/remarkPackageIslands.js';
+import { createSnippetTreeMap } from './getMdx/snippets.js';
+export const createPackageSnippetTreeMap = (legacySnippets, variables) => createSnippetTreeMap(legacySnippets.map(({ path, content }) => ({
+    snippetFileLocation: path.replace(/^\/?_snippets\//, ''),
+    content: preprocessPageContent(content, variables),
+})));

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

@@ -10,6 +10,7 @@ export * from './isImportedAsSnippet.js';
 export * from './nodeIncludesExport.js';
 export * from './removeExports.js';
 export * from './resolveAllImports.js';
+export * from './resolveSnippetImports.js';
 export * from './resolveImport/index.js';
 export * from './resolveImportPath.js';
 export * from './isBareSpecifier.js';

package/dist/mdx/snippets/index.js

@@ -10,6 +10,7 @@ export * from './isImportedAsSnippet.js';
 export * from './nodeIncludesExport.js';
 export * from './removeExports.js';
 export * from './resolveAllImports.js';
+export * from './resolveSnippetImports.js';
 export * from './resolveImport/index.js';
 export * from './resolveImportPath.js';
 export * from './isBareSpecifier.js';

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

@@ -0,0 +1,9 @@
+import type { FileWithImports } from '../../types/mdx/index.js';
+import type { PackageImportOptions } from '../islands/packageImports.js';
+import { type ResolveImportsWarning } from './resolveAllImports.js';
+export type ResolveSnippetImportsOptions = {
+    packages?: PackageImportOptions;
+    onWarning?: (warning: ResolveImportsWarning, filename: string) => void;
+    skip?: (filename: string) => boolean;
+};
+export declare const resolveSnippetImports: (snippets: FileWithImports[], { packages, onWarning, skip }?: ResolveSnippetImportsOptions) => Promise<FileWithImports[]>;

package/dist/mdx/snippets/resolveSnippetImports.js

@@ -0,0 +1,29 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { topologicalSort } from '../../topologicalSort.js';
+import { hasImports } from './hasImports.js';
+import { resolveAllImports } from './resolveAllImports.js';
+import { resolveImportPath } from './resolveImportPath.js';
+export const resolveSnippetImports = (snippets_1, ...args_1) => __awaiter(void 0, [snippets_1, ...args_1], void 0, function* (snippets, { packages, onWarning, skip } = {}) {
+    const graph = {};
+    for (const snippet of snippets) {
+        graph[snippet.filename] = Object.keys(snippet.importMap).flatMap((source) => { var _a; return (_a = resolveImportPath(source, snippet.filename)) !== null && _a !== void 0 ? _a : []; });
+    }
+    const byFilename = new Map(snippets.map((snippet) => [snippet.filename, snippet]));
+    const ordered = topologicalSort(graph)
+        .reverse()
+        .flatMap((filename) => { var _a; return (_a = byFilename.get(filename)) !== null && _a !== void 0 ? _a : []; });
+    for (const snippet of ordered) {
+        if (!hasImports(snippet) || (skip === null || skip === void 0 ? void 0 : skip(snippet.filename)))
+            continue;
+        snippet.tree = yield resolveAllImports(Object.assign(Object.assign({ snippets: ordered, fileWithImports: snippet }, (onWarning && { onWarning: (warning) => onWarning(warning, snippet.filename) })), (packages && { packages })));
+    }
+    return snippets;
+});