npm - @kaathewise/ssg - Versions diffs - 0.1.0-alpha.0 - Mend

@kaathewise/ssg 0.1.0-alpha.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

package/package.json ADDED Viewed

@@ -0,0 +1,24 @@
+{
+	"name": "@kaathewise/ssg",
+	"description": "Djot, Typst & Vite components static site generator",
+	"version": "0.1.0-alpha.0",
+	"license": "MPL",
+	"author": "Andrej Kolčin",
+	"type": "module",
+	"scripts": {
+		"lint": "biome check --fix --unsafe",
+		"check": "biome check",
+		"smoke": "cd examples/basic/; node ../../src/index.js"
+	},
+	"dependencies": {
+		"@djot/djot": "^0.3.2",
+		"@tailwindcss/postcss": "^4.1.11",
+		"chokidar": "^4.0.3",
+		"handlebars": "^4.7.8",
+		"postcss": "^8.5.6",
+		"vite": "^7.0.2"
+	},
+	"files": [
+		"src/"
+	]
+}

package/src/config.js ADDED Viewed

@@ -0,0 +1,43 @@
+import { promises as fs } from "node:fs"
+import path from "node:path"
+import process from "node:process"
+import { find_dir_with_file } from "./util.js"
+export default {
+	root: undefined,
+	async init() {
+		const [root, config_path] = await find_dir_with_file(
+			process.cwd(),
+			"ssg.config.js",
+		)
+		if (config_path === null) {
+			throw new Error("No config file")
+		}
+		const module = await import(config_path)
+		this.options = module.default
+		this.root = path.resolve(root)
+	},
+	get pages() {
+		return path.join(this.root, "pages/")
+	},
+	get target() {
+		return path.join(this.root, "target/")
+	},
+	get tree() {
+		return path.join(this.target, "tree/")
+	},
+	get assets() {
+		return path.join(this.tree, "assets/")
+	},
+	get gen_assets() {
+		return path.join(this.assets, "generated/")
+	},
+}

package/src/djot.js ADDED Viewed

@@ -0,0 +1,91 @@
+import { promises as fs } from "node:fs"
+import path from "node:path"
+import djot from "@djot/djot"
+import config from "./config.js"
+import { CACHE } from "./typst.js"
+export function parse(src) {
+	return djot.parse(src)
+}
+export function metadata(doc) {
+	const block = doc.children[0]
+	if (block.tag === "raw_block" && block.format === "metadata") {
+		return JSON.parse(block.text)
+	}
+	return null
+}
+export async function render(doc) {
+	await apply_filter(doc, typst_filter)
+	await apply_filter(doc, classes_filter)
+	return `<!doctype html>\n ${djot.renderHTML(doc)}`
+}
+async function apply_filter(element, filter) {
+	if (element.children) {
+		for (let i = 0; i < element.children.length; i += 1) {
+			const result = await apply_filter(
+				element.children[i],
+				filter,
+			)
+			if (result) {
+				element.children[i] = result
+			}
+		}
+	}
+	if (filter instanceof Function) {
+		return await filter(element)
+	}
+	for (const [tag, func] of Object.entries(filter)) {
+		if (tag === element.tag) {
+			return await func(element)
+		}
+	}
+}
+async function apply_func(element, func) {
+	const output = await func(element)
+	if (output) {
+		for (const [key, value] of Object.entries(output)) {
+			element[key] = value
+		}
+	}
+}
+const typst_filter = {
+	inline_math: async el => {
+		const formula = el.text
+		const path = await CACHE.insert(formula)
+		return {
+			tag: "raw_inline",
+			format: "html",
+			text: `<img src="/${path}" class=math-inline>`,
+		}
+	},
+	display_math: async el => {
+		const formula = el.text
+		const path = await CACHE.insert(formula)
+		return {
+			tag: "raw_inline",
+			format: "html",
+			text: `<p class=math-container><img src="/${path}" class=math-display></p>`,
+		}
+	},
+}
+async function classes_filter(element) {
+	if (element.attributes?.class) {
+		await fs.appendFile(
+			path.join(config.target, "classes"),
+			`${element.attributes.class}\n`,
+		)
+	}
+}

package/src/index.js ADDED Viewed

@@ -0,0 +1,12 @@
+import { fork } from "node:child_process"
+import { promises as fs } from "node:fs"
+import path from "node:path"
+import Proc from "./proc.js"
+import config from "./config.js"
+await config.init()
+const vite = Proc.launch("vite.js")
+const tailwind = Proc.launch("tailwind.js")
+const pages = Proc.launch("render.js")

