mintlify 1.3.0 → 2.0.3

package/src/local-preview/index.ts

@@ -6,80 +6,14 @@ import inquirer from "inquirer";
 import { isInternetAvailable } from "is-internet-available";
 import path from "path";
 import shell from "shelljs";
-import categorizeFiles from "./utils/categorizeFiles.js";
 import {
-  CMD_EXEC_PATH,
   CLIENT_PATH,
   HOME_DIR,
   DOT_MINTLIFY,
+  CMD_EXEC_PATH,
 } from "../constants.js";
-import { injectFavicons } from "./utils/injectFavicons.js";
-import listener from "./utils/listener.js";
-import { createPage, createMetadataFileFromPages } from "./utils/metadata.js";
-import { updateConfigFile } from "./utils/mintConfigFile.js";
 import { buildLogger, ensureYarn } from "../util.js";
-
-const { readFile } = _promises;
-
-const copyFiles = async (logger: any) => {
-  logger.start("Syncing doc files...");
-  shell.cd(CMD_EXEC_PATH);
-  const { markdownFiles, staticFiles, openApi } = await categorizeFiles();
-
-  const configObj = await updateConfigFile(logger);
-
-  const openApiTargetPath = path.join(CLIENT_PATH, "src", "openapi.json");
-  if (openApi) {
-    logger.succeed("OpenApi file synced");
-    await fse.outputFile(openApiTargetPath, JSON.stringify(openApi), {
-      flag: "w",
-    });
-  } else {
-    await fse.outputFile(openApiTargetPath, "{}", { flag: "w" });
-  }
-  let pages = {};
-  const mdPromises = [];
-  markdownFiles.forEach((filename) => {
-    mdPromises.push(
-      (async () => {
-        const sourcePath = path.join(CMD_EXEC_PATH, filename);
-        const pagesDir = path.join(CLIENT_PATH, "src", "pages");
-        const targetPath = path.join(pagesDir, filename);
-
-        await fse.remove(targetPath);
-        await fse.copy(sourcePath, targetPath);
-
-        const fileContent = await readFile(sourcePath);
-        const contentStr = fileContent.toString();
-        const page = createPage(filename, contentStr, openApi);
-        pages = {
-          ...pages,
-          ...page,
-        };
-      })()
-    );
-  });
-  const staticFilePromises = [];
-  staticFiles.forEach((filename) => {
-    staticFilePromises.push(
-      (async () => {
-        const sourcePath = path.join(CMD_EXEC_PATH, filename);
-        const publicDir = path.join(CLIENT_PATH, "public");
-        const targetPath = path.join(publicDir, filename);
-
-        await fse.remove(targetPath);
-        await fse.copy(sourcePath, targetPath);
-      })()
-    );
-  });
-  await Promise.all([
-    ...mdPromises,
-    ...staticFilePromises,
-    await injectFavicons(configObj, logger),
-  ]);
-  createMetadataFileFromPages(pages, configObj);
-  logger.succeed("All files synced");
-};
+import listener from "./listener/index.js";
 
 const shellExec = (cmd: string) => {
   return shell.exec(cmd, { silent: true });
@@ -116,7 +50,19 @@ const dev = async () => {
   await promptForYarn();
   const logger = buildLogger("Starting a local Mintlify instance...");
   await fse.ensureDir(path.join(DOT_MINTLIFY, "mint"));
-  shell.cd(path.join(HOME_DIR, ".mintlify", "mint"));
+  const MINT_PATH = path.join(DOT_MINTLIFY, "mint");
+  shell.cd(MINT_PATH);
+  const gitPullStatus = shellExec("git show").stdout;
+  const currBranch = shellExec("git rev-parse --abbrev-ref HEAD").stdout;
+  if (
+    gitPullStatus.startsWith(
+      "commit 78d764335877932a0dc305d615411dedd18bd18a"
+    ) ||
+    currBranch === "legacy-components-import"
+  ) {
+    await fse.emptyDir(MINT_PATH);
+  }
+
   let runYarn = true;
   const gitInstalled = shell.which("git");
   let firstInstallation = false;
@@ -144,9 +90,7 @@ const dev = async () => {
   if (internet && gitInstalled) {
     shellExec("git config core.sparseCheckout true");
     shellExec('echo "client/" >> .git/info/sparse-checkout');
-    pullOutput = shellExec(
-      "git pull mint-origin legacy-components-import"
-    ).stdout;
+    pullOutput = shellExec("git pull mint-origin main").stdout;
     shellExec("git config core.sparseCheckout false");
     shellExec("rm .git/info/sparse-checkout");
   }
@@ -176,7 +120,8 @@ const dev = async () => {
     `);
     process.exit(1);
   }
-  await copyFiles(logger);
+  shellExec(`yarn preconfigure ../../../../..${CMD_EXEC_PATH}`);
+  logger.succeed("Local Mintlify instance initialized");
   run();
 };
 
@@ -187,7 +132,7 @@ const run = () => {
       "Navigate to your local preview at http://localhost:3000"
     )}`
   );
-  shell.exec("npm run dev", { async: true });
+  shell.exec("npm run dev-watch", { async: true });
   open("http://localhost:3000");
   listener();
 };

package/src/local-preview/listener/categorizeFiles.ts

@@ -0,0 +1,55 @@
+// TODO - put in prebuild package
+import path from "path";
+
+import { getFileExtension, openApiCheck, getFileList } from "./utils.js";
+
+const categorizeFiles = async (contentDirectoryPath: string) => {
+  const allFilesInCmdExecutionPath = await getFileList(contentDirectoryPath);
+  const contentFilenames = [];
+  const staticFilenames = [];
+  const promises = [];
+  const openApiFiles = [];
+  const snippets = [];
+  allFilesInCmdExecutionPath.forEach((filename) => {
+    promises.push(
+      (async () => {
+        const extension = getFileExtension(filename);
+        let isOpenApi = false;
+        if (extension && (extension === "mdx" || extension === "md")) {
+          if (filename.startsWith("/_snippets")) {
+            snippets.push(filename);
+          } else {
+            contentFilenames.push(filename);
+          }
+        } else if (
+          extension &&
+          (extension === "json" || extension === "yaml" || extension === "yml")
+        ) {
+          const openApiInfo = await openApiCheck(
+            path.join(contentDirectoryPath, filename)
+          );
+          isOpenApi = openApiInfo.isOpenApi;
+          if (isOpenApi) {
+            const fileName = path.parse(filename).base;
+            openApiFiles.push({
+              filename: fileName.substring(0, fileName.lastIndexOf(".")),
+              spec: openApiInfo.spec,
+            });
+          }
+        } else if (
+          (!filename.endsWith("mint.config.json") ||
+            !filename.endsWith("mint.json")) &&
+          !isOpenApi
+        ) {
+          // all other files
+          staticFilenames.push(filename);
+        }
+      })()
+    );
+  });
+  await Promise.all(promises);
+
+  return { contentFilenames, staticFilenames, openApiFiles, snippets };
+};
+
+export default categorizeFiles;

package/src/local-preview/listener/generate.ts

@@ -0,0 +1,110 @@
+// TODO - add types
+import { promises as _promises } from "fs";
+import { outputFile } from "fs-extra";
+import path from "path";
+import createPage from "./utils/createPage.js";
+import { OpenApiFile } from "./utils/types.js";
+import categorizeFiles from "./categorizeFiles.js";
+import { CMD_EXEC_PATH } from "../../constants.js";
+import { getConfigObj } from "./utils/mintConfigFile.js";
+const { readFile } = _promises;
+
+// TODO: Put in prebuild package
+const generateNavFromPages = (pages, mintConfigNav) => {
+  const createNav = (nav) => {
+    return {
+      group: nav.group,
+      version: nav.version,
+      pages: nav.pages.map((page) => {
+        if (typeof page === "string") {
+          return pages[page];
+        }
+        return createNav(page);
+      }),
+    };
+  };
+
+  if (mintConfigNav == null) {
+    return;
+  }
+
+  let navFile = mintConfigNav.map((nav) => createNav(nav));
+  const filterOutNullInPages = (pages) => {
+    const newPages = [];
+    pages.forEach((page) => {
+      if (page == null) {
+        return;
+      }
+      if (page?.pages) {
+        const newGroup = filterOutNullInGroup(page);
+        newPages.push(newGroup);
+      } else {
+        newPages.push(page);
+      }
+    });
+
+    return newPages;
+  };
+  const filterOutNullInGroup = (group) => {
+    const newPages = filterOutNullInPages(group.pages);
+    const newGroup = {
+      ...group,
+      pages: newPages,
+    };
+    return newGroup;
+  };
+  const newNavFile = navFile.map((group) => {
+    return filterOutNullInGroup(group);
+  });
+  return newNavFile;
+};
+
+// TODO: Put in prebuild package
+const createPagesAcc = async (
+  contentDirectoryPath: string,
+  contentFilenames: string[],
+  openApiFiles: OpenApiFile[],
+  clientPath?: string,
+  writeFiles = false
+) => {
+  let pagesAcc = {};
+  const contentPromises = [];
+  contentFilenames.forEach((filename) => {
+    contentPromises.push(
+      (async () => {
+        const sourcePath = path.join(contentDirectoryPath, filename);
+
+        const contentStr = (await readFile(sourcePath)).toString();
+        const { slug, pageMetadata, pageContent } = await createPage(
+          filename,
+          contentStr,
+          contentDirectoryPath,
+          openApiFiles
+        );
+        if (clientPath && writeFiles) {
+          const targetPath = path.join(clientPath, "src", "_props", filename);
+          await outputFile(targetPath, pageContent, {
+            flag: "w",
+          });
+        }
+        pagesAcc = {
+          ...pagesAcc,
+          [slug]: pageMetadata,
+        };
+      })()
+    );
+  });
+  await Promise.all(contentPromises);
+  return pagesAcc;
+};
+
+export const generateNav = async () => {
+  const { contentFilenames, openApiFiles } = await categorizeFiles(
+    CMD_EXEC_PATH
+  );
+  const [pageAcc, configObj] = await Promise.all([
+    createPagesAcc(CMD_EXEC_PATH, contentFilenames, openApiFiles),
+    getConfigObj(CMD_EXEC_PATH),
+  ]);
+  return generateNavFromPages(pageAcc, configObj?.navigation);
+};

package/src/local-preview/listener/index.ts

@@ -0,0 +1,169 @@
+import chokidar from "chokidar";
+import fse from "fs-extra";
+import pathUtil from "path";
+import { fileIsMdxOrMd } from "./utils/fileIsMdxOrMd.js";
+import { openApiCheck } from "./utils.js";
+import { updateGeneratedNav, updateOpenApiFiles } from "./update.js";
+import { CLIENT_PATH, CMD_EXEC_PATH } from "../../constants.js";
+import { promises as _promises } from "fs";
+import createPage from "./utils/createPage.js";
+
+const { readFile } = _promises;
+
+const listener = () => {
+  chokidar
+    .watch(CMD_EXEC_PATH, {
+      ignoreInitial: true,
+      ignored: ["node_modules", ".git"],
+      cwd: CMD_EXEC_PATH,
+    })
+    .on("all", async (event, filename) => {
+      if (event === "unlink" || event === "unlinkDir") {
+        if (fileIsMdxOrMd(filename)) {
+          const targetPath = pathUtil.join(
+            CLIENT_PATH,
+            "src",
+            "_props",
+            filename
+          );
+          await fse.remove(targetPath);
+          console.log(
+            `${
+              filename.startsWith("_snippets") ? "Snippet" : "Page"
+            } deleted: `,
+            filename
+          );
+        } else if (filename === "mint.json") {
+          const targetPath = pathUtil.join(
+            CLIENT_PATH,
+            "src",
+            "_props",
+            "mint.json"
+          );
+          await fse.remove(targetPath);
+          console.log(
+            "⚠️ mint.json deleted. Please create a new mint.json file as it is mandatory."
+          );
+          process.exit(1);
+        } else {
+          const extension = pathUtil.parse(filename).ext.slice(1);
+          if (
+            extension &&
+            (extension === "json" ||
+              extension === "yaml" ||
+              extension === "yml")
+          ) {
+            await updateOpenApiFiles();
+            await updateGeneratedNav();
+            return;
+          }
+          // all other files
+          const targetPath = pathUtil.join(CLIENT_PATH, "public", filename);
+          await fse.remove(targetPath);
+          console.log("Static file deleted: ", filename);
+        }
+      } else {
+        const filePath = pathUtil.join(CMD_EXEC_PATH, filename);
+        let regenerateNav = false;
+        if (fileIsMdxOrMd(filename)) {
+          const targetPath = pathUtil.join(
+            CLIENT_PATH,
+            "src",
+            "_props",
+            filename
+          );
+          if (filename.startsWith("_snippets")) {
+            const sourcePath = pathUtil.join(CMD_EXEC_PATH, filename);
+            await fse.remove(targetPath);
+            await fse.copy(sourcePath, targetPath);
+            return;
+          }
+          regenerateNav = true;
+
+          const contentStr = (await readFile(filePath)).toString();
+          const { pageContent } = await createPage(
+            filename,
+            contentStr,
+            CMD_EXEC_PATH,
+            []
+          );
+          await fse.outputFile(targetPath, pageContent, {
+            flag: "w",
+          });
+          switch (event) {
+            case "add":
+            case "addDir":
+              console.log("New page detected: ", filename);
+              break;
+            default:
+              console.log("Page edited: ", filename);
+              break;
+          }
+        } else if (filename === "mint.json") {
+          regenerateNav = true;
+          const targetPath = pathUtil.join(
+            CLIENT_PATH,
+            "src",
+            "_props",
+            "mint.json"
+          );
+          await fse.copy(filePath, targetPath);
+          switch (event) {
+            case "add":
+            case "addDir":
+              console.log("Config added");
+              break;
+            default:
+              console.log("Config edited");
+              break;
+          }
+        } else {
+          const extension = pathUtil.parse(filename).ext.slice(1);
+          let isOpenApi = false;
+          if (
+            extension &&
+            (extension === "json" ||
+              extension === "yaml" ||
+              extension === "yml")
+          ) {
+            const openApiInfo = await openApiCheck(
+              pathUtil.join(CMD_EXEC_PATH, filename)
+            );
+            isOpenApi = openApiInfo.isOpenApi;
+            if (isOpenApi) {
+              await updateOpenApiFiles();
+              regenerateNav = true;
+            }
+          }
+          if (!isOpenApi) {
+            // all other files
+            const targetPath = pathUtil.join(CLIENT_PATH, "public", filename);
+            await fse.copy(filePath, targetPath);
+          }
+          switch (event) {
+            case "add":
+            case "addDir":
+              if (isOpenApi) {
+                console.log("OpenApi file added: ", filename);
+              } else {
+                console.log("Static file added: ", filename);
+              }
+              break;
+            default:
+              if (isOpenApi) {
+                console.log("OpenApi file edited: ", filename);
+              } else {
+                console.log("Static file edited: ", filename);
+              }
+              break;
+          }
+        }
+        if (regenerateNav) {
+          // TODO: Instead of re-generating the entire nav, optimize by just updating the specific page that changed.
+          await updateGeneratedNav();
+        }
+      }
+    });
+};
+
+export default listener;

package/src/local-preview/listener/update.ts

@@ -0,0 +1,45 @@
+// TODO: Add Types
+import fse from "fs-extra";
+import { promises as _promises } from "fs";
+import { getConfigPath } from "./utils/mintConfigFile.js";
+import { CLIENT_PATH, CMD_EXEC_PATH } from "../../constants.js";
+import { join } from "path";
+import { generateNav } from "./generate.js";
+import categorizeFiles from "./categorizeFiles.js";
+
+const { readFile } = _promises;
+
+// TODO: Put in prebuild package
+
+export const updateConfigFile = async (contentDirectoryPath: string) => {
+  const configTargetPath = join(CLIENT_PATH, "src/_props/mint.json");
+  await fse.remove(configTargetPath);
+  let configObj = null;
+  const configPath = await getConfigPath(contentDirectoryPath);
+
+  if (configPath) {
+    await fse.remove(configTargetPath);
+    await fse.copy(configPath, configTargetPath);
+    const configContents = await readFile(configPath);
+    configObj = JSON.parse(configContents.toString());
+  } else {
+    process.exit(1);
+  }
+  return configObj;
+};
+
+export const updateGeneratedNav = async () => {
+  const generatedNav = await generateNav();
+  const targetPath = join(CLIENT_PATH, "src", "_props", "generatedNav.json");
+  await fse.outputFile(targetPath, JSON.stringify(generatedNav, null, 2), {
+    flag: "w",
+  });
+};
+
+export const updateOpenApiFiles = async () => {
+  const { openApiFiles } = await categorizeFiles(CMD_EXEC_PATH);
+  const targetPath = join(CLIENT_PATH, "src", "_props", "openApiFiles.json");
+  await fse.outputFile(targetPath, JSON.stringify(openApiFiles, null, 2), {
+    flag: "w",
+  });
+};