@mintlify/previewing 4.0.1606 → 4.0.1608

package/dist/__tests__/listener-batching.test.d.ts

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

package/dist/__tests__/listener-batching.test.js

@@ -0,0 +1,274 @@
+import fse from 'fs-extra';
+import { mkdir, rm, writeFile } from 'fs/promises';
+import { join } from 'path';
+import { CMD_EXEC_PATH, NEXT_PROPS_PATH, NEXT_PUBLIC_PATH } from '../constants.js';
+import listener, { initializeDocsConfigHashCache, initializeFrontmatterHashCache, } from '../local-preview/listener/index.js';
+import { updateGeneratedNavFromPageMetadataCache } from '../local-preview/listener/update.js';
+import * as logs from '../logging-state.js';
+const watcher = vi.hoisted(() => ({
+    handlers: {},
+}));
+vi.mock('../constants.js', async (importOriginal) => {
+    const actual = await importOriginal();
+    const { mkdtempSync } = await import('fs');
+    const { tmpdir } = await import('os');
+    const { join } = await import('path');
+    const root = mkdtempSync(join(tmpdir(), 'listener-batching-'));
+    return {
+        ...actual,
+        CMD_EXEC_PATH: join(root, 'docs'),
+        CLIENT_PATH: join(root, 'client'),
+        CONTENT_PATH: join(root, 'client'),
+        NEXT_PROPS_PATH: join(root, 'client', 'src', '_props'),
+        NEXT_PUBLIC_PATH: join(root, 'client', 'public'),
+    };
+});
+vi.mock('chokidar', () => {
+    const watch = () => {
+        const instance = {
+            on: (event, handler) => {
+                watcher.handlers[event] = handler;
+                return instance;
+            },
+            close: async () => { },
+        };
+        return instance;
+    };
+    return { default: { watch }, watch };
+});
+vi.mock('@mintlify/prebuild', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        getMintIgnore: vi.fn().mockResolvedValue([]),
+        discoverOverlayFiles: vi.fn().mockResolvedValue([]),
+    };
+});
+vi.mock('../local-preview/listener/update.js', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        updateGeneratedNavFromPageMetadataCache: vi.fn(actual.updateGeneratedNavFromPageMetadataCache),
+    };
+});
+vi.mock('../local-preview/packages/index.js', () => ({
+    notifyPackageInputChange: vi.fn(),
+    writePackageBuildProps: vi.fn(),
+}));
+const addChangeLogSpy = vi.spyOn(logs, 'addChangeLog');
+const triggerRefresh = vi.fn();
+const startWatcher = async () => {
+    listener(triggerRefresh, {});
+    await vi.waitFor(() => expect(watcher.handlers.change).toBeDefined());
+};
+const emit = (event, filename) => watcher.handlers[event](filename);
+const loggedFor = (filename) => addChangeLogSpy.mock.calls.filter(([log]) => log.props?.filename === filename);
+const writeDocsFile = async (filename, content) => {
+    await mkdir(join(CMD_EXEC_PATH, filename, '..'), { recursive: true });
+    await writeFile(join(CMD_EXEC_PATH, filename), content);
+};
+const docsConfig = {
+    $schema: 'https://mintlify.com/docs.json',
+    theme: 'mint',
+    name: 'Docs',
+    colors: { primary: '#000000' },
+    navigation: { pages: ['guide', 'changed', 'restored', 'startup', 'nav/a', 'nav/b', 'nav/c'] },
+};
+beforeAll(async () => {
+    await mkdir(NEXT_PROPS_PATH, { recursive: true });
+    await mkdir(NEXT_PUBLIC_PATH, { recursive: true });
+    await writeFile(join(NEXT_PROPS_PATH, 'customLanguages.json'), '[]');
+    await writeDocsFile('docs.json', JSON.stringify(docsConfig));
+    await writeFile(join(NEXT_PROPS_PATH, 'docs.json'), JSON.stringify(docsConfig));
+});
+afterAll(async () => {
+    await rm(join(CMD_EXEC_PATH, '..'), { recursive: true, force: true });
+});
+beforeEach(async () => {
+    vi.clearAllMocks();
+    watcher.handlers = {};
+    await startWatcher();
+});
+describe('listener event batching', () => {
+    it('processes a burst of file events one at a time and refreshes once', async () => {
+        const files = ['images/a.png', 'images/b.png', 'images/c.png'];
+        await Promise.all(files.map((file) => writeDocsFile(file, file)));
+        let active = 0;
+        let maxActive = 0;
+        const copy = fse.copy.bind(fse);
+        const copySpy = vi.spyOn(fse, 'copy').mockImplementation((async (...args) => {
+            active += 1;
+            maxActive = Math.max(maxActive, active);
+            await new Promise((resolve) => setTimeout(resolve, 10));
+            try {
+                return await copy(...args);
+            }
+            finally {
+                active -= 1;
+            }
+        }));
+        await Promise.all(files.map((file) => emit('change', file)));
+        expect(maxActive).toBe(1);
+        expect(triggerRefresh).toHaveBeenCalledOnce();
+        for (const file of files) {
+            expect(await fse.pathExists(join(NEXT_PUBLIC_PATH, file))).toBe(true);
+            expect(loggedFor(file)).toHaveLength(1);
+        }
+        copySpy.mockRestore();
+    });
+    it('handles repeated events for one file once, keeping an add as an add', async () => {
+        await writeDocsFile('images/repeat.png', 'repeat');
+        await Promise.all([
+            emit('add', 'images/repeat.png'),
+            emit('change', 'images/repeat.png'),
+            emit('change', 'images/repeat.png'),
+        ]);
+        const logged = loggedFor('images/repeat.png');
+        expect(logged).toHaveLength(1);
+        expect(logged[0][0].type?.name).toBe('AddedLog');
+        expect(triggerRefresh).toHaveBeenCalledOnce();
+    });
+    it('regenerates navigation once for a batch of pages with new frontmatter', async () => {
+        const pages = ['nav/a.mdx', 'nav/b.mdx', 'nav/c.mdx'];
+        await Promise.all(pages.map((file) => writeDocsFile(file, `---\ntitle: ${file}\n---\n`)));
+        await Promise.all(pages.map((file) => emit('add', file)));
+        for (const file of pages)
+            expect(loggedFor(file)).toHaveLength(1);
+        expect(updateGeneratedNavFromPageMetadataCache).toHaveBeenCalledOnce();
+        expect(triggerRefresh).toHaveBeenCalledOnce();
+    });
+    it('processes events that arrive while a batch is running in the same batch', async () => {
+        await writeDocsFile('images/first.png', 'first');
+        await writeDocsFile('images/second.png', 'second');
+        const copy = fse.copy.bind(fse);
+        let secondEvent;
+        const copySpy = vi.spyOn(fse, 'copy').mockImplementation((async (...args) => {
+            secondEvent ??= emit('change', 'images/second.png');
+            return copy(...args);
+        }));
+        await emit('change', 'images/first.png');
+        await secondEvent;
+        expect(loggedFor('images/first.png')).toHaveLength(1);
+        expect(loggedFor('images/second.png')).toHaveLength(1);
+        expect(triggerRefresh).toHaveBeenCalledOnce();
+        copySpy.mockRestore();
+    });
+});
+describe('listener unchanged Markdown', () => {
+    const page = '---\ntitle: Guide\n---\n\nHello\n';
+    it('skips a Markdown file whose content has not changed since it was processed', async () => {
+        await writeDocsFile('guide.mdx', page);
+        await emit('change', 'guide.mdx');
+        expect(loggedFor('guide.mdx')).toHaveLength(1);
+        expect(await fse.pathExists(join(NEXT_PROPS_PATH, 'guide.mdx'))).toBe(true);
+        addChangeLogSpy.mockClear();
+        triggerRefresh.mockClear();
+        await writeDocsFile('guide.mdx', page);
+        await emit('change', 'guide.mdx');
+        expect(loggedFor('guide.mdx')).toHaveLength(0);
+        expect(triggerRefresh).not.toHaveBeenCalled();
+    });
+    it('processes a Markdown file again once its content changes', async () => {
+        await writeDocsFile('changed.mdx', page);
+        await emit('change', 'changed.mdx');
+        addChangeLogSpy.mockClear();
+        await writeDocsFile('changed.mdx', `${page}More\n`);
+        await emit('change', 'changed.mdx');
+        expect(loggedFor('changed.mdx')).toHaveLength(1);
+    });
+    it('processes a deleted Markdown file again when it comes back unchanged', async () => {
+        await writeDocsFile('restored.mdx', page);
+        await emit('change', 'restored.mdx');
+        await rm(join(CMD_EXEC_PATH, 'restored.mdx'));
+        await emit('unlink', 'restored.mdx');
+        addChangeLogSpy.mockClear();
+        await writeDocsFile('restored.mdx', page);
+        await emit('add', 'restored.mdx');
+        expect(loggedFor('restored.mdx')).toHaveLength(1);
+    });
+    it('processes a Markdown edit made while startup caches are seeded', async () => {
+        await writeDocsFile('startup.mdx', page);
+        let releaseGate = () => { };
+        const gate = new Promise((resolve) => {
+            releaseGate = resolve;
+        });
+        watcher.handlers = {};
+        listener(triggerRefresh, {}, gate);
+        await vi.waitFor(() => expect(watcher.handlers.change).toBeDefined());
+        await writeDocsFile('startup.mdx', `${page}Edited during startup\n`);
+        const event = emit('change', 'startup.mdx');
+        await initializeFrontmatterHashCache();
+        releaseGate();
+        await event;
+        expect(loggedFor('startup.mdx')).toHaveLength(1);
+        expect(triggerRefresh).toHaveBeenCalledOnce();
+    });
+    it('regenerates navigation for a frontmatter edit made while startup caches are seeded', async () => {
+        await writeDocsFile('startup.mdx', '---\ntitle: Before startup\n---\n');
+        let releaseGate = () => { };
+        const gate = new Promise((resolve) => {
+            releaseGate = resolve;
+        });
+        watcher.handlers = {};
+        listener(triggerRefresh, {}, gate);
+        await vi.waitFor(() => expect(watcher.handlers.change).toBeDefined());
+        await writeDocsFile('startup.mdx', '---\ntitle: Edited during startup\n---\n');
+        const event = emit('change', 'startup.mdx');
+        await initializeFrontmatterHashCache();
+        releaseGate();
+        await event;
+        expect(updateGeneratedNavFromPageMetadataCache).toHaveBeenCalledOnce();
+        expect(triggerRefresh).toHaveBeenCalledOnce();
+    });
+    it('applies pending page nav updates before handling docs.json in the same batch', async () => {
+        await initializeDocsConfigHashCache();
+        await writeDocsFile('nav/a.mdx', '---\ntitle: Renamed in batch\n---\n');
+        await writeDocsFile('docs.json', JSON.stringify({
+            ...docsConfig,
+            navigation: { pages: docsConfig.navigation.pages.filter((page) => page !== 'guide') },
+        }));
+        try {
+            await Promise.all([emit('change', 'nav/a.mdx'), emit('change', 'docs.json')]);
+            const generatedNav = (await fse.readJson(join(NEXT_PROPS_PATH, 'generatedDocsNav.json')));
+            expect(generatedNav.pages.map((page) => page.href)).not.toContain('/guide');
+            expect(generatedNav.pages).toContainEqual({ title: 'Renamed in batch', href: '/nav/a' });
+            expect(triggerRefresh).toHaveBeenCalledOnce();
+        }
+        finally {
+            await writeDocsFile('docs.json', JSON.stringify(docsConfig));
+        }
+    });
+    it('applies pending page nav updates before a referenced navigation file is handled', async () => {
+        await writeDocsFile('navigation.json', JSON.stringify(docsConfig.navigation));
+        await writeDocsFile('docs.json', JSON.stringify({ ...docsConfig, navigation: { $ref: './navigation.json' } }));
+        try {
+            await emit('change', 'docs.json');
+            await writeDocsFile('nav/b.mdx', '---\ntitle: Renamed via ref\n---\n');
+            await writeDocsFile('navigation.json', JSON.stringify({ pages: docsConfig.navigation.pages.filter((page) => page !== 'guide') }));
+            await Promise.all([emit('change', 'nav/b.mdx'), emit('change', 'navigation.json')]);
+            const generatedNav = (await fse.readJson(join(NEXT_PROPS_PATH, 'generatedDocsNav.json')));
+            expect(generatedNav.pages.map((page) => page.href)).not.toContain('/guide');
+            expect(generatedNav.pages).toContainEqual({ title: 'Renamed via ref', href: '/nav/b' });
+        }
+        finally {
+            await writeDocsFile('docs.json', JSON.stringify(docsConfig));
+            await rm(join(CMD_EXEC_PATH, 'navigation.json'), { force: true });
+            await emit('change', 'docs.json');
+        }
+    });
+    it('regenerates navigation once when page changes are interleaved with assets', async () => {
+        const pages = ['nav/a.mdx', 'nav/b.mdx', 'nav/c.mdx'];
+        await Promise.all(pages.map((file) => writeDocsFile(file, `---\ntitle: ${file} with assets\n---\n`)));
+        await Promise.all(pages.map((_, i) => writeDocsFile(`images/asset-${i}.png`, 'png')));
+        await Promise.all(pages.flatMap((file, i) => [emit('change', file), emit('add', `images/asset-${i}.png`)]));
+        expect(updateGeneratedNavFromPageMetadataCache).toHaveBeenCalledOnce();
+        expect(triggerRefresh).toHaveBeenCalledOnce();
+    });
+    it('always processes non-Markdown files, even when their content is unchanged', async () => {
+        await writeDocsFile('images/same.png', 'same');
+        await emit('change', 'images/same.png');
+        addChangeLogSpy.mockClear();
+        await emit('change', 'images/same.png');
+        expect(loggedFor('images/same.png')).toHaveLength(1);
+    });
+});

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

