@morphemecms/cms 0.0.0-stage → 0.1.0

package/src/check.ts

@@ -0,0 +1,285 @@
+// The rules a value must keep to before it is saved, from its fields (collections.ts): what must be
+// filled in, the form of a text (a pattern, an address, a number in pairs), the kind of each value
+// and that a choice is one of the options. The editor checks with them before it saves (fields.tsx
+// and the forms), and the site before it is built (packages/editor/scripts/check-content.mjs), so what the editor
+// would not save does not reach the site either. Also how a value is saved (clean) and a new one
+// (newValue). No React here, so the build can use it.
+import type { Field, Template } from './schema';
+import { addressOf } from './addresses';
+import { codeAt, regionOf } from './countries';
+import { blocksIn } from '../lib/blocks.mjs';
+import { t } from './i18n';
+
+type Item = Record<string, unknown>;
+
+/** The fields and value an object's fields are in: an item of a list is in the object with the list
+ * (a block's cards in the block), which may be in another. */
+export type Around = { fields: Field[]; value: Record<string, unknown> | undefined; around?: Around };
+
+/** Whether a field is in use: always, or (Field.only) while the field it depends on has one of the
+ * values (its default when it has none yet) and is in use itself (a pop-up's delay, by when it opens,
+ * which a kind without it does not have). That field is next to it or, for a field of an item in a
+ * list, next to the list (`around`): a card's icon by the block's design. */
+export function inUse(field: Field, fields: Field[], value: Record<string, unknown> | undefined, around?: Around): boolean {
+  if (!field.only) return true;
+  const name = field.only.field;
+  let at: Around = { fields, value, around };
+  while (at.around && !at.fields.some((f) => f.name === name)) at = at.around;
+  const by = at.fields.find((f) => f.name === name);
+  return (
+    field.only.is.includes(String(at.value?.[name] ?? by?.default ?? '')) &&
+    (!by || by === field || inUse(by, at.fields, at.value, at.around))
+  );
+}
+
+// The block an item of a list of blocks is (undefined for a type the editor does not know).
+const blockOf = (field: Field, item: unknown) => field.blocks!.find((b) => b.type === (item as Item)?.type);
+
+// The kind of value a field holds, and what is said when it holds another (a file edited by hand).
+const kindOf = (f: Field) =>
+  f.type === 'list' || f.type === 'blocks' || f.multiple
+    ? 'list'
+    : f.type === 'object'
+      ? 'object'
+      : f.type === 'number'
+        ? 'number'
+        : f.type === 'boolean'
+          ? 'boolean'
+          : 'text';
+function ofItsKind(f: Field, v: unknown): boolean {
+  // Only shown, never edited here: whatever the file has.
+  if (f.type === 'readonly') return true;
+  switch (kindOf(f)) {
+    case 'list':
+      return Array.isArray(v);
+    case 'object':
+      return typeof v === 'object' && v !== null && !Array.isArray(v);
+    case 'number':
+      return typeof v === 'number' && Number.isFinite(v);
+    case 'boolean':
+      return typeof v === 'boolean';
+    default:
+      return typeof v === 'string';
+  }
+}
+
+// A new, empty item of a list.
+export const newItem = (field: Field) => (field.field ? '' : newValue(field.fields!));
+
+/** A saved value with the defaults of the fields it has no value for (a field added after it was
+ * saved, the pop-up's "Rullet ned"), after its own values. */
+export const withDefaults = (fields: Field[], value: Record<string, unknown>): Record<string, unknown> => ({
+  ...value,
+  ...Object.fromEntries(fields.filter((f) => f.default !== undefined && value?.[f.name] === undefined).map((f) => [f.name, f.default])),
+});
+
+/** A saved entry in a form: its own values, and for a field it has none for, what that means (Field.missing), else
+ * its value in a new entry (newValue). */
+export const savedValue = (fields: Field[], value: Record<string, unknown>): Record<string, unknown> => ({
+  ...newValue(fields),
+  ...Object.fromEntries(fields.filter((f) => f.missing !== undefined).map((f) => [f.name, f.missing])),
+  ...value,
+});
+
+// An empty entry for a list of objects or a new file: the fields' defaults, lists empty.
+export function newValue(fields: Field[]): Record<string, unknown> {
+  return Object.fromEntries(
+    fields.map((f) => [
+      f.name,
+      f.default ??
+        (f.type === 'list' || f.type === 'blocks' || f.multiple
+          ? []
+          : f.type === 'object'
+            ? newValue(f.fields!)
+            : f.type === 'boolean'
+              ? false
+              : ''),
+    ]),
+  );
+}
+
+// A number typed with or without spaces (or dots, dashes, the site's own country code before a phone
+// number) as its digits in pairs, "30 64 16 12"; a text that is not only digits as it was typed.
+// abroad: a phone number with another country code, which is not counted or taken off.
+function digitsOf(field: Field, text: string, abroad = false) {
+  let digits = text.replace(/[\s.\-()]/g, '').replace(/^\+/, '');
+  const own = !abroad && field.phone?.slice(1);
+  if (own && typeof field.digitsInPairs === 'number' && digits.length === field.digitsInPairs + own.length && digits.startsWith(own))
+    digits = digits.slice(own.length);
+  return digits;
+}
+function pairsOf(field: Field, text: string) {
+  const digits = digitsOf(field, text);
+  return /^\d+$/.test(digits) ? digits.match(/\d{1,2}/g)!.join(' ') : text;
+}
+
+/** A phone number's country code and the number after it (Field.phone): one without a code, or with
+ * the site's own, is in the site's own country; one typed with another (+46 or 0046, with a space
+ * after it or not) has it taken off. */
+export function phoneParts(field: Field, text: string): [code: string, number: string] {
+  const typed = text.trim();
+  const m = typed.match(/^(?:\+|00)(\d*)(.*)$/s);
+  if (!m) return [field.phone!, typed];
+  // Written "+46 70 12 34 56", the code is the digits before the space; together, the longest that is one.
+  const whole = regionOf(`+${m[1]}`) ? `+${m[1]}` : undefined;
+  const code = (m[2] && whole) || codeAt(m[1]) || whole;
+  if (!code) return [field.phone!, typed];
+  return [code, `${m[1].slice(code.length - 1)}${m[2]}`.trim()];
+}
+
+/** A phone number as it is saved: with the site's own country code, the number alone; with another,
+ * the code before it. A number typed with a code keeps that one. */
+export function phoneText(field: Field, code: string, number: string) {
+  const typed = number.trim();
+  return !typed || /^(\+|00)/.test(typed) || code === field.phone ? number : `${code} ${number}`;
+}
+
+// A phone number in another country is written as it was typed (its groups differ from country to
+// country), only with one space between them.
+export function inPairs(field: Field, text: string) {
+  if (!field.phone) return pairsOf(field, text);
+  const [code, number] = phoneParts(field, text);
+  return phoneText(field, code, code === field.phone ? pairsOf(field, number) : number.replace(/\s+/g, ' '));
+}
+
+// What is wrong with a text that must have a form (a pattern, a number in pairs), or null.
+export function problemOf(field: Field, typed: string): string | null {
+  const text = typed.trim();
+  if (!text) return null;
+  if (field.pattern && !new RegExp(field.pattern[0]).test(text)) return field.pattern[1];
+  if (field.address && !addressOf(text, field.address)) return t.check.address;
+  if (field.digitsInPairs) {
+    // A phone number in another country: only digits, however many it has there.
+    const [code, number] = field.phone ? phoneParts(field, text) : [field.phone, text];
+    const abroad = code !== field.phone;
+    const digits = digitsOf(field, number, abroad);
+    if (!/^\d+$/.test(digits)) return t.check.onlyDigits;
+    if (typeof field.digitsInPairs === 'number' && !abroad && digits.length !== field.digitsInPairs)
+      return t.check.digits(field.digitsInPairs);
+  }
+  return null;
+}
+
+/** The first problem with a value: the message for the person editing, and the field it is about, as
+ * the names and item numbers to it joined with dots ("items.0.title"), so it can be shown there. */
+export type Problem = { text: string; path: string };
+
+// The first problem with a value, as a message for the person editing, or null.
+export function check(fields: Field[], value: Record<string, unknown>, where = '', around?: Around): string | null {
+  return problemAt(fields, value, where, around)?.text ?? null;
+}
+
+/** As check, with the field the problem is about (Problem). */
+export function problemAt(fields: Field[], value: Record<string, unknown>, where = '', around?: Around, at = ''): Problem | null {
+  const here: Around = { fields, value, around };
+  for (const f of fields) {
+    if (!inUse(f, fields, value, around)) continue;
+    const v = value?.[f.name];
+    const label = where ? `${where} › ${f.label}` : f.label;
+    const path = at ? `${at}.${f.name}` : f.name;
+    const empty = v == null || v === '' || (Array.isArray(v) && v.length === 0);
+    const wrong = (text: string) => ({ text, path });
+    if (f.required && empty) return wrong(t.check.fillIn(label));
+    if (!empty && !ofItsKind(f, v)) return wrong(t.check.wrong(label, t.check.kinds[kindOf(f)]));
+    if (f.type === 'select' && f.options && !empty && !f.options.some((o) => o.value === v))
+      return wrong(t.check.notAnOption(label, String(v)));
+    const form = typeof v === 'string' && problemOf(f, v);
+    if (form) return wrong(t.check.wrong(label, form));
+    if (f.type === 'markdown' && f.template && typeof v === 'string') {
+      const [rule] = textProblems(f.template, v);
+      if (rule) return wrong(t.check.inField(label, rule));
+    }
+    if (f.type === 'object') {
+      const problem = problemAt(f.fields!, v as Record<string, unknown>, label, here, path);
+      if (problem) return problem;
+    }
+    if (f.type === 'blocks' && Array.isArray(v) && f.template) {
+      const name = (type: string) => f.blocks!.find((b) => b.type === type)?.label ?? type;
+      const [rule] = templateProblems(f.template, v as Item[], name);
+      if (rule) return wrong(t.check.inField(label, rule));
+    }
+    if (f.type === 'blocks' && Array.isArray(v)) {
+      // Hidden blocks are not on the site, so they may be unfinished.
+      for (const [i, item] of (v as Item[]).entries()) {
+        const block = blockOf(f, item);
+        if (item.hidden || !block) continue;
+        const problem = problemAt(block.fields, item, `${label} › ${block.label}`, undefined, `${path}.${i}`);
+        if (problem) return problem;
+      }
+    }
+    if (f.type === 'list' && Array.isArray(v)) {
+      if (f.maxItems !== undefined && v.length > f.maxItems) return wrong(t.check.atMostItems(label, f.maxItems));
+      for (const [i, item] of v.entries()) {
+        const named = `${label} ${i + 1}`;
+        const problem = f.field
+          ? problemAt([f.field], { [f.field.name]: item }, named, here, `${path}.${i}`)
+          : problemAt(f.fields!, item as Record<string, unknown>, named, here, `${path}.${i}`);
+        if (problem) return problem;
+      }
+    }
+  }
+  return null;
+}
+
+// The value as it is saved: optional fields left empty (text, number, list) are left out, as in the
+// existing files (their readers treat a missing field as empty). Keys keep their order.
+export function clean(fields: Field[], value: Record<string, unknown>, around?: Around): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  const here: Around = { fields, value, around };
+  for (const [key, v] of Object.entries(value)) {
+    const f = fields.find((x) => x.name === key);
+    const empty = v == null || v === '' || (Array.isArray(v) && v.length === 0);
+    if (f && ((!f.required && empty) || !inUse(f, fields, value, around))) continue;
+    if (f?.digitsInPairs && typeof v === 'string') out[key] = inPairs(f, v);
+    else if (f?.pattern && typeof v === 'string') out[key] = v.trim();
+    else if (f?.type === 'object') out[key] = clean(f.fields!, v as Record<string, unknown>, here);
+    else if (f?.type === 'list' && f.fields) out[key] = (v as Record<string, unknown>[]).map((item) => clean(f.fields!, item, here));
+    // A block keeps its type first and `hidden` last, and only when it is hidden.
+    else if (f?.type === 'blocks')
+      out[key] = (v as Item[]).map(({ type, hidden, ...item }) => ({
+        type,
+        ...clean(blockOf(f, { type })?.fields ?? [], item),
+        ...(hidden ? { hidden: true } : {}),
+      }));
+    else out[key] = v;
+  }
+  return out;
+}
+
+// A picture in Markdown (MarkdownEditor.tsx puts them in).
+const PICTURES = /!\[(?:\\.|[^\]])*\]\([^)\s]+/g;
+
+// A block's name by its type: a standard block's (the editor's texts), a picture's, else its type.
+const nameOf = (type: string) =>
+  type === 'image' ? t.blocks.picture.label : ((t.blocks as unknown as Record<string, { label?: string }>)[type]?.label ?? type);
+
+/** What is wrong with the blocks and pictures in the text of a markdown field by its template (Field.template): one
+ * that cannot be there, and too many of a type ('image': the pictures). */
+export function textProblems(template: Template, markdown: string): string[] {
+  const types = [...blocksIn(markdown).map((b) => b.type), ...[...markdown.matchAll(PICTURES)].map(() => 'image')];
+  const problems: string[] = [];
+  for (const type of new Set(types)) {
+    if (template.blocks && !template.blocks.includes(type)) problems.push(t.check.cannotBeInText(nameOf(type)));
+    const max = template.max?.[type];
+    if (max !== undefined && types.filter((x) => x === type).length > max) problems.push(t.check.atMostInText(nameOf(type), max));
+  }
+  return problems;
+}
+
+/** What is wrong with the blocks of a text by its template (collections.ts): one that cannot be there,
+ * too many of a type, and one that must be on the page (required, locked) but is not, or is hidden.
+ * blocks: all of them in order, hidden ones too ({ type, hidden }); name: a type's name. */
+export function templateProblems(template: Template, blocks: Item[], name: (type: string) => string): string[] {
+  const problems: string[] = [];
+  const count = (type: string, shown = false) => blocks.filter((b) => b.type === type && !(shown && b.hidden)).length;
+  for (const type of new Set(blocks.map((b) => String(b.type)))) {
+    if (template.blocks && !template.blocks.includes(type)) problems.push(t.check.cannotBeHere(name(type)));
+    const max = template.max?.[type];
+    if (max !== undefined && count(type) > max) problems.push(t.check.atMost(name(type), max));
+  }
+  for (const type of [...(template.required ?? []), ...(template.locked ?? [])]) {
+    if (!count(type)) problems.push(t.check.mustBeOnPage(name(type)));
+    else if (!count(type, true)) problems.push(t.check.mustBeShown(name(type)));
+  }
+  return [...new Set(problems)];
+}

