@mintlify/previewing 4.0.527 → 4.0.528

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

@@ -1,33 +1,27 @@
-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 { categorizeFilePaths, createPage, generateDecoratedDocsNavigationFromPages, } from '@mintlify/prebuild';
 import { promises as _promises } from 'fs';
 import { join } from 'path';
 import { CMD_EXEC_PATH } from '../../constants.js';
 const { readFile } = _promises;
-const createFilenamePageMetadataMap = (_a) => __awaiter(void 0, [_a], void 0, function* ({ contentDirectoryPath, contentFilenames, openApiFiles, asyncApiFiles, pagesAcc = {}, }) {
+const createFilenamePageMetadataMap = async ({ contentDirectoryPath, contentFilenames, openApiFiles, asyncApiFiles, pagesAcc = {}, }) => {
     const contentPromises = [];
     contentFilenames.forEach((filename) => {
-        contentPromises.push((() => __awaiter(void 0, void 0, void 0, function* () {
+        contentPromises.push((async () => {
             const sourcePath = join(contentDirectoryPath, filename);
-            const contentStr = (yield readFile(sourcePath)).toString();
-            const { slug, pageMetadata } = yield createPage(filename, contentStr, contentDirectoryPath, openApiFiles, asyncApiFiles, true);
-            pagesAcc = Object.assign(Object.assign({}, pagesAcc), { [slug]: pageMetadata });
-        }))());
+            const contentStr = (await readFile(sourcePath)).toString();
+            const { slug, pageMetadata } = await createPage(filename, contentStr, contentDirectoryPath, openApiFiles, asyncApiFiles, true);
+            pagesAcc = {
+                ...pagesAcc,
+                [slug]: pageMetadata,
+            };
+        })());
     });
-    yield Promise.all(contentPromises);
+    await Promise.all(contentPromises);
     return pagesAcc;
-});
-export const generateNav = (pagesAcc, docsConfig) => __awaiter(void 0, void 0, void 0, function* () {
-    const { contentFilenames, openApiFiles, asyncApiFiles } = yield categorizeFilePaths(CMD_EXEC_PATH);
-    const filenamePageMetadataMap = yield createFilenamePageMetadataMap({
+};
+export const generateNav = async (pagesAcc, docsConfig) => {
+    const { contentFilenames, openApiFiles, asyncApiFiles } = await categorizeFilePaths(CMD_EXEC_PATH);
+    const filenamePageMetadataMap = await createFilenamePageMetadataMap({
         contentDirectoryPath: CMD_EXEC_PATH,
         contentFilenames,
         openApiFiles,
@@ -36,4 +30,4 @@ export const generateNav = (pagesAcc, docsConfig) => __awaiter(void 0, void 0, v
     });
     const generatedDocsNav = generateDecoratedDocsNavigationFromPages(filenamePageMetadataMap, docsConfig.navigation);
     return generatedDocsNav;
-});
+};

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

@@ -1,19 +1,10 @@
-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 findAllDependents = async (initialFileWithSlash, allSnippets, processedDataCache) => {
     const affected = new Set([initialFileWithSlash]);
     const queue = [initialFileWithSlash];
     while (queue.length > 0) {
@@ -25,7 +16,7 @@ const findAllDependents = (initialFileWithSlash, allSnippets, processedDataCache
             let processedData = processedDataCache.get(potentialDependentFile);
             if (processedData == null) {
                 const clonedTree = structuredClone(snippet.tree);
-                processedData = yield findAndRemoveImports(clonedTree);
+                processedData = await findAndRemoveImports(clonedTree);
                 processedDataCache.set(potentialDependentFile, processedData);
             }
             if (processedData.importMap[currentSourceFile]) {
@@ -37,30 +28,36 @@ const findAllDependents = (initialFileWithSlash, allSnippets, processedDataCache
         }
     }
     return affected;
-});
-export const generateDependentSnippets = (changedFilename, newImportData) => __awaiter(void 0, void 0, void 0, function* () {
+};
+export const generateDependentSnippets = async (changedFilename, newImportData) => {
     const processedDataCache = new Map();
-    const allOriginalSnippets = yield getOriginalSnippets();
+    const allOriginalSnippets = await 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 affectedSnippets = await findAllDependents(updatedSnippetFileKey, allOriginalSnippets, processedDataCache);
+    const snippetPromises = Array.from(affectedSnippets).map(async (filename) => {
         const cachedData = processedDataCache.get(filename);
         if (cachedData)
-            return Object.assign({ filename }, cachedData);
+            return { filename, ...cachedData };
         const originalSnippet = allOriginalSnippets.find((s) => optionallyAddLeadingSlash(s.filename) === filename);
         if (!originalSnippet)
             return null;
-        const processed = yield findAndRemoveImports(structuredClone(originalSnippet.tree));
+        const processed = await findAndRemoveImports(structuredClone(originalSnippet.tree));
         processedDataCache.set(filename, processed);
-        return Object.assign({ filename }, processed);
-    }));
-    const snippets = (yield Promise.all(snippetPromises)).filter((item) => item != null);
+        return { filename, ...processed };
+    });
+    const snippets = (await 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 });
+        snippets[idx] = {
+            ...newImportData,
+            filename: updatedSnippetFileKey,
+        };
     }
     else {
-        snippets.push(Object.assign(Object.assign({}, newImportData), { filename: updatedSnippetFileKey }));
+        snippets.push({
+            ...newImportData,
+            filename: updatedSnippetFileKey,
+        });
     }
     const graph = {};
     snippets.forEach((item) => {
@@ -75,12 +72,12 @@ export const generateDependentSnippets = (changedFilename, newImportData) => __a
     for (const currentSnippet of orderedSnippets) {
         let processedTree = currentSnippet.tree;
         if (currentSnippet.filename !== updatedSnippetFileKey && hasImports(currentSnippet)) {
-            processedTree = yield resolveAllImports(currentSnippet);
+            processedTree = await resolveAllImports(currentSnippet);
         }
         const targetFilename = optionallyRemoveLeadingSlash(currentSnippet.filename);
         const targetPath = join(NEXT_PUBLIC_PATH, targetFilename);
-        yield outputFile(targetPath, stringifyTree(processedTree), { flag: 'w' });
+        await outputFile(targetPath, stringifyTree(processedTree), { flag: 'w' });
         processedSnippets.push(targetFilename);
     }
     return processedSnippets;
-});
+};

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

