@morphemecms/cms 0.0.0-stage → 0.1.0

package/site/autolinks.mjs

@@ -0,0 +1,200 @@
+// Automatic internal links. The words come from the pages and posts themselves: their keywords
+// (`keyword`, the primary one, and `keywords`, more separated by commas; under
+// "Søgemaskiner" in the editor; the front page's link to / and the blog page's to /blog/, where they are shown, and the
+// 404 page's to nowhere). src/data/internal-links.json, under "Søgemaskineoptimering" ›
+// "Interne links" in the editor (packages/editor/defaults/internalLinks.ts): `enabled` turns the links on or off, `maxPerPage` is the
+// most per page. A word links to the page it is a
+// keyword of. Unlike linking every occurrence of a word, a target is
+// linked once per page, at most `maxPerPage` links per page, never to the page itself, never inside
+// headings or existing links, and never as part of a word joined with a hyphen (not "web" in "web-design"). Used by the Markdown pipeline (packages/editor/astro.mjs) and by an import
+// script, which removes the old plugin links so they are not doubled. Each link has data-link="auto", so how many there
+// are of each word can be counted after the build (packages/editor/scripts/link-counts.mjs, /editor/links.json).
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { parse } from 'yaml';
+import { isPreview, livePath } from './noindex.mjs';
+import { stateOf } from '@morphemecms/cms/lib/status.mjs';
+
+const FILE = path.resolve('src/data/internal-links.json');
+// The front page, the blog page and the 404 page ("Indstillinger" › "Udseende" › "Standardsider",
+// packages/editor/defaults/standardPages.ts): the front page's address sends on to /, the blog page's to /blog/, and the 404 page has none.
+const STANDARD = path.resolve('src/data/standard-pages.json');
+const PAGES = path.resolve('src/content/pages');
+const POSTS = path.resolve('src/content/blog');
+// What a word may not touch to be linked: a letter, a digit, or a hyphen joining it to another word.
+const LETTER = '\\p{L}\\p{N}-';
+const escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const split = (text) =>
+  String(text ?? '')
+    .split(',')
+    .map((w) => w.trim())
+    .filter(Boolean);
+
+let standard;
+/** A page's address as it is linked to: the front page's is /, the blog page's /blog/, and the 404 page's none (null). */
+function linked(href) {
+  standard ??= (() => {
+    try {
+      return JSON.parse(fs.readFileSync(STANDARD, 'utf8'));
+    } catch {
+      return {};
+    }
+  })();
+  if (href === standard.front) return '/';
+  if (href === standard.blog) return '/blog/';
+  return href === standard.notFound ? null : href;
+}
+
+/** The .md files in a folder and its subfolders, as paths relative to it (none when there is no folder). */
+const files = (dir) =>
+  fs.existsSync(dir) ? fs.readdirSync(dir, { recursive: true, encoding: 'utf8' }).filter((f) => f.endsWith('.md')) : [];
+const frontmatter = (file) => parse(fs.readFileSync(file, 'utf8').match(/^---\r?\n([\s\S]*?)\r?\n---/)?.[1] ?? '') ?? {};
+
+/** The keywords of the pages and posts: [{ href, primary, secondary }]. A page's address is its
+ * `path`, or else its file name (getPages() in packages/editor/site/content.ts); a new version of a page (/ny/…)
+ * gives its keywords to the page it is for, when that page exists. Only published ones are linked to
+ * (packages/editor/lib/status.mjs). */
+function keywordRules() {
+  const entries = [
+    ...files(PAGES).map((f) => {
+      const data = frontmatter(path.join(PAGES, f));
+      const id = f
+        .replace(/\\/g, '/')
+        .replace(/\.md$/, '')
+        .replace(/(^|\/)index$/, '');
+      return { href: data.path || `/${id}/`, data };
+    }),
+    ...files(POSTS).map((f) => ({ href: `/${path.basename(f, '.md')}/`, data: frontmatter(path.join(POSTS, f)) })),
+  ].filter((e) => stateOf(e.data) === 'published');
+  const live = new Set(
+    entries
+      .map((e) => e.href)
+      .filter((href) => !isPreview(href))
+      .map(linked),
+  );
+  return entries
+    .map(({ href, data }) => ({ href: linked(livePath(href)), primary: split(data.keyword), secondary: split(data.keywords) }))
+    .filter((r) => r.href && live.has(r.href) && (r.primary.length || r.secondary.length))
+    .sort((a, b) => a.href.localeCompare(b.href));
+}
+
+let cached;
+/** { enabled, maxPerPage, words: Map<lowercase word, href>, pattern } */
+export function loadLinks() {
+  if (cached) return cached;
+  const data = JSON.parse(fs.readFileSync(FILE, 'utf8'));
+  const enabled = data.enabled !== false;
+  const maxPerPage = Number.isFinite(data.maxPerPage) ? data.maxPerPage : 8;
+  // A word used for two pages links to the one it is the primary keyword of, then to the one it is
+  // a secondary keyword of; between equals, to the first by address.
+  const rules = keywordRules();
+  const ranked = [...rules.map((r) => ({ href: r.href, words: r.primary })), ...rules.map((r) => ({ href: r.href, words: r.secondary }))];
+  const words = new Map();
+  for (const { href, words: list } of ranked)
+    for (const word of list) {
+      const key = word.toLowerCase();
+      if (!words.has(key)) words.set(key, href);
+      else if (words.get(key) !== href) console.warn(`interne links: "${word}" linker til ${words.get(key)}, ikke ${href}`);
+    }
+  // One regex for all words, longest first so "tryg tilknytning" wins over shorter matches.
+  const all = [...words.keys()].sort((a, b) => b.length - a.length).map(escape);
+  const pattern = new RegExp(`(?<![${LETTER}])(${all.join('|')})(?![${LETTER}])`, 'giu');
+  cached = { enabled, maxPerPage, words, pattern };
+  return cached;
+}
+
+// Not inside links, headings, code, or the offer and price boxes.
+const SKIP = new Set(['aside', 'a', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'code', 'pre', 'button', 'figcaption', 'dl']);
+
+/** The URL of the page being rendered: front matter `path` (pages) or /<file name>/ (posts). A new
+ * version of a page (/ny/…) counts as the page it is for, so it links as it will once it replaces it. */
+function pagePath(file) {
+  const fm = file.data?.astro?.frontmatter;
+  if (fm?.path) return linked(livePath(fm.path));
+  const name = path.basename(file.path ?? '', '.md');
+  return name ? linked(`/${name}/`) : '';
+}
+
+/** The pages a block in the text links to (packages/editor/lib/blocks.mjs): its `href` fields (emner, priskort,
+ * knapper, Kort), the links in its texts (spørgsmål og svar) and the posts it picks. */
+function blockLinks(node) {
+  let props;
+  try {
+    props = JSON.parse(String(node.properties.dataProps ?? '{}'));
+  } catch {
+    return [];
+  }
+  const links = [];
+  const visit = (value, key) => {
+    if (typeof value === 'string') {
+      if (key === 'href' && value.startsWith('/')) links.push(value.split('#')[0]);
+      for (const m of value.matchAll(/\]\((\/[^)\s#]*)/g)) links.push(m[1]);
+    } else if (Array.isArray(value)) value.forEach((v) => visit(v, key));
+    else if (value && typeof value === 'object') Object.entries(value).forEach(([k, v]) => visit(v, k));
+  };
+  visit(props);
+  if (node.properties.dataBlock === 'posts' && Array.isArray(props.picked)) links.push(...props.picked.map((id) => `/${id}/`));
+  return links;
+}
+
+/** What every page's links are made from: the words and where each links to, whether they are on and how many there
+ * are per page, and this file. Given to the plugin in packages/editor/astro.mjs, so it is in Astro's config: a page's text is
+ * kept rendered between builds (node_modules/.astro) until it or the config changes, and a keyword changed on one page
+ * changes the links on the others, so then every page is rendered again. */
+export function linksDigest() {
+  const { enabled, maxPerPage, words } = loadLinks();
+  const text = JSON.stringify([enabled, maxPerPage, [...words], fs.readFileSync(new URL(import.meta.url), 'utf8')]);
+  return createHash('sha256').update(text).digest('hex').slice(0, 16);
+}
+
+/** Rehype plugin; `digest` (linksDigest) is not used here. */
+export function rehypeAutoLinks() {
+  return (tree, file) => {
+    const { enabled, maxPerPage, words, pattern } = loadLinks();
+    if (!enabled || !words.size) return;
+    const self = pagePath(file);
+    const used = new Set([self]);
+    // Targets the text already links to by hand, or a block on the page links to, are not linked again.
+    const collect = (node) => {
+      if (node.type === 'element' && node.tagName === 'a') used.add(String(node.properties?.href ?? '').split('#')[0]);
+      if (node.type === 'element' && node.properties?.dataBlock) blockLinks(node).forEach((href) => used.add(href));
+      node.children?.forEach(collect);
+    };
+    collect(tree);
+    let count = 0;
+
+    const walk = (node) => {
+      if (!node.children || count >= maxPerPage) return;
+      if (node.type === 'element' && SKIP.has(node.tagName)) return;
+      const out = [];
+      for (const child of node.children) {
+        if (child.type !== 'text' || count >= maxPerPage) {
+          walk(child);
+          out.push(child);
+          continue;
+        }
+        let last = 0;
+        for (const m of child.value.matchAll(pattern)) {
+          const href = words.get(m[1].toLowerCase());
+          if (used.has(href) || count >= maxPerPage) continue;
+          used.add(href);
+          count++;
+          if (m.index > last) out.push({ type: 'text', value: child.value.slice(last, m.index) });
+          // data-link="auto": counted after the build (packages/editor/scripts/link-counts.mjs), for the editor's list of keywords.
+          out.push({ type: 'element', tagName: 'a', properties: { href, dataLink: 'auto' }, children: [{ type: 'text', value: m[1] }] });
+          last = m.index + m[1].length;
+        }
+        if (last < child.value.length) out.push({ type: 'text', value: child.value.slice(last) });
+      }
+      node.children = out;
+    };
+    walk(tree);
+  };
+}
+
+/** For the migration: turn links whose text is one of the words back into plain text. */
+export function unlinkAutoWords(markdown) {
+  const { words } = loadLinks();
+  return markdown.replace(/(?<!!)\[([^\]\[]+)\]\((\/[^)\s]*)\)/g, (all, text) => (words.has(text.trim().toLowerCase()) ? text : all));
+}

package/site/blockScripts.ts

@@ -0,0 +1,31 @@
+// What the blocks do in a browser on the site: script.ts in a theme's blocks/<type>/ (the rows that fold out, the
+// testimonials' "Læs mere" …; the theme in use's, else the standard theme's, as their look, sites.ts), what the theme's
+// UI components do (ui/<name>.script.ts: a carousel's page indicator, by `ui/<name>`), in an app's
+// block (src/apps/<app>/blocks/<type>/), and in an app's part of a list's entries (src/apps/<app>/<list>/: Mailchimp's
+// signup in a pop-up). Each is a function that finds its blocks on the page and does nothing without them; the theme's
+// Base.astro runs them all on every page, so they also work where a site or an app shows a block's parts of its own
+// (this site's front page).
+type Script = () => void;
+
+const byType = (found: Record<string, Script>) =>
+  Object.fromEntries(Object.entries(found).map(([file, run]) => [file.split('/').at(-2)!, run]));
+
+// The theme's UI components' by their name (ui/carousel.script.ts: ui/carousel).
+const byUi = (found: Record<string, Script>) =>
+  Object.fromEntries(Object.entries(found).map(([file, run]) => [`ui/${file.split('/').at(-1)!.replace('.script.ts', '')}`, run]));
+
+/** What each block does in a browser, by its type. */
+export const blockScripts: Record<string, Script> = {
+  ...byType(import.meta.glob<Script>('@saturn/blocks/*/script.ts', { eager: true, import: 'default' })),
+  ...byType(import.meta.glob<Script>('@theme/blocks/*/script.ts', { eager: true, import: 'default' })),
+  ...byUi(import.meta.glob<Script>('@saturn/ui/*.script.ts', { eager: true, import: 'default' })),
+  ...byUi(import.meta.glob<Script>('@theme/ui/*.script.ts', { eager: true, import: 'default' })),
+  ...byType(import.meta.glob<Script>('/src/apps/*/blocks/*/script.ts', { eager: true, import: 'default' })),
+  // An app's part of its kind of a list's entries (Mailchimp's signup in a pop-up), by the app and the list.
+  ...Object.fromEntries(
+    Object.entries(import.meta.glob<Script>('/src/apps/*/*/script.ts', { eager: true, import: 'default' })).map(([file, run]) => [
+      file.split('/').slice(-3, -1).join('/'),
+      run,
+    ]),
+  ),
+};

package/site/categories.ts

@@ -0,0 +1,16 @@
+// Tags (called categories in the code): one JSON file per tag in src/data/categories/, edited in the
+// editor (/editor/, "Tags"). The file name is the slug: the address /blog/kategori/<slug>/ and the
+// value stored in the `categories` of the blog posts and the testimonials. Only a blog category
+// (`blogCategory`, "Blogkategori" in the editor) is shown on the blog: a pill on the blog index and
+// on its posts, and its own page. The others only pick posts and testimonials.
+type CategoryData = { name: string; blogCategory?: boolean; seoTitle?: string; seoDescription?: string; shareImage?: string };
+
+const files = import.meta.glob<CategoryData>('@data/categories/*.json', { eager: true, import: 'default' });
+
+export const categories = Object.entries(files)
+  .map(([file, c]) => ({ slug: file.replace(/^.*\/|\.json$/g, ''), ...c }))
+  .sort((a, b) => a.slug.localeCompare(b.slug));
+
+const notOnBlog = new Set(categories.filter((c) => c.blogCategory === false).map((c) => c.slug));
+/** Whether the tag is shown on the blog (a tag without a file, or from before the field, is). */
+export const isBlogCategory = (slug: string) => !notOnBlog.has(slug);

package/site/consent.ts

@@ -0,0 +1,26 @@
+// What the cookie banner asks about: the categories of cookies (@morphemecms/cms/lib/cookieCategories.mjs) of what the
+// installed apps load with their settings (`cookies` in their index.ts: Google Analytics statistics, Google Ads
+// marketing, Google Tag Manager both), each a yes or no of its own; and whether the site has the banner (and
+// "Cookieindstillinger" in the footer) at all: when it is switched on ("Privatliv" › "Cookiebanner",
+// src/data/cookies.json) and there is something to ask about. For the theme (Base.astro, Footer.astro,
+// CookieConsent.astro), which knows no app by name.
+import type { AppDefinition } from '../src/apps';
+import { appIdOf } from '../src/apps';
+import { CONSENT_CATEGORIES, type ConsentCategory } from '../lib/cookieCategories.mjs';
+import cookies from '@data/cookies.json';
+import { installed, settingsOf } from './apps';
+
+// Only the apps' index.ts, without their blocks (as opens.ts).
+const appFiles = import.meta.glob<{ default: AppDefinition }>('/src/apps/*/index.ts', { eager: true });
+
+const asked = new Set(
+  Object.entries(appFiles).flatMap(([path, { default: app }]) => {
+    const id = appIdOf(path);
+    return installed.includes(id) ? (app.cookies?.(settingsOf(id, app.settings?.values)) ?? []) : [];
+  }),
+);
+
+/** The categories the banner asks about, in its order. */
+export const consentCategories: ConsentCategory[] = CONSENT_CATEGORIES.filter((c) => asked.has(c));
+
+export const cookieBanner = cookies.enabled && consentCategories.length > 0;

package/site/content.config.ts

@@ -0,0 +1,84 @@
+import { defineCollection, z } from 'astro:content';
+import { glob } from 'astro/loaders';
+
+// Kladde, Skjult or Planlagt (Udgivet when left out), and for Planlagt when, in Danish time
+// ("2026-11-01T08:00"): what each one is on the site is in packages/editor/lib/status.mjs.
+const status = {
+  status: z.enum(['draft', 'unlisted', 'scheduled']).optional(),
+  publishAt: z.string().optional(),
+};
+
+// Blog posts: one .md file per post in src/content/blog/.
+// The file name becomes the URL: mit-foerste-indlaeg.md -> /mit-foerste-indlaeg/
+const blog = defineCollection({
+  loader: glob({ pattern: '**/*.md', base: './src/content/blog' }),
+  schema: z.object({
+    title: z.string(),
+    date: z.coerce.date(),
+    // Last edit (when imported, the old site's); dateModified in the structured data.
+    updated: z.coerce.date().optional(),
+    description: z.string().optional().default(''),
+    categories: z.array(z.string()).optional().default([]),
+    image: z.string().optional(),
+    imageAlt: z.string().optional(),
+    // "Dekorativt billede": `image` is drawn with alt="" (screen readers skip it), whatever `imageAlt` says.
+    imageDecorative: z.boolean().optional(),
+    ...status,
+    // Google title and description (the <title> and meta description). Empty: built from the title.
+    seoTitle: z.string().optional(),
+    seoDescription: z.string().optional(),
+    // The picture shown when it is shared (og:image). Empty: `image`, else the first picture in the text.
+    shareImage: z.string().optional(),
+    // The title and description when it is shared (og:title, og:description). Empty: the Google title and description.
+    shareTitle: z.string().optional(),
+    shareDescription: z.string().optional(),
+    // Words that link here from the other pages and posts (packages/editor/site/autolinks.mjs): the primary
+    // keyword, and more separated by commas.
+    keyword: z.string().optional(),
+    keywords: z.string().optional(),
+    // The address of the page Google should count as the original (rel=canonical). Empty: this one.
+    canonical: z.string().optional(),
+    // Not for search engines: noindex (Base.astro) and not in the sitemap (packages/editor/astro.mjs).
+    noindex: z.boolean().optional().default(false),
+  }),
+});
+
+// Imported pages. `path` is the exact URL, e.g. /ydelser/raadgivning/
+// Pages created in the editor (/editor/) have no `path`: the file name is the URL (getPages()).
+const pages = defineCollection({
+  loader: glob({ pattern: '**/*.md', base: './src/content/pages' }),
+  schema: z.object({
+    title: z.string(),
+    path: z
+      .string()
+      .regex(/^\/.*\/$/, 'path skal starte og slutte med /')
+      .optional(),
+    description: z.string().optional().default(''),
+    order: z.number().optional().default(0),
+    ...status,
+    // Google title and description (the <title> and meta description). Empty: built from the title.
+    seoTitle: z.string().optional(),
+    seoDescription: z.string().optional(),
+    // The picture shown when it is shared (og:image). Empty: the first picture in the text.
+    shareImage: z.string().optional(),
+    // The title and description when it is shared (og:title, og:description). Empty: the Google title and description.
+    shareTitle: z.string().optional(),
+    shareDescription: z.string().optional(),
+    // Words that link here from the other pages and posts (packages/editor/site/autolinks.mjs): the primary
+    // keyword, and more separated by commas.
+    keyword: z.string().optional(),
+    keywords: z.string().optional(),
+    // The address of the page Google should count as the original (rel=canonical). Empty: this one.
+    canonical: z.string().optional(),
+    // Not for search engines: noindex (Base.astro) and not in the sitemap (packages/editor/astro.mjs).
+    noindex: z.boolean().optional().default(false),
+    // Across the whole page, without the owner's card beside the text (PageLayout.astro).
+    wide: z.boolean().optional().default(false),
+    // A new version of a page (/ny/…): what the owner should look at or answer before it replaces the
+    // current page. Shown at the top of the new version and on /ny/.
+    review: z.string().optional(),
+    updated: z.coerce.date().optional(),
+  }),
+});
+
+export const collections = { blog, pages };

package/site/content.ts

@@ -0,0 +1,104 @@
+import { getCollection, type CollectionEntry } from 'astro:content';
+import { categories, isBlogCategory } from './categories';
+import { displayTitle } from './text';
+import { isPreview } from './noindex.mjs';
+import { stateOf } from '@morphemecms/cms/lib/status.mjs';
+import { pageH1 } from '@morphemecms/cms/src/sections.mjs';
+
+// From text.ts, which the editor uses too (it has no content collections).
+export { displayTitle, openingText } from './text';
+export { stateOf };
+
+export type Post = CollectionEntry<'blog'>;
+// Every page has a path: its own, or /<file name>/ for pages created in the editor.
+export type Page = CollectionEntry<'pages'> & { data: { path: string } };
+
+export const postPath = (post: Post) => `/${post.id}/`;
+
+// What a page or post is on this site (packages/editor/lib/status.mjs); in dev a draft is on it, as if published.
+const stateHere = (data: { status?: string; publishAt?: string }) => {
+  const state = stateOf(data);
+  return state === 'draft' && import.meta.env.DEV ? 'published' : state;
+};
+// Whether a page or post in that state is built: a published one, and with `unlisted` a hidden one.
+const shown = (state: ReturnType<typeof stateOf>, unlisted: boolean) => state === 'published' || (unlisted && state === 'unlisted');
+
+// The posts on the blog and in every list of posts; with `unlisted`, also those that only open on
+// their address (Skjult; the pages of the posts are made for those too). A draft is not on the site.
+export async function getPosts({ unlisted = false } = {}) {
+  return (await getCollection('blog', ({ data }) => shown(stateHere(data), unlisted))).sort(
+    (a, b) => b.data.date.valueOf() - a.data.date.valueOf(),
+  );
+}
+
+/** Which posts a "Blogindlæg" block or the front page's section shows (packages/editor/site/home.ts): those in
+ * any of `categories` (all when empty), the newest `count`, or with `order` "random" all of them,
+ * to show `count` of at random on the page (the theme's PostList.tsx); or with `show` "picked" those picked. */
+export async function postsFor(
+  { show = 'categories', categories = [], order = 'newest', picked = [] }: PostChoice,
+  count: number,
+): Promise<{ posts: Post[]; random: boolean }> {
+  const posts = await getPosts();
+  if (show === 'picked') return { posts: picked.map((id) => posts.find((p) => p.id === id)).filter((p) => p !== undefined), random: false };
+  const pool = posts.filter((p) => !categories.length || p.data.categories.some((c) => categories.includes(c)));
+  const random = order === 'random' && pool.length > count;
+  return { posts: random ? pool : pool.slice(0, count), random };
+}
+export type PostChoice = {
+  /** "all": all of them, which "Blogindlæg" lists itself (StandardSite.posts.list), not by this. */
+  show?: 'all' | 'categories' | 'picked';
+  categories?: string[];
+  /** How many, '3' to '6' (postCount in the standard block Blogindlæg's shared.ts). */
+  count?: string;
+  order?: 'newest' | 'random';
+  picked?: string[];
+  /** The category "Alle indlæg" goes to (allPostsCategory in packages/editor/site/home.ts). */
+  link?: string;
+};
+
+// The pages on the site, also the hidden ones (Skjult; with `unlisted: false` not those) and, like the
+// posts, the drafts on the editor's preview; with `previews: false`, not the new versions of pages under /ny/.
+export async function getPages({ previews = true, unlisted = true } = {}): Promise<Page[]> {
+  const pages = await getCollection('pages', ({ data }) => shown(stateHere(data), unlisted));
+  for (const page of pages) page.data.path ??= `/${page.id}/`;
+  return (previews ? pages : pages.filter((p) => !isPreview(p.data.path!))) as Page[];
+}
+
+const categoryNames = new Map(categories.map((c) => [c.slug, c.name]));
+export const categoryName = (slug: string) => categoryNames.get(slug) ?? slug.replace(/-/g, ' ').replace(/^./, (c) => c.toUpperCase());
+
+// The blog categories that actually have posts, most used first: the pills on the blog index and
+// the pages /blog/kategori/<slug>/.
+export async function getCategories() {
+  const posts = await getPosts();
+  const counts = new Map<string, number>();
+  for (const p of posts) for (const c of p.data.categories.filter(isBlogCategory)) counts.set(c, (counts.get(c) ?? 0) + 1);
+  return [...counts].sort((a, b) => b[1] - a[1]).map(([slug, count]) => ({ slug, name: categoryName(slug), count }));
+}
+
+export function parentPage(page: Page, all: Page[]) {
+  const folder = page.data.path.replace(/[^/]+\/$/, '');
+  if (folder === '/') return undefined;
+  return all.find((p) => p.data.path === folder);
+}
+
+// The H1 of a page: the heading at the top of its text ("# …", pageH1), else its title.
+export const pageHeading = (page: Page) => pageH1(page.body ?? '').heading ?? displayTitle(page.data.title);
+
+/** The H1 of a page as HTML, when a word in it has a colour (<span class="color-accent">, packages/editor/lib/text-colors.mjs),
+ * for the layout to draw in its place; else undefined, and the layout draws pageHeading. */
+export const pageHeadingHtml = (page: Page): string | undefined => pageH1(page.body ?? '').html;
+
+/** A page's text as HTML without its H1 at the top, which the layout draws in its own place (above the picture). */
+export const withoutH1 = (html: string) => html.replace(/^\s*<h1\b[^>]*>[\s\S]*?<\/h1>\s*/, '');
+
+/** Anchor for a testimonial on the testimonials page, e.g. "marie-louise-eriksen". */
+export const testimonialId = (t: { name: string }) =>
+  t.name
+    .toLowerCase()
+    .replace(/æ/g, 'ae')
+    .replace(/ø/g, 'oe')
+    .replace(/å/g, 'aa')
+    .normalize('NFD')
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-|-$/g, '');

package/site/cookieList.ts

@@ -0,0 +1,17 @@
+// The site's cookie list: one JSON file per cookie in src/data/cookie-list/ (config.cookieList), edited in the editor
+// ("Lister" › "Cookies"), with those of the apps installed and those the app "Cookiescanner" finds (see
+// packages/editor/src/cookieList.ts). The standard block "Cookieliste" shows them (StandardSite.cookies).
+import { categoryOf } from '@morphemecms/cms/lib/cookieCategories.mjs';
+import type { CookieItem } from '@morphemecms/cms/src/standard/site';
+
+const files = import.meta.glob<Record<string, unknown>>('@data/cookie-list/*.json', { eager: true, import: 'default' });
+
+const text = (v: unknown) => (v == null ? '' : String(v));
+
+export const cookieList: CookieItem[] = Object.values(files).map((c) => ({
+  name: text(c.name),
+  provider: text(c.provider),
+  purpose: text(c.purpose) || undefined,
+  lasts: text(c.lasts) || undefined,
+  category: categoryOf(c),
+}));

package/site/defineSite.d.mts

@@ -0,0 +1,142 @@
+export function defineSite(own: SiteOwn & Partial<SiteChoices>): SiteConfig;
+export type ButtonTarget = {
+    value: string;
+    label: string;
+    note?: string;
+    pick?: string;
+    pickLabel?: string;
+};
+/**
+ * What a site says of itself in its config.ts.
+ */
+export type SiteOwn = {
+    /**
+     * The editor's name as an app (on the home screen, in the tab).
+     */
+    name: string;
+    /**
+     * What the editor is for (the app's description).
+     */
+    description: string;
+    /**
+     * The site's language, with the country (BCP 47): the editor's, unless one is picked on "Konto" or
+     * the browser asks for another the editor has (src/i18n/); the commits are always in it.
+     */
+    locale: string;
+    /**
+     * The site's own domain: a link written with it is a link within the site. The site is at
+     * https://<domain>/ (Astro's `site`, the structured data), and measures only there and at www.<domain> (site/tracking.ts).
+     */
+    domain: string;
+    /**
+     * What search engines show of the site when a page has no description of its own.
+     */
+    siteDescription: string;
+    /**
+     * Where a save goes: one commit on this branch (src/github.ts).
+     */
+    repo: {
+        owner: string;
+        name: string;
+        branch: string;
+    };
+};
+/**
+ * What a site can say of itself, else the standard: the owner's picture (beside a blog post, and shown when a page with
+ * none of its own is shared), the booking page and the pages a booking ends on, the page about the owner, the block
+ * drawn after every blog post, the word a page's title can end in, pictures that are the same though their names say
+ * otherwise, the file of its redirects from old addresses, and its app store.
+ */
+export type SiteChoices = {
+    /**
+     * The owner's picture, or none.
+     */
+    picture: {
+        src: string;
+        alt: string;
+    } | null;
+    /**
+     * The booking page, where "Book en tid" goes when no booking sheet
+     * opens ('': the site has none, and the header has no button to it), and the pages a booking or an order ends on: not
+     * for search engines (site/noindex.mjs), and without the action bar.
+     */
+    booking: {
+        path: string;
+        thanks: string[];
+    };
+    /**
+     * The page about the owner (an AboutPage in the structured data), or ''.
+     */
+    aboutPath: string;
+    /**
+     * The block drawn across the page after every blog post (its type, with its shared texts), or ''.
+     */
+    postEnd: string;
+    /**
+     * A word a page's title can end in, after a dash, for search engines (" – København"): kept in
+     * <title>, left out of the page's heading (displayTitle in site/text.ts). Empty: nothing is left out.
+     */
+    titleEnd: string;
+    /**
+     * Pictures that are the same though their names say otherwise (a crop
+     * saved under a new name), by name (samePicture in site/images.mjs).
+     */
+    samePictures: Record<string, string>;
+    /**
+     * The site's other redirects: rules ("<from> <to> 301", one to a
+     * line) and the Worker's map (`{ ids, paths }`, worker/index.js), shown and changed with the editor's own under
+     * Videresendelser (src/redirects.ts).
+     */
+    siteRedirects: {
+        rules: string;
+        map: string;
+    };
+    /**
+     * The app store ("Apps" ›
+     * "Appstore", src/store.ts): the GitHub repository and branch of its catalog (`catalog`, the apps and themes that can
+     * be installed, each with where its folder is in the repository, at which commit), or none: then "Appstore" has only
+     * the site's own.
+     */
+    store: {
+        owner: string;
+        name: string;
+        branch: string;
+        catalog: string;
+    } | null;
+};
+export type SiteConfig = SiteOwn & SiteChoices & typeof STANDARD;
+declare namespace STANDARD {
+    let wrangler: string;
+    namespace folders {
+        let blog: string;
+        let pages: string;
+        let data: string;
+        let media: string;
+        let files: string;
+    }
+    let redirects: string;
+    let blockSettings: string;
+    namespace apps {
+        let installed: string;
+        let settings: string;
+        let folder: string;
+    }
+    let blockTexts: string;
+    let theme: string;
+    let icons: string;
+    let motion: string;
+    let themes: string;
+    let csp: string;
+    let colors: string;
+    let menu: string;
+    let reserved: string[];
+    namespace lists {
+        let testimonials: string;
+        let tags: string;
+        let cookies: string;
+    }
+    let cookieList: string;
+    let buttonTargets: ButtonTarget[];
+    let standardPages: string;
+}
+export {};