package/src/checkSite.ts

@@ -0,0 +1,256 @@
+// Everything the editor writes, checked by the editor's own rules (check.ts) before the site is built
+// (packages/editor/scripts/check-content.mjs): every block in the text of the pages and posts (src/apps/<app>/blocks/, an unknown
+// one too), and the data files with the fields the editor edits them with: the fixed pages with their
+// sections, the menu and the other single files, the lists (prices, testimonials, tags), the
+// screens under "Virksomheden" and "Blokke", the apps installed and their settings (src/apps/), and the
+// colours ("Farver": colours, readable together). A hidden block is not on the site, so it may be unfinished.
+// The rules of a page's template (collections.ts) too: what may be there, how many, and what must.
+// The redirects (redirects.ts): none sends on through another, and none in a loop. And the site's own rules
+// (siteProblems in its rules.ts: a button that opens a promotion not on its page).
+// And the site's texts the editor has no translation of (untranslated).
+import { check } from './check';
+import {
+  appearance,
+  blockParts,
+  collections,
+  colorFields,
+  colorPairs,
+  colorRoles,
+  companyParts,
+  config,
+  frontLeads,
+  groups,
+  partScreens,
+  seoParts,
+  siteProblems,
+} from '@site/editor';
+import { colorProblems, lowContrast, MODES } from '../lib/colors';
+import { completeColors, dynamicProblems } from '../lib/dynamic-colors';
+import { APP_HOOKS, hooksOf } from '../lib/hooks';
+import { texts } from '@site/texts';
+import { texts as standardTexts } from '../defaults/texts';
+import type { Part } from './schema';
+import { apps, asStandardTemplate, blockProblems, siteBlocks, standardPageOf, withPageBlocks } from './registry';
+import { installedApps, settingsFile } from './apps';
+import { appFolder, SCREENSHOTS, shotFile, shotOf } from './store';
+import { appFolders } from './appFiles';
+import { colorPairs as shownPairs, sharedParts, translator, writtenApps, writtenBlockParts, writtenCollections } from './site';
+import { splitBlocks } from '../lib/blocks.mjs';
+import { appTexts, DEFAULTS_LOCALE, locales, siteLocale, t, type Texts } from './i18n';
+import { flatten, readAll, REDIRECT_FILES, type AllRedirects } from './redirects';
+
+const ratio = (n: number) => n.toLocaleString(config.locale, { maximumFractionDigits: 1 });
+
+export type SiteFile = { path: string; text: string };
+
+/** What is wrong, a line for each file or block ('src/content/pages/x.md: Udfyld "Pris › Pris".'), and
+ * how many files and blocks were checked. */
+export function problemsOf(files: SiteFile[]): { problems: string[]; files: number; blocks: number } {
+  const problems: string[] = [];
+  const byPath = new Map(files.map((f) => [f.path, f]));
+  const checked = new Set<string>();
+  let blocks = 0;
+
+  // A data file by the fields it is edited with (at the top or under `at`, over the values it starts
+  // with; a file that is only a list under `root`).
+  const data = (
+    path: string,
+    fields: Parameters<typeof check>[0],
+    at?: string,
+    root?: string,
+    defaults?: Record<string, unknown>,
+    values?: Record<string, unknown>,
+    // An entry of a list as the list has it now (FolderCollection.upgrade: a contact bar is an action bar).
+    upgrade?: (value: Record<string, unknown>) => Record<string, unknown>,
+  ) => {
+    const file = byPath.get(path);
+    if (!file) return;
+    checked.add(path);
+    let value: unknown;
+    try {
+      value = JSON.parse(file.text);
+    } catch {
+      return problems.push(`${path}: ${t.app.invalidJson}`);
+    }
+    if (root) value = { [root]: value };
+    else if (at) value = { ...defaults, ...((value as Record<string, unknown>)[at] ?? {}) };
+    else if (values) value = { ...values, ...(value as Record<string, unknown>) };
+    if (upgrade) value = upgrade(value as Record<string, unknown>);
+    const problem = check(fields, value as Record<string, unknown>);
+    if (problem) problems.push(`${path}: ${problem}`);
+  };
+
+  // With the kinds the apps add to them (a Mailchimp pop-up).
+  for (const c of writtenCollections) {
+    if (c.kind === 'files')
+      for (const f of c.files)
+        data(f.file, f.root ? [...f.fields, f.root] : withPageBlocks(f.fields), undefined, f.fields.length ? undefined : f.root?.name);
+    if (c.kind === 'folder')
+      for (const f of files)
+        if (f.path.startsWith(`${c.folder}/`) && f.path.endsWith('.json'))
+          data(f.path, c.fields, undefined, undefined, undefined, undefined, c.upgrade && ((v) => c.upgrade!(v, files)));
+  }
+  for (const part of [
+    ...companyParts.flatMap((p) => [p, ...(p.parts ?? [])]),
+    ...partScreens.flatMap((s) => s.parts),
+    ...appearance,
+    ...seoParts,
+    ...writtenBlockParts,
+  ] as Part[])
+    if (part.file && part.fields) data(part.file, part.fields, part.at, undefined, part.defaults);
+  // The blocks turned off under "Blokindstillinger" (BlockSettings.tsx): a list of their types.
+  data(config.blockSettings, [
+    { name: 'off', label: t.app.blocksOff, type: 'list', field: { name: 'type', label: t.app.block, type: 'string' } },
+  ]);
+  // The apps installed under "Apps" (AppList.tsx): a list of their ids, and each app's settings.
+  data(config.apps.installed, [
+    { name: 'installed', label: t.app.appsInstalled, type: 'list', field: { name: 'id', label: t.app.app, type: 'string' } },
+  ]);
+  for (const app of apps)
+    if (app.settings) data(settingsFile(app.id), app.settings.fields, undefined, undefined, undefined, app.settings.values);
+  // Each app installed is in the site: one from the app store is copied into it when it is installed (store.ts).
+  for (const id of installedApps(files))
+    if (!apps.some((a) => a.id === id)) problems.push(`${config.apps.installed}: ${t.apps.missing(id, appFolder(id))}`);
+  // Each file in an app's hooks/ is a place an app may change the site (@morphemecms/cms/lib/hooks.ts).
+  for (const app of writtenApps)
+    for (const file of hooksOf(appFolders[app.id]?.files ?? []).unknown)
+      problems.push(`${appFolder(app.id)}/${file}: ${t.apps.unknownHook(APP_HOOKS.map((h) => `hooks/${h}.ts`).join(', '))}`);
+  // Each picture of an app shows something it has (shotOf) and is in its screenshots/, and each file there is one of them.
+  for (const app of writtenApps) {
+    const blocks = siteBlocks.filter((b) => b.app === app.id).map((b) => b.type);
+    const files = (appFolders[app.id]?.files ?? []).filter((f) => f.startsWith(`${SCREENSHOTS}/`));
+    const listed = (app.screenshots ?? []).map((x, i) => `${SCREENSHOTS}/${shotFile(i, x.shows)}`);
+    for (const x of app.screenshots ?? [])
+      if (!shotOf(x.shows, app, blocks)) problems.push(`${appFolder(app.id)}/index.ts: ${t.apps.unknownScreenshot(x.shows)}`);
+    for (const file of listed.filter((f) => !files.includes(f)))
+      problems.push(`${appFolder(app.id)}/index.ts: ${t.apps.noScreenshot(file)}`);
+    for (const file of files.filter((f) => !listed.includes(f)))
+      problems.push(`${appFolder(app.id)}/${file}: ${t.apps.unlistedScreenshot}`);
+  }
+
+  // The colours under "Farver" (Colors.tsx): every colour in both modes (those a file written before them does not have
+  // made, completeColors), readable together, the choice of dynamic colour they were made from, if they were.
+  const colorsFile = byPath.get(config.colors);
+  if (colorsFile) {
+    checked.add(colorsFile.path);
+    try {
+      const colors = completeColors(JSON.parse(colorsFile.text), colorRoles);
+      const bad = colorProblems(
+        colors,
+        colorFields.map((f) => f.name),
+      );
+      for (const where of bad) problems.push(`${colorsFile.path}: ${t.colors.notAColorAt(where)}`);
+      if (colors.dynamic !== undefined)
+        for (const where of dynamicProblems(colors.dynamic)) problems.push(`${colorsFile.path}: ${t.colors.dynamic.wrongAt(where)}`);
+      if (!bad.length)
+        for (const mode of MODES)
+          for (const pair of lowContrast(colors[mode], shownPairs))
+            problems.push(`${colorsFile.path}: ${t.colors[mode]}: ${t.colors.tooLow(pair.what, ratio(pair.ratio), ratio(pair.min))}`);
+    } catch {
+      problems.push(`${colorsFile.path}: ${t.app.invalidJson}`);
+    }
+  }
+
+  // The redirects in their three files: each straight to where it ends (flatten changes nothing).
+  const redirectFiles = files.filter((f) => REDIRECT_FILES.includes(f.path));
+  if (redirectFiles.length) {
+    redirectFiles.forEach((f) => checked.add(f.path));
+    try {
+      const all = readAll(redirectFiles.map((f) => ({ ...f, oid: '' })));
+      const flat = flatten(all);
+      if (typeof flat === 'string') problems.push(flat);
+      else for (const line of chainsOf(all, flat)) problems.push(line);
+    } catch {
+      problems.push(`${config.siteRedirects.map}: ${t.app.invalidJson}`);
+    }
+  }
+
+  // The blocks in the text of the pages and posts, by the template of their collection.
+  for (const f of files) {
+    if (!f.path.endsWith('.md')) continue;
+    checked.add(f.path);
+    blocks += splitBlocks(f.text, null).filter((part) => 'type' in part).length;
+    const collection = collections.find((c) => c.kind === 'markdown' && f.path.startsWith(`${c.folder}/`));
+    const template = collection?.kind === 'markdown' ? collection.template : undefined;
+    // A standard page by its own rules too (the blog page has "Blogindlæg"), and the front page's leads read as the site reads
+    // them (packages/editor/site/home.ts).
+    const standard = standardPageOf(f, files);
+    const front = standard?.key === 'front';
+    for (const problem of blockProblems(f.text, asStandardTemplate(template, standard), front ? frontLeads : undefined))
+      problems.push(`${f.path}: ${problem}`);
+  }
+  // The site's own rules (a button that opens a promotion that is not on its page).
+  problems.push(...siteProblems(files));
+  return { problems, files: checked.size, blocks };
+}
+
+// A line for each redirect that sends on through another: its file, where it sends and where it ends.
+function chainsOf(all: AllRedirects, flat: AllRedirects): string[] {
+  const lines: string[] = [];
+  const compare = (file: string, was: Record<string, string>, now: Record<string, string>) => {
+    for (const [from, to] of Object.entries(was)) if (now[from] !== to) lines.push(`${file}: ${t.redirects.chain(from, to, now[from])}`);
+  };
+  compare(config.redirects, all.own, flat.own);
+  compare(config.siteRedirects.map, all.map.paths, flat.map.paths);
+  compare(config.siteRedirects.map, all.map.ids, flat.map.ids);
+  all.rules.forEach((line, i) => {
+    if (line !== flat.rules[i]) lines.push(`${config.siteRedirects.rules}: ${t.redirects.chainRule(line.trim(), flat.rules[i].trim())}`);
+  });
+  return lines;
+}
+
+/** The site's own texts with no translation, by the editor's other languages, by the file they belong
+ * in: the site's in @site/texts, a block's in its texts.ts (or the site's, for what it takes from
+ * the site). The editor shows them as they are written. Not the ones said in code (the messages in
+ * rules.ts, the lines on the blocks' cards). */
+export function untranslated(): Record<string, Record<string, string[]>> {
+  // The editor shows a site's definitions translated already on a site in another language than Danish, so a text the walk
+  // meets is traced back to the one it was translated from (the translations' tables are by it). A text is written in the
+  // package's language when the package's standard parts or an app have it in Danish (defaults/texts.ts, an app's
+  // texts.ts), else in the site's; it needs a translation in each other language.
+  const tables = [standardTexts, ...Object.values(appTexts)].map((table) => Object.entries(table['en-US'] ?? {}));
+  const danish = new Set(tables.flatMap((entries) => entries.map(([text]) => text)));
+  const original = new Map(tables.flatMap((entries) => entries.map(([text, translated]) => [translated, text] as const)));
+  const writtenIn = (text: string) => (danish.has(text) ? DEFAULTS_LOCALE : siteLocale);
+  const missing = (l: string, own: Record<string, string>, walk: (w: ReturnType<typeof translator>) => void) => {
+    const found = new Set<string>();
+    walk(
+      translator((shown) => {
+        const text = original.get(shown) ?? shown;
+        if (writtenIn(text) !== l && !(text in own)) found.add(text);
+        return shown;
+      }),
+    );
+    return [...found];
+  };
+  return Object.fromEntries(
+    locales
+      .filter((l) => l !== siteLocale || l !== DEFAULTS_LOCALE)
+      .map((l) => {
+        const site = (texts as Texts)[l] ?? {};
+        const files: Record<string, string[]> = {
+          'src/site/texts.ts': missing(l, site, (w) => {
+            collections.forEach(w.collection);
+            [...companyParts, ...partScreens.flatMap((s) => s.parts), ...appearance, ...seoParts, ...blockParts].forEach(w.part);
+            partScreens.forEach((s) => w.group({ title: s.label, ids: [] }));
+            groups.forEach(w.group);
+            colorFields.forEach(w.color);
+            colorPairs.forEach(w.pair);
+          }),
+        };
+        // An app's block's own texts, and the fields of its shared texts (shared.ts), in its texts.ts.
+        for (const block of siteBlocks.filter((b) => b.app))
+          files[`src/apps/${block.app}/blocks/${block.type}/texts.ts`] = missing(
+            l,
+            { ...site, ...appTexts[`blocks/${block.type}`]?.[l] },
+            (w) => {
+              w.block(block);
+              sharedParts.filter((p) => p.id === block.type).forEach(w.part);
+            },
+          );
+        // An app's name, what it does and its settings, in its texts.ts.
+        for (const app of apps) files[`src/apps/${app.id}/texts.ts`] = missing(l, { ...site, ...appTexts[app.id]?.[l] }, (w) => w.app(app));
+        return [l, Object.fromEntries(Object.entries(files).filter(([, list]) => list.length))];
+      }),
+  );
+}

