serve-my-md 1.1.7 → 1.1.9

package/bin/index.js

@@ -12,12 +12,12 @@ var Logger = class {
 
 // cli/src/shared.ts
 import MarkdownIt from "markdown-it";
-import path2 from "path";
+import path3 from "path";
 import Prism from "prismjs";
 
 // cli/src/core/index.ts
-import fs2 from "fs/promises";
-import path from "path";
+import fs3 from "fs/promises";
+import path2 from "path";
 import { minimatch } from "minimatch";
 
 // cli/src/utils/index.ts
@@ -114,6 +114,8 @@ var config_default = {
 
 // cli/src/lib/commander.ts
 import { Command } from "commander";
+import path from "path";
+import fs2 from "fs";
 var program = new Command();
 program.name(config_default.name).description(config_default.description).version(config_default.version);
 program.option("-d, --directory <path>", "Directory to scan for markdown files", ".");
@@ -130,6 +132,11 @@ if (options.interactive || options.directory === void 0) {
   });
   options.directory = res.trim();
 }
+options.directory = path.resolve(options.directory);
+fs2.existsSync(options.directory) || (() => {
+  console.error("Directory does not exist: " + options.directory);
+  process.exit(1);
+})();
 
 // cli/src/core/index.ts
 import { readdirSync } from "fs";
