mikel-press 0.0.1 → 0.2.0

package/index.d.ts

@@ -0,0 +1,55 @@
+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;
+}

package/index.js

@@ -2,74 +2,39 @@ 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});
+// @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)];
         }
-        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;
-            }
+        if (value === "true" || value === "false" || value === "null") {
+            return [key, JSON.parse(value)];
         }
-        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];
-        }));
-    },
+        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
@@ -84,25 +49,77 @@ const getLayoutContent = config => {
         content = config.layoutContent || config.templateContent;
     }
     // parse with frontmatter
-    const {body, attributes} = utils.frontmatter(content, config.frontmatter);
+    const {body, attributes} = typeof config.frontmatter == "function" ? config.frontmatter(content) : {body: content, attributes: {}};
     return {
         content: body,
         data: attributes || {},
+        attributes: attributes || {},
+    };
+};
+
+// @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 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 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
@@ -113,7 +130,6 @@ const run = (config = {}) => {
         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()];
@@ -126,31 +142,63 @@ const run = (config = {}) => {
     }
     dispatch("initialize", []);
     // 2. initialize mikel instance
-    context.compiler = mikel.create(context.layout.content, config?.mikel || {});
+    const 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);
+    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 => {
-        context.compiler.addPartial("content", page.content); // register page content as partial
-        const content = context.compiler({
+        compiler.addPartial("content", page.content); // register page content as partial
+        const content = compiler({
             site: context.site,
             layout: context.layout,
             page: page,
         });
         dispatch("emitPage", [page, content]);
-        utils.saveFile(path.join(context.destination, page.url), content);
+        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);
+        saveFile(path.join(context.destination, asset.url), asset.content);
     });
     dispatch("done", []);
 };
 
+// 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
+        });
+    };
+};
+
+// 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)}`);
+        });
+        context.hooks.done.add(() => {
+            log("done", `build completed in ${Date.now() - timeStart}ms`);
+        });
+    };
+};
+
 // export
-export default {utils, plugins, run};
+export default {run, createVirtualPage, frontmatter, postsPlugin, progressPlugin};

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "mikel-press",
     "description": "A minimal static site generator based on mikel templating",
-    "version": "0.0.1",
+    "version": "0.2.0",
     "type": "module",
     "author": {
         "name": "Josemi Juanes",
@@ -12,16 +12,12 @@
     "bugs": "https://github.com/jmjuanes/mikel/issues",
     "main": "index.js",
     "module": "index.js",
+    "types": "index.d.ts",
     "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"
     },
@@ -39,6 +35,6 @@
     "files": [
         "README.md",
         "index.js",
-        "cli.js"
+        "index.d.ts"
     ]
 }

package/cli.js

@@ -1,47 +0,0 @@
-#!/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));