package/src/consents.ts

@@ -0,0 +1,26 @@
+// The visitors' answers in the cookie banner, as the site's Worker keeps them (packages/editor/worker/consent.js, /api/consent on the
+// editor's own address), for "Samtykker" under "Privatliv" (Consents.tsx). Asked with the GitHub sign-in (the Worker's
+// cookie, sent with the request): the Worker lets only someone who can save the site see or delete them.
+import type { ConsentCategory } from '../lib/cookieCategories.mjs';
+
+/** An answer: the visitor's consent id, when (ISO), the yes or no to each category the banner asked about, and the
+ * commit the site was built from (the banner they answered). */
+export type ConsentAnswer = { id: string; at: string; choices: Partial<Record<ConsentCategory, boolean>>; version: string };
+
+export const CONSENT_API = '/api/consent';
+
+/** The newest answers (at most 500), those of a consent id starting with `query`, and how many there are in all; null
+ * when the site does not keep them (no Worker, no storage). */
+export async function loadConsents(query = ''): Promise<{ entries: ConsentAnswer[]; total: number } | null> {
+  const res = await fetch(`${CONSENT_API}${query ? `?q=${encodeURIComponent(query)}` : ''}`, { cache: 'no-store' });
+  if (res.status === 503 || !res.headers.get('content-type')?.includes('application/json')) return null;
+  if (!res.ok) throw new Error(String(res.status));
+  return (await res.json()) as { entries: ConsentAnswer[]; total: number };
+}
+
+/** Deletes every answer with a consent id (a visitor asked for it); how many. */
+export async function deleteConsents(id: string): Promise<number> {
+  const res = await fetch(CONSENT_API, { method: 'DELETE', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ id }) });
+  if (!res.ok) throw new Error(String(res.status));
+  return ((await res.json()) as { deleted: number }).deleted;
+}

