@mintlify/previewing 4.0.1153 → 4.0.1155

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/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.js

@@ -17,7 +17,7 @@ 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 { resolveImportsFromImportClosure } from './resolve-imports-from-import-closure.js';
 import { resolvePageImports } from './resolve-page-imports.js';
 import { updateCustomLanguages, updateGeneratedNav, updateOpenApiFiles, upsertOpenApiFile, } from './update.js';
 import { getCurrentVariables, getMintIgnoreGlobs, handleParseError, isFileSizeValid, isJsonValid, seedFrontmatterHashForPage, shouldRegenerateNavForPage, suppressParseError, } from './utils.js';
@@ -301,7 +301,7 @@ const onUpdateEvent = async (filename, triggerRefresh, options = {}) => {
             const tree = await preparseMdxTree(contentStr, CMD_EXEC_PATH, filePath, handleParseError);
             const importsResponse = await findAndRemoveImports(tree);
             if (hasImports(importsResponse)) {
-                contentStr = stringifyTree(await resolveAllImports({ ...importsResponse, filename }));
+                contentStr = stringifyTree(await resolveImportsFromImportClosure({ ...importsResponse, filename }));
             }
             await fse.outputFile(targetPath, contentStr, {
                 flag: 'w',

package/dist/local-preview/listener/resolve-imports-from-import-closure.d.ts

@@ -0,0 +1,3 @@
+import type { FileWithImports } from '@mintlify/common';
+import type { Root } from 'mdast';
+export declare const resolveImportsFromImportClosure: (fileWithImports: FileWithImports) => Promise<Root>;

package/dist/local-preview/listener/resolve-imports-from-import-closure.js

@@ -0,0 +1,98 @@
+import { findAndRemoveImports, hasImports, optionallyAddLeadingSlash, optionallyRemoveLeadingSlash, replaceVariables, resolveAllImports as baseResolveAllImports, resolveImportPath, topologicalSort, } from '@mintlify/common';
+import { preparseMdxTree } from '@mintlify/prebuild';
+import fse from 'fs-extra';
+import { join } from 'path';
+import { CMD_EXEC_PATH, NEXT_PUBLIC_PATH } from '../../constants.js';
+import { getCurrentVariables, handleParseError } from './utils.js';
+const getImportSourcePath = async (filename) => {
+    const generatedPath = join(NEXT_PUBLIC_PATH, filename);
+    if (await fse.pathExists(generatedPath)) {
+        return {
+            baseDir: NEXT_PUBLIC_PATH,
+            path: generatedPath,
+        };
+    }
+    const originalPath = join(CMD_EXEC_PATH, filename);
+    if (await fse.pathExists(originalPath)) {
+        return {
+            baseDir: CMD_EXEC_PATH,
+            path: originalPath,
+        };
+    }
+    return null;
+};
+const parseSnippetWithImports = async ({ filename, variables, snippetsByFilename, }) => {
+    const normalizedFilename = optionallyAddLeadingSlash(filename);
+    if (snippetsByFilename.has(normalizedFilename)) {
+        return;
+    }
+    const importSource = await getImportSourcePath(optionallyRemoveLeadingSlash(normalizedFilename));
+    if (importSource == null) {
+        return;
+    }
+    const content = replaceVariables((await fse.readFile(importSource.path)).toString(), variables);
+    const tree = await preparseMdxTree(content, importSource.baseDir, importSource.path, handleParseError);
+    const importData = await findAndRemoveImports(tree);
+    const fileWithImports = {
+        filename: normalizedFilename,
+        ...importData,
+    };
+    snippetsByFilename.set(normalizedFilename, fileWithImports);
+    await Promise.all(Object.keys(importData.importMap).map(async (source) => {
+        const resolvedPath = resolveImportPath(source, normalizedFilename);
+        if (resolvedPath == null) {
+            return;
+        }
+        await parseSnippetWithImports({
+            filename: resolvedPath,
+            variables,
+            snippetsByFilename,
+        });
+    }));
+};
+const resolveSnippetImports = async (snippetsByFilename) => {
+    const graph = {};
+    for (const snippet of snippetsByFilename.values()) {
+        graph[snippet.filename] = Object.keys(snippet.importMap)
+            .map((source) => resolveImportPath(source, snippet.filename))
+            .filter((resolvedPath) => {
+            return resolvedPath != null && snippetsByFilename.has(resolvedPath);
+        });
+    }
+    const orderedFilenames = topologicalSort(graph).reverse();
+    const resolvedSnippets = [];
+    for (const filename of orderedFilenames) {
+        const snippet = snippetsByFilename.get(filename);
+        if (snippet == null) {
+            continue;
+        }
+        const tree = hasImports(snippet)
+            ? await baseResolveAllImports({
+                snippets: resolvedSnippets,
+                fileWithImports: snippet,
+            })
+            : snippet.tree;
+        resolvedSnippets.push({ filename: snippet.filename, tree });
+    }
+    return resolvedSnippets;
+};
+export const resolveImportsFromImportClosure = async (fileWithImports) => {
+    const variables = await getCurrentVariables();
+    const snippetsByFilename = new Map();
+    await Promise.all(Object.keys(fileWithImports.importMap).map(async (source) => {
+        const resolvedPath = resolveImportPath(source, fileWithImports.filename);
+        if (resolvedPath == null) {
+            return;
+        }
+        await parseSnippetWithImports({
+            filename: resolvedPath,
+            variables,
+            snippetsByFilename,
+        });
+    }));
+    const snippets = await resolveSnippetImports(snippetsByFilename);
+    return await baseResolveAllImports({
+        snippets,
+        fileWithImports,
+    });
+};