mothwing 0.0.0-stage → 0.0.1

package/src/config.js

@@ -0,0 +1,206 @@
+import fs from "fs"
+import path from "path"
+import { pathToFileURL } from "url"
+
+export const CONFIG_FILE = "mothwing.config.js"
+
+/**
+ * What a site's mothwing.config.js default exports. Only `domain` is needed. Paths are relative to `src` unless they
+ * say otherwise. The extras (minify to activeLinks) are off until asked for: `true` turns one on as it comes, an object
+ * with its own settings.
+ * @typedef {object} Config
+ * @property {string} domain "example.com", for the canonical URLs, sitemaps and CNAME
+ * @property {string} [src] The source folder, relative to the config. "src"
+ * @property {string} [out] The build folder, relative to the config. "dist"
+ * @property {string} [pages] The pages folder. "pages"
+ * @property {string} [data] The data folder, its files are in every page by their name: projects.json -> {{ projects }}.
+ *   "data"
+ * @property {string} [notFound] The 404 page, in the pages folder. Kept in the build's root, out of the sitemap. "404.html"
+ * @property {JsConfig} [js] The JS to bundle
+ * @property {Record<string, string>} [sass] Sass to compile, source to output: { "scss/index.scss": "css/index.css" }
+ * @property {string[]} [exclude] Folders left out of the build, on top of pages, partials and data: ["js", "scss"]
+ * @property {string[]} [rerender] Folders the pages read with fs, whose changes render every page again in dev. What
+ *   the pages import, include or use from the data folder is followed on its own
+ * @property {SeoConfig} [seo] For <x-seo>
+ * @property {boolean | import("html-minifier-terser").Options} [minify] Minify the HTML of production builds
+ * @property {boolean | Record<string, string>} [csp] A Content-Security-Policy <meta> that allows only the site's own
+ *   files and inline scripts. An object sets directives over the defaults: { "style-src": "'self' 'unsafe-inline'" }
+ * @property {boolean | SitemapConfig} [sitemap] sitemap.xml
+ * @property {boolean | RobotsConfig} [robots] robots.txt
+ * @property {boolean} [cname] A CNAME file with the domain, for GitHub Pages
+ * @property {boolean | ActiveLink} [activeLinks] aria-current on links to the page they're on and to its section
+ * @property {Record<string, TagFunction>} [tags] Your own tags: { "x-name": ({ attrs }) => "<b>html</b>" }
+ * @property {Transform[]} [transforms] Run on every page's HTML once its placeholders are filled
+ * @property {Hook[]} [after] Run once the pages are written
+ * @property {import("esbuild").BuildOptions} [esbuild] esbuild options for every bundle, over mothwing's
+ */
+
+/**
+ * Each file is bundled to the same path in the build, js/index.js -> /js/index.js.
+ * @typedef {object} JsConfig
+ * @property {string[]} [scripts] For <x-js src="..."/>, bundled on their own
+ * @property {string[]} [modules] For <x-js src="..." module/>, ES modules that share their common code in chunks
+ * @property {string} [chunks] Where the shared chunks go. A chunks folder next to the first module
+ */
+
+/**
+ * @typedef {object} SeoConfig
+ * @property {string} [siteName] Added to titles that fit, and the link previews' site name. The domain
+ * @property {string} [locale] "en_US"
+ * @property {{ src: string, width: number, height: number, alt: string } | null} [image] The link preview for pages
+ *   without their own
+ * @property {number} [maxTitle] Titles longer than this leave out the site name, search results cut them off. 60
+ * @property {number} [maxDescription] Longer descriptions are cut at a word. 160
+ */
+
+/**
+ * @typedef {object} SitemapConfig
+ * @property {string[]} [sections] Sections that get a sitemap of their own, the rest share sitemap-pages.xml
+ * @property {boolean} [dates] Date each page by the last git commit to its files. true
+ */
+
+/**
+ * @typedef {object} RobotsConfig
+ * @property {string[]} [block] Crawlers turned away from the whole site, by name
+ * @property {string[]} [disallow] Paths kept out of every crawler
+ */
+
+/**
+ * Returns the HTML a tag turns into. A list is one line each, indented like the tag.
+ * @typedef {(tag: { attrs: Record<string, string | true>, route: import("./routes.js").Route, site: Site }) => string | string[]} TagFunction
+ * @typedef {(html: string, route: import("./routes.js").Route, site: Site) => string} Transform
+ * @typedef {(build: { site: Site, routes: import("./routes.js").Route[], dev: boolean }) => any} Hook
+ */
+
+/**
+ * Decides what a link on a page is to it: "page" for the page itself, "section" for a section it's in, false for
+ * neither. undefined leaves it to the default.
+ * @typedef {(href: string, route: import("./routes.js").Route) => "page" | "section" | false | undefined} ActiveLink
+ */
+
+/**
+ * The config with its defaults filled in, its folders absolute, and each extra either false or its settings.
+ * @typedef {object} Site
+ * @property {string} domain
+ * @property {string} url "https://example.com"
+ * @property {string} root The config's folder
+ * @property {string} src
+ * @property {string} out
+ * @property {string} pages
+ * @property {string} data Relative to src
+ * @property {string} notFound
+ * @property {Required<JsConfig>} js
+ * @property {Record<string, string>} sass
+ * @property {string[]} exclude Folders, with pages, partials and data
+ * @property {string[]} rerender Folders
+ * @property {Required<SeoConfig>} seo
+ * @property {import("html-minifier-terser").Options | false} minify
+ * @property {Record<string, string> | false} csp
+ * @property {Required<SitemapConfig> | false} sitemap
+ * @property {Required<RobotsConfig> | false} robots
+ * @property {boolean} cname
+ * @property {ActiveLink | false} activeLinks
+ * @property {Record<string, TagFunction>} tags
+ * @property {Transform[]} transforms
+ * @property {Hook[]} after
+ * @property {import("esbuild").BuildOptions} esbuild
+ */
+
+const OPTIONS = [
+  "domain", "src", "out", "pages", "data", "notFound", "js", "sass", "exclude", "rerender", "seo", "minify", "csp", "sitemap",
+  "robots", "cname", "activeLinks", "tags", "transforms", "after", "esbuild"
+]
+
+const DEFAULT_CSP = {
+  "default-src": "'self'",
+  "script-src": "'self'",
+  "style-src": "'self'",
+  "img-src": "'self' data:",
+  "object-src": "'none'",
+  "base-uri": "'none'",
+  "form-action": "'none'"
+}
+
+const DEFAULT_MINIFY = {
+  collapseWhitespace: true,
+  removeComments: true,
+  minifyJS: true,
+  minifyCSS: true
+}
+
+/**
+ * @template T
+ * @param {boolean | T | undefined} value
+ * @returns {Partial<T>} The settings of an extra turned on with an object, none for `true`
+ */
+const settings = (value) => typeof value === "object" ? value : {}
+
+/**
+ * Gives the config its types in your editor, it's returned as it is.
+ * @param {Config} config
+ * @returns {Config}
+ */
+export const defineConfig = (config) => config
+
+/**
+ * @param {Config} config
+ * @param {string} root The config's folder
+ * @returns {Site}
+ */
+export function resolveConfig(config, root) {
+  if (!config?.domain) throw new Error(`${CONFIG_FILE}: needs a domain`)
+  const unknown = Object.keys(config).filter(key => !OPTIONS.includes(key))
+  if (unknown.length) throw new Error(`${CONFIG_FILE}: unknown option ${unknown.map(key => `"${key}"`).join(", ")}, the options are ${OPTIONS.join(", ")}`)
+
+  const src = path.resolve(root, config.src ?? "src")
+  const pages = config.pages ?? "pages"
+  const data = config.data ?? "data"
+  const modules = config.js?.modules ?? []
+
+  return {
+    domain: config.domain,
+    url: `https://${config.domain}`,
+    root,
+    src,
+    out: path.resolve(root, config.out ?? "dist"),
+    pages: path.join(src, pages),
+    data,
+    notFound: config.notFound ?? "404.html",
+    js: {
+      scripts: config.js?.scripts ?? [],
+      modules,
+      chunks: config.js?.chunks ?? (modules.length ? path.posix.join(path.posix.dirname(modules[0]), "chunks") : "chunks")
+    },
+    sass: config.sass ?? {},
+    exclude: [...new Set([pages, "partials", data, ...config.exclude ?? []])],
+    rerender: config.rerender ?? [],
+    seo: {
+      siteName: config.domain,
+      locale: "en_US",
+      image: null,
+      maxTitle: 60,
+      maxDescription: 160,
+      ...config.seo
+    },
+    minify: config.minify ? { ...DEFAULT_MINIFY, ...settings(config.minify) } : false,
+    csp: config.csp ? { ...DEFAULT_CSP, ...settings(config.csp) } : false,
+    sitemap: config.sitemap ? { sections: [], dates: true, ...settings(config.sitemap) } : false,
+    robots: config.robots ? { block: [], disallow: [], ...settings(config.robots) } : false,
+    cname: config.cname ?? false,
+    activeLinks: config.activeLinks === true ? () => undefined : config.activeLinks || false,
+    tags: config.tags ?? {},
+    transforms: config.transforms ?? [],
+    after: config.after ?? [],
+    esbuild: config.esbuild ?? {}
+  }
+}
+
+/**
+ * @param {string} [root] The folder with mothwing.config.js
+ * @returns {Promise<Site>}
+ */
+export async function loadConfig(root = process.cwd()) {
+  const file = path.join(root, CONFIG_FILE)
+  if (!fs.existsSync(file)) throw new Error(`No ${CONFIG_FILE} in ${root}`)
+  return resolveConfig((await import(pathToFileURL(file).href)).default, path.resolve(root))
+}

