mothwing 0.0.0-stage → 0.0.1

package/src/template.js

@@ -0,0 +1,207 @@
+import fs from "fs"
+import path from "path"
+import { escapeHtml } from "./html.js"
+import { posix } from "./log.js"
+
+/**
+ * @param {string} attrs ` src="index.js" module`
+ * @returns {Record<string, string | true>}
+ */
+export const parseAttrs = (attrs) => Object.fromEntries([...attrs.matchAll(/([\w-]+)(?:="([^"]*)")?/g)].map(([, name, value]) => [name, value ?? true]))
+
+/**
+ * Pastes in the <x-html src="..."/> partials. One on a line of its own is indented like its tag, so partials are
+ * written unindented.
+ * @param {string} src The source folder, partials are relative to it
+ * @param {string} html
+ * @param {string} from For errors, the file `html` came from
+ * @param {Set<string>} [used] Gets every partial pasted in, relative to src
+ * @param {number} [depth]
+ * @returns {string}
+ */
+export function includeHtml(src, html, from, used = new Set(), depth = 0) {
+  if (depth > 10) throw new Error(`${from}: <x-html> nested too deep, is a partial including itself?`)
+
+  return html.replace(/([ \t]*)<x-html((?:\s+[\w-]+(?:="[^"]*")?)*)\s*\/?>/g, (_, space, attrs, offset, page) => {
+    const file = parseAttrs(attrs).src
+    if (typeof file !== "string") throw new Error(`${from}: <x-html> needs a src="..."`)
+    const partial = path.join(src, file.replace(/^\//, ""))
+    if (!fs.existsSync(partial)) throw new Error(`${from}: <x-html> can't find ${file}`)
+    used.add(posix(path.relative(src, partial)))
+
+    const content = includeHtml(src, fs.readFileSync(partial, "utf8"), file, used, depth + 1).trimEnd()
+    const lineStart = offset === 0 || page[offset - 1] === "\n"
+    if (!lineStart) return space + content
+    return content.split("\n").map(line => line.trim() ? space + line : "").join("\n")
+  })
+}
+
+/**
+ * @param {Record<string, any>} values
+ * @param {string} name "project.name"
+ * @returns {any} undefined when any part of it is missing
+ */
+export const lookup = (values, name) => name.split(".").reduce((value, key) => value?.[key], values)
+
+/**
+ * What a page is filled from, and what it used of it.
+ * @typedef {object} Context
+ * @property {string} from The page, for errors
+ * @property {Set<string>} used The first part of every name looked up, "projects" for {{ projects.0.name }}
+ */
+
+/**
+ * @param {Record<string, any>} values
+ * @param {string} name
+ * @param {Context} context
+ * @returns {any}
+ */
+function find(values, name, context) {
+  context.used.add(name.split(".")[0])
+  return lookup(values, name)
+}
+
+/**
+ * {{ name }} is filled with the value as text, {{{ name }}} as HTML, on a line of its own each line indented like it.
+ * Names can go into objects: {{ project.name }}.
+ * @param {string} html
+ * @param {Record<string, any>} values
+ * @param {string} from For errors, the page's file
+ * @param {Set<string>} [used] Gets the first part of every name filled in
+ * @returns {string}
+ */
+export function fillPlaceholders(html, values, from, used = new Set()) {
+  /** @param {string} name */
+  const value = (name) => {
+    const found = find(values, name, { from, used })
+    if (found === undefined) throw new Error(`${from}: nothing to fill {{ ${name} }} with`)
+    return String(found)
+  }
+
+  // One pass, so what's filled in is never searched for placeholders itself
+  const placeholder = /^([ \t]*)\{\{\{\s*([\w.]+)\s*\}\}\}[ \t]*$|\{\{\{\s*([\w.]+)\s*\}\}\}|\{\{\s*([\w.]+)\s*\}\}/gm
+  return html.replace(placeholder, (_, indent, line, inline, text) => {
+    if (line) return value(line).split("\n").map(l => l.trim() ? indent + l : "").join("\n")
+    return inline ? value(inline) : escapeHtml(value(text))
+  })
+}
+
+/**
+ * A page's HTML split at its <x-each> and <x-if> blocks.
+ * @typedef {{ type: "text", text: string }
+ *   | { type: "x-each" | "x-if", attrs: Record<string, string | true>, dedent: number, children: Node[] }} Node
+ */
+
+// A block tag on a line of its own takes its line with it, so it leaves no empty line behind. Formatters like
+// Prettier can break a tag before its ">", "</x-if\n  >" included
+const BLOCK = /^([ \t]*)<(x-each|x-if)((?:\s+[\w-]+(?:="[^"]*")?)*)\s*>[ \t]*\r?\n|^[ \t]*<\/(x-each|x-if)\s*>[ \t]*(?:\r?\n|$)|<(x-each|x-if)((?:\s+[\w-]+(?:="[^"]*")?)*)\s*>|<\/(x-each|x-if)\s*>/gm
+
+/**
+ * @param {string} text
+ * @returns {number} The fewest spaces any of its lines start with
+ */
+const indentOf = (text) => Math.min(...text.split("\n").filter(line => line.trim()).map(line => line.length - line.trimStart().length))
+
+/**
+ * @param {string} html
+ * @param {string} from For errors, the page's file
+ * @returns {Node[]}
+ */
+export function parseTemplate(html, from) {
+  /** @type {{ node: Node & { type: "x-each" | "x-if" }, indent: string | null, bodyStart: number }[]} */
+  const open = []
+  /** @type {Node[]} */
+  const root = []
+  const children = () => open.at(-1)?.node.children ?? root
+  let last = 0
+
+  for (const match of html.matchAll(BLOCK)) {
+    const [whole, lineIndent, lineOpen, lineAttrs, lineClose, inlineOpen, inlineAttrs, inlineClose] = match
+    const start = match.index ?? 0
+    if (start > last) children().push({ type: "text", text: html.slice(last, start) })
+    last = start + whole.length
+
+    const opening = lineOpen ?? inlineOpen
+    if (opening) {
+      const node = { type: /** @type {"x-each" | "x-if"} */ (opening), attrs: parseAttrs(lineAttrs ?? inlineAttrs ?? ""), dedent: 0, children: [] }
+      children().push(node)
+      open.push({ node, indent: lineOpen ? lineIndent : null, bodyStart: last })
+      continue
+    }
+
+    const closing = lineClose ?? inlineClose
+    const block = open.pop()
+    if (!block) throw new Error(`${from}: </${closing}> without its <${closing}>`)
+    if (block.node.type !== closing) throw new Error(`${from}: </${closing}> where <${block.node.type}> should be closed`)
+    // A block on lines of its own is indented a step deeper than where its output goes
+    if (block.indent !== null) block.node.dedent = Math.max(0, indentOf(html.slice(block.bodyStart, start)) - block.indent.length)
+  }
+
+  if (open.length) throw new Error(`${from}: <${open[0].node.type}> is never closed`)
+  if (last < html.length) root.push({ type: "text", text: html.slice(last) })
+  return root
+}
+
+/**
+ * @param {string} text
+ * @param {number} spaces
+ * @returns {string} Every line with up to `spaces` of its indent taken off
+ */
+const dedent = (text, spaces) => spaces ? text.replace(new RegExp(`^[ \\t]{1,${spaces}}`, "gm"), "") : text
+
+/**
+ * @param {any} value
+ * @returns {boolean} False for nothing, false, 0, "" and empty lists
+ */
+const truthy = (value) => Array.isArray(value) ? value.length > 0 : Boolean(value)
+
+/**
+ * Fills in the placeholders and runs the blocks:
+ * - <x-each items="projects" as="project">...</x-each> once per item, `index="i"` names its position
+ * - <x-if value="project.url">...</x-if> only when it's there, `not="..."` only when it isn't
+ * @param {Node[]} nodes
+ * @param {Record<string, any>} values
+ * @param {Context} context
+ * @returns {string}
+ */
+export function renderNodes(nodes, values, context) {
+  const { from } = context
+
+  /**
+   * @param {string} tag
+   * @param {string} attr
+   * @param {string} name What the attribute says, a name to look up
+   */
+  const known = (tag, attr, name) => {
+    const bare = name.match(/^\{\{\{?\s*([\w.]+)\s*\}?\}\}$/)?.[1]
+    if (bare) throw new Error(`${from}: <${tag} ${attr}="${name}"> takes the name on its own: ${attr}="${bare}"`)
+    const value = find(values, name, context)
+    if (!(name.split(".")[0] in values)) throw new Error(`${from}: <${tag}> has nothing called ${name.split(".")[0]}`)
+    return value
+  }
+
+  return nodes.map(node => {
+    if (node.type === "text") return fillPlaceholders(node.text, values, from, context.used)
+
+    const { attrs } = node
+    if (node.type === "x-each") {
+      if (typeof attrs.items !== "string" || typeof attrs.as !== "string") throw new Error(`${from}: <x-each> needs items="..." and as="..."`)
+      const items = known("x-each", "items", attrs.items)
+      if (!Array.isArray(items)) throw new Error(`${from}: <x-each items="${attrs.items}"> isn't a list`)
+      const { as, index } = attrs
+      for (const [attr, name] of Object.entries({ as, index })) {
+        if (typeof name === "string" && !/^\w+$/.test(name)) throw new Error(`${from}: <x-each ${attr}="${name}"> names what's looped over, a plain name like ${attr}="${attr === "as" ? "project" : "i"}"`)
+      }
+      return dedent(items.map((item, i) => renderNodes(node.children, {
+        ...values,
+        [as]: item,
+        ...typeof index === "string" && { [index]: i }
+      }, context)).join(""), node.dedent)
+    }
+
+    const name = attrs.value ?? attrs.not
+    if (typeof name !== "string") throw new Error(`${from}: <x-if> needs value="..." or not="..."`)
+    const shown = truthy(known("x-if", attrs.value !== undefined ? "value" : "not", name)) === (attrs.value !== undefined)
+    return shown ? dedent(renderNodes(node.children, values, context), node.dedent) : ""
+  }).join("")
+}

package/types/assets.d.ts

@@ -0,0 +1,23 @@
+/** @param {import("./config.js").Site} site */
+export function clean(site: import("./config.js").Site): Promise<void>;
+/**
+ * Copies src as it is into the build, leaving out the excluded folders, pages and Sass.
+ * @param {import("./config.js").Site} site
+ */
+export function copyAssets(site: import("./config.js").Site): Promise<void>;
+/**
+ * The esbuild builds for the config's js: one per script, and one for all the modules, so they can share chunks.
+ * @param {import("./config.js").Site} site
+ * @param {import("esbuild").BuildOptions} [overrides]
+ * @returns {import("esbuild").BuildOptions[]}
+ */
+export function jsBuilds(site: import("./config.js").Site, overrides?: import("esbuild").BuildOptions): import("esbuild").BuildOptions[];
+/**
+ * Bundles the JS, and notes which chunks each file imports, for the modulepreload links.
+ * @param {import("./config.js").Site} site
+ * @param {import("./render.js").BuildState} state
+ */
+export function buildJS(site: import("./config.js").Site, state: import("./render.js").BuildState): Promise<void>;
+/** @param {import("./config.js").Site} site */
+export function buildSass(site: import("./config.js").Site): Promise<void>;
+export function isExcluded(site: import("./config.js").Site, file: string): boolean;

package/types/build.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Writes a file unless it already has this content. Writing is much slower than reading on Windows, and a dev render
+ * of a whole site mostly writes what's already there.
+ * @param {string} file
+ * @param {string} content
+ * @returns {boolean} Whether it was written
+ */
+export function writeIfChanged(file: string, content: string): boolean;
+/**
+ * @param {import("./config.js").Site} site
+ * @param {import("./render.js").BuildState} state
+ * @param {{ hashed?: boolean, only?: Set<string> }} [options] `hashed` for production: hashed asset links and minified
+ *   HTML. `only` renders just these pages, relative to the pages folder
+ * @returns {Promise<import("./routes.js").Route[]>} The pages rendered
+ */
+export function buildHTML(site: import("./config.js").Site, state: import("./render.js").BuildState, { hashed, only }?: {
+    hashed?: boolean;
+    only?: Set<string>;
+}): Promise<import("./routes.js").Route[]>;
+/**
+ * Renders the pages into an existing build, as dev does after a change. With `only`, just those pages, and the
+ * sitemaps are left as they are.
+ * @param {import("./config.js").Site} site
+ * @param {{ only?: Set<string> }} [options]
+ * @returns {Promise<Record<string, string[]>>} What each page rendered is made from, see deps.js
+ */
+export function renderSite(site: import("./config.js").Site, { only }?: {
+    only?: Set<string>;
+}): Promise<Record<string, string[]>>;
+/**
+ * The production build, from an empty build folder.
+ * @param {import("./config.js").Site} site
+ */
+export function build(site: import("./config.js").Site): Promise<void>;

package/types/config.d.ts

@@ -0,0 +1,240 @@
+/**
+ * @param {Config} config
+ * @param {string} root The config's folder
+ * @returns {Site}
+ */
+export function resolveConfig(config: Config, root: string): Site;
+/**
+ * @param {string} [root] The folder with mothwing.config.js
+ * @returns {Promise<Site>}
+ */
+export function loadConfig(root?: string): Promise<Site>;
+export const CONFIG_FILE: "mothwing.config.js";
+export function defineConfig(config: Config): Config;
+/**
+ * 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.
+ */
+export type Config = {
+    /**
+     * "example.com", for the canonical URLs, sitemaps and CNAME
+     */
+    domain: string;
+    /**
+     * The source folder, relative to the config. "src"
+     */
+    src?: string | undefined;
+    /**
+     * The build folder, relative to the config. "dist"
+     */
+    out?: string | undefined;
+    /**
+     * The pages folder. "pages"
+     */
+    pages?: string | undefined;
+    /**
+     * The data folder, its files are in every page by their name: projects.json -> {{ projects }}.
+     * "data"
+     */
+    data?: string | undefined;
+    /**
+     * The 404 page, in the pages folder. Kept in the build's root, out of the sitemap. "404.html"
+     */
+    notFound?: string | undefined;
+    /**
+     * The JS to bundle
+     */
+    js?: JsConfig | undefined;
+    /**
+     * Sass to compile, source to output: { "scss/index.scss": "css/index.css" }
+     */
+    sass?: Record<string, string> | undefined;
+    /**
+     * Folders left out of the build, on top of pages, partials and data: ["js", "scss"]
+     */
+    exclude?: string[] | undefined;
+    /**
+     * 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
+     */
+    rerender?: string[] | undefined;
+    /**
+     * For <x-seo>
+     */
+    seo?: SeoConfig | undefined;
+    /**
+     * Minify the HTML of production builds
+     */
+    minify?: boolean | import("html-minifier-terser").Options | undefined;
+    /**
+     * 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'" }
+     */
+    csp?: boolean | Record<string, string> | undefined;
+    /**
+     * sitemap.xml
+     */
+    sitemap?: boolean | SitemapConfig | undefined;
+    /**
+     * robots.txt
+     */
+    robots?: boolean | RobotsConfig | undefined;
+    /**
+     * A CNAME file with the domain, for GitHub Pages
+     */
+    cname?: boolean | undefined;
+    /**
+     * aria-current on links to the page they're on and to its section
+     */
+    activeLinks?: boolean | ActiveLink | undefined;
+    /**
+     * Your own tags: { "x-name": ({ attrs }) => "<b>html</b>" }
+     */
+    tags?: Record<string, TagFunction> | undefined;
+    /**
+     * Run on every page's HTML once its placeholders are filled
+     */
+    transforms?: Transform[] | undefined;
+    /**
+     * Run once the pages are written
+     */
+    after?: Hook[] | undefined;
+    /**
+     * esbuild options for every bundle, over mothwing's
+     */
+    esbuild?: import("esbuild").BuildOptions | undefined;
+};
+/**
+ * Each file is bundled to the same path in the build, js/index.js -> /js/index.js.
+ */
+export type JsConfig = {
+    /**
+     * For <x-js src="..."/>, bundled on their own
+     */
+    scripts?: string[] | undefined;
+    /**
+     * For <x-js src="..." module/>, ES modules that share their common code in chunks
+     */
+    modules?: string[] | undefined;
+    /**
+     * Where the shared chunks go. A chunks folder next to the first module
+     */
+    chunks?: string | undefined;
+};
+export type SeoConfig = {
+    /**
+     * Added to titles that fit, and the link previews' site name. The domain
+     */
+    siteName?: string | undefined;
+    /**
+     * "en_US"
+     */
+    locale?: string | undefined;
+    /**
+     * The link preview for pages
+     * without their own
+     */
+    image?: {
+        src: string;
+        width: number;
+        height: number;
+        alt: string;
+    } | null | undefined;
+    /**
+     * Titles longer than this leave out the site name, search results cut them off. 60
+     */
+    maxTitle?: number | undefined;
+    /**
+     * Longer descriptions are cut at a word. 160
+     */
+    maxDescription?: number | undefined;
+};
+export type SitemapConfig = {
+    /**
+     * Sections that get a sitemap of their own, the rest share sitemap-pages.xml
+     */
+    sections?: string[] | undefined;
+    /**
+     * Date each page by the last git commit to its files. true
+     */
+    dates?: boolean | undefined;
+};
+export type RobotsConfig = {
+    /**
+     * Crawlers turned away from the whole site, by name
+     */
+    block?: string[] | undefined;
+    /**
+     * Paths kept out of every crawler
+     */
+    disallow?: string[] | undefined;
+};
+/**
+ * Returns the HTML a tag turns into. A list is one line each, indented like the tag.
+ */
+export type TagFunction = (tag: {
+    attrs: Record<string, string | true>;
+    route: import("./routes.js").Route;
+    site: Site;
+}) => string | string[];
+/**
+ * Returns the HTML a tag turns into. A list is one line each, indented like the tag.
+ */
+export type Transform = (html: string, route: import("./routes.js").Route, site: Site) => string;
+/**
+ * Returns the HTML a tag turns into. A list is one line each, indented like the tag.
+ */
+export type Hook = (build: {
+    site: Site;
+    routes: import("./routes.js").Route[];
+    dev: boolean;
+}) => any;
+/**
+ * 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.
+ */
+export type ActiveLink = (href: string, route: import("./routes.js").Route) => "page" | "section" | false | undefined;
+/**
+ * The config with its defaults filled in, its folders absolute, and each extra either false or its settings.
+ */
+export type Site = {
+    domain: string;
+    /**
+     * "https://example.com"
+     */
+    url: string;
+    /**
+     * The config's folder
+     */
+    root: string;
+    src: string;
+    out: string;
+    pages: string;
+    /**
+     * Relative to src
+     */
+    data: string;
+    notFound: string;
+    js: Required<JsConfig>;
+    sass: Record<string, string>;
+    /**
+     * Folders, with pages, partials and data
+     */
+    exclude: string[];
+    /**
+     * Folders
+     */
+    rerender: string[];
+    seo: Required<SeoConfig>;
+    minify: import("html-minifier-terser").Options | false;
+    csp: Record<string, string> | false;
+    sitemap: Required<SitemapConfig> | false;
+    robots: Required<RobotsConfig> | false;
+    cname: boolean;
+    activeLinks: ActiveLink | false;
+    tags: Record<string, TagFunction>;
+    transforms: Transform[];
+    after: Hook[];
+    esbuild: import("esbuild").BuildOptions;
+};

package/types/csp.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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: Record<string, string>, html: string): string;

package/types/data.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @param {import("./config.js").Site} site
+ * @returns {Promise<SiteData>}
+ */
+export function loadData(site: import("./config.js").Site): Promise<SiteData>;
+/**
+ * The site's data folder, for every page.
+ */
+export type SiteData = {
+    /**
+     * projects.json -> values.projects, a folder is an object of its files
+     */
+    values: Record<string, any>;
+    /**
+     * Each top level name -> its file or folder, relative to src
+     */
+    files: Record<string, string>;
+};

package/types/deps.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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 function dependencies(site: import("./config.js").Site, state: import("./render.js").BuildState, routes: import("./routes.js").Route[]): Promise<Record<string, string[]>>;
+export function pagesUsing(deps: Record<string, string[]>, file: string): string[];

package/types/dev.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Builds, serves and rebuilds what changes.
+ * @param {import("./config.js").Site} site
+ * @param {{ host?: string, port?: number }} [options]
+ */
+export function dev(site: import("./config.js").Site, { host, port }?: {
+    host?: string;
+    port?: number;
+}): Promise<void>;

package/types/html.d.ts

@@ -0,0 +1,12 @@
+/** HTML that's safe to put in as-is. */
+export class Html {
+    /** @param {string} value */
+    constructor(value: string);
+    value: string;
+    toString(): string;
+}
+export function escapeHtml(text: string): string;
+export function unescapeHtml(html: string): string;
+export function raw(value: string): Html;
+export function slug(name: string): string;
+export function html(strings: TemplateStringsArray, ...values: any[]): Html;

package/types/index.d.ts

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

package/types/log.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {string} type Short tag, like "HTML"
+ * @param {string} message
+ */
+export function log(type: string, message: string): void;
+export function posix(file: string): string;

package/types/render.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @param {import("./config.js").Site} site
+ * @param {BuildState} state
+ * @param {import("./routes.js").Route} route
+ * @param {boolean} hashed Add ?v=hash to the assets
+ * @returns {string} The finished HTML, before minifying
+ */
+export function renderPage(site: import("./config.js").Site, state: BuildState, route: import("./routes.js").Route, hashed: boolean): string;
+export function buildState(): BuildState;
+/**
+ * What one build has worked out so far, shared by its pages.
+ */
+export type BuildState = {
+    /**
+     * The data folder
+     */
+    data: import("./data.js").SiteData;
+    /**
+     * "/js/index.js" -> "/js/index.js?v=hash"
+     */
+    assetUrls: Map<string, string>;
+    /**
+     * A page's file ->
+     * its HTML with the partials pasted in, and which those were
+     */
+    templates: Map<string, {
+        nodes: import("./template.js").Node[];
+        partials: Set<string>;
+    }>;
+    /**
+     * A page's file -> the names its pages filled in, for what they depend on
+     */
+    used: Map<string, Set<string>>;
+    /**
+     * "/js/gathering.js" -> the chunks it imports up front
+     */
+    chunkImports: Map<string, string[]>;
+    /**
+     * "/js/data/x.json" -> "/js/chunks/x-hash.js"
+     */
+    entryChunks: Map<string, string>;
+};

package/types/routes.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Every page, each folder's index.html first, so the front page leads the sitemap and a list comes before its items.
+ * - about.html is one page. Its .data.js, when it has one, default exports `() => values`
+ * - [projects.name].html is a page per item of the data folder's projects, by its name, the item is {{ page }}
+ * - [name].html is a page per item its .data.js returns, each `{ slug, ...values }`
+ * A .data.js can return a `sources` list (relative to src) of the files it's made from, for the sitemap's dates.
+ * @param {import("./config.js").Site} site
+ * @param {import("./data.js").SiteData} siteData
+ * @param {Set<string>} [only] Just these pages, relative to the pages folder
+ * @returns {Promise<Route[]>}
+ */
+export function listRoutes(site: import("./config.js").Site, siteData: import("./data.js").SiteData, only?: Set<string>): Promise<Route[]>;
+export function outputUrl(output: string): string;
+/**
+ * A page to write. Most come one to a file in the pages folder, a [name].html file gives one per item.
+ * Its props can have `files`, more files to write, by their path in the build.
+ */
+export type Route = {
+    /**
+     * "gathering/[item].html", relative to the pages folder
+     */
+    source: string;
+    /**
+     * Where it goes in the build: "gathering/cedar-log/index.html"
+     */
+    output: string;
+    /**
+     * "/gathering/cedar-log/"
+     */
+    url: string;
+    /**
+     * Its own values, the data folder's are added when it's rendered
+     */
+    props: Record<string, any>;
+    /**
+     * Files its content comes from, relative to src, for the sitemap's lastmod
+     */
+    sources: string[];
+};