@mintlify/previewing 4.0.853 → 4.0.855

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

@@ -2,6 +2,7 @@ import { categorizeFilePaths, createPage, generateDecoratedDocsNavigationFromPag
 import { promises as _promises } from 'fs';
 import { join } from 'path';
 import { CMD_EXEC_PATH } from '../../constants.js';
+import { handleParseError } from './utils.js';
 const { readFile } = _promises;
 const createFilenamePageMetadataMap = async ({ contentDirectoryPath, contentFilenames, openApiFiles, asyncApiFiles, pagesAcc = {}, }) => {
     const contentPromises = [];
@@ -9,7 +10,7 @@ const createFilenamePageMetadataMap = async ({ contentDirectoryPath, contentFile
         contentPromises.push((async () => {
             const sourcePath = join(contentDirectoryPath, filename);
             const contentStr = (await readFile(sourcePath)).toString();
-            const { slug, pageMetadata } = await createPage(filename, contentStr, contentDirectoryPath, openApiFiles, asyncApiFiles, true);
+            const { slug, pageMetadata } = await createPage(filename, contentStr, contentDirectoryPath, openApiFiles, asyncApiFiles, handleParseError);
             pagesAcc = {
                 ...pagesAcc,
                 [slug]: pageMetadata,

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

@@ -6,6 +6,7 @@ import { join } from 'path';
 import { CMD_EXEC_PATH, NEXT_PROPS_PATH } from '../../constants.js';
 import { getProcessedSnippets } from './getSnippets.js';
 import { getImportedFilesFromCache } from './importCache.js';
+import { handleParseError } from './utils.js';
 const { readFile } = _promises;
 export const generatePagesWithImports = async (updatedSnippets) => {
     const snippets = await getProcessedSnippets();
@@ -21,7 +22,7 @@ export const generatePagesWithImports = async (updatedSnippets) => {
         const sourcePath = join(CMD_EXEC_PATH, pageFilename);
         const contentStr = (await readFile(sourcePath)).toString();
         try {
-            const tree = await preparseMdxTree(contentStr, CMD_EXEC_PATH, sourcePath);
+            const tree = await preparseMdxTree(contentStr, CMD_EXEC_PATH, sourcePath, handleParseError);
             const importsResponse = await findAndRemoveImports(tree);
             if (Object.keys(importsResponse.importMap).some((importPath) => {
                 const resolvedPath = resolveImportPath(importPath, pageFilename);

package/dist/local-preview/listener/getDocsState.d.ts

@@ -1,6 +1,6 @@
 import type { DecoratedNavigationPage, MintConfig, OpenApiFile } from '@mintlify/models';
 import { DocsConfig } from '@mintlify/validation';
-export declare const getDocsState: () => Promise<{
+export declare const getDocsState: (onError?: (message: string) => void) => Promise<{
     mintConfig?: MintConfig;
     pagesAcc: Record<string, DecoratedNavigationPage>;
     openApiFiles: OpenApiFile[];

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

@@ -3,11 +3,11 @@ import { upgradeToDocsConfig } from '@mintlify/validation';
 import fse from 'fs-extra';
 import { join } from 'path';
 import { CMD_EXEC_PATH, CLIENT_PATH } from '../../constants.js';
-export const getDocsState = async () => {
+export const getDocsState = async (onError) => {
     const mintIgnore = await getMintIgnore(CMD_EXEC_PATH);
     const { openApiFiles } = await categorizeFilePaths(CMD_EXEC_PATH, mintIgnore);
     try {
-        const mintConfig = await MintConfigUpdater.getConfig(join(CMD_EXEC_PATH, 'mint.json'));
+        const mintConfig = await MintConfigUpdater.getConfig(join(CMD_EXEC_PATH, 'mint.json'), onError);
         const docsConfig = upgradeToDocsConfig(mintConfig);
         const { mintConfig: newMintConfig } = await generateOpenApiAnchorsOrTabs(mintConfig, openApiFiles, CLIENT_PATH);
         const { newDocsConfig, pagesAcc, openApiFiles: newOpenApiFiles, } = await generateOpenApiDivisions(docsConfig, openApiFiles, CLIENT_PATH);
@@ -22,7 +22,7 @@ export const getDocsState = async () => {
         const docsJsonPath = join(CMD_EXEC_PATH, 'docs.json');
         if (!(await fse.pathExists(docsJsonPath)))
             throw new Error('No config found');
-        const docsConfig = await DocsConfigUpdater.getConfig(docsJsonPath);
+        const docsConfig = await DocsConfigUpdater.getConfig(docsJsonPath, onError);
         const { newDocsConfig, pagesAcc, openApiFiles: newOpenApiFiles, } = await generateOpenApiDivisions(docsConfig, openApiFiles, CLIENT_PATH);
         return { pagesAcc, openApiFiles: newOpenApiFiles, docsConfig: newDocsConfig };
     }

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

@@ -4,6 +4,7 @@ import { promises as _promises } from 'fs';
 import { join } from 'path';
 import { CMD_EXEC_PATH, NEXT_PUBLIC_PATH } from '../../constants.js';
 import { getImportedFilesFromCache } from './importCache.js';
+import { handleParseError } from './utils.js';
 const { readFile } = _promises;
 const getSnippetBase = async (baseDir) => {
     const importedFiles = getImportedFilesFromCache();
@@ -21,7 +22,7 @@ const getSnippetBase = async (baseDir) => {
     });
     const promises = allSnippetFilenames.map(async (snippetFilename) => {
         try {
-            const tree = await preparseMdxTree((await readFile(join(baseDir, snippetFilename))).toString(), baseDir, join(baseDir, snippetFilename));
+            const tree = await preparseMdxTree((await readFile(join(baseDir, snippetFilename))).toString(), baseDir, join(baseDir, snippetFilename), handleParseError);
             return {
                 filename: optionallyAddLeadingSlash(snippetFilename),
                 tree,

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

@@ -5,7 +5,7 @@ import fse from 'fs-extra';
 import { join } from 'path';
 import { CMD_EXEC_PATH, NEXT_PROPS_PATH, NEXT_PUBLIC_PATH } from '../../constants.js';
 import { resolveAllImports } from './resolveAllImports.js';
-import { normalizePathForComparison } from './utils.js';
+import { handleParseError, normalizePathForComparison, suppressParseError } from './utils.js';
 const fileImportsMap = new Map();
 const importerCounts = new Map();
 const addImporter = (path) => {
@@ -28,7 +28,7 @@ const extractFileImports = async (baseDir, filename) => {
     const filePath = join(baseDir, filename);
     try {
         const content = (await fse.readFile(filePath)).toString();
-        const tree = await preparseMdxTree(content, baseDir, filePath);
+        const tree = await preparseMdxTree(content, baseDir, filePath, suppressParseError);
         const importSources = extractImportSources(tree);
         const imports = new Set();
         for (const source of importSources) {
@@ -115,7 +115,7 @@ const isSnippetByFolder = (path) => {
 };
 const resolveFileImports = async (sourcePath, relativePath) => {
     let contentStr = (await fse.readFile(sourcePath)).toString();
-    const tree = await preparseMdxTree(contentStr, CMD_EXEC_PATH, sourcePath);
+    const tree = await preparseMdxTree(contentStr, CMD_EXEC_PATH, sourcePath, handleParseError);
     const importsResponse = await findAndRemoveImports(tree);
     if (hasImports(importsResponse)) {
         contentStr = stringifyTree(await resolveAllImports({ ...importsResponse, filename: relativePath }));
@@ -155,7 +155,7 @@ export const syncImportedFileLocations = async (changes) => {
         if (await fse.pathExists(sourcePath)) {
             try {
                 const contentStr = await resolveFileImports(sourcePath, relativePath);
-                const { pageContent } = await createPage(relativePath, contentStr, CMD_EXEC_PATH, [], [], true);
+                const { pageContent } = await createPage(relativePath, contentStr, CMD_EXEC_PATH, [], [], suppressParseError);
                 await fse.outputFile(join(NEXT_PROPS_PATH, relativePath), pageContent, { flag: 'w' });
             }
             catch (err) {

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

@@ -9,7 +9,7 @@ import fs from 'fs/promises';
 import yaml from 'js-yaml';
 import pathUtil from 'path';
 import { CMD_EXEC_PATH, NEXT_PROPS_PATH, NEXT_PUBLIC_PATH, CLIENT_PATH } from '../../constants.js';
-import { addChangeLog } from '../../logging-state.js';
+import { addChangeLog, addErrorLog, clearErrorLogs, getCurrentErrorLogs, } from '../../logging-state.js';
 import { AddedLog, DeletedLog, EditedLog, WarningLog, InfoLog, ErrorLog } from '../../logs.js';
 import { generateDependentSnippets } from './generateDependentSnippets.js';
 import { generatePagesWithImports } from './generatePagesWithImports.js';
@@ -17,7 +17,7 @@ import { getDocsState } from './getDocsState.js';
 import { initializeImportCache, updateImportCacheForFile, removeFromImportCache, getImportedFilesFromCache, syncImportedFileLocations, } from './importCache.js';
 import { resolveAllImports } from './resolveAllImports.js';
 import { updateCustomLanguages, updateGeneratedNav, updateOpenApiFiles, upsertOpenApiFile, } from './update.js';
-import { getMintIgnoreGlobs, isFileSizeValid, isJsonValid, shouldRegenerateNavForPage, } from './utils.js';
+import { getMintIgnoreGlobs, handleParseError, isFileSizeValid, isJsonValid, shouldRegenerateNavForPage, suppressParseError, } from './utils.js';
 const { readFile } = _promises;
 const frontmatterHashes = new Map();
 const listener = (callback, options = {}) => {
@@ -168,6 +168,7 @@ const validateConfigFiles = async () => {
  * @returns FileCategory
  */
 const onUpdateEvent = async (filename, callback, options = {}) => {
+    clearErrorLogs();
     const filePath = pathUtil.join(CMD_EXEC_PATH, filename);
     const importChanges = await updateImportCacheForFile(CMD_EXEC_PATH, filename);
     await syncImportedFileLocations(importChanges);
@@ -186,14 +187,13 @@ const onUpdateEvent = async (filename, callback, options = {}) => {
     switch (potentialCategory) {
         case 'page': {
             let contentStr = (await readFile(filePath)).toString();
-            regenerateNav = await shouldRegenerateNavForPage(filename, contentStr, frontmatterHashes);
-            const tree = await preparseMdxTree(contentStr, CMD_EXEC_PATH, filePath);
+            regenerateNav = 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 resolveAllImports({ ...importsResponse, filename }));
             }
-            // set suppressErrLog true here to avoid double logging errors already logged in preparseMdxTree
-            const { pageContent } = await createPage(filename, contentStr, CMD_EXEC_PATH, [], [], true);
+            const { pageContent } = await createPage(filename, contentStr, CMD_EXEC_PATH, [], [], handleParseError);
             await fse.outputFile(targetPath, pageContent, {
                 flag: 'w',
             });
@@ -205,7 +205,7 @@ const onUpdateEvent = async (filename, callback, options = {}) => {
         }
         case 'snippet-v2': {
             let contentStr = (await readFile(filePath)).toString();
-            const tree = await preparseMdxTree(contentStr, CMD_EXEC_PATH, filePath);
+            const tree = await preparseMdxTree(contentStr, CMD_EXEC_PATH, filePath, handleParseError);
             const importsResponse = await findAndRemoveImports(tree);
             if (hasImports(importsResponse)) {
                 contentStr = stringifyTree(await resolveAllImports({ ...importsResponse, filename }));
@@ -221,21 +221,27 @@ const onUpdateEvent = async (filename, callback, options = {}) => {
         case 'docsConfig': {
             const { valid, error } = isJsonValid(filePath);
             if (!valid) {
-                addChangeLog(_jsx(ErrorLog, { message: `Syntax error in ${filename}: ${error}` }));
+                addErrorLog(_jsx(ErrorLog, { message: `Syntax error in ${filename}: ${error}` }));
                 return null;
             }
             regenerateNav = true;
             try {
-                const { mintConfig, openApiFiles, docsConfig } = await getDocsState();
+                const { mintConfig, openApiFiles, docsConfig } = await getDocsState(handleParseError);
                 if (mintConfig) {
                     await MintConfigUpdater.writeConfigFile(mintConfig, CLIENT_PATH);
                 }
                 await DocsConfigUpdater.writeConfigFile(docsConfig, CLIENT_PATH);
-                await updateOpenApiFiles(openApiFiles);
-                await updateCustomLanguages(docsConfig);
+                await updateOpenApiFiles(openApiFiles, suppressParseError);
+                await updateCustomLanguages(docsConfig, suppressParseError);
             }
             catch (err) {
-                console.error(err);
+                if (getCurrentErrorLogs().length > 0) {
+                    // no-op to suppress duplicate error logging
+                    return null;
+                }
+                else {
+                    console.error(err);
+                }
             }
             break;
         }
@@ -305,7 +311,7 @@ const onUpdateEvent = async (filename, callback, options = {}) => {
     }
     if (regenerateNav) {
         // TODO: Instead of re-generating the entire nav, optimize by just updating the specific page that changed.
-        await updateGeneratedNav();
+        await updateGeneratedNav(suppressParseError);
     }
     callback();
     return category;

package/dist/local-preview/listener/update.d.ts

@@ -1,6 +1,6 @@
 import { OpenApiFile } from '@mintlify/models';
 import { DocsConfig } from '@mintlify/validation';
-export declare const updateGeneratedNav: () => Promise<void>;
-export declare const updateOpenApiFiles: (providedOpenApiFiles?: OpenApiFile[]) => Promise<void>;
+export declare const updateGeneratedNav: (onError?: (message: string) => void) => Promise<void>;
+export declare const updateOpenApiFiles: (providedOpenApiFiles?: OpenApiFile[], onError?: (message: string) => void) => Promise<void>;
 export declare const upsertOpenApiFile: (openApiFile: OpenApiFile) => Promise<void>;
-export declare const updateCustomLanguages: (docsConfig?: DocsConfig) => Promise<void>;
+export declare const updateCustomLanguages: (docsConfig?: DocsConfig, onError?: (message: string) => void) => Promise<void>;

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

@@ -5,17 +5,17 @@ import { CMD_EXEC_PATH, NEXT_PROPS_PATH } from '../../constants.js';
 import { generateNav } from './generate.js';
 import { getDocsState } from './getDocsState.js';
 import { readJsonFile } from './utils.js';
-export const updateGeneratedNav = async () => {
-    const { pagesAcc, docsConfig } = await getDocsState();
+export const updateGeneratedNav = async (onError) => {
+    const { pagesAcc, docsConfig } = await getDocsState(onError);
     const generatedDocsNav = await generateNav(pagesAcc, docsConfig);
     const targetDocsPath = join(NEXT_PROPS_PATH, 'generatedDocsNav.json');
     await fse.outputFile(targetDocsPath, JSON.stringify(generatedDocsNav, null, 2), {
         flag: 'w',
     });
 };
-export const updateOpenApiFiles = async (providedOpenApiFiles) => {
+export const updateOpenApiFiles = async (providedOpenApiFiles, onError) => {
     if (providedOpenApiFiles == undefined) {
-        const { openApiFiles } = await getDocsState();
+        const { openApiFiles } = await getDocsState(onError);
         providedOpenApiFiles = openApiFiles;
     }
     const targetPath = join(NEXT_PROPS_PATH, 'openApiFiles.json');
@@ -41,9 +41,9 @@ export const upsertOpenApiFile = async (openApiFile) => {
         flag: 'w',
     });
 };
-export const updateCustomLanguages = async (docsConfig) => {
+export const updateCustomLanguages = async (docsConfig, onError) => {
     if (docsConfig == undefined) {
-        docsConfig = (await getDocsState()).docsConfig;
+        docsConfig = (await getDocsState(onError)).docsConfig;
     }
     const customLanguages = await getCustomLanguages({
         config: docsConfig,

package/dist/local-preview/listener/utils.d.ts

@@ -7,5 +7,7 @@ export declare const isJsonValid: (filePath: string) => {
     valid: boolean;
     error?: string;
 };
-export declare const shouldRegenerateNavForPage: (filename: string, contentStr: string, frontmatterHashes: Map<string, string>) => Promise<boolean>;
+export declare const shouldRegenerateNavForPage: (filename: string, contentStr: string, frontmatterHashes: Map<string, string>, onError?: (message: string) => void) => Promise<boolean>;
 export declare function normalizePathForComparison(filePath: string): string;
+export declare const handleParseError: (message: string) => void;
+export declare const suppressParseError: () => void;

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

@@ -4,6 +4,7 @@ import { promises as _promises, readFileSync, existsSync } from 'fs';
 import fse from 'fs-extra';
 import pathUtil from 'path';
 import { CMD_EXEC_PATH } from '../../constants.js';
+import { addRawErrorLog } from '../../logging-state.js';
 const { stat } = _promises;
 export const getFileExtension = (filename) => {
     return filename.substring(filename.lastIndexOf('.') + 1, filename.length) || filename;
@@ -41,7 +42,7 @@ export const isJsonValid = (filePath) => {
         return { valid: false, error: error.message };
     }
 };
-export const shouldRegenerateNavForPage = async (filename, contentStr, frontmatterHashes) => {
+export const shouldRegenerateNavForPage = async (filename, contentStr, frontmatterHashes, onError) => {
     try {
         const { attributes: currentFrontmatter } = parseFrontmatter(contentStr);
         const prevFrontmatterHash = frontmatterHashes.get(filename);
@@ -61,10 +62,25 @@ export const shouldRegenerateNavForPage = async (filename, contentStr, frontmatt
         return false;
     }
     catch (error) {
-        console.warn(`Error parsing frontmatter for ${filename}, regenerating nav:`, error);
+        const message = `Error parsing frontmatter for ${filename}, regenerating nav: ${error instanceof Error ? error.message : String(error)}`;
+        if (onError) {
+            onError(message);
+        }
+        else {
+            console.warn(message);
+        }
         return true;
     }
 };
 export function normalizePathForComparison(filePath) {
     return optionallyAddLeadingSlash(filePath).toLowerCase();
 }
+export const handleParseError = (message) => {
+    const trimmed = message.trim();
+    if (trimmed) {
+        addRawErrorLog(trimmed);
+    }
+};
+export const suppressParseError = () => {
+    // no-op to suppress duplicate error logging
+};

package/dist/logging-state.d.ts

@@ -1,7 +1,11 @@
 import React from 'react';
-export declare const setLoggingCallbacks: (setLogs: (logs: React.ReactNode[]) => void, setChangeLogs: (logs: React.ReactNode[]) => void) => void;
+export declare const setLoggingCallbacks: (setLogs: (logs: React.ReactNode[]) => void, setChangeLogs: (logs: React.ReactNode[]) => void, setErrorLogs: (logs: React.ReactNode[]) => void) => void;
 export declare const addLog: (log: React.ReactNode) => void;
 export declare const addLogs: (...logs: React.ReactNode[]) => void;
 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 clearLogs: () => void;
 export declare const removeLastLog: () => void;
+export declare const getCurrentErrorLogs: () => React.ReactNode[];

package/dist/logging-state.js

@@ -3,16 +3,19 @@ import React from 'react';
 import { Logs } from './logs.js';
 let currentLogs = [];
 let currentChangeLogs = [];
+let currentErrorLogs = [];
 let setLogsCallback = null;
 let setChangeLogsCallback = null;
+let setErrorLogsCallback = null;
 const ensureLoggingInstance = () => {
     if (!setLogsCallback) {
         render(React.createElement(Logs));
     }
 };
-export const setLoggingCallbacks = (setLogs, setChangeLogs) => {
+export const setLoggingCallbacks = (setLogs, setChangeLogs, setErrorLogs) => {
     setLogsCallback = setLogs;
     setChangeLogsCallback = setChangeLogs;
+    setErrorLogsCallback = setErrorLogs;
 };
 export const addLog = (log) => {
     ensureLoggingInstance();
@@ -29,6 +32,21 @@ export const addChangeLog = (log) => {
     currentChangeLogs = [...currentChangeLogs, log];
     setChangeLogsCallback?.(currentChangeLogs);
 };
+export const addErrorLog = (log) => {
+    ensureLoggingInstance();
+    currentErrorLogs = [...currentErrorLogs, log];
+    setErrorLogsCallback?.(currentErrorLogs);
+};
+export const addRawErrorLog = (message) => {
+    ensureLoggingInstance();
+    currentErrorLogs = [...currentErrorLogs, message];
+    setErrorLogsCallback?.(currentErrorLogs);
+};
+export const clearErrorLogs = () => {
+    ensureLoggingInstance();
+    currentErrorLogs = [];
+    setErrorLogsCallback?.(currentErrorLogs);
+};
 export const clearLogs = () => {
     ensureLoggingInstance();
     currentLogs = [];
@@ -39,3 +57,6 @@ export const removeLastLog = () => {
     currentLogs = currentLogs.slice(0, -1);
     setLogsCallback?.(currentLogs);
 };
+export const getCurrentErrorLogs = () => {
+    return currentErrorLogs;
+};

package/dist/logs.js

@@ -1,4 +1,4 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
 import Spinner from 'ink-spinner';
 import { useState, useEffect } from 'react';
@@ -93,8 +93,9 @@ export const RenamedLog = ({ before, after }) => {
 export const Logs = () => {
     const [logs, setLogs] = useState([]);
     const [changeLogs, setChangeLogs] = useState([]);
+    const [errorLogs, setErrorLogs] = useState([]);
     useEffect(() => {
-        setLoggingCallbacks(setLogs, setChangeLogs);
+        setLoggingCallbacks(setLogs, setChangeLogs, setErrorLogs);
     }, []);
-    return (_jsxs(_Fragment, { children: [logs.map((log, idx) => (_jsx(Box, { children: log }, idx))), changeLogs.length > 0 && (_jsxs(Box, { flexDirection: "column", alignItems: "flex-start", children: [_jsxs(Text, { children: [_jsx(Text, { dimColor: true, bold: true, children: "\u00B1" }), ' ', _jsx(Text, { children: "changes" })] }), changeLogs.map((log, idx) => (_jsx(Box, { children: log }, `change-${idx}`)))] }))] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [logs.map((log, idx) => (_jsx(Box, { children: log }, idx))), changeLogs.length > 0 && (_jsxs(Box, { flexDirection: "column", alignItems: "flex-start", children: [_jsxs(Text, { children: [_jsx(Text, { dimColor: true, bold: true, children: "\u00B1" }), ' ', _jsx(Text, { children: "changes" })] }), changeLogs.map((log, idx) => (_jsx(Box, { children: log }, `change-${idx}`)))] })), errorLogs.length > 0 && (_jsxs(Box, { flexDirection: "column", alignItems: "flex-start", marginTop: 1, children: [_jsxs(Text, { children: [_jsx(Text, { dimColor: true, bold: true, children: "!" }), ' ', _jsx(Text, { color: "red", bold: true, children: "errors" })] }), errorLogs.map((log, idx) => (_jsx(Box, { children: typeof log === 'string' ? _jsx(Text, { children: log }) : log }, `error-${idx}`)))] }))] }));
 };