host-mdx 1.0.13 → 2.0.0

package/README.md

@@ -1,49 +1,123 @@
 # host-mdx
 
-This creates and serves a [github pages](https://docs.github.com/en/pages) style html directory from a corresponding mdx directory
+[![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
 
 ## Usage
+
 ```
-deno npm:host-mdx [<mdx-dir>] [<optional-port-number>] [<optional-html-dir>]
+host-mdx [options]
+
+Options:
+--create-only, -c     Only create the html website from mdx does not host
+--help, -h            Shows all available options
+--input-path=...      The path at which all mdx files are stored
+--output-path=...     The path to which all html files will be generated
+--port=...            Localhost port number on which to host 
+--track-changes, -t   Tracks any changes made & auto reloads
+--verobse, -v         Shows additional log messages
 ```
 
-## Example
+Add a file by the name `.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)) 
+
+
+Add a file by the name `host-mdx.js` at the root of your project as a config file with the following:
+
+```js
+// Modify
+modBundleMDXSettings(settings)
+
 
+// Hooks
+onSiteCreateStart(inputPath, outputPath)
+onSiteCreateEnd(inputPath, outputPath)
+onFileCreateStart(inputFilePath, outputFilePath)
+onFileCreateEnd(inputFilePath, outputFilePath)
+```
+> Note: Any changes made to `host-mdx.js` require complete restart otherwise changes will not reflect
+
+## Example
 
+Command:
 ```bash
-deno npm:host-mdx "/home/username/my-website-template/" 3113 "/home/username/Desktop/my-website/"
+npx host-mdx --input-path="path/to/my-website-template" --output-path="path/to/my-website" --port=3113 -t
 ```
 
+Input Directory:
 ```
 my-website-template/
 ├─ index.mdx
+├─ .hostmdxignore
+├─ host-mdx.js
 ├─ about/
-│  └─ index.mdx
-├─ projects/
-│  ├─ project1/
+│  ├─ index.mdx
+│  └─ custom_component.jsx
+├─ blog/
+│  ├─ page1/
 │  │  └─ index.mdx
-│  └─ project2/
+│  └─ page2/
+│     ├─ extras.png
 │     └─ index.mdx
 └─ static/
    ├─ image1.png
    ├─ image2.jpg
+   ├─ temp.jpg
+   ├─ sample.jsx
    └─ styles.css
 ```
 
+`.hostmdxignore` file content:
+```sh
+*.jsx
+blog/page2/
+static/temp.jpg
+!static/sample.jsx
+```
+
+`host-mdx.js` file content:
+```js
+export function onSiteCreateStart(inputPath, outputPath) {
+   console.log("onSiteCreateStart", inputPath, outputPath)
+}
+export function onSiteCreateEnd(inputPath, outputPath, wasSuccessful){
+   console.log("onSiteCreateEnd", inputPath, outputPath)
+}
+export function onFileCreateStart(inputFilePath, outputFilePath){
+   console.log("onFileCreateStart", inputFilePath, outputFilePath)
+}
+export function onFileCreateEnd(inputFilePath, outputFilePath){
+   console.log("onFileCreateEnd", inputFilePath, outputFilePath)
+}
+export function onHostStart(port){
+   console.log("onHostStart", port)
+}
+export function onHostEnd(port){
+   console.log("onHostEnd", port)
+}
+export function modBundleMDXSettings(settings){
+   // Modify settings ...
+   return settings
+}
+```
+
+Output Directory:
 ```
 my-website/
 ├─ index.html
 ├─ about/
 │  └─ index.html
-├─ projects/
-│  ├─ project1/
-│  │  └─ index.html
-│  └─ project2/
+├─ blog/
+│  └─ page1/
 │     └─ index.html
 └─ static/
    ├─ image1.png
    ├─ image2.jpg
+   ├─ sample.jsx
    └─ styles.css
 ```
 
-The site will now be visible in the browser at `localhost:3113`
+The site will now be visible in the browser at `localhost:3113`
+
+> For a live example take a look at [sourcesnippet.github.io](https://sourcesnippet.github.io/)

package/index.js

@@ -1,35 +1,74 @@
 #!/usr/bin/env node
 
-console.log("version 1.0.13")
-
-import fs from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import http from 'node:http'
-import process from "node:process"
-import { pathToFileURL } from "node:url"
-import { minify } from 'html-minifier-terser'
-import * as runtime from 'react/jsx-runtime'
-import { createElement } from 'react'
-import { renderToString } from 'react-dom/server'
-import { evaluate } from '@mdx-js/mdx'
-import rehypeHighlight from "rehype-highlight";
-import { common } from 'lowlight'
-import gdscript from "@exercism/highlightjs-gdscript"
-import * as readline from 'node:readline';
-
-
-
-// Constants
-const DEFAULT_PORT = 3000
+import fs from 'fs'
+import os from 'os'
+import path from 'path'
+import http from 'http'
+import ignore from "ignore";
+import chokidar from 'chokidar';
+import * as readline from 'readline';
+import { mdxToHtml } from './mdx-to-html.js'
+
+
+// To-Set Properties
 const APP_NAME = "host-mdx"
-let TEMP_HTML_DIR = path.join(os.tmpdir(), `${APP_NAME}`)
-const HELP_MESSAGE = `deno ${APP_NAME} [mdx-path] [<optional-port-number>] [<optional-html-dir>]`
-const STARTED_CREATING_SITE = `==== Started creating site ==== `
-const FINISHED_CREATING_SITE = `==== Finished creating site ==== `
-const INVALID_MDX_DIR_ERROR = `Invalid mdx directory (1st argument) provided!`
-const INVALID_PORT_NUMBER_ERROR = `Invalid port number (2nd argument) provided!`
-const INVALID_HTML_DIR_ERROR = `Invalid html directory (3rd argument) could not create/find!`
+const DEFAULT_PORT = 3000
+const IGNORE_FILE_NAME = ".hostmdxignore"
+const CONFIG_FILE_NAME = "host-mdx.js"
+const DEFAULT_IGNORES = `
+${IGNORE_FILE_NAME}
+${CONFIG_FILE_NAME}
+node_modules
+package-lock.json
+package.json
+.git
+`
+
+
+// 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 = "--verobse"
+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 isVerbose = false
+let configs
+let server
+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',
+    hour12: false,
+    fractionalSecondDigits: 3
+}
 const MIME_TYPE = {  // Maps extensions to mime protocol
     '.html': 'text/html',
     '.css': 'text/css',
@@ -46,117 +85,222 @@ const MIME_TYPE = {  // Maps extensions to mime protocol
     '.pdf': 'application/pdf',
     '.zip': 'application/zip',
 }
-let is_creating_site = false  // Prevents site from being recreated if creation is ongoing
 
 
-// Functions
-async function mdx_to_html(mdx_code, base_url) {  // converts mdx code into html code, `base_url` is the path from where all the mdx import path relatively work from
+// Utility Methods
+function log(msg, checkVerbose = false) {
+    if (checkVerbose && !isVerbose) {
+        return
+    }
+
+    let timestamp = new Date().toLocaleString(undefined, TIME_OPTIONS)
+    console.log(`[${APP_NAME} ${timestamp}] ${msg}`)
+}
+function createTempDir() {
 
-    const jsx = (await evaluate(mdx_code, {
-        ...runtime,
-        rehypePlugins: [[rehypeHighlight, { languages: { ...common, gdscript } }]],
-        baseUrl: base_url
-    })).default
-    const html_code = renderToString(createElement(jsx))
+    // Delete existing temp dir
+    if (fs.existsSync(TEMP_HTML_DIR)) {
+        fs.rmSync(TEMP_HTML_DIR, { recursive: true, force: true })
+    }
+
+
+    // Create default temp html dir
+    fs.mkdirSync(TEMP_HTML_DIR, { recursive: true })
+
+
+    return fs.mkdtempSync(path.join(TEMP_HTML_DIR, `/html-`));
+}
+function getIgnore(ignoreFilePath) {
+    const ig = ignore();
+    let ignoreContent = DEFAULT_IGNORES
+
+    if (fs.existsSync(ignoreFilePath)) {
+        ignoreContent += `\n${fs.readFileSync(ignoreFilePath, "utf8")}`
+    }
 
-    return minify(html_code, { minifyCSS: true })
+    ig.add(ignoreContent);
 
+    return ig
 }
-async function create_site(create_from_path, create_at_path) {
+function createFile(filePath, fileContent = "") {
+
+    // Check if path for file exists
+    let fileLocation = path.dirname(filePath)
+    if (!fs.existsSync(fileLocation)) {
+        fs.mkdirSync(fileLocation, { recursive: true });
+    }
+
+
+    // Create file
+    fs.writeFileSync(filePath, fileContent);
+}
+async function createSite(inputPath, outputPath) {
     // Exit if already creating
-    if (is_creating_site) {
+    if (isCreatingSite) {
+        log("site creation already ongoing!")
         return
     }
 
 
     // Set creating status to ongoing
-    is_creating_site = true
-    console.log(STARTED_CREATING_SITE)
+    isCreatingSite = true
+
+
+    // Get config properties
+    let configFilePath = path.join(inputPath, `./${CONFIG_FILE_NAME}`)
+    if (fs.existsSync(configFilePath)) {
+        configs = await import(configFilePath);
+    }
+
+
+    // Broadcast site creation started
+    log("Creating site...")
+    configs?.onSiteCreateStart?.(inputPath, outputPath)
 
 
     // Remove html folder if it already exists
-    if (fs.existsSync(create_at_path)) {
-        fs.rmSync(create_at_path, { recursive: true, force: true });
+    if (fs.existsSync(outputPath)) {
+        fs.rmSync(outputPath, { recursive: true, force: true });
     }
 
 
-    // copy paste directory
-    fs.cpSync(create_from_path, create_at_path, { recursive: true });
+    // Setup ignore
+    let ignoreFilePath = path.join(inputPath, IGNORE_FILE_NAME)
+    let ig = getIgnore(ignoreFilePath)
+
+
+    // Iterate through all folders & files
+    const stack = [inputPath];
+    while (stack.length > 0) {
+        const currentPath = stack.pop()
+        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 && absToOutput.endsWith(".mdx")
 
 
-    // Iterate through files
-    let files = fs.readdirSync(create_from_path, { withFileTypes: true, recursive: true });
+        // Skip if to ignore this path
+        if (toIgnore) {
+            continue
+        }
+
 
-    for (const file of files) {
-        const file_path = path.join(file.parentPath, file.name)
+        // Make dir
+        if (isDir) {
+            log(`${currentPath} ---> ${absToOutput}`, true)
+            configs?.onFileCreateStart?.(currentPath, absToOutput)
+            fs.mkdirSync(absToOutput, { recursive: true });
+            configs?.onFileCreateEnd?.(currentPath, absToOutput)
+        }
+        // Make html file from mdx
+        else if (!isDir && isMdx) {
 
-        if (file.isFile() && file_path.endsWith(".mdx")) {
+            // Broadcast file creation started
+            let absHtmlPath = path.format({ ...path.parse(absToOutput), base: '', ext: '.html' })
+            log(`${currentPath} ---> ${absHtmlPath}`, true)
+            configs?.onFileCreateStart?.(currentPath, absHtmlPath)
 
-            // To ensure file paths work
-            process.chdir(file.parentPath);
 
-            let base_url = pathToFileURL(path.normalize(path.join(create_from_path, path.sep))).href  // Converts file into file uri i.e "file:///my/path/"
-            let mdx_code = fs.readFileSync(file_path, 'utf8');
-            let html_code = await mdx_to_html(mdx_code, base_url);
-            let html_file_path = file_path.replace(create_from_path, create_at_path).replace(".mdx", ".html")
-            let html_dir_path = path.dirname(html_file_path)
+            // convert mdx code into html & paste into file
+            let mdxCode = fs.readFileSync(currentPath, 'utf8');
+            let parentDir = path.dirname(currentPath)
+            let htmlCode = await mdxToHtml(mdxCode, parentDir, configs?.modBundleMDXSettings);
+            createFile(absHtmlPath, `<!DOCTYPE html>\n${htmlCode}`);
 
 
-            // Make directory if it doesn't exist
-            if (!fs.existsSync(html_dir_path)) {
-                fs.mkdirSync(html_dir_path, { recursive: true })
-            }
+            // Broadcast file creation ended
+            configs?.onFileCreateEnd?.(currentPath, absHtmlPath)
+        }
+        // Copy paste file
+        else if (!isDir) {
+            log(`${currentPath} ---> ${absToOutput}`, true)
+            configs?.onFileCreateStart?.(currentPath, absToOutput)
+            fs.copyFileSync(currentPath, absToOutput)
+            configs?.onFileCreateEnd?.(currentPath, absToOutput)
+        }
 
 
-            // write to file
-            fs.writeFileSync(html_file_path, html_code);
+        // Skip if current path is a file or a directory to ignore
+        if (!isDir) {
+            continue
         }
 
+
+        // Add to stack if current path is dir
+        const files = fs.readdirSync(currentPath);
+        for (const file of files) {
+            stack.push(path.join(currentPath, file));
+        }
     }
 
-    is_creating_site = false;
-    console.log(FINISHED_CREATING_SITE)
+
+    // Unset creating status & Notify
+    isCreatingSite = false;
+
+
+    // Broadcast site creation ended
+    log("Created site")
+    configs?.onSiteCreateEnd?.(inputPath, outputPath)
 }
-async function watch_for_reload(mdx_dir, html_dir) {  // Watches `mdx_dir` files for any code change
+
+
+// Main Methods
+async function createSiteSafe(...args) {
+    try {
+        await createSite(...args);
+    }
+    catch (err) {
+        isCreatingSite = false
+        console.log(err);
+        log("Failed to create site!");
+    }
+}
+async function listenForKey(createSiteCallback) {
 
     readline.emitKeypressEvents(process.stdin);
 
-    if (process.stdin.isTTY)
+    if (process.stdin.isTTY) {
         process.stdin.setRawMode(true);
+    }
 
     process.stdin.on('keypress', (chunk, key) => {
         if (key && key.name == 'r') {
-            create_site(mdx_dir, html_dir)
+            createSiteCallback();
         }
         else if (key && key.sequence == '\x03') {
-            process.exit();
+            server.close((e) => { process.exit() })
         }
     });
 }
-function start_server(html_dir, port) {  // Starts server at given port
+function startServer(htmlDir, port) {  // Starts server at given port
+
+    // Broadcast server starting
+    configs?.onHostStart?.(port)
+
 
     // Start Server
-    const server = http.createServer((req, res) => {
+    const newServer = http.createServer((req, res) => {
 
         // Parse & Sanitize URL
-        let parsed_url = new URL("http://" + req.headers.host + req.url)
-        let sanitized_url = path.normalize(parsed_url.pathname).replace(/^(\.\.[\/\\])+/, '')
-        let is_directory = !Boolean(path.parse(sanitized_url).ext)
-        let relative_file_path = path.normalize(sanitized_url + (is_directory ? "/index.html" : ""))
-        let absolute_file_path = path.join(path.resolve(html_dir), relative_file_path)
-        let path_exists = fs.existsSync(absolute_file_path)
+        let parsedUrl = new URL("http://" + req.headers.host + req.url)
+        let sanitizedUrl = path.normalize(parsedUrl.pathname).replace(/^(\.\.[\/\\])+/, '')
+        let isDirectory = !Boolean(path.parse(sanitizedUrl).ext)
+        let relativeFilePath = path.normalize(sanitizedUrl + (isDirectory ? "/index.html" : ""))
+        let absoluteFilePath = path.join(path.resolve(htmlDir), relativeFilePath)
+        let pathExists = fs.existsSync(absoluteFilePath)
 
         // Respondes with content of file
-        if (path_exists)
+        if (pathExists)
             // read file from file system
-            fs.readFile(absolute_file_path, function (err, data) {
+            fs.readFile(absoluteFilePath, function (err, data) {
                 if (err) {
                     res.statusCode = 500
                     res.end(`Error getting the file: ${err}.`)
                 }
                 else {
                     // Based on the URL path, extract the file extention. e.g. .js, .doc, ...
-                    const ext = path.parse(absolute_file_path).ext
+                    const ext = path.parse(absoluteFilePath).ext
                     res.setHeader('Content-type', MIME_TYPE[ext] || 'text/plain') // if the file is found, set Content-type and send data
                     res.end(data)
                 }
@@ -167,90 +311,97 @@ function start_server(html_dir, port) {  // Starts server at given port
             res.end(`404 Invalid url not found!`)
         }
     })
+    newServer.listen(port, () => { log(`Server listening at ${port} ... (Press 'r' to manually reload, Press 'Ctrl+c' to exit)`) })
+    newServer.on("close", () => { configs?.onHostEnd?.(port) });
 
-    server.listen(port, () => { console.log(`Server listening at ${port} ... (Press 'r' to reload, Press 'Ctrl+c' to exit)`) })
+    return newServer
 }
-async function main() {
-
+async function Main() {
     // Get all arguments
     const args = process.argv.slice(2)
 
 
     // Check if asked for help
-    if (args[0] === "--help" || args[0] === "-h") {
+    if (args.includes(HELP_FLAG) || args.includes(HELP_SHORT_FLAG)) {
         console.log(HELP_MESSAGE)
         return;
     }
 
 
-    // Check if valid mdx folder path
-    var mdx_path = args[0];
-    if (!fs.existsSync(mdx_path)) {
-        console.log(INVALID_MDX_DIR_ERROR)
-        return
-    }
+    // Assign to create
+    let toCreateOnly = args.includes(CREATE_FLAG) || args.includes(CREATE_SHORT_FLAG)
 
+    // Assign input path
+    let inputPath = args.find(val => val.startsWith(INPUT_PATH_FLAG))
+    inputPath = inputPath !== undefined ? inputPath.split('=')[1] : process.cwd()
 
-    // Check if valid port number
-    var port = args[1]
-    var port_number = DEFAULT_PORT
-    if (port != undefined) {
-        port_number = Number(port)
+    // Assign output path
+    let outputPath = args.find(val => val.startsWith(OUTPUT_PATH_FLAG))
+    let outputPathProvided = outputPath !== undefined
+    outputPath = outputPathProvided ? outputPath.split('=')[1] : createTempDir()
 
-        if (!Number.isInteger(port_number)) {
-            console.log(INVALID_PORT_NUMBER_ERROR)
-            return
-        }
-    }
+    // Assign tracking changes
+    let toTrackChanges = args.includes(TRACK_CHANGES_FLAG) || args.includes(TRACK_CHANGES_SHORT_FLAG)
 
+    // Assign port
+    let port = args.find(val => val.startsWith(PORT_FLAG))
+    port = port !== undefined ? Number(port.split('=')[1]) : DEFAULT_PORT
 
-    // Check if valid html folder path
-    var html_path = args[2];
-    if (html_path !== undefined) {
+    // Assign verbose
+    isVerbose = args.includes(VERBOSE_FLAG) || args.includes(VERBOSE_SHORT_FLAG)
 
-        // Create user given html dir if it does not exist
-        try {
-            if (!fs.existsSync(html_path)) {
-                fs.mkdirSync(html_path, { recursive: true })
-            }
-        }
-        catch {
-            console.log(INVALID_HTML_DIR_ERROR)
-            return;
-        }
+
+    // Check input path
+    if (!fs.existsSync(inputPath) || !fs.lstatSync(inputPath).isDirectory()) {
+        log(`Invalid input path "${inputPath}"`)
+        return
     }
-    else {
 
-        // Create default temp html dir
-        if (!fs.existsSync(TEMP_HTML_DIR)) {
-            fs.mkdirSync(TEMP_HTML_DIR, { recursive: true })
-        }
+    // Check output path
+    if (!fs.existsSync(outputPath) || !fs.lstatSync(outputPath).isDirectory()) {
+        log(`Invalid output path "${outputPath}"`)
+        return
+    }
+
+    // Check port
+    if (!Number.isInteger(port)) {
+        log(`Invalid port`)
+        return
+    }
 
-        html_path = fs.mkdtempSync(path.join(TEMP_HTML_DIR, `/html-`));
+
+    // Create site from mdx & return if only needed to create site
+    await createSiteSafe(inputPath, outputPath)
+    if (toCreateOnly) {
+        return;
     }
 
 
-    // Create site given html & mdx locations
-    var abs_mdx_path = path.resolve(mdx_path)
-    var abs_html_path = path.resolve(html_path)
-    create_site(abs_mdx_path, abs_html_path)
+    // Watch for key presses
+    listenForKey(() => createSiteSafe(inputPath, outputPath))
 
 
-    // Start server and watch for changes if flag is passed
-    watch_for_reload(abs_mdx_path, abs_html_path)
-    start_server(abs_html_path, port_number)
+    // Watch for changes
+    if (toTrackChanges) {
+        chokidar.watch(inputPath, { ignoreInitial: true }).on('all', (event, path) => {
+            createSiteSafe(inputPath, outputPath)
+        });
+    }
+
 
+    // Start server
+    server = startServer(outputPath, port)
 
-    // Remove temp html directory
-    process.on("SIGINT", () => {
 
+    // Handle quit
+    process.on("exit", () => {
         // Remove html path
-        if (fs.existsSync(abs_html_path)) {
-            fs.rmSync(abs_html_path, { recursive: true, force: true })
+        if (!outputPathProvided && fs.existsSync(outputPath)) {
+            fs.rmSync(outputPath, { recursive: true, force: true })
         }
 
         process.exit(0);
     });
 }
 
-await main();
+Main()

package/mdx-to-html.js

@@ -0,0 +1,42 @@
+import React from 'react';
+import rehypeHighlight from "rehype-highlight";
+import * as _jsx_runtime from 'react/jsx-runtime';
+import { common } from 'lowlight';
+import { bundleMDX } from 'mdx-bundler';
+import { getMDXComponent } from 'mdx-bundler/client/index.js'
+import { renderToString } from 'react-dom/server';
+import { createRequire } from 'module';
+
+const nativeRequire = createRequire(import.meta.url);
+
+export async function mdxToHtml(mdxCode, baseUrl, modSettingsCallback = undefined) {
+  
+  // Assign default settings
+  let settings = {
+    source: mdxCode,
+    cwd: baseUrl,
+    esbuildOptions: (options) => {
+      options.platform = 'node'
+      return options;
+    },
+    mdxOptions(options) {
+      options.rehypePlugins = [
+        ...(options.rehypePlugins ?? []),
+        [rehypeHighlight, { languages: { ...common } }]
+      ];
+      return options;
+    }
+  }
+
+
+  // Modify settings
+  if(modSettingsCallback !== undefined){
+    settings = modSettingsCallback(settings)
+  }
+
+
+  // Generate html
+  const { code } = await bundleMDX(settings);
+  const Component = getMDXComponent(code, { require: nativeRequire, cwd: baseUrl })
+  return renderToString(React.createElement(Component));
+}

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "host-mdx",
-  "version": "1.0.13",
+  "version": "2.0.0",
   "description": "Creates and serves a github pages style html directory from a corresponding mdx directory",
   "main": "index.js",
+  "type": "module",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
@@ -10,16 +11,21 @@
     "host-mdx": "index.js"
   },
   "dependencies": {
-    "@exercism/highlightjs-gdscript": "^0.0.1",
-    "@mdx-js/mdx": "^3.1.0",
-    "html-minifier-terser": "^7.2.0",
-    "react": "^19.0.0",
-    "react-dom": "^19.0.0",
-    "rehype-highlight": "^7.0.1"
+    "chokidar": "^5.0.0",
+    "ignore": "^7.0.5",
+    "lowlight": "^3.3.0",
+    "mdx-bundler": "^10.1.1",
+    "react": "^19.2.3",
+    "react-dom": "^19.2.3",
+    "rehype-highlight": "^7.0.2"
   },
   "keywords": [
     "mdx"
   ],
   "author": "Manas Makde",
-  "license": "ISC"
+  "license": "ISC",
+  "devDependencies": {
+    "@babel/preset-react": "^7.28.5",
+    "@babel/register": "^7.28.3"
+  }
 }