@moonwave99/goffre 0.0.4

package/LICENSE

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2021 Diego Caponera <hello@diegocaponera.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,125 @@
+# Goffre
+
+Goffre is a minimal static site generator available to the **node.js** ecosystem.
+
+It uses [handlebars][handlebars] as templating system and [markdown + frontmatter][mdfront] as data layer, or whatever you decide to pass to `render()`.
+
+## Installation
+
+```bash
+$ npm install goffre --save
+```
+
+## Basic Usage
+
+```js
+import { load, render } from "goffre";
+
+(async () => {
+    const { pages } = await load();
+
+    try {
+        const results = await render({ pages });
+        console.log(`Generated ${results.length} pages`);
+    } catch (error) {
+        console.log("Error generating site", error);
+    }
+})();
+```
+
+Default paths:
+
+-   **markdown files**: `./data` - used by `load()`
+-   **output folder**: `./dist` - used by `render()`
+-   **handlebars views**: `./src/views` - used by `render()`
+
+See [examples](#examples) for a more advanced use case, and the [documentation][docs] for the complete reference.
+
+## Data collecting and rendering are separate steps
+
+This is the key for the maximum flexibility: `load()` gets all the `.md` files inside the data folder, and populates its return `pages` each with a unique `slug`.
+
+The markdown body is available in the `content` key, and the YAML front matter is destructured - the output of `load()` of the following file:
+
+```yaml
+---
+title: "Goffre | Mini static site generator"
+slug: "index"
+---
+Goffre is a minimal static site generator available to the **node.js** ecosystem.
+```
+
+will be:
+
+```js
+{
+    title: "Goffre | Mini static site generator",
+    slug: "index",
+    content: "Goffre is a minimal static site generator available to the **node.js** ecosystem."
+}
+```
+
+**Note:** the markdown body is not yet parsed at this stage.
+
+The `render()` method writes then every incoming page to `{page.slug}.html` - you can add further pages to the collected ones, like the text you are reading from the main `README.md` file of the repository:
+
+```js
+const { pages } = await load({ dataPath });
+const results = await render({
+    buildPath,
+    sitePath,
+    pages: [
+        ...pages,
+        {
+            title: "Goffre | Mini static site generator",
+            description:
+                "Goffre is a minimal static site generator available to the node.js ecosystem.",
+            slug: "index",
+            content: await readFile(path.join("..", "README.md"), "utf8"),
+        },
+    ],
+});
+```
+
+## For a better development experience
+
+Goffre does not provide any watching / serving features out of the box, but don't worry.
+
+**Serving**: if you use [webpack][webpack] for bundling the frontend CSS and JS, just use its [dev server][webpack-dev-server] - see the [configuration file for this very page][webpack-config] as reference. If you don't, a simple [http-server][http-server] will do.
+
+**Watching**: use [nodemon][nodemon] to watch the _generation script_, the _data folder_ and the _handlebars views folder_:
+
+```bash
+$ nodemon -e js,json,md,handlebars --watch index.js --watch data --watch src/views
+```
+
+The scripts of `package.json` will look more or less like:
+
+```json
+{
+    "clean": "rm -rf dist",
+    "dev:client": "webpack serve --mode development",
+    "dev:site": "nodemon -e js,json,md,handlebars --watch index.js --watch data --watch src/views",
+    "build:client": "webpack --mode production",
+    "build:site": "node index.js"
+}
+```
+
+Just `npm run dev:client` and `npm run dev:site` in two terminal tabs and you are done. Don't forget to `npm install` the needed dependencies of course!
+
+## Examples
+
+-   [devblog][examples-devblog] - a personal website with blog posts and project pages
+-   this page of course
+
+[handlebars]: https://handlebarsjs.com/
+[express-handlebars]: https://www.npmjs.com/package/express-handlebars
+[mdfront]: https://www.google.com/search?q=markdown+frontmatter
+[webpack]: https://webpack.js.org/
+[webpack-dev-server]: https://webpack.js.org/configuration/dev-server/
+[http-server]: https://www.npmjs.com/package/http-server
+[nodemon]: https://www.npmjs.com/package/nodemon
+[example]: https://github.com/moonwave99/goffre/tree/main/examples/devblog
+[docs]: https://github.com/moonwave99/goffre/tree/main/examples/devblog
+[webpack-config]: https://github.com/moonwave99/goffre/blob/main/homepage/webpack.config.cjs
+[examples-devblog]: https://goffre-examples-devblog.netlify.app/

package/index.js

@@ -0,0 +1 @@
+export * from "./lib/goffre.js";

package/lib/goffre.js

@@ -0,0 +1,297 @@
+import path from "path";
+import { globby } from "globby";
+import { marked } from "marked";
+import matter from "gray-matter";
+import { createRequire } from "module";
+import fs from "fs-extra";
+import express from "express";
+import { engine } from "express-handlebars";
+import chalk from "chalk";
+import slugify from "slugify";
+import * as defaultHelpers from "./helpers.js";
+
+const require = createRequire(import.meta.url);
+const { readFile, outputFile } = fs;
+
+const DEFAULT_DATA_PATH = path.join(process.cwd(), "data");
+const DEFAULT_VIEWS_PATH = path.join(process.cwd(), "src", "views");
+const DEFAULT_BUILD_PATH = path.join(process.cwd(), "dist");
+const MAX_SLUG_LOG_LENGTH = 40;
+
+function log() {
+    console.log.apply(
+        null,
+        ["[goffre]", ...arguments].map((x) => chalk.cyan(x))
+    );
+}
+
+function getEnv() {
+    return {
+        mode: process.env.MODE || "dev",
+    };
+}
+
+function stringify(token) {
+    if (token instanceof Date) {
+        return token.toISOString().split("T")[0];
+    }
+    return token;
+}
+
+export function getSlug(slug, params) {
+    return slug
+        .split("/")
+        .reduce(
+            (memo, x) =>
+                !x.startsWith(":")
+                    ? [...memo, x]
+                    : [
+                          ...memo,
+                          slugify(stringify(params[x.slice(1)]), {
+                              lower: true,
+                              strict: true,
+                          }),
+                      ],
+            []
+        )
+        .join("/");
+}
+
+export function getTemplate({ page, templates, defaultTemplate = "_default" }) {
+    if (page.template) {
+        return page.template;
+    }
+    if (templates.find((x) => x.startsWith(page.slug))) {
+        return page.slug;
+    }
+    return defaultTemplate;
+}
+
+function renderPage({ app, templates, buildPath, maxSlugLogLength, ...page }) {
+    return new Promise((resolve, reject) => {
+        const template = getTemplate({ page, templates });
+
+        switch (app.locals.options.logLevel) {
+            case "silent":
+                break;
+            case "verbose":
+                log(
+                    `Generating ${chalk.yellow(
+                        page.slug.padEnd(maxSlugLogLength, " ")
+                    )} with template ${chalk.green(template)}...`
+                );
+                break;
+            case "normal":
+            default:
+                log(`Generating ${chalk.yellow(page.slug)}...`);
+        }
+
+        app.render(
+            template,
+            {
+                ...page,
+                layout:
+                    typeof page.layout === "undefined" ? "main" : page.layout,
+                content: page.content ? marked.parse(page.content) : null,
+            },
+            async (error, html) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                const outputFileName = `${page.slug}${page.extname || ".html"}`;
+                await outputFile(path.join(buildPath, outputFileName), html);
+                resolve({
+                    ...page,
+                    outputFileName,
+                });
+            }
+        );
+    });
+}
+
+export async function load({ dataPath } = {}) {
+    return {
+        json: await loadJSON(dataPath || DEFAULT_DATA_PATH),
+        pages: await loadMarkdown(dataPath || DEFAULT_DATA_PATH),
+    };
+}
+
+export async function loadJSON(cwd) {
+    const files = await globby("**/*.json", { cwd });
+    return files.reduce(
+        (memo, x) => ({
+            ...memo,
+            [path.basename(x, ".json")]: require(path.join(cwd, x)),
+        }),
+        {}
+    );
+}
+
+function excerpt(file) {
+    file.excerpt = file.content.split("\n")[1];
+}
+
+export async function loadMarkdown(cwd) {
+    const files = await globby("**/*.md", { cwd });
+    return Promise.all(
+        files.map(async (fileName) => {
+            const fullPath = path.join(cwd, fileName);
+            const contents = await readFile(fullPath, "utf-8");
+            const parsed = matter(contents, { excerpt });
+            const outputFileName = fileName.replace(".md", "");
+            const slug = !parsed.data.slug
+                ? outputFileName
+                : getSlug(parsed.data.slug, parsed.data);
+            return {
+                ...parsed.data,
+                excerpt: parsed.excerpt,
+                slug,
+                description: parsed.data.description || parsed.excerpt,
+                content: parsed.content,
+            };
+        })
+    );
+}
+
+export const getSorter =
+    ({ sortBy, order }) =>
+    (a, b) => {
+        let output;
+        if (a[sortBy] instanceof Date) {
+            output = new Date(a[sortBy]) - new Date(b[sortBy]);
+        } else {
+            output = a[sortBy] - b[sortBy];
+        }
+        return order === "desc" ? -output : output;
+    };
+
+export async function render({
+    pages,
+    viewsPath = DEFAULT_VIEWS_PATH,
+    buildPath = DEFAULT_BUILD_PATH,
+    domain,
+    uglyUrls = false,
+    logLevel = "normal",
+    locals = {},
+    markdown = {},
+    handlebars = {},
+    sitemap = {},
+    env = {},
+}) {
+    const extname = handlebars.extname || ".handlebars";
+    const app = express();
+    app.engine(
+        extname,
+        engine({
+            ...handlebars,
+            helpers: {
+                ...defaultHelpers,
+                ...handlebars.helpers,
+            },
+        })
+    );
+    app.set("view engine", "handlebars");
+    app.set("layoutsDir", path.join(viewsPath, "layouts"));
+    app.set("views", viewsPath);
+
+    const templates = await globby(`**/*${extname}`, {
+        cwd: viewsPath,
+    });
+
+    app.locals = {
+        ...app.locals,
+        ...locals,
+        options: {
+            domain,
+            uglyUrls,
+            logLevel,
+        },
+        env: { ...getEnv(), ...env },
+    };
+
+    marked.use(markdown);
+
+    switch (logLevel) {
+        case "silent":
+            break;
+        case "verbose":
+        case "normal":
+        default:
+            log(`Start generation...`);
+    }
+
+    const results = await Promise.all(
+        pages.map((x) =>
+            renderPage({
+                ...x,
+                buildPath,
+                app,
+                templates,
+                maxSlugLogLength: Math.min(
+                    Math.max.call(null, ...pages.map((x) => x.slug.length)),
+                    MAX_SLUG_LOG_LENGTH
+                ),
+            })
+        )
+    );
+
+    switch (logLevel) {
+        case "silent":
+            break;
+        case "verbose":
+        case "normal":
+        default:
+            log(`Generated ${results.length} pages`);
+    }
+
+    if (sitemap.generate) {
+        renderPage({
+            slug: "sitemap",
+            template: sitemap.template || "sitemap",
+            extname: ".xml",
+            layout: null,
+            pages: results,
+            buildPath,
+            app,
+            templates,
+        });
+    }
+
+    return results;
+}
+
+export function paginate({
+    collection,
+    size = 10,
+    sortBy = "slug",
+    order = "asc",
+}) {
+    const total = Math.ceil(collection.length / size);
+    return collection
+        .sort(getSorter({ sortBy, order }))
+        .reduce((memo, x, index) => {
+            if (index % size === 0) {
+                const page = Math.floor(index / size) + 1;
+                return [
+                    ...memo,
+                    {
+                        pagination: {
+                            page,
+                            prev: page > 1 ? page - 1 : null,
+                            next: page < total ? page + 1 : null,
+                            total,
+                        },
+                        items: [x],
+                    },
+                ];
+            }
+            return [
+                ...memo.slice(0, -1),
+                {
+                    ...memo[memo.length - 1],
+                    items: [...memo[memo.length - 1].items, x],
+                },
+            ];
+        }, []);
+}