@@ -4,6 +4,7 @@ import { createPage, discoverOverlayFiles, getFileListSync, getMintIgnore, MintC
 import { isOverlayDocument } from '@mintlify/validation';
 import Chalk from 'chalk';
 import chokidar from 'chokidar';
+import { createHash } from 'crypto';
 import { promises as _promises } from 'fs';
 import fse from 'fs-extra';
 import fs from 'fs/promises';
@@ -111,7 +112,93 @@ const addUpdateTimingLog = (filename, category, durationMs) => {
 let watcherGate;
 let previewWatcher;
 let previewWatcherRestart = Promise.resolve();
-const startPreviewWatcher = (triggerRefresh, options) => {
+const WATCH_BATCH_DELAY_MS = 100;
+const pendingWatchEvents = new Map();
+const markdownContentHashes = new Map();
+let watchBatch;
+let inFlightWatchFile;
+let deferNavRegeneration = false;
+let pendingNavRegeneration;
+let refreshRequested = false;
+let activeTriggerRefresh = () => { };
+let activeWatchOptions = {};
+const requestRefresh = () => {
+    refreshRequested = true;
+};
+const isMarkdownFile = (filename) => /\.mdx?$/i.test(filename);
+const hashContent = (content) => createHash('sha1').update(content).digest('hex');
+const readMarkdownContentHash = async (filename) => {
+    if (!isMarkdownFile(filename))
+        return undefined;
+    try {
+        return hashContent((await readFile(pathUtil.join(CMD_EXEC_PATH, filename))).toString());
+    }
+    catch {
+        return undefined;
+    }
+};
+const handleWatchEvent = (type, filename) => {
+    switch (type) {
+        case 'add':
+            return onAddEvent(filename, requestRefresh, activeWatchOptions);
+        case 'change':
+            return onChangeEvent(filename, requestRefresh, activeWatchOptions);
+        case 'unlink':
+            return onUnlinkEvent(filename, requestRefresh, activeWatchOptions);
+    }
+};
+const flushPendingNavRegeneration = async () => {
+    const navRegeneration = pendingNavRegeneration;
+    pendingNavRegeneration = undefined;
+    if (!navRegeneration)
+        return;
+    try {
+        await regenerateGeneratedNav(navRegeneration);
+    }
+    catch (error) {
+        console.error(error.message);
+    }
+};
+const drainWatchEvents = async () => {
+    deferNavRegeneration = true;
+    try {
+        while (pendingWatchEvents.size > 0 || pendingNavRegeneration) {
+            for (const [filename, type] of pendingWatchEvents) {
+                pendingWatchEvents.delete(filename);
+                inFlightWatchFile = filename;
+                try {
+                    await handleWatchEvent(type, filename);
+                }
+                catch (error) {
+                    console.error(error.message);
+                }
+                finally {
+                    inFlightWatchFile = undefined;
+                }
+            }
+            await flushPendingNavRegeneration();
+        }
+    }
+    finally {
+        deferNavRegeneration = false;
+        watchBatch = undefined;
+        if (refreshRequested) {
+            refreshRequested = false;
+            activeTriggerRefresh();
+        }
+    }
+};
+const enqueueWatchEvent = (type, filename) => {
+    const previous = pendingWatchEvents.get(filename);
+    pendingWatchEvents.delete(filename);
+    pendingWatchEvents.set(filename, previous === 'add' && type === 'change' ? 'add' : type);
+    watchBatch ??= new Promise((resolve) => {
+        setTimeout(() => void drainWatchEvents().finally(resolve), WATCH_BATCH_DELAY_MS);
+    });
+    return watchBatch;
+};
+const startPreviewWatcher = (options) => {
+    activeWatchOptions = options;
     previewWatcherRestart = previewWatcherRestart
         .catch(() => undefined)
         .then(async () => {
@@ -127,55 +214,47 @@ const startPreviewWatcher = (triggerRefresh, options) => {
             ignored: isPreviewPathIgnored,
             cwd: CMD_EXEC_PATH,
         })
-            .on('add', (filename) => onAddEvent(filename, triggerRefresh, options))
-            .on('change', (filename) => onChangeEvent(filename, triggerRefresh, options))
-            .on('unlink', (filename) => onUnlinkEvent(filename, triggerRefresh, options));
+            .on('add', (filename) => enqueueWatchEvent('add', filename))
+            .on('change', (filename) => enqueueWatchEvent('change', filename))
+            .on('unlink', (filename) => enqueueWatchEvent('unlink', filename));
     });
     return previewWatcherRestart;
 };
 const listener = (triggerRefresh, options = {}, gate) => {
     watcherGate = gate;
+    activeTriggerRefresh = triggerRefresh;
     const previewOptions = { ...options, allowSourceRefs: true };
-    void startPreviewWatcher(triggerRefresh, previewOptions);
+    void startPreviewWatcher(previewOptions);
 };
-const onAddEvent = async (filename, triggerRefresh, options) => {
+const processUpdateEvent = async (filename, triggerRefresh, options, log) => {
     if (watcherGate) {
         await watcherGate;
     }
     if (isMintIgnored(filename, getMintIgnoreGlobs())) {
         return;
     }
-    try {
-        const startTime = process.hrtime.bigint();
-        const category = await onUpdateEvent(filename, triggerRefresh, options);
-        addUpdateTimingLog(filename, category, getElapsedMs(startTime));
-        if (category !== undefined) {
-            addChangeLog(_jsx(AddedLog, { filename: filename }));
-        }
-    }
-    catch (error) {
-        console.error(error.message);
-    }
-};
-const onChangeEvent = async (filename, triggerRefresh, options) => {
-    if (watcherGate) {
-        await watcherGate;
-    }
-    if (isMintIgnored(filename, getMintIgnoreGlobs())) {
+    const contentHash = await readMarkdownContentHash(filename);
+    if (contentHash !== undefined && markdownContentHashes.get(filename) === contentHash) {
         return;
     }
     try {
         const startTime = process.hrtime.bigint();
         const category = await onUpdateEvent(filename, triggerRefresh, options);
+        if (contentHash !== undefined) {
+            markdownContentHashes.set(filename, contentHash);
+        }
         addUpdateTimingLog(filename, category, getElapsedMs(startTime));
         if (category !== undefined) {
-            addChangeLog(_jsx(EditedLog, { filename: filename }));
+            log(filename);
         }
     }
     catch (error) {
+        markdownContentHashes.delete(filename);
         console.error(error.message);
     }
 };
+const onAddEvent = (filename, triggerRefresh, options) => processUpdateEvent(filename, triggerRefresh, options, (name) => addChangeLog(_jsx(AddedLog, { filename: name })));
+const onChangeEvent = (filename, triggerRefresh, options) => processUpdateEvent(filename, triggerRefresh, options, (name) => addChangeLog(_jsx(EditedLog, { filename: name })));
 const onUnlinkEvent = async (filename, triggerRefresh, options) => {
     if (watcherGate) {
         await watcherGate;
@@ -188,6 +267,7 @@ const onUnlinkEvent = async (filename, triggerRefresh, options) => {
         const potentialCategory = getFileCategory(filename, { importedFiles });
         await notifyPackageInputChange(filename, potentialCategory);
         frontmatterHashes.delete(filename);
+        markdownContentHashes.delete(filename);
         removePageMetadataCacheEntryForFile(filename);
         if (potentialCategory === 'page') {
             reportPageCompileSuccess(filename);
@@ -280,7 +360,7 @@ const onUnlinkEvent = async (filename, triggerRefresh, options) => {
                     await initializeImportCache(CMD_EXEC_PATH, prebuildResult?.fileImportsMap);
                     await initializeFrontmatterHashCache();
                     await refreshTrackedReferencedFiles();
-                    await startPreviewWatcher(triggerRefresh, options);
+                    await startPreviewWatcher(options);
                 }
                 catch (err) {
                     console.error('Error rebuilding after .mintignore deletion:', err);
@@ -339,6 +419,7 @@ const validateConfigFiles = async () => {
 };
 const initializeFrontmatterHashCache = async () => {
     frontmatterHashes.clear();
+    markdownContentHashes.clear();
     clearPageMetadataCache();
     const importedFiles = getImportedFilesFromCache();
     const pageFilenames = getFileListSync(CMD_EXEC_PATH, CMD_EXEC_PATH, getMintIgnoreGlobs()).filter((file) => {
@@ -349,10 +430,18 @@ const initializeFrontmatterHashCache = async () => {
             const filePath = pathUtil.join(CMD_EXEC_PATH, filename);
             const contentStr = (await readFile(filePath)).toString();
             seedFrontmatterHashForPage(filename, contentStr, frontmatterHashes, suppressParseError);
+            markdownContentHashes.set(filename, hashContent(contentStr));
             upsertPageMetadataCacheEntryForFile(filename, contentStr);
         }
         catch { }
     }));
+    // Files with queued events may have been hashed after their edit; let those events rebuild them.
+    for (const filename of [...pendingWatchEvents.keys(), inFlightWatchFile]) {
+        if (!filename)
+            continue;
+        markdownContentHashes.delete(filename);
+        frontmatterHashes.delete(filename);
+    }
 };
 const initializeDocsConfigHashCache = async () => {
     clearDocsConfigCaches();
@@ -523,6 +612,8 @@ const onUpdateEvent = async (filename, triggerRefresh, options = {}) => {
                         // spec via frontmatter, this falls back to the full rebuild and
                         // returns the API-expanded config, which we then persist.
                         await updateCustomLanguages(docsConfig, suppressParseError);
+                        // Reused nav metadata must include page changes deferred earlier in this batch.
+                        await flushPendingNavRegeneration();
                         const generatedDocsConfig = await updateGeneratedNavFromPageMetadataCache(docsConfig, suppressParseError, { reuseGeneratedMetadata: true });
                         await DocsConfigUpdater.writeConfigFile(generatedDocsConfig, CONTENT_PATH);
                     }
@@ -597,7 +688,7 @@ const onUpdateEvent = async (filename, triggerRefresh, options = {}) => {
                 await initializeImportCache(CMD_EXEC_PATH, prebuildResult?.fileImportsMap);
                 await initializeFrontmatterHashCache();
                 await refreshTrackedReferencedFiles();
-                await startPreviewWatcher(triggerRefresh, options);
+                await startPreviewWatcher(options);
             }
             catch (err) {
                 console.error(err.message);
@@ -685,7 +776,22 @@ const onUpdateEvent = async (filename, triggerRefresh, options = {}) => {
             break;
         }
     }
-    if (regenerateNavFromPageMetadataCache) {
+    const navRegeneration = regenerateNavFromPageMetadataCache
+        ? 'pageMetadataCache'
+        : regenerateNav
+            ? 'full'
+            : undefined;
+    if (navRegeneration && deferNavRegeneration) {
+        pendingNavRegeneration = pendingNavRegeneration === 'full' ? 'full' : navRegeneration;
+    }
+    else if (navRegeneration) {
+        await regenerateGeneratedNav(navRegeneration);
+    }
+    triggerRefresh();
+    return category;
+};
+const regenerateGeneratedNav = async (navRegeneration) => {
+    if (navRegeneration === 'pageMetadataCache') {
         const rawDocsConfig = await getCurrentRawDocsConfig();
         const docsConfig = rawDocsConfig ?? (await getCurrentDocsConfig());
         if (hasDocsConfigApiRoutes(docsConfig)) {
@@ -696,13 +802,11 @@ const onUpdateEvent = async (filename, triggerRefresh, options = {}) => {
             await updateGeneratedNavFromPageMetadataCache(docsConfig, suppressParseError);
         }
     }
-    else if (regenerateNav) {
+    else {
         // TODO: Instead of re-generating the entire nav, optimize by just updating the specific page that changed.
         const docsConfig = await updateGeneratedNav(suppressParseError);
         await DocsConfigUpdater.writeConfigFile(docsConfig, CONTENT_PATH);
     }
-    triggerRefresh();
-    return category;
 };
 export { initializeDocsConfigHashCache, initializeFrontmatterHashCache, initializeImportCache };
 export default listener;