package/src/page.js ADDED Viewed

@@ -0,0 +1,73 @@
+import { promises as fs } from "node:fs"
+import path from "node:path"
+import Handlebars from "handlebars"
+import config from "./config.js"
+import * as djot from "./djot.js"
+import { find_dir_with_file } from "./util.js"
+export class Page {
+	constructor(src) {
+		this.src = src
+		const parsed = path.parse(path.relative("pages/", src))
+		parsed.base = null // it overrules ext and name
+		if (parsed.ext === ".dj") {
+			this.type = "djot"
+			if (parsed.name === "index") {
+				parsed.ext = "html"
+			} else {
+				parsed.ext = null
+			}
+		} else if (parsed.ext === ".html") {
+			this.type = "html"
+			// left as-is
+		} else {
+			throw new Error(
+				`The file must be HTML or Djot, got ${src}`,
+			)
+		}
+		this.dst = path.join(config.tree, path.format(parsed))
+	}
+	async raw() {
+		return fs.readFile(this.src, "utf8")
+	}
+	async template() {
+		const [_, template_path] = await find_dir_with_file(
+			path.dirname(this.src),
+			"template.html.hbs",
+		)
+		const template_raw = await fs.readFile(template_path, "utf8")
+		const template = Handlebars.compile(template_raw)
+		return template
+	}
+	async render() {
+		const raw = await this.raw()
+		switch (this.type) {
+			case "djot": {
+				return await this.#render_djot(raw)
+			}
+			case "html":
+				return raw
+		}
+	}
+	async #render_djot(raw) {
+		const template = await this.template()
+		const doc = djot.parse(raw)
+		const metadata = djot.metadata(doc)
+		const body = await djot.render(doc)
+		return template({ body, metadata })
+	}
+	async write() {
+		await fs.mkdir(path.dirname(this.dst), { recursive: true })
+		await fs.writeFile(this.dst, await this.render())
+	}
+}

package/src/proc.js ADDED Viewed

@@ -0,0 +1,56 @@
+// Main process behavior handling
+import { fork } from "node:child_process"
+import path from "node:path"
+import readline from "node:readline"
+import { dirname } from "./util.js"
+function is_shutdown_key(key) {
+	if (!key) {
+		return false
+	}
+	return key.name.toLowerCase() === "q" || (key.name === "c" && key.ctrl)
+}
+const Proc = {
+	children: [],
+	init() {
+		readline.emitKeypressEvents(process.stdin)
+		process.stdin.setRawMode(true)
+		process.stdin.on("keypress", (chunk, key) => {
+			if (is_shutdown_key(key)) {
+				this.shutdown()
+			}
+		})
+		process.stdin.on("data", key => {
+			if (key === "q" || key === "Q") {
+				this.shutdown()
+			}
+		})
+		process.on("SIGINT", () => this.shutdown())
+	},
+	launch(name) {
+		const location = path.join(dirname(), name)
+		const child = fork(location)
+		this.children.push(child)
+		return child
+	},
+	shutdown() {
+		for (const child of this.children) {
+			child.kill()
+		}
+		process.exit()
+	},
+}
+Proc.init()
+export default Proc

package/src/render.js ADDED Viewed

@@ -0,0 +1,42 @@
+import { promises as fs } from "node:fs"
+import path from "node:path"
+import chokidar from "chokidar"
+import config from "./config.js"
+import { Page } from "./page.js"
+import { silence_warning } from "./util.js"
+async function update(file) {
+	const page = new Page(file)
+	await page.write()
+}
+async function* pages() {
+	const pattern = path.join(config.pages, "**/*.dj")
+	const files = fs.glob(pattern)
+	for await (const djot_path of files) {
+		yield new Page(djot_path)
+	}
+}
+async function update_all() {
+	for await (const page of pages()) {
+		await page.write()
+	}
+}
+silence_warning("ExperimentalWarning")
+await config.init()
+await fs.rm(config.target, { recursive: true, force: true })
+await update_all()
+const watcher = chokidar.watch("pages/", {
+	persistent: true,
+	ignoreInitial: true,
+})
+watcher.on("all", async (event, file) => {
+	await update(file)
+	console.log(`${file} updated`)
+})

package/src/tailwind.js ADDED Viewed