package/src/cookieList.ts

@@ -0,0 +1,70 @@
+// The site's cookie list, "Cookies" under "Lister" (the list the standard block "Cookieliste" brings,
+// standard/cookies/list.ts): a file per cookie in config.cookieList, each with its name (`*` for the rest of it), who
+// sets it, what for, how long it lasts and its category (necessary, or one the visitor says yes to in the cookie banner,
+// lib/cookieCategories.mjs). An app's cookies (its
+// cookies.json, those with a name) are added to it in the commit that installs the app, and those it added (`app`, its
+// id, kept in the file but not shown) are taken out in the one that uninstalls it; an update adds its new ones and takes
+// out those it no longer sets. One already in the list by its name and provider is left as it is, so what was written
+// over an app's text stays. The app "Cookiescanner" adds those its scan finds besides (its worker.js), and more can be
+// added by hand.
+import { config } from '@site/config';
+import type { Change, RepoFile } from './github';
+import { slugify } from './schema';
+import { categoryOf, type CookieCategory } from '../lib/cookieCategories.mjs';
+import type { AppCookie } from './store';
+
+/** A cookie in the list, as its file has it; `app`: the app that added it; `new`: added by the app "Cookiescanner" and not
+ * yet looked through (first in the list, marked, until it is saved: FolderCollection.fresh); `scanned`: added by it, kept
+ * when saved (its tab "Problemer" says when the site no longer sets it). */
+export type CookieEntry = {
+  name: string;
+  provider: string;
+  purpose: string;
+  lasts?: string;
+  category: CookieCategory;
+  app?: string;
+  new?: boolean;
+  scanned?: boolean;
+};
+
+/** Whether a file is one of the list's. */
+export const inCookieList = (path: string) => path.startsWith(`${config.cookieList}/`) && path.endsWith('.json');
+
+function entryOf(file: RepoFile): Partial<CookieEntry> {
+  try {
+    return JSON.parse(file.text) ?? {};
+  } catch {
+    return {};
+  }
+}
+
+const same = (a: { name?: string; provider?: string }, b: { name?: string; provider?: string }) =>
+  a.name === b.name && (a.provider ?? '') === (b.provider ?? '');
+
+/** The changes to the list when an app is installed or updated with `cookies` (its cookies.json, in the site's
+ * language), or uninstalled (null), from the site's files now (see above). */
+export function cookieChanges(app: string, cookies: AppCookie[] | null, files: RepoFile[]): Change[] {
+  const list = files.filter((f) => inCookieList(f.path)).map((file) => ({ file, entry: entryOf(file) }));
+  const wanted = (cookies ?? []).filter((c) => c.name?.trim());
+  const changes: Change[] = list
+    .filter(({ entry }) => entry.app === app && !wanted.some((c) => same(c, entry)))
+    .map(({ file }) => ({ path: file.path, content: null, oid: file.oid }));
+  const taken = new Set(list.map(({ file }) => file.path));
+  for (const c of wanted) {
+    if (list.some(({ entry }) => same(c, entry))) continue;
+    const slug = slugify(`${c.name!.replace(/\*/g, ' x ')} ${c.provider ?? ''}`) || 'cookie';
+    let path = `${config.cookieList}/${slug}.json`;
+    for (let n = 2; taken.has(path); n++) path = `${config.cookieList}/${slug}-${n}.json`;
+    taken.add(path);
+    const entry: CookieEntry = {
+      name: c.name!,
+      provider: c.provider ?? '',
+      purpose: c.purpose,
+      ...(c.lasts ? { lasts: c.lasts } : {}),
+      category: categoryOf(c),
+      app,
+    };
+    changes.push({ path, content: `${JSON.stringify(entry, null, 2)}\n`, oid: null });
+  }
+  return changes;
+}