mikel-press 0.0.1

package/README.md

@@ -0,0 +1,52 @@
+# 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.
+
+## Installation
+
+To install **mikel-press**, ensure you have [Node.js](https://nodejs.org) installed on your system. Then, add this package as a dependency to your project using **yarn**:
+
+```bash
+$ yarn add --dev mikel-press
+```
+
+Or **npm**:
+
+```bash
+$ npm install --dev mikel-press
+```
+
+## Usage
+
+### Building the Site
+
+Run the `build` command to generate your static website:
+
+```bash
+$ mikel-press build
+```
+
+The generated files will be available in the `www` directory by default.
+
+### (WIP) Starting a Development Server
+
+To preview your site locally, use the `serve` command:
+
+```bash
+mikel-press serve
+```
+
+This will start a local server at `http://localhost:4000`.
+
+## (WIP) Configuration
+
+Create a file called `press.config.js` with the configuration.
+
+
+## Contributing
+
+Contributions are welcome! If you have ideas or find a bug, feel free to open an issue or submit a pull request.
+
+## License
+
+This project is licensed under the MIT License.

package/cli.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+
+import * as path from "node:path";
+import {parseArgs} from "node:util";
+import mikelPress from "./index.js";
+
+// get the configuration file from the provided path
+const resolveConfig = value => {
+    const configPath = path.resolve(process.cwd(), value || "./press.config.js");
+    return import(configPath).then(config => {
+        return config?.default || {};
+    });
+};
+
+// available commands
+const commands = {
+    build: {
+        description: "Generate the static site with the provided configuration.",
+        execute: async values => {
+            const config = await resolveConfig(values.config);
+            return mikelPress.run(config);
+        },
+        options: {
+            config: {
+                type: "string",
+                short: "c",
+                default: "press.config.js",
+            },
+        },
+    },
+};
+
+const main = async (args = []) => {
+    const [commandName, ...otherArguments] = args;
+    if (typeof commands[commandName] !== "undefined") {
+        const {values} = parseArgs({
+            args: otherArguments,
+            options: commands[commandName].options || {},
+        });
+        return commands[commandName].execute(values);
+    }
+    // if this command is not available, print help [TODO]
+    // return commands.help.execute();
+};
+
+// run
+main(process.argv.slice(2));

package/index.js

@@ -0,0 +1,156 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import mikel from "mikel";
+
+// global utils
+const utils = {
+    // @description save file
+    saveFile: (filePath, fileContent) => {
+        const folder = path.dirname(filePath);
+        if (!fs.existsSync(folder)) {
+            fs.mkdirSync(folder, {recursive: true});
+        }
+        fs.writeFileSync(filePath, fileContent, "utf8");
+    },
+    // @description tiny front-matter parser
+    frontmatter: (str = "", parser = null) => {
+        let body = (str || "").trim(), attributes = {};
+        if (!!parser) {
+            const matches = Array.from(body.matchAll(/^(--- *)/gm))
+            if (matches?.length === 2 && matches[0].index === 0) {
+                const front = body.substring(0 + matches[0][1].length, matches[1].index).trim();
+                body = body.substring(matches[1].index + matches[1][1].length).trim();
+                attributes = typeof parser === "function" ? parser(front) : front;
+            }
+        }
+        return {body, attributes};
+    },
+    // @description read a data folder
+    readData: folder => {
+        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);
+    },
+    // @description get pages from input folder
+    readPages: (folder, type = ".html", fm = null, parse = null) => {
+        return fs.readdirSync(folder, "utf8")
+            .filter(file => path.extname(file) === type)
+            .map(file => {
+                const content = fs.readFileSync(path.join(folder, file), "utf8");
+                const {body, attributes} = utils.frontmatter(content, fm);
+                return {
+                    name: file,
+                    basename: path.basename(file, type),
+                    extname: path.extname(file),
+                    url: attributes?.permalink || path.join("/", path.basename(file, type) + ".html"),
+                    data: attributes || {},
+                    content: typeof parse === "function" ? parse(body) : body,
+                };
+            });
+    },
+    // @description get assets
+    readAssets: (folder, fm = null) => {
+        const assetPaths = fs.readdirSync(folder, "utf8");
+        return Object.fromEntries(assetPaths.map(file => {
+            const content = fs.readFileSync(path.join(folder, file), "utf8");
+            const {body, attributes} = utils.frontmatter(content, fm);
+            const asset = {
+                name: file, 
+                basename: path.basename(file, path.extname(file)),
+                extname: path.extname(file),
+                url: attributes?.permalink || path.join("/", file),
+                data: attributes || {},
+                content: body,
+            };
+            const assetName = asset.basename.replaceAll(".", "_").replaceAll("-", "_");
+            return [assetName, asset];
+        }));
+    },
+};
+
+// @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} = utils.frontmatter(content, config.frontmatter);
+    return {
+        content: body,
+        data: attributes || {},
+    };
+};
+
+// @description plugins
+const plugins = {
+    // plugin to read and include posts in markdown
+    posts: (parser = null) => {
+        return context => {
+            context.hooks.beforeEmit.add(() => {
+                const posts = utils.readPages(path.join(context.source, "posts"), ".md", context.site.frontmatter, 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 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"),
+        compiler: null,
+        layout: getLayoutContent(config),
+        hooks: Object.freeze(Object.fromEntries(hooks.map(name => {
+            return [name, new Set()];
+        }))),
+    };
+    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
+    context.compiler = mikel.create(context.layout.content, config?.mikel || {});
+    dispatch("compiler", [context.compiler]);
+    // 3. read stuff
+    context.site.data = utils.readData(path.join(context.source, config?.dataDir || "data"));
+    context.site.pages = utils.readPages(path.join(context.source, config?.pagesDir || "pages"), ".html", config?.frontmatter ?? true, c => c);
+    context.site.assets = utils.readAssets(path.join(context.source, config?.assetsDir || "assets"), config?.frontmatter ?? true);
+    dispatch("beforeEmit", []);
+    // 4. save pages
+    context.site.pages.forEach(page => {
+        context.compiler.addPartial("content", page.content); // register page content as partial
+        const content = context.compiler({
+            site: context.site,
+            layout: context.layout,
+            page: page,
+        });
+        dispatch("emitPage", [page, content]);
+        utils.saveFile(path.join(context.destination, page.url), content);
+    });
+    // 5. save assets
+    Object.values(context.site.assets).forEach(asset => {
+        dispatch("emitAsset", [asset]);
+        utils.saveFile(path.join(context.destination, asset.url), asset.content);
+    });
+    dispatch("done", []);
+};
+
+// export
+export default {utils, plugins, run};

package/package.json

@@ -0,0 +1,44 @@
+{
+    "name": "mikel-press",
+    "description": "A minimal static site generator based on mikel templating",
+    "version": "0.0.1",
+    "type": "module",
+    "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",
+    "exports": {
+        ".": "./index.js",
+        "./index.js": "./index.js",
+        "./cli.js": "./cli.js",
+        "./package.json": "./package.json"
+    },
+    "bin": {
+        "mikelpress": "./cli.js",
+        "mikel-press": "./cli.js"
+    },
+    "scripts": {
+        "test": "node test.js"
+    },
+    "keywords": [
+        "static",
+        "site",
+        "generator",
+        "mikel",
+        "template",
+        "templating"
+    ],
+    "dependencies": {
+        "mikel": "^0.17.0"
+    },
+    "files": [
+        "README.md",
+        "index.js",
+        "cli.js"
+    ]
+}