@mintlify/previewing 4.0.513 → 4.0.515

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

@@ -0,0 +1,2 @@
+import type { FindAndRemoveImportsResponse } from '@mintlify/common';
+export declare const generateDependentSnippets: (changedFilename: string, newImportData: FindAndRemoveImportsResponse) => Promise<string[]>;

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

@@ -0,0 +1,86 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { findAndRemoveImports, stringifyTree, topologicalSort, hasImports, optionallyAddLeadingSlash, optionallyRemoveLeadingSlash, } from '@mintlify/common';
+import { outputFile } 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 = (initialFileWithSlash, allSnippets, processedDataCache) => __awaiter(void 0, void 0, void 0, function* () {
+    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 = yield findAndRemoveImports(clonedTree);
+                processedDataCache.set(potentialDependentFile, processedData);
+            }
+            if (processedData.importMap[currentSourceFile]) {
+                if (!affected.has(potentialDependentFile)) {
+                    affected.add(potentialDependentFile);
+                    queue.push(potentialDependentFile);
+                }
+            }
+        }
+    }
+    return affected;
+});
+export const generateDependentSnippets = (changedFilename, newImportData) => __awaiter(void 0, void 0, void 0, function* () {
+    const processedDataCache = new Map();
+    const allOriginalSnippets = yield getOriginalSnippets();
+    const updatedSnippetFileKey = optionallyAddLeadingSlash(changedFilename);
+    const affectedSnippets = yield findAllDependents(updatedSnippetFileKey, allOriginalSnippets, processedDataCache);
+    const snippetPromises = Array.from(affectedSnippets).map((filename) => __awaiter(void 0, void 0, void 0, function* () {
+        const cachedData = processedDataCache.get(filename);
+        if (cachedData)
+            return Object.assign({ filename }, cachedData);
+        const originalSnippet = allOriginalSnippets.find((s) => optionallyAddLeadingSlash(s.filename) === filename);
+        if (!originalSnippet)
+            return null;
+        const processed = yield findAndRemoveImports(structuredClone(originalSnippet.tree));
+        processedDataCache.set(filename, processed);
+        return Object.assign({ filename }, processed);
+    }));
+    const snippets = (yield Promise.all(snippetPromises)).filter((item) => item != null);
+    const idx = snippets.findIndex((item) => item.filename === updatedSnippetFileKey);
+    if (idx !== -1) {
+        snippets[idx] = Object.assign(Object.assign({}, newImportData), { filename: updatedSnippetFileKey });
+    }
+    else {
+        snippets.push(Object.assign(Object.assign({}, newImportData), { filename: updatedSnippetFileKey }));
+    }
+    const graph = {};
+    snippets.forEach((item) => {
+        graph[item.filename] = Object.keys(item.importMap).map((dep) => optionallyAddLeadingSlash(dep));
+    });
+    const sortedSnippets = topologicalSort(graph).reverse();
+    const snippetsMap = new Map(snippets.map((item) => [item.filename, item]));
+    const orderedSnippets = sortedSnippets
+        .map((filename) => snippetsMap.get(filename))
+        .filter((item) => item != null);
+    const processedSnippets = [];
+    for (const currentSnippet of orderedSnippets) {
+        let processedTree = currentSnippet.tree;
+        if (currentSnippet.filename !== updatedSnippetFileKey && hasImports(currentSnippet)) {
+            processedTree = yield resolveAllImports(currentSnippet);
+        }
+        const targetFilename = optionallyRemoveLeadingSlash(currentSnippet.filename);
+        const targetPath = join(NEXT_PUBLIC_PATH, targetFilename);
+        yield outputFile(targetPath, stringifyTree(processedTree), { flag: 'w' });
+        processedSnippets.push(targetFilename);
+    }
+    return processedSnippets;
+});

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

@@ -1 +1 @@
-export declare const generatePagesWithImports: () => Promise<void>;
+export declare const generatePagesWithImports: (updatedSnippets: Set<string>) => Promise<void>;

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

@@ -7,16 +7,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { hasImports, findAndRemoveImports, resolveAllImports, stringifyTree, } from '@mintlify/common';
+import { findAndRemoveImports, optionallyRemoveLeadingSlash, resolveAllImports, stringifyTree, } from '@mintlify/common';
 import { preparseMdxTree, getFileListSync } 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 { getSnippets } from './getSnippets.js';
+import { getProcessedSnippets } from './getSnippets.js';
 const { readFile } = _promises;
