@acms-subir/core 0.3.49 → 0.3.51

package/src/lib/display/board.ts

@@ -0,0 +1,216 @@
+// One TV board, ready to render: which days it covers, which events it may
+// show, and when it goes stale. Quick links (/display/calendar?…) and saved
+// screens without private details show what calendar.ics shows: published
+// events in public calendars (or an unlisted one named in cal=). A saved
+// screen with private details on also shows private calendars it names, the
+// bookings of its rooms with the booker's name, the rooms and hosts of every
+// event. Never emails, phone numbers, notes or RSVP lists.
+import type { ContentRepository } from '../repo/types';
+import { roomColor, type Resource, type Settings } from '../schema';
+import { collectViewEvents, type ViewEvent } from '../calendar/data';
+import { eventFilterQuery, resolveEventFilter } from '../calendar/filter';
+import { tzParts, zonedToUtc } from '../calendar/ics';
+import { safeColor } from '../calendar/events';
+import { addDays, dayOfWeek, monthWeeks, startOfWeek, type Iso } from '../calendar/grid';
+import { siteLang, siteLocale } from '../dates';
+import { DEFAULT_HOURS, MIN_AUTO_HOURS, type DisplaySettings, type HourRange } from './settings';
+import { renderBoard, type DisplayItem, type DisplayModel, type DisplayRoom } from './render';
+import { displayStrings } from './words';
+import { qrSvg } from './http';
+
+export const GOOGLE_BOOKING_TAG = '#google-booking';
+const pad = (n: number) => String(n).padStart(2, '0');
+const isoOf = (p: { y: number; m: number; d: number }) => `${p.y}-${pad(p.m)}-${pad(p.d)}`;
+
+export interface DisplayRequest {
+  settings: DisplaySettings;
+  /** a saved screen with "Show private calendars and room bookings" on */
+  privateDetails: boolean;
+  /** the display's language ('' = the site's) */
+  lang: string;
+  now?: number;
+  /** show=qr: the calendar page phones open (origin + path); the board adds its public filter */
+  phoneLink?: string;
+}
+
+export interface DisplayBoard {
+  html: string;
+  /** when the board is stale (the next midnight, or the next now/next change) */
+  until: number;
+  tz: string;
+  locale: string;
+  lang: string;
+  rendered: number;
+}
+
+/** Dates in the display's language, in the site's region: es on an en-US site → es-US. */
+export function displayLocale(site: Pick<Settings, 'locale'>, lang: string): string {
+  if (!lang || lang === siteLang(site)) return siteLocale(site);
+  const region = siteLocale(site).split('-')[1];
+  const wanted = region ? `${lang}-${region}` : lang;
+  try { return Intl.DateTimeFormat.supportedLocalesOf([wanted]).length ? wanted : lang; } catch { return lang; }
+}
+
+const asRoom = (r: Resource): DisplayRoom => ({ id: r.id, slug: r.slug, name: r.name, color: roomColor(r) });
+
+/** the days a board covers, and (month) its weeks */
+export function boardDays(s: DisplaySettings, today: Iso, siteWeekStart: 0 | 1): { days: Iso[]; weeks: Iso[][] } {
+  const ws: 0 | 1 = s.start === 'mon' ? 1 : s.start === 'sun' ? 0 : siteWeekStart;
+  const pick = (from: Iso, n: number) => Array.from({ length: n }, (_, i) => addDays(from, i));
+  const narrow = (days: Iso[]) => ('weekdays' in s.days ? days.filter((d) => (s.days as { weekdays: number[] }).weekdays.includes(dayOfWeek(d))) : days);
+  if (s.view === 'week') {
+    const first = s.start === 'today' ? today : startOfWeek(today, ws);
+    const days = 'count' in s.days ? pick(first, Math.min(7, s.days.count)) : narrow(pick(first, 7));
+    return { days, weeks: [] };
+  }
+  if (s.view === 'list') return { days: 'count' in s.days ? pick(today, s.days.count) : narrow(pick(today, 7)), weeks: [] };
+  if (s.view === 'month') {
+    const weeks = monthWeeks(today.slice(0, 7), ws).map((w) => ('count' in s.days ? w.slice(0, Math.min(7, s.days.count)) : narrow(w)));
+    return { days: weeks.flat(), weeks };
+  }
+  return { days: [today], weeks: [] };
+}
+
+/** hours=auto: the shown events' hours, whole hours, never less than 6 */
+export function autoHours(items: Pick<DisplayItem, 'allDay' | 'startDay' | 'endDay' | 'startMin' | 'endMin'>[], days: Iso[]): HourRange {
+  const timed = items.filter((it) => !it.allDay && it.startDay === it.endDay && days.includes(it.startDay));
+  if (!timed.length) return { ...DEFAULT_HOURS };
+  let from = Math.floor(Math.min(...timed.map((it) => it.startMin)) / 60) * 60;
+  let to = Math.min(1440, Math.ceil(Math.max(...timed.map((it) => it.endMin)) / 60) * 60);
+  const min = MIN_AUTO_HOURS * 60;
+  if (to - from < min) {
+    to = Math.min(1440, from + min);
+    from = Math.max(0, to - min);
+  }
+  return { from, to };
+}
+
+export async function loadDisplayBoard(repo: ContentRepository, site: Settings, req: DisplayRequest): Promise<DisplayBoard> {
+  const s = req.settings;
+  const now = req.now ?? Date.now();
+  const tz = site.timezone || 'UTC';
+  const lang = req.lang || siteLang(site);
+  const locale = displayLocale(site, lang);
+  const words = displayStrings(lang);
+  const today = isoOf(tzParts(now, tz));
+  const midnight = (d: Iso) => zonedToUtc(+d.slice(0, 4), +d.slice(5, 7), +d.slice(8, 10), 0, 0, 0, tz);
+  const { days, weeks } = boardDays(s, today, site.calendar.weekStart);
+  const first = s.view === 'list' || s.view === 'next' ? today : days[0] ?? today;
+  const last = s.view === 'next' ? addDays(today, 1) : days[days.length - 1] ?? today;
+  const win = { displayTz: tz, now, windowStartMs: midnight(first), windowEndMs: midnight(addDays(last, 1)) };
+
+  const [calendars, resources] = await Promise.all([repo.listCalendars(), repo.listResources()]);
+  const filter = resolveEventFilter(s.filter, { calendars, resources, allowPrivate: req.privateDetails });
+  // `shownCalendars`: the calendars this audience may see, the only ones a board names
+  const { events, calendars: shownCalendars } = await collectViewEvents(repo, site, win, {
+    audience: req.privateDetails ? 'screen' : 'public',
+    filter,
+    // quick links show what calendar.ics shows: no subscribed feeds, no bookings
+    includeFeeds: req.privateDetails,
+    includeBookings: req.privateDetails,
+    // translated titles in the display's language
+    locale: lang,
+  });
+  // rooms visitors may see: the ones named on public events
+  const allowed = resources.filter((r) => req.privateDetails || r.showOnEvents);
+  const roomById = new Map(allowed.map((r) => [r.id, asRoom(r)]));
+  const calById = new Map(shownCalendars.map((c) => [c.id, c]));
+  // a person invited without a name has their email as one: never on a TV
+  const hostName = req.privateDetails && s.show.includes('host')
+    ? new Map((await repo.listUsers()).filter((u) => u.name.trim() && !u.name.includes('@')).map((u): [string, string] => [u.id, u.name.trim()]))
+    : new Map<string, string>();
+
+  const items = events.map((v, i) => displayItem(v, i, { tz, words, roomById, calById, hostName, privateDetails: req.privateDetails }));
+  const shown = new Set(days);
+  // a board only carries what it can show (the list: what hasn't ended)
+  const visible = items.filter((it) => {
+    if (s.view === 'list') return it.end > now && days.some((d) => it.startDay <= d && it.endDay >= d);
+    if (s.view === 'next') return it.end > now;
+    return [...shown].some((d) => it.startDay <= d && it.endDay >= d);
+  });
+
+  // view=rooms columns: the rooms the address names, in its order; otherwise
+  // every room the board may show (resources of kind "Room", else all)
+  let rooms: DisplayRoom[] = [];
+  if (s.view === 'rooms') {
+    if (filter.roomIds) rooms = filter.rooms.map(asRoom);
+    else {
+      const sorted = [...allowed].sort((a, b) => a.order - b.order || a.name.localeCompare(b.name));
+      const kindRoom = sorted.filter((r) => r.kind.trim().toLowerCase() === 'room');
+      rooms = (kindRoom.length ? kindRoom : sorted).map(asRoom);
+    }
+  }
+  const hours = s.hours === 'auto' ? autoHours(visible, days) : s.hours;
+
+  const legend: { name: string; color: string }[] = [];
+  for (const it of visible) {
+    const room = it.rooms.find((r) => r.color);
+    const entry = room ? { name: room.name, color: room.color } : it.calendar && it.color ? { name: shownCalendars.find((c) => c.slug === it.calendar)?.name ?? '', color: it.color } : null;
+    if (entry?.name && !legend.some((l) => l.name === entry.name)) legend.push(entry);
+  }
+
+  // the phone link shows the same events where the public calendar can: only
+  // calendars and rooms visitors may see, never "#" tags
+  let qr = '';
+  if (s.show.includes('qr') && req.phoneLink) {
+    const pub = resolveEventFilter(s.filter, { calendars, resources });
+    const query = eventFilterQuery({
+      cal: pub.calendars.map((c) => c.slug), room: pub.rooms.map((r) => r.slug),
+      tag: s.filter.tag.filter((t) => !t.trim().startsWith('#')), notag: s.filter.notag.filter((t) => !t.trim().startsWith('#')),
+    });
+    qr = qrSvg(req.phoneLink + (query ? `?${query}` : ''));
+  }
+
+  const model: DisplayModel = {
+    s, now, tz, locale, words, today, days, weeks, month: today.slice(0, 7), hours, items: visible, rooms, legend, midnight, qr,
+  };
+  let until = midnight(addDays(today, 1));
+  // now/next changes when the current event ends or the next one starts
+  if (s.view === 'next') for (const it of visible) for (const t of [it.start, it.end]) if (t > now && t < until) until = t;
+  return { html: renderBoard(model), until, tz, locale, lang, rendered: now };
+}
+
+interface ItemContext {
+  tz: string;
+  words: ReturnType<typeof displayStrings>;
+  roomById: Map<string, DisplayRoom>;
+  calById: Map<string, { id: string; slug: string; color: string }>;
+  hostName: Map<string, string>;
+  privateDetails: boolean;
+}
+
+function displayItem(v: ViewEvent, i: number, c: ItemContext): DisplayItem {
+  const local = (ms: number, endExclusive = false) => {
+    const p = tzParts(endExclusive ? ms - 1 : ms, c.tz);
+    return { day: isoOf(p), min: endExclusive ? p.hh * 60 + p.mm + 1 : p.hh * 60 + p.mm };
+  };
+  const s = local(v.start);
+  const e = local(Math.max(v.end, v.start + 60_000), true);
+  const startDay = s.day;
+  // all-day: its days, or (a booking of a day or more that isn't midnight to
+  // midnight) every day up to the one it ends on
+  const endDay = v.allDay ? [addDays(startDay, Math.max(1, v.days) - 1), e.day].sort().pop()! : e.day < s.day ? s.day : e.day;
+  // already in the display's language (collectViewEvents' locale)
+  const ev = v.event;
+  const booked = Boolean(ev?.tags.some((t) => t.trim().toLowerCase() === GOOGLE_BOOKING_TAG));
+  const rooms = v.rooms ?? (ev ? ev.roomHold.resourceIds.map((id) => c.roomById.get(id)).filter((r): r is DisplayRoom => Boolean(r)) : []);
+  const cal = ev ? ev.calendarIds.map((id) => c.calById.get(id)).find(Boolean) : undefined;
+  const moved = (v as ViewEvent & { moved?: { from: { start: number; end: number } } }).moved?.from ?? null;
+  return {
+    key: `${ev?.id ?? v.ref ?? 'x'}:${v.start}:${i}`,
+    kind: ev ? 'event' : v.rooms ? 'booking' : 'feed',
+    title: booked ? c.words.booked : v.title,
+    // under "Booked", a private screen also names the appointment
+    detail: booked && c.privateDetails ? v.title : '',
+    start: v.start, end: v.end, allDay: v.allDay,
+    startDay, endDay,
+    startMin: v.allDay ? 0 : s.min,
+    endMin: v.allDay ? 1440 : endDay === startDay ? e.min : 1440,
+    color: rooms.find((r) => r.color)?.color || (v.color ? safeColor(v.color) : ''),
+    rooms,
+    hosts: ev ? ev.hostIds.map((id) => c.hostName.get(id)).filter((n): n is string => Boolean(n)) : [],
+    cancelled: Boolean(v.cancelled),
+    moved,
+    calendar: cal?.slug ?? '',
+  };
+}

