@mintlify/previewing 4.0.527 → 4.0.529

package/dist/local-preview/index.js

@@ -1,59 +1,46 @@
-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 { prebuild } from '@mintlify/prebuild';
-import open from 'better-opn';
-import Chalk from 'chalk';
-import express from 'express';
 import fse, { pathExists } from 'fs-extra';
-import { createServer } from 'http';
 import isOnline from 'is-online';
-import { pathToFileURL } from 'node:url';
-import { Server as SocketServer } from 'socket.io';
-import { CLIENT_PATH, DOT_MINTLIFY, CMD_EXEC_PATH, VERSION_PATH, NEXT_CONFIG_PATH, NEXT_PUBLIC_PATH, NEXT_PROPS_PATH, NEXT_SIDE_EFFECT_PATH, NEXT_ROUTER_SERVER_PATH, } from '../constants.js';
-import { buildLogger, maybeFixMissingWindowsEnvVar } from '../util.js';
+import { CLIENT_PATH, DOT_MINTLIFY, CMD_EXEC_PATH, VERSION_PATH, NEXT_PUBLIC_PATH, NEXT_PROPS_PATH, } from '../constants.js';
+import { buildLogger } from '../util.js';
 import { getTargetMintVersion, downloadTargetMint } from './client.js';
-import listener from './listener/index.js';
-const dev = (argv) => __awaiter(void 0, void 0, void 0, function* () {
+import { run } from './run.js';
+const dev = async (argv) => {
     // Note: We wait for specific text in the logger to be sure the server is ready when we e2e test the cli.
     // If the cli output does not exactly match:
     // "- Preparing local Mintlify instance...\n✔ Local Mintlify instance is ready. Launching your site...\nYour local preview is available at http://localhost:3000\nPress Ctrl+C any time to stop the local preview."
     // the test will fail/require an update.
     const logger = buildLogger('Preparing local Mintlify instance...');
-    const hasInternet = yield isOnline();
+    const hasInternet = await isOnline();
     const localSchema = argv['local-schema'];
     const clientVersion = argv['client-version'];
-    yield fse.ensureDir(DOT_MINTLIFY);
-    const versionString = (yield pathExists(VERSION_PATH))
+    await fse.ensureDir(DOT_MINTLIFY);
+    const versionString = (await pathExists(VERSION_PATH))
         ? fse.readFileSync(VERSION_PATH, 'utf8')
         : null;
     if (!versionString && !hasInternet) {
         logger.fail('Running mintlify dev afer updating requires an internet connection.');
         process.exit(1);
     }
-    const targetMintVersion = yield getTargetMintVersion(logger);
+    const targetMintVersion = await getTargetMintVersion(logger);
     if (!targetMintVersion) {
-        logger.text =
-            'Failed to get latest Mintlify client version. Your current version is: ' +
-                versionString +
-                ', which may not be the latest Mintlify client version.';
+        logger.stopAndPersist({ symbol: '✓' });
+        logger.warn(`Failed to get latest Mintlify client version. Your current version is: ${versionString?.trim()}, which may not be the latest Mintlify client version.`);
     }
     const shouldDownload = versionString !== targetMintVersion || clientVersion !== undefined;
     if (shouldDownload && hasInternet && targetMintVersion) {
-        yield downloadTargetMint(logger, targetMintVersion, versionString, clientVersion);
+        await downloadTargetMint({
+            logger,
+            targetVersion: clientVersion ?? targetMintVersion,
+            existingVersion: versionString,
+        });
     }
     // clear preexisting prebuild files
     fse.emptyDirSync(NEXT_PUBLIC_PATH);
     fse.emptyDirSync(NEXT_PROPS_PATH);
     process.chdir(CLIENT_PATH);
     try {
-        yield prebuild(CMD_EXEC_PATH, { localSchema });
+        await prebuild(CMD_EXEC_PATH, { localSchema });
     }
     catch (err) {
         const errorText = err instanceof Error && err.message ? err.message : 'Prebuild step failed';
@@ -61,82 +48,6 @@ const dev = (argv) => __awaiter(void 0, void 0, void 0, function* () {
         process.exit(1);
     }
     logger.succeed('Local Mintlify instance is ready. Launching your site...');
-    yield run(argv);
-});
-/**
- * When creating a standalone build, next.js outputs a server.js file that can be used as
- * an entry point into the server. However, because we want to customize some parts of the
- * http server (adding a socket.io server, serving the whole public directory), we
- * create the server ourselves, and just reproduce the setup that next.js would do.
- *
- * Because we need to directly import from node_modules files, this solution seems very hacky,
- * but it is arguably no more hacky than using the server.js that ships with the standalone
- * build.
- *
- * This function attempts to replicate the behavior of two next.js files:
- * - environment setup from server.js
- * - initialization of the request handler from start-server.ts
- *
- * Links:
- * - [standalone build](https://nextjs.org/docs/pages/api-reference/next-config-js/output#automatically-copying-traced-files)
- * - [server.js](https://github.com/vercel/next.js/blob/492156b4c5e2559b2a280f7d483cd85a8e8742a9/packages/next/src/build/utils.ts#L2108-L2113) (created programmatically)
- * - [start-server.ts](https://github.com/vercel/next.js/blob/492156b4c5e2559b2a280f7d483cd85a8e8742a9/packages/next/src/server/lib/start-server.ts#L296-L308)
- *
- * @returns the request handler provided by next.js
- */
-const setupNext = () => __awaiter(void 0, void 0, void 0, function* () {
-    const hostname = process.env.HOSTNAME || 'localhost';
-    const { config } = yield JSON.parse(fse.readFileSync(NEXT_CONFIG_PATH, 'utf8'));
-    process.env.__NEXT_PRIVATE_STANDALONE_CONFIG = JSON.stringify(config);
-    // The server.js provided by next.js's standalone build does a similar import of this file.
-    // Not sure what side effects are being created, but want to change as little as possible.
-    // Also, Windows requires us to use `pathToFileURL` (see #899)
-    yield import(pathToFileURL(NEXT_SIDE_EFFECT_PATH).href);
-    const { initialize } = yield import(pathToFileURL(NEXT_ROUTER_SERVER_PATH).href);
-    const [requestHandler] = yield initialize({
-        dir: CLIENT_PATH,
-        dev: false,
-        hostname,
-        minimalMode: true,
-    });
-    return requestHandler;
-});
-const run = (argv) => __awaiter(void 0, void 0, void 0, function* () {
-    const port = argv.port || '3000';
-    const currentPort = parseInt(port, 10) || 3000;
-    const app = express();
-    const server = createServer(app);
-    const io = new SocketServer(server);
-    const requestHandler = yield setupNext();
-    // next-server is bugged, public files added after starting aren't served
-    app.use('/', express.static(NEXT_PUBLIC_PATH));
-    app.all('*', (req, res) => requestHandler(req, res));
-    const onChange = () => {
-        io.emit('reload');
-    };
-    server.listen(currentPort, () => {
-        console.log(`${Chalk.green(`Your local preview is available at http://localhost:${port}`)}`);
-        // Note: We wait for this exact text to be sure the server is ready in the cli e2e test,
-        // if it changes, the test will fail/require an update.
-        console.log(`${Chalk.green('Press Ctrl+C any time to stop the local preview.')}`);
-        /**
-         * We're running into a known bug with the `open` package, where Windows machines error out because process.env.SYSTEMROOT is not set:
-         * https://github.com/sindresorhus/open/issues/292
-         *
-         * Let's use the same workaround that this project did:
-         * https://github.com/sanity-io/sanity/pull/4221/files#diff-aeb574e1becf61f21fdf87fbea709669c93d604d660dad4b0f9e24527a2fb54bR256-R262
-         */
-        maybeFixMissingWindowsEnvVar();
-        if (argv.open) {
-            void open(`http://localhost:${port}`);
-        }
-        // exit with successful status
-        const onExit = () => {
-            process.exit(0);
-        };
-        process.on('SIGINT', onExit);
-        process.on('SIGTERM', onExit);
-    });
-    listener(onChange);
-});
+    await run(argv);
+};
 export default dev;

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);