package/src/csp.js

@@ -0,0 +1,21 @@
+import crypto from "crypto"
+
+/**
+ * Adds a Content-Security-Policy <meta>, for hosts like GitHub Pages that can't send headers. The inline scripts are
+ * allowed by their hash, so it has to run on the finished HTML, after minifying changes them.
+ * @param {Record<string, string>} directives
+ * @param {string} html The finished page
+ * @returns {string}
+ */
+export function withCsp(directives, html) {
+  const hashes = [...html.matchAll(/<script(?![^>]*\ssrc=)([^>]*)>([\s\S]*?)<\/script>/g)]
+    // JSON-LD is data, it never runs
+    .filter(([, attrs]) => !attrs.includes("application/ld+json"))
+    // Over the text as the browser reads it, which turns every line break into a \n
+    .map(([, , code]) => `'sha256-${crypto.createHash("sha256").update(code.replace(/\r\n?/g, "\n")).digest("base64")}'`)
+
+  const policy = Object.entries(directives)
+    .map(([name, value]) => name === "script-src" && hashes.length ? `${name} ${value} ${[...new Set(hashes)].join(" ")}` : `${name} ${value}`)
+    .join("; ")
+  return html.replace(/<meta charset[^>]*>/, (charset) => `${charset}<meta http-equiv="Content-Security-Policy" content="${policy}">`)
+}

