ferst-core 0.7.2 → 0.7.5

package/lib/documents.ts

@@ -1,62 +1,68 @@
-/**
- * The `documents` block's list logic: newest first (dated items by date, undated ones
- * after, in the order given), an optional grouping by year, a file-type label from the
- * extension, and a readable date. Pure — the component only renders the result.
- */
-export interface DocumentItem {
-  title: string;
-  file: string;
-  date?: string;
-  note?: string;
-}
-export interface DocumentRow extends DocumentItem {
-  kind: string;
-  dateLabel?: string;
-}
-export interface DocumentGroup {
-  year: string | null;
-  items: DocumentRow[];
-}
-
-const KINDS: Record<string, string> = {
-  pdf: 'PDF', doc: 'Word', docx: 'Word', xls: 'Excel', xlsx: 'Excel', csv: 'CSV',
-  ppt: 'PowerPoint', pptx: 'PowerPoint', odt: 'Document', rtf: 'Document', txt: 'Text',
-  jpg: 'Image', jpeg: 'Image', png: 'Image', zip: 'ZIP',
-};
-
-export function fileKind(file: string): string {
-  const ext = file.split(/[?#]/)[0].split('.').pop()?.toLowerCase() ?? '';
-  return KINDS[ext] ?? 'File';
-}
-
-/** A valid ISO-ish date (YYYY-MM-DD…) → a Date, else null. */
-function parseDate(d: string | undefined): Date | null {
-  if (!d || !/^\d{4}-\d{2}-\d{2}/.test(d)) return null;
-  const t = new Date(d.slice(0, 10) + 'T00:00:00Z');
-  return Number.isNaN(t.getTime()) ? null : t;
-}
-
-export function documentGroups(items: DocumentItem[], groupByYear = false): DocumentGroup[] {
-  const rows = items.map((item, i) => {
-    const d = parseDate(item.date);
-    return {
-      row: {
-        ...item,
-        kind: fileKind(item.file),
-        dateLabel: d ? d.toLocaleDateString('en-GB', { day: 'numeric', month: 'long', year: 'numeric', timeZone: 'UTC' }) : undefined,
-      } as DocumentRow,
-      time: d?.getTime() ?? null,
-      year: d ? String(d.getUTCFullYear()) : null,
-      i,
-    };
-  });
-  rows.sort((a, b) => (a.time !== null && b.time !== null ? b.time - a.time : a.time !== null ? -1 : b.time !== null ? 1 : a.i - b.i));
-  if (!groupByYear) return [{ year: null, items: rows.map((r) => r.row) }];
-  const groups: DocumentGroup[] = [];
-  for (const r of rows) {
-    const last = groups[groups.length - 1];
-    if (last && last.year === r.year) last.items.push(r.row);
-    else groups.push({ year: r.year, items: [r.row] });
-  }
-  return groups;
-}
+/**
+ * The `documents` block's list logic: newest first (dated items by date, undated ones
+ * after, in the order given), an optional grouping by year, a file-type label from the
+ * extension, and a readable date. Pure — the component only renders the result.
+ */
+export interface DocumentItem {
+  title: string;
+  file: string;
+  date?: string;
+  note?: string;
+}
+export interface DocumentRow extends DocumentItem {
+  kind: string;
+  dateLabel?: string;
+}
+export interface DocumentGroup {
+  year: string | null;
+  items: DocumentRow[];
+}
+
+const KINDS: Record<string, string> = {
+  pdf: 'PDF', doc: 'Word', docx: 'Word', xls: 'Excel', xlsx: 'Excel', csv: 'CSV',
+  ppt: 'PowerPoint', pptx: 'PowerPoint', odt: 'Document', rtf: 'Document', txt: 'Text',
+  jpg: 'Image', jpeg: 'Image', png: 'Image', zip: 'ZIP',
+};
+
+export function fileKind(file: string): string {
+  const ext = file.split(/[?#]/)[0].split('.').pop()?.toLowerCase() ?? '';
+  return KINDS[ext] ?? 'File';
+}
+
+/** A YYYY-MM-DD date as "4 October 2026" (UTC, so it never shifts a day); else undefined. */
+export function longDate(d: string | undefined): string | undefined {
+  const t = parseDate(d);
+  return t ? t.toLocaleDateString('en-GB', { day: 'numeric', month: 'long', year: 'numeric', timeZone: 'UTC' }) : undefined;
+}
+
+/** A valid ISO-ish date (YYYY-MM-DD…) → a Date, else null. */
+function parseDate(d: string | undefined): Date | null {
+  if (!d || !/^\d{4}-\d{2}-\d{2}/.test(d)) return null;
+  const t = new Date(d.slice(0, 10) + 'T00:00:00Z');
+  return Number.isNaN(t.getTime()) ? null : t;
+}
+
+export function documentGroups(items: DocumentItem[], groupByYear = false): DocumentGroup[] {
+  const rows = items.map((item, i) => {
+    const d = parseDate(item.date);
+    return {
+      row: {
+        ...item,
+        kind: fileKind(item.file),
+        dateLabel: longDate(item.date),
+      } as DocumentRow,
+      time: d?.getTime() ?? null,
+      year: d ? String(d.getUTCFullYear()) : null,
+      i,
+    };
+  });
+  rows.sort((a, b) => (a.time !== null && b.time !== null ? b.time - a.time : a.time !== null ? -1 : b.time !== null ? 1 : a.i - b.i));
+  if (!groupByYear) return [{ year: null, items: rows.map((r) => r.row) }];
+  const groups: DocumentGroup[] = [];
+  for (const r of rows) {
+    const last = groups[groups.length - 1];
+    if (last && last.year === r.year) last.items.push(r.row);
+    else groups.push({ year: r.year, items: [r.row] });
+  }
+  return groups;
+}

package/lib/embed-consent.ts

@@ -1,73 +1,78 @@
-/**
- * Shared client-side loader for consent-gated third-party embeds (Google Calendar,
- * Google Maps, the Locations tiles). One implementation, so every embed gates,
- * loads and reacts to consent identically — instead of the same ~25-line script
- * copied into each component (where a fix, or a bug, lands in only one copy).
- *
- * Behaviour: nothing loads until the visitor consents. Accepting the site cookie
- * banner (or the footer preferences panel) grants the shared consent and
- * auto-loads EVERY registered embed on the page; the per-embed button is a
- * fallback that grants that same shared consent. Consent is remembered per
- * visitor. Import from a component `<script>` (it touches the DOM).
- *
- * Each embed root element carries the data the loader needs:
- *   data-embed-url   the https URL to load (required)
- *   data-title       the iframe title (optional)
- *   data-height      pixel height, for fixed-height embeds (optional)
- * and contains a `frame` slot (filled with the iframe), a `consent` card (hidden
- * once loaded) and a `button` that grants consent.
- */
-import { hasConsent, setConsent, onConsentChange } from './consent-client';
-
-export interface EmbedConsentConfig {
-  /** Selector for each embed root (one per embed on the page). */
-  root: string;
-  /** Selector, within a root, of the empty slot the iframe is injected into. */
-  frame: string;
-  /** Selector, within a root, of the consent card to hide once loaded. */
-  consent: string;
-  /** Selector, within a root, of the button that grants consent. */
-  button: string;
-  /** Build the iframe for one root — lets each embed set its own src / size / attrs. */
-  buildFrame: (el: HTMLElement, url: string) => HTMLIFrameElement;
-}
-
-/** Wire up every consent-gated embed matching `cfg.root`. Call once per component. */
-export function initEmbedConsent(cfg: EmbedConsentConfig): void {
-  const roots = document.querySelectorAll<HTMLElement>(cfg.root);
-  if (!roots.length) return;
-
-  function load(el: HTMLElement): void {
-    if (el.dataset.loaded === 'true') return;
-    const url = el.dataset.embedUrl;
-    const slot = el.querySelector<HTMLElement>(cfg.frame);
-    if (!url || !slot) return;
-    slot.replaceChildren(cfg.buildFrame(el, url));
-    el.dataset.loaded = 'true';
-    const card = el.querySelector<HTMLElement>(cfg.consent);
-    if (card) card.hidden = true;
-  }
-  const loadAll = (): void => roots.forEach(load);
-
-  if (hasConsent()) loadAll();
-  onConsentChange((allowed) => { if (allowed) loadAll(); });
-  roots.forEach((el) => {
-    el.querySelector<HTMLButtonElement>(cfg.button)?.addEventListener('click', () => setConsent(true));
-  });
-}
-
-/** Build a standard lazy embed iframe (100% width, 0 border). */
-export function makeEmbedFrame(
-  src: string,
-  opts: { title?: string; height?: string; referrer?: boolean } = {},
-): HTMLIFrameElement {
-  const f = document.createElement('iframe');
-  f.src = src;
-  if (opts.title) f.title = opts.title;
-  f.loading = 'lazy';
-  if (opts.referrer) f.referrerPolicy = 'no-referrer-when-downgrade';
-  f.style.width = '100%';
-  f.style.height = opts.height ?? '100%';
-  f.style.border = '0';
-  return f;
-}
+/**
+ * Shared client-side loader for consent-gated third-party embeds (Google Calendar,
+ * Google Maps, the Locations tiles). One implementation, so every embed gates,
+ * loads and reacts to consent identically — instead of the same ~25-line script
+ * copied into each component (where a fix, or a bug, lands in only one copy).
+ *
+ * Behaviour: nothing loads until the visitor consents. Accepting the site cookie
+ * banner (or the footer preferences panel) grants the shared consent and
+ * auto-loads EVERY registered embed on the page; the per-embed button is a
+ * fallback that grants that same shared consent. Consent is remembered per
+ * visitor. Import from a component `<script>` (it touches the DOM).
+ *
+ * Each embed root element carries the data the loader needs:
+ *   data-embed-url   the https URL to load (required)
+ *   data-title       the iframe title (optional)
+ *   data-height      pixel height, for fixed-height embeds (optional)
+ * and contains a `frame` slot (filled with the iframe), a `consent` card (hidden
+ * once loaded) and a `button` that grants consent.
+ */
+import { hasConsent, setConsent, onConsentChange } from './consent-client';
+
+export interface EmbedConsentConfig {
+  /** Selector for each embed root (one per embed on the page). */
+  root: string;
+  /** Selector, within a root, of the empty slot the iframe is injected into. */
+  frame: string;
+  /** Selector, within a root, of the consent card to hide once loaded. */
+  consent: string;
+  /** Selector, within a root, of the button that grants consent. */
+  button: string;
+  /** Build the iframe for one root — lets each embed set its own src / size / attrs. */
+  buildFrame: (el: HTMLElement, url: string) => HTMLIFrameElement;
+}
+
+/** Wire up every consent-gated embed matching `cfg.root`. Call once per component. */
+export function initEmbedConsent(cfg: EmbedConsentConfig): void {
+  const roots = document.querySelectorAll<HTMLElement>(cfg.root);
+  if (!roots.length) return;
+
+  function load(el: HTMLElement): void {
+    if (el.dataset.loaded === 'true') return;
+    const url = el.dataset.embedUrl;
+    const slot = el.querySelector<HTMLElement>(cfg.frame);
+    if (!url || !slot) return;
+    slot.replaceChildren(cfg.buildFrame(el, url));
+    el.dataset.loaded = 'true';
+    const card = el.querySelector<HTMLElement>(cfg.consent);
+    if (card) card.hidden = true;
+  }
+  // An embed marked `data-on-demand="true"` (e.g. a live stream that's often off air)
+  // never loads just because consent exists: only its own button loads it.
+  const loadAll = (): void => roots.forEach((el) => { if (el.dataset.onDemand !== 'true') load(el); });
+
+  if (hasConsent()) loadAll();
+  onConsentChange((allowed) => { if (allowed) loadAll(); });
+  roots.forEach((el) => {
+    el.querySelector<HTMLButtonElement>(cfg.button)?.addEventListener('click', () => {
+      setConsent(true);
+      if (el.dataset.onDemand === 'true') load(el);
+    });
+  });
+}
+
+/** Build a standard lazy embed iframe (100% width, 0 border). */
+export function makeEmbedFrame(
+  src: string,
+  opts: { title?: string; height?: string; referrer?: boolean } = {},
+): HTMLIFrameElement {
+  const f = document.createElement('iframe');
+  f.src = src;
+  if (opts.title) f.title = opts.title;
+  f.loading = 'lazy';
+  if (opts.referrer) f.referrerPolicy = 'no-referrer-when-downgrade';
+  f.style.width = '100%';
+  f.style.height = opts.height ?? '100%';
+  f.style.border = '0';
+  return f;
+}

package/lib/inline-markdown.ts

@@ -43,6 +43,12 @@ export function textWithBreaks(text: string | undefined | null): string {
   return text ? escapeHtml(text).replace(/\n/g, '<br>') : '';
 }
 
+/** Inline formatting (bold, italic, line breaks) WITHOUT links: `[label](href)` becomes
+ *  its label. For text inside something that is already a link (a linked tile or card). */
+export function inlineMarkdownNoLinks(text: string | undefined | null): string {
+  return text ? inlineFormat(escapeHtml(text.replace(LINK_RE, '$1'))) : '';
+}
+
 export function inlineMarkdown(text: string | undefined | null): string {
   if (!text) return '';
   let out = '';

package/lib/links.ts

@@ -0,0 +1,22 @@
+/**
+ * The icon a link deserves, read from the link itself — so an editor writes a phone
+ * number, an email or a web address and the row shows the right symbol without choosing.
+ */
+import type { IconKey } from './icons';
+
+export function linkIcon(href: string): IconKey {
+  if (/^tel:/i.test(href)) return 'phone';
+  if (/^mailto:/i.test(href)) return 'email';
+  if (/^https?:\/\//i.test(href)) return 'globe';
+  return 'arrow';
+}
+
+/** A tel: link from a number as an editor types it (spaces, brackets, a "(0)" dropped). */
+export function telHref(phone: string): string {
+  return 'tel:' + phone.replace(/\(0\)/g, '').replace(/[^\d+]/g, '');
+}
+
+/** A mailto: link, with an optional pre-filled subject. */
+export function mailtoHref(email: string, subject?: string): string {
+  return `mailto:${email}${subject ? `?subject=${encodeURIComponent(subject)}` : ''}`;
+}

package/lib/paginate.ts

@@ -0,0 +1,23 @@
+/**
+ * Pagination for post listings (the index and tag pages). Page 1 lives at the listing's
+ * own URL; later pages at `<base>/page/<n>`. Pure, unit-tested.
+ */
+export function pageCount(total: number, perPage: number): number {
+  return Math.max(1, Math.ceil(total / Math.max(1, perPage)));
+}
+
+export function pageSlice<T>(items: T[], page: number, perPage: number): T[] {
+  return items.slice((page - 1) * perPage, page * perPage);
+}
+
+export function pageHref(base: string, page: number): string {
+  return page <= 1 ? base : `${base}/page/${page}`;
+}
+
+/** Newer (prev) and older (next) page links, where they exist. */
+export function pagerLinks(base: string, page: number, pages: number): { prev?: string; next?: string } {
+  return {
+    prev: page > 1 ? pageHref(base, page - 1) : undefined,
+    next: page < pages ? pageHref(base, page + 1) : undefined,
+  };
+}

package/lib/posts.ts

@@ -13,6 +13,7 @@
  *   // <PostArticle ...><Content /></PostArticle>
  */
 import { getCollection, getEntry, type CollectionEntry } from 'astro:content';
+import { pageCount } from './paginate';
 import {
   postsSettingsSchema,
   tagSchema,
@@ -92,6 +93,23 @@ export async function getPostRoutes() {
 
 /** `getStaticPaths` for a tag route (`tags/[...tag].astro`). */
 export async function getTagRoutes() {
-  const tags = await getUsedTags();
-  return tags.map((tag) => ({ params: { tag: tag.slug }, props: { tag } }));
+  const [tags, settings] = await Promise.all([getUsedTags(), getPostsSettings()]);
+  // Page 1 at /posts/tag/<slug>; later pages at /posts/tag/<slug>/page/<n>.
+  return tags.flatMap((tag) => {
+    const pages = pageCount(tag.count, settings.perPage);
+    return Array.from({ length: pages }, (_, i) => ({
+      params: { tag: i === 0 ? tag.slug : `${tag.slug}/page/${i + 1}` },
+      props: { tag, page: i + 1, pages },
+    }));
+  });
+}
+
+/** `/posts/page/<n>` for n ≥ 2 (page 1 is `/posts` itself). */
+export async function getIndexPageRoutes() {
+  const [posts, settings] = await Promise.all([getIndexPosts(), getPostsSettings()]);
+  const pages = pageCount(posts.length, settings.perPage);
+  return Array.from({ length: Math.max(0, pages - 1) }, (_, i) => ({
+    params: { page: String(i + 2) },
+    props: { page: i + 2, pages },
+  }));
 }

package/lib/siteSettings.ts

@@ -1,60 +1,61 @@
-/**
- * Single accessor merging the site-settings content entries into one combined
- * object. Storage is split across small collections (identity+contact, logos,
- * navbar, footer, theme) so each is its own focused Sveltia CMS pane — see
- * `content/schemas.ts`. Consumers read one combined shape though, so this loader
- * re-assembles it (including the `navigation.primary` / `navigation.footer`
- * grouping) at read time — the only place that needs to know storage is split.
- *
- * `getEntry(...)` yields `data` typed per-collection when the entry exists, but
- * the content runtime doesn't always apply nested Zod defaults the way a plain
- * `schema.parse()` does. We re-parse each entry through its own schema so nested
- * defaults are fully populated, including when a file is missing.
- */
-import { getEntry } from 'astro:content';
-import {
-  footerSettingsSchema,
-  logoSettingsSchema,
-  navbarSettingsSchema,
-  siteSettingsSchema,
-  themeSettingsSchema,
-  type LogoSettings,
-  type NavLink,
-  type NavGroup,
-  type SiteSettings,
-  type ThemeSettings,
-} from '../content/schemas';
-
-export type LoadedSiteSettings = SiteSettings &
-  LogoSettings & {
-    navigation: { primary: NavLink[]; footer: NavLink[]; dropdown?: NavGroup };
-    /** Client-provided design-token overrides (empty objects if none). */
-    theme: ThemeSettings;
-  };
-
-let cached: LoadedSiteSettings | null = null;
-
-export async function loadSiteSettings(): Promise<LoadedSiteSettings> {
-  if (cached) return cached;
-
-  const [siteSettingsEntry, logoEntry, navbarEntry, footerEntry, themeEntry] = await Promise.all([
-    getEntry('siteSettings', 'index'),
-    getEntry('logoSettings', 'index'),
-    getEntry('navbarSettings', 'index'),
-    getEntry('footerSettings', 'index'),
-    getEntry('themeSettings', 'index'),
-  ]);
-
-  cached = {
-    ...siteSettingsSchema.parse(siteSettingsEntry?.data ?? {}),
-    ...logoSettingsSchema.parse(logoEntry?.data ?? {}),
-    navigation: {
-      primary: navbarSettingsSchema.parse(navbarEntry?.data ?? {}).primary,
-      footer: footerSettingsSchema.parse(footerEntry?.data ?? {}).footer,
-      dropdown: navbarSettingsSchema.parse(navbarEntry?.data ?? {}).dropdown,
-    },
-    theme: themeSettingsSchema.parse(themeEntry?.data ?? {}),
-  };
-
-  return cached;
-}
+/**
+ * Single accessor merging the site-settings content entries into one combined
+ * object. Storage is split across small collections (identity+contact, logos,
+ * navbar, footer, theme) so each is its own focused Sveltia CMS pane — see
+ * `content/schemas.ts`. Consumers read one combined shape though, so this loader
+ * re-assembles it (including the `navigation.primary` / `navigation.footer`
+ * grouping) at read time — the only place that needs to know storage is split.
+ *
+ * `getEntry(...)` yields `data` typed per-collection when the entry exists, but
+ * the content runtime doesn't always apply nested Zod defaults the way a plain
+ * `schema.parse()` does. We re-parse each entry through its own schema so nested
+ * defaults are fully populated, including when a file is missing.
+ */
+import { getEntry } from 'astro:content';
+import {
+  footerSettingsSchema,
+  logoSettingsSchema,
+  navbarSettingsSchema,
+  siteSettingsSchema,
+  themeSettingsSchema,
+  type LogoSettings,
+  type NavLink,
+  type NavGroup,
+  type SiteSettings,
+  type ThemeSettings,
+} from '../content/schemas';
+
+export type LoadedSiteSettings = SiteSettings &
+  LogoSettings & {
+    navigation: { primary: NavLink[]; footer: NavLink[]; dropdown?: NavGroup; cta: { label: string; href: string } | null };
+    /** Client-provided design-token overrides (empty objects if none). */
+    theme: ThemeSettings;
+  };
+
+let cached: LoadedSiteSettings | null = null;
+
+export async function loadSiteSettings(): Promise<LoadedSiteSettings> {
+  if (cached) return cached;
+
+  const [siteSettingsEntry, logoEntry, navbarEntry, footerEntry, themeEntry] = await Promise.all([
+    getEntry('siteSettings', 'index'),
+    getEntry('logoSettings', 'index'),
+    getEntry('navbarSettings', 'index'),
+    getEntry('footerSettings', 'index'),
+    getEntry('themeSettings', 'index'),
+  ]);
+
+  cached = {
+    ...siteSettingsSchema.parse(siteSettingsEntry?.data ?? {}),
+    ...logoSettingsSchema.parse(logoEntry?.data ?? {}),
+    navigation: {
+      primary: navbarSettingsSchema.parse(navbarEntry?.data ?? {}).primary,
+      footer: footerSettingsSchema.parse(footerEntry?.data ?? {}).footer,
+      dropdown: navbarSettingsSchema.parse(navbarEntry?.data ?? {}).dropdown,
+      cta: navbarSettingsSchema.parse(navbarEntry?.data ?? {}).cta,
+    },
+    theme: themeSettingsSchema.parse(themeEntry?.data ?? {}),
+  };
+
+  return cached;
+}

package/lib/slug.ts

@@ -0,0 +1,32 @@
+/**
+ * Readable anchor ids for headings and document sections (`/sacraments#confirmation`).
+ * `slugify` is pure; `uniqueSlug` de-duplicates within one page using a Set the caller
+ * keeps per request (Astro.locals), so two "Mass times" headings become `mass-times` and
+ * `mass-times-2`.
+ */
+export function slugify(text: string): string {
+  const s = text
+    .normalize('NFKD')
+    .replace(/[̀-ͯ]/g, '') // accents
+    .toLowerCase()
+    .replace(/['’]/g, '') // apostrophes join the word ("joachim's" → "joachims")
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 60)
+    .replace(/-+$/, '');
+  return s || 'section';
+}
+
+export function uniqueSlug(text: string, used: Set<string>): string {
+  const base = slugify(text);
+  let slug = base;
+  for (let n = 2; used.has(slug); n++) slug = `${base}-${n}`;
+  used.add(slug);
+  return slug;
+}
+
+/** The per-page Set of anchor ids already used, kept on Astro.locals. */
+export function pageSlugs(locals: unknown): Set<string> {
+  const bag = (locals ?? {}) as { __ferstSlugs?: Set<string> };
+  return (bag.__ferstSlugs ??= new Set<string>());
+}

package/lib/table.ts

@@ -0,0 +1,10 @@
+/**
+ * Which of a table's columns to show: those with content in at least one body row. A column
+ * that's empty everywhere (e.g. an unused "Evening") is dropped rather than shown blank.
+ * A header-only table keeps all its columns. Pure.
+ */
+export function filledColumns(columns: string[], rows: string[][]): number[] {
+  const all = columns.map((_, i) => i);
+  if (!rows.length) return all;
+  return all.filter((i) => rows.some((r) => (r[i] ?? '').trim() !== ''));
+}

package/lib/timetable.ts

@@ -0,0 +1,27 @@
+/**
+ * The `timetable` recipe's logic: which days a place actually has times on, and the
+ * rows of the side-by-side table (days down the side, a cell per place). Pure.
+ */
+export interface DaySchedule { day: string; times: string[] }
+export interface Place { name: string; schedule: DaySchedule[] }
+
+/** Only the days with at least one real time (blank strings don't count). */
+export function daysWithTimes(schedule: DaySchedule[]): DaySchedule[] {
+  return schedule
+    .map((d) => ({ day: d.day, times: d.times.map((t) => t.trim()).filter(Boolean) }))
+    .filter((d) => d.times.length > 0);
+}
+
+/** Table rows: every day some place uses, in first-seen order, with that day's times per place. */
+export function timetableRows(places: Place[]): Array<{ day: string; cells: string[][] }> {
+  const days: string[] = [];
+  const byPlace = places.map((p) => {
+    const map = new Map<string, string[]>();
+    for (const d of daysWithTimes(p.schedule)) {
+      map.set(d.day, d.times);
+      if (!days.includes(d.day)) days.push(d.day);
+    }
+    return map;
+  });
+  return days.map((day) => ({ day, cells: byPlace.map((m) => m.get(day) ?? []) }));
+}