host-mdx 2.2.1 → 2.3.0

package/index.js

@@ -1,26 +1,39 @@
-#!/usr/bin/env node
-
-import fs from 'fs';
-import os from 'os';
-import net from 'net';
-import path from 'path'
-import sirv from 'sirv';
-import polka from 'polka';
-import ignore from 'ignore';
-import chokidar from 'chokidar';
-import * as readline from 'readline';
-import { pathToFileURL } from 'url';
-import { mdxToHtml } from './mdx-to-html.js';
+import fs from "fs";
+import os from "os";
+import net from "net";
+import path from "path";
+import sirv from "sirv";
+import polka from "polka";
+import ignore from "ignore";
+import pLimit from 'p-limit';
+import chokidar from "chokidar";
+import { pathToFileURL } from "url";
+import { promises as fsp } from "fs";
+import { mdxToHtml } from "./mdx-to-html.js";
+
+
+// Enums
+export const TrackChanges = Object.freeze({
+    NONE: 0,
+    SOFT: 1,
+    HARD: 2
+});
+export const SiteCreationStatus = Object.freeze({
+    NONE: 0,
+    PENDING_RECREATION: 1,
+    ONGOING: 2,
+});
 
 
 // To-Set Properties
 const APP_NAME = "host-mdx";
-const DEFAULT_PORT = 3000;
-const MAX_PORT = 3002;
 const IGNORE_FILE_NAME = ".hostmdxignore";
 const CONFIG_FILE_NAME = "host-mdx.js";
 const FILE_404 = "404.html";
 const NOT_FOUND_404_MESSAGE = "404";
+const DEFAULT_PORT = 3000;
+const MAX_PORT = 4000;
+const TEMP_HTML_DIR = path.join(os.tmpdir(), `${APP_NAME}`);
 const DEFAULT_IGNORES = `
 ${IGNORE_FILE_NAME}
 ${CONFIG_FILE_NAME}
@@ -33,63 +46,138 @@ package.json
 `;
 
 
