@mintlify/previewing 4.0.1152 → 4.0.1154

package/dist/__tests__/generate-dependent-snippets.test.d.ts

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

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

@@ -0,0 +1,60 @@
+import { findAndRemoveImports, replaceVariables } from '@mintlify/common';
+import { preparseMdxTree } from '@mintlify/prebuild';
+import fse from 'fs-extra';
+import { mkdtemp, rm } from 'fs/promises';
+import { tmpdir } from 'os';
+import { join } from 'path';
+const testPaths = vi.hoisted(() => ({
+    cmd: '',
+    public: '',
+}));
+vi.mock('../constants.js', () => ({
+    get CMD_EXEC_PATH() {
+        return testPaths.cmd;
+    },
+    get NEXT_PUBLIC_PATH() {
+        return testPaths.public;
+    },
+}));
+vi.mock('../local-preview/listener/utils.js', () => ({
+    getCurrentVariables: vi.fn(async () => ({ name: 'Ada' })),
+    handleParseError: vi.fn(),
+    normalizePathForComparison: (path) => {
+        const normalized = path.startsWith('/') ? path : `/${path}`;
+        return normalized.toLowerCase();
+    },
+    suppressParseError: vi.fn(),
+}));
+import { generateDependentSnippets } from '../local-preview/listener/generateDependentSnippets.js';
+import { initializeImportCache } from '../local-preview/listener/importCache.js';
+describe('generateDependentSnippets', () => {
+    let root;
+    beforeEach(async () => {
+        root = await mkdtemp(join(tmpdir(), 'generate-dependent-snippets-'));
+        testPaths.cmd = join(root, 'docs');
+        testPaths.public = join(root, 'public');
+        await fse.ensureDir(testPaths.cmd);
+        await fse.ensureDir(testPaths.public);
+    });
+    afterEach(async () => {
+        await rm(root, { recursive: true, force: true });
+    });
+    it('regenerates legacy snippet importers of changed v2 snippets', async () => {
+        await fse.outputFile(join(testPaths.cmd, 'snippets/base.mdx'), 'export const Base = () => <span>{{name}}</span>;');
+        await fse.outputFile(join(testPaths.cmd, '_snippets/legacy.mdx'), "import { Base } from '../snippets/base.mdx';\n\n<Base />");
+        await initializeImportCache(testPaths.cmd, new Map([
+            ['/snippets/base.mdx', new Set()],
+            ['/_snippets/legacy.mdx', new Set(['/snippets/base.mdx'])],
+        ]));
+        const changedSourcePath = join(testPaths.cmd, 'snippets/base.mdx');
+        const changedContent = replaceVariables((await fse.readFile(changedSourcePath)).toString(), {
+            name: 'Ada',
+        });
+        const changedTree = await preparseMdxTree(changedContent, testPaths.cmd, changedSourcePath, vi.fn());
+        const changedImportData = await findAndRemoveImports(changedTree);
+        const updatedSnippets = await generateDependentSnippets('snippets/base.mdx', changedImportData);
+        expect(updatedSnippets).toEqual(['snippets/base.mdx', '_snippets/legacy.mdx']);
+        expect(await fse.pathExists(join(testPaths.public, '_snippets/legacy.mdx'))).toBe(true);
+        expect((await fse.readFile(join(testPaths.public, '_snippets/legacy.mdx'))).toString()).toContain('Ada');
+    });
+});

package/dist/__tests__/importCache.test.js

@@ -1,5 +1,6 @@
+import { getFileListSync } from '@mintlify/prebuild';
 import fse from 'fs-extra';
-import { initializeImportCache, updateImportCacheForFile, removeFromImportCache, getImportedFilesFromCache, } from '../local-preview/listener/importCache.js';
+import { initializeImportCache, updateImportCacheForFile, removeFromImportCache, getImportedFilesFromCache, getFilesImportingPathFromCache, getTransitiveImportersFromCache, } from '../local-preview/listener/importCache.js';
 vi.mock('fs-extra', () => ({
     default: { readFile: vi.fn() },
 }));