@@ -0,0 +1,32 @@
+import { promises as fs } from "node:fs"
+import path from "node:path"
+import process from "node:process"
+import tailwindcss from "@tailwindcss/postcss"
+import chokidar from "chokidar"
+import postcss from "postcss"
+import config from "./config.js"
+async function run() {
+	const css = await fs.readFile("style.css", "utf8")
+	const result = postcss([tailwindcss]).process(css, {
+		from: "style.css",
+		to: path.join(config.gen_assets, "style.css"),
+	})
+	await result
+	fs.writeFile(path.join(config.gen_assets, "style.css"), result.css)
+}
+await config.init()
+await run()
+const watcher = chokidar.watch(["style.css", "pages/", "target/classes"], {
+	persistent: true,
+	ignoreInitial: true,
+})
+watcher.on("all", async (event, file_path) => {
+	await run()
+	console.log("TailwindCSS updated")
+})

package/src/typst.js ADDED Viewed

@@ -0,0 +1,59 @@
+import { spawn } from "node:child_process"
+import { createHash } from "node:crypto"
+import { promises as fs } from "node:fs"
+import path from "node:path"
+import config from "./config.js"
+import { file_exists } from "./util.js"
+function dir() {
+	return path.join(config.gen_assets, "typst/")
+}
+function svg_file_path(formula) {
+	return path.format({ dir: dir(), name: hash(formula), ext: "svg" })
+}
+export const CACHE = {
+	async contains(formula) {
+		return file_exists(svg_file_path(formula))
+	},
+	// Returns the relative path to the file
+	async insert(formula) {
+		if (!(await this.contains(formula))) {
+			render(formula)
+		}
+		return path.relative(config.tree, svg_file_path(formula))
+	},
+}
+function hash(text) {
+	return createHash("sha256").update(text).digest("hex")
+}
+export async function render(formula) {
+	// TODO: this should probably go elsewhere
+	await fs.mkdir(dir(), { recursive: true })
+	const typst = `\
+#set page(width: auto, height: auto, margin: (x: 0pt, y: 5pt))
+#set text(size: 16pt)
+$${formula}$
+`
+	const dst = svg_file_path(formula)
+	const child = spawn("typst", ["compile", "--format", "svg", "-", dst], {
+		stdio: ["pipe", null, null],
+	})
+	child.stderr.on("data", data => {
+		console.log(data.toString("utf8"))
+	})
+	child.stdin.write(typst)
+	child.stdin.end()
+	await child
+}

package/src/util.js ADDED Viewed

@@ -0,0 +1,48 @@
+import { promises as fs } from "node:fs"
+import path from "node:path"
+import url from "node:url"
+export async function file_exists(file_path) {
+	try {
+		await fs.access(file_path)
+		return true
+	} catch (error) {
+		return false
+	}
+}
+export async function find_dir_with_file(start_dir, name) {
+	let current_dir = start_dir
+	while (true) {
+		const file_path = path.join(current_dir, name)
+		if (await file_exists(file_path)) {
+			return [current_dir, file_path]
+		}
+		const parent_dir = path.dirname(current_dir)
+		if (parent_dir === current_dir) {
+			return [null, null]
+		}
+		current_dir = parent_dir
+	}
+}
+export function filename() {
+	return url.fileURLToPath(import.meta.url)
+}
+export function dirname() {
+	return path.dirname(filename())
+}
+export function silence_warning(name) {
+	const originalEmitWarning = process.emitWarning
+	process.emitWarning = (warning, type, code, ctor) => {
+		if (type === name) {
+			return
+		}
+		originalEmitWarning(warning, type, code, ctor)
+	}
+}

package/src/vite.js ADDED Viewed

@@ -0,0 +1,34 @@
+import path from "node:path"
+import { build } from "vite"
+import config from "./config.js"
+async function run() {
+	await build(vite_config(["js/main.js", "js/other.js"]))
+}
+function vite_config(files) {
+	const entries = files.reduce((acc, file) => {
+		const name = path.parse(file).name
+		acc[name] = file
+		return acc
+	}, {})
+	return {
+		build: {
+			minify: false,
+			lib: {
+				entry: entries,
+				// only build ES
+				fileName: (format, entry) => `${entry}.js`,
+				formats: ["es"],
+			},
+			rollupOptions: {},
+			outDir: path.join(config.gen_assets, "vite/"),
+			watch: "./js/",
+		},
+	}
+}
+await config.init()
+await run()