-// Flags
-const CREATE_FLAG = "--create-only";
-const CREATE_SHORT_FLAG = "-c";
-const HELP_FLAG = "--help";
-const HELP_SHORT_FLAG = "-h";
-const INPUT_PATH_FLAG = "--input-path";
-const OUTPUT_PATH_FLAG = "--output-path";
-const PORT_FLAG = "--port";
-const VERBOSE_FLAG = "--verbose";
-const VERBOSE_SHORT_FLAG = "-v";
-const TRACK_CHANGES_FLAG = "--track-changes";
-const TRACK_CHANGES_SHORT_FLAG = "-t";
-
-
-// Messages & Errors
-const HELP_MESSAGE = `Usage: host-mdx [options]
-
-Options:
-${CREATE_FLAG}, ${CREATE_SHORT_FLAG}     Only create the html website from mdx does not host
-${HELP_FLAG}, ${HELP_SHORT_FLAG}            Shows all available options
-${INPUT_PATH_FLAG}=...      The path at which all mdx files are stored
-${OUTPUT_PATH_FLAG}=...     The path to which all html files will be generated
-${PORT_FLAG}=...            Localhost port number on which to host 
-${TRACK_CHANGES_FLAG}, ${TRACK_CHANGES_SHORT_FLAG}   Tracks any changes made & auto reloads
-${VERBOSE_FLAG}, ${VERBOSE_SHORT_FLAG}         Shows additional log messages
-`;
-
-
-// Private Properties
-let isCreatingSite = false;  // Prevents site from being recreated if creation is already ongoing
-let isCreateSitePending = false  // Keeps track if files have been modified and site needs to be recreated
-let isVerbose = false;
-let configs;
-let app;
-const TEMP_HTML_DIR = path.join(os.tmpdir(), `${APP_NAME}`);
-const TIME_OPTIONS = {
-    year: 'numeric',
-    month: 'long',
-    day: 'numeric',
-    hour: 'numeric',
-    minute: 'numeric',
-    second: 'numeric',
+// Properties
+const LOG_TIME_OPTIONS = {
+    year: "numeric",
+    month: "long",
+    day: "numeric",
+    hour: "numeric",
+    minute: "numeric",
+    second: "numeric",
     hour12: false,
     fractionalSecondDigits: 3
 };
+const DEFAULT_CHOKIDAR_OPTIONS = {
+    ignoreInitial: true
+};
 
 
 // Utility Methods
-function log(msg, checkVerbose = false) {
-    if (checkVerbose && !isVerbose) {
+function getIgnore(ignoreFilePath) {
+    const ig = ignore();
+    let ignoreContent = DEFAULT_IGNORES;
+    if (fs.existsSync(ignoreFilePath)) {
+        ignoreContent += `\n${fs.readFileSync(ignoreFilePath, "utf8")}`;
+    }
+
+    ig.add(ignoreContent);
+
+    return ig;
+}
+async function createFile(filePath, fileContent = "") {
+    let fileLocation = path.dirname(filePath)
+    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 setupConfigs(configFilePath) {
+    if (fs.existsSync(configFilePath)) {
+        let cleanConfigFilePath = pathToFileURL(configFilePath).href
+        return await import(cleanConfigFilePath);
+    }
+
+    return {};
+}
+async function startServer(hostDir, port, errorCallback) {  // Starts server at given port
+
+    // Make sure host dir path is absolute
+    hostDir = path.resolve(hostDir);
+
+
+    // 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);
+                res.writeHead(404, {
+                    'Content-Type': 'text/html',
+                    'Content-Length': content.length
+                });
+                res.end(content);
+            } else {
+                res.statusCode = 404;
+                res.end(NOT_FOUND_404_MESSAGE);
+            }
+        }
+    }).use((req, res, next) => {  // Add trailing slash
+        if (1 < req.path.length && !req.path.endsWith('/') && !path.extname(req.path)) {
+            res.writeHead(301, { Location: req.path + '/' });
+            return res.end();
+        }
+        next();
+    }).use(assets)
+
+
+    // Start listening
+    newApp.listen(port)
+    newApp.server.on("error", errorCallback);
+
+
+    return newApp
+}
+async function isPortAvailable(port) {
+    const server = net.createServer();
+    server.unref();
+
+    return new Promise((resolve) => {
+        server.once("error", () => {
+            server.close();
+            resolve(false);
+        });
+
+        server.once("listening", () => {
+            server.close(() => resolve(true));
+        });
+
+        server.listen(port);
+    });
+}
+export function log(msg, toSkip = false) {
+    if (toSkip) {  // Useful for verbose check
         return
     }
 
-    let timestamp = new Date().toLocaleString(undefined, TIME_OPTIONS)
+    let timestamp = new Date().toLocaleString(undefined, LOG_TIME_OPTIONS)
     console.log(`[${APP_NAME} ${timestamp}] ${msg}`)
 }