package/src/data.js

@@ -0,0 +1,54 @@
+import fs from "fs"
+import path from "path"
+import { pathToFileURL } from "url"
+import { posix } from "./log.js"
+
+/**
+ * The site's data folder, for every page.
+ * @typedef {object} SiteData
+ * @property {Record<string, any>} values projects.json -> values.projects, a folder is an object of its files
+ * @property {Record<string, string>} files Each top level name -> its file or folder, relative to src
+ */
+
+/**
+ * @param {string} file
+ * @returns {Promise<any>} A JSON file as it is, a JS file's default export, called first when it's a function
+ */
+async function read(file) {
+  if (file.endsWith(".json")) return JSON.parse(fs.readFileSync(file, "utf8"))
+  const value = (await import(pathToFileURL(file).href)).default
+  return typeof value === "function" ? await value() : value
+}
+
+/**
+ * @param {string} dir
+ * @param {string} from For errors, the folder relative to src
+ * @returns {Promise<Record<string, any>>}
+ */
+async function readFolder(dir, from) {
+  /** @type {Record<string, any>} */
+  const values = {}
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const file = path.join(dir, entry.name)
+    const name = entry.isDirectory() ? entry.name : entry.name.replace(/\.(json|js)$/, "")
+    if (!entry.isDirectory() && name === entry.name) continue
+    if (name in values) throw new Error(`${from}/${entry.name}: there's more than one ${name} in ${from}`)
+    values[name] = entry.isDirectory() ? await readFolder(file, `${from}/${entry.name}`) : await read(file)
+  }
+  return values
+}
+
+/**
+ * @param {import("./config.js").Site} site
+ * @returns {Promise<SiteData>}
+ */
+export async function loadData(site) {
+  const dir = path.join(site.src, site.data)
+  if (!fs.existsSync(dir)) return { values: {}, files: {} }
+
+  const values = await readFolder(dir, site.data)
+  const files = Object.fromEntries(fs.readdirSync(dir, { withFileTypes: true })
+    .filter(entry => entry.isDirectory() || /\.(json|js)$/.test(entry.name))
+    .map(entry => [entry.isDirectory() ? entry.name : entry.name.replace(/\.(json|js)$/, ""), posix(path.join(site.data, entry.name))]))
+  return { values, files }
+}

