@morphemecms/cms 0.5.0 → 0.7.0

package/src/sections.mjs

@@ -15,9 +15,11 @@
 // The front page is an ordinary page (packages/editor/defaults/standardPages.ts): its text is read into sections the same way, by the editor
 // and by the site (partsOfMarkdown, packages/editor/site/home.ts).
 // Shared by the editor and packages/editor/scripts/editor-roundtrip.mjs, which checks that every page comes back the same.
+// Depends on lib/blocks.mjs, lib/crop.mjs, lib/text-colors.mjs and the section colour marker (lib/section-marker.mjs).
 import { blockHtml, cutAtBlock, parseBlock } from '../lib/blocks.mjs';
 import { decorated, decorativeOf } from '../lib/crop.mjs';
 import { coloredHtml, withoutColors } from '../lib/text-colors.mjs';
+import { SECTION_COLORS, isLabelLine } from '../lib/section-marker.mjs';
 
 // Text that is plain in the file (a heading, a picture's description); in Markdown every sign that
 // could mean something is escaped, and back from Markdown the escapes go again. The page's
@@ -96,16 +98,18 @@ function hero(lead, props) {
 
 // A section with a lead from the text before its card (`run`): what is left of the run first, as
 // sections of text, then the section with its picture, heading and text.
-function withLead(run, block, lead) {
+function withLead(run, block, lead, blockColor) {
   let rest = [...run];
   let heading;
   let body = '';
+  let color = blockColor;
   if (lead.heading) {
     const at = rest.findLastIndex((p) => 'heading' in p);
     // A section with only a heading has no place for text: with text after it, the heading and the
     // text stay a section of text (as they look in the editor), and the section has no heading.
     if (at >= 0 && (lead.body || at === rest.length - 1)) {
       heading = rest[at].heading;
+      color = rest[at].sectionColor;
       body = rest
         .slice(at + 1)
         .map((p) => p.markdown)
@@ -135,26 +139,39 @@ function withLead(run, block, lead) {
     ...(lead.heading ? { [lead.heading]: heading ?? '' } : {}),
     ...(lead.body && paragraphs.length ? { [lead.body]: lead.list ? paragraphs : paragraphs.join('\n\n') } : {}),
   };
-  return [...textSections(rest), { type: block.type, ...own, ...block.props }];
+  return [...textSections(rest), { type: block.type, ...own, ...block.props, ...colorOf(color) }];
 }
 
-/** The sections for the parts of the text (partsOf in markdown.mjs); leads as for sectionsToMarkdown. */
-export function sectionsFromParts(parts, leads = {}) {
-  const first = parts.findIndex((p) => p.block);
-  if (first >= 0 && parts[first].block.type === 'hero' && leads.hero)
-    return [hero(parts.slice(0, first), parts[first].block.props), ...sectionsFromParts(parts.slice(first + 1), leads)];
+const colorOf = (color) => (color ? { sectionColor: color } : {});
+
+// Each part with the colour of the H2 it is under (`sectionColor`): a heading starts it, a heading without a colour ends it.
+function withColors(parts) {
+  let current = null;
+  return parts.map((part) => {
+    if ('heading' in part) current = part.color ?? null;
+    return current ? { ...part, sectionColor: current } : part;
+  });
+}
+
+/** The sections for the parts of the text (partsOf in markdown.mjs); leads as for sectionsToMarkdown. `colors`: the front
+ * page: each section also has the colour of its H2 as `sectionColor` (the top, the "Banner", has none). */
+export function sectionsFromParts(parts, leads = {}, options = {}) {
+  const all = options.colors ? withColors(parts) : parts;
+  const first = all.findIndex((p) => p.block);
+  if (first >= 0 && all[first].block.type === 'hero' && leads.hero)
+    return [hero(parts.slice(0, first), all[first].block.props), ...sectionsFromParts(parts.slice(first + 1), leads, options)];
   const sections = [];
   // The text since the last card, for the next card (its lead) or as sections of text.
   let run = [];
-  for (const part of parts) {
+  for (const part of all) {
     if (!part.block) {
       run.push(part);
       continue;
     }
     // A "Hero" further down is a card with all of its fields (only the top's are written above it).
     const lead = part.block.type === 'hero' ? undefined : leads[part.block.type];
-    if (lead) sections.push(...withLead(run, part.block, lead));
-    else sections.push(...textSections(run), { type: part.block.type, ...part.block.props });
+    if (lead) sections.push(...withLead(run, part.block, lead, part.sectionColor));
+    else sections.push(...textSections(run), { type: part.block.type, ...part.block.props, ...colorOf(part.sectionColor) });
     run = [];
   }
   return [...sections, ...textSections(run)];
@@ -167,12 +184,12 @@ function textSections(parts) {
   let text = null;
   for (const part of parts) {
     if ('heading' in part) {
-      text = part.heading ? { type: 'text', heading: part.heading, body: '' } : { type: 'text', body: '' };
+      text = { type: 'text', ...(part.heading ? { heading: part.heading } : {}), body: '', ...colorOf(part.sectionColor) };
       sections.push(text);
     } else if (text) {
       text.body = part.markdown;
       text = null;
-    } else sections.push({ type: 'text', body: part.markdown });
+    } else sections.push({ type: 'text', body: part.markdown, ...colorOf(part.sectionColor) });
   }
   return sections.filter((s) => s.heading || s.body);
 }
@@ -238,31 +255,50 @@ export const plainHeading = (s) =>
 const atx = (level) => new RegExp(`^ {0,3}#{${level}}(?!#)(?:[ \t]+(.*?))?(?:[ \t]+#+)?[ \t]*$`);
 const h1Line = atx(1);
 
-/** A page's H1: the heading "# …" on the first line of its text that is not empty (the page's own heading, written
- * at the top of its text), as text, and the text without it. Without one: no heading, and the text as it is. With a
- * word or more in colour, `html` is the heading as HTML with its colours (coloredHtml), for the layout to draw. */
+/** A page's H1: the first heading "# …" of its text outside fenced code, wherever it stands (the editor makes the first
+ * heading of a page its H1, src/firstHeading.mjs, but text may stand above it), as text, and the text without that line
+ * (what stood above it first, a blank line, then what stood below). Without one: no heading, and the text as it is.
+ * With a word or more in colour, `html` is the heading as HTML with its colours (coloredHtml), for the layout to draw. */
 export function pageH1(markdown) {
   const text = String(markdown ?? '');
-  const match = text.match(/^(?:[ \t]*\r?\n)*([^\r\n]*)(?:\r?\n|$)/);
-  const line = match?.[1] ?? '';
-  const h1 = line.match(h1Line);
-  if (!h1) return { heading: undefined, rest: text };
-  const heading = plainHeading(h1[1] ?? '') || undefined;
-  return {
-    heading,
-    html: heading && coloredHtml(h1[1] ?? '', plainHeading),
-    rest: text.slice(match[0].length).replace(/^(?:[ \t]*\r?\n)+/, ''),
-  };
+  const lines = text.split(/(?<=\n)/);
+  const bare = (line) => line.replace(/\r?\n$/, '');
+  let fence = null;
+  let at = -1;
+  for (let i = 0; i < lines.length && at < 0; i++) {
+    const line = bare(lines[i]);
+    const mark = line.match(/^ {0,3}(`{3,}|~{3,})/)?.[1];
+    if (fence) {
+      if (mark && mark[0] === fence[0] && mark.length >= fence.length) fence = null;
+    } else if (mark) fence = mark;
+    else if (h1Line.test(line)) at = i;
+  }
+  if (at < 0) return { heading: undefined, rest: text };
+  const h1 = bare(lines[at]).match(h1Line);
+  const heading = plainHeading(h1?.[1] ?? '') || undefined;
+  const before = lines.slice(0, at).join('');
+  const after = lines
+    .slice(at + 1)
+    .join('')
+    .replace(/^(?:[ \t]*\r?\n)+/, '');
+  const eol = text.includes('\r\n') ? '\r\n' : '\n';
+  const rest = !before.trim() ? after : after ? `${before.trimEnd()}${eol}${eol}${after}` : before.trimEnd();
+  return { heading, html: heading && coloredHtml(h1?.[1] ?? '', plainHeading), rest };
 }
 
+// A section's colour marker on its own line (lib/section-marker.mjs); any colour name, so an unknown one is dropped too.
+const MARKER_LINE = /^ {0,3}<div data-section="([^"]*)"><\/div>[ \t]*$/;
+
 /** The parts of a page's Markdown as the editor reads them (partsOf in markdown.mjs), without the editor: each block,
  * each heading at the top level (H2), and the Markdown between them; for the site, which reads the front page into
  * sections (packages/editor/site/home.ts). The page's H1 ("# …") is no section's and is left out. `npm run check:editor` checks
- * that it gives the editor's sections for every page. */
+ * that it gives the editor's sections for every page. A colour marker before an H2 is its part's `color`. */
 export function partsOfMarkdown(markdown) {
   const parts = [];
   let run = [];
   let fence = null;
+  // The colour of a marker line, kept for the H2 it stands before (blank lines and a label line may come between).
+  let pending = null;
   const flush = () => {
     const text = run.join('\n').trim();
     if (text) parts.push({ markdown: text });
@@ -277,25 +313,36 @@ export function partsOfMarkdown(markdown) {
     }
     if (mark) {
       fence = mark;
+      pending = null;
       run.push(line);
       continue;
     }
+    // The marker is never text: it is the colour of the H2 after it, or dropped (unknown colour, or no H2 after it).
+    const marker = line.match(MARKER_LINE);
+    if (marker) {
+      pending = SECTION_COLORS.includes(marker[1]) ? marker[1] : null;
+      continue;
+    }
     const block = parseBlock(line);
     if (block) {
       flush();
+      pending = null;
       parts.push({ block });
       continue;
     }
     if (h1Line.test(line)) {
       flush();
+      pending = null;
       continue;
     }
     const heading = line.match(atx(2));
     if (heading) {
       flush();
-      parts.push({ heading: plainHeading(heading[1] ?? '') });
+      parts.push({ heading: plainHeading(heading[1] ?? ''), ...(pending ? { color: pending } : {}) });
+      pending = null;
       continue;
     }
+    if (line.trim() && !isLabelLine(line)) pending = null;
     run.push(line);
   }
   flush();

package/src/sections.test.mjs

@@ -0,0 +1,59 @@
+// Tests pageH1 in sections.mjs: a page's H1 is the first "# …" line of its text outside code, wherever it is.
+// Run with `node --test packages/editor/src/*.test.mjs` (part of npm run check).
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { pageH1 } from './sections.mjs';
+
+test('an H1 on the first line, as before', () => {
+  assert.deepEqual(pageH1('# Title\n\nText'), { heading: 'Title', html: undefined, rest: 'Text' });
+});
+
+test('blank lines above the H1 are skipped', () => {
+  const found = pageH1('\n \n# Title\n\n\nText');
+  assert.equal(found.heading, 'Title');
+  assert.equal(found.rest, 'Text');
+});
+
+test('an H1 after some text: the text stays, without the H1', () => {
+  const found = pageH1('Intro\n\n# Title\n\nMore\n\n## Section');
+  assert.equal(found.heading, 'Title');
+  assert.equal(found.rest, 'Intro\n\nMore\n\n## Section');
+});
+
+test('an H1 after a heading is found too', () => {
+  const found = pageH1('## Section\n\ntext\n\n# Title');
+  assert.equal(found.heading, 'Title');
+  assert.equal(found.rest, '## Section\n\ntext');
+});
+
+test('only the first H1 counts, the next stays in the text', () => {
+  const found = pageH1('# One\n\n# Two\n\ntext');
+  assert.equal(found.heading, 'One');
+  assert.equal(found.rest, '# Two\n\ntext');
+});
+
+test('an H1 line in a code fence is not a heading', () => {
+  const found = pageH1('```\n# not a heading\n```\n\n# Real');
+  assert.equal(found.heading, 'Real');
+  assert.equal(found.rest, '```\n# not a heading\n```');
+  assert.equal(pageH1('~~~\n# code\n~~~').heading, undefined);
+});
+
+test('without an H1: no heading, the text as it is', () => {
+  assert.deepEqual(pageH1('## Only\n\ntext'), { heading: undefined, rest: '## Only\n\ntext' });
+  assert.deepEqual(pageH1(undefined), { heading: undefined, rest: '' });
+});
+
+test('an H2 or "#tag" is not an H1', () => {
+  assert.equal(pageH1('## Two\n\n#tag').heading, undefined);
+});
+
+test('the heading is plain text: bold, links and escapes are gone', () => {
+  assert.equal(pageH1('Intro\n\n# A **bold** [link](/x) title').heading, 'A bold link title');
+});
+
+test('Windows line endings are kept in the rest', () => {
+  const found = pageH1('Intro\r\n\r\n# Title\r\n\r\nMore');
+  assert.equal(found.heading, 'Title');
+  assert.equal(found.rest, 'Intro\r\n\r\nMore');
+});

package/src/sidebar.ts

@@ -1,5 +1,5 @@
-// Whether the sidebar is open on a computer (App.tsx), closed and opened with the button at its top
-// or, while it is closed, at the start of the top bar (Screen.tsx). Kept in this browser.
+// Whether the standard navigation drawer is open (expanded and wider, MainDrawer in ui.tsx), opened and closed with the menu
+// button at the top of the navigation rail and of the drawer (ui.tsx, through menuOpen.ts). Kept in this browser (`editor-sidebar`).
 import { useSyncExternalStore } from 'react';
 
 const KEY = 'editor-sidebar';

package/src/site.ts

@@ -1,5 +1,5 @@
 // The site as the editor shows it: what src/site/ describes (the collections and their fields, the
-// start screen's groups, the screens under "Virksomheden" and "Blokke") with the site's texts in the
+// menu's sections (groups), the screens under "Virksomheden" and "Blokke") with the site's texts in the
 // editor's language (siteText, @site/texts). The editor takes these from here, not from
 // @site/editor. A commit says what was saved in the site's language: asWritten gives back a
 // collection, a file, a part or a block as the site wrote it.
@@ -160,9 +160,14 @@ export const appearance = each(
   site.appearance.map((p) => ({ ...p, back: { href: '#udseende', label: t.common.parts.appearance } })),
   local.part,
 );
-/** The site's own parts under "Søgemaskineoptimering" (#seo, Library.tsx Seo), after the redirects, each going back to it. */
+/** Where a screen goes back to: the start screen. The menu's sections ("Indhold" …) are lists in the drawer, not screens,
+ * so Redirects and "Interne links" under "Indhold" go there too. */
+export const backFrom = (_id: string) => ({ href: '#', label: site.siteName });
+
+/** The site's own parts under "Søgemaskineoptimering" (#seo/<id>, in the menu under "Indhold"), each going back
+ * to the start screen (backFrom). */
 export const seoParts = each(
-  site.seoParts.map((p) => ({ ...p, back: { href: '#seo', label: t.common.parts.seo } })),
+  site.seoParts.map((p) => ({ ...p, back: backFrom(p.id) })),
   local.part,
 );
 /** The site's own first ("Book en tid"), then the blocks' by their names. */
@@ -175,19 +180,14 @@ export const groups = each(site.groups, local.group);
 export const colorFields = each(site.colorFields, local.color);
 /** The pairs that must be readable (@site/colors), with what they are in the editor's language. */
 export const colorPairs = each(site.colorPairs, local.pair);
-/** The settings of the whole site, on "Indstillinger" (#indstillinger) instead of the start screen. */
+/** The settings of the whole site, the drawer's last section. */
 export const settings: string[] = site.settings;
 
-/** Where a part of the start screen is, as the way there says it: its group's title, or "Indstillinger" for a setting. */
-export const placeOf = (id: string): string | undefined =>
-  settings.includes(id) ? t.common.parts.settings : groups.find((g) => g.ids.includes(id))?.title;
-
-/** Where a screen goes back to: "Indstillinger" for a setting ("Udseende", "Apps", "Analytics" …), else the start screen. */
-export const backFrom = (id: string) =>
-  settings.includes(id) ? { href: '#indstillinger', label: t.common.parts.settings } : { href: '#', label: site.siteName };
+/** Where a part of the menu is, as the way there says it: the title of the section it is in ("Indhold › …"). */
+export const placeOf = (id: string): string | undefined => groups.find((g) => g.ids.includes(id))?.title;
 
 /** Where a standard page (by its key, packages/editor/defaults/standardPages.ts) is chosen, as the way there from the start screen
- * ("Indstillinger › Udseende › Standardsider"): the part with its field in the file of the standard pages. */
+ * ("Udseende › Standardsider"): the part with its field in the file of the standard pages. */
 export function standardPageAt(key: string): string {
   const chosenIn = (p: Part) => p.file === site.config.standardPages && !!p.fields?.some((f) => f.name === key);
   const screen = [{ id: 'udseende', label: t.common.parts.appearance, parts: appearance }, ...partScreens].find((s) =>
@@ -303,15 +303,25 @@ export const listRowsOf = (files: { path: string; text: string }[]): ListRows =>
     ]),
   );
 
-/** The icon of each part on the start screen, in the sidebar and under "Lister", by its id: the site's, and the
- * standard blocks' and the apps' lists'. */
-export const icons = { ...site.icons, ...Object.fromEntries(ownedLists.map((l) => [l.id, l.icon])) };
+/** The icon of each part on the start screen, in the sidebar and under "Lister", by its id: the site's, the
+ * standard blocks' and the apps' lists', and those of the parts the menu lists (appearance, seoParts, partScreens). */
+export const icons = {
+  ...site.icons,
+  ...Object.fromEntries(ownedLists.map((l) => [l.id, l.icon])),
+  // The parts the menu lists by their id: the site's standard pages, Internal links and the parts of the screens with parts.
+  ...Object.fromEntries(
+    [...appearance, ...seoParts, ...partScreens.flatMap((s) => s.parts)].flatMap((p) => (p.icon ? [[p.id, p.icon]] : [])),
+  ),
+};
 
 /** The short lists, under "Lister" (#lister): the site's, the standard blocks' and the apps', which go back there too. */
 export const lists = [...site.lists, ...ownedLists.map((l) => l.id)];
 
-/** The lists under "Lister" now: the site's, the standard blocks' and those of the apps installed. */
+/** The lists under "Lister" now: the site's, the standard blocks' and those of the apps installed, without the cookie
+ * list, which is a row under "Privatliv" (privacy.ts). */
 export const listsShown = (files: { path: string; text: string }[]) => {
   const installed = installedApps(files);
-  return [...site.lists, ...[...standardLists, ...listsOf(writtenApps.filter((a) => installed.includes(a.id)))].map((l) => l.id)];
+  return [...site.lists, ...[...standardLists, ...listsOf(writtenApps.filter((a) => installed.includes(a.id)))].map((l) => l.id)].filter(
+    (id) => id !== site.config.lists.cookies,
+  );
 };

package/src/stillCursor.d.mts

@@ -0,0 +1,8 @@
+/** The word around the cursor as positions in the document, or null (a selection, or no word there).
+ * @param {import('@milkdown/kit/prose/state').EditorState} state @returns {{ from: number, to: number } | null} */
+export function wordRange(state: import("@milkdown/kit/prose/state").EditorState): {
+    from: number;
+    to: number;
+} | null;
+/** How long the cursor stands still in a word before the menu appears, in ms. */
+export const STILL_MS: 700;

package/src/stillCursor.mjs

@@ -0,0 +1,19 @@
+// The word at a cursor that has stood still, for the menu over a text (selectionMenu in MarkdownEditor.tsx): how long
+// the cursor waits (STILL_MS) and the word around it as positions in the document (wordRange). Depends on
+// lib/word-at.mjs and ProseMirror's state.
+import { wordAt } from '../lib/word-at.mjs';
+
+/** How long the cursor stands still in a word before the menu appears, in ms. */
+export const STILL_MS = 700;
+
+/** The word around the cursor as positions in the document, or null (a selection, or no word there).
+ * @param {import('@milkdown/kit/prose/state').EditorState} state @returns {{ from: number, to: number } | null} */
+export function wordRange(state) {
+  const { $from, empty } = state.selection;
+  const block = $from.parent;
+  if (!empty || !block.isTextblock) return null;
+  // One character for each picture or line break, so a place in the text is the same place in the block.
+  const word = wordAt(block.textBetween(0, block.content.size, undefined, ''), $from.parentOffset);
+  const start = $from.start();
+  return word && { from: start + word.from, to: start + word.to };
+}

package/src/stillCursor.test.mjs

@@ -0,0 +1,26 @@
+// Tests for src/stillCursor.mjs: the word around the cursor as positions in the document. Run: node --test packages/editor/lib/*.test.mjs packages/editor/src/*.test.mjs
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { Schema } from '@milkdown/kit/prose/model';
+import { EditorState, TextSelection } from '@milkdown/kit/prose/state';
+import { STILL_MS, wordRange } from './stillCursor.mjs';
+
+const schema = new Schema({
+  nodes: {
+    doc: { content: 'block+' },
+    paragraph: { group: 'block', content: 'inline*' },
+    text: { group: 'inline' },
+    image: { group: 'inline', inline: true },
+  },
+});
+// "How ", a picture, " saving works": the text starts at 1, the picture is at 5, "saving" is 7–13.
+const doc = schema.node('doc', null, [
+  schema.node('paragraph', null, [schema.text('How '), schema.node('image'), schema.text(' saving works')]),
+]);
+const at = (from, to = from) => EditorState.create({ doc, selection: TextSelection.create(doc, from, to) });
+
+test('waits 700 ms', () => assert.equal(STILL_MS, 700));
+test('the word after a picture', () => assert.deepEqual(wordRange(at(9)), { from: 7, to: 13 }));
+test('the word before a picture', () => assert.deepEqual(wordRange(at(2)), { from: 1, to: 4 }));
+test('no word next to the picture', () => assert.equal(wordRange(at(5)), null));
+test('none for a selection', () => assert.equal(wordRange(at(7, 13)), null));

package/src/tagUses.d.mts

@@ -0,0 +1,47 @@
+/** The tags a promotion is shown on the posts of (Promovering, "Vises på": "Blogindlæg med tags").
+ * @param {Record<string, unknown>} d
+ * @returns {string[]} */
+export function promotionTags(d: Record<string, unknown>): string[];
+/**
+ * The files that use each tag, keyed by path, each file once.
+ * @template {TagFile} F
+ * @param {F[]} files
+ * @param {TagFolders} folders
+ * @returns {Map<string, Map<string, F>>}
+ */
+export function tagUses<F extends TagFile>(files: F[], folders: TagFolders): Map<string, Map<string, F>>;
+/**
+ * A file record's use of a tag: the Filer address the file record is for, as a path under filer/.
+ * @param {TagFile} file
+ * @param {string} folder the file records folder
+ * @returns {{ path: string; name: string } | null}
+ */
+export function recordUse(file: TagFile, folder: string): {
+    path: string;
+    name: string;
+} | null;
+/**
+ * The files that have a tag by their own categories: posts, pages and testimonials (not blocks).
+ * @template {TagFile} F
+ * @param {F[]} files
+ * @param {string} slug
+ * @param {TagFolders} folders
+ * @returns {{ posts: F[]; pages: F[]; testimonials: F[]; records: F[] }}
+ */
+export function taggedWith<F extends TagFile>(files: F[], slug: string, folders: TagFolders): {
+    posts: F[];
+    pages: F[];
+    testimonials: F[];
+    records: F[];
+};
+export type TagFile = {
+    path: string;
+    text: string;
+};
+export type TagFolders = {
+    blog: string;
+    pages: string;
+    testimonials: string;
+    popups: string;
+    fileRecords?: string;
+};

package/src/tagUses.mjs

@@ -0,0 +1,121 @@
+// What on the site uses each tag: posts and pages by their front matter, testimonials, promotions on tagged posts,
+// file records (tags on files in Filer), and the "Blogindlæg"/"Udtalelser" blocks that pick a tag. Pure (no @site imports),
+// so node --test can run it; defaults/rules.ts uses it for usedBy, usesOf and countsOf.
+import { blocksIn } from '../lib/blocks.mjs';
+import { isRecordPath, parseRecord } from './fileRecords.mjs';
+import { readFields, splitFrontmatter } from './frontmatter.mjs';
+
+/**
+ * @typedef {{ path: string; text: string }} TagFile
+ * @typedef {{ blog: string; pages: string; testimonials: string; popups: string; fileRecords?: string }} TagFolders
+ */
+
+/** The front matter fields of a file; a broken one gives no fields (never throws). @param {TagFile} f */
+const frontmatterOf = (f) => {
+  try {
+    return readFields(splitFrontmatter(f.text).yaml) ?? {};
+  } catch {
+    return {};
+  }
+};
+
+/** The JSON of a file; a broken one gives no fields (never throws). @param {TagFile} f */
+const jsonOf = (f) => {
+  try {
+    return JSON.parse(f.text) ?? {};
+  } catch {
+    return {};
+  }
+};
+
+/** @param {string} path @param {string} folder @param {string} ext */
+const inFolder = (path, folder, ext) => path.startsWith(`${folder}/`) && path.endsWith(ext);
+
+/** The record of a file record, or null when the file is not one.
+ * @param {TagFile} f @param {TagFolders} folders */
+const recordOf = (f, folders) =>
+  folders.fileRecords !== undefined && isRecordPath(f.path, folders.fileRecords) ? parseRecord(f.text) : null;
+
+/** The tags a promotion is shown on the posts of (Promovering, "Vises på": "Blogindlæg med tags").
+ * @param {Record<string, unknown>} d
+ * @returns {string[]} */
+export function promotionTags(d) {
+  return d.where === 'tags' && Array.isArray(d.tags) ? d.tags.map(String) : [];
+}
+
+/** The tags a block picks: a "Blogindlæg" or "Udtalelser" block's categories, and its link.
+ * @param {string} type
+ * @param {Record<string, any>} props
+ * @returns {unknown[]} */
+const blockTags = (type, props) => {
+  if (type !== 'posts' && type !== 'testimonials') return [];
+  return [...(Array.isArray(props?.categories) ? props.categories : []), ...(props?.link ? [props.link] : [])];
+};
+
+/**
+ * The files that use each tag, keyed by path, each file once.
+ * @template {TagFile} F
+ * @param {F[]} files
+ * @param {TagFolders} folders
+ * @returns {Map<string, Map<string, F>>}
+ */
+export function tagUses(files, folders) {
+  /** @type {Map<string, Map<string, F>>} */
+  const uses = new Map();
+  /** @param {F} f @param {unknown} slugs */
+  const add = (f, slugs) => {
+    for (const slug of Array.isArray(slugs) ? slugs.map(String) : []) {
+      const byPath = uses.get(slug) ?? new Map();
+      byPath.set(f.path, f);
+      uses.set(slug, byPath);
+    }
+  };
+  for (const f of files) {
+    if (inFolder(f.path, folders.blog, '.md') || inFolder(f.path, folders.pages, '.md')) {
+      add(f, frontmatterOf(f).categories);
+      for (const b of blocksIn(f.text)) add(f, blockTags(b.type, b.props));
+    } else if (inFolder(f.path, folders.testimonials, '.json')) {
+      add(f, jsonOf(f).categories);
+    } else if (inFolder(f.path, folders.popups, '.json')) {
+      add(f, promotionTags(jsonOf(f)));
+    } else {
+      const record = recordOf(f, folders);
+      if (record) add(f, record.categories);
+    }
+  }
+  return uses;
+}
+
+/**
+ * A file record's use of a tag: the Filer address the file record is for, as a path under filer/.
+ * @param {TagFile} file
+ * @param {string} folder the file records folder
+ * @returns {{ path: string; name: string } | null}
+ */
+export function recordUse(file, folder) {
+  const record = folder !== undefined && isRecordPath(file.path, folder) ? parseRecord(file.text) : null;
+  if (!record) return null;
+  return { path: `filer${record.src}`, name: record.src.slice(record.src.lastIndexOf('/') + 1) };
+}
+
+/**
+ * The files that have a tag by their own categories: posts, pages and testimonials (not blocks).
+ * @template {TagFile} F
+ * @param {F[]} files
+ * @param {string} slug
+ * @param {TagFolders} folders
+ * @returns {{ posts: F[]; pages: F[]; testimonials: F[]; records: F[] }}
+ */
+export function taggedWith(files, slug, folders) {
+  /** @param {unknown} categories */
+  const has = (categories) => Array.isArray(categories) && categories.map(String).includes(slug);
+  return {
+    posts: files.filter((f) => inFolder(f.path, folders.blog, '.md') && has(frontmatterOf(f).categories)),
+    pages: files.filter((f) => inFolder(f.path, folders.pages, '.md') && has(frontmatterOf(f).categories)),
+    testimonials: files.filter((f) => inFolder(f.path, folders.testimonials, '.json') && has(jsonOf(f).categories)),
+    records: files.filter((f) => {
+      const record = recordOf(f, folders);
+      return record !== null && has(record.categories);
+    }),
+  };
+}