@morphemecms/cms 0.0.0-stage → 0.1.0

package/scripts/releases.mjs

@@ -0,0 +1,80 @@
+// What of the apps and themes in the app store is released and what is not yet (store-release.mjs, check-content.mjs).
+// The catalog (store/catalog.json) is what is released: an app or a theme is released when the owner asks for it, with
+// `npm run store:release -- <id>`, not by each merge. Between two releases, what is changed in its folder waits for the
+// next one under the next version, given once: the next patch, minor or major release after the one in the catalog
+// (whichever the changes together are), with one release note saying all that is new in it.
+import { execFileSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+
+const git = (args, input) => execFileSync('git', args, { encoding: 'utf8', input }).trim();
+const parts = (v) => v.split('.').map((n) => Number.parseInt(n, 10) || 0);
+
+/** Whether a version is newer than another (as `newer` in packages/editor/src/store.ts). */
+function newer(a, b) {
+  const [x, y] = [parts(a), parts(b)];
+  for (let i = 0; i < Math.max(x.length, y.length); i++) if ((x[i] ?? 0) !== (y[i] ?? 0)) return (x[i] ?? 0) > (y[i] ?? 0);
+  return false;
+}
+
+/** The versions that can follow one: its next patch, minor and major release ("1.2.1": 1.2.2, 1.3.0, 2.0.0). */
+export function nextVersions(version) {
+  const [x, y, z] = parts(version);
+  return [`${x}.${y}.${z + 1}`, `${x}.${y + 1}.0`, `${x + 1}.0.0`];
+}
+
+/** A folder's files as they are now, committed or not (but those git ignores and its store.json), by their path in it,
+ * with their blob ids. */
+function filesNow(folder) {
+  const paths = git(['ls-files', '-co', '--exclude-standard', '--', folder])
+    .split('\n')
+    .filter((p) => p && p !== `${folder}/store.json` && existsSync(p));
+  const oids = paths.length ? git(['hash-object', '--stdin-paths'], paths.join('\n')).split('\n') : [];
+  return new Map(paths.map((p, i) => [p.slice(folder.length + 1), oids[i]]));
+}
+
+/** Whether a folder is not as its entry in the catalog has it (another file, one more or one less). */
+export function changedSince(folder, entry) {
+  const now = filesNow(folder);
+  return now.size !== entry.files.length || entry.files.some((f) => now.get(f.path) !== f.oid);
+}
+
+/** What is wrong with the version of an app or a theme of the store against what the catalog has released of it.
+ * `item`: `kind` ('apps' or 'themes'), `id`, `folder`, `version`, `notes` (its release notes by version, one object
+ * for each language it writes them in, by the language: [[null, notes]] for an app) and `where` (the file with its
+ * version). One never released can have any version. */
+export function releaseProblems(catalog, item) {
+  const entry = catalog[item.kind]?.find((x) => x.id === item.id);
+  if (!entry) return [];
+  const { version, where, folder } = item;
+  const released = entry.version;
+  if (newer(released, version))
+    return [`${where}: version ${version} er lavere end ${released}, som er udgivet. En udgivet version sættes aldrig ned.`];
+  if (!changedSince(folder, entry))
+    return version === released
+      ? []
+      : [`${where}: version ${version}, men intet i ${folder} er ændret, siden ${released} blev udgivet. Sæt den tilbage til ${released}.`];
+  const next = nextVersions(released);
+  const problems = [];
+  if (version === released)
+    problems.push(
+      `${where}: ${folder} er ændret, siden ${released} blev udgivet, så den skal have den næste version, ${next.join(', ')} (efter, hvad ændringerne er), med en release note. Den udgives først, når ejeren beder om det.`,
+    );
+  else if (!next.includes(version))
+    problems.push(
+      `${where}: version ${version} følger ikke ${released}, som er udgivet. Mellem to udgivelser får den den næste version én gang: ${next.join(', ')}, og det nye står i dens ene release note.`,
+    );
+  else
+    for (const [language, notes] of item.notes)
+      if (!notes?.[version]) problems.push(`${where}: version ${version} har ingen release note${language ? ` på ${language}` : ''}.`);
+  for (const [language, notes] of item.notes)
+    for (const v of Object.keys(notes ?? {}))
+      if (v !== version && newer(v, released))
+        problems.push(
+          `${where}: release noten til ${v}${language ? ` (${language})` : ''} er til en version, der aldrig blev udgivet. Skriv det i noten til ${version}.`,
+        );
+  return problems;
+}
+
+/** An app's or a theme's release notes as releaseProblems takes them. */
+export const notesOf = (releaseNotes, byLanguage) =>
+  byLanguage && Object.keys(releaseNotes ?? {}).length ? Object.entries(releaseNotes) : [[null, releaseNotes ?? {}]];

package/scripts/responsive-images.mjs

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+// Responsive image variants. Runs automatically before `npm run build` and `npm run dev`.
+//
+// For every image in public/images/uploads/ (imported, in their year/month
+// folders, and uploaded in the editor at /editor/) it writes smaller webp copies to public/images/_r/
+// (160, 480, 800 and 1200 px wide, only sizes smaller than the original) and records the
+// original dimensions in src/data/image-manifest.json. Templates (packages/editor/theme/components/Img.astro)
+// and Markdown content (rehype plugin in packages/editor/astro.mjs) use the manifest to add
+// srcset/sizes and width/height, so phones download a size that fits their screen.
+// It also writes a 1200 × 630 JPEG of each to public/images/_s/: the picture shown when a page is shared
+// on Facebook, LinkedIn, in a text message and the like (og:image, `shareImage` in packages/editor/site/images.mjs).
+// JPEG, because not every one of them shows webp, and cut to their wide format around what matters most.
+// Generated files are git-ignored and rebuilt only when missing or older than the source.
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import sharp from 'sharp';
+
+const ROOT = process.cwd();
+const IMAGES = path.join(ROOT, 'public/images');
+const SOURCES = [{ dir: 'uploads', out: 'uploads/' }];
+const OUT_DIR = path.join(ROOT, 'public/images/_r');
+const MANIFEST = path.join(ROOT, 'src/data/image-manifest.json');
+const WIDTHS = [160, 480, 800, 1200];
+const SHARE_DIR = path.join(ROOT, 'public/images/_s');
+const SHARE = { width: 1200, height: 630 };
+
+async function walk(dir) {
+  const entries = await fs.readdir(dir, { withFileTypes: true }).catch((e) => {
+    if (e.code === 'ENOENT') return [];
+    throw e;
+  });
+  const files = await Promise.all(entries.map((e) => (e.isDirectory() ? walk(path.join(dir, e.name)) : [path.join(dir, e.name)])));
+  return files.flat();
+}
+
+async function isFresh(out, srcMtime) {
+  try {
+    return (await fs.stat(out)).mtimeMs >= srcMtime;
+  } catch {
+    return false;
+  }
+}
+
+// The share picture: a square or upright picture keeps its upper part (20 % down, like the portrait on
+// the site, so a face stays in it), a wide one what sharp finds matters most.
+function shareCut(file, width, height) {
+  if (width / height >= 1.5) return sharp(file).resize({ ...SHARE, fit: 'cover', position: 'attention' });
+  const tall = Math.round((height * SHARE.width) / width);
+  const top = Math.round((tall - SHARE.height) * 0.2);
+  return sharp(file)
+    .resize({ width: SHARE.width, height: tall })
+    .extract({ left: 0, top, ...SHARE });
+}
+
+const isImage = (f) => /\.(webp|jpe?g|png)$/i.test(f);
+const files = [];
+for (const { dir, out } of SOURCES) {
+  const src = path.join(IMAGES, dir);
+  for (const file of (await walk(src)).filter(isImage)) {
+    const rel = path.relative(src, file).split(path.sep).join('/');
+    files.push({ file, url: `/images/${dir}/${rel}`, outBase: out + rel });
+  }
+}
+const manifest = {};
+let written = 0;
+
+for (const { file, url, outBase } of files) {
+  const { width, height } = await sharp(file).metadata();
+  if (!width || !height) continue;
+  const srcMtime = (await fs.stat(file)).mtimeMs;
+  const variants = [];
+  for (const w of WIDTHS.filter((w) => w < width)) {
+    const outRel = outBase.replace(/\.[a-z]+$/i, `-${w}.webp`);
+    const out = path.join(OUT_DIR, outRel);
+    if (!(await isFresh(out, srcMtime))) {
+      await fs.mkdir(path.dirname(out), { recursive: true });
+      await sharp(file).resize({ width: w }).webp({ quality: 78 }).toFile(out);
+      written++;
+    }
+    variants.push({ w, src: `/images/_r/${outRel}` });
+  }
+  const shareRel = outBase.replace(/\.[a-z]+$/i, '.jpg');
+  const shareOut = path.join(SHARE_DIR, shareRel);
+  if (!(await isFresh(shareOut, srcMtime))) {
+    await fs.mkdir(path.dirname(shareOut), { recursive: true });
+    await shareCut(file, width, height).flatten({ background: '#ffffff' }).jpeg({ quality: 80, mozjpeg: true }).toFile(shareOut);
+    written++;
+  }
+  manifest[url] = { width, height, variants, share: `/images/_s/${shareRel}` };
+}
+
+await fs.mkdir(path.dirname(MANIFEST), { recursive: true });
+await fs.writeFile(MANIFEST, JSON.stringify(manifest) + '\n');
+console.log(`responsive-images: ${files.length} images, ${written} variants written`);

package/scripts/scheduled-list.mjs

@@ -0,0 +1,15 @@
+// After the build: the pages and blog posts that are Planlagt, with their time, in dist/_scheduled.json, for the site's
+// Worker, which publishes each hour those whose time has come (packages/editor/worker/publish.js). Only the Worker reads it: on the
+// site the address gives nothing (packages/editor/worker/index.js).
+import { existsSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { KINDS, scheduleOf } from '../lib/scheduled.mjs';
+
+const ROOT = `${process.cwd()}/`;
+const list = [];
+for (const { dir } of KINDS.filter(({ dir }) => existsSync(join(ROOT, dir))))
+  for (const file of readdirSync(join(ROOT, dir), { recursive: true, encoding: 'utf8' }).filter((f) => f.endsWith('.md'))) {
+    const { status, publishAt } = scheduleOf(readFileSync(join(ROOT, dir, file), 'utf8'));
+    if (status === 'scheduled' && publishAt) list.push({ path: `${dir}/${file}`, publishAt });
+  }
+writeFileSync(join(ROOT, process.argv[2] ?? 'dist', '_scheduled.json'), `${JSON.stringify(list)}\n`);

package/scripts/theme-screenshots.mjs

@@ -0,0 +1,88 @@
+// Takes the pictures of the site in each theme installed (src/themes/), shown on the theme's page in the editor
+// ("Udseende" › "Temaer" › the theme, ThemePage in packages/editor/src/Library.tsx): the CMS's demo site (demo/, never the
+// site's own content) built with the theme (demo-site.mjs, in a folder of its own), opened on a phone, and the top of each
+// page in SHOTS taken, into the theme's screenshots/<n>-<key>.jpg (the standard theme's in this package's theme/, another's
+// in src/themes/<theme>/; packages/editor/src/themes.ts reads them; their names in the editor are t.library.themeShots[key]). Without
+// the cookie question and the pop-ups, which would cover the page. Run it again when a theme or the demo has changed much:
+// npx morpheme theme-screenshots (or with the themes to take, by folder: … saturn material).
+import { execFileSync } from 'node:child_process';
+import { createServer } from 'node:http';
+import { existsSync, mkdirSync, readFileSync, rmSync, statSync } from 'node:fs';
+import { extname, join } from 'node:path';
+import { chromium } from 'playwright';
+import { installedThemes, themeFolder } from '@morphemecms/cms/site/theme.mjs';
+import { binOf } from './bin.mjs';
+import { demoSite } from './demo-site.mjs';
+
+const ROOT = `${process.cwd()}/`;
+const themes = process.argv.length > 2 ? process.argv.slice(2) : installedThemes();
+const standardPages = JSON.parse(readFileSync(new URL('../demo/src/data/standard-pages.json', import.meta.url), 'utf8'));
+
+/** The pictures, in their order: the key (its name in the editor), the page and whether it is in dark mode. */
+const SHOTS = [
+  { key: 'front', path: '/' },
+  { key: 'front-dark', path: '/', dark: true },
+  { key: 'blog', path: '/blog/' },
+  { key: 'contact', path: standardPages.contact },
+];
+
+// The built site, as the host serves it: a folder is its index.html.
+const types = {
+  '.html': 'text/html',
+  '.js': 'text/javascript',
+  '.css': 'text/css',
+  '.svg': 'image/svg+xml',
+  '.json': 'application/json',
+  '.webp': 'image/webp',
+  '.jpg': 'image/jpeg',
+  '.png': 'image/png',
+  '.woff2': 'font/woff2',
+};
+function serve(dir) {
+  const server = createServer((req, res) => {
+    let path = join(dir, decodeURIComponent(new URL(req.url, 'http://x').pathname));
+    if (existsSync(path) && statSync(path).isDirectory()) path = join(path, 'index.html');
+    if (!existsSync(path)) return res.writeHead(404).end();
+    res.writeHead(200, { 'content-type': types[extname(path)] ?? 'application/octet-stream' }).end(readFileSync(path));
+  });
+  return new Promise((done) => server.listen(0, () => done(server)));
+}
+
+// CHROMIUM_PATH: another Chromium than Playwright's own (one installed for another version of Playwright).
+const browser = await chromium.launch({ executablePath: process.env.CHROMIUM_PATH || undefined });
+try {
+  for (const theme of themes) {
+    console.log(`\nTemaet ${theme}:`);
+    const demo = demoSite(theme);
+    const out = join(demo, 'dist');
+    try {
+      execFileSync(process.execPath, [binOf('astro'), 'build', '--outDir', out], { cwd: demo, stdio: 'inherit' });
+      const server = await serve(out);
+      const site = `http://localhost:${server.address().port}`;
+      const folder = join(ROOT, `${themeFolder(theme)}/screenshots`);
+      rmSync(folder, { recursive: true, force: true });
+      mkdirSync(folder, { recursive: true });
+      for (const [i, shot] of SHOTS.entries()) {
+        const page = await browser.newPage({
+          viewport: { width: 390, height: 520 },
+          deviceScaleFactor: 2,
+          // The demo's language (its src/site/config.ts).
+          locale: 'en-US',
+          colorScheme: shot.dark ? 'dark' : 'light',
+        });
+        await page.goto(`${site}${shot.path}`, { waitUntil: 'networkidle' });
+        await page.addStyleTag({ content: '#cookie-consent, dialog[data-popup] { display: none !important; }' });
+        await page.evaluate(() => document.fonts.ready);
+        await page.waitForTimeout(800);
+        await page.screenshot({ path: join(folder, `${i + 1}-${shot.key}.jpg`), type: 'jpeg', quality: 80 });
+        await page.close();
+      }
+      server.close();
+      console.log(`${SHOTS.length} billeder i ${themeFolder(theme)}/screenshots/.`);
+    } finally {
+      rmSync(demo, { recursive: true, force: true });
+    }
+  }
+} finally {
+  await browser.close();
+}

package/scripts/types.mjs

@@ -0,0 +1,21 @@
+// The types of this package's JavaScript modules, for a site that has it from npm (tsconfig.types.json): `write` before
+// it is packed (prepack), `clean` after (postpack), so they are never left beside the code they were made from.
+import { execFileSync } from 'node:child_process';
+import { readdirSync, rmSync } from 'node:fs';
+import { join, relative, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { binOf } from './bin.mjs';
+
+const PACKAGE = fileURLToPath(new URL('..', import.meta.url));
+
+const declarations = () =>
+  readdirSync(PACKAGE, { recursive: true, withFileTypes: true })
+    .filter((e) => e.isFile() && e.name.endsWith('.d.mts') && !relative(PACKAGE, e.parentPath).split(sep).includes('node_modules'))
+    .map((e) => join(e.parentPath, e.name));
+
+for (const file of declarations()) rmSync(file);
+if (process.argv[2] === 'write')
+  execFileSync(process.execPath, [binOf('typescript', 'tsc', PACKAGE), '-p', join(PACKAGE, 'tsconfig.types.json')], {
+    cwd: PACKAGE,
+    stdio: 'inherit',
+  });

package/scripts/video-thumbnails.mjs

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+// A still from each video from YouTube and Vimeo on the site, shown behind its play button
+// (packages/editor/lib/video.mjs). Runs before `npm run build` and `npm run dev`, after
+// packages/editor/scripts/responsive-images.mjs.
+//
+// The videos are found in the texts (src/content/) and the data files (src/data/): the video blocks
+// and the code from YouTube and Vimeo to embed them (videoOf, packages/editor/lib/video-id.mjs). For a
+// video from YouTube, its largest still is fetched (maxresdefault, else sddefault or hqdefault, which
+// have black bars above and below); for one from Vimeo, the still Vimeo gives for it. Each is cut to
+// 16:9 and written as webp to public/images/_video/<site>-<id>-480.webp and -960.webp, so a visitor
+// gets it from the site and nothing from Google or Vimeo until the video is played.
+// A video whose still cannot be fetched (no network, a removed video) keeps the plain box. Generated
+// files are git-ignored and fetched once (kept while they exist).
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import sharp from 'sharp';
+import { stillName, videoOf, vimeoInfo } from '../lib/video-id.mjs';
+
+const ROOT = process.cwd();
+const OUT = path.join(ROOT, 'public/images/_video');
+const WIDTHS = [480, 960];
+const LINK = /(?:https?:)?(?:\/\/)?(?:[\w-]+\.)*(?:youtube(?:-nocookie)?\.com|youtu\.be|vimeo\.com)\/[^\s"'<>()[\]\\]*/gi;
+
+async function walk(dir) {
+  const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
+  const files = await Promise.all(entries.map((e) => (e.isDirectory() ? walk(path.join(dir, e.name)) : [path.join(dir, e.name)])));
+  return files.flat();
+}
+
+const texts = [...(await walk(path.join(ROOT, 'src/content'))), ...(await walk(path.join(ROOT, 'src/data')))].filter((f) =>
+  /\.(md|json)$/.test(f),
+);
+const videos = new Map();
+for (const file of texts)
+  for (const [link] of (await fs.readFile(file, 'utf8')).replaceAll('&quot;', '"').replaceAll('&amp;', '&').matchAll(LINK)) {
+    const video = videoOf(link);
+    if (video) videos.set(stillName(video), video);
+  }
+
+const download = async (url) => {
+  try {
+    const res = await fetch(url, { signal: AbortSignal.timeout(10_000) });
+    return res.ok ? res : null;
+  } catch {
+    return null;
+  }
+};
+
+async function still(video) {
+  if (video.site === 'vimeo') {
+    const url = (await (await download(vimeoInfo(video, 1280)))?.json().catch(() => null))?.thumbnail_url;
+    const res = url && (await download(url));
+    return res ? Buffer.from(await res.arrayBuffer()) : null;
+  }
+  for (const size of ['maxresdefault', 'sddefault', 'hqdefault']) {
+    const res = await download(`https://i.ytimg.com/vi/${video.id}/${size}.jpg`);
+    if (res) return Buffer.from(await res.arrayBuffer());
+  }
+  return null;
+}
+
+await fs.mkdir(OUT, { recursive: true });
+let written = 0;
+let missing = 0;
+for (const [name, video] of videos) {
+  const outs = WIDTHS.map((w) => path.join(OUT, `${name}-${w}.webp`));
+  const have = await Promise.all(
+    outs.map((o) =>
+      fs.stat(o).then(
+        () => true,
+        () => false,
+      ),
+    ),
+  );
+  if (have.every(Boolean)) continue;
+  const image = await still(video);
+  if (!image) {
+    missing++;
+    continue;
+  }
+  for (const [i, w] of WIDTHS.entries())
+    // cover: the 4:3 stills lose their black bars, which are exactly the parts outside 16:9.
+    await sharp(image)
+      .resize(w, Math.round((w * 9) / 16), { fit: 'cover' })
+      .webp({ quality: 78 })
+      .toFile(outs[i]);
+  written++;
+}
+console.log(`video-thumbnails: ${videos.size} videos, ${written} stills fetched${missing ? `, ${missing} could not be fetched` : ''}`);

package/scripts/worker-modules.mjs

@@ -0,0 +1,34 @@
+// The site's Worker's modules (packages/editor/worker/) for the checks, built as wrangler builds them: with the
+// aliases in wrangler.jsonc (`@site/config`, `@site/worker`), in one bundle, so they share what they keep, as in the
+// Worker. Used by packages/editor/scripts/check-worker.mjs and packages/editor/scripts/check-consent.mjs.
+import { mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { build } from 'esbuild';
+
+const ROOT = `${process.cwd()}/`;
+
+/** The modules named (files in packages/editor/worker/), in that order. @param {...string} names */
+export async function workerModules(...names) {
+  const { experimental_readRawConfig } = await import('wrangler');
+  const { alias = {} } = experimental_readRawConfig({ config: join(ROOT, 'wrangler.jsonc') }).rawConfig;
+  const outfile = join(mkdtempSync(join(tmpdir(), 'worker-modules-')), 'worker.mjs');
+  await build({
+    stdin: {
+      contents: names
+        .map((name, i) => `export * as m${i} from ${JSON.stringify(fileURLToPath(new URL(`../worker/${name}`, import.meta.url)))};`)
+        .join('\n'),
+      resolveDir: ROOT,
+      loader: 'js',
+    },
+    bundle: true,
+    format: 'esm',
+    platform: 'node',
+    outfile,
+    alias: Object.fromEntries(Object.entries(alias).map(([from, to]) => [from, join(ROOT, to)])),
+    logLevel: 'silent',
+  });
+  const bundle = await import(pathToFileURL(outfile).href);
+  return names.map((_, i) => bundle[`m${i}`]);
+}

package/site/appCookies.d.mts

@@ -0,0 +1,9 @@
+/** What is wrong with a list of cookies written in a file (an app's cookies.json), each as a sentence.
+ * @param {unknown} list @param {string} file */
+export function cookieProblems(list: unknown, file: string): string[];
+/** The cookies of each app (installed or not) in the repository at `root`, by the app's id. */
+export function appCookies(root: any): {
+    [k: string]: any[];
+};
+/** What is wrong with the apps' cookies.json (npm run check:content). */
+export function appCookieProblems(root?: import("url").URL): string[];

package/site/appCookies.mjs

@@ -0,0 +1,74 @@
+// The cookies the apps set (src/apps/<app>/cookies.json): each app names those it sets, with who sets them, what for,
+// how long they last and their category (@morphemecms/cms/lib/cookieCategories.mjs: 'necessary', set also without a yes in
+// the cookie banner, or 'preferences', 'statistics', 'marketing' or 'targeting', only after a yes to it), in the site's language, as its csp.json names what it loads; one without a name (those a service decides itself) is
+// only a line on the app's page in the editor (`cookieList` in its index.ts, AppCookie in packages/editor/src/store.ts).
+// Those with a name are added to the site's cookie list ("Lister" › "Cookies", which the standard block "Cookieliste"
+// shows) when the app is installed, and taken out when it is uninstalled (packages/editor/src/cookieList.ts). Read by
+// the app Cookiescanner's step after the build (build.mjs, what it knows of a cookie) and by npm run check:content
+// (appCookieProblems), so no TypeScript here.
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { pathToFileURL } from 'node:url';
+import { COOKIE_CATEGORIES, isCookieCategory } from '../lib/cookieCategories.mjs';
+
+const TEXTS = ['name', 'provider', 'purpose', 'lasts'];
+
+/** What is wrong with a list of cookies written in a file (an app's cookies.json), each as a sentence.
+ * @param {unknown} list @param {string} file */
+export function cookieProblems(list, file) {
+  if (!Array.isArray(list)) return [`${file}: skal være en liste med en cookie for hver.`];
+  return list.flatMap((c, i) => {
+    const at = `${file}: cookie ${i + 1}`;
+    if (!c || typeof c !== 'object' || Array.isArray(c)) return [`${at} skal være et objekt.`];
+    return [
+      ...Object.keys(c)
+        .filter((k) => !TEXTS.includes(k) && k !== 'category')
+        .map((k) => `${at} har feltet ${k}, som ikke findes (${[...TEXTS, 'category'].join(', ')}).`),
+      ...TEXTS.filter((k) => k in c && typeof c[k] !== 'string').map((k) => `${at}: ${k} skal være en tekst.`),
+      ...(String(c.purpose ?? '').trim() ? [] : [`${at} mangler purpose.`]),
+      // Without a name, only a line on the app's page; with one, a cookie in the cookie list.
+      ...(c.name === undefined
+        ? []
+        : [
+            ...(String(c.name).trim() ? [] : [`${at}: name er tom.`]),
+            ...(String(c.provider ?? '').trim() ? [] : [`${at} mangler provider.`]),
+            ...(isCookieCategory(c.category) ? [] : [`${at}: category skal være ${COOKIE_CATEGORIES.join(', ')}.`]),
+          ]),
+    ];
+  });
+}
+
+const read = (file) => JSON.parse(readFileSync(file, 'utf8'));
+
+/** The cookies of each app (installed or not) in the repository at `root`, by the app's id. */
+export function appCookies(root) {
+  const apps = new URL('src/apps/', root);
+  if (!existsSync(apps)) return {};
+  return Object.fromEntries(
+    readdirSync(apps, { withFileTypes: true })
+      .filter((d) => d.isDirectory() && existsSync(new URL(`${d.name}/cookies.json`, apps)))
+      .map((d) => {
+        try {
+          const list = read(new URL(`${d.name}/cookies.json`, apps));
+          return [d.name, Array.isArray(list) ? list : []];
+        } catch {
+          return [d.name, []];
+        }
+      }),
+  );
+}
+
+/** What is wrong with the apps' cookies.json (npm run check:content). */
+export function appCookieProblems(root = pathToFileURL(`${process.cwd()}/`)) {
+  const apps = new URL('src/apps/', root);
+  if (!existsSync(apps)) return [];
+  return readdirSync(apps, { withFileTypes: true })
+    .filter((d) => d.isDirectory() && existsSync(new URL(`${d.name}/cookies.json`, apps)))
+    .flatMap(({ name }) => {
+      const file = `src/apps/${name}/cookies.json`;
+      try {
+        return cookieProblems(read(new URL(`${name}/cookies.json`, apps)), file);
+      } catch {
+        return [`${file}: er ikke JSON.`];
+      }
+    });
+}

package/site/apps.ts

@@ -0,0 +1,21 @@
+// The apps on the site (src/apps/<app>/, packages/editor/src/apps.ts): which are installed under
+// "Indstillinger" › "Apps" in the editor (apps.json), and each app's settings (apps/<app>.json), as the
+// site's build reads them. What an app puts on every page (AppSlot.astro) is there only while it is
+// installed; what was made with it (a pop-up, a block on a page) stays when it is uninstalled.
+import data from '@data/apps.json';
+
+/** The ids of the apps installed. */
+export const installed: string[] = Array.isArray(data.installed) ? data.installed.map(String) : [];
+
+// Each app's saved settings, by its id (the file's name).
+const saved = Object.fromEntries(
+  Object.entries(import.meta.glob<Record<string, unknown>>('@data/apps/*.json', { eager: true, import: 'default' })).map(
+    ([file, values]) => [file.replace(/^.*\/|\.json$/g, ''), values],
+  ),
+);
+
+/** An app's settings as saved in the editor, over those it starts with (its settings.ts `values`). */
+export const settingsOf = (id: string, values: Record<string, unknown> = {}): Record<string, any> => ({
+  ...values,
+  ...saved[id],
+});

package/site/autolinks.d.mts

@@ -0,0 +1,11 @@
+/** { enabled, maxPerPage, words: Map<lowercase word, href>, pattern } */
+export function loadLinks(): any;
+/** 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(): string;
+/** Rehype plugin; `digest` (linksDigest) is not used here. */
+export function rehypeAutoLinks(): (tree: any, file: any) => void;
+/** For the migration: turn links whose text is one of the words back into plain text. */
+export function unlinkAutoWords(markdown: any): any;