package/src/deps.js

@@ -0,0 +1,76 @@
+import esbuild from "esbuild"
+import fs from "fs"
+import path from "path"
+import { posix } from "./log.js"
+
+/**
+ * @param {import("./config.js").Site} site
+ * @param {string} file Relative to src
+ * @returns {Promise<string[]>} It and every file in src it imports, however deep, relative to src
+ */
+async function importsOf(site, file) {
+  try {
+    const { metafile } = await esbuild.build({
+      entryPoints: [path.join(site.src, file)],
+      bundle: true,
+      write: false,
+      metafile: true,
+      platform: "node",
+      format: "esm",
+      packages: "external",
+      logLevel: "silent"
+    })
+    return Object.keys(metafile.inputs)
+      .map(input => posix(path.relative(site.src, path.resolve(input))))
+      .filter(input => !input.startsWith("../"))
+  } catch {
+    return [file]
+  }
+}
+
+/**
+ * The files each page is made from, so dev can render just the pages a change is in: the page, its partials, its
+ * .data.js and what that imports, its sources, and the data files it used.
+ * @param {import("./config.js").Site} site
+ * @param {import("./render.js").BuildState} state
+ * @param {import("./routes.js").Route[]} routes
+ * @returns {Promise<Record<string, string[]>>} A page's file, relative to the pages folder -> files relative to src
+ */
+export async function dependencies(site, state, routes) {
+  const pagesDir = posix(path.relative(site.src, site.pages))
+  /** @type {Map<string, Promise<string[]>>} */
+  const imports = new Map()
+  /** @param {string} file */
+  const importsCached = (file) => {
+    if (!imports.has(file)) imports.set(file, importsOf(site, file))
+    return /** @type {Promise<string[]>} */ (imports.get(file))
+  }
+
+  /** @type {Record<string, string[]>} */
+  const deps = {}
+  for (const source of new Set(routes.map(route => route.source))) {
+    const files = new Set([`${pagesDir}/${source}`, ...state.templates.get(source)?.partials ?? []])
+    for (const route of routes.filter(route => route.source === source)) route.sources.forEach(file => files.add(file))
+
+    const dataFile = `${pagesDir}/${source.replace(/\.html$/, ".data.js")}`
+    if (fs.existsSync(path.join(site.src, dataFile))) (await importsCached(dataFile)).forEach(file => files.add(file))
+
+    for (const name of state.used.get(source) ?? []) {
+      const file = state.data.files[name]
+      if (!file) continue
+      files.add(file)
+      if (file.endsWith(".js")) (await importsCached(file)).forEach(input => files.add(input))
+    }
+    deps[source] = [...files]
+  }
+  return deps
+}
+
+/**
+ * @param {Record<string, string[]>} deps From dependencies
+ * @param {string} file A changed file, relative to src
+ * @returns {string[]} The pages made from it. A data folder counts for every file in it
+ */
+export const pagesUsing = (deps, file) => Object.entries(deps)
+  .filter(([, files]) => files.some(dep => dep === file || file.startsWith(`${dep}/`)))
+  .map(([source]) => source)

package/src/dev.js

