mikel-press 0.2.0 → 0.18.2

package/README.md

@@ -1,6 +1,9 @@
 # mikel-press
 
-**mikel-press** is a tiny static site generator inspired by Jekyll that uses **mikel** as its templating engine. It provides a simple and efficient way to build static websites with customizable layouts and content.
+![npm version](https://badgen.net/npm/v/mikel-press?labelColor=1d2734&color=21bf81)
+![license](https://badgen.net/github/license/jmjuanes/mikel?labelColor=1d2734&color=21bf81)
+
+**mikel-press** is a static site generator inspired by [Jekyll](https://jekyllrb.com/) and built on top of **mikel**, a Mustache-based templating engine. It allows you to generate static websites from HTML and Markdown files using a flexible plugin system.
 
 ## Installation
 
@@ -16,37 +19,152 @@ Or **npm**:
 $ npm install --dev mikel-press
 ```
 
-## Usage
+## Configuration
+
+**mikel-press** can be configured using a `config` object that accepts the following options:
+
+| Field | Description | Default |
+|-------|-------------|---------|
+| `source` | The path to the directory containing the site's HTML or Markdown files. | `"content"` |
+| `destination` | The output directory where the generated static site will be saved. | `"www"` |
+| `layout` | The path to the layout file that will be used as the base template for all pages. | - |
+| `plugins` | A list of plugins used to extend the functionality of mikel-press. | `[]` |
+| `*` | Any other properties passed in config will be available as `site.*` inside each page template. | - |
+
+Here is an example configuration object:
+
+```javascript
+const config = {
+    source: "./content",
+    destination: "./www",
+    layout: "./layout.html",
+    title: "Hello world",
+    description: "My awesome site",
+    plugins: [
+        press.SourcePlugin(),
+        press.FrontmatterPlugin(),
+        press.PermalinkPlugin(),
+        press.ContentPlugin(),
+        press.CopyAssetsPlugin({
+            patterns: [
+                { from: "./static/styles.css", to: "static/" },
+            ],
+        }),
+    ],
+};
+```
 
-### Building the Site
+## Content
 
-Run the `build` command to generate your static website:
+### Variables
 
-```bash
-$ mikel-press build
-```
+Each HTML file processed by **mikel-press** will be handled by the mikel templating engine, that will provide the following data variables to each page:
 
-The generated files will be available in the `www` directory by default.
+#### Global variables
 
-### (WIP) Starting a Development Server
+| Variable | Description |
+|----------|-------------|
+| `site` | Contains the site information and all the additional keys provided in the configuration object. |
+| `page` | Specific information about the page that is rendered. |
+| `layout` | Specific information about the layout that is used for renderin the page. |
 
-To preview your site locally, use the `serve` command:
+#### Site variables
 
-```bash
-mikel-press serve
-```
+| Variable | Description |
+|----------|-------------|
+| `site.data` | An object containing all data items loaded by `DataPlugin`. |
+| `site.pages` | A list containing all pages processed by **mikel-pres**. |
+| `site.*` | All the additional configuration fields provided in the configuration. |
+
+#### Page variables
+
+| Variable | Description |
+|----------|-------------|
+| `page.path` | The path to the page. Example: `about/index.html`. |
+| `page.url` | The path to the page including the leading `/`. Example: `/about/index.html`. |
+| `page.attributes` | An object containing all the frontmatter variables in the page processed by `FrontmatterPlugin`. |
+| `page.content` | The raw content of the page before begin processed by **mikel**. |
+
+#### Layout variables
+
+| Variable | Description |
+|----------|-------------|
+| `layout.attributes` | An object containing all the frontmatter variables in the layout processed by `FrontmatterPlugin`. |
+| `layout.content` | The raw content of the layout. |
+
+## Plugins
+
+**mikel-press** relies on plugins to handle file reading, transformation, and rendering. The following plugins are built-in:
+
+### `press.SourcePlugin(options)`
+
+This plugin reads content from the specified `config.source` directory and loads it into the system for processing.
+
+Options:
+- `options.source` (string): Specifies a custom source directory. If not provided, `config.source` is used.
+- `options.extensions` (array): Defines the file extensions that should be processed. The default value is `[".html", ".md", ".markdown"]`.
+
+### `press.DataPlugin(options)`
+
+This plugin loads JSON files from the specified directory and makes them available in the site context.
+
+Options:
+- `options.source` (string): Specifies a custom source directory for data files. If not provided, `./data` is used.
+
+### `press.FrontmatterPlugin(options)`
 
-This will start a local server at `http://localhost:4000`.
+This plugin processes frontmatter in Markdown and HTML files.
 
-## (WIP) Configuration
+Options:
+- `options.extensions` (array): Defines the file extensions that should be processed. The default value is `[".md", ".markdown", ".html"]`.
+- `options.parser` (function): Frontmatter parser function (e.g., `JSON.parse`, `YAML.load`).
 
-Create a file called `press.config.js` with the configuration.
+### `press.PermalinkPlugin()`
 
+This plugin allows defining custom permalinks for pages.
 
-## Contributing
+### `press.MarkdownPlugin(options)`
 
-Contributions are welcome! If you have ideas or find a bug, feel free to open an issue or submit a pull request.
+This plugin processes Markdown files and converts them to HTML.
+
+Options:
+- `options.parser` (function): Markdown parser function (e.g., `marked.parse`).
+
+### `press.ContentPlugin(options)`
+
+This plugin processes each page and saves it into `config.destination`. It accepts an `options` object, which is passed to mikel for template processing.
+
+### `press.CopyAssetsPlugin(options)`
+
+This plugin copies static files from the source to the destination.
+
+Options:
+- `options.patterns` (array): List of file patterns to copy. Each pattern should have `from` and `to`.
+
+## Node API
+
+**mikel-press** provides an API with two main methods:
+
+### `press.build(config)`
+
+Triggers the build of **mikel-press** with the given configuration object provided as an argument.
+
+```javascript
+import press from "mikel-press";
+
+press.build(config);
+```
+
+### `press.watch(config)`
+
+Calling the `watch` method triggers the build, but also watches for changes and rebuilds the site as soon as it detects a change in any of the source files.
+
+```javascript
+import press from "mikel-press";
+
+press.watch(config);
+```
 
 ## License
 
-This project is licensed under the MIT License.
+This project is licensed under the [MIT License](../../LICENSE).

package/index.js

@@ -1,204 +1,462 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
+import * as http from "node:http";
 import mikel from "mikel";
 
-// @description tiny yaml parser
-const parseYaml = (str = "") => {
-    const lines = str.split("\n").filter(line => line.trim() !== "" && !line.trim().startsWith("#"));
-    return Object.fromEntries(lines.map(line => {
-        const [key, value] = line.split(":").map(part => part.trim());
-        if (!isNaN(value)) {
-            return [key, Number(value)];
+// @description default mime types
+const DEFAULT_MIME_TYPES = {
+    ".css": "text/css",
+    ".gif": "image/gif",
+    ".html": "text/html",
+    ".ico": "image/vnd.microsoft.icon",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".js": "text/javascript",
+    ".json": "application/json",
+    ".mjs": "text/javascript",
+    ".png": "image/png",
+    ".svg": "image/svg+xml",
+    ".txt": "text/plain", 
+};
+
+// @description general utilities
+const utils = {
+    // @description read a file from disk
+    // @param {String} file path to the file to read
+    read: (file, encoding = "utf8") => {
+        return fs.readFileSync(file, encoding);
+    },
+    // @description write a file to disk
+    // @param {String} file path to the file to save
+    // @param {String} content content to save
+    write: (file, content = "") => {
+        const folder = path.dirname(file);
+        if (!fs.existsSync(folder)) {
+            fs.mkdirSync(folder, {recursive: true});
         }
-        if (value === "true" || value === "false" || value === "null") {
-            return [key, JSON.parse(value)];
+        fs.writeFileSync(file, content, "utf8");
+    },
+    // @description copy a file
+    copy: (source, target) => {
+        const folder = path.dirname(target);
+        if (!fs.existsSync(folder)) {
+            fs.mkdirSync(folder, {recursive: true});
         }
-        return [key, value.replaceAll(/^["']|["']$/g, "")];
-    }));
-};
-
-// @description tiny front-matter parser
-const frontmatter = (str = "") => {
-    let body = (str || "").trim(), attributes = {};
-    const matches = Array.from(body.matchAll(/^(--- *)/gm));
-    if (matches?.length === 2 && matches[0].index === 0) {
-        attributes = parseYaml(body.substring(0 + matches[0][1].length, matches[1].index).trim());
-        body = body.substring(matches[1].index + matches[1][1].length).trim();
-    }
-    return {body, attributes};
-};
-
-// @description utility to save a file to disk
-const saveFile = (filePath, fileContent) => {
-    const folder = path.dirname(filePath);
-    if (!fs.existsSync(folder)) {
-        fs.mkdirSync(folder, {recursive: true});
-    }
-    fs.writeFileSync(filePath, fileContent, "utf8");
-};
-
-// @description returns the layout content from the given options
-const getLayoutContent = config => {
-    let content = "";
-    // using options.template to specify the the absolute path to the template file
-    if (typeof config?.layout === "string" || typeof config?.template === "string") {
-        content = fs.readFileSync(config.layout || config.template, "utf8");
-    }
-    // using templateContent to specify the string content of the template
-    if (typeof config?.layoutContent === "string" || typeof config?.templateContent === "string") {
-        content = config.layoutContent || config.templateContent;
-    }
-    // parse with frontmatter
-    const {body, attributes} = typeof config.frontmatter == "function" ? config.frontmatter(content) : {body: content, attributes: {}};
-    return {
-        content: body,
-        data: attributes || {},
-        attributes: attributes || {},
-    };
+        fs.copyFileSync(source, target);
+    },
+    // @description get all files from the given folder and the given extensions
+    readdir: (folder, extensions = "*") => {
+        if (!fs.existsSync(folder) || !fs.statSync(folder).isDirectory()) {
+            return [];
+        }
+        return fs.readdirSync(folder, "utf8").filter(file => {
+            return extensions === "*" || extensions.includes(path.extname(file));
+        });
+    },
+    // @description walk through the given folder and get all files
+    // @params {String} folder folder to walk through
+    // @params {Array|String} extensions extensions to include. Default: "*"
+    walkdir: (folder, extensions = "*") => {
+        const files = [];
+        const walkSync = currentFolder => {
+            const fullFolderPath = path.join(folder, currentFolder);
+            fs.readdirSync(fullFolderPath).forEach(file => {
+                const filePath = path.join(currentFolder, file);
+                const fullFilePath = path.join(fullFolderPath, file);
+                if (fs.statSync(fullFilePath).isDirectory()) {
+                    return walkSync(filePath);
+                }
+                if (extensions === "*" || extensions.includes(path.extname(file))) {
+                    files.push(filePath);
+                }
+            });
+        };
+        walkSync("./");
+        return files;
+    },
+    // @description watch for file changes
+    // @param {String} filePath path to the file to watch
+    // @param {Function} listener method to listen for file changes
+    watch: (filePath, listener) => {
+        let lastModifiedTime = null;
+        fs.watch(filePath, "utf8", () => {
+            const modifiedTime = fs.statSync(filePath).mtimeMs;
+            if (lastModifiedTime !== modifiedTime) {
+                lastModifiedTime = modifiedTime;
+                return listener(filePath);
+            }
+        });
+    },
+    // @description change the properties of the given path (dirname, basename, extname)
+    format: (filePath, options = {}) => {
+        const dirname = options.dirname || path.dirname(filePath);
+        const extname = options.extname || path.extname(filePath);
+        const basename = options.basename || path.basename(filePath, path.extname(filePath));
+        return path.join(dirname, `${basename}${extname}`);
+    },
+    // @description get the mime type from the given extension
+    getMimeType: (extname = ".txt") => {
+        return DEFAULT_MIME_TYPES[extname] || "text/plain";
+    },
 };
 
-// @description create a virtual page object from the given options
-const createVirtualPage = (options = {}) => {
-    const content = options.content || fs.readFileSync(options.file, "utf8");
-    const extname = options.extname || path.extname(options.file || "") || ".html";
-    const basename = options.basename || path.basename(options.file || "", extname) || "virtual";
-    const {body, attributes} = typeof options?.frontmatter == "function" ? options.frontmatter(content) : {body: content, attributes: {}};
-    return {
-        name: basename + extname,
-        basename: basename,
-        extname: extname,
-        url: options.url || attributes?.permalink || path.join("/", basename + extname),
-        data: attributes || {}, // DEPRECATED
-        attributes: attributes || {},
-        content: typeof options.transform === "function" ? options.transform(body) : body,
-    };
+// @description add a new node item
+const createNode = (source, path, label = "", data = {}) => {
+    return {source, path, label, data};
 };
 
-// @description get pages from input folder
-const readPages = (folder, extensions = ".html", fm = null, transform = null) => {
-    const extensionsList = new Set([extensions].flat());
-    if (fs.existsSync(folder) && fs.lstatSync(folder).isDirectory()) {
-        return fs.readdirSync(folder, "utf8")
-            .filter(file => extensionsList.has(path.extname(file)))
-            .map(file => {
-                return createVirtualPage({
-                    file: path.join(folder, file),
-                    frontmatter: fm,
-                    transform: transform,
-                    extname: ".html",
-                });
-            });
-    }
-    return [];
-};
-
-// @description get assets
-const readAssets = (folder, fm = null) => {
-    if (fs.existsSync(folder) && fs.lstatSync(folder).isDirectory()) {
-        const assetPaths = fs.readdirSync(folder, "utf8");
-        return Object.fromEntries(assetPaths.map(file => {
-            const asset = createVirtualPage({
-                file: path.join(folder, file),
-                frontmatter: fm,
-            });
-            const assetName = asset.basename.replaceAll(".", "_").replaceAll("-", "_");
-            return [assetName, asset];
-        }));
-    }
-    return {};
-};
-
-// @description read a data folder
-const readData = folder => {
-    if (fs.existsSync(folder) && fs.lstatSync(folder).isDirectory()) {
-        const files = fs.readdirSync(folder, "utf8")
-            .filter(file => path.extname(file) === ".json")
-            .map(file => path.join(folder, file))
-            .map(file => {
-                return [path.basename(file, ".json"), JSON.parse(fs.readFileSync(file, "utf8"))];
-            });
-        return Object.fromEntries(files);
-    }
-    return {};
-};
-
-// @description run mikel press with the provided configuration
-const run = (config = {}) => {
-    // 0. initialize context object
-    const hooks = ["initialize", "compiler", "beforeEmit", "emitPage", "emitAsset", "done"];
-    const context = {
-        site: config || {},
-        source: path.resolve(process.cwd(), config?.source || "."),
-        destination: path.resolve(process.cwd(), config?.destination || "./www"),
-        layout: getLayoutContent(config),
-        hooks: Object.freeze(Object.fromEntries(hooks.map(name => {
-            return [name, new Set()];
-        }))),
+// @description get nodes with the specified label
+const getNodesByLabel = (nodes, label) => {
+    return Array.from(nodes).filter(node => node.label === label);
+};
+
+// @description get all nodes to update
+const getNodesToUpdate = (graph, affectedNode) => {
+    const listOfAffectedNodes = new Set();
+    const walkNodes = currentNode => {
+        listOfAffectedNodes.add(currentNode);
+        return graph.forEach(edge => {
+            if (edge[0] === currentNode && !listOfAffectedNodes.has(edge[1])) {
+                walkNodes(edge[1]);
+            }
+        });
     };
-    const dispatch = (name, args) => Array.from(context.hooks[name]).forEach(fn => fn.apply(null, args));
-    // 1. execute plugins
-    if (config?.plugins && Array.isArray(config?.plugins)) {
-        config.plugins.forEach(plugin => plugin(context));
-    }
-    dispatch("initialize", []);
-    // 2. initialize mikel instance
-    const compiler = mikel.create(context.layout.content, config?.mikel || {});
-    dispatch("compiler", [context.compiler]);
-    // 3. read stuff
-    context.site.data = readData(path.join(context.source, config?.dataDir || "data"));
-    context.site.pages = readPages(path.join(context.source, config?.pagesDir || "pages"), ".html", config?.frontmatter, c => c);
-    context.site.assets = readAssets(path.join(context.source, config?.assetsDir || "assets"), config?.frontmatter);
-    dispatch("beforeEmit", []);
-    // 4. save pages
-    context.site.pages.forEach(page => {
-        compiler.addPartial("content", page.content); // register page content as partial
-        const content = compiler({
-            site: context.site,
-            layout: context.layout,
-            page: page,
+    walkNodes(affectedNode);
+    return listOfAffectedNodes;
+};
+
+// @description get plugins with the specified function
+const getPlugins = (plugins, functionName) => {
+    return plugins.filter(plugin => typeof plugin[functionName] === "function");
+};
+
+// create a new context from the provided configuration
+const createContext = config => {
+    const {source, destination, plugins, ...otherConfiguration} = config;
+    const context = Object.freeze({
+        config: otherConfiguration,
+        source: path.resolve(source || "."),
+        destination: path.resolve(destination || "./www"),
+        plugins: plugins || [],
+        nodes: [],
+        edges: [],
+    });
+    // load nodes into context
+    const nodesPaths = new Set(); // prevent adding duplicated nodes
+    getPlugins(context.plugins, "load").forEach(plugin => {
+        const nodes = plugin.load(context) || [];
+        [nodes].flat().forEach(node => {
+            const nodeFullPath = path.join(node.source, node.path);
+            if (nodesPaths.has(nodeFullPath)) {
+                throw new Error(`File ${nodeFullPath} has been already processed by another plugin`);
+            }
+            context.nodes.push(node);
+            nodesPaths.add(nodeFullPath);
         });
-        dispatch("emitPage", [page, content]);
-        saveFile(path.join(context.destination, page.url), content);
     });
-    // 5. save assets
-    Object.values(context.site.assets).forEach(asset => {
-        dispatch("emitAsset", [asset]);
-        saveFile(path.join(context.destination, asset.url), asset.content);
+    // generate dependency graph
+    const edgesPaths = new Set(); // prevent adding duplicated edges
+    getPlugins(context.plugins, "getDependencyGraph").forEach(plugin => {
+        (plugin.getDependencyGraph(context) || []).forEach(edge => {
+            if (!edge.every(node => nodesPaths.has(node))) {
+                throw new Error(`Dependency graph contains nodes that have not been loaded`);
+            }
+            const edgePath = edge.join(" -> ");
+            if (!edgesPaths.has(edgePath)) {
+                context.edges.push(edge);
+                edgesPaths.add(edgePath);
+            }
+        });
     });
-    dispatch("done", []);
+    // return context
+    return context;
 };
 
-// plugin to read and include posts in markdown
-const postsPlugin = (options = {}) => {
-    return context => {
-        context.hooks.beforeEmit.add(() => {
-            const posts = readPages(path.join(context.source, options?.dir || "posts"), [".md"], context.site.frontmatter, options?.parser);
-            context.site.posts = posts; // posts will be accesible in site.posts
-            context.site.pages = [...context.site.pages, ...posts]; // posts will be included as pages also
+// @description build context
+const buildContext = (context, nodes = null) => {
+    const nodesToBuild = (nodes && Array.isArray(nodes)) ? nodes : context.nodes;
+    // reset nodes path
+    nodesToBuild.forEach(node => {
+        node.data.path = node.path;
+    });
+    // transform nodes
+    const transformPlugins = getPlugins(context.plugins, "transform");
+    nodesToBuild.forEach((node, _, allNodes) => {
+        transformPlugins.forEach(plugin => {
+            return plugin.transform(context, node, allNodes);
         });
-    };
+    });
+    // filter nodes and get only the ones that are going to be emitted
+    const shouldEmitPlugins = getPlugins(context.plugins, "shouldEmit");
+    const filteredNodes = nodesToBuild.filter((node, _, allNodes) => {
+        for (let i = 0; i < shouldEmitPlugins.length; i++) {
+            const plugin = shouldEmitPlugins[i];
+            if (!plugin.shouldEmit(context, node, allNodes)) {
+                return false;
+            }
+        }
+        return true;
+    });
+    // emit each node
+    getPlugins(context.plugins, "emit").forEach(plugin => {
+        return plugin.emit(context, filteredNodes);
+    });
 };
 
-// progress plugin
-const progressPlugin = () => {
-    return context => {
-        const timeStart = Date.now();
-        const log = (status, msg) => console.log(`[${new Date().toISOString()}] (${status}) ${msg}`);
-        context.hooks.initialize.add(() => {
-            log("info", `source directory:       ${context.source}`);
-            log("info", `destination directory:  ${context.destination}`);
-        });
-        context.hooks.emitPage.add(page => {
-            log("info", `saving page:  ${page.url} --> ${path.join(context.destination, page.url)}`);
-        });
-        context.hooks.emitAsset.add(asset => {
-            log("info", `saving asset: ${asset.url} --> ${path.join(context.destination, asset.url)}`);
+// @description start a watch on the current context
+const watchContext = context => {
+    // force to rebuild
+    const rebuild = changedNodePath => {
+        const nodesPathsToBuild = getNodesToUpdate(context.edges, changedNodePath);
+        const nodesToRebuild = context.nodes.filter(node => {
+            return nodesPathsToBuild.has(path.join(node.source, node.path));
         });
-        context.hooks.done.add(() => {
-            log("done", `build completed in ${Date.now() - timeStart}ms`);
+        // perform the rebuild of the context
+        buildContext(context, nodesToRebuild);
+    };
+    // create a watch for each registered node in the context
+    context.nodes.forEach(node => {
+        return utils.watch(path.join(node.source, node.path), rebuild);
+    });
+};
+
+// @description start a server on the current context
+// @param {Object} context current site context
+// @param {Object} options server options
+// @param {String} options.port port that the server will listen. Default: "3000"
+// @param {Function} options.getMimeType function to obtain the associated mime type from the given extension
+const serveContext = (context, options = {}) => {
+    const port = parseInt(options?.port || "3000");
+    const getMimeType = options?.getMimeType || utils.getMimeType;
+    const server = http.createServer((request, response) => {
+        let responseCode = 200;
+        let url = path.join(context.destination, path.normalize(request.url));
+        // check for directory
+        if (url.endsWith("/") || (fs.existsSync(url) && fs.statSync(url).isDirectory())) {
+            url = path.join(url, "index.html");
+        }
+        // check if we have to append the '.html' extension
+        if (!fs.existsSync(url) && fs.existsSync(url + ".html")) {
+            url = url + ".html";
+        }
+        // check if the file does not exist
+        if (!fs.existsSync(url)) {
+            url = path.join(context.destination, "404.html");
+            responseCode = 404;
+        }
+        // send the file
+        response.writeHead(responseCode, {
+            "Content-Type": getMimeType?.(path.extname(url)) || "text/plain",
         });
+        fs.createReadStream(url).pipe(response);
+        console.log(`[${responseCode}] ${request.method} ${request.url}`);
+    });
+    // launch server
+    server.listen(port);
+    console.log(`Server running at http://127.0.0.1:${port}/`);
+};
+
+// @description source plugin
+const SourcePlugin = (options = {}) => {
+    const label = options.label || "pages";
+    return {
+        name: "SourcePlugin",
+        load: context => {
+            const folder = path.resolve(context.source, options.source || "./content");
+            const nodes = utils.walkdir(folder, options?.extensions || "*").map(file => {
+                return createNode(folder, file, label);
+            });
+            return nodes;
+        },
+        transform: (_, node) => {
+            if (node.label === label) {
+                node.data.content = utils.read(path.join(node.source, node.path));
+            }
+        },
+    };
+};
+
+// @description data plugin
+const DataPlugin = (options = {}) => {
+    const label = options?.label || "asset/data";
+    return {
+        name: "DataPlugin",
+        load: context => {
+            const folder = path.resolve(context.source, options.source || "./data");
+            return utils.readdir(folder, [".json"]).map(file => {
+                return createNode(folder, file, label);
+            });
+        },
+        transform: (_, node) => {
+            if (node.label === label && path.extname(node.path) === ".json") {
+                node.data.name = path.basename(node.path, ".json");
+                node.data.content = JSON.parse(utils.read(path.join(node.source, node.path)));
+            }
+        },
+        shouldEmit: (_, node) => {
+            return node.label !== label;
+        },
+    };
+};
+
+// @description frontmatter plugin
+// @params {Object} options options for this plugin
+// @params {Array} options.extensions extensions to process. Default: [".md", ".markdown", ".html"]
+// @params {Function} options.parser frontmatter parser (JSON.parse, YAML.load)
+const FrontmatterPlugin = (options = {}) => {
+    const extensions = options.extensions || [".md", ".markdown", ".html"];
+    return {
+        name: "FrontmatterPlugin",
+        transform: (_, node) => {
+            if ((extensions === "*" || extensions.includes(path.extname(node.path))) && typeof node.data.content === "string") {
+                node.data.attributes = {};
+                const matches = Array.from(node.data.content.matchAll(/^(--- *)/gm))
+                if (matches?.length === 2 && matches[0].index === 0) {
+                    const front = node.data.content.substring(0 + matches[0][1].length, matches[1].index).trim();
+                    node.data.content = node.data.content.substring(matches[1].index + matches[1][1].length).trim();
+                    if (typeof options.parser === "function") {
+                        node.data.attributes = options.parser(front);
+                    }
+                }
+            }
+        },
+    };
+};
+
+// @description permalink plugin
+const PermalinkPlugin = () => {
+    return {
+        name: "PermalinkPlugin",
+        transform: (_, node) => {
+            node.data.path = node.data?.attributes?.permalink || node.data.path;
+            // node.data.url = path.normalize("/" + node.data.path);
+        },
+    };
+};
+
+// @description markdown plugin
+// @params {Object} options options for this plugin
+// @params {Object} options.parser markdown parser (for example marked.parse)
+const MarkdownPlugin = (options = {}) => {
+    return {
+        name: "MarkdownPlugin",
+        transform: (_, node) => {
+            if (path.extname(node.path) === ".md" || path.extname(node.path) === ".markdown") {
+                // const marked = new Marked(options);
+                // getPlugins(context.plugins, "markdownPlugins").forEach(plugin => {
+                //     (plugin.markdownPlugins(context, node) || []).forEach(markedPlugin => {
+                //         marked.use(markedPlugin);
+                //     });
+                // });
+                node.data.content = options.parser(node.data.content);
+                node.data.path = utils.format(node.data.path, {extname: ".html"});
+            }
+        },
+    };
+};
+
+// @description content plugin
+const ContentPlugin = (options = {}) => {
+    const label = options.label || "asset/layout";
+    const extensions = options.extensions || [".html", ".md", ".markdown"];
+    return {
+        name: "ContentPlugin",
+        load: context => {
+            const layoutPath = path.resolve(context.source, context.config.layout || options.layout);
+            return createNode(path.dirname(layoutPath), path.basename(layoutPath), label);
+        },
+        transform: (_, node) => {
+            if (node.label === label) {
+                node.data.content = utils.read(path.join(node.source, node.path));
+            }
+        },
+        getDependencyGraph: context => {
+            const graph = [];
+            const template = getNodesByLabel(context.nodes, label)[0];
+            context.nodes.forEach(node => {
+                if (node.label !== label && extensions.includes(path.extname(node.path))) {
+                    graph.push([
+                        path.join(template.source, template.path),
+                        path.join(node.source, node.path),
+                    ]);
+                }
+            });
+            return graph;
+        },
+        shouldEmit: (_, node) => {
+            return node.label !== label;
+        },
+        emit: (context, nodesToEmit) => {
+            // prepare site data
+            const siteData = Object.assign({}, context.config, {
+                data: Object.fromEntries(getNodesByLabel(context.nodes, "asset/data").map(node => {
+                    return [node.data.name, node.data.content];
+                })),
+                pages: getNodesByLabel(context.nodes, "pages").map(n => n.data),
+                posts: getNodesByLabel(context.nodes, "posts").map(n => n.data),
+            });
+            // get data files
+            const template = getNodesByLabel(context.nodes, label)[0];
+            const compiler = mikel.create(template.data.content, options);
+            nodesToEmit.forEach(node => {
+                if (extensions.includes(path.extname(node.path))) {
+                    compiler.addPartial("content", node.data.content);
+                    const content = compiler({
+                        site: siteData,
+                        page: node.data,
+                        layout: template.data,
+                    });
+                    // const filePath = utils.format(node.data.path || node.path, {extname: ".html"});
+                    const filePath = node.data?.path || node.path;
+                    utils.write(path.join(context.destination, filePath), content);
+                }
+            });
+        },
     };
 };
 
-// export
-export default {run, createVirtualPage, frontmatter, postsPlugin, progressPlugin};
+// @description copy plugin
+const CopyAssetsPlugin = (options = {}) => {
+    return {
+        name: "CopyAssetsPlugin",
+        emit: context => {
+            (options.patterns || []).forEach(item => {
+                if (item.from && item.to && fs.existsSync(item.from)) {
+                    utils.copy(item.from, path.join(context.destination, item.to));
+                }
+            });
+        },
+    };
+};
+
+// @description default export of mikel-press
+export default {
+    // @description run mikel-press and generate the static site
+    // @param {Object} config configuration object
+    build: config => {
+        buildContext(createContext(config));
+    },
+    // @description watch for changes in the source folder and rebuild the site
+    // @param {Object} config configuration object
+    watch: config => {
+        const context = createContext(config);
+        buildContext(context, context.nodes);
+        watchContext(context);
+    },
+    // utilities for working with files
+    utils: utils,
+    // helpers for working with the context
+    createNode: createNode,
+    createContext: createContext,
+    buildContext: buildContext,
+    watchContext: watchContext,
+    serveContext: serveContext,
+    // plugins 
+    SourcePlugin: SourcePlugin,
+    DataPlugin: DataPlugin,
+    MarkdownPlugin: MarkdownPlugin,
+    FrontmatterPlugin: FrontmatterPlugin,
+    PermalinkPlugin: PermalinkPlugin,
+    ContentPlugin: ContentPlugin,
+    CopyAssetsPlugin: CopyAssetsPlugin,
+};

package/package.json

@@ -1,40 +1,36 @@
 {
     "name": "mikel-press",
-    "description": "A minimal static site generator based on mikel templating",
-    "version": "0.2.0",
+    "description": "A tiny and fast static site generator based on mikel templating",
+    "version": "0.18.2",
     "type": "module",
+    "license": "MIT",
     "author": {
         "name": "Josemi Juanes",
         "email": "hello@josemi.xyz"
     },
-    "license": "MIT",
     "repository": "https://github.com/jmjuanes/mikel",
     "bugs": "https://github.com/jmjuanes/mikel/issues",
-    "main": "index.js",
-    "module": "index.js",
-    "types": "index.d.ts",
     "exports": {
         ".": "./index.js",
         "./index.js": "./index.js",
         "./package.json": "./package.json"
     },
-    "scripts": {
-        "test": "node test.js"
+    "engines": {
+        "node": ">=20"
     },
-    "keywords": [
-        "static",
-        "site",
-        "generator",
-        "mikel",
-        "template",
-        "templating"
-    ],
     "dependencies": {
-        "mikel": "^0.17.0"
+        "mikel": "^0.18.2"
     },
     "files": [
         "README.md",
-        "index.js",
-        "index.d.ts"
+        "index.js"
+    ],
+    "keywords": [
+        "static-site",
+        "site-generator",
+        "digital-garden",
+        "markdown",
+        "blog",
+        "mikel"
     ]
-}
+}

package/index.d.ts

@@ -1,55 +0,0 @@
-interface MikelTemplateOptions {
-    functions: {[key: string]: (args: any) => string};
-    helpers: {[key: string]: (args: any) => string};
-    partials: {[key: string]: string};
-}
-
-interface FrontmatterResult {
-    body: string;
-    attributes: any;
-}
-
-interface VirtualPageOptions {
-    content?: string;
-    file?: string;
-    extname?: string;
-    basename?: string;
-    frontmatter?: (str: string) => FrontmatterResult;
-    transform?: (str: string) => string;
-}
-
-interface VirtualPage {
-    content: string;
-    attributes: any;
-    name: string;
-    extname: string;
-    basename: string;
-    url: string;
-}
-
-interface PostsPluginOptions {
-    dir: string;
-    parser: (str: string) => string;
-}
-
-interface SiteConfig {
-    source: string;
-    destination: string;
-    layout: string;
-    layoutContent: string;
-    dataDir: string;
-    pagesDir: string;
-    assetsDir: string;
-    frontmatter: (str: string) => FrontmatterResult;
-    mikel: Partial<MikelTemplateOptions>;
-    plugins: any[];
-}
-
-declare module "mikel-press" {
-    export function frontmatter(str: string): FrontmatterResult;
-    export function createVirtualPage(options: VirtualPageOptions): VirtualPage;
-    export function run(config: Partial<SiteConfig>): void;
-
-    export function postsPlugin(options: PostsPluginOptions): any;
-    export function progressPlugin(): any;
-}