-export const generatePagesWithImports = () => __awaiter(void 0, void 0, void 0, function* () {
-    const snippets = yield getSnippets();
+export const generatePagesWithImports = (updatedSnippets) => __awaiter(void 0, void 0, void 0, function* () {
+    const snippets = yield getProcessedSnippets();
     const pageFilenames = getFileListSync(CMD_EXEC_PATH).filter((file) => file.endsWith('.mdx') && !file.startsWith('_snippets/') && !file.startsWith('snippets/'));
     yield Promise.all(pageFilenames.map((pageFilename) => __awaiter(void 0, void 0, void 0, function* () {
         const sourcePath = join(CMD_EXEC_PATH, pageFilename);
@@ -24,7 +24,7 @@ export const generatePagesWithImports = () => __awaiter(void 0, void 0, void 0,
         try {
             const tree = yield preparseMdxTree(contentStr, CMD_EXEC_PATH, sourcePath);
             const importsResponse = yield findAndRemoveImports(tree);
-            if (hasImports(importsResponse)) {
+            if (Object.keys(importsResponse.importMap).some((importPath) => updatedSnippets.has(optionallyRemoveLeadingSlash(importPath)))) {
                 const content = yield resolveAllImports({
                     snippets,
                     fileWithImports: Object.assign(Object.assign({}, importsResponse), { filename: pageFilename }),

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

@@ -1,2 +1,3 @@
-import type { FileType } from '@mintlify/common';
-export declare const getSnippets: () => Promise<FileType[]>;
+import { type FileType } from '@mintlify/common';
+export declare const getProcessedSnippets: () => Promise<FileType[]>;
+export declare const getOriginalSnippets: () => Promise<FileType[]>;

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

@@ -7,18 +7,19 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+import { optionallyAddLeadingSlash } from '@mintlify/common';
 import { getFileListSync, preparseMdxTree } from '@mintlify/prebuild';
 import { promises as _promises } from 'fs';
 import { join } from 'path';
-import { NEXT_PUBLIC_PATH } from '../../constants.js';
+import { CMD_EXEC_PATH, NEXT_PUBLIC_PATH } from '../../constants.js';
 const { readFile } = _promises;
-export const getSnippets = () => __awaiter(void 0, void 0, void 0, function* () {
-    const snippetFilenames = getFileListSync(NEXT_PUBLIC_PATH).filter((file) => file.endsWith('.mdx') && file.startsWith('snippets/'));
+const getSnippetBase = (BASE_DIR) => __awaiter(void 0, void 0, void 0, function* () {
+    const snippetFilenames = getFileListSync(BASE_DIR).filter((file) => file.endsWith('.mdx') && file.startsWith('snippets/'));
     const promises = snippetFilenames.map((snippetFilename) => __awaiter(void 0, void 0, void 0, function* () {
         try {
-            const tree = yield preparseMdxTree((yield readFile(join(NEXT_PUBLIC_PATH, snippetFilename))).toString(), NEXT_PUBLIC_PATH, join(NEXT_PUBLIC_PATH, snippetFilename));
+            const tree = yield preparseMdxTree((yield readFile(join(BASE_DIR, snippetFilename))).toString(), BASE_DIR, join(BASE_DIR, snippetFilename));
             return {
-                filename: '/' + snippetFilename,
+                filename: optionallyAddLeadingSlash(snippetFilename),
                 tree,
             };
         }
@@ -29,3 +30,5 @@ export const getSnippets = () => __awaiter(void 0, void 0, void 0, function* ()
     }));
     return (yield Promise.all(promises)).filter(Boolean);
 });
+export const getProcessedSnippets = () => getSnippetBase(NEXT_PUBLIC_PATH);
+export const getOriginalSnippets = () => getSnippetBase(CMD_EXEC_PATH);

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

@@ -17,6 +17,7 @@ import fs from 'fs/promises';
 import yaml from 'js-yaml';
 import pathUtil from 'path';
 import { CMD_EXEC_PATH, NEXT_PROPS_PATH, NEXT_PUBLIC_PATH, CLIENT_PATH } from '../../constants.js';
+import { generateDependentSnippets } from './generateDependentSnippets.js';
 import { generatePagesWithImports } from './generatePagesWithImports.js';
 import { getDocsState } from './getDocsState.js';
 import { resolveAllImports } from './resolveAllImports.js';
@@ -228,7 +229,8 @@ const onUpdateEvent = (filename, callback) => __awaiter(void 0, void 0, void 0,
             yield fse.outputFile(targetPath, contentStr, {
                 flag: 'w',
             });
-            yield generatePagesWithImports();
+            const updatedSnippets = yield generateDependentSnippets(filename, importsResponse);
+            yield generatePagesWithImports(new Set(updatedSnippets));
             break;
         }
         case 'mintConfig':

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

@@ -8,9 +8,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { resolveAllImports as baseResolveAllImports } from '@mintlify/common';
-import { getSnippets } from './getSnippets.js';
+import { getProcessedSnippets } from './getSnippets.js';
 export const resolveAllImports = (fileWithImports) => __awaiter(void 0, void 0, void 0, function* () {
-    const snippets = yield getSnippets();
+    const snippets = yield getProcessedSnippets();
     return yield baseResolveAllImports({
         snippets,
         fileWithImports,