@mintlify/previewing 4.0.1461 → 4.0.1463

package/dist/local-preview/packages/index.js

@@ -0,0 +1,89 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import path from 'path';
+import { CMD_EXEC_PATH, NEXT_PROPS_PATH, PREVIEW_PATH } from '../../constants.js';
+import { addChangeLog, addErrorLog, getCurrentErrorLogs, removeErrorLogs, } from '../../logging-state.js';
+import { ErrorLog, InfoLog, SuccessLog, WarningLog } from '../../logs.js';
+import { regenerateAllSnippets } from '../listener/regenerateAllSnippets.js';
+import { PackagesDev } from './dev.js';
+import { createPackageRoute, PACKAGE_ROUTE_PREFIX } from './serve.js';
+const MAX_LOGGED = 5;
+let instance;
+let shownIslandErrors = { key: '', logs: [] };
+const reporter = {
+    building: () => {
+        addChangeLog(_jsx(InfoLog, { message: "building npm packages\u2026" }));
+    },
+    built: ({ buildId, islands, ms, warnings }) => {
+        addChangeLog(_jsx(SuccessLog, { message: `built npm packages (${islands} component${islands === 1 ? '' : 's'}, build ${buildId.slice(0, 12)}) in ${(ms / 1000).toFixed(1)}s` }));
+        for (const warning of warnings.slice(0, MAX_LOGGED)) {
+            addChangeLog(_jsx(WarningLog, { message: `npm packages: ${warning}` }));
+        }
+    },
+    failed: (errors, warnings) => {
+        for (const error of errors.slice(0, MAX_LOGGED)) {
+            addErrorLog(_jsx(ErrorLog, { message: `npm packages: ${error}` }));
+        }
+        for (const warning of warnings.slice(0, MAX_LOGGED)) {
+            addChangeLog(_jsx(WarningLog, { message: `npm packages: ${warning}` }));
+        }
+    },
+    missingNodeModules: (docsRoot) => {
+        addErrorLog(_jsx(ErrorLog, { message: `docs.json uses npm packages but ${path.join(docsRoot, 'node_modules')} is missing. Run npm install in ${docsRoot}; package components stay empty until then.` }));
+    },
+    configError: (message) => {
+        addErrorLog(_jsx(ErrorLog, { message: `npm packages: ${message}` }));
+    },
+    islandErrors: (errors) => {
+        const key = errors.join('\n');
+        const current = getCurrentErrorLogs();
+        const visible = shownIslandErrors.logs.every((log) => current.includes(log));
+        if (key === shownIslandErrors.key && visible)
+            return;
+        removeErrorLogs(shownIslandErrors.logs);
+        const logs = errors
+            .slice(0, MAX_LOGGED)
+            .map((error) => _jsx(ErrorLog, { message: `npm packages: ${error}` }));
+        logs.forEach(addErrorLog);
+        shownIslandErrors = { key, logs };
+    },
+};
+const onRebuiltRef = { current: () => { } };
+export const setPackagesRebuiltListener = (listener) => {
+    onRebuiltRef.current = listener;
+};
+const reportError = (error) => addErrorLog(_jsx(ErrorLog, { message: `npm packages: ${error instanceof Error ? error.message : String(error)}` }));
+export const startPackagesDev = async () => {
+    await instance?.close();
+    instance = new PackagesDev({
+        docsRoot: CMD_EXEC_PATH,
+        buildsDir: path.join(PREVIEW_PATH, 'packages'),
+        propsPath: NEXT_PROPS_PATH,
+        onRebuilt: () => onRebuiltRef.current(),
+        regenerateSnippets: regenerateAllSnippets,
+        reporter,
+    });
+    try {
+        await instance.init();
+    }
+    catch (error) {
+        reportError(error);
+    }
+};
+export const notifyPackageInputChange = async (filename, category) => {
+    try {
+        await instance?.onFileChange(filename, category);
+    }
+    catch (error) {
+        reportError(error);
+    }
+};
+export const writePackageBuildProps = async () => {
+    await instance?.writeProps();
+};
+export const packageRoute = {
+    prefix: PACKAGE_ROUTE_PREFIX,
+    handler: createPackageRoute(() => instance?.routeState() ?? {
+        enabled: false,
+        buildsDir: '',
+    }),
+};

