@mintlify/previewing 4.0.1588 → 4.0.1590

package/dist/local-preview/export.js

@@ -2,32 +2,23 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { getAllPathsInDecoratedNav, getAllPathsInDocsNav } from '@mintlify/common';
 import { prebuild } from '@mintlify/prebuild';
 import AdmZip from 'adm-zip';
-import express from 'express';
 import fse, { pathExists } from 'fs-extra';
-import { createServer } from 'http';
 import os from 'os';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import { CLIENT_PATH, CMD_EXEC_PATH, VERSION_PATH, NEXT_PUBLIC_PATH, NEXT_PROPS_PATH, PREVIEW_PATH, configureSharedPreviewPath, } from '../constants.js';
+import { CMD_EXEC_PATH, CONTENT_PATH, VERSION_PATH, NEXT_PUBLIC_PATH, NEXT_PROPS_PATH, PREVIEW_PATH, configureSharedPreviewPath, } from '../constants.js';
 import { addLog, clearLogs } from '../logging-state.js';
 import { ErrorLog, SpinnerLog, SuccessLog, WarningLog } from '../logs.js';
 import { localizeAssets } from './export-assets.js';
-import { applyBasePathToExport, findBasePathConflict, normalizeExportBasePath, } from './export-base-path.js';
+import { findBasePathConflict, normalizeExportBasePath } from './export-base-path.js';
 import { generateExportLlmsTxt } from './export-llms.js';
+import { createNextRenderer } from './export-next.js';
 import { writeSearchIndex } from './export-search.js';
+import { createViteRenderer } from './export-vite.js';
 import { getGroupFilteredRoutes } from './getGroupFilteredRoutes.js';
 import { isOnline } from './is-online.js';
-import { setupNext } from './setupNext.js';
 import { silentUpdateClient } from './update.js';
-const CONCURRENCY = 10;
-const RSC_CONTENT_TYPE = 'text/x-component';
-const RSC_PAYLOAD_FILE = 'index.txt';
 const EXPORT_SCRIPTS_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', '..', 'export-scripts');
-function resolveRequestRoute(route, rootRoute) {
-    if (route === '/' && rootRoute)
-        return rootRoute;
-    return route;
-}
 function prepareRoutesForExport(routes, groups) {
     if (!groups?.length || routes.includes('/'))
         return { routes };
@@ -94,59 +85,6 @@ async function collectRoutes(groups) {
     }
     return [...routes];
 }
-export async function generatePages(baseUrl, routes, outputDir, rootRoute) {
-    const queue = [...routes];
-    let failedPageCount = 0;
-    async function worker() {
-        while (queue.length > 0) {
-            const route = queue.shift();
-            try {
-                const requestRoute = resolveRequestRoute(route, rootRoute);
-                const [res, rscRes] = await Promise.all([
-                    fetch(`${baseUrl}${requestRoute}`),
-                    fetch(`${baseUrl}${requestRoute}`, { headers: { RSC: '1' } }),
-                ]);
-                const isRscPayload = rscRes.headers.get('content-type')?.startsWith(RSC_CONTENT_TYPE);
-                if (!res.ok || !rscRes.ok || !isRscPayload) {
-                    failedPageCount += 1;
-                    addLog(_jsx(ErrorLog, { message: `failed to generate ${route} (status ${res.ok ? rscRes.status : res.status})` }));
-                    continue;
-                }
-                const pageDir = route === '/' ? outputDir : path.join(outputDir, route);
-                await fse.ensureDir(pageDir);
-                await Promise.all([
-                    fse.writeFile(path.join(pageDir, 'index.html'), await res.text(), 'utf8'),
-                    fse.writeFile(path.join(pageDir, RSC_PAYLOAD_FILE), await rscRes.text(), 'utf8'),
-                ]);
-            }
-            catch (err) {
-                failedPageCount += 1;
-                addLog(_jsx(ErrorLog, { message: `failed to generate ${route}: ${err instanceof Error ? err.message : 'unknown error'}` }));
-            }
-        }
-    }
-    await Promise.all(Array.from({ length: Math.min(CONCURRENCY, routes.length) }, () => worker()));
-    return failedPageCount;
-}
-async function startServer(basePath) {
-    const app = express();
-    const requestHandler = await setupNext(basePath ? { assetPrefix: basePath } : undefined);
-    app.use('/', express.static(NEXT_PUBLIC_PATH));
-    app.all('*', (req, res) => requestHandler(req, res));
-    const server = createServer(app);
-    const port = await new Promise((resolve, reject) => {
-        server.once('error', reject);
-        server.listen(0, () => {
-            const addr = server.address();
-            if (!addr || typeof addr === 'string') {
-                reject(new Error('failed to determine listening port'));
-                return;
-            }
-            resolve(addr.port);
-        });
-    });
-    return { server, port };
-}
 export async function writeStaticUserInfo(tmpDir, groups) {
     if (!groups?.length)
         return;
@@ -154,11 +92,8 @@ export async function writeStaticUserInfo(tmpDir, groups) {
         user: { groups },
     });
 }
