mikel-press 0.19.0 → 0.20.0

package/README.md

@@ -19,39 +19,61 @@ Or **npm**:
 $ npm install --dev mikel-press
 ```
 
+## Directory structure
+
+A basic **mikel-press** directory structure looks like this:
+
+```
+.
+├── data
+│   └── projects.json
+├── partials
+│   ├── footer.html
+│   └── header.html
+├── posts
+│   ├── 2025-04-03-introducing-our-new-project.html
+│   ├── 2025-04-05-how-to-stay-productive.html
+│   └── 2025-04-07-understanding-javascript-closures.html
+├── www
+├── press.js
+├── package.json
+├── projects.html
+├── blog.html
+├── about.html
+└── index.html
+```
+
 ## 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"` |
+| `source` | The path to the directory containing the site folders. | `"."` |
 | `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. | `[]` |
+| `extensions` | List of file extensions to process. | `[".html"]` |
+| `mikelOptions` | An object containing custom configuration for the **mikel** templating engine. | `{}` |
+| `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",
+import press from "mikel-press";
+
+press({
+    source: ".",
     destination: "./www",
-    layout: "./layout.html",
     title: "Hello world",
     description: "My awesome site",
     plugins: [
-        press.SourcePlugin(),
+        press.SourcePlugin({folder: "posts", basePath: "blog"}),
+        press.PartialsLoaderPlugin(),
+        press.DataLoaderPlugin(),
         press.FrontmatterPlugin(),
-        press.PermalinkPlugin(),
-        press.ContentPlugin(),
-        press.CopyAssetsPlugin({
-            patterns: [
-                { from: "./static/styles.css", to: "static/" },
-            ],
-        }),
+        press.ContentPagePlugin(),
     ],
-};
+});
 ```
 
 ## Content
@@ -66,31 +88,25 @@ Each HTML file processed by **mikel-press** will be handled by the mikel templat
 |----------|-------------|
 | `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. |
 
 #### Site variables
 
 | 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.pages` | A list containing all pages processed by **mikel-press**. |
+| `site.data` | An object containing all data items loaded by `DataLoaderPlugin`. |
+| `site.partials` | A list containing all partials files loaded by the `PartialsLoaderPlugin`. |
 | `site.*` | All the additional configuration fields provided in the configuration. |
 
 #### Page variables
 
 | Variable | Description |
 |----------|-------------|
+| `page.content` | The raw content of the page before begin processed by **mikel**. |
+| `page.title` | The title of the page. |
 | `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
 
@@ -98,41 +114,35 @@ Each HTML file processed by **mikel-press** will be handled by the mikel templat
 
 ### `press.SourcePlugin(options)`
 
-This plugin reads content from the specified `config.source` directory and loads it into the system for processing.
+This plugin reads content from the specified 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"]`.
+- `options.folder` (string): Specifies a custom source directory. If not provided, `config.source` is used.
+- `options.extensions` (array): Defines the file extensions that should be processed. If not provided, it will use `config.extensions`.
+- `options.basePath` (string): Specifies the base path for the output files.
 
-### `press.DataPlugin(options)`
+### `press.PartialsLoaderPlugin(options)`
 
-This plugin loads JSON files from the specified directory and makes them available in the site context.
+An alias of `press.SourcePlugin` that will read all files in the `partials` folder and process them as a partials. The **mikel** tag `{{>file}}` can be used to include the partial in `partials/file.html`.
 
-Options:
-- `options.source` (string): Specifies a custom source directory for data files. If not provided, `./data` is used.
+This plugin accepts the following options:
+- `options.folder` (string): To change the directory to load the partials files. Default is `./partials`.
+- `options.extensions` (array): Defines the file extensions that should be processed. If not provided, it will use `config.extensions`.
 
-### `press.FrontmatterPlugin(options)`
+### `press.DataLoaderPlugin(options)`
 
-This plugin processes frontmatter in Markdown and HTML files.
+This plugin loads JSON files from the specified directory and makes them available in the site context.
 
 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`).
-
-### `press.PermalinkPlugin()`
+- `options.folder` (string): Specifies a custom source directory for data files. If not provided, `./data` is used.
 
-This plugin allows defining custom permalinks for pages.
+### `press.FrontmatterPlugin()`
 
-### `press.MarkdownPlugin(options)`
+This plugin processes and parses the frontmatter in each file. The parsed frontmatter content will be available in `page.attributes` field.
 
-This plugin processes Markdown files and converts them to HTML.
-
-Options:
-- `options.parser` (function): Markdown parser function (e.g., `marked.parse`).
+### `press.ContentPagePlugin()`
 
-### `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.
+This plugin processes each page and saves it into `config.destination`.
 
 ### `press.CopyAssetsPlugin(options)`
 
