@mintlify/previewing 4.0.1009 → 4.0.1011

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

@@ -7,7 +7,7 @@ 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'), false, onError);
+        const mintConfig = await MintConfigUpdater.getConfig(join(CMD_EXEC_PATH, 'mint.json'), false, CMD_EXEC_PATH, 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 (onError) => {
         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, false, onError);
+        const docsConfig = await DocsConfigUpdater.getConfig(docsJsonPath, false, CMD_EXEC_PATH, onError);
         const { newDocsConfig, pagesAcc, openApiFiles: newOpenApiFiles, } = await generateOpenApiDivisions(docsConfig, openApiFiles, CLIENT_PATH);
         return { pagesAcc, openApiFiles: newOpenApiFiles, docsConfig: newDocsConfig };
     }

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

@@ -1,5 +1,5 @@
 import { initializeImportCache } from './importCache.js';
-declare const listener: (callback: () => void, options?: {
+declare const listener: (triggerRefresh: () => void, options?: {
     localSchema?: boolean;
     groups?: string[];
 }) => void;

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

@@ -15,13 +15,14 @@ import { generateDependentSnippets } from './generateDependentSnippets.js';
 import { generatePagesWithImports } from './generatePagesWithImports.js';
 import { getDocsState } from './getDocsState.js';
 import { initializeImportCache, updateImportCacheForFile, removeFromImportCache, getImportedFilesFromCache, syncImportedFileLocations, } from './importCache.js';
+import { hasTrackedReferencedFile, refreshTrackedReferencedFiles } from './referencedFiles.js';
 import { regenerateAllSnippets } from './regenerateAllSnippets.js';
 import { resolveAllImports } from './resolveAllImports.js';
 import { updateCustomLanguages, updateGeneratedNav, updateOpenApiFiles, upsertOpenApiFile, } from './update.js';
 import { getCurrentVariables, getMintIgnoreGlobs, handleParseError, isFileSizeValid, isJsonValid, shouldRegenerateNavForPage, suppressParseError, } from './utils.js';
 const { readFile } = _promises;
 const frontmatterHashes = new Map();
-const listener = (callback, options = {}) => {
+const listener = (triggerRefresh, options = {}) => {
     const mintIgnoreGlobs = getMintIgnoreGlobs();
     chokidar
         .watch(CMD_EXEC_PATH, {
@@ -37,17 +38,17 @@ const listener = (callback, options = {}) => {
         },
         cwd: CMD_EXEC_PATH,
     })
-        .on('add', (filename) => onAddEvent(filename, callback, options))
-        .on('change', (filename) => onChangeEvent(filename, callback, options))
-        .on('unlink', (filename) => onUnlinkEvent(filename, options));
+        .on('add', (filename) => onAddEvent(filename, triggerRefresh, options))
+        .on('change', (filename) => onChangeEvent(filename, triggerRefresh, options))
+        .on('unlink', (filename) => onUnlinkEvent(filename, triggerRefresh, options));
 };
-const onAddEvent = async (filename, callback, options) => {
+const onAddEvent = async (filename, triggerRefresh, options) => {
     if (isMintIgnored(filename, getMintIgnoreGlobs())) {
         return;
     }
     try {
-        const category = await onUpdateEvent(filename, callback, options);
-        if (category) {
+        const category = await onUpdateEvent(filename, triggerRefresh, options);
+        if (category !== undefined) {
             addChangeLog(_jsx(AddedLog, { filename: filename }));
         }
     }
@@ -55,13 +56,13 @@ const onAddEvent = async (filename, callback, options) => {
         console.error(error.message);
     }
 };
-const onChangeEvent = async (filename, callback, options) => {
+const onChangeEvent = async (filename, triggerRefresh, options) => {
     if (isMintIgnored(filename, getMintIgnoreGlobs())) {
         return;
     }
     try {
-        const category = await onUpdateEvent(filename, callback, options);
-        if (category) {
+        const category = await onUpdateEvent(filename, triggerRefresh, options);
+        if (category !== undefined) {
             addChangeLog(_jsx(EditedLog, { filename: filename }));
         }
     }
@@ -69,13 +70,38 @@ const onChangeEvent = async (filename, callback, options) => {
         console.error(error.message);
     }
 };
-const onUnlinkEvent = async (filename, options) => {
+const onUnlinkEvent = async (filename, triggerRefresh, options) => {
     if (isMintIgnored(filename, getMintIgnoreGlobs())) {
         return;
     }
     try {
         const importedFiles = getImportedFilesFromCache();
         const potentialCategory = getFileCategory(filename, { importedFiles });
+        if (hasTrackedReferencedFile(filename)) {
+            try {
+                const { mintConfig, openApiFiles, docsConfig } = await getDocsState(handleParseError);
+                await refreshTrackedReferencedFiles();
+                if (mintConfig) {
+                    await MintConfigUpdater.writeConfigFile(mintConfig, CLIENT_PATH);
+                }
+                await DocsConfigUpdater.writeConfigFile(docsConfig, CLIENT_PATH);
+                await updateOpenApiFiles(openApiFiles, suppressParseError);
+                await updateCustomLanguages(docsConfig, suppressParseError);
+                await updateGeneratedNav(suppressParseError);
+            }
+            catch (err) {
+                if (getCurrentErrorLogs().length === 0) {
+                    console.error(err);
+                }
+            }
+            const updatedSnippets = await regenerateAllSnippets();
+            await generatePagesWithImports(new Set(updatedSnippets));
+            const importChanges = removeFromImportCache(filename);
+            await syncImportedFileLocations(importChanges);
+            triggerRefresh();
+            addChangeLog(_jsx(DeletedLog, { filename: filename }));
+            return;
+        }
         if (potentialCategory == null) {
             const importChanges = removeFromImportCache(filename);
             await syncImportedFileLocations(importChanges);
@@ -109,6 +135,7 @@ const onUnlinkEvent = async (filename, options) => {
                     await fse.emptyDir(NEXT_PROPS_PATH);
                     const prebuildResult = await prebuild(CMD_EXEC_PATH, options);
                     await initializeImportCache(CMD_EXEC_PATH, prebuildResult?.fileImportsMap);
+                    await refreshTrackedReferencedFiles();
                 }
                 catch (err) {
                     console.error('Error rebuilding after .mintignore deletion:', err);
@@ -168,17 +195,39 @@ const validateConfigFiles = async () => {
  * @param filename
  * @returns FileCategory
  */
-const onUpdateEvent = async (filename, callback, options = {}) => {
+const onUpdateEvent = async (filename, triggerRefresh, options = {}) => {
     clearErrorLogs();
     const filePath = pathUtil.join(CMD_EXEC_PATH, filename);
     const importChanges = await updateImportCacheForFile(CMD_EXEC_PATH, filename);
     await syncImportedFileLocations(importChanges);
     const importedFiles = getImportedFilesFromCache();
     const potentialCategory = getFileCategory(filename, { importedFiles });
-    if (potentialCategory == null) {
-        callback();
+    if (hasTrackedReferencedFile(filename)) {
+        try {
+            const { mintConfig, openApiFiles, docsConfig } = await getDocsState(handleParseError);
+            await refreshTrackedReferencedFiles();
+            if (mintConfig) {
+                await MintConfigUpdater.writeConfigFile(mintConfig, CLIENT_PATH);
+            }
+            await DocsConfigUpdater.writeConfigFile(docsConfig, CLIENT_PATH);
+            await updateOpenApiFiles(openApiFiles, suppressParseError);
+            await updateCustomLanguages(docsConfig, suppressParseError);
+            await updateGeneratedNav(suppressParseError);
+        }
+        catch (err) {
+            if (getCurrentErrorLogs().length === 0) {
+                console.error(err);
+            }
+        }
+        const updatedSnippets = await regenerateAllSnippets();
+        await generatePagesWithImports(new Set(updatedSnippets));
+        triggerRefresh();
         return null;
     }
+    if (potentialCategory == null) {
+        triggerRefresh();
+        return undefined;
+    }
     let regenerateNav = false;
     let category = potentialCategory === 'potentialYamlOpenApiSpec' ||
         potentialCategory === 'potentialJsonOpenApiSpec'
@@ -224,11 +273,12 @@ const onUpdateEvent = async (filename, callback, options = {}) => {
             const { valid, error } = isJsonValid(filePath);
             if (!valid) {
                 addErrorLog(_jsx(ErrorLog, { message: `Syntax error in ${filename}: ${error}` }));
-                return null;
+                return undefined;
             }
             regenerateNav = true;
             try {
                 const { mintConfig, openApiFiles, docsConfig } = await getDocsState(handleParseError);
+                await refreshTrackedReferencedFiles();
                 if (mintConfig) {
                     await MintConfigUpdater.writeConfigFile(mintConfig, CLIENT_PATH);
                 }
@@ -239,7 +289,7 @@ const onUpdateEvent = async (filename, callback, options = {}) => {
             catch (err) {
                 if (getCurrentErrorLogs().length > 0) {
                     // no-op to suppress duplicate error logging
-                    return null;
+                    return undefined;
                 }
                 else {
                     console.error(err);
@@ -258,6 +308,7 @@ const onUpdateEvent = async (filename, callback, options = {}) => {
                 await fse.emptyDir(NEXT_PROPS_PATH);
                 const prebuildResult = await prebuild(CMD_EXEC_PATH, options);
                 await initializeImportCache(CMD_EXEC_PATH, prebuildResult?.fileImportsMap);
+                await refreshTrackedReferencedFiles();
             }
             catch (err) {
                 console.error(err.message);
@@ -319,7 +370,7 @@ const onUpdateEvent = async (filename, callback, options = {}) => {
         // TODO: Instead of re-generating the entire nav, optimize by just updating the specific page that changed.
         await updateGeneratedNav(suppressParseError);
     }
-    callback();
+    triggerRefresh();
     return category;
 };
 export { initializeImportCache };

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

@@ -0,0 +1,2 @@
+export declare const refreshTrackedReferencedFiles: () => Promise<void>;
+export declare const hasTrackedReferencedFile: (filePath: string) => boolean;

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

@@ -0,0 +1,21 @@
+import { getConfigPath, resolveFileRefs } from '@mintlify/prebuild';
+import { readFile } from 'fs/promises';
+import { CMD_EXEC_PATH } from '../../constants.js';
+let trackedReferencedFiles = new Set();
+export const refreshTrackedReferencedFiles = async () => {
+    try {
+        const configPath = (await getConfigPath(CMD_EXEC_PATH, 'docs')) ?? (await getConfigPath(CMD_EXEC_PATH, 'mint'));
+        if (!configPath) {
+            trackedReferencedFiles = new Set();
+            return;
+        }
+        const content = await readFile(configPath, 'utf-8');
+        const parsed = JSON.parse(content);
+        const { referencedFiles } = await resolveFileRefs(parsed, CMD_EXEC_PATH);
+        trackedReferencedFiles = new Set(referencedFiles);
+    }
+    catch {
+        trackedReferencedFiles = new Set();
+    }
+};
+export const hasTrackedReferencedFile = (filePath) => trackedReferencedFiles.has(filePath);

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

@@ -1,4 +1,5 @@
 import { parseFrontmatter, processMintIgnoreString, optionallyAddLeadingSlash, } from '@mintlify/common';
+import { resolveFileRefs } from '@mintlify/prebuild';
 import crypto from 'crypto';
 import { promises as _promises, readFileSync, existsSync } from 'fs';
 import fse from 'fs-extra';
@@ -87,8 +88,9 @@ export const suppressParseError = () => {
 export const getCurrentVariables = async () => {
     try {
         const content = await readFile(pathUtil.join(CMD_EXEC_PATH, 'docs.json'), 'utf8');
-        const parsed = JSON.parse(content);
-        return parsed.variables;
+        const { resolved } = await resolveFileRefs(JSON.parse(content), CMD_EXEC_PATH);
+        const resolvedConfig = resolved;
+        return resolvedConfig.variables;
     }
     catch {
         return undefined;

package/dist/local-preview/run.js

@@ -8,6 +8,7 @@ import { addLog, removeLastLog } from '../logging-state.js';
 import { LaunchLog, UpdateLog } from '../logs.js';
 import { maybeFixMissingWindowsEnvVar } from '../util.js';
 import listener, { initializeImportCache } from './listener/index.js';
+import { refreshTrackedReferencedFiles } from './listener/referencedFiles.js';
 import { getLocalNetworkIp } from './network.js';
 import { setupNext } from './setupNext.js';
 export const run = async (argv) => {
@@ -49,5 +50,6 @@ export const run = async (argv) => {
         process.on('SIGTERM', onExit);
     });
     await initializeImportCache(CMD_EXEC_PATH, argv.fileImportsMap);
+    await refreshTrackedReferencedFiles();
     listener(onChange);
 };