-function createTempDir() {
+export function isPathInside(parentPath, childPath) {
+
+    // Make sure both are absolute paths
+    parentPath = parentPath !== "" ? path.resolve(parentPath) : "";
+    childPath = childPath !== "" ? path.resolve(childPath) : "";
+
+
+    // Check if parent & child are same
+    if (parentPath === childPath) {
+        return true;
+    }
+
+
+    const relation = path.relative(parentPath, childPath);
+    return Boolean(
+        relation &&
+        relation !== '..' &&
+        !relation.startsWith(`..${path.sep}`) &&
+        relation !== path.resolve(childPath)
+    );
+}
+export function createTempDir() {
     // Create default temp html dir
     fs.mkdirSync(TEMP_HTML_DIR, { recursive: true });
 
@@ -101,440 +189,401 @@ function createTempDir() {
 
     return fs.mkdtempSync(path.join(TEMP_HTML_DIR, `html-${timestamp}-`));
 }
-function getIgnore(ignoreFilePath) {
-    const ig = ignore();
-    let ignoreContent = DEFAULT_IGNORES
-
-    if (fs.existsSync(ignoreFilePath)) {
-        ignoreContent += `\n${fs.readFileSync(ignoreFilePath, "utf8")}`
+export function emptyDir(dirPath) {
+    const files = fs.readdirSync(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;
+        }
 
-    ig.add(ignoreContent);
+        currentPort++;
+    }
 
-    return ig
+    return -1;
 }
-function createFile(filePath, fileContent = "") {
+export async function createSite(inputPath = "", outputPath = "", pathsToCreate = [], ignores = undefined, configs = undefined, interruptCondition = undefined) {
 
-    // Check if path for file exists
-    let fileLocation = path.dirname(filePath)
-    if (!fs.existsSync(fileLocation)) {
-        fs.mkdirSync(fileLocation, { recursive: true });
-    }
+    // Check `inputPath`
+    inputPath = inputPath !== "" ? inputPath : process.cwd();
 
 
-    // Create file
-    fs.writeFileSync(filePath, fileContent);
-}
-async function createSite(inputPath, outputPath) {
-    // Exit if already creating
-    if (isCreatingSite) {
-        log("Site creation already ongoing! Added to pending")
-        isCreateSitePending = true
-        return
-    }
+    // Check `outputPath`
+    outputPath = outputPath !== "" ? outputPath : createTempDir();
 
 
-    // Set creating status to ongoing
-    isCreatingSite = true
-    isCreateSitePending = false
+    // Get input path
+    if (!fs.existsSync(inputPath) || !fs.lstatSync(inputPath)?.isDirectory()) {
+        throw new Error(`Invalid input path "${inputPath}"`);
+    }
 
 
-    // Broadcast site creation started
-    log("Creating site...")
-    await configs?.onSiteCreateStart?.(inputPath, outputPath)
+    // Get output path exists & is a directory
+    if (!fs.existsSync(outputPath) || !fs.lstatSync(outputPath).isDirectory()) {
+        throw new Error(`Invalid output path "${outputPath}"`);
+    }
 
 
-    // Remove html folder if it already exists
-    if (fs.existsSync(outputPath)) {
-        fs.rmSync(outputPath, { recursive: true, force: true });
+    // Check if `outputPath` is inside `inputPath` (causing infinite loop)
+    if (isPathInside(inputPath, outputPath)) {
+        throw new Error(`Output path "${outputPath}" cannot be inside or same as input path "${inputPath}"`);
     }
 
 
-    // Setup ignore
-    let ignoreFilePath = path.join(inputPath, IGNORE_FILE_NAME)
-    let ig = getIgnore(ignoreFilePath)
+    // 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}"`;
+    }
 
 
-    // Iterate through all folders & files
-    const stack = [inputPath];
-    while (stack.length > 0 && !isCreateSitePending) {
-        // Continue if path does not exist
-        const currentPath = stack.pop()
-        if (!fs.existsSync(currentPath)) {
-            continue;
-        }
+    // Check for verbose
+    const toBeVerbose = configs?.toBeVerbose === true;
 
 
-        // Get essentials
-        const relToInput = path.relative(inputPath, currentPath)
-        const toIgnore = inputPath != currentPath && ig.ignores(relToInput)
-        const absToOutput = path.join(outputPath, relToInput)
-        const isDir = fs.statSync(currentPath).isDirectory()
-        const isMdx = !isDir && currentPath.endsWith(".mdx")
+    // Check `interruptCondition` provided
+    if (typeof interruptCondition !== 'function') {
+        interruptCondition = async () => false;
+    }
 
 
-        // Skip if to ignore this path
-        if (toIgnore) {
-            continue
-        }
+    // Hard reload, clear output path & Get all paths from `inputPath`
+    if (pathsToCreate == null) {
+        emptyDir(outputPath)
+        pathsToCreate = crawlDir(inputPath);
+    }
 
 
-        // Make dir
-        if (isDir) {
-            log(`${currentPath} ---> ${absToOutput}`, true)
-            await configs?.onFileCreateStart?.(inputPath, outputPath, currentPath, absToOutput)
-            fs.mkdirSync(absToOutput, { recursive: true });
-            await configs?.onFileCreateEnd?.(inputPath, outputPath, currentPath, absToOutput, undefined)
-        }
-        // Make html file from mdx
-        else if (!isDir && isMdx) {
+    // Setup .ignore file 
+    if (ignores === undefined) {
+        let ignoreFilePath = path.join(inputPath, IGNORE_FILE_NAME);
+        ignores = getIgnore(ignoreFilePath)
+    }
 
-            // Broadcast file creation started
-            let absHtmlPath = path.format({ ...path.parse(absToOutput), base: '', ext: '.html' })
-            log(`${currentPath} ---> ${absHtmlPath}`, true)
-            await configs?.onFileCreateStart?.(inputPath, outputPath, currentPath, absHtmlPath)
 
+    // Setup configs
+    if (configs === undefined) {
+        let configFilePath = path.join(inputPath, `./${CONFIG_FILE_NAME}`);
+        let doesConfigFileExists = fs.existsSync(configFilePath);
+        log(`Importing config file ${configFilePath}`, !doesConfigFileExists);
+        configs = await setupConfigs(configFilePath);
+    }
 
-            // Intercept mdx code
-            let mdxCode = fs.readFileSync(currentPath, 'utf8');
-            if (typeof configs?.modMDXCode === 'function') {
-                log(`Modifying mdx code of ${currentPath}`, true);
-                mdxCode = await configs?.modMDXCode(inputPath, outputPath, currentPath, absHtmlPath, mdxCode);
-            }
-            
-            
-            // convert mdx code into html & paste into file
-            let parentDir = path.dirname(currentPath);
-            let globalArgs = {
-                hostmdxCwd: parentDir,
-                hostmdxInputPath: inputPath,
-                hostmdxOutputPath: outputPath
-            };
-            globalArgs = await configs?.modGlobalArgs?.(inputPath, outputPath, globalArgs) ?? globalArgs;
-            let result = await mdxToHtml(mdxCode, parentDir, globalArgs, async (settings) => { return await configs?.modBundleMDXSettings?.(inputPath, outputPath, settings) ?? settings });
-            let htmlCode = result.html;
-            createFile(absHtmlPath, `<!DOCTYPE html>${htmlCode}`);
 
+    // Setup concurrency limit
+    const concurrency = configs?.concurrency ?? 1;
+    log(`Setting concurrency to ${concurrency}`, !toBeVerbose);
+    const limit = pLimit(concurrency);
 
-            // Broadcast file creation ended
-            await configs?.onFileCreateEnd?.(inputPath, outputPath, currentPath, absHtmlPath, result)
-        }
-        // Copy paste file
-        else if (!isDir) {
-            log(`${currentPath} ---> ${absToOutput}`, true)
-            await configs?.onFileCreateStart?.(inputPath, outputPath, currentPath, absToOutput)
-            fs.copyFileSync(currentPath, absToOutput)
-            await configs?.onFileCreateEnd?.(inputPath, outputPath, currentPath, absToOutput, undefined)
+
+    // Filter out paths based on ignore
+    const filterResults = await Promise.all(pathsToCreate.map(async (currentPath) => limit(async () => {
+        // Filter out input path itself if passed
+        if (inputPath === currentPath) {
+            return false;
         }
 
 
-        // Skip if current path is a file or a directory to ignore
-        if (!isDir) {
-            continue
+        // Filter based on .ignore file
+        const relToInput = path.relative(inputPath, currentPath);
+        if (ignores.ignores(relToInput)) {
+            return false;
         }
 
 
-        // Add to stack if current path is dir
-        const files = fs.readdirSync(currentPath);
-        for (const file of files) {
-            stack.push(path.join(currentPath, file));
+        // Filter based on toIgnore() in configs
+        const toIgnore = await configs?.toIgnore?.(inputPath, outputPath, currentPath);
+        if (toIgnore) {
+            return false;
         }
-    }
-
 
-    // Unset creating status & Notify
-    isCreatingSite = false;
+        return true;
+    })));
+    pathsToCreate = pathsToCreate.filter((_, index) => filterResults[index]);
 
 
-    // Broadcast site creation ended
-    if (isCreateSitePending) {
-        log(`Restarting site creation...`)
-    }
-    else {
-        log(`Created site at ${outputPath}`)
+    // Return if no paths remaining to create after filtering for ignores
+    if (pathsToCreate.length === 0) {
+        log(`Skipping site creation since no paths to create`, !toBeVerbose);
+        return;
     }
-    await configs?.onSiteCreateEnd?.(inputPath, outputPath, isCreateSitePending)
 
 
-    // Reinvoke creation
-    if (isCreateSitePending) {
-        await createSite(inputPath, outputPath);
-    }
-}
-async function isPortAvailable(port) {
-    const server = net.createServer();
-    server.unref();
+    // Modify rebuild paths based on configs
+    pathsToCreate = await configs?.modRebuildPaths?.(inputPath, outputPath, pathsToCreate) ?? pathsToCreate;
 
-    return new Promise((resolve) => {
-        server.once('error', () => {
-            server.close();
-            resolve(false);
-        });
 
-        server.once('listening', () => {
-            server.close(() => resolve(true));
-        });
+    // Broadcast site creation started
+    log("Creating site...");
+    await configs?.onSiteCreateStart?.(inputPath, outputPath);
 
-        server.listen(port);
-    });
-}
-async function getAvailablePort(startPort, maxPort) {
-    let currentPort = startPort;
-    while (currentPort <= maxPort) {
-        if (await isPortAvailable(currentPort)) {
-            return currentPort;
+
+    // Iterate through all folders & files
+    let wasInterrupted = false;
+    await Promise.all(pathsToCreate.map((currentPath) => limit(async () => {
+
+        // Check for interruption & return
+        wasInterrupted = wasInterrupted || await interruptCondition(inputPath, outputPath, currentPath);
+        if (wasInterrupted) {
+            return;
         }
 
-        currentPort++;
-    }
 
-    return -1;
-}
-function stripTrailingSep(thePath) {
-    if (thePath[thePath.length - 1] === path.sep) {
-        return thePath.slice(0, -1);
-    }
-    return thePath;
-}
-function isSubPath(potentialParent, thePath) {
-    // For inside-directory checking, we want to allow trailing slashes, so normalize.
-    thePath = stripTrailingSep(thePath);
-    potentialParent = stripTrailingSep(potentialParent);
+        // Essentials
+        const pathExists = fs.existsSync(currentPath);
+        const relToInput = path.relative(inputPath, currentPath);
+        const absToOutput = path.join(outputPath, relToInput);
+        const isDir = pathExists ? fs.statSync(currentPath).isDirectory() : false;
+        const isMdx = currentPath.endsWith(".mdx");
+        const absHtmlPath = isMdx ? path.format({ ...path.parse(absToOutput), base: "", ext: ".html" }) : "";
 
 
-    // Node treats only Windows as case-insensitive in its path module; we follow those conventions.
-    if (process.platform === "win32") {
-        thePath = thePath.toLowerCase();
-        potentialParent = potentialParent.toLowerCase();
-    }
+        // Delete if path does not exist
+        if (!pathExists) {
+            let pathToDelete = isMdx ? absHtmlPath : absToOutput;
+            log(`Deleting ${pathToDelete}`, !toBeVerbose);
+            await fsp.rm(pathToDelete, { recursive: true, force: true });
+        }
+        // Make corresponding directory
+        else if (isDir) {
+            log(`Creating ${currentPath} ---> ${absToOutput}`, !toBeVerbose);
+            await configs?.onFileCreateStart?.(inputPath, outputPath, currentPath, absToOutput);
+            await fsp.mkdir(absToOutput, { recursive: true });
+            await configs?.onFileCreateEnd?.(inputPath, outputPath, currentPath, absToOutput, 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);
 
-    return thePath.lastIndexOf(potentialParent, 0) === 0 &&
-        (
-            thePath[potentialParent.length] === path.sep ||
-            thePath[potentialParent.length] === undefined
-        );
-}
-async function filterArgs(rawArgs) {
-    // Assign to create
-    let toCreateOnly = rawArgs.includes(CREATE_FLAG) || rawArgs.includes(CREATE_SHORT_FLAG)
 
+            // Intercept mdx code
+            let mdxCode = await fsp.readFile(currentPath, "utf8");
+            log(`Modifying mdx code of ${currentPath}`, !toBeVerbose || !configs?.modMDXCode);
+            mdxCode = await configs?.modMDXCode?.(inputPath, outputPath, currentPath, absHtmlPath, mdxCode) ?? mdxCode;
 
-    // Assign input path
-    let inputPath = rawArgs.find(val => val.startsWith(INPUT_PATH_FLAG));
-    let inputPathProvided = inputPath !== undefined;
-    inputPath = inputPathProvided ? inputPath.split('=')[1] : process.cwd();
 
+            // convert mdx code into html & paste into file
+            let parentDir = path.dirname(currentPath);
+            let globalArgs = { hostmdxCwd: parentDir, hostmdxInputPath: inputPath, hostmdxOutputPath: outputPath };
+            globalArgs = await configs?.modGlobalArgs?.(inputPath, outputPath, globalArgs) ?? globalArgs;
+            let result = await mdxToHtml(mdxCode, parentDir, globalArgs, async (settings) => { return await configs?.modBundleMDXSettings?.(inputPath, outputPath, settings) ?? settings });
+            let htmlCode = result.html;
+            await createFile(absHtmlPath, `<!DOCTYPE html>${htmlCode}`);
 
-    // Check input path
-    if (!fs.existsSync(inputPath) || !fs.lstatSync(inputPath).isDirectory()) {
-        log(`Invalid input path "${inputPath}"`)
-        return null;
-    }
-    else {
-        inputPath = inputPath !== "" ? path.resolve(inputPath) : inputPath;  // To ensure input path is absolute
-    }
 
+            // Broadcast file creation ended
+            await configs?.onFileCreateEnd?.(inputPath, outputPath, currentPath, absHtmlPath, result);
+        }
+        // Copy paste file
+        else {
+            log(`Creating ${currentPath} ---> ${absToOutput}`, !configs.toBeVerbose);
+            await configs?.onFileCreateStart?.(inputPath, outputPath, currentPath, absToOutput);
+            await fsp.mkdir(path.dirname(absToOutput), { recursive: true });
+            await fsp.copyFile(currentPath, absToOutput);
+            await configs?.onFileCreateEnd?.(inputPath, outputPath, currentPath, absToOutput, undefined);
+        }
+    })));
 
-    // Assign output path
-    let outputPath = rawArgs.find(val => val.startsWith(OUTPUT_PATH_FLAG));
-    let outputPathProvided = outputPath !== undefined;
-    outputPath = outputPathProvided ? outputPath.split('=')[1] : createTempDir();
 
+    // Broadcast site creation ended
+    log(wasInterrupted ? `Site creation was interrupted!` : `Created site at ${outputPath}`);
+    await configs?.onSiteCreateEnd?.(inputPath, outputPath, wasInterrupted);
+}
 
-    // Check output path
-    if (!fs.existsSync(outputPath) || !fs.lstatSync(outputPath).isDirectory()) {
-        log(`Invalid output path "${outputPath}"`)
-        return null;
-    }
-    else {
-        outputPath = outputPath !== "" ? path.resolve(outputPath) : outputPath;  // To ensure output path is absolute
-    }
 
+// Classes
+export class HostMdx {
 
-    // Check if output path is inside input path (causing infinite loop)
-    if (isSubPath(inputPath, outputPath)) {
-        log(`Output path "${outputPath}" cannot be inside or same as input path "${inputPath}"`);
-        return null;
+    // Private Properties
+    #inputPathProvided = true;
+    #outputPathProvided = true;
+    #siteCreationStatus = SiteCreationStatus.NONE;
+    #pendingHardSiteCreation = false;
+    #alteredPaths = [];
+    #app = null;
+    #watcher = null;
+    #ignores = null;
+
+
+    // Constructors
+    constructor(inputPath = "", outputPath = "", configs = {}) {
+        this.inputPath = inputPath;
+        this.outputPath = outputPath;
+        this.configs = configs;
     }
 
 
-    // Assign port
-    let port = rawArgs.find(val => val.startsWith(PORT_FLAG));
-    let portProvided = port !== undefined;
-    port = portProvided ? Number(port.split('=')[1]) : (await getAvailablePort(DEFAULT_PORT, MAX_PORT));
+    // Private Methods
+    async #watchForChanges(event, somePath) {
 
+        // Return if out input path itself if passed
+        if (this.inputPath === somePath) {
+            return;
+        }
 
-    // Check port
-    if (port === -1) {
-        log(`Could not find any available ports between ${DEFAULT_PORT} to ${MAX_PORT}, Try manually passing ${PORT_FLAG}=... flag`);
-        return null;
-    }
-    else if (!Number.isInteger(port)) {
-        log(`Invalid port`)
-        return null;
-    }
 
+        // Return if matches .ignore file
+        const relToInput = path.relative(this.inputPath, somePath);
+        if (this.#ignores.ignores(relToInput)) {
+            return;
+        }
 
-    // Assign tracking changes
-    let toTrackChanges = rawArgs.includes(TRACK_CHANGES_FLAG) || rawArgs.includes(TRACK_CHANGES_SHORT_FLAG);
 
+        // Return if toIgnore() from configs
+        const toIgnore = await this.configs?.toIgnore?.(this.inputPath, this.outputPath, somePath);
+        if (toIgnore) {
+            return;
+        }
 
-    return { toCreateOnly, inputPath, inputPathProvided, outputPath, outputPathProvided, toTrackChanges, port, portProvided, };
-}
 
+        // Add changed path
+        this.#alteredPaths.push(somePath);
 
-// Main Methods
-async function createSiteSafe(...args) {
 
-    let success = true;
-    try {
-        await createSite(...args);
+        // 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);
+            await this.recreateSite(toHardReload);
+        }
     }
-    catch (err) {
-        success = false;
-        isCreatingSite = false;
-        log(`Failed to create site!\n${err.stack}`);
+
+
+    // Getter Methods
+    getSiteCreationStatus() {
+        return this.#siteCreationStatus;
     }
 
-    return success;
-}
-async function listenForKey(createSiteCallback) {
 
-    readline.emitKeypressEvents(process.stdin);
+    // Public Methods
+    async start() {
 
-    if (process.stdin.isTTY) {
-        process.stdin.setRawMode(true);
-    }
+        // Make sure hosting has stopped before starting again
+        await this.stop();
 
-    process.stdin.on('keypress', (chunk, key) => {
-        if (key && key.name == 'r') {
-            createSiteCallback();
-        }
-        else if (key && key.sequence == '\x03') {
-            app?.server?.close((e) => { process.exit() })
-        }
-    });
-}
-async function watchForChanges(pathTowatch, callback) {
-    chokidar.watch(pathTowatch, {
-        ignoreInitial: true
-    }).on('all', callback);
-}
-async function startServer(htmlDir, port) {  // Starts server at given port
 
-    // Broadcast server starting
-    await configs?.onHostStart?.(port)
+        // Asssign all
+        this.#inputPathProvided = this.inputPath !== "";
+        this.#outputPathProvided = this.outputPath !== "";
+        this.inputPath = this.#inputPathProvided ? this.inputPath : process.cwd();
+        this.outputPath = this.#outputPathProvided ? this.outputPath : createTempDir();
 
 
-    // Start Server
-    const assets = sirv(htmlDir, { dev: true });
-    const newApp = polka({
-        onNoMatch: (req, res) => {
-            // Set status code to 404
-            res.statusCode = 404;
+        // Get configs
+        let configFilePath = path.join(this.inputPath, `./${CONFIG_FILE_NAME}`);
+        let doesConfigFileExists = fs.existsSync(configFilePath);
+        log(`Importing config file ${configFilePath}`, !doesConfigFileExists);
+        this.configs = { ...(await setupConfigs(configFilePath)), ...this.configs };
 
 
-            // Send 404 file if found else not found message
-            const errorFile = path.join(htmlDir, FILE_404);
-            if (fs.existsSync(errorFile)) {
-                res.setHeader('Content-Type', 'text/html');
-                res.end(fs.readFileSync(errorFile));
-            } else {
-                res.end(NOT_FOUND_404_MESSAGE);
-            }
+        // Get port
+        let port = this.configs?.port ?? await getAvailablePort();
+        if (port === -1) {
+            log(`Could not find any available ports`);
+            return false;
         }
-    }).use((req, res, next) => {  // Add trailing slash
-        if (1 < req.path.length && !req.path.endsWith('/') && !path.extname(req.path)) {
-            res.writeHead(301, { Location: req.path + '/' });
-            return res.end();
+        else if (!Number.isInteger(port)) {
+            log(`Invalid port`)
+            return false;
         }
-        next();
-    }).use(assets)
 
 
-    // Start listening
-    newApp.listen(port)
-    newApp.server.on("close", async () => { await configs?.onHostEnd?.(port) });
-    newApp.server.on("error", (e) => { log(`Failed to start server: ${e.message}`); throw e; });
-    log(`Server listening at ${port} ... (Press 'r' to manually reload, Press 'Ctrl+c' to exit)`)
+        // Get ignores
+        let ignoreFilePath = path.join(this.inputPath, IGNORE_FILE_NAME);
+        this.#ignores = getIgnore(ignoreFilePath);
 
 
-    return newApp
-}
-async function Main() {
+        // Broadcast hosting about to start
+        await this.configs?.onHostStarting?.(this.inputPath, this.outputPath, port);
 
-    // Get all arguments
-    const rawArgs = process.argv.slice(2);
 
+        // 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));
 
-    // Check if verbose
-    isVerbose = rawArgs.includes(VERBOSE_FLAG) || rawArgs.includes(VERBOSE_SHORT_FLAG);
 
+        // Delete old files & Create site
+        await this.recreateSite(true);
 
-    // Check if asked for help
-    if (rawArgs.includes(HELP_FLAG) || rawArgs.includes(HELP_SHORT_FLAG)) {
-        console.log(HELP_MESSAGE)
-        return;
-    }
 
+        // Start server to host site
+        this.#app = await startServer(this.outputPath, port, (e) => { log(`Failed to start server: ${e.message}`); throw e; });
+        this.#app?.server?.on("close", async () => { await this.configs?.onHostEnded?.(this.inputPath, this.outputPath, port); });
 
-    // Filter arguments
-    let args = await filterArgs(rawArgs);
-    if (args === null) {
-        return;
-    }
 
+        // Broadcast hosting started
+        await this.configs?.onHostStarted?.(this.inputPath, this.outputPath, port);
 
-    // Get config
-    let configFilePath = path.join(args.inputPath, `./${CONFIG_FILE_NAME}`)
-    if (fs.existsSync(configFilePath)) {
-        log(`Importing config file ${CONFIG_FILE_NAME}`);
-        configs = await import(pathToFileURL(configFilePath).href);
-    }
 
+        // Load as started
+        log(`Server listening at ${port} ...`);
 
-    // Create site from mdx & return if only needed to create site
-    let wasCreated = await createSiteSafe(args.inputPath, args.outputPath);
-    if (args.toCreateOnly) {
-        process.exitCode = !wasCreated ? 1 : 0;  // Exit with error code if not created successfully
-        return;
+
+        return true;
     }
+    async recreateSite(hardReload = false) {
 
+        // Return if no changes made and no requested hard reload
+        if (this.#alteredPaths.length == 0 && !hardReload) {
+            log(`No changes made which require reloading, Try hard reloading instead`)
+            return;
+        }
 
-    // Watch for key presses
-    listenForKey(() => createSiteSafe(args.inputPath, args.outputPath));
 
+        // Return & add to pending if already creating
+        if (this.#siteCreationStatus == SiteCreationStatus.ONGOING) {
+            log("Site creation already ongoing! Added to pending")
+            this.#siteCreationStatus = SiteCreationStatus.PENDING_RECREATION;
+            this.#pendingHardSiteCreation = hardReload;
+            return;
+        }
 
-    // Watch for changes
-    if (args.toTrackChanges) {
-        watchForChanges(args.inputPath, async (event, path) => {
-            if (typeof configs?.toTriggerRecreate === 'function' && !(await configs?.toTriggerRecreate(event, path))) {
-                return;
-            }
 
-            log(`Recreating site, Event: ${event}, Path: ${path}`, true)
-            createSiteSafe(args.inputPath, args.outputPath)
-        });
-    }
+        // Set creating status to ongoing
+        this.#siteCreationStatus = SiteCreationStatus.ONGOING;
 
 
-    // Start server
-    app = await startServer(args.outputPath, args.port);
+        // Actual site creation
+        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) {
+            log(`Failed to create site!\n${err.stack}`);
+        }
 
 
-    // Handle quit
-    const cleanup = () => {
-        // Remove html path
-        if (!args.outputPathProvided && fs.existsSync(args.outputPath)) {
-            fs.rmSync(args.outputPath, { recursive: true, force: true })
+        // If recreate was triggered while site creation was ongoing
+        const wasPending = this.#siteCreationStatus === SiteCreationStatus.PENDING_RECREATION;
+        this.#siteCreationStatus = SiteCreationStatus.NONE;
+        if (wasPending) {
+            await this.recreateSite(this.#pendingHardSiteCreation);
         }
-
-        process.stdin.setRawMode(false);
     }
-    process.on("exit", cleanup);
-    process.on("SIGINT", cleanup);
-    process.on("SIGTERM", cleanup);
-}
+    async abortSiteCreation() {
+        this.#siteCreationStatus = SiteCreationStatus.NONE;
+    }
+    async stop() {
+        // Remove temp dir html path
+        if (!this.#outputPathProvided && fs.existsSync(this.outputPath)) {
+            fs.rmSync(this.outputPath, { recursive: true });
+        }
+
 
-Main()
+        // Stop server       
+        this.#app?.server?.close?.(); //(e) => { process.exit(); });
+
+
+        // Stop watching for changes
+        await this.#watcher?.close?.();
+    }
+}