@moonwave99/goffre 0.1.5 → 0.1.6

package/dist/index.d.mts

@@ -0,0 +1,141 @@
+import { MarkedExtension, RendererObject } from "marked";
+import { HelperOptions } from "handlebars";
+
+//#region lib/goffre.d.ts
+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;
+    slug: string;
+    description: any;
+    content: string;
+  }[];
+}>;
+declare function loadJSON(cwd: string): Promise<{}>;
+declare function loadMarkdown(cwd: string): Promise<{
+  excerpt: string;
+  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>[];
+declare namespace helpers_d_exports {
+  export { getAsset, getExcerpt, getLink, getNavClass, getParamLink, getSitemapLink, list, markdown$1 as markdown, nextItem, prevItem };
+}
+type Context = {
+  data: {
+    root: {
+      options?: {
+        domain?: string;
+        env?: {
+          mode?: string;
+        };
+      };
+    };
+  };
+};
+type HelperContext = Context & Omit<HelperOptions, "fn" | "inverse">;
+type BlockContext = Context & HelperOptions;
+declare const markdown$1: (text: string) => string | Promise<string>;
+declare function getExcerpt(content: string): Promise<string>;
+declare const getParamLink: (url: string, options: HelperContext) => string;
+declare const getAsset: (asset: string, context: Omit<HelperContext, "hash">) => string;
+declare const getSitemapLink: (page: Page, context: HelperContext) => string;
+declare const getLink: (page: Page, context: HelperContext) => string;
+declare const getNavClass: ({
+  slug
+}: Page, currentPage: Page) => string;
+declare const list: (context: Page[], options: BlockContext) => string;
+declare const nextItem: (context: Page, options: Pick<BlockContext, "hash" | "fn">) => string | undefined;
+declare const prevItem: (context: Page, options: Pick<BlockContext, "hash" | "fn">) => string | undefined;
+//#endregion
+export { Page, getSlug, getSorter, getTemplate, helpers_d_exports as helpers, load, loadJSON, loadMarkdown, paginate, render };

package/dist/index.mjs

@@ -0,0 +1,280 @@
+import { t as __exportAll } from "./chunk-DQk6qfdC.mjs";
+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 { stripHtml } from "string-strip-html";
+
+//#region lib/helpers.ts
+var helpers_exports = /* @__PURE__ */ __exportAll({
+	getAsset: () => getAsset,
+	getExcerpt: () => getExcerpt,
+	getLink: () => getLink,
+	getNavClass: () => getNavClass,
+	getParamLink: () => getParamLink,
+	getSitemapLink: () => getSitemapLink,
+	list: () => list,
+	markdown: () => markdown,
+	nextItem: () => nextItem,
+	prevItem: () => prevItem
+});
+const markdown = (text) => marked(text);
+async function getExcerpt(content) {
+	const firstParagraph = content.split("\n").filter(Boolean).at(0);
+	if (!firstParagraph) return "";
+	return stripHtml(await marked(firstParagraph)).result;
+}
+const getParamLink = (url, options) => {
+	return getAsset(getSlug(url, options.hash), options);
+};
+const getAsset = (asset, context) => {
+	const { options, env } = context.data.root;
+	return env.mode === "prod" && options.domain ? `${options.domain}${asset.startsWith("/") ? "" : "/"}${asset}` : asset;
+};
+const getSitemapLink = (page, context) => {
+	const { options } = context.data.root;
+	return `${options.domain}${getLink(page, context)}`;
+};
+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);
+};
+const getNavClass = ({ slug }, currentPage) => {
+	const cleanSlug = slug && slug[0] === "/" ? slug.slice(1) : slug;
+	return currentPage.slug.startsWith(cleanSlug) ? `${cleanSlug} current` : cleanSlug;
+};
+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;
+	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;
+};
+const nextItem = (context, options) => {
+	const { list } = options.hash;
+	const next = list[list.findIndex((x) => x.slug === context.slug) + 1];
+	if (!next) return;
+	return options.fn(next);
+};
+const prevItem = (context, options) => {
+	const { list } = options.hash;
+	const prev = list[list.findIndex((x) => x.slug === context.slug) - 1];
+	if (!prev) return;
+	return options.fn(prev);
+};
+
+//#endregion
+//#region lib/goffre.ts
+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 -->";
+const thisYear = (/* @__PURE__ */ new Date()).getFullYear();
+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, sitemapLink, ...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;
+			default: log(`Generating ${chalk.yellow(page.slug)}...`);
+		}
+		app.render(template, {
+			...page,
+			sitemapLink,
+			thisYear,
+			layout: typeof page.layout === "undefined" ? "main" : page.layout,
+			content: page.content ? marked.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 [];
+	return content.split(separator).map((x) => marked.parse(x)).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) {
+	return (await globby("**/*.json", { cwd })).reduce((memo, x) => ({
+		...memo,
+		[path.basename(x, ".json")]: require(path.join(cwd, x))
+	}), {});
+}
+async function loadMarkdown(cwd) {
+	const files = await globby("**/*.md", { cwd });
+	return Promise.all(files.map(async (fileName) => {
+		const parsed = matter(await readFile(path.join(cwd, fileName), "utf-8"));
+		const outputFileName = fileName.replace(".md", "");
+		const slug = !parsed.data.slug ? outputFileName : getSlug(parsed.data.slug, parsed.data);
+		return {
+			...parsed.data,
+			excerpt: await getExcerpt(parsed.content),
+			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 = {}, 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 (markdown.middleware) markdown.middleware.forEach((x) => marked.use(typeof x === "function" ? x() : x));
+	marked.use(markdown);
+	switch (logLevel) {
+		case "silent": break;
+		default: log(`Start generation...`);
+	}
+	const results = await Promise.all(pages.map((x) => renderPage({
+		...x,
+		buildPath,
+		app,
+		templates,
+		sitemapLink: sitemap.generate ? `${domain}/sitemap.xml` : "",
+		blockSeparator,
+		maxSlugLogLength: Math.min(Math.max.call(null, ...pages.map((x) => x.slug.length)), MAX_SLUG_LOG_LENGTH)
+	})));
+	switch (logLevel) {
+		case "silent": break;
+		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]
+		}];
+	}, []);
+}
+
+//#endregion
+export { getSlug, getSorter, getTemplate, helpers_exports as helpers, load, loadJSON, loadMarkdown, paginate, render };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moonwave99/goffre",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Mini static site generator",
   "author": {
     "name": "Diego Caponera",
@@ -47,6 +47,7 @@
     "fs-extra": "^10.0.0",
     "globby": "^12.0.2",
     "gray-matter": "^4.0.3",
+    "handlebars": "^4.7.8",
     "marked": "^17.0.3",
     "slugify": "^1.6.2",
     "string-strip-html": "^13.5.3"
@@ -72,13 +73,13 @@
     "js-yaml": "^4.1.1",
     "rimraf": "^6.1.3",
     "sinon": "^21.0.1",
+    "tsdown": "^0.20.3",
     "tsimp": "^2.0.12",
-    "tsup": "^8.5.1",
     "typescript": "^5.9.3"
   },
   "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
+    "build": "tsdown",
+    "dev": "tsdown --watch",
     "test": "ava **/*.test.ts",
     "lint": "pnpm eslint ./lib --ext .js,.jsx,.ts,.tsx"
   }

