host-mdx 2.4.0 → 2.4.1

package/README.md

@@ -53,10 +53,11 @@ hostMdx.start();
 You can add `.hostmdxignore` at the root of your project to filter out which files/folders to skip while generating html
 (similar to [.gitignore](https://git-scm.com/docs/gitignore))
 
+> You can add `# [EXCLUDE]` comment on top of every path for behaviour similar to returning null in `toIgnore`
+
 You can also add `host-mdx.js` at the root of your project as an optional config file for more complex behaviour (Look at the example below for all available options)
 
 
-> **Note:**  
 > 1. Any config properties passed from npx or import e.g. `port`, `toBeVerbose`, `trackChanges`, etc will override `host-mdx.js` export values
 > 1. Any changes made to `host-mdx.js` or any new packages added require complete restart otherwise changes will not reflect due to [this bug](https://github.com/nodejs/node/issues/49442)
 
@@ -107,9 +108,11 @@ my-website-template/
 
 ```sh
 *.jsx
-blog/page2/
+# [EXCLUDE]
 static/temp.jpg
 !static/sample.jsx
+# [EXCLUDE]
+blog/page2/
 ```
 
 `host-mdx.js` file content:
@@ -140,11 +143,21 @@ export async function onFileChangeEnd(inputPath, outputPath, inFilePath, outFile
    console.log("onFileChangeEnd");
 }
 export async function toIgnore(inputPath, outputPath, targetPath) {
+   
+   // Return true = file not generated in output folder, 
+   // Return null = same as true but also prevents triggering reload
+   
    const isGOutputStream = /\.goutputstream-\w+$/.test(targetPath);
    if (isGOutputStream) {
-      return true;
+      return null; 
    }
-   
+
+   const ignoredDirs = new Set(['node_modules', '.git', '.github']);
+   const segments = targetPath.split(path.sep);
+   if (segments.some(segment => ignoredDirs.has(segment))) {
+      return null;
+   }
+
    return false;
 }
 export async function modMDXCode(inputPath, outputPath, inFilePath, outFilePath, code){
@@ -177,11 +190,6 @@ export async function modRebuildPaths(inputPath, outputPath, rebuildPaths) {
    // Modify rebuildPaths ...
    return rebuildPaths;
 }
-export async function canTriggerReload(inputPath, outputPath, targetPath) {
-   const ignoredDirs = new Set(['node_modules', '.git', '.github']);
-   const segments = targetPath.split(/[\\/]/);  // or targetPath.split(path.sep);
-   return !segments.some(segment => ignoredDirs.has(segment));
-}
 export const chokidarOptions = {
    awaitWriteFinish: true
 }

package/cli.js

@@ -56,8 +56,14 @@ function getPortFromArgs(rawArgs) {
     return portProvided ? Number(port.split('=')[1]) : undefined;
 }
 function getTrackChangesFromArgs(rawArgs) {
+
     // If flag not passed do not track changes
-    let trackChanges = rawArgs.find(val => (val.startsWith(TRACK_CHANGES_FLAG) || val.startsWith(TRACK_CHANGES_SHORT_FLAG)));
+    let trackChanges = rawArgs.find(val =>
+        val === TRACK_CHANGES_SHORT_FLAG ||
+        val.startsWith(`${TRACK_CHANGES_SHORT_FLAG}=`) ||
+        val === TRACK_CHANGES_FLAG ||
+        val.startsWith(`${TRACK_CHANGES_FLAG}=`)
+    );
     if (trackChanges == undefined) {
         return undefined;
     }
@@ -79,7 +85,8 @@ function getTrackChangesFromArgs(rawArgs) {
 function getConcurrencyFromArgs(rawArgs) {
     let concurrency = rawArgs.find(val => val.startsWith(CONCURRENCY_FLAG));
     let concurrencyProvided = concurrency !== undefined;
-    return concurrencyProvided ? Number(concurrency.split('=')[1]) : undefined;
+    const val = concurrencyProvided ? Number(concurrency.split('=')[1]) : undefined;
+    return Number.isInteger(val) && val >= 1 ? val : undefined;
 }
 function listenForKey(reloadCallback, hardReloadCallback, exitCallback) {
     readline.emitKeypressEvents(process.stdin);
@@ -176,19 +183,22 @@ export async function main() {
 
     // Watch for key press
     listenForKey(
-        async () => await hostMdx?.recreateSite(),
         async () => {
-            log("--- HARD RELOADING ---")
-            await hostMdx?.recreateSite(true)
+            log("--- RELOAD TRIGGERED ---");
+            await hostMdx?.recreateSite();
+        },
+        async () => {
+            log("--- HARD RELOAD TRIGGERED ---");
+            await hostMdx?.recreateSite(true);
         },
         cleanup
     );
 
 
     // Watch for quit
-    process.on("exit", cleanup);
     process.on("SIGINT", cleanup);
     process.on("SIGTERM", cleanup);
+    process.on("exit", () => { process.stdin.setRawMode(false) });
 
 
     // Log key press instructions

package/dependency-graph.js

@@ -20,10 +20,10 @@ export async function crawlDir(dir, ignoreCheck = async (p) => false) {
     // Iterate through all files in dir
     let results = [];
     const list = fs.readdirSync(dir);
-    for (let somePath of list) {
+    for (let targetPath of list) {
 
         // get absolute path
-        const absPath = path.join(dir, somePath);
+        const absPath = path.join(dir, targetPath);
 
 
         // Skip if to ignore
@@ -46,21 +46,21 @@ export async function crawlDir(dir, ignoreCheck = async (p) => false) {
 
     return results;
 }
-export function resolveAlias(somePath, aliases) {
+export function resolveAlias(targetPath, aliases) {
     for (const [alias, aliasPath] of Object.entries(aliases)) {
 
         // Check if import is the alias or starts with alias + system separator
-        const isExact = somePath === alias;
-        const isSubPath = somePath.startsWith(`${alias}${path.sep}`) || somePath.startsWith(`${alias}/`);
+        const isExact = targetPath === alias;
+        const isSubPath = targetPath.startsWith(`${alias}${path.sep}`) || targetPath.startsWith(`${alias}/`);
 
         if (isExact || isSubPath) {
-            somePath = somePath.replace(alias, aliasPath);
-            somePath = path.normalize(somePath);
+            targetPath = targetPath.replace(alias, aliasPath);
+            targetPath = path.normalize(targetPath);
             break;
         }
     }
 
-    return somePath;
+    return targetPath;
 }
 export function ensureRelativePath(rootPath, filePath) {
     const absoluteTarget = path.resolve(rootPath, filePath);
@@ -69,9 +69,9 @@ export function ensureRelativePath(rootPath, filePath) {
 }
 export async function calcDependencies(filePath, aliases = {}) {
 
-    // Return if given path has already been traversed or is a node_modules
+    // Return if given path is in node_modules
     const absolutePath = path.resolve(filePath);
-    if (absolutePath.includes('node_modules')) {
+    if (absolutePath.split(path.sep).includes('node_modules')) {
         return new Set();
     }
 
@@ -115,7 +115,7 @@ export async function calcDependencies(filePath, aliases = {}) {
 
 
         // Skip if the resolved path is within node_modules
-        if (resolvedPath.includes('node_modules')) {
+        if (resolvedPath.split(path.sep).includes('node_modules')) {
             continue;
         }
 
@@ -129,7 +129,7 @@ export async function calcDependencies(filePath, aliases = {}) {
 }
 
 
-// classes
+// Classes
 export class DependencyGraph {
 
     // Private Properties
@@ -164,36 +164,49 @@ export class DependencyGraph {
         let relFilePath = ensureRelativePath(this.#rootFolder, filePath);
 
 
+        // If did not exist previously create fresh
+        if (this.#graph?.[relFilePath] === undefined) {
+            this.#graph[relFilePath] = {
+                [DEPENDENCIES_KEY]: new Set(),
+                [DEPENDENTS_KEY]: new Set()
+            }
+        }
+
+
+        // Remove previous dependencies
+        const oldDeps = this.#graph[relFilePath][DEPENDENCIES_KEY];
+        oldDeps.forEach(dep => {
+            this.#graph?.[dep]?.[DEPENDENTS_KEY]?.delete(relFilePath);
+        });
+
+
+        // Intentionally not removing dependents since no way of knowing which files depend on `relFilePath` DO NOT CHANGE
+
+
         // Get all dependencies
-        const absFilePath = path.resolve(this.#rootFolder, relFilePath);
-        const dependencies = await calcDependencies(absFilePath, this.#aliases);
         const relDependencies = new Set();
+        const absFilePath = path.resolve(this.#rootFolder, relFilePath);
+        let dependencies;
+        try {
+            dependencies = await calcDependencies(absFilePath, this.#aliases);
+        }
+        catch (err) {
+            dependencies = new Set();
+        }
         dependencies.forEach(p => {
             relDependencies.add(path.relative(this.#rootFolder, p));
-        })
-
-
-        // Skip if no dependencies
-        if (dependencies.size === 0) {
-            return;
-        }
+        });
 
 
         // Add dependencies
-        this.#graph[relFilePath] = {
-            [DEPENDENCIES_KEY]: relDependencies,
-            [DEPENDENTS_KEY]: new Set()
-        };
+        this.#graph[relFilePath][DEPENDENCIES_KEY] = relDependencies;
 
 
-        // Add dependents
+        // Add to dependents
         const depList = this.#graph[relFilePath][DEPENDENCIES_KEY];
         depList.forEach(dep => {
-            if (this.#graph[dep] === undefined) {
-                this.#graph[dep] = {
-                    [DEPENDENCIES_KEY]: new Set(),
-                    [DEPENDENTS_KEY]: new Set()
-                }
+            if (this.#graph?.[dep] === undefined) {
+                this.#graph[dep] = { [DEPENDENCIES_KEY]: new Set(), [DEPENDENTS_KEY]: new Set() };
             }
 
             this.#graph[dep][DEPENDENTS_KEY].add(relFilePath);
@@ -214,11 +227,14 @@ export class DependencyGraph {
         // Remove from dependents
         const depList = this.#graph[relFilePath][DEPENDENCIES_KEY];
         depList.forEach(dep => {
-            if (this.#graph[dep] === undefined) {
-                return;
-            }
+            this.#graph?.[dep]?.[DEPENDENTS_KEY]?.delete(relFilePath);
+        });
+
 
-            this.#graph[dep][DEPENDENTS_KEY].delete(relFilePath);
+        // Remove from dependencies
+        const depOf = this.#graph[relFilePath][DEPENDENTS_KEY];
+        depOf.forEach(dependent => {
+            this.#graph[dependent]?.[DEPENDENCIES_KEY]?.delete(relFilePath);
         });
 
 
@@ -259,13 +275,8 @@ export class DependencyGraph {
         const deepDeps = new Set();
         const walk = (currentPath) => {
 
-            // Skip if not in graph
-            const deps = this.getDependencies(currentPath);
-            if (!deps) {
-                return;
-            }
-
             // Iterate over all dependencies
+            const deps = this.getDependencies(currentPath);
             deps.forEach(dep => {
                 if (deepDeps.has(dep)) {
                     return;
@@ -306,13 +317,8 @@ export class DependencyGraph {
         const deepDependents = new Set();
         const walk = (currentPath) => {
 
-            // Skip if not in graph
+            // Iterate over all dependents
             const dependents = this.getDependents(currentPath);
-            if (!dependents) {
-                return;
-            }
-
-            // Iterate over all dependencies
             dependents.forEach(dependent => {
                 if (deepDependents.has(dependent)) {
                     return;
@@ -324,7 +330,7 @@ export class DependencyGraph {
             });
         };
         walk(relFilePath);
-        
+
 
         return deepDependents;
     }

package/index.js

@@ -35,15 +35,24 @@ const FILE_404 = "404.html";
 const NOT_FOUND_404_MESSAGE = "404";
 const DEFAULT_PORT = 3000;
 const MAX_PORT = 4000;
+const EXCLUDE_HEADER = "# [EXCLUDE]";  // Case insensitive
 const TEMP_HTML_DIR = path.join(os.tmpdir(), `${APP_NAME}`);
 const DEFAULT_IGNORES = `
+${EXCLUDE_HEADER}
 ${IGNORE_FILE_NAME}
+${EXCLUDE_HEADER}
 ${CONFIG_FILE_NAME}
+${EXCLUDE_HEADER}
 node_modules
+${EXCLUDE_HEADER}
 package-lock.json
+${EXCLUDE_HEADER}
 package.json
+${EXCLUDE_HEADER}
 .git
+${EXCLUDE_HEADER}
 .github
+${EXCLUDE_HEADER}
 .gitignore
 `;
 
@@ -64,15 +73,23 @@ const DEFAULT_CHOKIDAR_OPTIONS = {
 };
 const DEFAULT_CONFIGS = {
     // port: 3000,  // Intentionally kept commented out, otherwise interferes with auto port assigning DO NOT CHANGE
-    chokidarOptions: DEFAULT_CHOKIDAR_OPTIONS,
     trackChanges: 0,
     toBeVerbose: false,
     concurrency: 1,
     chokidarOptions: DEFAULT_CHOKIDAR_OPTIONS,
-    canTriggerReload: (inputPath, outputpath, p) => {
+    toIgnore: (inputPath, outputPath, targetPath) => {
+        const isGOutputStream = /\.goutputstream-\w+$/.test(targetPath);
+        if (isGOutputStream) {
+            return null;
+        }
+
         const ignoredDirs = new Set(['node_modules', '.git', '.github']);
-        const segments = p.split(path.sep);
-        return !segments.some(segment => ignoredDirs.has(segment));
+        const segments = targetPath.split(path.sep);
+        if (segments.some(segment => ignoredDirs.has(segment))) {
+            return null;
+        }
+
+        return false;
     }
 };
 
@@ -84,9 +101,48 @@ function getIgnore(ignoreFilePath) {
     if (fs.existsSync(ignoreFilePath)) {
         ignoreContent += `\n${fs.readFileSync(ignoreFilePath, "utf8")}`;
     }
-
     ig.add(ignoreContent);
+    return ig;
+}
+function getExclude(ignoreFilePath) {
+
+    // Read .ignore file
+    const ig = ignore();
+    let rawContent = DEFAULT_IGNORES;
+    if (fs.existsSync(ignoreFilePath)) {
+        rawContent += "\n" + fs.readFileSync(ignoreFilePath, "utf8");
+    }
+
+
+    // Only get lines which have "# [EXCLUDE]" comment on top
+    let filteredLines = [];
+    let hasExclude = false;
+    const lines = rawContent.split(/\r?\n/);
+    const excludeComment = EXCLUDE_HEADER.toLowerCase();
+    for (const line of lines) {
+        const trimmed = line.trim();
+
+        // Check for the header tag
+        if (trimmed.toLowerCase() === excludeComment) {
+            hasExclude = true;
+            continue;
+        }
+
+        // Reset if empty line found 
+        if (trimmed === "") {
+            hasExclude = false;
+            continue;
+        }
+
+        // Add line if has exclude otherwise continue
+        if (hasExclude) {
+            filteredLines.push(trimmed);
+        }
+    }
+
 
+    // Add to ignore
+    ig.add(filteredLines.join("\n"));
     return ig;
 }
 async function createFile(filePath, fileContent = "") {
@@ -103,10 +159,10 @@ async function startServer(hostDir, port, errorCallback) {  // Starts server at
     // Start Server
     const assets = sirv(hostDir, { dev: true });
     const newApp = polka({
-        onNoMatch: (req, res) => {  // Send 404 file if found else not found message
-            const errorFile = path.join(hostDir, FILE_404);
-            if (fs.existsSync(errorFile)) {
-                const content = fs.readFileSync(errorFile);
+        onNoMatch: async (req, res) => {  // Send 404 file if found else not found message
+            const file404 = path.join(hostDir, FILE_404);
+            if (fs.existsSync(file404)) {
+                const content = await fsp.readFile(file404);
                 res.writeHead(404, {
                     'Content-Type': 'text/html',
                     'Content-Length': content.length
@@ -150,6 +206,18 @@ async function isPortAvailable(port) {
         server.listen(port);
     });
 }
+async function getAvailablePort(startPort = DEFAULT_PORT, maxPort = MAX_PORT) {
+    let currentPort = startPort;
+    while (currentPort <= maxPort) {
+        if (await isPortAvailable(currentPort)) {
+            return currentPort;
+        }
+
+        currentPort++;
+    }
+
+    return -1;
+}
 export function log(msg, toSkip = false) {
     if (toSkip) {  // Useful for verbose check
         return
@@ -201,25 +269,13 @@ export function createTempDir() {
 
     return fs.mkdtempSync(path.join(TEMP_HTML_DIR, `html-${timestamp}-`));
 }
-export function emptyDir(dirPath) {
-    const files = fs.readdirSync(dirPath);
+export async function emptyDir(dirPath) {
+    const files = await fsp.readdir(dirPath);
     for (const file of files) {
         const fullPath = path.join(dirPath, file);
-        fs.rmSync(fullPath, { recursive: true, force: true });
+        await fsp.rm(fullPath, { recursive: true, force: true });
     }
 }
-export async function getAvailablePort(startPort = DEFAULT_PORT, maxPort = MAX_PORT) {
-    let currentPort = startPort;
-    while (currentPort <= maxPort) {
-        if (await isPortAvailable(currentPort)) {
-            return currentPort;
-        }
-
-        currentPort++;
-    }
-
-    return -1;
-}
 export async function createSite(inputPath = "", outputPath = "", pathsToCreate = [], ignores = undefined, configs = undefined, interruptCondition = undefined) {
 
     // Check `inputPath`
@@ -267,7 +323,7 @@ export async function createSite(inputPath = "", outputPath = "", pathsToCreate
     // Hard reload, clear output path & Get all paths from `inputPath`
     let isHardReloading = pathsToCreate == null;
     if (isHardReloading) {
-        emptyDir(outputPath)
+        await emptyDir(outputPath)
         pathsToCreate = await crawlDir(inputPath);
     }
 
@@ -310,8 +366,8 @@ export async function createSite(inputPath = "", outputPath = "", pathsToCreate
 
 
         // Filter based on toIgnore() in configs
-        const toIgnore = await configs?.toIgnore?.(inputPath, outputPath, currentPath);
-        if (toIgnore) {
+        const toBeIgnored = await configs?.toIgnore?.(inputPath, outputPath, currentPath);
+        if (toBeIgnored === true || toBeIgnored === null) {
             return false;
         }
 
@@ -336,7 +392,7 @@ export async function createSite(inputPath = "", outputPath = "", pathsToCreate
     await configs?.onSiteCreateStart?.(inputPath, outputPath, !isHardReloading);
 
 
-    // Iterate through all folders & files
+    // Iterate & build all files
     let wasInterrupted = false;
     await Promise.all(pathsToCreate.map((currentPath) => limit(async () => {
 
@@ -360,9 +416,9 @@ export async function createSite(inputPath = "", outputPath = "", pathsToCreate
         if (!pathExists) {
             let pathToDelete = isMdx ? absHtmlPath : absToOutput;
             log(`Deleting ${pathToDelete}`, !toBeVerbose);
-            await configs?.onFileChangeStart?.(inputPath, outputPath, pathToDelete, absToOutput, true);
+            await configs?.onFileChangeStart?.(inputPath, outputPath, currentPath, pathToDelete, true);
             await fsp.rm(pathToDelete, { recursive: true, force: true });
-            await configs?.onFileChangeEnd?.(inputPath, outputPath, pathToDelete, absToOutput, true, undefined);
+            await configs?.onFileChangeEnd?.(inputPath, outputPath, currentPath, pathToDelete, true, undefined);
         }
         // Make corresponding directory
         else if (isDir) {
@@ -426,6 +482,7 @@ export class HostMdx {
     #app = null;
     #watcher = null;
     #ignores = null;
+    #excludes = null;
     #depGraph = new DependencyGraph();
 
 
@@ -438,26 +495,41 @@ export class HostMdx {
 
 
     // Private Methods
-    async #watchForChanges(event, somePath) {
+    async #watchForChanges(event, targetPath) {
+
+        // Skip reload if `toIgnore` gives null
+        let ignoreStat = await this.configs?.toIgnore?.(this.inputPath, this.outputPath, targetPath);
+        if (ignoreStat === null) {
+            return;
+        }
+
+
+        // Skip reload if has # [EXCLUDE] header in .ignore file
+        let relTargetPath = path.relative(this.inputPath, targetPath);
+        let excludeStat = this.#excludes?.ignores(relTargetPath);
+        if (excludeStat) {
+            return;
+        }
+
 
         // Update dependency graph
         if (event === "unlink") {
-            this.#depGraph.removeEntry(somePath);
+            this.#depGraph.removeEntry(targetPath);
         }
         else {
-            this.#depGraph.addEntry(somePath);
+            this.#depGraph.addEntry(targetPath);
         }
 
 
         // Add changed path
-        let dependencies = this.#depGraph.getDeepDependents(somePath);
-        this.#alteredPaths = this.#alteredPaths.concat([...dependencies, somePath]);
+        let dependencies = this.#depGraph.getDeepDependents(targetPath);
+        this.#alteredPaths = this.#alteredPaths.concat([...dependencies, targetPath]);
 
 
         // Reflect changes immediately
         if (this.configs?.trackChanges !== undefined && this.configs?.trackChanges != TrackChanges.NONE) {
             let toHardReload = this.configs?.trackChanges == TrackChanges.HARD;
-            log(`${toHardReload ? "Hard recreating" : "Recreating"} site, Event: ${event}, Path: ${somePath}`, !this.configs?.toBeVerbose);
+            log(`${toHardReload ? "Hard recreating" : "Recreating"} site, Event: ${event}, Path: ${targetPath}`, !this.configs?.toBeVerbose);
             await this.recreateSite(toHardReload);
         }
     }
@@ -507,13 +579,12 @@ export class HostMdx {
         this.#ignores = getIgnore(ignoreFilePath);
 
 
-        // Broadcast hosting about to start
-        await this.configs?.onHostStarting?.(this.inputPath, this.outputPath, port);
+        // Get excludes
+        this.#excludes = getExclude(ignoreFilePath);
 
 
-        // Watch for changes
-        let chokidarOptions = { ...DEFAULT_CHOKIDAR_OPTIONS, ...(this.configs?.chokidarOptions ?? {}) };
-        this.#watcher = chokidar.watch(this.inputPath, chokidarOptions).on("all", (event, targetPath) => this.#watchForChanges(event, targetPath));
+        // Broadcast hosting about to start
+        await this.configs?.onHostStarting?.(this.inputPath, this.outputPath, port);
 
 
         // Delete old files & Create site
@@ -525,14 +596,19 @@ export class HostMdx {
         let modMdxSettings = await this.configs?.modBundleMDXSettings?.(this.inputPath, this.outputPath, defaultMdxSettings);
         let aliases = modMdxSettings?.esbuildOptions?.({})?.alias ?? {};
         this.#depGraph.setAlias(aliases);
-        await this.#depGraph.createGraph(this.inputPath, async (p) => !(await this.configs?.canTriggerReload?.(this.inputPath, this.outputPath, p)));
+        await this.#depGraph.createGraph(this.inputPath, async (targetPath) => (await this.configs?.toIgnore?.(this.inputPath, this.outputPath, targetPath)) === null || this.#excludes?.ignores(path.relative(this.inputPath, targetPath)));
 
 
         // Start server to host site
-        this.#app = await startServer(this.outputPath, port, (e) => { log(`Failed to start server: ${e.message}`); throw e; });
+        this.#app = await startServer(this.outputPath, port, (e) => { log(`Failed to start server: ${e.message}`); });
         this.#app?.server?.on("close", async () => { await this.configs?.onHostEnded?.(this.inputPath, this.outputPath, port); });
 
 
+        // Watch for changes
+        let chokidarOptions = { ...DEFAULT_CHOKIDAR_OPTIONS, ...(this.configs?.chokidarOptions ?? {}) };
+        this.#watcher = chokidar.watch(this.inputPath, chokidarOptions).on("all", async (event, targetPath) => { await this.#watchForChanges(event, targetPath) });
+
+
         // Broadcast hosting started
         await this.configs?.onHostStarted?.(this.inputPath, this.outputPath, port);
 
@@ -566,12 +642,13 @@ export class HostMdx {
 
 
         // Actual site creation
+        let pathsToCreate = hardReload ? null : [...new Set(this.#alteredPaths)];
         try {
-            let pathsToCreate = hardReload ? null : [...this.#alteredPaths];
-            await createSite(this.inputPath, this.outputPath, pathsToCreate, this.#ignores, this.configs, () => this.#siteCreationStatus != SiteCreationStatus.ONGOING);
             this.#alteredPaths = [];
+            await createSite(this.inputPath, this.outputPath, pathsToCreate, this.#ignores, this.configs, () => this.#siteCreationStatus != SiteCreationStatus.ONGOING);
         }
         catch (err) {
+            this.#alteredPaths = hardReload ? this.#alteredPaths : [...new Set([...pathsToCreate, ...this.#alteredPaths])];  // Readd incase of failure
             log(`Failed to create site!\n${err.stack}`);
         }
 
@@ -580,13 +657,22 @@ export class HostMdx {
         const wasPending = this.#siteCreationStatus === SiteCreationStatus.PENDING_RECREATION;
         this.#siteCreationStatus = SiteCreationStatus.NONE;
         if (wasPending) {
-            await this.recreateSite(this.#pendingHardSiteCreation);
+            log("Recreating previously pending")
+            const wasHard = this.#pendingHardSiteCreation;
+            this.#pendingHardSiteCreation = false;
+            await this.recreateSite(wasHard);
         }
     }
     async abortSiteCreation() {
         this.#siteCreationStatus = SiteCreationStatus.NONE;
+        this.#pendingHardSiteCreation = false;
     }
     async stop() {
+
+        // Abort site creation if ongoing
+        await this.abortSiteCreation()
+
+
         // Remove temp dir html path
         if (!this.#outputPathProvided && fs.existsSync(this.outputPath)) {
             fs.rmSync(this.outputPath, { recursive: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "host-mdx",
-  "version": "2.4.0",
+  "version": "2.4.1",
   "description": "A cli tool to create and serve a static html website from a given mdx directory",
   "main": "index.js",
   "type": "module",