package/lib/helpers.js

@@ -0,0 +1,84 @@
+import { getSorter, getSlug } from "./goffre.js";
+import { marked } from "marked";
+
+export const markdown = (text) => marked(text);
+
+export const getParamLink = (url, options) => {
+  const output = getSlug(url, options.hash);
+  return getAsset(output, options);
+};
+
+export const getAsset = (asset, context) => {
+  const { options, env } = context.data.root;
+  return env.mode === "prod" && options.domain
+    ? `${options.domain}${asset.startsWith("/") ? "" : "/"}${asset}`
+    : asset;
+};
+
+export const getSitemapLink = (page, context) => {
+  const { options } = context.data.root;
+  return `${options.domain}${getLink(page, context)}`;
+};
+
+export const getLink = (page, context) => {
+  const base =
+    page.link || `${page.slug.startsWith("/") ? "" : "/"}${page.slug}`;
+  const { uglyUrls } = context.data.root.options;
+  if (uglyUrls) {
+    return getAsset(`${base === "/" ? "/index" : base}.html`, context);
+  }
+  return getAsset(base.replace(/^\/index/, "/"), context);
+};
+
+export const getNavClass = ({ slug }, currentPage) => {
+  const cleanSlug = slug && slug[0] === "/" ? slug.slice(1) : slug;
+  return currentPage.slug.startsWith(cleanSlug)
+    ? `${cleanSlug} current`
+    : cleanSlug;
+};
+
+export const list = (context, options) => {
+  const offset = parseInt(options.hash.offset, 10) || 0;
+  const limit = parseInt(options.hash.limit, 10) || 100;
+  const sortBy = options.hash.sortBy || "slug";
+  const order = options.hash.order || "asc";
+
+  let output = "";
+  let i, j;
+
+  const data = [...context].sort(getSorter({ sortBy, order }));
+
+  if (offset < 0) {
+    i = -offset < data.length ? data.length - -offset : 0;
+  } else {
+    i = offset < data.length ? offset : 0;
+  }
+
+  j = limit + i < data.length ? limit + i : data.length;
+
+  for (i, j; i < j; i++) {
+    output += options.fn(data[i]);
+  }
+
+  return output;
+};
+
+export const nextItem = (context, options) => {
+  const { list } = options.hash;
+  const index = list.findIndex((x) => x.slug === context.slug);
+  const next = list[index + 1];
+  if (!next) {
+    return;
+  }
+  return options.fn(next);
+};
+
+export const prevItem = (context, options) => {
+  const { list } = options.hash;
+  const index = list.findIndex((x) => x.slug === context.slug);
+  const prev = list[index - 1];
+  if (!prev) {
+    return;
+  }
+  return options.fn(prev);
+};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@moonwave99/goffre",
+  "version": "0.0.4",
+  "description": "Mini static site generator",
+  "author": {
+    "name": "Diego Caponera",
+    "email": "hello@diegocaponera.com",
+    "url": "https://github.com/moonwwave99"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/moonwave99/goffre.git"
+  },
+  "homepage": "https://moonwave99.github.io/goffre",
+  "type": "module",
+  "scripts": {
+    "test": "ava **/*.test.js",
+    "lint": "npx eslint ./lib --ext .js,.jsx,.ts,.tsx"
+  },
+  "main": "index.js",
+  "keywords": [
+    "front-matter",
+    "generate",
+    "generator",
+    "markdown",
+    "static",
+    "static-site",
+    "yaml"
+  ],
+  "files": [
+    "lib/goffre.js",
+    "lib/helpers.js"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "express": "^4.17.1",
+    "express-handlebars": "^6.0.1",
+    "fs-extra": "^10.0.0",
+    "globby": "^12.0.2",
+    "gray-matter": "^4.0.3",
+    "marked": "^4.0.3",
+    "slugify": "^1.6.2"
+  },
+  "devDependencies": {
+    "ava": "^3.15.0",
+    "cheerio": "^1.0.0-rc.10",
+    "dirname-filename-esm": "^1.1.1",
+    "eslint": "^8.3.0",
+    "faker": "^5.5.3",
+    "js-yaml": "^4.1.0",
+    "rimraf": "^3.0.2",
+    "sinon": "^12.0.1"
+  }
+}