package/dist/index.d.ts

@@ -1,188 +0,0 @@
-import { MarkedExtension, RendererObject } from 'marked';
-import { HelperOptions } from 'handlebars';
-
-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;
-        slug: string;
-        description: any;
-        content: string;
-    }[];
-}>;
-declare function loadJSON(cwd: string): Promise<{}>;
-declare function loadMarkdown(cwd: string): Promise<{
-    excerpt: string;
-    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>[];
-
-type Context = {
-    data: {
-        root: {
-            options?: {
-                domain?: string;
-                env?: {
-                    mode?: string;
-                };
-            };
-        };
-    };
-};
-type HelperContext = Context & Omit<HelperOptions, "fn" | "inverse">;
-type BlockContext = Context & HelperOptions;
-declare const markdown: (text: string) => string | Promise<string>;
-declare function getExcerpt(content: string): Promise<string>;
-declare const getParamLink: (url: string, options: HelperContext) => string;
-declare const getAsset: (asset: string, context: Omit<HelperContext, "hash">) => string;
-declare const getSitemapLink: (page: Page, context: HelperContext) => string;
-declare const getLink: (page: Page, context: HelperContext) => string;
-declare const getNavClass: ({ slug }: Page, currentPage: Page) => string;
-declare const list: (context: Page[], options: BlockContext) => string;
-declare const nextItem: (context: Page, options: Pick<BlockContext, "hash" | "fn">) => string | undefined;
-declare const prevItem: (context: Page, options: Pick<BlockContext, "hash" | "fn">) => string | undefined;
-
-declare const helpers_getAsset: typeof getAsset;
-declare const helpers_getExcerpt: typeof getExcerpt;
-declare const helpers_getLink: typeof getLink;
-declare const helpers_getNavClass: typeof getNavClass;
-declare const helpers_getParamLink: typeof getParamLink;
-declare const helpers_getSitemapLink: typeof getSitemapLink;
-declare const helpers_list: typeof list;
-declare const helpers_markdown: typeof markdown;
-declare const helpers_nextItem: typeof nextItem;
-declare const helpers_prevItem: typeof prevItem;
-declare namespace helpers {
-  export { helpers_getAsset as getAsset, helpers_getExcerpt as getExcerpt, helpers_getLink as getLink, helpers_getNavClass as getNavClass, helpers_getParamLink as getParamLink, helpers_getSitemapLink as getSitemapLink, helpers_list as list, helpers_markdown as markdown, helpers_nextItem as nextItem, helpers_prevItem as prevItem };
-}
-
-declare function getRandomProjectNames(length: number): string[];
-type WriteOutputParams = {
-    basePath: string;
-    fileName: string;
-    output: string;
-};
-declare function writeOutput({ basePath, fileName, output, }: WriteOutputParams): Promise<void>;
-declare function toMarkdownFile({ content, ...frontMatter }: {
-    content: string;
-    frontMatter: Record<string, unknown>;
-}): string;
-type GeneratePostParams = {
-    index: number;
-    template?: string;
-    slug?: string;
-    withBlocks?: boolean;
-};
-declare function generatePost({ index, template, slug, withBlocks, }: GeneratePostParams): {
-    title: string;
-    template: string;
-    created_at: Date;
-    slug: string;
-    cover: {
-        url: string;
-        caption: string;
-        attribution: {
-            text: string;
-            link: string;
-        };
-    };
-    fileName: string;
-    content: string;
-};
-declare function generateProject({ name, index, }: {
-    name: string;
-    index: number;
-}): {
-    title: string;
-    slug: string;
-    template: string;
-    work_date: Date;
-    homepage: string;
-    demo: string;
-    technologies: string[];
-    cover: {
-        url: string;
-        caption: string;
-        attribution: {
-            text: string;
-            link: string;
-        };
-    };
-    fileName: string;
-    content: string;
-};
-
-declare const generator_generatePost: typeof generatePost;
-declare const generator_generateProject: typeof generateProject;
-declare const generator_getRandomProjectNames: typeof getRandomProjectNames;
-declare const generator_toMarkdownFile: typeof toMarkdownFile;
-declare const generator_writeOutput: typeof writeOutput;
-declare namespace generator {
-  export { generator_generatePost as generatePost, generator_generateProject as generateProject, generator_getRandomProjectNames as getRandomProjectNames, generator_toMarkdownFile as toMarkdownFile, generator_writeOutput as writeOutput };
-}
-
-export { type Page, generator, getSlug, getSorter, getTemplate, helpers, load, loadJSON, loadMarkdown, paginate, render };