@mintlify/previewing 4.0.1462 → 4.0.1464

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

@@ -1,4 +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

@@ -14,3 +14,4 @@ export const loadPackageBuilder = async (load = () => import('@mintlify/package-
         throw error;
     }
 };
+export const formatDiagnostic = ({ pkg, message }) => `${pkg ? `${pkg}: ` : ''}${message}`;

package/dist/packages/index.d.ts

@@ -1,4 +1,3 @@
-export { checkPackages, describeBuild, type PackagesCheckLine, type PackagesCheckOptions, type PackagesCheckResult, } from './check.js';
 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

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

package/dist/packages/setup.d.ts

@@ -11,6 +11,8 @@ export declare class DocsJsonError extends Error {
     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>;

package/dist/packages/setup.js

@@ -12,6 +12,10 @@ export class DocsJsonError extends Error {
     }
 }
 export class InvalidPackagesError extends DocsJsonError {
+    constructor(problems, variables) {
+        super(problems);
+        this.variables = variables;
+    }
 }
 const messageOf = (error) => (error instanceof Error ? error.message : String(error));
 const readText = async (path) => {
@@ -51,7 +55,7 @@ export const readPackagesSetup = async (docsRoot) => {
         return undefined;
     const parsed = packagesSchema.safeParse(docsConfig.packages);
     if (!parsed.success) {
-        throw new InvalidPackagesError(parsed.error.issues.map((issue) => `docs.json ${['packages', ...issue.path].join('.')}: ${issue.message}`));
+        throw new InvalidPackagesError(parsed.error.issues.map((issue) => `docs.json ${['packages', ...issue.path].join('.')}: ${issue.message}`), readVariables(docsConfig.variables));
     }
     const packages = parsed.data;
     if (packages.provider !== undefined)