@sevenfold/setto-client 0.34.0 → 0.36.0

package/dist/types.d.ts

@@ -1,3 +1,4 @@
+import type { SettoBlogData } from './blog/data';
 import type { SectionSchema } from './section-schema';
 export interface BrandColor {
     /** Display name in the swatch picker, e.g. 'Beige'. */
@@ -66,6 +67,13 @@ export interface SettoConfig {
     images?: {
         optimize?: boolean;
     };
+    /**
+     * The site's blog posts, as its build bundles them: `import blog from
+     * 'virtual:setto-blog'` with the `settoBlog()` plugin from
+     * `@setto/client/vite`. Without it the `blog` and `blog-latest` sections
+     * draw nothing.
+     */
+    blog?: SettoBlogData;
 }
 export interface DeploymentRow {
     id: string;

package/dist/vite/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * `@sevenfold/setto-client/vite` — build-time only. Runs in Node inside the
+ * site's Vite build; never imported by the site's browser code.
+ */
+export { settoBlog } from './plugin';
+export type { SettoBlogPluginOptions } from './plugin';

package/dist/vite/plugin.d.ts

@@ -0,0 +1,32 @@
+import type { Plugin } from 'vite';
+import { type BlogFrontmatter } from '../blog/contract';
+export interface SettoBlogPluginOptions {
+    /**
+     * The site's public address, for canonical links, `og:url`, RSS and the
+     * sitemap. Otherwise `SETTO_SITE_URL`, then Vercel's
+     * `VERCEL_PROJECT_PRODUCTION_URL`, then the first address in
+     * `public/sitemap.xml`. Without any, pages still get their own head, only
+     * with relative addresses, and no feed.
+     */
+    siteUrl?: string;
+    /** Hosts a post's images may come from. Setto's media store by default. */
+    imageHosts?: readonly string[];
+    /**
+     * Where the blog lives, for a site without a blog page in `pages.json`
+     * (one that routes by hand and mounts `<SettoBlog basePath>`). A blog page
+     * in the manifest wins.
+     */
+    blogPath?: string;
+}
+interface LoadedPost {
+    key: string;
+    frontmatter: BlogFrontmatter;
+    body: unknown;
+}
+export declare function loadPosts(root: string, imageHosts: readonly string[]): LoadedPost[];
+export declare function settoBlog(options?: SettoBlogPluginOptions): Plugin;
+/** Exported for tests: everything `writeBundle` does, given a built `outDir`. */
+export declare function writeStaticFiles(root: string, outDir: string, loaded: readonly LoadedPost[], options?: SettoBlogPluginOptions): {
+    written: string[];
+};
+export {};

package/dist/vite/static.d.ts

@@ -0,0 +1,78 @@
+/**
+ * The static files a blog adds to a site's build: one HTML page per post with
+ * its own head, the blog's index page, an RSS feed, and the posts in
+ * `sitemap.xml`.
+ *
+ * Why: the sites are single-page apps — every path is the same `index.html`.
+ * Google runs the JavaScript; Facebook, LinkedIn, X, Slack, Messenger and
+ * iMessage do not. They fetch the address and read the `og:` tags in the raw
+ * HTML, so without a file of its own a shared post shows the front page's
+ * title and picture. Vercel serves a real file before it applies the
+ * catch-all rewrite, so `/blogg/<slug>` gets this one and the app takes over
+ * in the browser as before.
+ *
+ * Pure functions over strings, so they can be tested without a build.
+ */
+import type { BlogFrontmatter } from '../blog/contract';
+export interface HeadMeta {
+    title: string;
+    description: string;
+    /** Absolute, when the site's address is known. */
+    url?: string;
+    /** Absolute. */
+    image?: string;
+    type: 'article' | 'website';
+    locale: string;
+    siteName?: string;
+    publishedTime?: string;
+    jsonLd?: Record<string, unknown>;
+    rssUrl?: string;
+    /** The same page in other languages, absolute; `x-default` for the primary. */
+    alternates?: {
+        hreflang: string;
+        href: string;
+    }[];
+}
+export declare const escapeXml: (value: string) => string;
+/**
+ * The site's `index.html` with a page's own head: its title, description,
+ * canonical address, Open Graph and Twitter tags and structured data. Any of
+ * those the front page already had are taken out first, so a crawler never
+ * reads two answers.
+ */
+export declare function withHead(indexHtml: string, meta: HeadMeta): string;
+/** `https://x.no` + `/blogg/a` — or the path alone when the address is unknown. */
+export declare function absolute(siteUrl: string | null, pathOrUrl: string): string;
+export interface PostHeadInput {
+    post: BlogFrontmatter;
+    blogPath: string;
+    siteUrl: string | null;
+    siteName?: string;
+}
+export declare function postHead({ post, blogPath, siteUrl, siteName }: PostHeadInput): HeadMeta;
+export declare function indexHead({ title, description, blogPath, siteUrl, siteName, locale, }: {
+    title: string;
+    description: string;
+    blogPath: string;
+    siteUrl: string | null;
+    siteName?: string;
+    locale: string;
+}): HeadMeta;
+export declare function rssFeed({ posts, blogPath, siteUrl, title, description, locale, }: {
+    posts: readonly BlogFrontmatter[];
+    blogPath: string;
+    siteUrl: string;
+    title: string;
+    description: string;
+    locale: string;
+}): string;
+/**
+ * The site's `sitemap.xml` with the blog and its posts added — before the
+ * closing tag, and only those not already listed.
+ */
+export declare function withSitemapEntries(sitemap: string, entries: readonly {
+    loc: string;
+    lastmod?: string;
+}[]): string;
+/** The site's own address, from the first `<loc>` of its sitemap. */
+export declare function originFromSitemap(sitemap: string): string | null;

package/dist/vite.js

@@ -0,0 +1,550 @@
+import { existsSync, readFileSync, mkdirSync, writeFileSync, readdirSync } from "node:fs";
+import path from "node:path";
+import { SETTO_MEDIA_HOST, BLOG_DIR, parseBlogPostPath, validateBlogPost } from "./blog.js";
+function byDateDesc(a, b) {
+  return a.date === b.date ? a.slug.localeCompare(b.slug) : a.date < b.date ? 1 : -1;
+}
+function postsForLanguage(posts, language, fallbackLanguage) {
+  const bySlug = /* @__PURE__ */ new Map();
+  for (const post of posts) {
+    const current = bySlug.get(post.slug);
+    if (!current || rank(post, language, fallbackLanguage) < rank(current, language, fallbackLanguage)) {
+      bySlug.set(post.slug, post);
+    }
+  }
+  return [...bySlug.values()].sort(byDateDesc);
+}
+function rank(post, language, fallbackLanguage) {
+  if (post.locale === language) return 0;
+  if (post.locale === fallbackLanguage) return 1;
+  return 2;
+}
+const NO = {
+  blog: "Blogg",
+  latest: "Fra bloggen",
+  allPosts: "Alle innlegg",
+  readMore: "Les mer",
+  back: "Alle innlegg",
+  empty: "Ingen innlegg ennå.",
+  notFound: "Fant ikke innlegget.",
+  loading: "Henter innlegget …",
+  share: "Del",
+  moreShare: "Flere valg …",
+  copyLink: "Kopier lenke",
+  copied: "Lenken er kopiert",
+  email: "E-post",
+  video: "Video",
+  play: "Spill av"
+};
+const EN = {
+  blog: "Blog",
+  latest: "From the blog",
+  allPosts: "All posts",
+  readMore: "Read more",
+  back: "All posts",
+  empty: "No posts yet.",
+  notFound: "That post could not be found.",
+  loading: "Loading the post …",
+  share: "Share",
+  moreShare: "More …",
+  copyLink: "Copy link",
+  copied: "Link copied",
+  email: "Email",
+  video: "Video",
+  play: "Play"
+};
+function blogStrings(language) {
+  return language === "no" || language === "nb" || language === "nn" ? NO : EN;
+}
+const PAGES_MANIFEST_VERSION = 1;
+const PAGES_PATH = "src/content/pages.json";
+const BUILTIN_SECTION_TYPES = ["text", "blog", "blog-latest"];
+const ID = /^[a-z0-9][a-z0-9-]{0,62}$/;
+const PATH = /^\/(?:[a-z0-9][a-z0-9-]*(?:\/[a-z0-9][a-z0-9-]*)*)?$/;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseManifest(input) {
+  const issues = [];
+  if (!isRecord(input)) return { ok: false, issues: [{ at: "$", message: "not an object" }] };
+  if (input.version !== PAGES_MANIFEST_VERSION) {
+    issues.push({ at: "version", message: `expected ${PAGES_MANIFEST_VERSION}` });
+  }
+  const pages = [];
+  const pageIds = /* @__PURE__ */ new Set();
+  const paths = /* @__PURE__ */ new Set();
+  const sectionIds = /* @__PURE__ */ new Set();
+  const rawPages = Array.isArray(input.pages) ? input.pages : null;
+  if (!rawPages) issues.push({ at: "pages", message: "must be a list" });
+  (rawPages ?? []).forEach((raw, i) => {
+    const at = `pages[${i}]`;
+    if (!isRecord(raw)) {
+      issues.push({ at, message: "not an object" });
+      return;
+    }
+    const id = String(raw.id ?? "");
+    const path2 = String(raw.path ?? "");
+    const titleKey = String(raw.titleKey ?? "");
+    if (!ID.test(id)) issues.push({ at: `${at}.id`, message: `invalid id "${id}"` });
+    else if (pageIds.has(id)) issues.push({ at: `${at}.id`, message: `duplicate page "${id}"` });
+    pageIds.add(id);
+    if (!PATH.test(path2)) issues.push({ at: `${at}.path`, message: `invalid path "${path2}"` });
+    else if (path2 === "/setto" || path2.startsWith("/setto/")) {
+      issues.push({ at: `${at}.path`, message: "/setto belongs to the editor" });
+    } else if (paths.has(path2)) issues.push({ at: `${at}.path`, message: `duplicate path "${path2}"` });
+    paths.add(path2);
+    if (!titleKey) issues.push({ at: `${at}.titleKey`, message: "required" });
+    const sections = [];
+    const rawSections = Array.isArray(raw.sections) ? raw.sections : null;
+    if (!rawSections) issues.push({ at: `${at}.sections`, message: "must be a list" });
+    (rawSections ?? []).forEach((s, j) => {
+      const sat = `${at}.sections[${j}]`;
+      if (!isRecord(s)) {
+        issues.push({ at: sat, message: "not an object" });
+        return;
+      }
+      const sid = String(s.id ?? "");
+      if (!ID.test(sid)) issues.push({ at: `${sat}.id`, message: `invalid id "${sid}"` });
+      else if (sectionIds.has(sid)) issues.push({ at: `${sat}.id`, message: `duplicate section "${sid}"` });
+      sectionIds.add(sid);
+      const type = s.type;
+      if (type !== void 0 && !BUILTIN_SECTION_TYPES.includes(type)) {
+        issues.push({ at: `${sat}.type`, message: `unknown section type "${String(type)}"` });
+      }
+      sections.push({
+        id: sid,
+        ...type !== void 0 ? { type } : {},
+        ...s.hidden === true ? { hidden: true } : {},
+        ...typeof s.label === "string" && s.label.trim() ? { label: s.label.trim() } : {}
+      });
+    });
+    pages.push({
+      id,
+      path: path2,
+      titleKey,
+      ...raw.hidden === true ? { hidden: true } : {},
+      sections
+    });
+  });
+  const blogs = pages.flatMap(
+    (p, i) => p.sections.flatMap((s, j) => s.type === "blog" ? [{ page: p, at: `pages[${i}].sections[${j}]` }] : [])
+  );
+  if (blogs.length > 1) {
+    issues.push({ at: blogs[1].at, message: "a site has one blog; another blog section is already on a page" });
+  }
+  for (const blog of blogs) {
+    if (blog.page.path === "/") issues.push({ at: blog.at, message: "the blog cannot be the front page" });
+  }
+  const menu = parseMenu(input.menu, "menu", issues);
+  const footer = parseMenu(input.footer, "footer", issues);
+  if (issues.length > 0) return { ok: false, issues };
+  return { ok: true, manifest: { version: PAGES_MANIFEST_VERSION, pages, menu, footer } };
+}
+function parseMenu(raw, at, issues) {
+  if (raw === void 0) return [];
+  if (!Array.isArray(raw)) {
+    issues.push({ at, message: "must be a list" });
+    return [];
+  }
+  const ids = /* @__PURE__ */ new Set();
+  const items = [];
+  raw.forEach((item, i) => {
+    const iat = `${at}[${i}]`;
+    if (!isRecord(item)) {
+      issues.push({ at: iat, message: "not an object" });
+      return;
+    }
+    const id = String(item.id ?? "");
+    const href = String(item.href ?? "");
+    const labelKey = String(item.labelKey ?? "");
+    if (!ID.test(id)) issues.push({ at: `${iat}.id`, message: `invalid id "${id}"` });
+    else if (ids.has(id)) issues.push({ at: `${iat}.id`, message: `duplicate item "${id}"` });
+    ids.add(id);
+    if (!isSafeHref(href)) issues.push({ at: `${iat}.href`, message: `invalid link "${href}"` });
+    if (!labelKey) issues.push({ at: `${iat}.labelKey`, message: "required" });
+    items.push({ id, href, labelKey, ...item.hidden === true ? { hidden: true } : {} });
+  });
+  return items;
+}
+function isSafeHref(href) {
+  if (!href) return false;
+  if (href.startsWith("/") && !href.startsWith("//")) return true;
+  if (href.startsWith("#")) return true;
+  return /^(https?:\/\/|mailto:|tel:)/i.test(href);
+}
+function normalisePath(path2) {
+  const bare = (path2.split(/[?#]/)[0] ?? "").replace(/\/+$/, "");
+  return bare === "" ? "/" : bare.toLowerCase();
+}
+function blogPage(manifest) {
+  for (const page of manifest.pages) {
+    const section = page.sections.find((s) => s.type === "blog");
+    if (section) return { page, section };
+  }
+  return null;
+}
+const escapeAttr = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+const escapeXml = escapeAttr;
+const safeJson = (value) => JSON.stringify(value).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026");
+function htmlLang(locale) {
+  return locale === "no" || locale === "nb" ? "nb-NO" : locale === "nn" ? "nn-NO" : locale;
+}
+const OG_LOCALE = { no: "nb_NO", nb: "nb_NO", nn: "nn_NO", en: "en_GB", sv: "sv_SE", da: "da_DK", de: "de_DE" };
+function withHead(indexHtml, meta) {
+  let html = indexHtml.replace(/<title>[\s\S]*?<\/title>\s*/gi, "").replace(/<meta\s+name=["']description["'][^>]*>\s*/gi, "").replace(/<meta\s+(?:property|name)=["'](?:og|twitter|article):[^"']*["'][^>]*>\s*/gi, "").replace(/<link\s+rel=["']canonical["'][^>]*>\s*/gi, "").replace(/<link\s+rel=["']alternate["']\s+type=["']application\/rss\+xml["'][^>]*>\s*/gi, "").replace(/<link\b(?=[^>]*\bhreflang=)[^>]*>\s*/gi, "").replace(/<script\s+type=["']application\/ld\+json["'][^>]*>[\s\S]*?<\/script>\s*/gi, "");
+  const lang = escapeAttr(htmlLang(meta.locale));
+  html = /<html\b[^>]*\blang=/i.test(html) ? html.replace(/(<html\b[^>]*\blang=)(["'])[^"']*\2/i, `$1"${lang}"`) : html.replace(/<html\b/i, `<html lang="${lang}"`);
+  const tags = [
+    `<title>${escapeAttr(meta.title)}</title>`,
+    `<meta name="description" content="${escapeAttr(meta.description)}" />`,
+    meta.url ? `<link rel="canonical" href="${escapeAttr(meta.url)}" />` : "",
+    ...(meta.alternates ?? []).map(
+      (a) => `<link rel="alternate" hreflang="${escapeAttr(a.hreflang === "x-default" ? a.hreflang : htmlLang(a.hreflang))}" href="${escapeAttr(a.href)}" />`
+    ),
+    meta.rssUrl ? `<link rel="alternate" type="application/rss+xml" title="${escapeAttr(meta.siteName ?? meta.title)}" href="${escapeAttr(meta.rssUrl)}" />` : "",
+    `<meta property="og:type" content="${meta.type}" />`,
+    `<meta property="og:title" content="${escapeAttr(meta.title)}" />`,
+    `<meta property="og:description" content="${escapeAttr(meta.description)}" />`,
+    meta.url ? `<meta property="og:url" content="${escapeAttr(meta.url)}" />` : "",
+    meta.image ? `<meta property="og:image" content="${escapeAttr(meta.image)}" />` : "",
+    meta.siteName ? `<meta property="og:site_name" content="${escapeAttr(meta.siteName)}" />` : "",
+    `<meta property="og:locale" content="${OG_LOCALE[meta.locale] ?? meta.locale}" />`,
+    meta.publishedTime ? `<meta property="article:published_time" content="${escapeAttr(meta.publishedTime)}" />` : "",
+    `<meta name="twitter:card" content="${meta.image ? "summary_large_image" : "summary"}" />`,
+    `<meta name="twitter:title" content="${escapeAttr(meta.title)}" />`,
+    `<meta name="twitter:description" content="${escapeAttr(meta.description)}" />`,
+    meta.image ? `<meta name="twitter:image" content="${escapeAttr(meta.image)}" />` : "",
+    meta.jsonLd ? `<script type="application/ld+json">${safeJson(meta.jsonLd)}<\/script>` : ""
+  ].filter(Boolean);
+  return html.replace(/<\/head>/i, `    ${tags.join("\n    ")}
+  </head>`);
+}
+function absolute(siteUrl, pathOrUrl) {
+  if (/^https?:\/\//i.test(pathOrUrl)) return pathOrUrl;
+  return siteUrl ? `${siteUrl.replace(/\/+$/, "")}${pathOrUrl}` : pathOrUrl;
+}
+function postHead({ post, blogPath, siteUrl, siteName }) {
+  const path2 = `${blogPath}/${post.slug}`;
+  const url = siteUrl ? absolute(siteUrl, path2) : void 0;
+  const image = post.cover ? absolute(siteUrl, post.cover) : void 0;
+  return {
+    title: siteName ? `${post.title} · ${siteName}` : post.title,
+    description: post.description,
+    url,
+    image,
+    type: "article",
+    locale: post.locale,
+    siteName,
+    publishedTime: post.date,
+    rssUrl: siteUrl ? absolute(siteUrl, `${blogPath}/rss.xml`) : void 0,
+    jsonLd: {
+      "@context": "https://schema.org",
+      "@type": "BlogPosting",
+      headline: post.title,
+      description: post.description,
+      datePublished: post.date,
+      inLanguage: post.locale,
+      ...image ? { image } : {},
+      ...url ? { url, mainEntityOfPage: url } : {},
+      ...siteName ? { publisher: { "@type": "Organization", name: siteName } } : {},
+      ...post.tags?.length ? { keywords: post.tags.join(", ") } : {}
+    }
+  };
+}
+function indexHead({
+  title,
+  description,
+  blogPath,
+  siteUrl,
+  siteName,
+  locale
+}) {
+  const url = siteUrl ? absolute(siteUrl, blogPath) : void 0;
+  return {
+    title: siteName ? `${title} · ${siteName}` : title,
+    description,
+    url,
+    type: "website",
+    locale,
+    siteName,
+    rssUrl: siteUrl ? absolute(siteUrl, `${blogPath}/rss.xml`) : void 0,
+    jsonLd: {
+      "@context": "https://schema.org",
+      "@type": "Blog",
+      name: title,
+      ...url ? { url } : {},
+      ...siteName ? { publisher: { "@type": "Organization", name: siteName } } : {}
+    }
+  };
+}
+function rssDate(date) {
+  return (/* @__PURE__ */ new Date(`${date}T12:00:00Z`)).toUTCString();
+}
+function rssFeed({
+  posts,
+  blogPath,
+  siteUrl,
+  title,
+  description,
+  locale
+}) {
+  const link = absolute(siteUrl, blogPath);
+  const self = absolute(siteUrl, `${blogPath}/rss.xml`);
+  const items = posts.map((post) => {
+    const url = absolute(siteUrl, `${blogPath}/${post.slug}`);
+    return [
+      "    <item>",
+      `      <title>${escapeXml(post.title)}</title>`,
+      `      <link>${escapeXml(url)}</link>`,
+      `      <guid isPermaLink="true">${escapeXml(url)}</guid>`,
+      `      <pubDate>${rssDate(post.date)}</pubDate>`,
+      `      <description>${escapeXml(post.description)}</description>`,
+      "    </item>"
+    ].join("\n");
+  }).join("\n");
+  return [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">',
+    "  <channel>",
+    `    <title>${escapeXml(title)}</title>`,
+    `    <link>${escapeXml(link)}</link>`,
+    `    <description>${escapeXml(description)}</description>`,
+    `    <language>${escapeXml(locale === "no" ? "nb" : locale)}</language>`,
+    `    <atom:link href="${escapeXml(self)}" rel="self" type="application/rss+xml" />`,
+    items,
+    "  </channel>",
+    "</rss>",
+    ""
+  ].filter((line) => line !== "").join("\n") + "\n";
+}
+function withSitemapEntries(sitemap, entries) {
+  const missing = entries.filter((entry) => !sitemap.includes(`<loc>${escapeXml(entry.loc)}</loc>`));
+  if (missing.length === 0 || !/<\/urlset>/i.test(sitemap)) return sitemap;
+  const block = missing.map(
+    (entry) => [
+      "  <url>",
+      `    <loc>${escapeXml(entry.loc)}</loc>`,
+      entry.lastmod ? `    <lastmod>${escapeXml(entry.lastmod)}</lastmod>` : "",
+      "  </url>"
+    ].filter(Boolean).join("\n")
+  ).join("\n");
+  return sitemap.replace(/<\/urlset>/i, `${block}
+</urlset>`);
+}
+function originFromSitemap(sitemap) {
+  const loc = /<loc>\s*([^<\s]+)\s*<\/loc>/i.exec(sitemap)?.[1];
+  if (!loc) return null;
+  try {
+    return new URL(loc).origin;
+  } catch {
+    return null;
+  }
+}
+const INDEX_ID = "virtual:setto-blog";
+const POST_PREFIX = "virtual:setto-blog/post/";
+const RESOLVED = "\0";
+function stripForBrowser(node) {
+  if (Array.isArray(node)) return node.map(stripForBrowser);
+  if (!node || typeof node !== "object") return node;
+  const out = {};
+  for (const [key, value] of Object.entries(node)) {
+    if (key === "position" || key === "data") continue;
+    out[key] = stripForBrowser(value);
+  }
+  return out;
+}
+function formatIssues(file, issues) {
+  return issues.map((i) => `  ${file}${i.line ? `:${i.line}` : ""} (${i.path}): ${i.message}`).join("\n");
+}
+function loadPosts(root, imageHosts) {
+  const dir = path.join(root, BLOG_DIR);
+  if (!existsSync(dir)) return [];
+  const posts = [];
+  const problems = [];
+  for (const name of readdirSync(dir).sort()) {
+    if (!name.endsWith(".mdx")) continue;
+    const repoPath = `${BLOG_DIR}/${name}`;
+    if (!parseBlogPostPath(repoPath)) {
+      problems.push(`  ${repoPath}: not <slug>.<locale>.mdx`);
+      continue;
+    }
+    const result = validateBlogPost(readFileSync(path.join(dir, name), "utf8"), { path: repoPath, imageHosts });
+    if (!result.ok) {
+      problems.push(formatIssues(repoPath, result.issues));
+      continue;
+    }
+    const { slug, locale } = result.post.frontmatter;
+    posts.push({ key: `${slug}.${locale}`, frontmatter: result.post.frontmatter, body: stripForBrowser(result.post.body) });
+  }
+  if (problems.length) {
+    throw new Error(`[setto-blog] ${problems.length === 1 ? "a post breaks" : "posts break"} the blog contract:
+${problems.join("\n")}`);
+  }
+  return posts;
+}
+function readJson(file) {
+  try {
+    return JSON.parse(readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function settoBlog(options = {}) {
+  const imageHosts = options.imageHosts ?? [SETTO_MEDIA_HOST];
+  let config;
+  let cache = null;
+  const posts = () => cache ??= loadPosts(config.root, imageHosts);
+  return {
+    name: "setto-blog",
+    configResolved(resolved) {
+      config = resolved;
+    },
+    resolveId(id) {
+      if (id === INDEX_ID || id.startsWith(POST_PREFIX)) return RESOLVED + id;
+      return null;
+    },
+    load(id) {
+      if (!id.startsWith(RESOLVED)) return null;
+      const bare = id.slice(RESOLVED.length);
+      if (bare === INDEX_ID) {
+        const list = posts();
+        const loaders = list.map((p) => `  ${JSON.stringify(p.key)}: () => import(${JSON.stringify(POST_PREFIX + p.key)}),`).join("\n");
+        return [
+          `const posts = ${JSON.stringify(list.map((p) => p.frontmatter))};`,
+          `const loaders = {
+${loaders}
+};`,
+          "export default {",
+          "  posts,",
+          "  load(slug, locale) {",
+          "    const load = loaders[slug + '.' + locale];",
+          "    return load ? load().then((m) => m.default) : Promise.resolve(null);",
+          "  },",
+          "};"
+        ].join("\n");
+      }
+      if (bare.startsWith(POST_PREFIX)) {
+        const post = posts().find((p) => p.key === bare.slice(POST_PREFIX.length));
+        if (!post) return "export default null;";
+        return `export default ${JSON.stringify({ frontmatter: post.frontmatter, body: post.body })};`;
+      }
+      return null;
+    },
+    configureServer(server) {
+      const dir = path.join(config.root, BLOG_DIR);
+      server.watcher.add(dir);
+      const changed = (file) => {
+        if (!path.resolve(file).startsWith(path.resolve(dir))) return;
+        cache = null;
+        for (const [id, mod] of server.moduleGraph.idToModuleMap) {
+          if (id.startsWith(RESOLVED + INDEX_ID)) server.moduleGraph.invalidateModule(mod);
+        }
+        server.ws.send({ type: "full-reload" });
+      };
+      server.watcher.on("add", changed).on("change", changed).on("unlink", changed);
+    },
+    writeBundle: {
+      sequential: true,
+      handler() {
+        if (config.command !== "build" || config.build.ssr) return;
+        writeStaticFiles(config.root, path.resolve(config.root, config.build.outDir), posts(), options);
+      }
+    }
+  };
+}
+function writeStaticFiles(root, outDir, loaded, options = {}) {
+  const written = [];
+  const manifestRaw = readJson(path.join(root, PAGES_PATH));
+  const parsed = manifestRaw ? parseManifest(manifestRaw) : null;
+  const blog = parsed?.ok ? blogPage(parsed.manifest) : null;
+  if (blog && (blog.page.hidden || blog.section.hidden)) return { written };
+  const blogPath = blog?.page.path ?? (options.blogPath ? normalisePath(options.blogPath) : null);
+  if (!blogPath || blogPath === "/") return { written };
+  const indexFile = path.join(outDir, "index.html");
+  if (!existsSync(indexFile)) return { written };
+  const indexHtml = readFileSync(indexFile, "utf8");
+  const settoConfig = readJson(path.join(root, "setto.config.json")) ?? {};
+  const languages = settoConfig.languages?.length ? settoConfig.languages : ["no"];
+  const language = languages[0];
+  const siteName = settoConfig.displayName;
+  const sitemapFile = path.join(outDir, "sitemap.xml");
+  const sitemap = existsSync(sitemapFile) ? readFileSync(sitemapFile, "utf8") : null;
+  const vercel = process.env.VERCEL_PROJECT_PRODUCTION_URL;
+  const siteUrl = options.siteUrl ?? process.env.SETTO_SITE_URL ?? (vercel ? `https://${vercel}` : null) ?? (sitemap ? originFromSitemap(sitemap) : null);
+  const posts = postsForLanguage(
+    loaded.map((p) => p.frontmatter),
+    language,
+    language
+  );
+  const write = (relative, content) => {
+    const file = path.join(outDir, relative);
+    mkdirSync(path.dirname(file), { recursive: true });
+    writeFileSync(file, content);
+    written.push(relative.split(path.sep).join("/"));
+  };
+  const all = loaded.map((p) => p.frontmatter);
+  const prefixOf = (lang) => lang === language ? "" : `/${lang}`;
+  const versionsOf = (slug) => all.filter((p) => p.slug === slug);
+  for (const lang of languages) {
+    const langBlogPath = `${prefixOf(lang)}${blogPath}`;
+    const dir = langBlogPath.replace(/^\//, "");
+    const langStrings = blogStrings(lang);
+    write(
+      path.join(dir, "index.html"),
+      withHead(
+        indexHtml,
+        indexHead({
+          title: langStrings.blog,
+          description: siteName ? `${langStrings.latest} · ${siteName}` : langStrings.latest,
+          blogPath: langBlogPath,
+          siteUrl,
+          siteName,
+          locale: lang
+        })
+      )
+    );
+    for (const post of postsForLanguage(all, lang, language)) {
+      const meta = postHead({ post, blogPath: langBlogPath, siteUrl, siteName });
+      const versions = versionsOf(post.slug);
+      if (post.locale !== lang && siteUrl) meta.url = absolute(siteUrl, `${prefixOf(post.locale)}${blogPath}/${post.slug}`);
+      if (siteUrl && versions.length > 1) {
+        meta.alternates = [
+          ...versions.map((v) => ({ hreflang: v.locale, href: absolute(siteUrl, `${prefixOf(v.locale)}${blogPath}/${v.slug}`) })),
+          { hreflang: "x-default", href: absolute(siteUrl, `${blogPath}/${post.slug}`) }
+        ];
+      }
+      write(path.join(dir, post.slug, "index.html"), withHead(indexHtml, meta));
+    }
+    if (siteUrl) {
+      const feedTitle = siteName ? `${langStrings.blog} · ${siteName}` : langStrings.blog;
+      write(
+        path.join(dir, "rss.xml"),
+        rssFeed({
+          posts: postsForLanguage(all, lang, language).slice(0, 50),
+          blogPath: langBlogPath,
+          siteUrl,
+          title: feedTitle,
+          description: siteName ? `${langStrings.latest} · ${siteName}` : langStrings.latest,
+          locale: lang
+        })
+      );
+    }
+  }
+  if (siteUrl) {
+    if (sitemap) {
+      const entries = [
+        { loc: absolute(siteUrl, blogPath), lastmod: posts[0]?.date },
+        ...posts.map((post) => ({ loc: absolute(siteUrl, `${blogPath}/${post.slug}`), lastmod: post.date })),
+        // A version in another language is a page of its own.
+        ...all.filter((post) => post.locale !== language && languages.includes(post.locale)).map((post) => ({ loc: absolute(siteUrl, `${prefixOf(post.locale)}${blogPath}/${post.slug}`), lastmod: post.date }))
+      ];
+      const next = withSitemapEntries(sitemap, entries);
+      if (next !== sitemap) write("sitemap.xml", next);
+    }
+  }
+  return { written };
+}
+export {
+  settoBlog
+};
+//# sourceMappingURL=vite.js.map