package/src/lib/display/http.ts

@@ -0,0 +1,35 @@
+// Response plumbing shared by the display routes.
+import qrcode from 'qrcode-generator';
+
+/**
+ * Display pages may be framed anywhere (signage players, other sites), are
+ * never indexed, and never send their address on: a saved screen's key is
+ * in it. Quick links may sit in a shared cache for a minute; saved screens
+ * never do (rotating a key must stop the old one at once).
+ */
+export function displayHeaders(h: Headers, opts: { shared: boolean }) {
+  h.set('Content-Security-Policy', 'frame-ancestors *');
+  h.set('Referrer-Policy', 'no-referrer');
+  h.set('X-Robots-Tag', 'noindex, nofollow');
+  h.set('Cache-Control', opts.shared ? 'public, max-age=60, s-maxage=60' : 'private, no-store');
+}
+
+/** A QR code for `text` as an inline SVG (one path, no styles of its own); '' when it's too long for one. */
+export function qrSvg(text: string): string {
+  const qr = qrcode(0, 'M');
+  qr.addData(text);
+  try { qr.make(); } catch { return ''; }
+  const n = qr.getModuleCount();
+  let d = '';
+  for (let y = 0; y < n; y++) {
+    for (let x = 0; x < n; x++) {
+      if (!qr.isDark(y, x)) continue;
+      // one run of dark modules per segment keeps the path short
+      let w = 1;
+      while (x + w < n && qr.isDark(y, x + w)) w++;
+      d += `M${x} ${y}h${w}v1h-${w}z`;
+      x += w - 1;
+    }
+  }
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="-2 -2 ${n + 4} ${n + 4}" shape-rendering="crispEdges" aria-hidden="true"><path fill="#000" d="${d}"/></svg>`;
+}