host-mdx 2.3.1 → 2.4.1

package/README.md

@@ -1,4 +1,4 @@
-# host-mdx
+# 🌐 host-mdx
 
 [![Version](https://img.shields.io/npm/v/host-mdx.svg)](https://www.npmjs.com/package/host-mdx)\
 A cli tool to create and serve a static html website from a given mdx directory
@@ -50,15 +50,16 @@ hostMdx.start();
 
 ### Additional:
 
-You can add a file by the name `.hostmdxignore` at the root of your project to filter out which files/folders to skip while generating html
+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 also add a file by the name `host-mdx.js` at the root of your input folder as a config file (Look at the example below for all available options)
+> 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 package added requires complete restart otherwise changes will not reflect due to [this bug](https://github.com/nodejs/node/issues/49442)
+> 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)
 
 <br/>
 
@@ -82,9 +83,9 @@ Input Directory:
 
 ```
 my-website-template/
+├─ .hostmdxignore
 ├─ 404.mdx
 ├─ index.mdx
-├─ .hostmdxignore
 ├─ host-mdx.js
 ├─ about/
 │  ├─ index.mdx
@@ -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:
@@ -124,31 +127,42 @@ export async function onHostStarted(inputPath, outputPath, port) {
 export async function onHostEnded(inputPath, outputPath, port) {
    console.log("onHostEnded");
 }
-export async function onSiteCreateStart(inputPath, outputPath) {
+export async function onSiteCreateStart(inputPath, outputPath, isSoftReload) {
    console.log("onSiteCreateStart");
 }
-export async function onSiteCreateEnd(inputPath, outputPath, wasInterrupted) {
+export async function onSiteCreateEnd(inputPath, outputPath, isSoftReload, wasInterrupted) {
    console.log("onSiteCreateEnd");
 }
-export async function onFileCreateStart(inputFilePath, outputFilePath, inFilePath, outFilePath) {
-   console.log("onFileCreateStart");
+export async function onFileChangeStart(inputPath, outputPath, inFilePath, outFilePath, toBeDeleted) {
+   console.log("onFileChangeStart");
 }
-export async function onFileCreateEnd(inputFilePath, outputFilePath, inFilePath, outFilePath, result) {
+export async function onFileChangeEnd(inputPath, outputPath, inFilePath, outFilePath, wasDeleted, result) {
    // `result = undefined` if file is not .mdx
    // `result.html` contains stringified HTML
    // `result.exports` contains exports from mdx
-   console.log("onFileCreateEnd");
+   console.log("onFileChangeEnd");
 }
-export async function toIgnore(inputPath, outputPath, path) {
-   const isGOutputStream = /\.goutputstream-\w+$/.test(path);
+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){
-   // Modify code ...
+   // Wrapper example
+   code = `import Content from "${inFilePath}"; import { Wrapper } from "utils.jsx";\n\n<Wrapper><Content /></Wrapper>`
    return code;
 }
 export async function modGlobalArgs(inputPath, outputPath, globalArgs){
@@ -156,7 +170,20 @@ export async function modGlobalArgs(inputPath, outputPath, globalArgs){
    return globalArgs;
 }
 export async function modBundleMDXSettings(inputPath, outputPath, settings) {
-   // Modify settings ...
+   // Example for adding '@' root alias
+   var oldBuildOptions = settings.esbuildOptions;
+   settings.esbuildOptions = (options) => {
+      options = oldBuildOptions(options)
+      options.logLevel = 'error';
+      options.alias = {
+         ...options.alias,
+         '@': inputPath
+      };
+
+      return options;
+   }
+
+
    return settings;
 }
 export async function modRebuildPaths(inputPath, outputPath, rebuildPaths) {

package/cli.js

@@ -41,7 +41,7 @@ ${VERBOSE_FLAG}, ${VERBOSE_SHORT_FLAG}             Shows additional log messages
 function getInputPathFromArgs(rawArgs) {
     let inputPath = rawArgs.find(val => val.startsWith(INPUT_PATH_FLAG));
     let inputPathProvided = inputPath !== undefined;
-    inputPath = inputPathProvided ? inputPath.split('=')?.[1] : "";
+    inputPath = inputPathProvided ? inputPath.split('=')?.[1] : process.cwd();
     return inputPath !== "" ? path.resolve(inputPath) : inputPath;  // To ensure input path is absolute
 }
 function getOutputPathFromArgs(rawArgs) {
@@ -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,16 +183,22 @@ export async function main() {
 
     // Watch for key press
     listenForKey(
-        async () => await hostMdx?.recreateSite(),
-        async () => await hostMdx?.recreateSite(true),
+        async () => {
+            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

@@ -0,0 +1,346 @@
+import fs from "fs";
+import path from "path";
+import resolve from 'resolve';
+import precinct from 'precinct';
+import * as mdx from '@mdx-js/mdx';
+
+
+// Properties
+const DEPENDENTS_KEY = "dependents";
+const DEPENDENCIES_KEY = "dependencies";
+
+
+// Methods
+export async function crawlDir(dir, ignoreCheck = async (p) => false) {
+
+    // Make sure dir is absolute
+    dir = path.resolve(dir);
+
+
+    // Iterate through all files in dir
+    let results = [];
+    const list = fs.readdirSync(dir);
+    for (let targetPath of list) {
+
+        // get absolute path
+        const absPath = path.join(dir, targetPath);
+
+
+        // Skip if to ignore
+        if (await ignoreCheck(absPath)) {
+            continue;
+        }
+
+
+        // If directory, Recurse into it
+        const stat = fs.statSync(absPath);
+        if (stat && stat.isDirectory()) {
+            results = results.concat(await crawlDir(absPath, ignoreCheck));
+            continue;
+        }
+
+
+        // If file, Add to list
+        results.push(absPath);
+    }
+
+    return results;
+}
+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 = targetPath === alias;
+        const isSubPath = targetPath.startsWith(`${alias}${path.sep}`) || targetPath.startsWith(`${alias}/`);
+
+        if (isExact || isSubPath) {
+            targetPath = targetPath.replace(alias, aliasPath);
+            targetPath = path.normalize(targetPath);
+            break;
+        }
+    }
+
+    return targetPath;
+}
+export function ensureRelativePath(rootPath, filePath) {
+    const absoluteTarget = path.resolve(rootPath, filePath);
+    const absoluteRoot = path.resolve(rootPath);
+    return path.relative(absoluteRoot, absoluteTarget);
+}
+export async function calcDependencies(filePath, aliases = {}) {
+
+    // Return if given path is in node_modules
+    const absolutePath = path.resolve(filePath);
+    if (absolutePath.split(path.sep).includes('node_modules')) {
+        return new Set();
+    }
+
+
+    // Compile mdx if passed
+    let foundImports = [];
+    if (absolutePath.endsWith('.mdx')) {
+        let content = fs.readFileSync(absolutePath, 'utf8');
+        const compiled = await mdx.compile(content);
+        content = String(compiled?.value ?? "");
+        foundImports = precinct(content);
+    }
+    else {
+        foundImports = precinct.paperwork(absolutePath);
+    }
+
+
+    // Get & iterate through all imports
+    let filteredImports = [];
+    for (let i of foundImports) {
+
+        // Resolve aliases
+        i = resolveAlias(i, aliases);
+
+
+        // Skip if not a local file
+        const isLocal = i.startsWith('.') || i.startsWith('/');
+        if (!isLocal) {
+            continue;
+        }
+
+
+        // Resolve the found import
+        let resolvedPath = "";
+        try {
+            resolvedPath = resolve.sync(i, { basedir: path.dirname(absolutePath) }); // extensions: ['.js', '.jsx', '.mdx', '.json', '.tsx', '.ts']
+        }
+        catch (err) {
+            continue;
+        }
+
+
+        // Skip if the resolved path is within node_modules
+        if (resolvedPath.split(path.sep).includes('node_modules')) {
+            continue;
+        }
+
+
+        // Add path as a dependency
+        filteredImports.push(resolvedPath);
+    }
+
+
+    return new Set(filteredImports);
+}
+
+
+// Classes
+export class DependencyGraph {
+
+    // Private Properties
+    #graph = {};  // Format { "path/to/file" : { dependents: Set(...), dependencies : Set(...) }, ... }
+    #aliases = {};  // Format { '@' : "path/to/dir" }
+    #rootFolder = "";
+    #ignoreCheck = async (checkPath) => false;
+
+
+    // Public Methods
+    getGraph() {
+        return structuredClone(this.#graph);
+    }
+    async createGraph(newRootFolder, newIgnoreCheck = async (checkPath) => false) {
+        this.#graph = {};
+        this.#rootFolder = path.resolve(newRootFolder);
+        this.#ignoreCheck = newIgnoreCheck;
+
+
+        // Get all files inside directory
+        const allFiles = await crawlDir(this.#rootFolder, this.#ignoreCheck);
+
+
+        // Assign all dependencies
+        for (const file of allFiles) {
+            await this.addEntry(file);
+        }
+    }
+    async addEntry(filePath) {
+
+        // Get relative path
+        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 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));
+        });
+
+
+        // Add dependencies
+        this.#graph[relFilePath][DEPENDENCIES_KEY] = relDependencies;
+
+
+        // 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() };
+            }
+
+            this.#graph[dep][DEPENDENTS_KEY].add(relFilePath);
+        });
+    }
+    removeEntry(filePath) {
+
+        // Get relative path
+        let relFilePath = ensureRelativePath(this.#rootFolder, filePath);
+
+
+        // Return if entry does not exist
+        if (this.#graph[relFilePath] === undefined) {
+            return;
+        }
+
+
+        // Remove from dependents
+        const depList = this.#graph[relFilePath][DEPENDENCIES_KEY];
+        depList.forEach(dep => {
+            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);
+        });
+
+
+        // Remove entry
+        delete this.#graph[relFilePath];
+    }
+    hasEntry(filePath) {
+        let relFilePath = ensureRelativePath(this.#rootFolder, filePath);
+        return this.#graph[relFilePath] !== undefined;
+    }
+    getEntry(filePath) {
+        let relFilePath = ensureRelativePath(this.#rootFolder, filePath);
+        return this.#graph[relFilePath];
+    }
+    getDependencies(filePath) {
+        let relFilePath = ensureRelativePath(this.#rootFolder, filePath);
+        let absDeps = new Set();
+        let deps = this.#graph?.[relFilePath]?.[DEPENDENCIES_KEY] ?? new Set();
+        for (const dep of deps) {
+            absDeps.add(path.resolve(this.#rootFolder, dep));
+        }
+
+        return absDeps;
+    }
+    getDeepDependencies(filePath) {
+
+        // Get relative path
+        let relFilePath = ensureRelativePath(this.#rootFolder, filePath);
+
+
+        // Return empty set if entry does not exist
+        if (!this.hasEntry(relFilePath)) {
+            return new Set();
+        }
+
+
+        // Recursively get dependencies
+        const deepDeps = new Set();
+        const walk = (currentPath) => {
+
+            // Iterate over all dependencies
+            const deps = this.getDependencies(currentPath);
+            deps.forEach(dep => {
+                if (deepDeps.has(dep)) {
+                    return;
+                }
+
+                // Add to list and continue walking
+                deepDeps.add(dep);
+                walk(dep);
+            });
+        };
+        walk(relFilePath);
+
+        return deepDeps;
+    }
+    getDependents(filePath) {
+        let relFilePath = ensureRelativePath(this.#rootFolder, filePath);
+        let absDeps = new Set();
+        let deps = this.#graph?.[relFilePath]?.[DEPENDENTS_KEY] ?? new Set();
+        for (const dep of deps) {
+            absDeps.add(path.resolve(this.#rootFolder, dep));
+        }
+
+        return absDeps;
+    }
+    getDeepDependents(filePath) {
+
+        // Get relative path
+        let relFilePath = ensureRelativePath(this.#rootFolder, filePath);
+
+
+        // Return empty set if entry does not exist
+        if (!this.hasEntry(relFilePath)) {
+            return new Set();
+        }
+
+
+        // Recursively get dependents
+        const deepDependents = new Set();
+        const walk = (currentPath) => {
+
+            // Iterate over all dependents
+            const dependents = this.getDependents(currentPath);
+            dependents.forEach(dependent => {
+                if (deepDependents.has(dependent)) {
+                    return;
+                }
+
+                // Add to list and continue walking
+                deepDependents.add(dependent);
+                walk(dependent);
+            });
+        };
+        walk(relFilePath);
+
+
+        return deepDependents;
+    }
+    addAlias(symbol, toPath) {
+        this.#aliases[symbol] = toPath;
+    }
+    removeAlias(symbol) {
+        delete this.#aliases[symbol];
+    }
+    setAlias(newAliases) {
+        this.#aliases = newAliases;
+    }
+}

package/index.js

@@ -1,6 +1,7 @@
 import fs from "fs";
 import os from "os";
 import net from "net";
+import _ from 'lodash';
 import path from "path";
 import sirv from "sirv";
 import polka from "polka";
@@ -10,6 +11,7 @@ import chokidar from "chokidar";
 import { pathToFileURL } from "url";
 import { promises as fsp } from "fs";
 import { mdxToHtml } from "./mdx-to-html.js";
+import { DependencyGraph, crawlDir } from "./dependency-graph.js";
 
 
 // Enums
@@ -33,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
 `;
 
@@ -60,6 +71,27 @@ const LOG_TIME_OPTIONS = {
 const DEFAULT_CHOKIDAR_OPTIONS = {
     ignoreInitial: true
 };
+const DEFAULT_CONFIGS = {
+    // port: 3000,  // Intentionally kept commented out, otherwise interferes with auto port assigning DO NOT CHANGE
+    trackChanges: 0,
+    toBeVerbose: false,
+    concurrency: 1,
+    chokidarOptions: DEFAULT_CHOKIDAR_OPTIONS,
+    toIgnore: (inputPath, outputPath, targetPath) => {
+        const isGOutputStream = /\.goutputstream-\w+$/.test(targetPath);
+        if (isGOutputStream) {
+            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;
+    }
+};
 
 
 // Utility Methods
@@ -69,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 = "") {
@@ -79,11 +150,6 @@ async function createFile(filePath, fileContent = "") {
     await fsp.mkdir(fileLocation, { recursive: true });
     await fsp.writeFile(filePath, fileContent);
 }
-function crawlDir(dir) {
-    const absDir = path.resolve(dir);
-    let entries = fs.readdirSync(absDir, { recursive: true });
-    return entries.map(file => path.join(absDir, file));
-}
 async function startServer(hostDir, port, errorCallback) {  // Starts server at given port
 
     // Make sure host dir path is absolute
@@ -93,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
@@ -140,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
@@ -174,10 +252,10 @@ export async function setupConfigs(inputPath) {
     let configFilePath = path.join(inputPath, CONFIG_FILE_NAME);
     if (fs.existsSync(configFilePath)) {
         let cleanConfigFilePath = pathToFileURL(configFilePath).href
-        return await import(cleanConfigFilePath);
+        return { ...DEFAULT_CONFIGS, ...(await import(cleanConfigFilePath)) };
     }
 
-    return {};
+    return _.cloneDeep(DEFAULT_CONFIGS);
 }
 export function createTempDir() {
     // Create default temp html dir
@@ -191,24 +269,12 @@ 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 });
-    }
-}
-export async function getAvailablePort(startPort = DEFAULT_PORT, maxPort = MAX_PORT) {
-    let currentPort = startPort;
-    while (currentPort <= maxPort) {
-        if (await isPortAvailable(currentPort)) {
-            return currentPort;
-        }
-
-        currentPort++;
+        await fsp.rm(fullPath, { recursive: true, force: true });
     }
-
-    return -1;
 }
 export async function createSite(inputPath = "", outputPath = "", pathsToCreate = [], ignores = undefined, configs = undefined, interruptCondition = undefined) {
 
@@ -240,7 +306,7 @@ export async function createSite(inputPath = "", outputPath = "", pathsToCreate
 
     // Check if `inputPath` is inside `outputPath` (causing code wipeout)
     if (isPathInside(outputPath, inputPath)) {
-        throw `Input path "${inputPath}" cannot be inside or same as output path "${outputPath}"`;
+        throw new Error(`Input path "${inputPath}" cannot be inside or same as output path "${outputPath}"`);
     }
 
 
@@ -255,9 +321,10 @@ export async function createSite(inputPath = "", outputPath = "", pathsToCreate
 
 
     // Hard reload, clear output path & Get all paths from `inputPath`
-    if (pathsToCreate == null) {
-        emptyDir(outputPath)
-        pathsToCreate = crawlDir(inputPath);
+    let isHardReloading = pathsToCreate == null;
+    if (isHardReloading) {
+        await emptyDir(outputPath)
+        pathsToCreate = await crawlDir(inputPath);
     }
 
 
@@ -299,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;
         }
 
@@ -321,11 +388,11 @@ export async function createSite(inputPath = "", outputPath = "", pathsToCreate
 
 
     // Broadcast site creation started
-    log("Creating site...");
-    await configs?.onSiteCreateStart?.(inputPath, outputPath);
+    log(`Starting site creation at ${outputPath} ...`);
+    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 () => {
 
@@ -349,21 +416,23 @@ export async function createSite(inputPath = "", outputPath = "", pathsToCreate
         if (!pathExists) {
             let pathToDelete = isMdx ? absHtmlPath : absToOutput;
             log(`Deleting ${pathToDelete}`, !toBeVerbose);
+            await configs?.onFileChangeStart?.(inputPath, outputPath, currentPath, pathToDelete, true);
             await fsp.rm(pathToDelete, { recursive: true, force: true });
+            await configs?.onFileChangeEnd?.(inputPath, outputPath, currentPath, pathToDelete, true, undefined);
         }
         // Make corresponding directory
         else if (isDir) {
             log(`Creating ${currentPath} ---> ${absToOutput}`, !toBeVerbose);
-            await configs?.onFileCreateStart?.(inputPath, outputPath, currentPath, absToOutput);
+            await configs?.onFileChangeStart?.(inputPath, outputPath, currentPath, absToOutput, false);
             await fsp.mkdir(absToOutput, { recursive: true });
-            await configs?.onFileCreateEnd?.(inputPath, outputPath, currentPath, absToOutput, undefined);
+            await configs?.onFileChangeEnd?.(inputPath, outputPath, currentPath, absToOutput, false, undefined);
         }
         // Make html file from mdx
         else if (isMdx) {
 
             // Broadcast file creation started
             log(`Creating ${currentPath} ---> ${absHtmlPath}`, !toBeVerbose);
-            await configs?.onFileCreateStart?.(inputPath, outputPath, currentPath, absHtmlPath);
+            await configs?.onFileChangeStart?.(inputPath, outputPath, currentPath, absHtmlPath, false);
 
 
             // Intercept mdx code
@@ -382,22 +451,22 @@ export async function createSite(inputPath = "", outputPath = "", pathsToCreate
 
 
             // Broadcast file creation ended
-            await configs?.onFileCreateEnd?.(inputPath, outputPath, currentPath, absHtmlPath, result);
+            await configs?.onFileChangeEnd?.(inputPath, outputPath, currentPath, absHtmlPath, false, result);
         }
         // Copy paste file
         else {
-            log(`Creating ${currentPath} ---> ${absToOutput}`, !configs.toBeVerbose);
-            await configs?.onFileCreateStart?.(inputPath, outputPath, currentPath, absToOutput);
+            log(`Creating ${currentPath} ---> ${absToOutput}`, !toBeVerbose);
+            await configs?.onFileChangeStart?.(inputPath, outputPath, currentPath, absToOutput, false);
             await fsp.mkdir(path.dirname(absToOutput), { recursive: true });
             await fsp.copyFile(currentPath, absToOutput);
-            await configs?.onFileCreateEnd?.(inputPath, outputPath, currentPath, absToOutput, undefined);
+            await configs?.onFileChangeEnd?.(inputPath, outputPath, currentPath, absToOutput, false, undefined);
         }
     })));
 
 
     // Broadcast site creation ended
-    log(wasInterrupted ? `Site creation was interrupted!` : `Created site at ${outputPath}`);
-    await configs?.onSiteCreateEnd?.(inputPath, outputPath, wasInterrupted);
+    log(wasInterrupted ? `Site creation was interrupted!` : `Completed site creation at ${outputPath}`);
+    await configs?.onSiteCreateEnd?.(inputPath, outputPath, !isHardReloading, wasInterrupted);
 }
 
 
@@ -413,6 +482,8 @@ export class HostMdx {
     #app = null;
     #watcher = null;
     #ignores = null;
+    #excludes = null;
+    #depGraph = new DependencyGraph();
 
 
     // Constructors
@@ -424,36 +495,41 @@ export class HostMdx {
 
 
     // Private Methods
-    async #watchForChanges(event, somePath) {
+    async #watchForChanges(event, targetPath) {
 
-        // Return if out input path itself if passed
-        if (this.inputPath === somePath) {
+        // Skip reload if `toIgnore` gives null
+        let ignoreStat = await this.configs?.toIgnore?.(this.inputPath, this.outputPath, targetPath);
+        if (ignoreStat === null) {
             return;
         }
 
 
-        // Return if matches .ignore file
-        const relToInput = path.relative(this.inputPath, somePath);
-        if (this.#ignores.ignores(relToInput)) {
+        // 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;
         }
 
 
-        // Return if toIgnore() from configs
-        const toIgnore = await this.configs?.toIgnore?.(this.inputPath, this.outputPath, somePath);
-        if (toIgnore) {
-            return;
+        // Update dependency graph
+        if (event === "unlink") {
+            this.#depGraph.removeEntry(targetPath);
+        }
+        else {
+            this.#depGraph.addEntry(targetPath);
         }
 
 
         // Add changed path
-        this.#alteredPaths.push(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);
         }
     }
@@ -472,7 +548,7 @@ export class HostMdx {
         await this.stop();
 
 
-        // Asssign all
+        // Assign all
         this.#inputPathProvided = this.inputPath !== "";
         this.#outputPathProvided = this.outputPath !== "";
         this.inputPath = this.#inputPathProvided ? this.inputPath : process.cwd();
@@ -503,24 +579,36 @@ 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, path) => this.#watchForChanges(event, path));
+        // Broadcast hosting about to start
+        await this.configs?.onHostStarting?.(this.inputPath, this.outputPath, port);
 
 
         // Delete old files & Create site
         await this.recreateSite(true);
 
 
+        // Create dependency graph 
+        let defaultMdxSettings = { esbuildOptions: () => ({}) };
+        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 (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);
 
@@ -544,7 +632,7 @@ export class HostMdx {
         if (this.#siteCreationStatus == SiteCreationStatus.ONGOING) {
             log("Site creation already ongoing! Added to pending")
             this.#siteCreationStatus = SiteCreationStatus.PENDING_RECREATION;
-            this.#pendingHardSiteCreation = hardReload;
+            this.#pendingHardSiteCreation = this.#pendingHardSiteCreation || hardReload;
             return;
         }
 
@@ -554,12 +642,13 @@ export class HostMdx {
 
 
         // Actual site creation
+        let pathsToCreate = hardReload ? null : [...new Set(this.#alteredPaths)];
         try {
-            let pathsToCreate = hardReload ? null : [...this.#alteredPaths];
             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}`);
         }
 
@@ -568,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.3.1",
+  "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",
@@ -20,12 +20,14 @@
   "dependencies": {
     "chokidar": "^5.0.0",
     "ignore": "^7.0.5",
+    "lodash": "^4.17.23",
     "lowlight": "^3.3.0",
     "mdx-bundler": "^10.1.1",
     "p-limit": "^7.3.0",
     "polka": "^0.5.2",
     "preact": "^10.28.2",
     "preact-render-to-string": "^6.6.5",
+    "precinct": "^12.2.0",
     "rehype-highlight": "^7.0.2",
     "sirv": "^3.0.2"
   },