@@ -1,12 +1,3 @@
-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, optionallyRemoveLeadingSlash, resolveAllImports, stringifyTree, } from '@mintlify/common';
 import { preparseMdxTree, getFileListSync } from '@mintlify/prebuild';
 import { promises as _promises } from 'fs';
@@ -15,22 +6,22 @@ import { join } from 'path';
 import { CMD_EXEC_PATH, NEXT_PROPS_PATH } from '../../constants.js';
 import { getProcessedSnippets } from './getSnippets.js';
 const { readFile } = _promises;
-export const generatePagesWithImports = (updatedSnippets) => __awaiter(void 0, void 0, void 0, function* () {
-    const snippets = yield getProcessedSnippets();
+export const generatePagesWithImports = async (updatedSnippets) => {
+    const snippets = await 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* () {
+    await Promise.all(pageFilenames.map(async (pageFilename) => {
         const sourcePath = join(CMD_EXEC_PATH, pageFilename);
-        const contentStr = (yield readFile(sourcePath)).toString();
+        const contentStr = (await readFile(sourcePath)).toString();
         try {
-            const tree = yield preparseMdxTree(contentStr, CMD_EXEC_PATH, sourcePath);
-            const importsResponse = yield findAndRemoveImports(tree);
+            const tree = await preparseMdxTree(contentStr, CMD_EXEC_PATH, sourcePath);
+            const importsResponse = await findAndRemoveImports(tree);
             if (Object.keys(importsResponse.importMap).some((importPath) => updatedSnippets.has(optionallyRemoveLeadingSlash(importPath)))) {
-                const content = yield resolveAllImports({
+                const content = await resolveAllImports({
                     snippets,
-                    fileWithImports: Object.assign(Object.assign({}, importsResponse), { filename: pageFilename }),
+                    fileWithImports: { ...importsResponse, filename: pageFilename },
                 });
                 const targetPath = join(NEXT_PROPS_PATH, pageFilename);
-                yield outputFile(targetPath, stringifyTree(content), {
+                await outputFile(targetPath, stringifyTree(content), {
                     flag: 'w',
                 });
             }
@@ -40,5 +31,5 @@ export const generatePagesWithImports = (updatedSnippets) => __awaiter(void 0, v
             console.log(pageFilename);
             console.log(err);
         }
-    })));
-});
+    }));
+};

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

@@ -1,24 +1,15 @@
-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 { generateOpenApiAnchorsOrTabs, categorizeFilePaths, generateOpenApiDivisions, MintConfigUpdater, DocsConfigUpdater, } from '@mintlify/prebuild';
 import { upgradeToDocsConfig } from '@mintlify/validation';
 import fse from 'fs-extra';
 import { join } from 'path';
 import { CMD_EXEC_PATH, CLIENT_PATH } from '../../constants.js';
-export const getDocsState = () => __awaiter(void 0, void 0, void 0, function* () {
-    const { openApiFiles } = yield categorizeFilePaths(CMD_EXEC_PATH);
+export const getDocsState = async () => {
+    const { openApiFiles } = await categorizeFilePaths(CMD_EXEC_PATH);
     try {
-        const mintConfig = yield MintConfigUpdater.getConfig(join(CMD_EXEC_PATH, 'mint.json'));
+        const mintConfig = await MintConfigUpdater.getConfig(join(CMD_EXEC_PATH, 'mint.json'));
         const docsConfig = upgradeToDocsConfig(mintConfig);
-        const { mintConfig: newMintConfig } = yield generateOpenApiAnchorsOrTabs(mintConfig, openApiFiles, CLIENT_PATH);
-        const { newDocsConfig, pagesAcc, openApiFiles: newOpenApiFiles, } = yield generateOpenApiDivisions(docsConfig, openApiFiles, CLIENT_PATH);
+        const { mintConfig: newMintConfig } = await generateOpenApiAnchorsOrTabs(mintConfig, openApiFiles, CLIENT_PATH);
+        const { newDocsConfig, pagesAcc, openApiFiles: newOpenApiFiles, } = await generateOpenApiDivisions(docsConfig, openApiFiles, CLIENT_PATH);
         return {
             mintConfig: newMintConfig,
             pagesAcc,
@@ -26,12 +17,12 @@ export const getDocsState = () => __awaiter(void 0, void 0, void 0, function* ()
             docsConfig: newDocsConfig,
         };
     }
-    catch (_a) {
+    catch {
         const docsJsonPath = join(CMD_EXEC_PATH, 'docs.json');
-        if (!(yield fse.pathExists(docsJsonPath)))
+        if (!(await fse.pathExists(docsJsonPath)))
             throw new Error('No config found');
-        const docsConfig = yield DocsConfigUpdater.getConfig(docsJsonPath);
-        const { newDocsConfig, pagesAcc, openApiFiles: newOpenApiFiles, } = yield generateOpenApiDivisions(docsConfig, openApiFiles, CLIENT_PATH);
+        const docsConfig = await DocsConfigUpdater.getConfig(docsJsonPath);
+        const { newDocsConfig, pagesAcc, openApiFiles: newOpenApiFiles, } = await generateOpenApiDivisions(docsConfig, openApiFiles, CLIENT_PATH);
         return { pagesAcc, openApiFiles: newOpenApiFiles, docsConfig: newDocsConfig };
     }
-});
+};

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

@@ -1,23 +1,14 @@
-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 { optionallyAddLeadingSlash } from '@mintlify/common';
 import { getFileListSync, preparseMdxTree } from '@mintlify/prebuild';
 import { promises as _promises } from 'fs';
 import { join } from 'path';
 import { CMD_EXEC_PATH, NEXT_PUBLIC_PATH } from '../../constants.js';
 const { readFile } = _promises;
-const getSnippetBase = (BASE_DIR) => __awaiter(void 0, void 0, void 0, function* () {
+const getSnippetBase = async (BASE_DIR) => {
     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* () {
+    const promises = snippetFilenames.map(async (snippetFilename) => {
         try {
-            const tree = yield preparseMdxTree((yield readFile(join(BASE_DIR, snippetFilename))).toString(), BASE_DIR, join(BASE_DIR, snippetFilename));
+            const tree = await preparseMdxTree((await readFile(join(BASE_DIR, snippetFilename))).toString(), BASE_DIR, join(BASE_DIR, snippetFilename));
             return {
                 filename: optionallyAddLeadingSlash(snippetFilename),
                 tree,
@@ -27,8 +18,8 @@ const getSnippetBase = (BASE_DIR) => __awaiter(void 0, void 0, void 0, function*
             console.warn(`Error reading snippet file ${snippetFilename}`);
             return;
         }
-    }));
-    return (yield Promise.all(promises)).filter(Boolean);
-});
+    });
+    return (await 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

@@ -1,12 +1,3 @@
-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, hasImports, getFileCategory, openApiCheck, stringifyTree, } from '@mintlify/common';
 import { createPage, MintConfigUpdater, DocsConfigUpdater, preparseMdxTree, } from '@mintlify/prebuild';
 import Chalk from 'chalk';
@@ -35,9 +26,9 @@ const listener = (callback) => {
         .on('change', (filename) => onChangeEvent(filename, callback))
         .on('unlink', onUnlinkEvent);
 };
-const onAddEvent = (filename, callback) => __awaiter(void 0, void 0, void 0, function* () {
+const onAddEvent = async (filename, callback) => {
     try {
-        const category = yield onUpdateEvent(filename, callback);
+        const category = await onUpdateEvent(filename, callback);
         switch (category) {
             case 'page':
                 console.log('New page detected: ', filename);
@@ -67,10 +58,10 @@ const onAddEvent = (filename, callback) => __awaiter(void 0, void 0, void 0, fun
     catch (error) {
         console.error(error.message);
     }
-});
-const onChangeEvent = (filename, callback) => __awaiter(void 0, void 0, void 0, function* () {
+};
+const onChangeEvent = async (filename, callback) => {
     try {
-        const category = yield onUpdateEvent(filename, callback);
+        const category = await onUpdateEvent(filename, callback);
         switch (category) {
             case 'page':
                 console.log('Page edited: ', filename);
@@ -100,8 +91,8 @@ const onChangeEvent = (filename, callback) => __awaiter(void 0, void 0, void 0,
     catch (error) {
         console.error(error.message);
     }
-});
-const onUnlinkEvent = (filename) => __awaiter(void 0, void 0, void 0, function* () {
+};
+const onUnlinkEvent = async (filename) => {
     try {
         const potentialCategory = getFileCategory(filename);
         const targetPath = getTargetPath(potentialCategory, filename);
@@ -113,7 +104,7 @@ const onUnlinkEvent = (filename) => __awaiter(void 0, void 0, void 0, function*
             potentialCategory === 'snippet-v2' ||
             potentialCategory === 'css' ||
             potentialCategory === 'js') {
-            yield fse.remove(targetPath);
+            await fse.remove(targetPath);
         }
         switch (potentialCategory) {
             case 'page':
@@ -125,16 +116,16 @@ const onUnlinkEvent = (filename) => __awaiter(void 0, void 0, void 0, function*
                 break;
             case 'mintConfig':
                 console.error('⚠️ mint.json has been deleted.');
-                yield validateConfigFiles();
+                await validateConfigFiles();
                 break;
             case 'docsConfig':
                 console.error('⚠️ docs.json has been deleted.');
-                yield validateConfigFiles();
+                await validateConfigFiles();
                 break;
             case 'potentialJsonOpenApiSpec':
             case 'potentialYamlOpenApiSpec':
-                yield updateOpenApiFiles();
-                yield updateGeneratedNav();
+                await updateOpenApiFiles();
+                await updateGeneratedNav();
                 break;
             case 'css':
                 console.log(`CSS file deleted: ${filename}`);
@@ -150,7 +141,7 @@ const onUnlinkEvent = (filename) => __awaiter(void 0, void 0, void 0, function*
     catch (error) {
         console.error(error.message);
     }
-});
+};
 const getTargetPath = (potentialCategory, filePath) => {
     switch (potentialCategory) {
         case 'page':
@@ -172,12 +163,12 @@ const getTargetPath = (potentialCategory, filePath) => {
             throw new Error('Invalid category');
     }
 };
-const validateConfigFiles = () => __awaiter(void 0, void 0, void 0, function* () {
+const validateConfigFiles = async () => {
     try {
         const mintConfigPath = pathUtil.join(CMD_EXEC_PATH, 'mint.json');
         const docsConfigPath = pathUtil.join(CMD_EXEC_PATH, 'docs.json');
-        const mintConfigExists = yield fse.pathExists(mintConfigPath);
-        const docsConfigExists = yield fse.pathExists(docsConfigPath);
+        const mintConfigExists = await fse.pathExists(mintConfigPath);
+        const docsConfigExists = await fse.pathExists(docsConfigPath);
         if (!mintConfigExists && !docsConfigExists) {
             console.error('⚠️ Error: Neither mint.json nor docs.json found in the directory');
             process.exit(1);
@@ -186,13 +177,13 @@ const validateConfigFiles = () => __awaiter(void 0, void 0, void 0, function* ()
     catch (error) {
         console.error('⚠️ Error validating configuration files:', error);
     }
-});
+};
 /**
  * This function is called when a file is added or changed
  * @param filename
  * @returns FileCategory
  */
-const onUpdateEvent = (filename, callback) => __awaiter(void 0, void 0, void 0, function* () {
+const onUpdateEvent = async (filename, callback) => {
     const filePath = pathUtil.join(CMD_EXEC_PATH, filename);
     const potentialCategory = getFileCategory(filename);
     const targetPath = getTargetPath(potentialCategory, filename);
@@ -204,46 +195,46 @@ const onUpdateEvent = (filename, callback) => __awaiter(void 0, void 0, void 0,
     switch (potentialCategory) {
         case 'page': {
             regenerateNav = true;
-            let contentStr = (yield readFile(filePath)).toString();
-            const tree = yield preparseMdxTree(contentStr, CMD_EXEC_PATH, filePath);
-            const importsResponse = yield findAndRemoveImports(tree);
+            let contentStr = (await readFile(filePath)).toString();
+            const tree = await preparseMdxTree(contentStr, CMD_EXEC_PATH, filePath);
+            const importsResponse = await findAndRemoveImports(tree);
             if (hasImports(importsResponse)) {
-                contentStr = stringifyTree(yield resolveAllImports(Object.assign(Object.assign({}, importsResponse), { filename })));
+                contentStr = stringifyTree(await resolveAllImports({ ...importsResponse, filename }));
             }
-            const { pageContent } = yield createPage(filename, contentStr, CMD_EXEC_PATH, [], []);
-            yield fse.outputFile(targetPath, pageContent, {
+            const { pageContent } = await createPage(filename, contentStr, CMD_EXEC_PATH, [], []);
+            await fse.outputFile(targetPath, pageContent, {
                 flag: 'w',
             });
             break;
         }
         case 'snippet': {
-            yield fse.copy(filePath, targetPath);
+            await fse.copy(filePath, targetPath);
             break;
         }
         case 'snippet-v2': {
-            let contentStr = (yield readFile(filePath)).toString();
-            const tree = yield preparseMdxTree(contentStr, CMD_EXEC_PATH, filePath);
-            const importsResponse = yield findAndRemoveImports(tree);
+            let contentStr = (await readFile(filePath)).toString();
+            const tree = await preparseMdxTree(contentStr, CMD_EXEC_PATH, filePath);
+            const importsResponse = await findAndRemoveImports(tree);
             if (hasImports(importsResponse)) {
-                contentStr = stringifyTree(yield resolveAllImports(Object.assign(Object.assign({}, importsResponse), { filename })));
+                contentStr = stringifyTree(await resolveAllImports({ ...importsResponse, filename }));
             }
-            yield fse.outputFile(targetPath, contentStr, {
+            await fse.outputFile(targetPath, contentStr, {
                 flag: 'w',
             });
-            const updatedSnippets = yield generateDependentSnippets(filename, importsResponse);
-            yield generatePagesWithImports(new Set(updatedSnippets));
+            const updatedSnippets = await generateDependentSnippets(filename, importsResponse);
+            await generatePagesWithImports(new Set(updatedSnippets));
             break;
         }
         case 'mintConfig':
         case 'docsConfig': {
             regenerateNav = true;
             try {
-                const { mintConfig, openApiFiles, docsConfig } = yield getDocsState();
+                const { mintConfig, openApiFiles, docsConfig } = await getDocsState();
                 if (mintConfig) {
-                    yield MintConfigUpdater.writeConfigFile(mintConfig, CLIENT_PATH);
+                    await MintConfigUpdater.writeConfigFile(mintConfig, CLIENT_PATH);
                 }
-                yield DocsConfigUpdater.writeConfigFile(docsConfig, CLIENT_PATH);
-                yield updateOpenApiFiles(openApiFiles);
+                await DocsConfigUpdater.writeConfigFile(docsConfig, CLIENT_PATH);
+                await updateOpenApiFiles(openApiFiles);
             }
             catch (err) {
                 console.error(err);
@@ -254,19 +245,19 @@ const onUpdateEvent = (filename, callback) => __awaiter(void 0, void 0, void 0,
         case 'potentialJsonOpenApiSpec': {
             let doc;
             try {
-                const file = yield fs.readFile(filePath, 'utf-8');
-                doc = yield openApiCheck(yaml.load(file));
+                const file = await fs.readFile(filePath, 'utf-8');
+                doc = await openApiCheck(yaml.load(file));
             }
-            catch (_a) {
+            catch {
                 doc = undefined;
             }
             if (doc) {
-                yield upsertOpenApiFile({
+                await upsertOpenApiFile({
                     filename: pathUtil.parse(filename).name,
                     originalFileLocation: '/' + filename,
                     spec: doc,
                 });
-                yield updateOpenApiFiles();
+                await updateOpenApiFiles();
                 regenerateNav = true;
                 category = 'openApi';
             }
@@ -275,8 +266,8 @@ const onUpdateEvent = (filename, callback) => __awaiter(void 0, void 0, void 0,
         case 'css':
         case 'js':
         case 'staticFile': {
-            if (yield isFileSizeValid(filePath, 5)) {
-                yield fse.copy(filePath, targetPath);
+            if (await isFileSizeValid(filePath, 5)) {
+                await fse.copy(filePath, targetPath);
             }
             else {
                 console.error(Chalk.red(`🚨 The file at ${filename} is too big. The maximum file size is 5 mb.`));
@@ -286,9 +277,9 @@ const onUpdateEvent = (filename, callback) => __awaiter(void 0, void 0, void 0,
     }
     if (regenerateNav) {
         // TODO: Instead of re-generating the entire nav, optimize by just updating the specific page that changed.
-        yield updateGeneratedNav();
+        await updateGeneratedNav();
     }
     callback();
     return category;
-});
+};
 export default listener;

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

@@ -1,18 +1,9 @@
-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 { resolveAllImports as baseResolveAllImports } from '@mintlify/common';
 import { getProcessedSnippets } from './getSnippets.js';
-export const resolveAllImports = (fileWithImports) => __awaiter(void 0, void 0, void 0, function* () {
-    const snippets = yield getProcessedSnippets();
-    return yield baseResolveAllImports({
+export const resolveAllImports = async (fileWithImports) => {
+    const snippets = await getProcessedSnippets();
+    return await baseResolveAllImports({
         snippets,
         fileWithImports,
     });
-});
+};

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

@@ -1,43 +1,34 @@
-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 fse from 'fs-extra';
 import { join } from 'path';
 import { NEXT_PROPS_PATH } from '../../constants.js';
 import { generateNav } from './generate.js';
 import { getDocsState } from './getDocsState.js';
 import { readJsonFile } from './utils.js';
-export const updateGeneratedNav = () => __awaiter(void 0, void 0, void 0, function* () {
-    const { pagesAcc, docsConfig } = yield getDocsState();
-    const generatedDocsNav = yield generateNav(pagesAcc, docsConfig);
+export const updateGeneratedNav = async () => {
+    const { pagesAcc, docsConfig } = await getDocsState();
+    const generatedDocsNav = await generateNav(pagesAcc, docsConfig);
     const targetDocsPath = join(NEXT_PROPS_PATH, 'generatedDocsNav.json');
-    yield fse.outputFile(targetDocsPath, JSON.stringify(generatedDocsNav, null, 2), {
+    await fse.outputFile(targetDocsPath, JSON.stringify(generatedDocsNav, null, 2), {
         flag: 'w',
     });
-});
-export const updateOpenApiFiles = (providedOpenApiFiles) => __awaiter(void 0, void 0, void 0, function* () {
+};
+export const updateOpenApiFiles = async (providedOpenApiFiles) => {
     if (providedOpenApiFiles == undefined) {
-        const { openApiFiles } = yield getDocsState();
+        const { openApiFiles } = await getDocsState();
         providedOpenApiFiles = openApiFiles;
     }
     const targetPath = join(NEXT_PROPS_PATH, 'openApiFiles.json');
-    yield fse.outputFile(targetPath, JSON.stringify(providedOpenApiFiles, null, 2), {
+    await fse.outputFile(targetPath, JSON.stringify(providedOpenApiFiles, null, 2), {
         flag: 'w',
     });
-});
-export const upsertOpenApiFile = (openApiFile) => __awaiter(void 0, void 0, void 0, function* () {
+};
+export const upsertOpenApiFile = async (openApiFile) => {
     const sourcePath = join(NEXT_PROPS_PATH, 'openApiFiles.json');
     let existingOpenApiFiles = [];
     try {
-        existingOpenApiFiles = (yield readJsonFile(sourcePath));
+        existingOpenApiFiles = (await readJsonFile(sourcePath));
     }
-    catch (_a) { }
+    catch { }
     const existingIndex = existingOpenApiFiles.findIndex((file) => file.originalFileLocation === openApiFile.originalFileLocation);
     if (existingIndex >= 0) {
         existingOpenApiFiles[existingIndex] = openApiFile;
@@ -45,7 +36,7 @@ export const upsertOpenApiFile = (openApiFile) => __awaiter(void 0, void 0, void
     else {
         existingOpenApiFiles.push(openApiFile);
     }
-    yield fse.outputFile(sourcePath, JSON.stringify(existingOpenApiFiles, null, 2), {
+    await fse.outputFile(sourcePath, JSON.stringify(existingOpenApiFiles, null, 2), {
         flag: 'w',
     });
-});
+};

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

@@ -1,27 +1,18 @@
-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 { promises as _promises } from 'fs';
 import fse from 'fs-extra';
 const { stat } = _promises;
 export const getFileExtension = (filename) => {
     return filename.substring(filename.lastIndexOf('.') + 1, filename.length) || filename;
 };
-export const isFileSizeValid = (path, maxFileSizeInMb) => __awaiter(void 0, void 0, void 0, function* () {
+export const isFileSizeValid = async (path, maxFileSizeInMb) => {
     const maxFileSizeBytes = maxFileSizeInMb * 1000000;
-    const stats = yield stat(path);
+    const stats = await stat(path);
     return stats.size <= maxFileSizeBytes;
-});
+};
 export function isError(obj) {
     return Object.prototype.toString.call(obj) === '[object Error]';
 }
-export const readJsonFile = (path) => __awaiter(void 0, void 0, void 0, function* () {
-    const file = yield fse.readFile(path, 'utf-8');
+export const readJsonFile = async (path) => {
+    const file = await fse.readFile(path, 'utf-8');
     return JSON.parse(file);
-});
+};