@@ -11,9 +12,11 @@ vi.mock('@mintlify/prebuild', async () => {
     };
 });
 const mockReadFile = vi.mocked(fse.readFile);
+const mockGetFileListSync = vi.mocked(getFileListSync);
 describe('importCache', () => {
     beforeEach(async () => {
         vi.clearAllMocks();
+        mockGetFileListSync.mockReturnValue([]);
         await initializeImportCache('/base');
     });
     it('starts with empty cache', () => {
@@ -47,6 +50,16 @@ describe('importCache', () => {
         expect(result.noLongerImported).toEqual([]);
         expect(getImportedFilesFromCache()).toEqual(new Set(['/shared.mdx']));
     });
+    it('tracks parent-directory relative imports', async () => {
+        mockReadFile.mockResolvedValue(Buffer.from(`import Shared from '../shared/snippet.mdx';\n\n<Shared />`));
+        await updateImportCacheForFile('/base', 'docs/page.mdx');
+        expect(getImportedFilesFromCache()).toEqual(new Set(['/shared/snippet.mdx']));
+    });
+    it('tracks explicit snippet folder imports', async () => {
+        mockReadFile.mockResolvedValue(Buffer.from(`import Callout from '/snippets/callout.mdx';\n\n<Callout />`));
+        await updateImportCacheForFile('/base', 'docs/page.mdx');
+        expect(getImportedFilesFromCache()).toEqual(new Set(['/snippets/callout.mdx']));
+    });
     it('detects when imports change in a file', async () => {
         mockReadFile.mockResolvedValue(Buffer.from(`import Old from './old.mdx';\n\n<Old />`));
         await updateImportCacheForFile('/base', 'page.mdx');
@@ -55,4 +68,35 @@ describe('importCache', () => {
         expect(result.newlyImported).toEqual(['/new.mdx']);
         expect(result.noLongerImported).toEqual(['/old.mdx']);
     });
+    it('returns files that directly import a path', async () => {
+        mockReadFile.mockResolvedValueOnce(Buffer.from(`import S from './shared.mdx';\n\n<S />`));
+        await updateImportCacheForFile('/base', 'a.mdx');
+        mockReadFile.mockResolvedValueOnce(Buffer.from(`import S from './shared.mdx';\n\n<S />`));
+        await updateImportCacheForFile('/base', 'b.mdx');
+        expect(getFilesImportingPathFromCache('/shared.mdx')).toEqual(new Set(['/a.mdx', '/b.mdx']));
+    });
+    it('preserves importer path casing from file updates', async () => {
+        mockReadFile.mockResolvedValue(Buffer.from(`import S from '../Shared.mdx';\n\n<S />`));
+        await updateImportCacheForFile('/base', 'Docs/MyPage.mdx');
+        expect(getFilesImportingPathFromCache('/Shared.mdx')).toEqual(new Set(['/Docs/MyPage.mdx']));
+    });
+    it('preserves importer path casing when initialized from a prebuild import map', async () => {
+        mockGetFileListSync.mockReturnValue(['Docs/MyPage.mdx']);
+        await initializeImportCache('/base', new Map([['/docs/mypage.mdx', new Set(['/shared.mdx'])]]));
+        expect(getFilesImportingPathFromCache('/shared.mdx')).toEqual(new Set(['/Docs/MyPage.mdx']));
+    });
+    it('returns transitive importers for a path', async () => {
+        mockReadFile.mockResolvedValueOnce(Buffer.from(`import S from './shared.mdx';\n\n<S />`));
+        await updateImportCacheForFile('/base', 'snippet.mdx');
+        mockReadFile.mockResolvedValueOnce(Buffer.from(`import Snippet from './snippet.mdx';\n\n<Snippet />`));
+        await updateImportCacheForFile('/base', 'page.mdx');
+        expect(getTransitiveImportersFromCache('/shared.mdx')).toEqual(new Set(['/snippet.mdx', '/page.mdx']));
+    });
+    it('preserves transitive importer path casing', async () => {
+        mockReadFile.mockResolvedValueOnce(Buffer.from(`import S from '../Shared.mdx';\n\n<S />`));
+        await updateImportCacheForFile('/base', 'Snippets/Card.mdx');
+        mockReadFile.mockResolvedValueOnce(Buffer.from(`import Card from '../Snippets/Card.mdx';\n\n<Card />`));
+        await updateImportCacheForFile('/base', 'Docs/Page.mdx');
+        expect(getTransitiveImportersFromCache('/Shared.mdx')).toEqual(new Set(['/Snippets/Card.mdx', '/Docs/Page.mdx']));
+    });
 });

package/dist/__tests__/resolve-imports-from-import-closure.test.d.ts

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

package/dist/__tests__/resolve-imports-from-import-closure.test.js

@@ -0,0 +1,80 @@
+import { findAndRemoveImports, stringifyTree } from '@mintlify/common';
+import { preparseMdxTree } from '@mintlify/prebuild';
+import fse from 'fs-extra';
+import { mkdtemp, rm } from 'fs/promises';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { resolveImportsFromImportClosure } from '../local-preview/listener/resolve-imports-from-import-closure.js';
+const testPaths = vi.hoisted(() => ({
+    cmd: '',
+    public: '',
+}));
+vi.mock('../constants.js', () => ({
+    get CMD_EXEC_PATH() {
+        return testPaths.cmd;
+    },
+    get NEXT_PUBLIC_PATH() {
+        return testPaths.public;
+    },
+}));
+vi.mock('../local-preview/listener/utils.js', () => ({
+    getCurrentVariables: vi.fn(async () => ({ name: 'Ada' })),
+    handleParseError: vi.fn(),
+}));
+describe('resolveImportsFromImportClosure', () => {
+    let root;
+    beforeEach(async () => {
+        root = await mkdtemp(join(tmpdir(), 'resolve-imports-from-import-closure-'));
+        testPaths.cmd = join(root, 'docs');
+        testPaths.public = join(root, 'public');
+        await fse.ensureDir(testPaths.cmd);
+        await fse.ensureDir(testPaths.public);
+    });
+    afterEach(async () => {
+        await rm(root, { recursive: true, force: true });
+    });
+    it('resolves newly imported source snippets with variables and nested imports', async () => {
+        await fse.outputFile(join(testPaths.cmd, 'nested.mdx'), 'export const Nested = () => <span>{{name}}</span>;');
+        await fse.outputFile(join(testPaths.cmd, 'snippet.mdx'), "import { Nested } from './nested.mdx';\n\n<Nested />");
+        const pageContent = "import Snippet from './snippet.mdx';\n\n<Snippet />";
+        const tree = await preparseMdxTree(pageContent, testPaths.cmd, join(testPaths.cmd, 'page.mdx'), vi.fn());
+        const importsResponse = await findAndRemoveImports(tree);
+        const resolvedTree = await resolveImportsFromImportClosure({
+            ...importsResponse,
+            filename: 'page.mdx',
+        });
+        const resolvedContent = stringifyTree(resolvedTree);
+        expect(resolvedContent).toContain('Ada');
+        expect(resolvedContent).not.toContain('{{name}}');
+        expect(resolvedContent).not.toContain("import { Nested } from './nested.mdx'");
+    });
+    it('resolves explicit snippet imports with parent-directory nested imports', async () => {
+        await fse.outputFile(join(testPaths.cmd, 'shared/nested.mdx'), 'export const Nested = () => <span>{{name}}</span>;');
+        await fse.outputFile(join(testPaths.cmd, 'snippets/foundry/card.mdx'), "import { Nested } from '../../shared/nested.mdx';\n\n<Nested />");
+        const pageContent = "import Card from '/snippets/foundry/card.mdx';\n\n<Card />";
+        const tree = await preparseMdxTree(pageContent, testPaths.cmd, join(testPaths.cmd, 'docs/page.mdx'), vi.fn());
+        const importsResponse = await findAndRemoveImports(tree);
+        const resolvedTree = await resolveImportsFromImportClosure({
+            ...importsResponse,
+            filename: 'docs/page.mdx',
+        });
+        const resolvedContent = stringifyTree(resolvedTree);
+        expect(resolvedContent).toContain('Ada');
+        expect(resolvedContent).not.toContain('{{name}}');
+        expect(resolvedContent).not.toContain("import { Nested } from '../../shared/nested.mdx'");
+    });
+    it('resolves named imports from explicit snippets', async () => {
+        await fse.outputFile(join(testPaths.cmd, 'snippets/badge.mdx'), 'export const Badge = () => <span>{{name}}</span>;');
+        const pageContent = "import { Badge } from '/snippets/badge.mdx';\n\n<Badge />";
+        const tree = await preparseMdxTree(pageContent, testPaths.cmd, join(testPaths.cmd, 'docs/page.mdx'), vi.fn());
+        const importsResponse = await findAndRemoveImports(tree);
+        const resolvedTree = await resolveImportsFromImportClosure({
+            ...importsResponse,
+            filename: 'docs/page.mdx',
+        });
+        const resolvedContent = stringifyTree(resolvedTree);
+        expect(resolvedContent).toContain('Ada');
+        expect(resolvedContent).not.toContain('{{name}}');
+        expect(resolvedContent).not.toContain("import { Badge } from '/snippets/badge.mdx'");
+    });
+});

package/dist/__tests__/resolve-page-imports.test.d.ts

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

package/dist/__tests__/resolve-page-imports.test.js

@@ -0,0 +1,48 @@
+import { findAndRemoveImports, stringifyTree } from '@mintlify/common';
+import { preparseMdxTree } from '@mintlify/prebuild';
+import fse from 'fs-extra';
+import { mkdtemp, rm } from 'fs/promises';
+import { tmpdir } from 'os';
+import { join } from 'path';
+const testPaths = vi.hoisted(() => ({
+    cmd: '',
+    public: '',
+}));
+vi.mock('../constants.js', () => ({
+    get CMD_EXEC_PATH() {
+        return testPaths.cmd;
+    },
+    get NEXT_PUBLIC_PATH() {
+        return testPaths.public;
+    },
+}));
+vi.mock('../local-preview/listener/utils.js', () => ({
+    getCurrentVariables: vi.fn(async () => ({ name: 'Ada' })),
+    handleParseError: vi.fn(),
+}));
+import { resolvePageImports } from '../local-preview/listener/resolve-page-imports.js';
+describe('resolvePageImports', () => {
+    let root;
+    beforeEach(async () => {
+        root = await mkdtemp(join(tmpdir(), 'resolve-page-imports-'));
+        testPaths.cmd = join(root, 'docs');
+        testPaths.public = join(root, 'public');
+        await fse.ensureDir(testPaths.cmd);
+        await fse.ensureDir(testPaths.public);
+    });
+    afterEach(async () => {
+        await rm(root, { recursive: true, force: true });
+    });
+    it('resolves newly imported source snippets with variables and nested imports', async () => {
+        await fse.outputFile(join(testPaths.cmd, 'nested.mdx'), 'export const Nested = () => <span>{{name}}</span>;');
+        await fse.outputFile(join(testPaths.cmd, 'snippet.mdx'), "import { Nested } from './nested.mdx';\n\n<Nested />");
+        const pageContent = "import Snippet from './snippet.mdx';\n\n<Snippet />";
+        const tree = await preparseMdxTree(pageContent, testPaths.cmd, join(testPaths.cmd, 'page.mdx'), vi.fn());
+        const importsResponse = await findAndRemoveImports(tree);
+        const resolvedTree = await resolvePageImports({ ...importsResponse, filename: 'page.mdx' });
+        const resolvedContent = stringifyTree(resolvedTree);
+        expect(resolvedContent).toContain('Ada');
+        expect(resolvedContent).not.toContain('{{name}}');
+        expect(resolvedContent).not.toContain("import { Nested } from './nested.mdx'");
+    });
+});

package/dist/__tests__/shouldRegenerateNavForPage.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach } from 'vitest';
-import { shouldRegenerateNavForPage } from '../local-preview/listener/utils.js';
+import { seedFrontmatterHashForPage, shouldRegenerateNavForPage, } from '../local-preview/listener/utils.js';
 describe('shouldRegenerateNavForPage', () => {
     let frontmatterHashes;
     beforeEach(() => {
@@ -30,6 +30,13 @@ describe('shouldRegenerateNavForPage', () => {
         const result = await shouldRegenerateNavForPage('test.mdx', updatedContent, frontmatterHashes);
         expect(result).toBe(false);
     });
+    it('should return false for a content-only change after seeding frontmatter', async () => {
+        const originalContent = `---\ntitle: "Test Page"\ndescription: "A test page"\n---\n# Original Content`;
+        const updatedContent = `---\ntitle: "Test Page"\ndescription: "A test page"\n---\n# Updated Content`;
+        seedFrontmatterHashForPage('test.mdx', originalContent, frontmatterHashes);
+        const result = await shouldRegenerateNavForPage('test.mdx', updatedContent, frontmatterHashes);
+        expect(result).toBe(false);
+    });
     it('should handle files with no frontmatter', async () => {
         const contentNoFrontmatter = '# Just a heading\n\nSome content';
         await shouldRegenerateNavForPage('test.mdx', contentNoFrontmatter, frontmatterHashes);

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

@@ -1,68 +1,56 @@
-import { findAndRemoveImports, stringifyTree, topologicalSort, hasImports, optionallyAddLeadingSlash, optionallyRemoveLeadingSlash, resolveImportPath, } from '@mintlify/common';
-import { outputFile } from 'fs-extra';
+import { findAndRemoveImports, getFileCategory, stringifyTree, topologicalSort, hasImports, optionallyAddLeadingSlash, optionallyRemoveLeadingSlash, replaceVariables, resolveImportPath, } from '@mintlify/common';
+import { preparseMdxTree } from '@mintlify/prebuild';
+import { promises as _promises } from 'fs';
+import fse from 'fs-extra';
 import { join } from 'path';
-import { NEXT_PUBLIC_PATH } from '../../constants.js';
-import { getOriginalSnippets } from './getSnippets.js';
-import { resolveAllImports } from './resolveAllImports.js';
-const findAllDependents = async (initialFileWithSlash, allSnippets, processedDataCache) => {
-    const affected = new Set([initialFileWithSlash]);
-    const queue = [initialFileWithSlash];
-    while (queue.length > 0) {
-        const currentSourceFile = queue.shift();
-        for (const snippet of allSnippets) {
-            const potentialDependentFile = optionallyAddLeadingSlash(snippet.filename);
-            if (potentialDependentFile === currentSourceFile)
-                continue;
-            let processedData = processedDataCache.get(potentialDependentFile);
-            if (processedData == null) {
-                const clonedTree = structuredClone(snippet.tree);
-                processedData = await findAndRemoveImports(clonedTree);
-                processedDataCache.set(potentialDependentFile, processedData);
-            }
-            const importsCurrentFile = Object.keys(processedData.importMap).some((importPath) => {
-                const resolvedPath = resolveImportPath(importPath, potentialDependentFile);
-                return resolvedPath === currentSourceFile;
-            });
-            if (importsCurrentFile) {
-                if (!affected.has(potentialDependentFile)) {
-                    affected.add(potentialDependentFile);
-                    queue.push(potentialDependentFile);
-                }
-            }
+import { CMD_EXEC_PATH, NEXT_PUBLIC_PATH } from '../../constants.js';
+import { getImportedFilesFromCache, getTransitiveImportersFromCache } from './importCache.js';
+import { resolveImportsFromImportClosure } from './resolve-imports-from-import-closure.js';
+import { getCurrentVariables, handleParseError } from './utils.js';
+const { readFile } = _promises;
+const getAffectedSnippetFilenames = (changedFilename) => {
+    const affectedSnippets = new Set([optionallyAddLeadingSlash(changedFilename)]);
+    const importedFiles = getImportedFilesFromCache();
+    const transitiveImporters = getTransitiveImportersFromCache(changedFilename);
+    for (const importer of transitiveImporters) {
+        const category = getFileCategory(importer, { importedFiles });
+        if (category === 'snippet' || category === 'snippet-v2') {
+            affectedSnippets.add(importer);
         }
     }
-    return affected;
+    return affectedSnippets;
+};
+const getSnippetImportData = async (filename, variables) => {
+    try {
+        const relativePath = optionallyRemoveLeadingSlash(filename);
+        const sourcePath = join(CMD_EXEC_PATH, relativePath);
+        const content = replaceVariables((await readFile(sourcePath)).toString(), variables);
+        const tree = await preparseMdxTree(content, CMD_EXEC_PATH, sourcePath, handleParseError);
+        const importData = await findAndRemoveImports(tree);
+        return {
+            filename: optionallyAddLeadingSlash(filename),
+            ...importData,
+        };
+    }
+    catch (err) {
+        console.warn(`Failed to parse snippet ${filename}:`, err);
+        return null;
+    }
 };
 export const generateDependentSnippets = async (changedFilename, newImportData) => {
-    const processedDataCache = new Map();
-    const allOriginalSnippets = await getOriginalSnippets();
     const updatedSnippetFileKey = optionallyAddLeadingSlash(changedFilename);
-    const affectedSnippets = await findAllDependents(updatedSnippetFileKey, allOriginalSnippets, processedDataCache);
+    const affectedSnippets = getAffectedSnippetFilenames(changedFilename);
+    const variables = await getCurrentVariables();
     const snippetPromises = Array.from(affectedSnippets).map(async (filename) => {
-        const cachedData = processedDataCache.get(filename);
-        if (cachedData)
-            return { filename, ...cachedData };
-        const originalSnippet = allOriginalSnippets.find((s) => optionallyAddLeadingSlash(s.filename) === filename);
-        if (!originalSnippet)
-            return null;
-        const processed = await findAndRemoveImports(structuredClone(originalSnippet.tree));
-        processedDataCache.set(filename, processed);
-        return { filename, ...processed };
+        if (filename === updatedSnippetFileKey) {
+            return {
+                ...newImportData,
+                filename: updatedSnippetFileKey,
+            };
+        }
+        return await getSnippetImportData(filename, variables);
     });
     const snippets = (await Promise.all(snippetPromises)).filter((item) => item != null);
-    const idx = snippets.findIndex((item) => item.filename === updatedSnippetFileKey);
-    if (idx !== -1) {
-        snippets[idx] = {
-            ...newImportData,
-            filename: updatedSnippetFileKey,
-        };
-    }
-    else {
-        snippets.push({
-            ...newImportData,
-            filename: updatedSnippetFileKey,
-        });
-    }
     const graph = {};
     snippets.forEach((item) => {
         graph[item.filename] = Object.keys(item.importMap)
@@ -77,12 +65,12 @@ export const generateDependentSnippets = async (changedFilename, newImportData)
     const processedSnippets = [];
     for (const currentSnippet of orderedSnippets) {
         let processedTree = currentSnippet.tree;
-        if (currentSnippet.filename !== updatedSnippetFileKey && hasImports(currentSnippet)) {
-            processedTree = await resolveAllImports(currentSnippet);
+        if (hasImports(currentSnippet)) {
+            processedTree = await resolveImportsFromImportClosure(currentSnippet);
         }
         const targetFilename = optionallyRemoveLeadingSlash(currentSnippet.filename);
         const targetPath = join(NEXT_PUBLIC_PATH, targetFilename);
-        await outputFile(targetPath, stringifyTree(processedTree), { flag: 'w' });
+        await fse.outputFile(targetPath, stringifyTree(processedTree), { flag: 'w' });
         processedSnippets.push(targetFilename);
     }
     return processedSnippets;

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

@@ -1,43 +1,42 @@
-import { findAndRemoveImports, optionallyRemoveLeadingSlash, resolveAllImports, resolveImportPath, stringifyTree, isSnippetExtension, getFileCategory, } from '@mintlify/common';
-import { preparseMdxTree, getFileListSync, getFileExtension } from '@mintlify/prebuild';
+import { findAndRemoveImports, optionallyAddLeadingSlash, optionallyRemoveLeadingSlash, stringifyTree, getFileCategory, } from '@mintlify/common';
+import { preparseMdxTree } from '@mintlify/prebuild';
 import { promises as _promises } from 'fs';
 import { outputFile } from 'fs-extra';
 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 { getFilesImportingPathFromCache, getImportedFilesFromCache } from './importCache.js';
+import { resolvePageImports } from './resolve-page-imports.js';
 import { handleParseError } from './utils.js';
 const { readFile } = _promises;
-export const generatePagesWithImports = async (updatedSnippets) => {
-    const snippets = await getProcessedSnippets();
+const getAffectedPageFilenames = (updatedSnippets) => {
     const importedFiles = getImportedFilesFromCache();
-    const pageFilenames = getFileListSync(CMD_EXEC_PATH).filter((file) => {
-        if (!isSnippetExtension(getFileExtension(file))) {
-            return false;
+    const pageFilenames = new Set();
+    for (const snippet of updatedSnippets) {
+        for (const importer of getFilesImportingPathFromCache(optionallyAddLeadingSlash(snippet))) {
+            const category = getFileCategory(importer, { importedFiles });
+            if (category === 'page') {
+                pageFilenames.add(optionallyRemoveLeadingSlash(importer));
+            }
         }
-        const category = getFileCategory(file, { importedFiles });
-        return category === 'page';
-    });
-    await Promise.all(pageFilenames.map(async (pageFilename) => {
+    }
+    return pageFilenames;
+};
+export const generatePagesWithImports = async (updatedSnippets) => {
+    const pageFilenames = getAffectedPageFilenames(updatedSnippets);
+    await Promise.all(Array.from(pageFilenames).map(async (pageFilename) => {
         const sourcePath = join(CMD_EXEC_PATH, pageFilename);
         const contentStr = (await readFile(sourcePath)).toString();
         try {
             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);
-                return (resolvedPath != null &&
-                    updatedSnippets.has(optionallyRemoveLeadingSlash(resolvedPath)));
-            })) {
-                const content = await resolveAllImports({
-                    snippets,
-                    fileWithImports: { ...importsResponse, filename: pageFilename },
-                });
-                const targetPath = join(NEXT_PROPS_PATH, pageFilename);
-                await outputFile(targetPath, stringifyTree(content), {
-                    flag: 'w',
-                });
-            }
+            const content = await resolvePageImports({
+                ...importsResponse,
+                filename: pageFilename,
+            });
+            const targetPath = join(NEXT_PROPS_PATH, pageFilename);
+            await outputFile(targetPath, stringifyTree(content), {
+                flag: 'w',
+            });
         }
         catch (err) {
             console.log('Error generating pages with imports');

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

@@ -6,4 +6,6 @@ export declare const initializeImportCache: (baseDir: string, prebuildImportMap?
 export declare const updateImportCacheForFile: (baseDir: string, filename: string) => Promise<ImportCacheChangeResult>;
 export declare const removeFromImportCache: (filename: string) => ImportCacheChangeResult;
 export declare const getImportedFilesFromCache: () => Set<string>;
+export declare const getFilesImportingPathFromCache: (path: string) => Set<string>;
+export declare const getTransitiveImportersFromCache: (path: string) => Set<string>;
 export declare const syncImportedFileLocations: (changes: ImportCacheChangeResult) => Promise<void>;

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

@@ -8,6 +8,7 @@ import { resolveAllImports } from './resolveAllImports.js';
 import { handleParseError, normalizePathForComparison, suppressParseError } from './utils.js';
 const fileImportsMap = new Map();
 const importerCounts = new Map();
+const originalPathByNormalizedPath = new Map();
 const addImporter = (path) => {
     const count = importerCounts.get(path) ?? 0;
     importerCounts.set(path, count + 1);
@@ -49,9 +50,15 @@ const extractFileImports = async (baseDir, filename) => {
 export const initializeImportCache = async (baseDir, prebuildImportMap) => {
     fileImportsMap.clear();
     importerCounts.clear();
+    originalPathByNormalizedPath.clear();
     if (prebuildImportMap) {
+        for (const filePath of getFileListSync(baseDir)) {
+            originalPathByNormalizedPath.set(normalizePathForComparison(filePath), optionallyAddLeadingSlash(filePath));
+        }
         for (const [filePath, imports] of prebuildImportMap) {
             const normalizedPath = normalizePathForComparison(filePath);
+            const originalPath = originalPathByNormalizedPath.get(normalizedPath) ?? filePath;
+            originalPathByNormalizedPath.set(normalizedPath, optionallyAddLeadingSlash(originalPath));
             fileImportsMap.set(normalizedPath, imports);
             for (const imp of imports) {
                 addImporter(imp);
@@ -64,6 +71,7 @@ export const initializeImportCache = async (baseDir, prebuildImportMap) => {
         const normalizedPath = normalizePathForComparison(filename);
         const imports = await extractFileImports(baseDir, filename);
         fileImportsMap.set(normalizedPath, imports);
+        originalPathByNormalizedPath.set(normalizedPath, optionallyAddLeadingSlash(filename));
         for (const imp of imports) {
             addImporter(imp);
         }
@@ -76,6 +84,7 @@ export const updateImportCacheForFile = async (baseDir, filename) => {
     const normalizedPath = normalizePathForComparison(filename);
     const newImports = await extractFileImports(baseDir, filename);
     const oldImports = fileImportsMap.get(normalizedPath) ?? new Set();
+    originalPathByNormalizedPath.set(normalizedPath, optionallyAddLeadingSlash(filename));
     const newlyImported = [];
     const noLongerImported = [];
     for (const imp of newImports) {
@@ -104,11 +113,40 @@ export const removeFromImportCache = (filename) => {
         }
     }
     fileImportsMap.delete(normalizedPath);
+    originalPathByNormalizedPath.delete(normalizedPath);
     return { newlyImported: [], noLongerImported };
 };
 export const getImportedFilesFromCache = () => {
     return new Set(Array.from(importerCounts.keys(), (key) => key.toLowerCase()));
 };
+export const getFilesImportingPathFromCache = (path) => {
+    const normalizedPath = normalizePathForComparison(path);
+    const importers = new Set();
+    for (const [filePath, imports] of fileImportsMap) {
+        if (imports.has(normalizedPath)) {
+            importers.add(originalPathByNormalizedPath.get(filePath) ?? filePath);
+        }
+    }
+    return importers;
+};
+export const getTransitiveImportersFromCache = (path) => {
+    const importers = new Set();
+    const queue = [normalizePathForComparison(path)];
+    while (queue.length > 0) {
+        const currentPath = queue.shift();
+        if (currentPath == null) {
+            continue;
+        }
+        for (const importer of getFilesImportingPathFromCache(currentPath)) {
+            if (importers.has(importer)) {
+                continue;
+            }
+            importers.add(importer);
+            queue.push(importer);
+        }
+    }
+    return importers;
+};
 const isSnippetByFolder = (path) => {
     const normalized = normalizePathForComparison(path).toLowerCase();
     return normalized.startsWith('/snippets/') || normalized.startsWith('/_snippets/');

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

@@ -3,5 +3,6 @@ declare const listener: (triggerRefresh: () => void, options?: {
     localSchema?: boolean;
     groups?: string[];
 }) => void;
-export { initializeImportCache };
+declare const initializeFrontmatterHashCache: () => Promise<void>;
+export { initializeFrontmatterHashCache, initializeImportCache };
 export default listener;