@@ -141,28 +151,14 @@ 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)`
+## API
 
-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.
+**mikel-press** exposes a single function that triggers the build with the given configuration object provided as an argument.
 
 ```javascript
 import press from "mikel-press";
 
-press.watch(config);
+press({...});
 ```
 
 ## License

package/index.js

@@ -1,26 +1,67 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import * as http from "node:http";
 import mikel from "mikel";
 
-// @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 press main function
+// @param {Object} config - configuration object
+// @param {String} config.source - source folder
+// @param {String} config.destination - destination folder to save the files
+// @param {Array} config.plugins - list of plugins to apply
+const press = (config = {}) => {
+    const {source, destination, plugins, extensions, mikelOptions, ...otherConfig} = config;
+    const context = Object.freeze({
+        config: otherConfig,
+        source: path.resolve(source || "."),
+        destination: path.resolve(destination || "./www"),
+        extensions: extensions || [".html"],
+        template: mikel.create("{{>content}}", mikelOptions || {}),
+        plugins: [
+            SourcePlugin({folder: ".", label: press.LABEL_PAGE}),
+            ...plugins,
+        ],
+        nodes: [],
+    });
+    const getPlugins = name => context.plugins.filter(plugin => typeof plugin[name] === "function");
+    // 1. load nodes into context
+    const nodesPaths = new Set(); // prevent adding duplicated nodes
+    getPlugins("load").forEach(plugin => {
+        [plugin.load(context) || []].flat().forEach(node => {
+            if (nodesPaths.has(node.source)) {
+                throw new Error(`File ${node.source} has been already processed by another plugin`);
+            }
+            context.nodes.push(node);
+            nodesPaths.add(node.source);
+        });
+    });
+    // 2. transform nodes
+    const transformPlugins = getPlugins("transform");
+    context.nodes.forEach((node, _, allNodes) => {
+        transformPlugins.forEach(plugin => {
+            return plugin.transform(context, node, allNodes);
+        });
+    });
+    // 3. filter nodes and get only the ones that are going to be emitted
+    const shouldEmitPlugins = getPlugins("shouldEmit");
+    const filteredNodes = context.nodes.filter((node, _, allNodes) => {
+        return shouldEmitPlugins.every(plugin => {
+            return !!plugin.shouldEmit(context, node, allNodes);
+        });
+    });
+    // 4. before emit
+    getPlugins("beforeEmit").forEach(plugin => {
+        return plugin.beforeEmit(context);
+    });
+    // 5. emit each node
+    const emitPlugins = getPlugins("emit");
+    filteredNodes.forEach((node, _, allNodes) => {
+        emitPlugins.forEach(plugin => {
+            return plugin.emit(context, node, allNodes);
+        });
+    });
 };
 
 // @description general utilities
-const utils = {
+press.utils = {
     // @description read a file from disk
     // @param {String} file path to the file to read
     read: (file, encoding = "utf8") => {
@@ -49,414 +90,125 @@ const utils = {
         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;
+        return fs.readdirSync(folder, "utf8")
+            .filter(file => extensions === "*" || extensions.includes(path.extname(file)))
+            .filter(file => fs.statSync(path.join(folder, file)).isFile());
     },
-    // @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 add a new node item
-const createNode = (source, path, label = "", data = {}) => {
-    return {source, path, label, data};
-};
-
-// @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]);
-            }
-        });
-    };
-    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);
-        });
-    });
-    // 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);
-            }
-        });
-    });
-    // return context
-    return context;
-};
-
-// @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;
-            }
+    // @description frontmatter parser
+    // @params {String} content content to parse
+    // @params {Function} parser parser function to use
+    frontmatter: (content = "", parser = JSON.parse) => {
+        const matches = Array.from(content.matchAll(/^(--- *)/gm))
+        if (matches?.length === 2 && matches[0].index === 0) {
+            return {
+                body: content.substring(matches[1].index + matches[1][1].length).trim(),
+                attributes: parser(content.substring(matches[0].index + matches[0][1].length, matches[1].index).trim()),
+            };
         }
-        return true;
-    });
-    // emit each node
-    getPlugins(context.plugins, "emit").forEach(plugin => {
-        return plugin.emit(context, filteredNodes);
-    });
-};
-
-// @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));
-        });
-        // 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);
-    });
+        return {body: content, attributes: {}};
+    },
 };
 
-// @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}/`);
-};
+// assign constants
+press.LABEL_PAGE = "page";
+press.LABEL_ASSET = "asset";
+press.LABEL_DATA = "asset/data";
+press.LABEL_PARTIAL = "asset/partial";
 
 // @description source plugin