package/dist/local-preview/packages/serve.d.ts

@@ -0,0 +1,8 @@
+import type { NextFunction, Request, Response } from 'express';
+export declare const PACKAGE_ROUTE_PREFIX = "/_mintlify/pkg";
+export type PackageRouteState = {
+    enabled: boolean;
+    buildsDir: string;
+};
+export declare const EMPTY_ISLAND_MODULE = "export function hydrate() {\n  return { unmount() {} };\n}\n";
+export declare const createPackageRoute: (getState: () => PackageRouteState) => (req: Request, res: Response, next: NextFunction) => Promise<void>;

package/dist/local-preview/packages/serve.js

@@ -0,0 +1,41 @@
+import fse from 'fs-extra';
+import path from 'path';
+export const PACKAGE_ROUTE_PREFIX = '/_mintlify/pkg';
+const BUILD_ID = /^[A-Za-z0-9_-]{1,64}$/;
+const ISLAND_ENTRY = /^client\/islands\/([A-Za-z0-9_-]{1,64})\.js$/;
+export const EMPTY_ISLAND_MODULE = 'export function hydrate() {\n  return { unmount() {} };\n}\n';
+const resolveInside = (root, relative) => {
+    const resolved = path.resolve(root, relative);
+    return resolved.startsWith(root + path.sep) ? resolved : undefined;
+};
+export const createPackageRoute = (getState) => async (req, res, next) => {
+    const state = getState();
+    if (!state.enabled || (req.method !== 'GET' && req.method !== 'HEAD')) {
+        next();
+        return;
+    }
+    const [buildId, ...rest] = req.path.replace(/^\/+/, '').split('/');
+    const relative = rest.join('/');
+    const clientDir = buildId && BUILD_ID.test(buildId) ? path.join(state.buildsDir, buildId, 'client') : '';
+    const inClient = relative.startsWith('client/') ? relative.slice('client/'.length) : '';
+    const file = clientDir && inClient ? resolveInside(clientDir, inClient) : undefined;
+    res.setHeader('X-Content-Type-Options', 'nosniff');
+    if (file &&
+        (await fse.stat(file).then((stat) => stat.isFile(), () => false))) {
+        res.sendFile(path.relative(clientDir, file), {
+            root: clientDir,
+            dotfiles: 'deny',
+            headers: { 'Cache-Control': 'no-cache' },
+        });
+        return;
+    }
+    if (ISLAND_ENTRY.test(relative)) {
+        res
+            .status(200)
+            .type('text/javascript')
+            .setHeader('Cache-Control', 'no-store')
+            .send(EMPTY_ISLAND_MODULE);
+        return;
+    }
+    res.status(404).type('text/plain').send('Not found');
+};

package/dist/local-preview/packages/state.d.ts

@@ -0,0 +1,6 @@
+import type { PackageImportOptions } from '@mintlify/common';
+export declare const getPackageImportOptions: () => PackageImportOptions | undefined;
+export declare const setPackageImportOptions: (options: PackageImportOptions | undefined) => void;
+export declare const packageImportArgs: () => {
+    packages?: PackageImportOptions;
+};

package/dist/local-preview/packages/state.js

@@ -0,0 +1,6 @@
+let current;
+export const getPackageImportOptions = () => current;
+export const setPackageImportOptions = (options) => {
+    current = options;
+};
+export const packageImportArgs = () => current ? { packages: current } : {};

package/dist/local-preview/run.js

@@ -6,12 +6,14 @@ import { Server as SocketServer } from 'socket.io';
 import { CMD_EXEC_PATH, NEXT_PUBLIC_PATH } from '../constants.js';
 import { addLog, removeSpinnerLogs } from '../logging-state.js';
 import { LaunchLog, SearchDisabledLog, UpdateLog } from '../logs.js';
