@mintlify/previewing 4.0.1216 → 4.0.1218

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

@@ -11,6 +11,7 @@ import pathUtil from 'path';
 import { CMD_EXEC_PATH, NEXT_PROPS_PATH, NEXT_PUBLIC_PATH, CLIENT_PATH } from '../../constants.js';
 import { addChangeLog, addErrorLog, clearErrorLogs, getCurrentErrorLogs, } from '../../logging-state.js';
 import { AddedLog, DeletedLog, EditedLog, WarningLog, InfoLog, ErrorLog } from '../../logs.js';
+import { reportPageCompileError, reportPageCompileSuccess } from '../on-demand-page.js';
 import { clearDocsConfigCaches, getDocsConfigApiHash, getDocsConfigNavigationHash, getVariablesHash, hasDocsConfigApiChanged, hasDocsConfigNavigationChanged, hasNavigationApiReference, hasDocsConfigVariablesChanged, updateDocsConfigHashCache, } from './docs-config-cache.js';
 import { generateDependentSnippets } from './generateDependentSnippets.js';
 import { generatePagesWithImports } from './generatePagesWithImports.js';
@@ -154,6 +155,9 @@ const onUnlinkEvent = async (filename, triggerRefresh, options) => {
         const potentialCategory = getFileCategory(filename, { importedFiles });
         frontmatterHashes.delete(filename);
         removePageMetadataCacheEntryForFile(filename);
+        if (potentialCategory === 'page') {
+            reportPageCompileSuccess(filename);
+        }
         if (hasTrackedReferencedFile(filename)) {
             try {
                 const { mintConfig, openApiFiles, docsConfig } = await getDocsState(handleParseError);
@@ -359,16 +363,36 @@ const onUpdateEvent = async (filename, triggerRefresh, options = {}) => {
         case 'page': {
             let contentStr = (await readFile(filePath)).toString();
             regenerateNavFromPageMetadataCache = await shouldRegenerateNavForPage(filename, contentStr, frontmatterHashes, handleParseError);
-            const tree = await preparseMdxTree(contentStr, CMD_EXEC_PATH, filePath, suppressParseError);
-            const importsResponse = await findAndRemoveImports(tree);
-            if (hasImports(importsResponse)) {
-                contentStr = stringifyTree(await resolvePageImports({ ...importsResponse, filename }));
+            let pageFailed = false;
+            const capturePageError = () => {
+                pageFailed = true;
+            };
+            const capturePageErrorAndLog = (message) => {
+                pageFailed = true;
+                handleParseError(message);
+            };
+            try {
+                const tree = await preparseMdxTree(contentStr, CMD_EXEC_PATH, filePath, capturePageError);
+                const importsResponse = await findAndRemoveImports(tree);
+                if (hasImports(importsResponse)) {
+                    contentStr = stringifyTree(await resolvePageImports({ ...importsResponse, filename }));
+                }
+                const { pageContent, pageMetadata, slug } = await createPage(filename, contentStr, CMD_EXEC_PATH, [], [], capturePageErrorAndLog);
+                await fse.outputFile(targetPath, pageContent, {
+                    flag: 'w',
+                });
+                upsertPageMetadataCacheEntry(slug, pageMetadata);
+            }
+            catch (error) {
+                reportPageCompileError(filename);
+                throw error;
+            }
+            if (pageFailed) {
+                reportPageCompileError(filename);
+            }
+            else {
+                reportPageCompileSuccess(filename);
             }
-            const { pageContent, pageMetadata, slug } = await createPage(filename, contentStr, CMD_EXEC_PATH, [], [], handleParseError);
-            await fse.outputFile(targetPath, pageContent, {
-                flag: 'w',
-            });
-            upsertPageMetadataCacheEntry(slug, pageMetadata);
             break;
         }
         case 'snippet': {

package/dist/local-preview/on-demand-page.d.ts

@@ -2,9 +2,13 @@ export declare const markOnDemandPagesReady: () => void;
 export type CompileEvent = {
     path: string;
     active: boolean;
+    error?: boolean;
 };
 type CompileListener = (event: CompileEvent) => void;
 export declare const setCompileListener: (listener: CompileListener) => void;
+export declare const getFailedCompileEvents: () => CompileEvent[];
+export declare const reportPageCompileSuccess: (filename: string) => void;
+export declare const reportPageCompileError: (filename: string) => void;
 export declare const ensurePageCompiled: (pathname: string, options?: {
     silent?: boolean;
 }) => Promise<void>;

package/dist/local-preview/on-demand-page.js

@@ -8,7 +8,7 @@ import { startDevTiming } from './dev-timing.js';
 import { getImportedFilesFromCache } from './listener/importCache.js';
 import { upsertPageMetadataCacheEntry } from './listener/page-metadata-cache.js';
 import { resolvePageImports } from './listener/resolve-page-imports.js';
-import { getMintIgnoreGlobs, handleParseError, suppressParseError } from './listener/utils.js';
+import { getMintIgnoreGlobs, handleParseError } from './listener/utils.js';
 const { readFile } = _promises;
 let resolveReady = () => { };
 const ready = new Promise((resolve) => {
@@ -27,11 +27,12 @@ const pagePathForFilename = (filename) => {
 const trackCompile = async (filename, task) => {
     const path = pagePathForFilename(filename);
     compileListener?.({ path, active: true });
+    let failed = false;
     try {
-        return await task();
+        failed = await task();
     }
     finally {
-        compileListener?.({ path, active: false });
+        compileListener?.({ path, active: false, error: failed || undefined });
     }
 };
 const inflight = new Map();
@@ -69,25 +70,50 @@ const candidateFilenames = (slug) => [
     `${slug}/index.md`,
 ];
 const failedCompiles = new Map();
+export const getFailedCompileEvents = () => Array.from(failedCompiles.keys()).map((filename) => ({
+    path: pagePathForFilename(filename),
+    active: false,
+    error: true,
+}));
+export const reportPageCompileSuccess = (filename) => {
+    if (!failedCompiles.delete(filename))
+        return;
+    compileListener?.({ path: pagePathForFilename(filename), active: false });
+};
+export const reportPageCompileError = (filename) => {
+    failedCompiles.set(filename, 0);
+    compileListener?.({ path: pagePathForFilename(filename), active: false, error: true });
+};
 const compilePage = async (filename, sourcePath, targetPath, sourceMtimeMs) => {
     const finish = startDevTiming(`compile ${filename}`);
+    let hasParseError = false;
+    const captureParseError = () => {
+        hasParseError = true;
+    };
     try {
         let contentStr = (await readFile(sourcePath)).toString();
-        const tree = await preparseMdxTree(contentStr, CMD_EXEC_PATH, sourcePath, suppressParseError);
+        const tree = await preparseMdxTree(contentStr, CMD_EXEC_PATH, sourcePath, captureParseError);
         const importsResponse = await findAndRemoveImports(tree);
         if (hasImports(importsResponse)) {
             contentStr = stringifyTree(await resolvePageImports({ ...importsResponse, filename }));
         }
-        const { pageContent, pageMetadata, slug } = await createPage(filename, contentStr, CMD_EXEC_PATH, [], [], suppressParseError);
+        const { pageContent, pageMetadata, slug } = await createPage(filename, contentStr, CMD_EXEC_PATH, [], [], captureParseError);
         await fse.outputFile(targetPath, pageContent, { flag: 'w' });
         upsertPageMetadataCacheEntry(slug, pageMetadata);
+        if (hasParseError) {
+            failedCompiles.set(filename, sourceMtimeMs);
+            finish('failed');
+            return true;
+        }
         failedCompiles.delete(filename);
         finish();
+        return false;
     }
     catch (error) {
         failedCompiles.set(filename, sourceMtimeMs);
         handleParseError(`Failed to compile ${filename}: ${error instanceof Error ? error.message : String(error)}`);
         finish('failed');
+        return true;
     }
 };
 export const ensurePageCompiled = async (pathname, options = {}) => {
@@ -106,6 +132,16 @@ export const ensurePageCompiled = async (pathname, options = {}) => {
         const sourceStat = await fse.stat(sourcePath);
         const targetPath = pathUtil.join(NEXT_PROPS_PATH, filename);
         const targetStat = await fse.stat(targetPath).catch(() => undefined);
+        if (failedCompiles.get(filename) === sourceStat.mtimeMs) {
+            if (!options.silent) {
+                compileListener?.({
+                    path: pagePathForFilename(filename),
+                    active: false,
+                    error: true,
+                });
+            }
+            return;
+        }
         if (targetStat !== undefined && targetStat.mtimeMs >= sourceStat.mtimeMs) {
             return;
         }
@@ -113,14 +149,15 @@ export const ensurePageCompiled = async (pathname, options = {}) => {
         if (getFileCategory(filename, { importedFiles: getImportedFilesFromCache() }) !== 'page') {
             continue;
         }
-        if (failedCompiles.get(filename) === sourceStat.mtimeMs) {
-            continue;
-        }
         const pending = inflight.get(filename) ??
             compilePage(filename, sourcePath, targetPath, sourceStat.mtimeMs).finally(() => {
                 inflight.delete(filename);
             });
         inflight.set(filename, pending);
-        return options.silent ? pending : trackCompile(filename, () => pending);
+        if (options.silent) {
+            await pending;
+            return;
+        }
+        return trackCompile(filename, () => pending);
     }
 };

package/dist/local-preview/run.js

@@ -11,7 +11,7 @@ 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, markOnDemandPagesReady, setCompileListener } from './on-demand-page.js';
+import { ensurePageCompiled, getFailedCompileEvents, markOnDemandPagesReady, setCompileListener, } from './on-demand-page.js';
 import { setupNext } from './setupNext.js';
 const PROXY_RESPONSE_HEADER_DENYLIST = new Set([
     'connection',
@@ -135,6 +135,11 @@ export const run = async (argv) => {
     setCompileListener((event) => {
         io.emit('compiling', event);
     });
+    io.on('connection', (socket) => {
+        for (const event of getFailedCompileEvents()) {
+            socket.emit('compiling', event);
+        }
+    });
     const finishServerListenTiming = startDevTiming('server ready');
     server.listen(currentPort, () => {
         finishServerListenTiming();