@@ -0,0 +1,145 @@
+import { spawn } from "child_process"
+import esbuild from "esbuild"
+import fs from "fs"
+import net from "net"
+import os from "os"
+import path from "path"
+import { fileURLToPath } from "url"
+import { buildSass, clean, copyAssets, isExcluded, jsBuilds } from "./assets.js"
+import { renderSite } from "./build.js"
+import { pagesUsing } from "./deps.js"
+import { log, posix } from "./log.js"
+
+const CLI = fileURLToPath(new URL("../bin/mothwing.js", import.meta.url))
+
+/**
+ * @param {number} port
+ * @param {string} host
+ * @returns {Promise<void>} Rejects when something is already listening on it
+ */
+const portFree = (port, host) => new Promise((resolve, reject) => {
+  const server = net.createServer()
+  server.once("error", reject)
+  server.listen(port, host, () => server.close(() => resolve()))
+})
+
+/** @returns {string[]} This machine's addresses on the local network, to open the dev server from a phone */
+const lanAddresses = () => Object.values(os.networkInterfaces()).flatMap((list) => list ?? [])
+  .filter((i) => i.family === "IPv4" && !i.internal)
+  .map((i) => i.address)
+
+/** @type {import("esbuild").Plugin} */
+const jsWatchPlugin = {
+  name: "watch-log",
+  setup(build) {
+    build.onStart(() => log("JS", "Building JS..."))
+    build.onEnd(result => log("JS", result.errors.length ? "Error" : "Done building"))
+  }
+}
+
+/**
+ * Builds, serves and rebuilds what changes.
+ * @param {import("./config.js").Site} site
+ * @param {{ host?: string, port?: number }} [options]
+ */
+export async function dev(site, { host = "localhost", port = 8080 } = {}) {
+  log("WATCH", "Starting to watch for changes...")
+
+  const contexts = await Promise.all(jsBuilds(site, {
+    minify: false,
+    sourcemap: true,
+    plugins: [jsWatchPlugin]
+  }).map(build => esbuild.context(build)))
+
+  // The port first, so a second dev server stops here, before it wipes the files the running one serves
+  try {
+    await portFree(port, host)
+  } catch (err) {
+    await Promise.all(contexts.map(ctx => ctx.dispose()))
+    log("SERVE", `Port ${port} is taken, is the dev server already running? (${/** @type {Error} */ (err).message})`)
+    process.exit(1)
+  }
+
+  await clean(site)
+  await copyAssets(site)
+  await buildSass(site)
+  // What each page is made from, so a change renders just the pages it's in
+  let deps = await renderSite(site)
+
+  // Served only now: a tab left open asks for the page at once, and the server builds the JS for it, which would
+  // land in the folder while it's being wiped
+  const server = contexts[0] ?? await esbuild.context({})
+  await server.serve({ servedir: site.out, host, port })
+  await Promise.all(contexts.map(ctx => ctx.watch()))
+  const hosts = host === "0.0.0.0" ? ["localhost", ...lanAddresses()] : [host]
+  for (const name of hosts) log("SERVE", `http://${name}:${port}/`)
+
+  /** @type {import("child_process").ChildProcess | null} */
+  let rendering = null
+  /** @type {Set<string> | "all" | null} The pages to render next, or all of them */
+  let pending = null
+  /** @type {NodeJS.Timeout | undefined} */
+  let soon
+
+  // In a new process, so the .data.js files and what they import load fresh, Node would otherwise keep the first copy
+  const startRender = () => {
+    if (rendering || !pending) return
+    const job = pending
+    pending = null
+    const only = job === "all" ? [] : ["--pages", [...job].join(",")]
+    rendering = spawn(process.execPath, [CLI, "html", "--root", site.root, ...only], { stdio: ["inherit", "inherit", "inherit", "ipc"] })
+    rendering.on("message", (/** @type {{ deps?: Record<string, string[]> }} */ message) => {
+      if (message.deps) deps = job === "all" ? message.deps : { ...deps, ...message.deps }
+    })
+    rendering.on("exit", () => {
+      rendering = null
+      startRender()
+    })
+  }
+
+  /** @param {string[] | "all"} pages Relative to the pages folder */
+  const render = (pages) => {
+    pending = pages === "all" || pending === "all" ? "all" : new Set([...pending ?? [], ...pages])
+    // A save fires a few events at once, they're rendered together
+    clearTimeout(soon)
+    soon = setTimeout(startRender, 50)
+  }
+
+  // A deleted or renamed file would leave its old output behind, so that starts over from an empty folder
+  const rebuildAll = async () => {
+    log("WATCH", "A file was removed, building everything again...")
+    await clean(site)
+    await copyAssets(site)
+    await buildSass(site)
+    await Promise.all(contexts.map(ctx => ctx.rebuild()))
+    render("all")
+  }
+
+  const pagesDir = posix(path.relative(site.src, site.pages))
+  /** @type {NodeJS.Timeout | undefined} */
+  let restart
+  fs.watch(site.src, { recursive: true }, (_, filename) => {
+    if (!filename) return
+    const file = path.join(site.src, filename)
+    const relative = posix(filename)
+    if (!fs.existsSync(file)) {
+      clearTimeout(restart)
+      restart = setTimeout(() => rebuildAll().catch(err => log("WATCH", err.message)), 200)
+      return
+    }
+    if (fs.statSync(file).isDirectory()) return
+
+    const page = relative.startsWith(`${pagesDir}/`) && relative.slice(pagesDir.length + 1).replace(/\.data\.js$/, ".html")
+    const using = pagesUsing(deps, relative)
+    if (/\.(scss|sass)$/.test(file))
+      buildSass(site).catch(err => log("CSS", err.message))
+    else if (page && page.endsWith(".html"))
+      render([page])
+    else if (using.length)
+      render(using)
+    else if (site.rerender.some(dir => relative === dir || relative.startsWith(`${dir}/`)))
+      render("all")
+    else if (!isExcluded(site, file))
+      copyAssets(site).catch(err => log("ASSET", err.message))
+  })
+}

