@mintlify/previewing 4.0.836 → 4.0.838

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

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

package/dist/__tests__/importCache.test.js

@@ -0,0 +1,58 @@
+import fse from 'fs-extra';
+import { initializeImportCache, updateImportCacheForFile, removeFromImportCache, getImportedFilesFromCache, } from '../local-preview/listener/importCache.js';
+vi.mock('fs-extra', () => ({
+    default: { readFile: vi.fn() },
+}));
+vi.mock('@mintlify/prebuild', async () => {
+    const actual = await vi.importActual('@mintlify/prebuild');
+    return {
+        ...actual,
+        getFileListSync: vi.fn().mockReturnValue([]),
+    };
+});
+const mockReadFile = vi.mocked(fse.readFile);
+describe('importCache', () => {
+    beforeEach(async () => {
+        vi.clearAllMocks();
+        await initializeImportCache('/base');
+    });
+    it('starts with empty cache', () => {
+        expect(getImportedFilesFromCache()).toEqual(new Set());
+    });
+    it('tracks imports when file is updated', async () => {
+        mockReadFile.mockResolvedValue(Buffer.from(`import Foo from './foo.mdx';\n\n<Foo />`));
+        await updateImportCacheForFile('/base', 'page.mdx');
+        expect(getImportedFilesFromCache()).toEqual(new Set(['/foo.mdx']));
+    });
+    it('returns newlyImported when import is added', async () => {
+        mockReadFile.mockResolvedValue(Buffer.from(`import Bar from '/bar.mdx';\n\n<Bar />`));
+        const result = await updateImportCacheForFile('/base', 'page.mdx');
+        expect(result.newlyImported).toEqual(['/bar.mdx']);
+    });
+    it('returns noLongerImported when file is removed', async () => {
+        mockReadFile.mockResolvedValue(Buffer.from(`import X from './x.mdx';\n\n<X />`));
+        await updateImportCacheForFile('/base', 'a.mdx');
+        const result = removeFromImportCache('a.mdx');
+        expect(result.noLongerImported).toEqual(['/x.mdx']);
+    });
+    it('ignores non-mdx files', async () => {
+        const result = await updateImportCacheForFile('/base', 'file.js');
+        expect(result).toEqual({ newlyImported: [], noLongerImported: [] });
+    });
+    it('keeps import in cache if still referenced by another file', async () => {
+        mockReadFile.mockResolvedValue(Buffer.from(`import S from './shared.mdx';\n\n<S />`));
+        await updateImportCacheForFile('/base', 'a.mdx');
+        await updateImportCacheForFile('/base', 'b.mdx');
+        const result = removeFromImportCache('a.mdx');
+        expect(result.noLongerImported).toEqual([]);
+        expect(getImportedFilesFromCache()).toEqual(new Set(['/shared.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');
+        mockReadFile.mockResolvedValue(Buffer.from(`import New from './new.mdx';\n\n<New />`));
+        const result = await updateImportCacheForFile('/base', 'page.mdx');
+        expect(result.newlyImported).toEqual(['/new.mdx']);
+        expect(result.noLongerImported).toEqual(['/old.mdx']);
+    });
+});

package/dist/local-preview/index.js

@@ -5,8 +5,8 @@ import isOnline from 'is-online';
 import { CLIENT_PATH, DOT_MINTLIFY, CMD_EXEC_PATH, VERSION_PATH, NEXT_PUBLIC_PATH, NEXT_PROPS_PATH, } from '../constants.js';
 import { addLog, clearLogs } from '../logging-state.js';
 import { ErrorLog, SpinnerLog } from '../logs.js';
-import { silentUpdateClient } from './update.js';
 import { run } from './run.js';
+import { silentUpdateClient } from './update.js';
 const dev = async (argv) => {
     const hasInternet = await isOnline();
     const localSchema = argv['local-schema'];
@@ -26,7 +26,11 @@ const dev = async (argv) => {
         process.exit(1);
     }
     addLog(_jsx(SpinnerLog, { message: "preparing local preview..." }));
-    const { needsUpdate, error } = await silentUpdateClient({ versionString, clientVersion, cliVersion });
+    const { needsUpdate, error } = await silentUpdateClient({
+        versionString,
+        clientVersion,
+        cliVersion,
+    });
     if (error) {
         clearLogs();
         addLog(_jsx(ErrorLog, { message: error }));
@@ -37,8 +41,10 @@ const dev = async (argv) => {
     fse.emptyDirSync(NEXT_PUBLIC_PATH);
     fse.emptyDirSync(NEXT_PROPS_PATH);
     process.chdir(CLIENT_PATH);
+    let fileImportsMap;
     try {
-        await prebuild(CMD_EXEC_PATH, { localSchema, groups, disableOpenApi });
+        const result = await prebuild(CMD_EXEC_PATH, { localSchema, groups, disableOpenApi });
+        fileImportsMap = result?.fileImportsMap;
     }
     catch (err) {
         clearLogs();
@@ -47,6 +53,6 @@ const dev = async (argv) => {
         await new Promise((resolve) => setTimeout(resolve, 50));
         process.exit(1);
     }
-    await run({ ...argv, needsUpdate });
+    await run({ ...argv, needsUpdate, fileImportsMap });
 };
 export default dev;

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

@@ -1,4 +1,4 @@
-import { findAndRemoveImports, stringifyTree, topologicalSort, hasImports, optionallyAddLeadingSlash, optionallyRemoveLeadingSlash, resolveSnippetImportPath, } from '@mintlify/common';
+import { findAndRemoveImports, stringifyTree, topologicalSort, hasImports, optionallyAddLeadingSlash, optionallyRemoveLeadingSlash, resolveImportPath, } from '@mintlify/common';
 import { outputFile } from 'fs-extra';
 import { join } from 'path';
 import { NEXT_PUBLIC_PATH } from '../../constants.js';
@@ -20,7 +20,7 @@ const findAllDependents = async (initialFileWithSlash, allSnippets, processedDat
                 processedDataCache.set(potentialDependentFile, processedData);
             }
             const importsCurrentFile = Object.keys(processedData.importMap).some((importPath) => {
-                const resolvedPath = resolveSnippetImportPath(importPath, potentialDependentFile);
+                const resolvedPath = resolveImportPath(importPath, potentialDependentFile);
                 return resolvedPath === currentSourceFile;
             });
             if (importsCurrentFile) {
@@ -66,7 +66,7 @@ export const generateDependentSnippets = async (changedFilename, newImportData)
     const graph = {};
     snippets.forEach((item) => {
         graph[item.filename] = Object.keys(item.importMap)
-            .map((dep) => resolveSnippetImportPath(dep, item.filename))
+            .map((dep) => resolveImportPath(dep, item.filename))
             .filter((resolvedDep) => resolvedDep != null);
     });
     const sortedSnippets = topologicalSort(graph).reverse();

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

@@ -1,16 +1,22 @@
-import { findAndRemoveImports, optionallyRemoveLeadingSlash, resolveAllImports, resolveSnippetImportPath, stringifyTree, SNIPPET_EXTENSIONS, } from '@mintlify/common';
-import { preparseMdxTree, getFileListSync } from '@mintlify/prebuild';
+import { findAndRemoveImports, optionallyRemoveLeadingSlash, resolveAllImports, resolveImportPath, stringifyTree, isSnippetExtension, getFileCategory, } from '@mintlify/common';
+import { preparseMdxTree, getFileListSync, getFileExtension } 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';
 const { readFile } = _promises;
 export const generatePagesWithImports = async (updatedSnippets) => {
     const snippets = await getProcessedSnippets();
-    const pageFilenames = getFileListSync(CMD_EXEC_PATH).filter((file) => SNIPPET_EXTENSIONS.some((ext) => file.endsWith(ext)) &&
-        !file.startsWith('_snippets/') &&
-        !file.startsWith('snippets/'));
+    const importedFiles = getImportedFilesFromCache();
+    const pageFilenames = getFileListSync(CMD_EXEC_PATH).filter((file) => {
+        if (!isSnippetExtension(getFileExtension(file))) {
+            return false;
+        }
+        const category = getFileCategory(file, { importedFiles });
+        return category === 'page';
+    });
     await Promise.all(pageFilenames.map(async (pageFilename) => {
         const sourcePath = join(CMD_EXEC_PATH, pageFilename);
         const contentStr = (await readFile(sourcePath)).toString();
@@ -18,7 +24,7 @@ export const generatePagesWithImports = async (updatedSnippets) => {
             const tree = await preparseMdxTree(contentStr, CMD_EXEC_PATH, sourcePath);
             const importsResponse = await findAndRemoveImports(tree);
             if (Object.keys(importsResponse.importMap).some((importPath) => {
-                const resolvedPath = resolveSnippetImportPath(importPath, pageFilename);
+                const resolvedPath = resolveImportPath(importPath, pageFilename);
                 return (resolvedPath != null &&
                     updatedSnippets.has(optionallyRemoveLeadingSlash(resolvedPath)));
             })) {

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

@@ -1,14 +1,27 @@
-import { optionallyAddLeadingSlash, SNIPPET_EXTENSIONS } from '@mintlify/common';
-import { getFileListSync, preparseMdxTree } from '@mintlify/prebuild';
+import { optionallyAddLeadingSlash, isSnippetExtension, isImportedAsSnippet, } from '@mintlify/common';
+import { getFileListSync, preparseMdxTree, getFileExtension } from '@mintlify/prebuild';
 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';
 const { readFile } = _promises;
-const getSnippetBase = async (BASE_DIR) => {
-    const snippetFilenames = getFileListSync(BASE_DIR).filter((file) => SNIPPET_EXTENSIONS.some((ext) => file.endsWith(ext)) && file.startsWith('snippets/'));
-    const promises = snippetFilenames.map(async (snippetFilename) => {
+const getSnippetBase = async (baseDir) => {
+    const importedFiles = getImportedFilesFromCache();
+    const allSnippetFilenames = getFileListSync(baseDir).filter((file) => {
+        if (!isSnippetExtension(getFileExtension(file))) {
+            return false;
+        }
+        if (file.startsWith('snippets/') || file.startsWith('_snippets/')) {
+            return true;
+        }
+        if (getFileExtension(file) === 'jsx') {
+            return true;
+        }
+        return isImportedAsSnippet(file, importedFiles);
+    });
+    const promises = allSnippetFilenames.map(async (snippetFilename) => {
         try {
-            const tree = await preparseMdxTree((await readFile(join(BASE_DIR, snippetFilename))).toString(), BASE_DIR, join(BASE_DIR, snippetFilename));
+            const tree = await preparseMdxTree((await readFile(join(baseDir, snippetFilename))).toString(), baseDir, join(baseDir, snippetFilename));
             return {
                 filename: optionallyAddLeadingSlash(snippetFilename),
                 tree,

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

@@ -0,0 +1,9 @@
+export interface ImportCacheChangeResult {
+    newlyImported: string[];
+    noLongerImported: string[];
+}
+export declare const initializeImportCache: (baseDir: string, prebuildImportMap?: Map<string, Set<string>>) => Promise<void>;
+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 syncImportedFileLocations: (changes: ImportCacheChangeResult) => Promise<void>;

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

@@ -0,0 +1,168 @@
+import { optionallyAddLeadingSlash, optionallyRemoveLeadingSlash, isSnippetExtension, extractImportSources, resolveImportPath, findAndRemoveImports, hasImports, stringifyTree, getFileCategory, } from '@mintlify/common';
+import { getFileExtension } from '@mintlify/prebuild';
+import { getFileListSync, createPage, preparseMdxTree } from '@mintlify/prebuild';
+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 { normalizePathForComparison } from './utils.js';
+const fileImportsMap = new Map();
+const importerCounts = new Map();
+const addImporter = (path) => {
+    const count = importerCounts.get(path) ?? 0;
+    importerCounts.set(path, count + 1);
+    return count === 0;
+};
+const removeImporter = (path) => {
+    const count = importerCounts.get(path);
+    if (count == null)
+        return false;
+    if (count <= 1) {
+        importerCounts.delete(path);
+        return true;
+    }
+    importerCounts.set(path, count - 1);
+    return false;
+};
+const extractFileImports = async (baseDir, filename) => {
+    const filePath = join(baseDir, filename);
+    try {
+        const content = (await fse.readFile(filePath)).toString();
+        const tree = await preparseMdxTree(content, baseDir, filePath);
+        const importSources = extractImportSources(tree);
+        const imports = new Set();
+        for (const source of importSources) {
+            const resolvedPath = resolveImportPath(source, optionallyAddLeadingSlash(filename));
+            if (resolvedPath != null) {
+                imports.add(normalizePathForComparison(resolvedPath));
+            }
+        }
+        return imports;
+    }
+    catch (err) {
+        console.log('Error extracting imports from file');
+        console.log(filename);
+        console.log(err);
+        return new Set();
+    }
+};
+export const initializeImportCache = async (baseDir, prebuildImportMap) => {
+    fileImportsMap.clear();
+    importerCounts.clear();
+    if (prebuildImportMap) {
+        for (const [filePath, imports] of prebuildImportMap) {
+            const normalizedPath = normalizePathForComparison(filePath);
+            fileImportsMap.set(normalizedPath, imports);
+            for (const imp of imports) {
+                addImporter(imp);
+            }
+        }
+        return;
+    }
+    const allFiles = getFileListSync(baseDir).filter((file) => isSnippetExtension(getFileExtension(file)));
+    await Promise.all(allFiles.map(async (filename) => {
+        const normalizedPath = normalizePathForComparison(filename);
+        const imports = await extractFileImports(baseDir, filename);
+        fileImportsMap.set(normalizedPath, imports);
+        for (const imp of imports) {
+            addImporter(imp);
+        }
+    }));
+};
+export const updateImportCacheForFile = async (baseDir, filename) => {
+    if (!isSnippetExtension(getFileExtension(filename))) {
+        return { newlyImported: [], noLongerImported: [] };
+    }
+    const normalizedPath = normalizePathForComparison(filename);
+    const newImports = await extractFileImports(baseDir, filename);
+    const oldImports = fileImportsMap.get(normalizedPath) ?? new Set();
+    const newlyImported = [];
+    const noLongerImported = [];
+    for (const imp of newImports) {
+        if (!oldImports.has(imp) && addImporter(imp)) {
+            newlyImported.push(imp);
+        }
+    }
+    for (const imp of oldImports) {
+        if (!newImports.has(imp) && removeImporter(imp)) {
+            noLongerImported.push(imp);
+        }
+    }
+    fileImportsMap.set(normalizedPath, newImports);
+    return { newlyImported, noLongerImported };
+};
+export const removeFromImportCache = (filename) => {
+    const normalizedPath = normalizePathForComparison(filename);
+    const oldImports = fileImportsMap.get(normalizedPath);
+    if (oldImports == null) {
+        return { newlyImported: [], noLongerImported: [] };
+    }
+    const noLongerImported = [];
+    for (const imp of oldImports) {
+        if (removeImporter(imp)) {
+            noLongerImported.push(imp);
+        }
+    }
+    fileImportsMap.delete(normalizedPath);
+    return { newlyImported: [], noLongerImported };
+};
+export const getImportedFilesFromCache = () => {
+    return new Set(Array.from(importerCounts.keys(), (key) => key.toLowerCase()));
+};
+const isSnippetByFolder = (path) => {
+    const normalized = normalizePathForComparison(path).toLowerCase();
+    return normalized.startsWith('/snippets/') || normalized.startsWith('/_snippets/');
+};
+const resolveFileImports = async (sourcePath, relativePath) => {
+    let contentStr = (await fse.readFile(sourcePath)).toString();
+    const tree = await preparseMdxTree(contentStr, CMD_EXEC_PATH, sourcePath);
+    const importsResponse = await findAndRemoveImports(tree);
+    if (hasImports(importsResponse)) {
+        contentStr = stringifyTree(await resolveAllImports({ ...importsResponse, filename: relativePath }));
+    }
+    return contentStr;
+};
+export const syncImportedFileLocations = async (changes) => {
+    for (const importedPath of changes.newlyImported) {
+        if (isSnippetByFolder(importedPath))
+            continue;
+        if (!isSnippetExtension(getFileExtension(importedPath)))
+            continue;
+        const relativePath = optionallyRemoveLeadingSlash(importedPath);
+        const sourcePath = join(CMD_EXEC_PATH, relativePath);
+        const targetPath = join(NEXT_PUBLIC_PATH, relativePath);
+        try {
+            const contentStr = await resolveFileImports(sourcePath, relativePath);
+            await fse.outputFile(targetPath, contentStr, { flag: 'w' });
+            await fse.remove(join(NEXT_PROPS_PATH, relativePath));
+        }
+        catch (err) {
+            console.log('Error processing newly imported snippet');
+            console.log(relativePath);
+            console.log(err);
+        }
+    }
+    for (const importedPath of changes.noLongerImported) {
+        if (isSnippetByFolder(importedPath))
+            continue;
+        if (!isSnippetExtension(getFileExtension(importedPath)))
+            continue;
+        const relativePath = optionallyRemoveLeadingSlash(importedPath);
+        const sourcePath = join(CMD_EXEC_PATH, relativePath);
+        await fse.remove(join(NEXT_PUBLIC_PATH, relativePath));
+        if (getFileCategory(relativePath) !== 'page')
+            continue;
+        if (await fse.pathExists(sourcePath)) {
+            try {
+                const contentStr = await resolveFileImports(sourcePath, relativePath);
+                const { pageContent } = await createPage(relativePath, contentStr, CMD_EXEC_PATH, [], [], true);
+                await fse.outputFile(join(NEXT_PROPS_PATH, relativePath), pageContent, { flag: 'w' });
+            }
+            catch (err) {
+                console.log('Error regenerating page after import status change');
+                console.log(relativePath);
+                console.log(err);
+            }
+        }
+    }
+};

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

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

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

@@ -14,6 +14,7 @@ import { AddedLog, DeletedLog, EditedLog, WarningLog, InfoLog, ErrorLog } from '
 import { generateDependentSnippets } from './generateDependentSnippets.js';
 import { generatePagesWithImports } from './generatePagesWithImports.js';
 import { getDocsState } from './getDocsState.js';
+import { initializeImportCache, updateImportCacheForFile, removeFromImportCache, getImportedFilesFromCache, syncImportedFileLocations, } from './importCache.js';
 import { resolveAllImports } from './resolveAllImports.js';
 import { updateCustomLanguages, updateGeneratedNav, updateOpenApiFiles, upsertOpenApiFile, } from './update.js';
 import { getMintIgnoreGlobs, isFileSizeValid, isJsonValid, shouldRegenerateNavForPage, } from './utils.js';
@@ -72,7 +73,13 @@ const onUnlinkEvent = async (filename, options) => {
         return;
     }
     try {
-        const potentialCategory = getFileCategory(filename);
+        const importedFiles = getImportedFilesFromCache();
+        const potentialCategory = getFileCategory(filename, { importedFiles });
+        if (potentialCategory == null) {
+            const importChanges = removeFromImportCache(filename);
+            await syncImportedFileLocations(importChanges);
+            return;
+        }
         const targetPath = getTargetPath(potentialCategory, filename);
         if (potentialCategory === 'page' ||
             potentialCategory === 'snippet' ||
@@ -99,13 +106,18 @@ const onUnlinkEvent = async (filename, options) => {
                 try {
                     await fse.emptyDir(NEXT_PUBLIC_PATH);
                     await fse.emptyDir(NEXT_PROPS_PATH);
-                    await prebuild(CMD_EXEC_PATH, options);
+                    const prebuildResult = await prebuild(CMD_EXEC_PATH, options);
+                    if (prebuildResult) {
+                        await initializeImportCache(CMD_EXEC_PATH, prebuildResult.fileImportsMap);
+                    }
                 }
                 catch (err) {
                     console.error('Error rebuilding after .mintignore deletion:', err);
                 }
                 break;
         }
+        const importChanges = removeFromImportCache(filename);
+        await syncImportedFileLocations(importChanges);
         addChangeLog(_jsx(DeletedLog, { filename: filename }));
     }
     catch (error) {
@@ -159,13 +171,20 @@ const validateConfigFiles = async () => {
  */
 const onUpdateEvent = async (filename, callback, options = {}) => {
     const filePath = pathUtil.join(CMD_EXEC_PATH, filename);
-    const potentialCategory = getFileCategory(filename);
-    const targetPath = getTargetPath(potentialCategory, filename);
+    const importChanges = await updateImportCacheForFile(CMD_EXEC_PATH, filename);
+    await syncImportedFileLocations(importChanges);
+    const importedFiles = getImportedFilesFromCache();
+    const potentialCategory = getFileCategory(filename, { importedFiles });
+    if (potentialCategory == null) {
+        callback();
+        return null;
+    }
     let regenerateNav = false;
     let category = potentialCategory === 'potentialYamlOpenApiSpec' ||
         potentialCategory === 'potentialJsonOpenApiSpec'
         ? 'staticFile'
         : potentialCategory;
+    const targetPath = getTargetPath(potentialCategory, filename);
     switch (potentialCategory) {
         case 'page': {
             let contentStr = (await readFile(filePath)).toString();
@@ -227,7 +246,10 @@ const onUpdateEvent = async (filename, callback, options = {}) => {
                 addChangeLog(_jsx(InfoLog, { message: ".mintignore has been updated. Rebuilding..." }));
                 await fse.emptyDir(NEXT_PUBLIC_PATH);
                 await fse.emptyDir(NEXT_PROPS_PATH);
-                await prebuild(CMD_EXEC_PATH, options);
+                const prebuildResult = await prebuild(CMD_EXEC_PATH, options);
+                if (prebuildResult) {
+                    await initializeImportCache(CMD_EXEC_PATH, prebuildResult.fileImportsMap);
+                }
             }
             catch (err) {
                 console.error(err.message);
@@ -291,4 +313,5 @@ const onUpdateEvent = async (filename, callback, options = {}) => {
     callback();
     return category;
 };
+export { initializeImportCache };
 export default listener;

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

@@ -8,3 +8,4 @@ export declare const isJsonValid: (filePath: string) => {
     error?: string;
 };
 export declare const shouldRegenerateNavForPage: (filename: string, contentStr: string, frontmatterHashes: Map<string, string>) => Promise<boolean>;
+export declare function normalizePathForComparison(filePath: string): string;

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

@@ -1,4 +1,4 @@
-import { parseFrontmatter, processMintIgnoreString } from '@mintlify/common';
+import { parseFrontmatter, processMintIgnoreString, optionallyAddLeadingSlash, } from '@mintlify/common';
 import crypto from 'crypto';
 import { promises as _promises, readFileSync, existsSync } from 'fs';
 import fse from 'fs-extra';
@@ -65,3 +65,6 @@ export const shouldRegenerateNavForPage = async (filename, contentStr, frontmatt
         return true;
     }
 };
+export function normalizePathForComparison(filePath) {
+    return optionallyAddLeadingSlash(filePath).toLowerCase();
+}

package/dist/local-preview/run.d.ts

@@ -1,4 +1,5 @@
 import { ArgumentsCamelCase } from 'yargs';
 export declare const run: (argv: ArgumentsCamelCase & {
     needsUpdate: boolean;
+    fileImportsMap?: Map<string, Set<string>>;
 }) => Promise<void>;

package/dist/local-preview/run.js

@@ -3,11 +3,11 @@ import open from 'better-opn';
 import express from 'express';
 import { createServer } from 'http';
 import { Server as SocketServer } from 'socket.io';
-import { NEXT_PUBLIC_PATH } from '../constants.js';
+import { CMD_EXEC_PATH, NEXT_PUBLIC_PATH } from '../constants.js';
 import { addLog, removeLastLog } from '../logging-state.js';
 import { LaunchLog, UpdateLog } from '../logs.js';
 import { maybeFixMissingWindowsEnvVar } from '../util.js';
-import listener from './listener/index.js';
+import listener, { initializeImportCache } from './listener/index.js';
 import { getLocalNetworkIp } from './network.js';
 import { setupNext } from './setupNext.js';
 export const run = async (argv) => {
@@ -48,5 +48,6 @@ export const run = async (argv) => {
         process.on('SIGINT', onExit);
         process.on('SIGTERM', onExit);
     });
+    await initializeImportCache(CMD_EXEC_PATH, argv.fileImportsMap);
     listener(onChange);
 };