@mintlify/previewing 4.0.1588 → 4.0.1590

package/dist/__tests__/dev.test.js

@@ -67,7 +67,7 @@ describe('dev', () => {
         process.chdir = originalChdir;
     });
     it('happy path', async () => {
-        await dev(defaultYargs);
+        await dev({ ...defaultYargs, classic: true });
         expect(addLogSpy).toHaveBeenCalledWith(expect.objectContaining({ props: { message: 'preparing local preview...' } }));
         expect(seedPreviewFromSharedMock).toHaveBeenCalled();
         expect(silentUpdateClientMock).toHaveBeenCalled();
@@ -75,12 +75,12 @@ describe('dev', () => {
         expect(runMock).toHaveBeenCalled();
     });
     it('does not seed from shared when a specific client version is requested', async () => {
-        await dev({ ...defaultYargs, 'client-version': '1.2.3' });
+        await dev({ ...defaultYargs, classic: true, 'client-version': '1.2.3' });
         expect(seedPreviewFromSharedMock).not.toHaveBeenCalled();
         expect(silentUpdateClientMock).toHaveBeenCalled();
     });
     it('downloads the vite client without seeding it from the next workspace', async () => {
-        await dev({ ...defaultYargs, beta: true });
+        await dev(defaultYargs);
         expect(seedPreviewFromSharedMock).not.toHaveBeenCalled();
         expect(silentUpdateClientMock).toHaveBeenCalled();
         expect(runMock).toHaveBeenCalled();

package/dist/__tests__/export-assets.test.js

@@ -6,6 +6,7 @@ import { fileURLToPath } from 'url';
 import { collectAssetPaths, localizeAssets, rewriteCssUrls, } from '../local-preview/export-assets.js';
 import { fetchPublicAsset } from '../local-preview/export-fetch.js';
 import { generateExportLlmsTxt } from '../local-preview/export-llms.js';
+const NEXT_STATIC = path.join('_next', 'static');
 const ICON_URL = 'https://d3gk2c5xim1je2.cloudfront.net/fontawesome/v7.2.0/regular/house.svg';
 const GOOGLE_CSS_URL = 'https://fonts.googleapis.com/css2?family=Open+Sans:wght@400&display=swap';
 const asset = (body, contentType) => ({
@@ -58,7 +59,7 @@ describe('export assets', () => {
                 return asset(new Uint8Array([1, 2, 3]));
             return undefined;
         });
-        const result = await localizeAssets(exportDir, fetchAsset);
+        const result = await localizeAssets(exportDir, { stylesheetDir: NEXT_STATIC, fetchAsset });
         expect(result.failed).toEqual(['https://d3gk2c5xim1je2.cloudfront.net/missing.svg']);
         await expect(fse.readFile(path.join(exportDir, iconPath), 'utf8')).resolves.toBe('<svg/>');
         await expect(fse.readFile(path.join(exportDir, cssPath), 'utf8')).resolves.toBe('@font-face{src:url(../../../fonts.gstatic.com/s/a.woff2)}');
@@ -68,7 +69,10 @@ describe('export assets', () => {
     });
     it('does not report missing language icons as failed', async () => {
         await fse.outputFile(path.join(exportDir, 'index.html'), '<pre language="sql"></pre><pre language="python"></pre>');
-        const result = await localizeAssets(exportDir, async () => undefined);
+        const result = await localizeAssets(exportDir, {
+            stylesheetDir: NEXT_STATIC,
+            fetchAsset: async () => undefined,
+        });
         expect(result.failed).toEqual([]);
     });
 });
@@ -87,7 +91,7 @@ describe('localizeAssets path safety', () => {
         const fetchAsset = vi.fn(async (url) => url === cssUrl
             ? asset('@font-face{src:url(https://evil.example/%2e%2e%2f%2e%2e%2f%2e%2e%2fserve.js)}', 'text/css')
             : asset('malicious launcher'));
-        const result = await localizeAssets(exportDir, fetchAsset);
+        const result = await localizeAssets(exportDir, { stylesheetDir: NEXT_STATIC, fetchAsset });
         await expect(fse.readFile(path.join(exportDir, 'serve.js'), 'utf8')).resolves.toBe('original launcher');
         expect(result.failed).toContain('/_mintlify/export-assets/evil.example/%2e%2e%2f%2e%2e%2f%2e%2e%2fserve.js');
     });
@@ -106,7 +110,7 @@ describe('localizeAssets private destinations', () => {
         const fetchAsset = vi.fn(async (url) => url === cssUrl
             ? asset('.a{background:url(http://127.0.0.1:9000/secret.png)}', 'text/css')
             : fetchPublicAsset(url));
-        const result = await localizeAssets(exportDir, fetchAsset);
+        const result = await localizeAssets(exportDir, { stylesheetDir: NEXT_STATIC, fetchAsset });
         expect(result.failed).toEqual(['http://127.0.0.1:9000/secret.png']);
         await expect(fse.pathExists(path.join(exportDir, '_mintlify/export-assets/_http/127.0.0.1~9000/secret.png'))).resolves.toBe(false);
     });
@@ -123,7 +127,7 @@ describe('localizeAssets stylesheets', () => {
         const cssFile = path.join(exportDir, '_next', 'static', 'chunks', 'app.css');
         await fse.outputFile(cssFile, '@font-face{src:url(https://cdn.jsdelivr.net/gh/x/latex-css/fonts/LM-regular.woff2)}@font-face{src:url(//fonts.cdnfonts.com/s/1/cmuntt.woff)}@font-face{src:url(../media/inter.woff2)}');
         const fetchAsset = vi.fn(async () => asset(new Uint8Array([7])));
-        const result = await localizeAssets(exportDir, fetchAsset);
+        const result = await localizeAssets(exportDir, { stylesheetDir: NEXT_STATIC, fetchAsset });
         expect(result.failed).toEqual([]);
         await expect(fse.readFile(cssFile, 'utf8')).resolves.toBe('@font-face{src:url(../../../_mintlify/export-assets/cdn.jsdelivr.net/gh/x/latex-css/fonts/LM-regular.woff2)}@font-face{src:url(../../../_mintlify/export-assets/fonts.cdnfonts.com/s/1/cmuntt.woff)}@font-face{src:url(../media/inter.woff2)}');
         await expect(fse.pathExists(path.join(exportDir, '_mintlify/export-assets/fonts.cdnfonts.com/s/1/cmuntt.woff'))).resolves.toBe(true);

package/dist/__tests__/export-vite.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/export-vite.test.js

@@ -0,0 +1,101 @@
+import fse from 'fs-extra';
+import os from 'os';
+import path from 'path';
+import { bundleServerAssets, generateVitePages } from '../local-preview/export-vite.js';
+const html = (body, status = 200) => new Response(body, { status, headers: { 'content-type': 'text/html' } });
+describe('generateVitePages', () => {
+    let outputDir;
+    beforeEach(async () => {
+        outputDir = await fse.mkdtemp(path.join(os.tmpdir(), 'mint-export-vite-test-'));
+    });
+    afterEach(async () => {
+        await fse.remove(outputDir);
+    });
+    it('writes one html document per route', async () => {
+        const fetchPage = vi.fn(async (req) => html(new URL(req.url).pathname));
+        await expect(generateVitePages(fetchPage, ['/', '/guides/math'], outputDir, '/introduction')).resolves.toBe(0);
+        await expect(fse.readFile(path.join(outputDir, 'index.html'), 'utf8')).resolves.toBe('/introduction');
+        await expect(fse.readFile(path.join(outputDir, 'guides', 'math', 'index.html'), 'utf8')).resolves.toBe('/guides/math');
+        expect(await fse.pathExists(path.join(outputDir, 'guides', 'math', 'index.txt'))).toBe(false);
+    });
+    it('follows local redirects, like a root that redirects to the first page', async () => {
+        const fetchPage = vi.fn(async (req) => new URL(req.url).pathname === '/'
+            ? new Response(null, { status: 307, headers: { location: '/introduction' } })
+            : html(new URL(req.url).pathname));
+        await expect(generateVitePages(fetchPage, ['/'], outputDir)).resolves.toBe(0);
+        await expect(fse.readFile(path.join(outputDir, 'index.html'), 'utf8')).resolves.toBe('/introduction');
+    });
+    it('does not follow redirects off the local origin', async () => {
+        const fetchPage = vi.fn(async () => new Response(null, { status: 307, headers: { location: 'https://example.com/' } }));
+        await expect(generateVitePages(fetchPage, ['/'], outputDir)).resolves.toBe(1);
+        expect(fetchPage).toHaveBeenCalledTimes(1);
+    });
+    it('counts failed and non-html responses', async () => {
+        const fetchPage = vi.fn(async (req) => req.url.endsWith('/missing')
+            ? html('', 404)
+            : new Response('{}', { headers: { 'content-type': 'application/json' } }));
+        await expect(generateVitePages(fetchPage, ['/missing', '/json'], outputDir)).resolves.toBe(2);
+    });
+});
+const ASSET_PREFIXES = ['/_mintlify/custom/', '/_mintlify/assets/fonts/google/'];
+describe('bundleServerAssets', () => {
+    let outputDir;
+    beforeEach(async () => {
+        outputDir = await fse.mkdtemp(path.join(os.tmpdir(), 'mint-export-vite-test-'));
+    });
+    afterEach(async () => {
+        await fse.remove(outputDir);
+    });
+    it('writes the server assets the pages reference and reports failures', async () => {
+        await fse.outputFile(path.join(outputDir, 'index.html'), '<style>src:url(/_mintlify/assets/fonts/google/s/inter/v1/a.woff2) url(/_mintlify/assets/fonts/google/s/inter/v1/b.woff2)</style><script src="/_mintlify/custom/localhost/abc/script.js"></script>');
+        const fetchAsset = vi.fn(async (req) => req.url.endsWith('b.woff2') ? new Response(null, { status: 502 }) : new Response('ok'));
+        await expect(bundleServerAssets(fetchAsset, outputDir, ASSET_PREFIXES)).resolves.toEqual([
+            '/_mintlify/assets/fonts/google/s/inter/v1/b.woff2',
+        ]);
+        await expect(fse.readFile(path.join(outputDir, '_mintlify/assets/fonts/google/s/inter/v1/a.woff2'), 'utf8')).resolves.toBe('ok');
+        await expect(fse.readFile(path.join(outputDir, '_mintlify/custom/localhost/abc/script.js'), 'utf8')).resolves.toBe('ok');
+    });
+    it('fetches server assets referenced by fetched stylesheets', async () => {
+        await fse.outputFile(path.join(outputDir, 'index.html'), '<link rel="stylesheet" href="/_mintlify/custom/localhost/abc/style.css">');
+        const fetchAsset = vi.fn(async (req) => req.url.endsWith('style.css')
+            ? new Response('@font-face{src:url(/_mintlify/assets/fonts/google/s/geist/v1/c.woff2)}', {
+                headers: { 'content-type': 'text/css' },
+            })
+            : new Response('font'));
+        await expect(bundleServerAssets(fetchAsset, outputDir, ASSET_PREFIXES)).resolves.toEqual([]);
+        await expect(fse.readFile(path.join(outputDir, '_mintlify/assets/fonts/google/s/geist/v1/c.woff2'), 'utf8')).resolves.toBe('font');
+    });
+    it('writes percent-encoded custom filenames decoded', async () => {
+        await fse.outputFile(path.join(outputDir, 'index.html'), '<script src="/_mintlify/custom/localhost/abc/custom%281%29%21%27.js"></script>');
+        const fetchAsset = vi.fn(async () => new Response('ok'));
+        await expect(bundleServerAssets(fetchAsset, outputDir, ASSET_PREFIXES)).resolves.toEqual([]);
+        await expect(fse.readFile(path.join(outputDir, "_mintlify/custom/localhost/abc/custom(1)!'.js"), 'utf8')).resolves.toBe('ok');
+    });
+    it('collects assets under a base path', async () => {
+        await fse.outputFile(path.join(outputDir, 'index.html'), '<link href="/docs/_mintlify/custom/localhost/abc/style.css"><style>src:url(/docs/_mintlify/assets/fonts/google/s/a.woff2)</style>');
+        const fetchAsset = vi.fn(async (_req) => new Response('ok'));
+        await expect(bundleServerAssets(fetchAsset, outputDir, ASSET_PREFIXES)).resolves.toEqual([]);
+        expect(fetchAsset.mock.calls.map(([req]) => new URL(req.url).pathname).sort()).toEqual([
+            '/_mintlify/assets/fonts/google/s/a.woff2',
+            '/_mintlify/custom/localhost/abc/style.css',
+        ]);
+    });
+    it('strips quotes from css urls', async () => {
+        await fse.outputFile(path.join(outputDir, 'index.html'), `<style>src:url("/_mintlify/assets/fonts/google/s/a.woff2") url('/_mintlify/custom/localhost/abc/b.png')</style>`);
+        const fetchAsset = vi.fn(async (_req) => new Response('ok'));
+        await expect(bundleServerAssets(fetchAsset, outputDir, ASSET_PREFIXES)).resolves.toEqual([]);
+        expect(fetchAsset.mock.calls.map(([req]) => new URL(req.url).pathname).sort()).toEqual([
+            '/_mintlify/assets/fonts/google/s/a.woff2',
+            '/_mintlify/custom/localhost/abc/b.png',
+        ]);
+    });
+    it('never writes encoded traversal paths outside the export', async () => {
+        await fse.outputFile(path.join(outputDir, 'index.html'), '<script src="/_mintlify/custom/%2e%2e/%2e%2e/%2e%2e/escape.js"></script>');
+        const fetchAsset = vi.fn(async () => new Response('x'));
+        await expect(bundleServerAssets(fetchAsset, outputDir, ASSET_PREFIXES)).resolves.toEqual([
+            '/_mintlify/custom/%2e%2e/%2e%2e/%2e%2e/escape.js',
+        ]);
+        expect(fetchAsset).not.toHaveBeenCalled();
+        expect(await fse.pathExists(path.join(path.dirname(outputDir), 'escape.js'))).toBe(false);
+    });
+});

package/dist/__tests__/export.test.js

@@ -1,7 +1,8 @@
 import fse from 'fs-extra';
 import os from 'os';
 import path from 'path';
-import { generatePages, withIndexRouteAliases, writeStaticUserInfo, } from '../local-preview/export.js';
+import { generatePages } from '../local-preview/export-next.js';
+import { withIndexRouteAliases, writeStaticUserInfo } from '../local-preview/export.js';
 import { getGroupFilteredRoutes } from '../local-preview/getGroupFilteredRoutes.js';
 describe('getGroupFilteredRoutes', () => {
     it('prunes routes outside the selected groups', () => {

package/dist/constants.d.ts

@@ -16,7 +16,7 @@ export declare let TAR_PATH: string;
 export type ClientFramework = 'next' | 'vite';
 export declare let CLIENT_FRAMEWORK: ClientFramework;
 export declare const configurePreviewPath: (port?: string | number, framework?: ClientFramework) => void;
-export declare const configureSharedPreviewPath: () => void;
+export declare const configureSharedPreviewPath: (framework?: ClientFramework) => void;
 export declare const MINT_CLIENT_RELEASES_CLOUDFRONT_URL = "https://releases.mintlify.com";
 export declare const TARGET_MINT_VERSION_URL = "https://releases.mintlify.com/mint-version.txt";
 export declare const MINT_VERSION_MAP_URL = "https://releases.mintlify.com/mint-version-map.json";

package/dist/constants.js

@@ -43,8 +43,8 @@ export const configurePreviewPath = (port = 3000, framework = 'next') => {
     }
     setPreviewPath(String(numericPort), framework);
 };
-export const configureSharedPreviewPath = () => {
-    setPreviewPath('shared');
+export const configureSharedPreviewPath = (framework = 'next') => {
+    setPreviewPath('shared', framework);
 };
 configureSharedPreviewPath();
 export const MINT_CLIENT_RELEASES_CLOUDFRONT_URL = 'https://releases.mintlify.com';

package/dist/local-preview/export-assets.d.ts

@@ -6,4 +6,7 @@ export type LocalizeAssetsResult = {
 export declare function walkFiles(dir: string): AsyncGenerator<string>;
 export declare function collectAssetPaths(exportDir: string): Promise<Set<string>>;
 export declare function rewriteCssUrls(css: string, cssUrl: string | undefined, cssAssetPath: string, onAsset: (assetPath: string) => void): string;
-export declare function localizeAssets(exportDir: string, fetchAsset?: FetchAsset): Promise<LocalizeAssetsResult>;
+export declare function localizeAssets(exportDir: string, { stylesheetDir, fetchAsset, }: {
+    stylesheetDir: string;
+    fetchAsset?: FetchAsset;
+}): Promise<LocalizeAssetsResult>;

package/dist/local-preview/export-assets.js

@@ -73,11 +73,11 @@ export function rewriteCssUrls(css, cssUrl, cssAssetPath, onAsset) {
         return `url(${quote}${relativePath}${quote})`;
     });
 }
-async function localizeStylesheets(exportDir, onAsset) {
-    const nextStaticDir = path.join(exportDir, '_next', 'static');
-    if (!(await fse.pathExists(nextStaticDir)))
+async function localizeStylesheets(exportDir, stylesheetDir, onAsset) {
+    const dir = path.join(exportDir, stylesheetDir);
+    if (!(await fse.pathExists(dir)))
         return;
-    for await (const file of walkFiles(nextStaticDir)) {
+    for await (const file of walkFiles(dir)) {
         if (!file.endsWith('.css'))
             continue;
         const css = await fse.readFile(file, 'utf8');
@@ -87,7 +87,7 @@ async function localizeStylesheets(exportDir, onAsset) {
             await fse.writeFile(file, rewritten, 'utf8');
     }
 }
-export async function localizeAssets(exportDir, fetchAsset = fetchPublicAsset) {
+export async function localizeAssets(exportDir, { stylesheetDir, fetchAsset = fetchPublicAsset, }) {
     const queue = [...(await collectAssetPaths(exportDir))];
     const seen = new Set(queue);
     const downloaded = [];
@@ -98,7 +98,7 @@ export async function localizeAssets(exportDir, fetchAsset = fetchPublicAsset) {
         seen.add(assetPath);
         queue.push(assetPath);
     };
-    await localizeStylesheets(exportDir, enqueue);
+    await localizeStylesheets(exportDir, stylesheetDir, enqueue);
     const localize = async (assetPath) => {
         const url = fromMintExportAssetPath(assetPath);
         const outputPath = resolveOutputPath(exportDir, assetPath);

package/dist/local-preview/export-next.d.ts

@@ -0,0 +1,3 @@
+import { type ExportRenderer } from './export-pages.js';
+export declare const generatePages: (baseUrl: string, routes: string[], outputDir: string, rootRoute?: string) => Promise<number>;
+export declare function createNextRenderer(groups: string[] | undefined, basePath: string): Promise<ExportRenderer>;

package/dist/local-preview/export-next.js

@@ -0,0 +1,68 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import express from 'express';
+import fse, { pathExists } from 'fs-extra';
+import { createServer } from 'http';
+import path from 'path';
+import { CLIENT_PATH, NEXT_PUBLIC_PATH } from '../constants.js';
+import { addLog } from '../logging-state.js';
+import { SpinnerLog } from '../logs.js';
+import { applyBasePathToExport } from './export-base-path.js';
+import { writePages } from './export-pages.js';
+import { setupNext } from './setupNext.js';
+const RSC_CONTENT_TYPE = 'text/x-component';
+const RSC_PAYLOAD_FILE = 'index.txt';
+export const generatePages = (baseUrl, routes, outputDir, rootRoute) => writePages(routes, outputDir, rootRoute, async (requestRoute) => {
+    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)
+        return { status: res.ok ? rscRes.status : res.status };
+    return { files: { 'index.html': await res.text(), [RSC_PAYLOAD_FILE]: await rscRes.text() } };
+});
+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 };
+}
+async function closeServer(server) {
+    await new Promise((resolve) => {
+        server.close(() => resolve());
+    });
+}
+export async function createNextRenderer(groups, basePath) {
+    addLog(_jsx(SpinnerLog, { message: "starting local server..." }));
+    process.env.MINT_EXPORT = JSON.stringify({ groups, basePath: basePath || undefined });
+    const { server, port } = await startServer(basePath);
+    return {
+        readme: 'README.classic.md',
+        stylesheetDir: path.join('_next', 'static'),
+        generatePages: (routes, outputDir, rootRoute) => generatePages(`http://localhost:${port}`, routes, outputDir, rootRoute),
+        copyAssets: async (exportDir) => {
+            const nextStaticSrc = path.join(CLIENT_PATH, '.next', 'static');
+            if (await pathExists(nextStaticSrc)) {
+                await fse.copy(nextStaticSrc, path.join(exportDir, '_next', 'static'));
+            }
+        },
+        bundleAssets: async (exportDir) => {
+            await applyBasePathToExport(exportDir, basePath);
+            return [];
+        },
+        close: () => closeServer(server),
+    };
+}

package/dist/local-preview/export-pages.d.ts

@@ -0,0 +1,16 @@
+export type ExportRenderer = {
+    readme: string;
+    stylesheetDir: string;
+    generatePages: (routes: string[], outputDir: string, rootRoute?: string) => Promise<number>;
+    copyAssets: (exportDir: string) => Promise<void>;
+    bundleAssets: (exportDir: string) => Promise<string[]>;
+    close: () => Promise<void>;
+};
+export declare const resolveRequestRoute: (route: string, rootRoute: string | undefined) => string;
+export declare function forEachConcurrent<T>(items: T[], task: (item: T) => Promise<void>): Promise<void>;
+export type RenderedPage = {
+    files: Record<string, string>;
+} | {
+    status: number;
+};
+export declare function writePages(routes: string[], outputDir: string, rootRoute: string | undefined, render: (requestRoute: string) => Promise<RenderedPage>): Promise<number>;

package/dist/local-preview/export-pages.js

@@ -0,0 +1,36 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import fse from 'fs-extra';
+import path from 'path';
+import { addLog } from '../logging-state.js';
+import { ErrorLog } from '../logs.js';
+const CONCURRENCY = 10;
+export const resolveRequestRoute = (route, rootRoute) => route === '/' && rootRoute ? rootRoute : route;
+export async function forEachConcurrent(items, task) {
+    const queue = [...items];
+    const worker = async () => {
+        for (let item = queue.shift(); item !== undefined; item = queue.shift())
+            await task(item);
+    };
+    await Promise.all(Array.from({ length: Math.min(CONCURRENCY, queue.length) }, worker));
+}
+export async function writePages(routes, outputDir, rootRoute, render) {
+    let failedPageCount = 0;
+    const fail = (message) => {
+        failedPageCount += 1;
+        addLog(_jsx(ErrorLog, { message: message }));
+    };
+    await forEachConcurrent(routes, async (route) => {
+        try {
+            const page = await render(resolveRequestRoute(route, rootRoute));
+            if ('status' in page)
+                return fail(`failed to generate ${route} (status ${page.status})`);
+            const pageDir = route === '/' ? outputDir : path.join(outputDir, route);
+            await fse.ensureDir(pageDir);
+            await Promise.all(Object.entries(page.files).map(([name, body]) => fse.writeFile(path.join(pageDir, name), body, 'utf8')));
+        }
+        catch (err) {
+            fail(`failed to generate ${route}: ${err instanceof Error ? err.message : 'unknown error'}`);
+        }
+    });
+    return failedPageCount;
+}

package/dist/local-preview/export-vite.d.ts

@@ -0,0 +1,9 @@
+import { type ExportRenderer } from './export-pages.js';
+import { type ExportFetch } from './setupVite.js';
+export declare const generateVitePages: (fetchPage: ExportFetch, routes: string[], outputDir: string, rootRoute?: string) => Promise<number>;
+export declare function copyViteAssets(exportDir: string): Promise<void>;
+export declare function bundleServerAssets(fetchAsset: ExportFetch, exportDir: string, assetPrefixes: string[]): Promise<string[]>;
+export declare function createViteRenderer(mintExport: {
+    groups?: string[];
+    basePath?: string;
+}): Promise<ExportRenderer>;

package/dist/local-preview/export-vite.js

@@ -0,0 +1,90 @@
+import fse, { pathExists } from 'fs-extra';
+import path from 'path';
+import { CLIENT_PATH } from '../constants.js';
+import { walkFiles } from './export-assets.js';
+import { forEachConcurrent, writePages } from './export-pages.js';
+import { setupViteExport } from './setupVite.js';
+const MAX_REDIRECTS = 5;
+const EXPORT_ORIGIN = 'http://localhost';
+const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const serverAssetPattern = (prefixes) => new RegExp(`(?:${prefixes.map(escapeRegExp).join('|')})[^"'()\\s]+`, 'g');
+const exportRequest = (route) => new Request(`${EXPORT_ORIGIN}${route}`, { headers: { accept: 'text/html' } });
+async function fetchFollowingRedirects(fetchExport, route) {
+    let res = await fetchExport(exportRequest(route));
+    for (let hops = 0; hops < MAX_REDIRECTS && res.status >= 300 && res.status < 400; hops++) {
+        const location = res.headers.get('location');
+        if (!location)
+            break;
+        const target = new URL(location, `${EXPORT_ORIGIN}${route}`);
+        if (target.origin !== EXPORT_ORIGIN)
+            break;
+        route = `${target.pathname}${target.search}`;
+        res = await fetchExport(exportRequest(route));
+    }
+    return res;
+}
+export const generateVitePages = (fetchPage, routes, outputDir, rootRoute) => writePages(routes, outputDir, rootRoute, async (requestRoute) => {
+    const res = await fetchFollowingRedirects(fetchPage, requestRoute);
+    if (!res.ok || !res.headers.get('content-type')?.includes('text/html')) {
+        return { status: res.status };
+    }
+    return { files: { 'index.html': await res.text() } };
+});
+export async function copyViteAssets(exportDir) {
+    const assetsDir = path.join(CLIENT_PATH, 'dist', 'client', '_mintlify');
+    if (!(await pathExists(assetsDir)))
+        throw new Error('client assets not found, rerun online to fetch the latest client');
+    await fse.copy(assetsDir, path.join(exportDir, '_mintlify'));
+}
+export async function bundleServerAssets(fetchAsset, exportDir, assetPrefixes) {
+    const pattern = serverAssetPattern(assetPrefixes);
+    const seen = new Set();
+    let pending = [];
+    const collect = (source) => {
+        for (const [assetPath] of source.matchAll(pattern)) {
+            if (seen.has(assetPath))
+                continue;
+            seen.add(assetPath);
+            pending.push(assetPath);
+        }
+    };
+    for await (const file of walkFiles(exportDir)) {
+        if (file.endsWith('.html'))
+            collect(await fse.readFile(file, 'utf8'));
+    }
+    const failed = [];
+    while (pending.length > 0) {
+        const batch = pending;
+        pending = [];
+        await forEachConcurrent(batch, async (assetPath) => {
+            try {
+                const outputPath = path.join(exportDir, decodeURIComponent(assetPath));
+                if (!outputPath.startsWith(exportDir + path.sep))
+                    throw new Error('outside export');
+                const res = await fetchAsset(new Request(`${EXPORT_ORIGIN}${assetPath}`));
+                if (!res.ok)
+                    throw new Error(`status ${res.status}`);
+                const body = Buffer.from(await res.arrayBuffer());
+                if (res.headers.get('content-type')?.includes('text/css') || assetPath.endsWith('.css')) {
+                    collect(body.toString('utf8'));
+                }
+                await fse.outputFile(outputPath, body);
+            }
+            catch {
+                failed.push(assetPath);
+            }
+        });
+    }
+    return failed;
+}
+export async function createViteRenderer(mintExport) {
+    const { fetchPage, assetPrefixes } = await setupViteExport(mintExport);
+    return {
+        readme: 'README.md',
+        stylesheetDir: path.join('_mintlify', 'assets'),
+        generatePages: (routes, outputDir, rootRoute) => generateVitePages(fetchPage, routes, outputDir, rootRoute),
+        copyAssets: copyViteAssets,
+        bundleAssets: (exportDir) => bundleServerAssets(fetchPage, exportDir, assetPrefixes),
+        close: async () => { },
+    };
+}

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

@@ -1,6 +1,5 @@
 import { ArgumentsCamelCase } from 'yargs';
 export declare const withIndexRouteAliases: (routes: string[]) => string[];
-export declare function generatePages(baseUrl: string, routes: string[], outputDir: string, rootRoute?: string): Promise<number>;
 export declare function writeStaticUserInfo(tmpDir: string, groups: string[] | undefined): Promise<void>;
 export declare function writeLlmsTxt(tmpDir: string, routes: string[], basePath?: string): Promise<void>;
 export declare const exportSite: (argv: ArgumentsCamelCase) => Promise<void>;