package/src/html.js

@@ -0,0 +1,67 @@
+/*
+  HTML helpers for a site's .data.js files, also what the builder escapes with.
+  html`...` escapes what goes into it, unless it's HTML already: another html`...`, raw(), or a list of those.
+*/
+
+/** HTML that's safe to put in as-is. */
+export class Html {
+  /** @param {string} value */
+  constructor(value) {
+    this.value = value
+  }
+
+  toString() {
+    return this.value
+  }
+}
+
+/** @type {Record<string, string>} */
+const ENTITIES = { "&": "&amp;", "<": "&lt;", ">": "&gt;", "\"": "&quot;", "'": "&#39;" }
+
+/**
+ * @param {string} text
+ * @returns {string}
+ */
+export const escapeHtml = (text) => String(text).replace(/[&<>"']/g, (c) => ENTITIES[c])
+
+const CHARACTERS = Object.fromEntries(Object.entries(ENTITIES).map(([c, entity]) => [entity, c]))
+
+/**
+ * @param {string} html What escapeHtml made
+ * @returns {string} The text back
+ */
+export const unescapeHtml = (html) => html.replace(/&(amp|lt|gt|quot|#39);/g, (entity) => CHARACTERS[entity])
+
+/**
+ * @param {string} value
+ * @returns {Html} Put in as it is, not escaped
+ */
+export const raw = (value) => new Html(value)
+
+/**
+ * @param {any} value
+ * @returns {string} null, undefined and false are left out, lists are joined
+ */
+const toHtml = (value) => {
+  if (value == null || value === false) return ""
+  if (Array.isArray(value)) return value.map(toHtml).join("")
+  return value instanceof Html ? value.value : escapeHtml(value)
+}
+
+/**
+ * @param {string} name
+ * @returns {string} The name as a URL part: "Rak'tika Greatwood" -> "raktika-greatwood"
+ */
+export const slug = (name) => name
+  .normalize("NFD")
+  .replace(/[̀-ͯ'’*]/g, "")
+  .toLowerCase()
+  .replace(/[^a-z0-9]+/g, "-")
+  .replace(/^-|-$/g, "")
+
+/**
+ * @param {TemplateStringsArray} strings
+ * @param {...any} values
+ * @returns {Html}
+ */
+export const html = (strings, ...values) => raw(strings.reduce((out, string, i) => out + toHtml(values[i - 1]) + string))

package/src/index.js

@@ -0,0 +1,20 @@
+export { clean } from "./assets.js"
+export { build, renderSite } from "./build.js"
+export { defineConfig, loadConfig, resolveConfig } from "./config.js"
+export { dev } from "./dev.js"
+export { escapeHtml, html, raw, unescapeHtml } from "./html.js"
+export { log } from "./log.js"
+
+/**
+ * @typedef {import("./config.js").Config} Config
+ * @typedef {import("./config.js").Site} Site
+ * @typedef {import("./config.js").JsConfig} JsConfig
+ * @typedef {import("./config.js").SeoConfig} SeoConfig
+ * @typedef {import("./config.js").SitemapConfig} SitemapConfig
+ * @typedef {import("./config.js").RobotsConfig} RobotsConfig
+ * @typedef {import("./config.js").ActiveLink} ActiveLink
+ * @typedef {import("./config.js").TagFunction} TagFunction
+ * @typedef {import("./config.js").Transform} Transform
+ * @typedef {import("./config.js").Hook} Hook
+ * @typedef {import("./routes.js").Route} Route
+ */

package/src/log.js

@@ -0,0 +1,24 @@
+/**
+ * @param {string} type Short tag, like "HTML"
+ * @param {string} message
+ */
+export function log(type, message) {
+  const now = new Date()
+  /** @param {number} num */
+  const pad = (num) => String(num).padStart(2, "0")
+  const formattedDate =
+    now.getFullYear() + "-" +
+    pad(now.getMonth() + 1) + "-" +
+    pad(now.getDate()) + " " +
+    pad(now.getHours()) + ":" +
+    pad(now.getMinutes()) + ":" +
+    pad(now.getSeconds())
+
+  console.log(`[ ${type.padStart(5)} ] ${formattedDate} ${message}`)
+}
+
+/**
+ * @param {string} file
+ * @returns {string} With / separators, however the OS writes it
+ */
+export const posix = (file) => file.split("\\").join("/")