@@ -143,7 +150,7 @@ var constants_default = {
 var STATIC_TEMP_CONTENT_PREFIX = constants_default.STATIC_TEMP_CONTENT_PREFIX;
 async function readConfig(filepath) {
   try {
-    const data = JSON.parse(await fs2.readFile(filepath, "utf-8"));
+    const data = JSON.parse(await fs3.readFile(filepath, "utf-8"));
     return data;
   } catch (err) {
     Logger.log(
@@ -166,7 +173,7 @@ async function parseSmmIgnore(filePath) {
       return ignored;
     };
     var shouldIgnore2 = shouldIgnore3;
-    const raw = await fs2.readFile(filePath, "utf8");
+    const raw = await fs3.readFile(filePath, "utf8");
     const rules = raw.split(/\r?\n/).map((line) => line.trim()).filter((line) => line !== "" && !line.startsWith("#")).map((line) => {
       const negated = line.startsWith("!");
       const pattern = negated ? line.slice(1) : line;
@@ -185,11 +192,11 @@ async function parseSmmIgnore(filePath) {
   }
 }
 async function getMarkdownFiles(baseUrl, pairChildren) {
-  const files = await fs2.readdir(baseUrl, { withFileTypes: true });
+  const files = await fs3.readdir(baseUrl, { withFileTypes: true });
   const routeTree = pairChildren || [];
   const promises = [];
   for (const file of files) {
-    const filePath = path.join(baseUrl, file.name);
+    const filePath = path2.join(baseUrl, file.name);
     if (shouldIgnore(filePath.slice(options.directory.length)) || filePath.slice(options.directory.length) === finalConfig.publicPath)
       continue;
     if (file.isDirectory()) {
@@ -247,16 +254,16 @@ function getPath(filepath) {
   return slugify(transformedPath).split("/").filter((s) => !(s.startsWith("(") && s.endsWith(")"))).join("/") || "/";
 }
 async function parseMD(filepath) {
-  const path4 = getPath(filepath);
+  const path5 = getPath(filepath);
   return {
-    path: path4,
-    content: mdParser.render(await fs2.readFile(filepath, "utf-8"))
+    path: path5,
+    content: mdParser.render(await fs3.readFile(filepath, "utf-8"))
   };
 }
 async function generateHtml(distDir, routeContent) {
   try {
-    let htmlTemplate = await fs2.readFile(
-      path.join(import.meta.dirname, "..", "index.html"),
+    let htmlTemplate = await fs3.readFile(
+      path2.join(import.meta.dirname, "..", "index.html"),
       "utf-8"
     );
     const commentStart = htmlTemplate.indexOf("<!--");
@@ -268,20 +275,20 @@ async function generateHtml(distDir, routeContent) {
       ""
     );
     if (distDir) {
-      const files = readdirSync(path.join(distDir, "assets"));
+      const files = readdirSync(path2.join(distDir, "assets"));
       const cssFile = files.find((file) => file.endsWith(".css"));
       const jsFile = files.find((file) => file.endsWith(".js"));
-      const prefix = distDir.slice(path.join(import.meta.dirname, options.directory).length);
+      const prefix = distDir.slice(path2.join(import.meta.dirname, options.directory).length);
       htmlTemplate = htmlTemplate.replace(`<script type="module" src="/src/main.tsx"></script>`, "");
       if (cssFile && jsFile) {
         htmlTemplate = htmlTemplate.replace(
           "{{distAssets}}",
-          `<link rel="stylesheet" href="${path.join(
+          `<link rel="stylesheet" href="${path2.join(
             prefix,
             "assets",
             cssFile
           )}" />
-             <script type="module" src="${path.join(
+             <script type="module" src="${path2.join(
             prefix,
             "assets",
             jsFile
@@ -315,19 +322,19 @@ async function buildDistRoutesFromRouteTree(routeTree, groupedRoutes, distPath,
         prefix
       );
     } else {
-      const distRoutePath = path.join(distPath, prefix, node.pathSegment.replace("/", "")) + (node.pathSegment === "" ? "/index.html" : ".html");
-      await fs2.mkdir(path.dirname(distRoutePath), { recursive: true });
+      const distRoutePath = path2.join(distPath, prefix, node.pathSegment.replace("/", "")) + (node.pathSegment === "" ? "/index.html" : ".html");
+      await fs3.mkdir(path2.dirname(distRoutePath), { recursive: true });
       const html = await generateHtml(
         distPath,
-        groupedRoutes[path.posix.join(prefix, node.pathSegment)]?.[0]?.content
+        groupedRoutes[path2.posix.join(prefix, node.pathSegment)]?.[0]?.content
       );
-      await fs2.writeFile(distRoutePath, html, "utf-8");
+      await fs3.writeFile(distRoutePath, html, "utf-8");
       if (node.children) {
         await buildDistRoutesFromRouteTree(
           node.children,
           groupedRoutes,
           distPath,
-          path.join(prefix, node.pathSegment)
+          path2.join(prefix, node.pathSegment)
         );
       }
     }
@@ -362,11 +369,11 @@ import MarkdownItFootNote from "markdown-it-footnote";
 import MarkdownItTasks from "markdown-it-task-lists";
 import loadLanguages from "prismjs/components/index.js";
 var { shouldIgnore } = await parseSmmIgnore(
-  path2.join(options.directory, config_default.defaultIgnorePath)
+  path3.join(options.directory, config_default.defaultIgnorePath)
 );
 var finalConfig = {
   ...smm_config_default,
-  ...await readConfig(path2.join(options.directory, config_default.defaultConfigPath))
+  ...await readConfig(path3.join(options.directory, config_default.defaultConfigPath))
 };
 var md = new MarkdownIt({
   ...finalConfig.markdownItOptions,
@@ -383,10 +390,10 @@ var mdParser = md;
 
 // cli/src/core/build.ts
 import { cp, readdir as readdir2, rm, writeFile } from "fs/promises";
-import path3, { resolve } from "path";
+import path4, { resolve } from "path";
 import { fileURLToPath } from "url";
 import { build as viteBuild } from "vite";
-import { mkdirSync } from "fs";
+import { mkdirSync, existsSync } from "fs";
 var DIST_DIRNAME = finalConfig.outDir || "dist";
 var WEB_DIRNAME = "web";
 var PUBLIC_DIRNAME = "public";
@@ -398,7 +405,7 @@ async function build(options2) {
   const parsePromises = [];
   Logger.log("Processing routes...");
   for (const file of makeRoutesOfNestedPathsRaw(routeTree)) {
-    parsePromises.push(parseMD(path3.join(options2.directory, file)));
+    parsePromises.push(parseMD(path4.join(options2.directory, file)));
   }
   cleanNestedPaths(routeTree);
   const groupedRoutes = Object.groupBy(
@@ -406,7 +413,13 @@ async function build(options2) {
     (route) => route.path
   );
   const routes = makeRoutesOfNestedPaths(routeTree).reduce(
-    (acc, pth) => [...acc, ...(groupedRoutes[pth] ?? []).map((r) => ({ ...r, path: path3.join(finalConfig.baseRoute || "/", r.path) }))],
+    (acc, pth) => [
+      ...acc,
+      ...(groupedRoutes[pth] ?? []).map((r) => ({
+        ...r,
+        path: path4.join(finalConfig.baseRoute || "/", r.path)
+      }))
+    ],
     []
   );
   const out = {
@@ -429,37 +442,41 @@ async function build(options2) {
   routes.forEach((o) => {
     Logger.log(o.path);
   });
-  const __dirname = path3.dirname(fileURLToPath(import.meta.url));
-  const webDir = path3.join(__dirname, "..", WEB_DIRNAME);
-  const distDir = path3.join(webDir, DIST_DIRNAME);
-  mkdirSync(path3.join(webDir, "src", ".generated"), { recursive: true });
+  const __dirname = path4.dirname(fileURLToPath(import.meta.url));
+  const webDir = path4.join(__dirname, "..", WEB_DIRNAME);
+  const distDir = path4.join(webDir, DIST_DIRNAME);
+  mkdirSync(path4.join(webDir, "src", ".generated"), { recursive: true });
   await writeFile(
-    path3.join(webDir, "src", ".generated", "output.json"),
+    path4.join(webDir, "src", ".generated", "output.json"),
     JSON.stringify(out)
   );
   await writeFile(
-    path3.join(webDir, "src", ".generated", "paths.json"),
+    path4.join(webDir, "src", ".generated", "paths.json"),
     JSON.stringify(routeTree)
   );
   Logger.log("\nParsed MDs");
-  await writeFile(path3.join(webDir, "index.html"), await generateHtml());
+  await writeFile(path4.join(webDir, "index.html"), await generateHtml());
   Logger.log("Generated HTML from template");
   if (!skipBuild) {
-    const entries = await readdir2(path3.join(webDir, PUBLIC_DIRNAME));
-    for (const entry of entries) {
-      await rm(path3.join(webDir, PUBLIC_DIRNAME, entry), {
-        recursive: true,
-        force: true
-      });
+    if (existsSync(path4.join(webDir, PUBLIC_DIRNAME))) {
+      const entries = await readdir2(path4.join(webDir, PUBLIC_DIRNAME));
+      for (const entry of entries) {
+        await rm(path4.join(webDir, PUBLIC_DIRNAME, entry), {
+          recursive: true,
+          force: true
+        });
+      }
+    } else {
+      mkdirSync(path4.join(webDir, PUBLIC_DIRNAME));
     }
     if (finalConfig.publicPath) {
       if (await FileOrDirectoryExists(
-        path3.join(options2.directory, finalConfig.publicPath)
+        path4.join(options2.directory, finalConfig.publicPath)
       )) {
         Logger.log(`Copying public assets from ${finalConfig.publicPath}...`);
         await cp(
-          path3.join(options2.directory, finalConfig.publicPath),
-          path3.join(webDir, PUBLIC_DIRNAME),
+          path4.join(options2.directory, finalConfig.publicPath),
+          path4.join(webDir, PUBLIC_DIRNAME),
           { recursive: true }
         );
       } else {
@@ -471,7 +488,7 @@ async function build(options2) {
       configFile: resolve(webDir, "vite.config.ts")
     });
     await buildDistRoutesFromRouteTree(routeTree, groupedRoutes, distDir);
-    const targetDist = path3.join(options2.directory, DIST_DIRNAME);
+    const targetDist = path4.join(options2.directory, DIST_DIRNAME);
     await rm(targetDist, { recursive: true }).catch(() => {
     });
     Logger.log("Built the app, copying results...");

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "serve-my-md",
-  "version": "1.1.7",
+  "version": "1.1.9",
   "type": "module",
   "description": "Generate beautiful SEO-friendly static websites from Markdown files.",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/AshishAntil07/serve-my-md.git"
   },
-  "homepage": "https://ashishantil.dev/serve-my-md",
+  "homepage": "https://serve-my-md.ashishantil.dev",
   "author": "AshishAntil07 <ashishantil.antil07@gmail.com>",
   "license": "MIT",
   "keywords": [