@moonwave99/goffre 0.0.7 → 0.1.1

package/LICENSE

@@ -1,6 +1,6 @@
 (The MIT License)
 
-Copyright (c) 2021 Diego Caponera <hello@diegocaponera.com>
+Copyright (c) 2026 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

package/README.md

@@ -7,31 +7,31 @@ It uses [handlebars][handlebars] as templating system and [markdown + frontmatte
 ## Installation
 
 ```bash
-$ npm install goffre --save
+npm install @moonwave99/goffre --save
 ```
 
 ## Basic Usage
 
 ```js
-import { load, render } from "goffre";
+import { load, render } from "@moonwave99/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);
-    }
+  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()`
+- **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.
 
@@ -66,18 +66,18 @@ The `render()` method writes then every incoming page to `{page.slug}.html` - yo
 ```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"),
-        },
-    ],
+  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"),
+    },
+  ],
 });
 ```
 
@@ -97,11 +97,11 @@ 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"
+  "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"
 }
 ```
 
@@ -109,17 +109,15 @@ Just `npm run dev:client` and `npm run dev:site` in two terminal tabs and you ar
 
 ## Examples
 
--   [devblog][examples-devblog] - a personal website with blog posts and project pages
--   this page of course
+- [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/dist/index.d.ts

@@ -0,0 +1,83 @@
+import { MarkedExtension, RendererObject } from 'marked';
+
+type Page = {
+    slug: string;
+    link?: string;
+    template?: string;
+    layout?: string | null;
+    content?: string;
+    extname?: string;
+};
+declare function getSlug(slug: string, params: Record<string, unknown>): string;
+type GetTemplateParams = {
+    page: Page;
+    templates: string[];
+    defaultTemplate?: string;
+};
+declare function getTemplate({ page, templates, defaultTemplate, }: GetTemplateParams): string;
+type LoadParams = {
+    dataPath?: string;
+};
+declare function load({ dataPath }?: LoadParams): Promise<{
+    json: {};
+    pages: {
+        excerpt: string | undefined;
+        slug: string;
+        description: any;
+        content: string;
+    }[];
+}>;
+declare function loadJSON(cwd: string): Promise<{}>;
+declare function loadMarkdown(cwd: string): Promise<{
+    excerpt: string | undefined;
+    slug: string;
+    description: any;
+    content: string;
+}[]>;
+type GetSorterParams = {
+    sortBy: string;
+    order: "asc" | "desc";
+};
+declare function getSorter<T extends Record<string, unknown>>({ sortBy, order, }: GetSorterParams): (a: T, b: T) => number;
+type RenderParams = {
+    pages: Page[];
+    viewsPath?: string;
+    buildPath?: string;
+    blockSeparator?: string;
+    domain?: string;
+    uglyUrls?: boolean;
+    logLevel?: "silent" | "verbose" | "normal";
+    locals: Record<string, unknown>;
+    sitemap?: {
+        generate?: boolean;
+        template?: string;
+    };
+    env?: Record<string, unknown>;
+    handlebars?: {
+        extname?: string;
+        helpers?: Record<string, unknown>;
+    };
+    markdown?: {
+        middleware?: (MarkedExtension | (() => MarkedExtension))[];
+        renderer?: RendererObject;
+    };
+};
+declare function render({ pages, viewsPath, buildPath, blockSeparator, domain, uglyUrls, logLevel, locals, markdown, handlebars, sitemap, env, }: RenderParams): Promise<unknown[]>;
+type PaginateParams<T extends Page> = {
+    collection: T[];
+    size?: number;
+    sortBy?: keyof T;
+    order?: "asc" | "desc";
+};
+type PaginatedResult<T extends Page> = {
+    pagination: {
+        page: number;
+        prev: number | null;
+        next: number | null;
+        total: number;
+    };
+    items: T[];
+};
+declare function paginate<T extends Page>({ collection, size, sortBy, order, }: PaginateParams<T>): PaginatedResult<T>[];
+
+export { type Page, getSlug, getSorter, getTemplate, load, loadJSON, loadMarkdown, paginate, render };

package/dist/index.js

@@ -0,0 +1,395 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// lib/goffre.ts
+import path from "path";
+import { globby } from "globby";
+import { marked as marked2 } 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";
+
+// lib/helpers.ts
+var helpers_exports = {};
+__export(helpers_exports, {
+  getAsset: () => getAsset,
+  getLink: () => getLink,
+  getNavClass: () => getNavClass,
+  getParamLink: () => getParamLink,
+  getSitemapLink: () => getSitemapLink,
+  list: () => list,
+  markdown: () => markdown,
+  nextItem: () => nextItem,
+  prevItem: () => prevItem
+});
+import { marked } from "marked";
+var markdown = (text) => marked(text);
+var getParamLink = (url, options) => {
+  const output = getSlug(url, options.hash);
+  return getAsset(output, options);
+};
+var getAsset = (asset, context) => {
+  const { options, env } = context.data.root;
+  return env.mode === "prod" && options.domain ? `${options.domain}${asset.startsWith("/") ? "" : "/"}${asset}` : asset;
+};
+var getSitemapLink = (page, context) => {
+  const { options } = context.data.root;
+  return `${options.domain}${getLink(page, context)}`;
+};
+var 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);
+};
+var getNavClass = ({ slug }, currentPage) => {
+  const cleanSlug = slug && slug[0] === "/" ? slug.slice(1) : slug;
+  return currentPage.slug.startsWith(cleanSlug) ? `${cleanSlug} current` : cleanSlug;
+};
+var 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;
+  const data = context.toSorted(getSorter({ sortBy, order }));
+  if (offset < 0) {
+    i = -offset < data.length ? data.length - -offset : 0;
+  } else {
+    i = offset < data.length ? offset : 0;
+  }
+  const j = limit + i < data.length ? limit + i : data.length;
+  for (; i < j; i++) {
+    output += options.fn(data[i]);
+  }
+  return output;
+};
+var nextItem = (context, options) => {
+  const { list: list2 } = options.hash;
+  const index = list2.findIndex((x) => x.slug === context.slug);
+  const next = list2[index + 1];
+  if (!next) {
+    return;
+  }
+  return options.fn(next);
+};
+var prevItem = (context, options) => {
+  const { list: list2 } = options.hash;
+  const index = list2.findIndex((x) => x.slug === context.slug);
+  const prev = list2[index - 1];
+  if (!prev) {
+    return;
+  }
+  return options.fn(prev);
+};
+
+// lib/goffre.ts
+var require2 = createRequire(import.meta.url);
+var { readFile, outputFile } = fs;
+var DEFAULT_DATA_PATH = path.join(process.cwd(), "data");
+var DEFAULT_VIEWS_PATH = path.join(process.cwd(), "src", "views");
+var DEFAULT_BUILD_PATH = path.join(process.cwd(), "dist");
+var MAX_SLUG_LOG_LENGTH = 40;
+var DEFAULT_BLOCK_SEPARATOR = "<!-- block -->";
+function log(...args) {
+  console.log.apply(
+    null,
+    ["[goffre]", ...args].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}`;
+}
+function getSlug(slug, params) {
+  return slug.split("/").reduce((memo, x) => {
+    if (!x.startsWith(":")) {
+      return [...memo, x];
+    }
+    const param = x.slice(1);
+    const value = params[param];
+    if (!value) {
+      throw new Error(`No value found for parameter: ${param}`);
+    }
+    return [
+      ...memo,
+      slugify(stringify(value), {
+        lower: true,
+        strict: true
+      })
+    ];
+  }, []).join("/");
+}
+function getTemplate({
+  page,
+  templates = [],
+  defaultTemplate = "_default"
+}) {
+  if (templates.find((x) => x === `${page.template}.handlebars`)) {
+    return page.template;
+  }
+  if (templates.find((x) => x.startsWith(page.slug))) {
+    return page.slug;
+  }
+  return defaultTemplate;
+}
+function renderPage({
+  app,
+  templates,
+  buildPath,
+  maxSlugLogLength,
+  blockSeparator,
+  ...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 || MAX_SLUG_LOG_LENGTH, " ")
+          )} 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 ? marked2.parse(page.content) : null,
+        blocks: getPageBlocks(
+          page.content,
+          blockSeparator || DEFAULT_BLOCK_SEPARATOR
+        )
+      },
+      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
+        });
+      }
+    );
+  });
+}
+function getPageBlocks(content = "", separator) {
+  if (!content.includes(separator)) {
+    return [];
+  }
+  const blocks = content.split(separator).map((x) => marked2.parse(x));
+  return blocks.filter(Boolean);
+}
+async function load({ dataPath } = {}) {
+  return {
+    json: await loadJSON(dataPath || DEFAULT_DATA_PATH),
+    pages: await loadMarkdown(dataPath || DEFAULT_DATA_PATH)
+  };
+}
+async function loadJSON(cwd) {
+  const files = await globby("**/*.json", { cwd });
+  return files.reduce(
+    (memo, x) => ({
+      ...memo,
+      [path.basename(x, ".json")]: require2(path.join(cwd, x))
+    }),
+    {}
+  );
+}
+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: true });
+      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
+      };
+    })
+  );
+}
+function getSorter({
+  sortBy,
+  order
+}) {
+  return (a, b) => {
+    let output;
+    const valA = a[sortBy];
+    const valB = b[sortBy];
+    if (valA instanceof Date && valB instanceof Date) {
+      output = Number(new Date(valA)) - Number(new Date(valB));
+    } else {
+      output = Number(valA) - Number(valB);
+    }
+    return order === "desc" ? -output : output;
+  };
+}
+async function render({
+  pages,
+  viewsPath = DEFAULT_VIEWS_PATH,
+  buildPath = DEFAULT_BUILD_PATH,
+  blockSeparator = DEFAULT_BLOCK_SEPARATOR,
+  domain,
+  uglyUrls = false,
+  logLevel = "normal",
+  locals = {},
+  markdown: markdown2 = {},
+  handlebars = {},
+  sitemap = {},
+  env = {}
+}) {
+  const extname = handlebars.extname || ".handlebars";
+  const app = express();
+  app.engine(
+    extname,
+    engine({
+      ...handlebars,
+      helpers: {
+        ...helpers_exports,
+        ...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 }
+  };
+  if (markdown2.middleware) {
+    markdown2.middleware.forEach(
+      (x) => marked2.use(typeof x === "function" ? x() : x)
+    );
+  }
+  marked2.use(markdown2);
+  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,
+        blockSeparator,
+        maxSlugLogLength: Math.min(
+          Math.max.call(null, ...pages.map((x2) => x2.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;
+}
+function paginate({
+  collection,
+  size = 10,
+  sortBy = "slug",
+  order = "asc"
+}) {
+  const total = Math.ceil(collection.length / size);
+  return collection.toSorted(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]
+      }
+    ];
+  }, []);
+}
+export {
+  getSlug,
+  getSorter,
+  getTemplate,
+  load,
+  loadJSON,
+  loadMarkdown,
+  paginate,
+  render
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moonwave99/goffre",
-  "version": "0.0.7",
+  "version": "0.1.1",
   "description": "Mini static site generator",
   "author": {
     "name": "Diego Caponera",
@@ -13,11 +13,23 @@
   },
   "homepage": "https://moonwave99.github.io/goffre",
   "type": "module",
-  "scripts": {
-    "test": "ava **/*.test.js",
-    "lint": "npx eslint ./lib --ext .js,.jsx,.ts,.tsx"
+  "ava": {
+    "extensions": {
+      "ts": "module"
+    },
+    "nodeArguments": [
+      "--import=tsimp"
+    ],
+    "environmentVariables": {
+      "TSIMP_DIAG": "ignore"
+    }
   },
-  "main": "index.js",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
   "keywords": [
     "front-matter",
     "generate",
@@ -27,29 +39,46 @@
     "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",
+    "express-handlebars": "^8.0.6",
     "fs-extra": "^10.0.0",
     "globby": "^12.0.2",
     "gray-matter": "^4.0.3",
-    "marked": "^4.0.3",
+    "marked": "^17.0.3",
     "slugify": "^1.6.2"
   },
   "devDependencies": {
-    "ava": "^3.15.0",
+    "@eslint/compat": "^2.0.2",
+    "@eslint/eslintrc": "^3.3.3",
+    "@eslint/js": "^10.0.1",
+    "@faker-js/faker": "^10.3.0",
+    "@types/express": "^5.0.6",
+    "@types/fs-extra": "^11.0.4",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^25.2.3",
+    "@types/sinon": "^21.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.56.0",
+    "@typescript-eslint/parser": "^8.56.0",
+    "ava": "^6.4.1",
     "cheerio": "^1.0.0-rc.10",
     "dirname-filename-esm": "^1.1.1",
-    "eslint": "^8.3.0",
+    "eslint": "^10.0.0",
     "faker": "^5.5.3",
-    "js-yaml": "^4.1.0",
-    "rimraf": "^3.0.2",
-    "sinon": "^12.0.1"
+    "globals": "^17.3.0",
+    "js-yaml": "^4.1.1",
+    "rimraf": "^6.1.3",
+    "sinon": "^21.0.1",
+    "tsimp": "^2.0.12",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "ava **/*.test.ts",
+    "lint": "pnpm eslint ./lib --ext .js,.jsx,.ts,.tsx"
   }
-}
+}

package/index.js

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

package/lib/goffre.js

@@ -1,325 +0,0 @@
-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;
-const DEFAULT_BLOCK_SEPARATOR = "<!-- block -->";
-
-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 (templates.find((x) => x === `${page.template}.handlebars`)) {
-    return page.template;
-  }
-  if (templates.find((x) => x.startsWith(page.slug))) {
-    return page.slug;
-  }
-  return defaultTemplate;
-}
-
-function renderPage({
-  app,
-  templates,
-  buildPath,
-  maxSlugLogLength,
-  blockSeparator,
-  ...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,
-        blocks: getPageBlocks(page.content, blockSeparator),
-      },
-      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,
-        });
-      },
-    );
-  });
-}
-
-function getPageBlocks(content = "", separator) {
-  if (!content.includes(separator)) {
-    return [];
-  }
-  const blocks = content.split(separator).map((x) => marked.parse(x));
-  return blocks.filter(Boolean);
-}
-
-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,
-  blockSeparator = DEFAULT_BLOCK_SEPARATOR,
-  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 },
-  };
-
-  if (markdown.middleware) {
-    markdown.middleware.forEach((x) =>
-      marked.use(typeof x === "function" ? x() : x),
-    );
-  }
-
-  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,
-        blockSeparator,
-        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

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