@mintlify/previewing 4.0.948 → 4.0.950

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

@@ -1,13 +1,14 @@
-import { optionallyAddLeadingSlash, isSnippetExtension, isImportedAsSnippet, } from '@mintlify/common';
+import { optionallyAddLeadingSlash, replaceVariables, 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';
-import { handleParseError } from './utils.js';
+import { handleParseError, getCurrentVariables } from './utils.js';
 const { readFile } = _promises;
 const getSnippetBase = async (baseDir) => {
     const importedFiles = getImportedFilesFromCache();
+    const variables = await getCurrentVariables();
     const allSnippetFilenames = getFileListSync(baseDir).filter((file) => {
         if (!isSnippetExtension(getFileExtension(file))) {
             return false;
@@ -22,7 +23,7 @@ const getSnippetBase = async (baseDir) => {
     });
     const promises = allSnippetFilenames.map(async (snippetFilename) => {
         try {
-            const tree = await preparseMdxTree((await readFile(join(baseDir, snippetFilename))).toString(), baseDir, join(baseDir, snippetFilename), handleParseError);
+            const tree = await preparseMdxTree(replaceVariables((await readFile(join(baseDir, snippetFilename))).toString(), variables), baseDir, join(baseDir, snippetFilename), handleParseError);
             return {
                 filename: optionallyAddLeadingSlash(snippetFilename),
                 tree,

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

@@ -1,5 +1,5 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { findAndRemoveImports, hasImports, getFileCategory, validate, stringifyTree, isMintIgnored, } from '@mintlify/common';
+import { findAndRemoveImports, hasImports, getFileCategory, validate, stringifyTree, isMintIgnored, replaceVariables, } from '@mintlify/common';
 import { createPage, MintConfigUpdater, DocsConfigUpdater, preparseMdxTree, prebuild, } from '@mintlify/prebuild';
 import Chalk from 'chalk';
 import chokidar from 'chokidar';
@@ -15,9 +15,10 @@ 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 { regenerateAllSnippets } from './regenerateAllSnippets.js';
 import { resolveAllImports } from './resolveAllImports.js';
 import { updateCustomLanguages, updateGeneratedNav, updateOpenApiFiles, upsertOpenApiFile, } from './update.js';
-import { getMintIgnoreGlobs, handleParseError, isFileSizeValid, isJsonValid, shouldRegenerateNavForPage, suppressParseError, } from './utils.js';
+import { getCurrentVariables, getMintIgnoreGlobs, handleParseError, isFileSizeValid, isJsonValid, shouldRegenerateNavForPage, suppressParseError, } from './utils.js';
 const { readFile } = _promises;
 const frontmatterHashes = new Map();
 const listener = (callback, options = {}) => {
@@ -204,7 +205,8 @@ const onUpdateEvent = async (filename, callback, options = {}) => {
             break;
         }
         case 'snippet-v2': {
-            let contentStr = (await readFile(filePath)).toString();
+            const variables = await getCurrentVariables();
+            let contentStr = replaceVariables((await readFile(filePath)).toString(), variables);
             const tree = await preparseMdxTree(contentStr, CMD_EXEC_PATH, filePath, handleParseError);
             const importsResponse = await findAndRemoveImports(tree);
             if (hasImports(importsResponse)) {
@@ -243,6 +245,10 @@ const onUpdateEvent = async (filename, callback, options = {}) => {
                     console.error(err);
                 }
             }
+            if (potentialCategory === 'docsConfig') {
+                const updatedSnippets = await regenerateAllSnippets();
+                await generatePagesWithImports(new Set(updatedSnippets));
+            }
             break;
         }
         case 'mintIgnore': {

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

@@ -0,0 +1 @@
+export declare const regenerateAllSnippets: () => Promise<string[]>;

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

@@ -0,0 +1,81 @@
+import { findAndRemoveImports, replaceVariables, stringifyTree, topologicalSort, hasImports, optionallyAddLeadingSlash, optionallyRemoveLeadingSlash, resolveImportPath, resolveAllImports as baseResolveAllImports, isSnippetExtension, isImportedAsSnippet, } from '@mintlify/common';
+import { preparseMdxTree, getFileListSync, getFileExtension } from '@mintlify/prebuild';
+import { outputFile } from 'fs-extra';
+import { readFile } from 'fs/promises';
+import { join } from 'path';
+import { CMD_EXEC_PATH, NEXT_PUBLIC_PATH } from '../../constants.js';
+import { getImportedFilesFromCache } from './importCache.js';
+import { getCurrentVariables, handleParseError } from './utils.js';
+const getV2SnippetFilenames = () => {
+    const importedFiles = getImportedFilesFromCache();
+    return getFileListSync(CMD_EXEC_PATH).filter((file) => {
+        if (!isSnippetExtension(getFileExtension(file)))
+            return false;
+        if (file.startsWith('snippets/'))
+            return true;
+        if (getFileExtension(file) === 'jsx')
+            return true;
+        return isImportedAsSnippet(file, importedFiles);
+    });
+};
+export const regenerateAllSnippets = async () => {
+    const variables = await getCurrentVariables();
+    const vars = variables ?? {};
+    const snippetFilenames = getV2SnippetFilenames();
+    const processedSnippets = [];
+    const resolvedTrees = [];
+    const v2Parsed = [];
+    for (const filename of snippetFilenames) {
+        try {
+            const targetFilename = optionallyRemoveLeadingSlash(filename);
+            const rawContent = await readFile(join(CMD_EXEC_PATH, targetFilename), 'utf8');
+            const content = replaceVariables(rawContent, vars);
+            const tree = await preparseMdxTree(content, CMD_EXEC_PATH, join(CMD_EXEC_PATH, targetFilename), handleParseError);
+            const normalizedFilename = optionallyAddLeadingSlash(filename);
+            const processed = await findAndRemoveImports(tree);
+            v2Parsed.push({
+                filename: normalizedFilename,
+                content,
+                importData: { filename: normalizedFilename, ...processed },
+            });
+        }
+        catch (err) {
+            console.warn(`Failed to parse snippet ${filename}:`, err);
+        }
+    }
+    const graph = {};
+    for (const { importData } of v2Parsed) {
+        graph[importData.filename] = Object.keys(importData.importMap)
+            .map((dep) => resolveImportPath(dep, importData.filename))
+            .filter((resolvedDep) => resolvedDep != null);
+    }
+    const sortedFilenames = topologicalSort(graph).reverse();
+    const v2Map = new Map(v2Parsed.map((item) => [item.filename, item]));
+    const orderedV2 = sortedFilenames
+        .map((filename) => v2Map.get(filename))
+        .filter((item) => item != null);
+    for (const { filename, content, importData } of orderedV2) {
+        try {
+            const targetFilename = optionallyRemoveLeadingSlash(filename);
+            if (!hasImports(importData)) {
+                await outputFile(join(NEXT_PUBLIC_PATH, targetFilename), content, { flag: 'w' });
+                resolvedTrees.push({ filename, tree: importData.tree });
+            }
+            else {
+                const resolvedTree = await baseResolveAllImports({
+                    snippets: resolvedTrees,
+                    fileWithImports: importData,
+                });
+                await outputFile(join(NEXT_PUBLIC_PATH, targetFilename), stringifyTree(resolvedTree), {
+                    flag: 'w',
+                });
+                resolvedTrees.push({ filename, tree: resolvedTree });
+            }
+            processedSnippets.push(targetFilename);
+        }
+        catch (err) {
+            console.warn(`Failed to regenerate snippet ${filename}:`, err);
+        }
+    }
+    return processedSnippets;
+};

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

@@ -11,3 +11,4 @@ export declare const shouldRegenerateNavForPage: (filename: string, contentStr:
 export declare function normalizePathForComparison(filePath: string): string;
 export declare const handleParseError: (message: string) => void;
 export declare const suppressParseError: () => void;
+export declare const getCurrentVariables: () => Promise<Record<string, string> | undefined>;

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

@@ -5,7 +5,7 @@ import fse from 'fs-extra';
 import pathUtil from 'path';
 import { CMD_EXEC_PATH } from '../../constants.js';
 import { addRawErrorLog } from '../../logging-state.js';
-const { stat } = _promises;
+const { stat, readFile } = _promises;
 export const getFileExtension = (filename) => {
     return filename.substring(filename.lastIndexOf('.') + 1, filename.length) || filename;
 };
@@ -84,3 +84,13 @@ export const handleParseError = (message) => {
 export const suppressParseError = () => {
     // no-op to suppress duplicate error logging
 };
+export const getCurrentVariables = async () => {
+    try {
+        const content = await readFile(pathUtil.join(CMD_EXEC_PATH, 'docs.json'), 'utf8');
+        const parsed = JSON.parse(content);
+        return parsed.variables;
+    }
+    catch {
+        return undefined;
+    }
+};