+import { isNativePackagesEnabled } from '../packages/flag.js';
 import { maybeFixMissingWindowsEnvVar } from '../util.js';
 import { addDevTimingLog, startDevTiming, timeDev } from './dev-timing.js';
 import listener, { initializeDocsConfigHashCache, initializeFrontmatterHashCache, initializeImportCache, } from './listener/index.js';
 import { refreshTrackedReferencedFiles } from './listener/referencedFiles.js';
 import { getLocalNetworkIp } from './network.js';
 import { ensurePageCompiled, getFailedCompileEvents, markOnDemandPagesReady, setCompileListener, } from './on-demand-page.js';
+import { packageRoute, setPackagesRebuiltListener } from './packages/index.js';
 import { setupNext } from './setupNext.js';
 const PROXY_RESPONSE_HEADER_DENYLIST = new Set([
     'connection',
@@ -53,6 +55,7 @@ export const run = async (argv) => {
     process.env.LOCAL_OG_PREVIEW = 'true';
     const requestHandler = await timeDev('setup Next handler', () => setupNext());
     const localIp = getLocalNetworkIp();
+    const nativePackages = isNativePackagesEnabled();
     const apiUrl = argv.apiUrl ?? process.env.MINTLIFY_API_URL ?? 'http://localhost:5000';
     const accessToken = argv.accessToken;
     const subdomain = argv.subdomain;
@@ -60,6 +63,8 @@ export const run = async (argv) => {
     process.env.MINTLIFY_API_URL = apiUrl;
     if (subdomain)
         process.env.MINTLIFY_CLI_SUBDOMAIN = subdomain;
+    if (nativePackages)
+        app.use(packageRoute.prefix, packageRoute.handler);
     // next-server is bugged, public files added after starting aren't served
     app.use('/', express.static(NEXT_PUBLIC_PATH));
     app.use((req, _res, next) => {
@@ -133,6 +138,8 @@ export const run = async (argv) => {
     const onChange = () => {
         io.emit('reload');
     };
+    if (nativePackages)
+        setPackagesRebuiltListener(onChange);
     setCompileListener((event) => {
         io.emit('compiling', event);
     });
@@ -184,6 +191,7 @@ export const run = async (argv) => {
         disablePrefetch: argv.disablePrefetch,
         allowSourceRefs: true,
         lazyPages: true,
+        nativePackages,
     }, watcherGate);
     await timeDev('initialize import cache', () => initializeImportCache(CMD_EXEC_PATH, argv.fileImportsMap));
     markOnDemandPagesReady();

package/dist/logging-state.d.ts

@@ -6,6 +6,7 @@ export declare const addChangeLog: (log: React.ReactNode) => void;
 export declare const addErrorLog: (log: React.ReactNode) => void;
 export declare const addRawErrorLog: (message: string) => void;
 export declare const clearErrorLogs: () => void;
+export declare const removeErrorLogs: (targets: readonly React.ReactNode[]) => void;
 export declare const clearLogs: () => void;
 export declare const removeLastLog: () => void;
 export declare const removeLog: (target: React.ReactNode) => void;

package/dist/logging-state.js

@@ -47,6 +47,11 @@ export const clearErrorLogs = () => {
     currentErrorLogs = [];
     setErrorLogsCallback?.(currentErrorLogs);
 };
+export const removeErrorLogs = (targets) => {
+    ensureLoggingInstance();
+    currentErrorLogs = currentErrorLogs.filter((log) => !targets.includes(log));
+    setErrorLogsCallback?.(currentErrorLogs);
+};
 export const clearLogs = () => {
     ensureLoggingInstance();
     currentLogs = [];

package/dist/packages/builder.d.ts

@@ -0,0 +1,6 @@
+import type { BuildDiagnostic } from '@mintlify/package-builder';
+type PackageBuilder = typeof import('@mintlify/package-builder');
+export declare const PACKAGE_BUILDER_MISSING = "The optional @mintlify/package-builder dependency is not installed, so npm packages are unavailable. npm skips it under --omit=optional or when esbuild fails to install; reinstall mint with --include=optional --foreground-scripts to see why.";
+export declare const loadPackageBuilder: (load?: () => Promise<PackageBuilder>) => Promise<PackageBuilder>;
+export declare const formatDiagnostic: ({ pkg, message }: BuildDiagnostic) => string;
+export {};

package/dist/packages/builder.js

@@ -0,0 +1,17 @@
+import { errnoCode } from './errno.js';
+export const PACKAGE_BUILDER_MISSING = 'The optional @mintlify/package-builder dependency is not installed, so npm packages are unavailable. npm skips it under --omit=optional or when esbuild fails to install; reinstall mint with --include=optional --foreground-scripts to see why.';
+const NOT_FOUND_CODES = new Set(['ERR_MODULE_NOT_FOUND', 'MODULE_NOT_FOUND']);
+export const loadPackageBuilder = async (load = () => import('@mintlify/package-builder')) => {
+    try {
+        return await load();
+    }
+    catch (error) {
+        if (NOT_FOUND_CODES.has(errnoCode(error) ?? '') &&
+            error instanceof Error &&
+            error.message.includes("'@mintlify/package-builder'")) {
+            throw new Error(PACKAGE_BUILDER_MISSING);
+        }
+        throw error;
+    }
+};
+export const formatDiagnostic = ({ pkg, message }) => `${pkg ? `${pkg}: ` : ''}${message}`;

package/dist/packages/collect.d.ts

@@ -0,0 +1,61 @@
+import { type FileWithImports, type IslandSpec, type PackageImportOptions, type PackageSourceProblem } from '@mintlify/common';
+export type PackageIslandProblem = PackageSourceProblem;
+export declare const formatProblem: ({ file, line, message }: PackageIslandProblem) => string;
+export type CollectPackageIslandsInput = {
+    docsRoot: string;
+    packageNames: ReadonlySet<string>;
+    variables?: Record<string, string>;
+    provider?: string;
+    mintIgnore?: string[];
+};
+export type PageIslands = {
+    ids: string[];
+    errors: PackageIslandProblem[];
+};
+export type CollectedIslands = {
+    islands: IslandSpec[];
+    errors: PackageIslandProblem[];
+    warnings: PackageIslandProblem[];
+    packageSnippets: Set<string>;
+    snippetFiles: Record<string, string>;
+    pages: Record<string, PageIslands>;
+};
+type SourceFile = {
+    filename: string;
+    content: string;
+};
+export declare const resolvePageContent: ({ page, docsRoot, snippets, packages, onWarning, }: {
+    page: SourceFile;
+    docsRoot: string;
+    snippets: FileWithImports[];
+    packages: PackageImportOptions;
+    onWarning?: (message: string) => void;
+}) => Promise<string | undefined>;
+export declare class PackageIslandCollector {
+    private readonly input;
+    private snippetSources;
+    private snippets;
+    private snippetTreeMap;
+    private packageSnippets;
+    private packageSnippetTrees;
+    private pageEntries;
+    private warnings;
+    private providerErrors;
+    private snippetErrors;
+    private snippetFiles;
+    private queue;
+    constructor(input: CollectPackageIslandsInput);
+    private get packages();
+    private warn;
+    inheritSnippetTrees(previous: PackageIslandCollector): void;
+    collectAll(): Promise<CollectedIslands>;
+    updatePage(filename: string): Promise<CollectedIslands>;
+    private enqueue;
+    private classify;
+    private collectAllNow;
+    private updatePageNow;
+    result(): CollectedIslands;
+    private extractPage;
+}
+export declare const collectPackageIslands: (input: CollectPackageIslandsInput) => Promise<CollectedIslands>;
+export {};

package/dist/packages/collect.js

@@ -0,0 +1,240 @@
+import { classifyPackageSources, extractImportSources, extractPagePackageIslands, findAndRemoveImports, findPackageSnippets, getAST, hasImports, isPackageSnippetPath, isSnippetExtension, mergePackageIslands, parseFrontmatter, replaceVariables, resolveAllImports, resolveImportPath, resolveSnippetImports, stringifyTree, } from '@mintlify/common';
+import { createPage, getFileListSync, getMintIgnore } from '@mintlify/prebuild';
+import { readFile } from 'fs/promises';
+import { extname, join, sep } from 'path';
+export const formatProblem = ({ file, line, message }) => `${file}${line === undefined ? '' : `:${line}`} ${message}`;
+const withSlash = (filename) => (filename.startsWith('/') ? filename : `/${filename}`);
+const displayPath = (filename) => filename.replace(/^\/+/, '');
+const mayImport = (content) => /\bimport\b/.test(content);
+const parseOrUndefined = (content, filename) => {
+    try {
+        return getAST(content, filename);
+    }
+    catch {
+        return undefined;
+    }
+};
+const readSources = async (docsRoot, mintIgnore) => {
+    const filenames = getFileListSync(docsRoot, docsRoot, mintIgnore)
+        .filter((filename) => isSnippetExtension(extname(filename).slice(1)))
+        .sort();
+    const sources = await Promise.all(filenames.map(async (filename) => {
+        const content = await readFile(join(docsRoot, filename), 'utf8').catch(() => undefined);
+        return content === undefined ? [] : [{ path: displayPath(filename), content }];
+    }));
+    return sources.flat();
+};
+const createLegacySnippetTreeMap = async (snippets, variables) => {
+    if (snippets.length === 0)
+        return {};
+    const { createPackageSnippetTreeMap } = await import('@mintlify/common/server-mdx');
+    return createPackageSnippetTreeMap(snippets, variables);
+};
+const resolveSnippets = async (snippets, variables, packages, onWarning) => {
+    const parsed = [];
+    for (const { filename, content } of snippets) {
+        const tree = parseOrUndefined(replaceVariables(content, variables), filename);
+        if (tree)
+            parsed.push({ ...(await findAndRemoveImports(tree)), filename });
+    }
+    return resolveSnippetImports(parsed, {
+        packages,
+        onWarning: (warning, filename) => onWarning(filename, warning.message),
+        skip: (filename) => packages.packageSnippets?.has(filename) ?? false,
+    });
+};
+export const resolvePageContent = async ({ page, docsRoot, snippets, packages, onWarning, }) => {
+    const tree = parseOrUndefined(page.content, page.filename);
+    if (!tree)
+        return undefined;
+    const importsResponse = await findAndRemoveImports(tree);
+    const content = hasImports(importsResponse)
+        ? stringifyTree(await resolveAllImports({
+            snippets,
+            fileWithImports: { ...importsResponse, filename: page.filename },
+            onWarning: (warning) => onWarning?.(warning.message),
+            packages,
+        }))
+        : page.content;
+    const { pageContent } = await createPage(displayPath(page.filename), content, docsRoot, [], [], () => { });
+    return parseFrontmatter(pageContent).body;
+};
+export class PackageIslandCollector {
+    constructor(input) {
+        this.input = input;
+        this.snippetSources = [];
+        this.snippets = [];
+        this.snippetTreeMap = {};
+        this.packageSnippets = new Set();
+        this.packageSnippetTrees = new Map();
+        this.pageEntries = new Map();
+        this.warnings = [];
+        this.providerErrors = [];
+        this.snippetErrors = [];
+        this.snippetFiles = {};
+        this.queue = Promise.resolve();
+        this.warn = (file, message) => {
+            if (!this.warnings.some((warning) => warning.message === message)) {
+                this.warnings.push({ file: displayPath(file), message });
+            }
+        };
+    }
+    get packages() {
+        return { packageNames: this.input.packageNames, packageSnippets: this.packageSnippets };
+    }
+    inheritSnippetTrees(previous) {
+        if (previous.input.docsRoot !== this.input.docsRoot)
+            return;
+        this.queue = Promise.all([this.queue, previous.queue]).then(() => {
+            this.packageSnippetTrees = new Map(previous.packageSnippetTrees);
+        });
+    }
+    collectAll() {
+        return this.enqueue(() => this.collectAllNow());
+    }
+    updatePage(filename) {
+        return this.enqueue(() => this.updatePageNow(filename));
+    }
+    enqueue(operation) {
+        const run = this.queue.then(operation);
+        this.queue = run.catch(() => { });
+        return run;
+    }
+    classify(files) {
+        return classifyPackageSources(files, {
+            packageNames: this.input.packageNames,
+            variables: this.input.variables,
+        });
+    }
+    async collectAllNow() {
+        const { docsRoot, variables, provider } = this.input;
+        const files = await readSources(docsRoot, this.input.mintIgnore ?? (await getMintIgnore(docsRoot)));
+        const classified = this.classify(files);
+        const snippetPaths = new Set([
+            ...classified.snippets.map(({ path }) => path),
+            ...classified.unparsed.flatMap(({ path, category }) => (category === 'snippet' ? path : [])),
+        ]);
+        this.snippetSources = files
+            .filter(({ path }) => snippetPaths.has(path))
+            .map(({ path, content }) => ({ filename: withSlash(path), content }));
+        this.snippetTreeMap = await createLegacySnippetTreeMap(classified.legacySnippets, variables);
+        const previousTrees = this.packageSnippetTrees;
+        const parsedTrees = new Map(classified.snippets.map(({ path, tree }) => [path, tree]));
+        this.packageSnippetTrees = new Map();
+        for (const { filename } of this.snippetSources) {
+            if (!isPackageSnippetPath(filename))
+                continue;
+            const tree = parsedTrees.get(displayPath(filename)) ?? previousTrees.get(filename);
+            if (tree)
+                this.packageSnippetTrees.set(filename, tree);
+        }
+        this.packageSnippets = findPackageSnippets([...this.packageSnippetTrees].map(([filename, tree]) => ({ filename, tree })));
+        this.warnings = [];
+        this.snippets = await resolveSnippets(this.snippetSources, variables, this.packages, this.warn);
+        const sourceErrors = new Map();
+        for (const error of classified.errors) {
+            sourceErrors.set(error.file, [...(sourceErrors.get(error.file) ?? []), error]);
+        }
+        this.pageEntries = new Map();
+        for (const page of classified.pages)
+            await this.extractPage(page, sourceErrors.get(page.path));
+        for (const { path, content, category } of classified.unparsed) {
+            if (category === 'page')
+                await this.extractPage({ path, content }, sourceErrors.get(path));
+        }
+        this.snippetErrors = classified.errors.filter(({ file }) => !this.pageEntries.has(file));
+        this.snippetFiles = {};
+        for (const path of [...this.packageSnippets].sort()) {
+            const source = this.snippetSources.find(({ filename }) => filename === path);
+            if (source)
+                this.snippetFiles[path] = source.content;
+        }
+        this.providerErrors = [];
+        if (provider !== undefined) {
+            try {
+                this.snippetFiles[provider] = await readFile(join(docsRoot, provider), 'utf8');
+            }
+            catch {
+                this.providerErrors.push({
+                    file: 'docs.json',
+                    message: `packages.provider ${provider} was not found.`,
+                });
+            }
+        }
+        return this.result();
+    }
+    async updatePageNow(filename) {
+        const path = displayPath(filename.split(sep).join('/'));
+        if (!this.pageEntries.has(path))
+            return this.collectAllNow();
+        let content;
+        try {
+            content = await readFile(join(this.input.docsRoot, path), 'utf8');
+        }
+        catch {
+            this.pageEntries.delete(path);
+            return this.result();
+        }
+        const tree = parseOrUndefined(content, withSlash(path));
+        const importsPages = (tree ? extractImportSources(tree) : []).some((source) => {
+            const resolved = resolveImportPath(source, withSlash(path));
+            return resolved !== null && this.pageEntries.has(displayPath(resolved));
+        });
+        if (importsPages)
+            return this.collectAllNow();
+        await this.extractPage({ path, content }, this.classify([{ path, content }]).errors);
+        return this.result();
+    }
+    result() {
+        const entries = [...this.pageEntries.entries()].sort(([a], [b]) => a.localeCompare(b));
+        const pages = {};
+        for (const [file, entry] of entries)
+            pages[file] = { ids: entry.ids, errors: entry.errors };
+        return {
+            islands: mergePackageIslands(entries.map(([, entry]) => entry)).islands,
+            errors: [
+                ...entries.flatMap(([, entry]) => entry.errors),
+                ...this.snippetErrors,
+                ...this.providerErrors,
+            ],
+            warnings: [...this.warnings],
+            packageSnippets: new Set(this.packageSnippets),
+            snippetFiles: { ...this.snippetFiles },
+            pages,
+        };
+    }
+    async extractPage(page, sourceErrors = []) {
+        const { path } = page;
+        const content = replaceVariables(page.content, this.input.variables);
+        const noIslands = { ids: [], islands: [], errors: sourceErrors };
+        if (!mayImport(content) && !content.includes('<Snippet')) {
+            this.pageEntries.set(path, noIslands);
+            return;
+        }
+        const body = await resolvePageContent({
+            page: { filename: withSlash(path), content: page.content },
+            docsRoot: this.input.docsRoot,
+            snippets: this.snippets,
+            packages: this.packages,
+            onWarning: (message) => this.warn(path, message),
+        });
+        if (body === undefined) {
+            this.pageEntries.set(path, noIslands);
+            return;
+        }
+        const extraction = extractPagePackageIslands({
+            path,
+            content: body,
+            packageNames: this.input.packageNames,
+            packageSnippets: this.packageSnippets,
+            variables: this.input.variables,
+            snippetTreeMap: this.snippetTreeMap,
+        });
+        this.pageEntries.set(path, {
+            ids: extraction.ids,
+            islands: extraction.islands,
+            errors: [...sourceErrors, ...extraction.errors],
+        });
+    }
+}
+export const collectPackageIslands = (input) => new PackageIslandCollector(input).collectAll();

package/dist/packages/errno.d.ts

@@ -0,0 +1 @@
+export declare const errnoCode: (error: unknown) => string | undefined;

package/dist/packages/errno.js

@@ -0,0 +1,3 @@
+export const errnoCode = (error) => error instanceof Error && 'code' in error && typeof error.code === 'string'
+    ? error.code
+    : undefined;

package/dist/packages/flag.d.ts

@@ -0,0 +1 @@
+export declare const isNativePackagesEnabled: () => boolean;

package/dist/packages/flag.js

@@ -0,0 +1 @@
+export const isNativePackagesEnabled = () => process.env.MINTLIFY_NATIVE_NPM_PACKAGES === '1';

package/dist/packages/index.d.ts

@@ -0,0 +1,3 @@
+export { collectPackageIslands, PackageIslandCollector, resolvePageContent, type CollectedIslands, type CollectPackageIslandsInput, type PackageIslandProblem, type PageIslands, } from './collect.js';
+export { isNativePackagesEnabled } from './flag.js';
+export { normalizeProviderPath, readPackagesSetup, type PackagesSetup } from './setup.js';

package/dist/packages/index.js

@@ -0,0 +1,3 @@
+export { collectPackageIslands, PackageIslandCollector, resolvePageContent, } from './collect.js';
+export { isNativePackagesEnabled } from './flag.js';
+export { normalizeProviderPath, readPackagesSetup } from './setup.js';

package/dist/packages/setup.d.ts

@@ -0,0 +1,18 @@
+import { type PackagesConfig } from '@mintlify/validation';
+export type PackagesSetup = {
+    packages: PackagesConfig;
+    packageNames: Set<string>;
+    variables?: Record<string, string>;
+    errors: string[];
+    packageJsonError?: string;
+};
+export declare class DocsJsonError extends Error {
+    readonly problems: string[];
+    constructor(problems: string[]);
+}
+export declare class InvalidPackagesError extends DocsJsonError {
+    readonly variables: Record<string, string> | undefined;
+    constructor(problems: string[], variables: Record<string, string> | undefined);
+}
+export declare const normalizeProviderPath: (provider: string) => string;
+export declare const readPackagesSetup: (docsRoot: string) => Promise<PackagesSetup | undefined>;