-const SourcePlugin = (options = {}) => {
-    const label = options.label || "pages";
+press.SourcePlugin = (options = {}) => {
     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));
-            }
+            const folder = path.join(context.source, options?.folder || ".");
+            return press.utils.readdir(folder, options?.extensions || context.extensions).map(file => ({
+                source: path.join(folder, file),
+                label: options.label || press.LABEL_PAGE,
+                path: path.join(options?.basePath || ".", file),
+                url: path.normalize("/" + path.join(options?.basePath || ".", file)),
+                content: press.utils.read(path.join(folder, file)),
+            }));
         },
     };
 };
 
-// @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 loader plugins
+press.DataLoaderPlugin = (options = {}) => {
+    return SourcePlugin({folder: "./data", extensions: [".json"], label: press.LABEL_DATA, ...options});
+};
+press.PartialsLoaderPlugin = (options = {}) => {
+    return SourcePlugin({folder: "./partials", extensions: [".html"], label: press.LABEL_PARTIAL, ...options});
 };
 
 // @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"];
+press.FrontmatterPlugin = () => {
     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);
-                    }
+            if (typeof node.content === "string") {
+                const result = press.utils.frontmatter(node.content, JSON.parse);
+                node.content = result.content;
+                node.attributes = result.attributes || {};
+                node.title = node.attributes?.title || node.path;
+                if (node.attributes.permalink) {
+                    node.path = node.attributes.permalink;
+                    node.url = path.normalize("/" + node.path);
                 }
             }
         },
     };
 };
 
-// @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 = {}) => {
+// @description plugin to generate pages content
+press.ContentPagePlugin = (siteData = {}) => {
     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);
+        name: "ContentPagePlugin",
+        shouldEmit: (context, node) => {
+            return ![press.LABEL_ASSET, press.LABEL_DATA, press.LABEL_PARTIAL].includes(node.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];
+        beforeEmit: context => {
+            const getNodes = label => context.nodes.filter(n => n.label === label);
+            // 1. prepare site data
+            Object.assign(siteData, context.config, {
+                pages: getNodes(press.LABEL_PAGE),
+                data: Object.fromEntries(getNodes(press.LABEL_DATA).map(node => {
+                    return [path.basename(node.path, ".json"), JSON.parse(node.content)];
                 })),
-                pages: getNodesByLabel(context.nodes, "pages").map(n => n.data),
-                posts: getNodesByLabel(context.nodes, "posts").map(n => n.data),
+                partials: getNodes(press.LABEL_PARTIAL),
+                assets: getNodes(press.LABEL_ASSET),
             });
-            // 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);
-                }
+            // 2. register partials into template
+            siteData.partials.forEach(partial => {
+                context.template.addPartial(path.basename(partial.path), {
+                    body: partial.content,
+                    attributes: partial.attributes || {},
+                });
             });
         },
+        emit: (context, node) => {
+            if (node.label === press.LABEL_PAGE && typeof node.content === "string") {
+                context.template.use(ctx => {
+                    ctx.tokens = mikel.tokenize(node.content || "");
+                });
+                // compile and write the template
+                const result = context.template({site: siteData, page: node});
+                press.utils.write(path.join(context.destination, node.path), result);
+            }
+        },
     };
 };
 
 // @description copy plugin
-const CopyAssetsPlugin = (options = {}) => {
+press.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));
-                }
-            });
+        beforeEmit: context => {
+            (options.patterns || [])
+                .filter(item => !!item.from && !!item.to && fs.existsSync(item.from))
+                .forEach(item => press.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,
-};
+// export press generator
+export default press;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "mikel-press",
     "description": "A tiny and fast static site generator based on mikel templating",
-    "version": "0.19.0",
+    "version": "0.20.0",
     "type": "module",
     "license": "MIT",
     "author": {
@@ -19,7 +19,7 @@
         "node": ">=20"
     },
     "dependencies": {
-        "mikel": "^0.19.0"
+        "mikel": "^0.20.0"
     },
     "files": [
         "README.md",