@mintlify/previewing 4.0.1365 → 4.0.1367

package/dist/__tests__/generate-dependent-snippets.test.js

@@ -18,6 +18,7 @@ vi.mock('../constants.js', () => ({
 }));
 vi.mock('../local-preview/listener/utils.js', () => ({
     getCurrentVariables: vi.fn(async () => ({ name: 'Ada' })),
+    getMintIgnoreGlobs: vi.fn(() => []),
     handleParseError: vi.fn(),
     normalizePathForComparison: (path) => {
         const normalized = path.startsWith('/') ? path : `/${path}`;

package/dist/__tests__/previewPathIgnored.test.d.ts

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

package/dist/__tests__/previewPathIgnored.test.js

@@ -0,0 +1,82 @@
+import chokidar from 'chokidar';
+import { appendFile, mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { createPreviewPathIgnored } from '../local-preview/listener/previewPathIgnored.js';
+const watchRoot = (root, globs) => chokidar.watch(root, {
+    ignoreInitial: true,
+    ignored: createPreviewPathIgnored(root, globs),
+    cwd: root,
+});
+const waitForReady = (watcher) => new Promise((resolve) => {
+    watcher.once('ready', () => resolve());
+});
+describe('createPreviewPathIgnored', () => {
+    let root;
+    beforeEach(async () => {
+        root = await mkdtemp(path.join(os.tmpdir(), 'mint-preview-ignore-unit-'));
+    });
+    afterEach(async () => {
+        await rm(root, { recursive: true, force: true });
+    });
+    it('skips a directory named junk for junk/ even when stats are omitted', async () => {
+        await mkdir(path.join(root, 'junk'));
+        const ignored = createPreviewPathIgnored(root, ['junk/']);
+        expect(ignored('junk')).toBe(true);
+        expect(ignored('junk', { isDirectory: () => true })).toBe(true);
+        expect(ignored('page.mdx')).toBe(false);
+        expect(ignored('.mintlify/skills', { isDirectory: () => true })).toBe(false);
+    });
+    it('does not treat a regular file named junk as the ignored junk/ directory', async () => {
+        await writeFile(path.join(root, 'junk'), 'notes\n');
+        const ignored = createPreviewPathIgnored(root, ['junk/']);
+        expect(ignored('junk')).toBe(false);
+        expect(ignored('junk', { isDirectory: () => false })).toBe(false);
+        expect(ignored('junk', { isDirectory: () => true })).toBe(true);
+    });
+});
+describe('preview watcher ignore restart', () => {
+    let root;
+    let watcher;
+    beforeEach(async () => {
+        root = await mkdtemp(path.join(os.tmpdir(), 'mint-preview-ignore-'));
+        await mkdir(path.join(root, 'junk'), { recursive: true });
+        await writeFile(path.join(root, 'page.mdx'), '# Page\n');
+        await writeFile(path.join(root, 'junk', 'hidden.mdx'), '# Hidden\n');
+    });
+    afterEach(async () => {
+        if (watcher) {
+            await watcher.close();
+            watcher = undefined;
+        }
+        await rm(root, { recursive: true, force: true });
+    });
+    it('starts watching a previously ignored directory after the matcher is rebuilt', async () => {
+        watcher = watchRoot(root, ['junk/']);
+        await waitForReady(watcher);
+        const ignoredChanges = [];
+        watcher.on('change', (filename) => ignoredChanges.push(filename));
+        await appendFile(path.join(root, 'junk', 'hidden.mdx'), 'ignored\n');
+        await new Promise((resolve) => setTimeout(resolve, 400));
+        expect(ignoredChanges).toEqual([]);
+        await watcher.close();
+        watcher = watchRoot(root, []);
+        await waitForReady(watcher);
+        const includedChanges = new Promise((resolve) => {
+            watcher?.once('change', (filename) => resolve(filename));
+        });
+        await appendFile(path.join(root, 'junk', 'hidden.mdx'), 'watched\n');
+        await expect(includedChanges).resolves.toMatch(/hidden\.mdx$/);
+    }, 10_000);
+    it('watches a regular file named junk while junk/ is ignored', async () => {
+        await rm(path.join(root, 'junk'), { recursive: true, force: true });
+        await writeFile(path.join(root, 'junk'), 'notes\n');
+        watcher = watchRoot(root, ['junk/']);
+        await waitForReady(watcher);
+        const includedChanges = new Promise((resolve) => {
+            watcher?.once('change', (filename) => resolve(filename));
+        });
+        await appendFile(path.join(root, 'junk'), 'watched\n');
+        await expect(includedChanges).resolves.toMatch(/junk$/);
+    }, 10_000);
+});

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

@@ -4,12 +4,12 @@ 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, getCurrentVariables } from './utils.js';
+import { getMintIgnoreGlobs, handleParseError, getCurrentVariables } from './utils.js';
 const { readFile } = _promises;
 const getSnippetBase = async (baseDir) => {
     const importedFiles = getImportedFilesFromCache();
     const variables = await getCurrentVariables();
-    const allSnippetFilenames = getFileListSync(baseDir).filter((file) => {
+    const allSnippetFilenames = getFileListSync(baseDir, baseDir, getMintIgnoreGlobs()).filter((file) => {
         if (!isSnippetExtension(getFileExtension(file))) {
             return false;
         }

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 { handleParseError, normalizePathForComparison, suppressParseError } from './utils.js';
+import { getMintIgnoreGlobs, handleParseError, normalizePathForComparison, suppressParseError, } from './utils.js';
 const fileImportsMap = new Map();
 const importerCounts = new Map();
 const originalPathByNormalizedPath = new Map();
@@ -52,7 +52,7 @@ export const initializeImportCache = async (baseDir, prebuildImportMap) => {
     importerCounts.clear();
     originalPathByNormalizedPath.clear();
     if (prebuildImportMap) {
-        for (const filePath of getFileListSync(baseDir)) {
+        for (const filePath of getFileListSync(baseDir, baseDir, getMintIgnoreGlobs())) {
             originalPathByNormalizedPath.set(normalizePathForComparison(filePath), optionallyAddLeadingSlash(filePath));
         }
         for (const [filePath, imports] of prebuildImportMap) {
@@ -66,7 +66,7 @@ export const initializeImportCache = async (baseDir, prebuildImportMap) => {
         }
         return;
     }
-    const allFiles = getFileListSync(baseDir).filter((file) => isSnippetExtension(getFileExtension(file)));
+    const allFiles = getFileListSync(baseDir, baseDir, getMintIgnoreGlobs()).filter((file) => isSnippetExtension(getFileExtension(file)));
     await Promise.all(allFiles.map(async (filename) => {
         const normalizedPath = normalizePathForComparison(filename);
         const imports = await extractFileImports(baseDir, filename);

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

@@ -19,6 +19,7 @@ import { generatePagesWithImports } from './generatePagesWithImports.js';
 import { getDocsState } from './getDocsState.js';
 import { initializeImportCache, updateImportCacheForFile, removeFromImportCache, getImportedFilesFromCache, syncImportedFileLocations, } from './importCache.js';
 import { clearPageMetadataCache, removePageMetadataCacheEntryForFile, upsertPageMetadataCacheEntry, upsertPageMetadataCacheEntryForFile, } from './page-metadata-cache.js';
+import { createPreviewPathIgnored } from './previewPathIgnored.js';
 import { hasTrackedReferencedFile, refreshTrackedReferencedFiles, shouldRegenerateGraphqlSource, } from './referencedFiles.js';
 import { regenerateAllSnippets } from './regenerateAllSnippets.js';
 import { resolveImportsFromImportClosure } from './resolve-imports-from-import-closure.js';
@@ -107,27 +108,34 @@ const addUpdateTimingLog = (filename, category, durationMs) => {
     addChangeLog(_jsx(InfoLog, { message: `processed ${filename} in ${formatElapsedSeconds(durationMs)} (${categoryLabel})` }));
 };
 let watcherGate;
+let previewWatcher;
+let previewWatcherRestart = Promise.resolve();
+const startPreviewWatcher = (triggerRefresh, options) => {
+    previewWatcherRestart = previewWatcherRestart
+        .catch(() => undefined)
+        .then(async () => {
+        const previous = previewWatcher;
+        previewWatcher = undefined;
+        if (previous) {
+            await previous.close();
+        }
+        const isPreviewPathIgnored = createPreviewPathIgnored(CMD_EXEC_PATH, getMintIgnoreGlobs());
+        previewWatcher = chokidar
+            .watch(CMD_EXEC_PATH, {
+            ignoreInitial: true,
+            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));
+    });
+    return previewWatcherRestart;
+};
 const listener = (triggerRefresh, options = {}, gate) => {
     watcherGate = gate;
     const previewOptions = { ...options, allowSourceRefs: true };
-    const mintIgnoreGlobs = getMintIgnoreGlobs();
-    chokidar
-        .watch(CMD_EXEC_PATH, {
-        ignoreInitial: true,
-        ignored: (filePath) => {
-            const relativePath = pathUtil.isAbsolute(filePath)
-                ? pathUtil.relative(CMD_EXEC_PATH, filePath)
-                : filePath;
-            if (!relativePath) {
-                return false;
-            }
-            return isMintIgnored(relativePath, mintIgnoreGlobs);
-        },
-        cwd: CMD_EXEC_PATH,
-    })
-        .on('add', (filename) => onAddEvent(filename, triggerRefresh, previewOptions))
-        .on('change', (filename) => onChangeEvent(filename, triggerRefresh, previewOptions))
-        .on('unlink', (filename) => onUnlinkEvent(filename, triggerRefresh, previewOptions));
+    void startPreviewWatcher(triggerRefresh, previewOptions);
 };
 const onAddEvent = async (filename, triggerRefresh, options) => {
     if (watcherGate) {
@@ -270,6 +278,7 @@ const onUnlinkEvent = async (filename, triggerRefresh, options) => {
                     await initializeImportCache(CMD_EXEC_PATH, prebuildResult?.fileImportsMap);
                     await initializeFrontmatterHashCache();
                     await refreshTrackedReferencedFiles();
+                    await startPreviewWatcher(triggerRefresh, options);
                 }
                 catch (err) {
                     console.error('Error rebuilding after .mintignore deletion:', err);
@@ -330,7 +339,7 @@ const initializeFrontmatterHashCache = async () => {
     frontmatterHashes.clear();
     clearPageMetadataCache();
     const importedFiles = getImportedFilesFromCache();
-    const pageFilenames = getFileListSync(CMD_EXEC_PATH).filter((file) => {
+    const pageFilenames = getFileListSync(CMD_EXEC_PATH, CMD_EXEC_PATH, getMintIgnoreGlobs()).filter((file) => {
         return getFileCategory(file, { importedFiles }) === 'page';
     });
     await Promise.all(pageFilenames.map(async (filename) => {
@@ -581,6 +590,7 @@ const onUpdateEvent = async (filename, triggerRefresh, options = {}) => {
                 await initializeImportCache(CMD_EXEC_PATH, prebuildResult?.fileImportsMap);
                 await initializeFrontmatterHashCache();
                 await refreshTrackedReferencedFiles();
+                await startPreviewWatcher(triggerRefresh, options);
             }
             catch (err) {
                 console.error(err.message);

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

@@ -0,0 +1,3 @@
+export declare const createPreviewPathIgnored: (root: string, globs: string[]) => ((filePath: string, stats?: {
+    isDirectory: () => boolean;
+}) => boolean);

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

@@ -0,0 +1,29 @@
+import { createMintIgnoreMatcher, isMintIgnoredBy } from '@mintlify/common';
+import { statSync } from 'fs';
+import pathUtil from 'path';
+const isDirectoryPath = (absolutePath, stats) => {
+    if (stats) {
+        return stats.isDirectory();
+    }
+    try {
+        return statSync(absolutePath).isDirectory();
+    }
+    catch {
+        // Path may already be gone (unlink). Treat as a file so a directory-only
+        // pattern like junk/ does not hide a same-named file's events.
+        return false;
+    }
+};
+export const createPreviewPathIgnored = (root, globs) => {
+    const matcher = createMintIgnoreMatcher(globs);
+    return (filePath, stats) => {
+        const relativePath = pathUtil.isAbsolute(filePath)
+            ? pathUtil.relative(root, filePath)
+            : filePath;
+        if (!relativePath) {
+            return false;
+        }
+        const absolutePath = pathUtil.isAbsolute(filePath) ? filePath : pathUtil.join(root, filePath);
+        return isMintIgnoredBy(relativePath, matcher, isDirectoryPath(absolutePath, stats));
+    };
+};

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

@@ -5,10 +5,10 @@ import { readFile } from 'fs/promises';
 import { join } from 'path';
 import { CMD_EXEC_PATH, NEXT_PUBLIC_PATH } from '../../constants.js';
 import { getImportedFilesFromCache } from './importCache.js';
-import { getCurrentVariables, handleParseError } from './utils.js';
+import { getCurrentVariables, getMintIgnoreGlobs, handleParseError } from './utils.js';
 const getV2SnippetFilenames = () => {
     const importedFiles = getImportedFilesFromCache();
-    return getFileListSync(CMD_EXEC_PATH).filter((file) => {
+    return getFileListSync(CMD_EXEC_PATH, CMD_EXEC_PATH, getMintIgnoreGlobs()).filter((file) => {
         if (!isSnippetExtension(getFileExtension(file)))
             return false;
         if (file.startsWith('snippets/'))