-async function bundleStaticAssets(tmpDir, groups, basePath) {
-    const nextStaticSrc = path.join(CLIENT_PATH, '.next', 'static');
-    if (await pathExists(nextStaticSrc)) {
-        await fse.copy(nextStaticSrc, path.join(tmpDir, '_next', 'static'));
-    }
+async function bundleStaticAssets(tmpDir, groups, basePath, renderer) {
+    await renderer.copyAssets(tmpDir);
     if (await pathExists(NEXT_PUBLIC_PATH)) {
         const publicFiles = await fse.readdir(NEXT_PUBLIC_PATH);
         for (const file of publicFiles) {
@@ -170,7 +105,7 @@ async function bundleStaticAssets(tmpDir, groups, basePath) {
     await writeStaticUserInfo(tmpDir, groups);
     const serveScript = await fse.readFile(path.join(EXPORT_SCRIPTS_DIR, 'serve.js'), 'utf8');
     await fse.writeFile(path.join(tmpDir, 'serve.js'), serveScript.replace("const BASE_PATH = '';", `const BASE_PATH = ${JSON.stringify(basePath)};`));
-    await fse.copy(path.join(EXPORT_SCRIPTS_DIR, 'README.md'), path.join(tmpDir, 'README.md'));
+    await fse.copy(path.join(EXPORT_SCRIPTS_DIR, renderer.readme), path.join(tmpDir, 'README.md'));
     await fse.copy(path.join(EXPORT_SCRIPTS_DIR, 'start-docs.sh'), path.join(tmpDir, 'Start Docs.command'));
     await fse.copy(path.join(EXPORT_SCRIPTS_DIR, 'start-docs.bat'), path.join(tmpDir, 'Start Docs.bat'));
 }
@@ -184,13 +119,10 @@ export async function writeLlmsTxt(tmpDir, routes, basePath = '') {
     ]);
     await fse.writeFile(llmsTxtPath, generateExportLlmsTxt(docsConfig, generatedNav, routes, basePath), 'utf8');
 }
-async function closeServer(server) {
-    await new Promise((resolve) => {
-        server.close(() => resolve());
-    });
-}
-async function generateExportArchive(routes, outputPath, groups, basePath) {
-    const { server, port } = await startServer(basePath);
+async function generateExportArchive(routes, outputPath, groups, basePath, vite) {
+    const renderer = vite
+        ? await createViteRenderer({ groups, basePath: basePath || undefined })
+        : await createNextRenderer(groups, basePath);
     const { routes: preparedRoutes, rootRoute } = prepareRoutesForExport(routes, groups);
     const routesToGenerate = withIndexRouteAliases(preparedRoutes);
     let tmpDir;
@@ -200,14 +132,13 @@ async function generateExportArchive(routes, outputPath, groups, basePath) {
         tmpDir = await fse.mkdtemp(path.join(os.tmpdir(), 'mint-export-'));
         const exportDir = tmpDir;
         const failedPageCount = await withExportConsoleSilenced(async () => {
-            return generatePages(`http://localhost:${port}`, routesToGenerate, exportDir, rootRoute);
+            return renderer.generatePages(routesToGenerate, exportDir, rootRoute);
         });
         if (failedPageCount > 0) {
             throw new Error(`failed to export: ${failedPageCount} page(s) could not be generated.`);
         }
         addLog(_jsx(SpinnerLog, { message: "collecting static assets..." }));
-        await bundleStaticAssets(exportDir, groups, basePath);
-        await applyBasePathToExport(exportDir, basePath);
+        await bundleStaticAssets(exportDir, groups, basePath, renderer);
         await writeLlmsTxt(exportDir, routes, basePath);
         addLog(_jsx(SpinnerLog, { message: "building search index..." }));
         const [docsConfig, generatedNav] = await Promise.all([
@@ -216,7 +147,11 @@ async function generateExportArchive(routes, outputPath, groups, basePath) {
         ]);
         await writeSearchIndex(exportDir, { generatedNav, docsConfig, groups });
         addLog(_jsx(SpinnerLog, { message: "bundling external assets..." }));
-        const { failed } = await localizeAssets(exportDir);
+        const clientAssetFailures = await renderer.bundleAssets(exportDir);
+        const { failed: assetFailures } = await localizeAssets(exportDir, {
+            stylesheetDir: renderer.stylesheetDir,
+        });
+        const failed = [...clientAssetFailures, ...assetFailures];
         addLog(_jsx(SpinnerLog, { message: "creating zip archive..." }));
         const zip = new AdmZip();
         zip.addLocalFolder(exportDir);
@@ -231,11 +166,12 @@ async function generateExportArchive(routes, outputPath, groups, basePath) {
         if (tmpDir) {
             await fse.remove(tmpDir);
         }
-        await closeServer(server);
+        await renderer.close();
     }
 }
 export const exportSite = async (argv) => {
-    configureSharedPreviewPath();
+    const vite = argv.classic !== true;
+    configureSharedPreviewPath(vite ? 'vite' : 'next');
     const hasInternet = await isOnline();
     const clientVersion = argv['client-version'];
     const localClientVersion = argv['local-client-version'];
@@ -273,7 +209,8 @@ export const exportSite = async (argv) => {
     catch (err) {
         await fatal(err instanceof Error && err.message ? err.message : 'failed to prepare export directories');
     }
-    process.chdir(CLIENT_PATH);
+    await fse.ensureDir(CONTENT_PATH);
+    process.chdir(CONTENT_PATH);
     addLog(_jsx(SpinnerLog, { message: "running prebuild..." }));
     try {
         await withExportConsoleSilenced(async () => {
@@ -294,10 +231,8 @@ export const exportSite = async (argv) => {
     if (conflictingRoute) {
         await fatal(`--base-path ${basePath} conflicts with the page ${conflictingRoute}. Pages can't start with the base path, so pick a different one.`);
     }
-    addLog(_jsx(SpinnerLog, { message: "starting local server..." }));
-    process.env.MINT_EXPORT = JSON.stringify({ groups, basePath: basePath || undefined });
     try {
-        await generateExportArchive(routes, outputPath, groups, basePath);
+        await generateExportArchive(routes, outputPath, groups, basePath, vite);
     }
     catch (err) {
         await fatal(err instanceof Error && err.message ? err.message : 'export failed');

package/dist/local-preview/index.js

@@ -43,13 +43,6 @@ const startDev = async (argv) => {
     const cliVersion = argv.cliVersion;
     const disableOpenApi = argv.disableOpenapi;
     const disablePrefetch = argv.disablePrefetch;
-    const [nodeMajor = 0, nodeMinor = 0] = process.versions.node.split('.').map(Number);
-    if (CLIENT_FRAMEWORK === 'vite' && (nodeMajor < 20 || (nodeMajor === 20 && nodeMinor < 11))) {
-        clearLogs();
-        addLog(_jsx(ErrorLog, { message: `${packageName} dev --beta needs node 20.11 or newer.` }));
-        await new Promise((resolve) => setTimeout(resolve, 50));
-        process.exit(1);
-    }
     await timeDev('ensure preview directory', () => fse.ensureDir(PREVIEW_PATH));
     if (!localClientVersion && !clientVersion && CLIENT_FRAMEWORK === 'next') {
         timeDevSync('seed preview from shared workspace', () => seedPreviewFromShared());
@@ -126,7 +119,7 @@ const startDev = async (argv) => {
 };
 const dev = async (argv) => {
     const port = Number(argv.port ?? 3000);
-    configurePreviewPath(port, argv.beta === true ? 'vite' : 'next');
+    configurePreviewPath(port, argv.classic === true ? 'next' : 'vite');
     const releasePreviewLock = acquirePreviewLock(port);
     try {
         await startDev(argv);

package/dist/local-preview/setupVite.d.ts

@@ -1,4 +1,13 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
+type MintExportConfig = {
+    groups?: string[];
+    basePath?: string;
+};
 type RequestListener = (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+export type ExportFetch = (request: Request) => Promise<Response>;
 export declare const setupVite: () => Promise<RequestListener>;
+export declare const setupViteExport: (mintExport: MintExportConfig) => Promise<{
+    fetchPage: ExportFetch;
+    assetPrefixes: string[];
+}>;
 export {};

package/dist/local-preview/setupVite.js

@@ -2,13 +2,26 @@ import fse from 'fs-extra';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { CLIENT_PATH } from '../constants.js';
-export const setupVite = async () => {
+const loadCliEntry = async () => {
     const entryPath = path.join(CLIENT_PATH, 'dist-cli', 'index.js');
     if (!(await fse.pathExists(entryPath))) {
         throw new Error(`Client not built. Run: cd <path>/apps/client-vite && pnpm build:cli`);
     }
-    const entry = await import(pathToFileURL(entryPath).href);
+    return { entry: await import(pathToFileURL(entryPath).href), entryPath };
+};
+export const setupVite = async () => {
+    const { entry, entryPath } = await loadCliEntry();
     if (!entry.createCliHandler)
         throw new Error(`${entryPath} does not export createCliHandler`);
     return entry.createCliHandler();
 };
+export const setupViteExport = async (mintExport) => {
+    const { entry } = await loadCliEntry();
+    if (!entry.createCliExportFetch || !entry.exportAssetPrefixes) {
+        throw new Error('this client version is too old to export, rerun online to fetch the latest client or export with --classic');
+    }
+    return {
+        fetchPage: await entry.createCliExportFetch(mintExport),
+        assetPrefixes: entry.exportAssetPrefixes,
+    };
+};