@acms-subir/core 0.3.46 → 0.3.47

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @acms-subir/core
 
+## 0.3.47
+
+### Patch Changes
+
+- 26f2060: The public calendar can be filtered from its address, and speaks the page's language.
+
+  **Filters.** `/calendar?tag=Class` shows only classes, `/calendar?notag=Class&cal=events` shows the Events calendar without them, and `/calendar?room=chapel` shows what happens in a room. `tag` keeps events with any of its tags, `notag` (alias `excludeTag`) leaves them out, `cal` (alias `calendar`) now takes several calendars, and `room` takes room slugs. Each can repeat (`tag=a&tag=b`) or be comma-separated (`tag=a,b`); different filters must all match. Tags keep their rules (a name in any case, or its slug; internal `#` tags never match publicly). Only rooms shown on public events match, and a private calendar or a hidden room answers exactly like one that doesn't exist, so a link can't probe for them. Events from linked feed calendars and "Reserved" booking blocks have no tags: `tag` leaves them out, `notag` keeps them, and a room filter keeps a room's own Reserved blocks.
+
+  On `/calendar` the calendar chips now switch calendars on and off, so several can be picked; tags, left-out tags and rooms show as removable chips with **Clear filters**; and view links, chips and **Subscribe** keep the filters. A filtered page subscribes to `/calendar.ics` with the same filters (one calendar alone keeps its own feed). The same parameters work on `/embed/calendar/<slug|all>` (`cal` adds calendars to the one in the address), `/calendar.ics`, `/calendar/<slug>.ics` (`tag`, `notag`, `room`), `/api/v1/events` (now documented in the OpenAPI document; repeating them is allowed, other parameters still may not repeat) and `/api/calendar/events`, where a key with `events:read` also matches private calendars, every room and `#` tags. An unknown, private or hidden calendar or room is a 404 on the APIs and feeds, and an empty calendar with its chip on the page.
+
+  **Languages.** `/es/calendar` is in Spanish like event pages: the headings, chips, views, Subscribe menu, agenda, empty states, the grid's Today/Upcoming/Details and the dates and time zone. Event titles use their translations, and every link on the page (views, chips, events, cards) stays under `/es`. French, German and Portuguese work the same way. Embeds take `?lang=es` (one of the site's languages). The calendar card ("No calendar connected", "Calendar unavailable right now", "Open in Google Calendar") and event cards ("Untitled event", "No upcoming events") also speak their dates' language.
+
 ## 0.3.46
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acms-subir/core",
-  "version": "0.3.46",
+  "version": "0.3.47",
   "publishConfig": {
     "access": "public"
   },

package/src/lib/calendar/cards.ts

@@ -9,6 +9,7 @@ import { eventImage } from './images';
 import { eventUrl } from './config';
 import { eventIsPublic, featuredOccurrence, formatOccurrence, locationLine, type Occurrence } from './events';
 import { collectViewEvents } from './data';
+import type { ResolvedEventFilter } from './filter';
 
 export interface EventCardAttrs {
   mode: 'single' | 'upcoming';
@@ -56,7 +57,7 @@ export function eventCardHtml(
   return (
     `<article class="pc-ev-card${cancelled ? ' is-cancelled' : ''}">${media}<div class="pc-ev-card-body">` +
     `<div class="pc-ev-card-when">${cancelled ? `<span class="pc-ev-flag">${esc(eventStrings(siteLang(settings)).cancelled)}</span> ` : ''}${esc(when)}</div>` +
-    `<${h} class="pc-ev-card-title"><a href="${esc(href)}">${esc(e.title || 'Untitled event')}</a></${h}>` +
+    `<${h} class="pc-ev-card-title"><a href="${esc(href)}">${esc(e.title || eventStrings(siteLang(settings)).calendar.untitled)}</a></${h}>` +
     (e.excerpt ? `<p class="pc-ev-card-excerpt">${esc(e.excerpt)}</p>` : '') +
     (loc ? `<div class="pc-ev-card-loc">${esc(loc)}</div>` : '') +
     cta +
@@ -65,18 +66,19 @@ export function eventCardHtml(
 }
 
 // next occurrence of each distinct event, soonest first; tag/excludeTag
-// narrow by event tag (name or slug, any case)
+// narrow by event tag (name or slug, any case), and filter by an address's
+// cal/tag/notag/room (filter.ts); locale: titles and links in that language
 export async function upcomingEvents(
   repo: ContentRepository,
   settings: Settings,
   now: number,
-  opts: { calendarIds?: string[]; limit: number; horizonDays?: number; tag?: string; excludeTag?: string }
+  opts: { calendarIds?: string[]; limit: number; horizonDays?: number; tag?: string; excludeTag?: string; filter?: ResolvedEventFilter; locale?: string }
 ) {
   const tz = settings.timezone || 'UTC';
   const tagged = tagFilter(opts.tag, opts.excludeTag);
   const { events } = await collectViewEvents(repo, settings, {
     displayTz: tz, now, windowStartMs: now, windowEndMs: now + (opts.horizonDays ?? 400) * 86_400_000,
-  }, { audience: 'public', calendarIds: opts.calendarIds, includeFeeds: false });
+  }, { audience: 'public', calendarIds: opts.calendarIds, includeFeeds: false, filter: opts.filter, locale: opts.locale });
   const seen = new Set<string>();
   const out: Pick<Occurrence, 'event' | 'start' | 'end' | 'allDay' | 'days' | 'cancelled'>[] = [];
   for (const v of events) {
@@ -98,13 +100,14 @@ export async function renderEventCards(a: EventCardAttrs, repo: ContentRepositor
     if (!o) return wrap('<p class="pc-ev-empty">This event isn’t available.</p>', ' is-empty');
     return wrap(eventCardHtml(o, settings, { showImage: a.showImage, showCta: true }), ' is-single');
   }
+  const noUpcoming = eventStrings(siteLang(settings)).calendar.noUpcoming;
   let calendarIds: string[] | undefined;
   if (a.calendar) {
     const c = await repo.getCalendarBySlug(a.calendar);
-    if (!c || c.visibility === 'private') return wrap('<p class="pc-ev-empty">No upcoming events.</p>', ' is-empty');
+    if (!c || c.visibility === 'private') return wrap(`<p class="pc-ev-empty">${esc(noUpcoming)}</p>`, ' is-empty');
     calendarIds = [c.id];
   }
   const items = await upcomingEvents(repo, settings, now, { calendarIds, limit: a.limit });
-  if (!items.length) return wrap('<p class="pc-ev-empty">No upcoming events.</p>', ' is-empty');
+  if (!items.length) return wrap(`<p class="pc-ev-empty">${esc(noUpcoming)}</p>`, ' is-empty');
   return wrap(items.map((o) => eventCardHtml(o, settings, { showImage: a.showImage })).join(''));
 }

package/src/lib/calendar/data.ts

@@ -7,6 +7,10 @@ import { roomColor, type CalEvent, type Calendar, type Resource, type Settings }
 import { eventIsListed, eventIsPublic, expandEvents, safeColor } from './events';
 import { expandVEvents, loadFeed, tzParts, type CalendarEvent, type CalendarWindow } from './ics';
 import { CALENDAR, eventUrl, resourceUrl, withoutPrivateFields } from './config';
+import { occurrenceMatches, tagsMatch, untaggedMatches, type ResolvedEventFilter } from './filter';
+import { eventStrings } from './event-words';
+import { localePath } from '../i18n';
+import { localizeDoc } from '../translations';
 
 export interface ViewEvent extends CalendarEvent {
   url?: string;
@@ -34,6 +38,12 @@ export interface ViewScope {
   includeFeeds?: boolean;
   // "Reserved" blocks from resources set to show on the calendar
   includeBookings?: boolean;
+  // the address's cal/tag/notag/room (filter.ts); its calendars narrow
+  // calendarIds when both are given
+  filter?: ResolvedEventFilter;
+  // the request's language (requestLocale): translated titles, event links
+  // under its /<locale> prefix, and "Reserved" in its words
+  locale?: string;
 }
 
 const pad = (n: number) => String(n).padStart(2, '0');
@@ -46,7 +56,9 @@ export async function collectViewEvents(
 ): Promise<{ events: ViewEvent[]; calendars: Calendar[]; errors: string[] }> {
   const all = await repo.listCalendars();
   const byId = new Map(all.map((c) => [c.id, c]));
-  const requested = scope.calendarIds ? new Set(scope.calendarIds) : null;
+  const f = scope.filter;
+  const ids = scope.calendarIds && f?.calendarIds ? scope.calendarIds.filter((id) => f.calendarIds!.includes(id)) : scope.calendarIds ?? f?.calendarIds;
+  const requested = ids ? new Set(ids) : null;
   const visible = all.filter((c) => {
     if (scope.audience === 'admin') return true;
     // a directly requested calendar may be unlisted; private never is
@@ -60,6 +72,7 @@ export async function collectViewEvents(
   const source = scope.audience === 'admin' ? (await repo.listEvents()).filter((e) => e.status !== 'archived') : await repo.listPublishedEvents();
   const natives = source.filter((e) => {
     if (scope.audience === 'public' && !eventIsPublic(e, byId)) return false;
+    if (f && !tagsMatch(f, e.tags, { internal: f.internal })) return false;
     if (!e.calendarIds.length) {
       if (requested) return false;
       return scope.includeUncategorized ?? true;
@@ -73,39 +86,42 @@ export async function collectViewEvents(
   const shown = new Map<string, CalEvent>();
   const view = (e: CalEvent) => {
     if (scope.audience === 'admin') return e;
-    if (!shown.has(e.id)) shown.set(e.id, withoutPrivateFields(e));
+    if (!shown.has(e.id)) shown.set(e.id, withoutPrivateFields(localizeDoc(e, scope.locale)));
     return shown.get(e.id)!;
   };
   const resources = natives.some((e) => e.roomHold.resourceIds.length) ? new Map((await repo.listResources()).map((r) => [r.id, r])) : new Map<string, Resource>();
   const rooms = (ids: string[]) => ids.map((id) => resources.get(id))
     .filter((r): r is Resource => Boolean(r) && (scope.audience === 'admin' || r!.showOnEvents))
     .map((r) => ({ id: r.id, slug: r.slug, name: r.name, color: roomColor(r) }));
+  const words = eventStrings(scope.locale).calendar;
   for (const o of expandEvents(natives, settings, win)) {
-    const e = o.event;
+    // rooms are per date (a moved date can change them)
+    if (f?.roomIds && !occurrenceMatches(f, o)) continue;
+    const e = view(o.event);
     const cal = e.calendarIds.map((id) => byId.get(id)).find((c) => c && scoped.has(c.id));
     const p = tzParts(o.start, tz);
     const on = e.rrule ? `?on=${p.y}-${pad(p.m)}-${pad(p.d)}` : '';
     events.push({
       start: o.start, end: o.end, allDay: o.allDay, days: o.days,
-      title: e.title || 'Untitled event',
+      title: e.title || words.untitled,
       location: [e.location.name, e.location.address].filter(Boolean).join(', '),
       description: e.excerpt,
       cal: cal ? idx.get(cal.id) ?? 0 : 0,
       ref: e.id,
-      url: eventUrl(e.slug) + on,
+      url: localePath(eventUrl(e.slug), scope.locale ?? '') + on,
       color: cal ? safeColor(cal.color) : undefined,
       cancelled: o.cancelled,
       image: e.cover || undefined,
       imageAlt: e.coverAlt || undefined,
       calendarName: cal?.name,
-      event: view(e),
+      event: e,
       rooms: rooms(o.roomIds),
     });
   }
 
   const errors: string[] = [];
   if (scope.includeFeeds ?? true) {
-    const feeds = inScope.filter((c) => c.kind === 'feed' && c.feedUrl);
+    const feeds = inScope.filter((c) => c.kind === 'feed' && c.feedUrl && (!f || untaggedMatches(f, { calendarId: c.id })));
     const results = await Promise.all(
       feeds.map(async (c) => {
         try {
@@ -125,7 +141,7 @@ export async function collectViewEvents(
   // resources marked "show on calendar": confirmed bookings appear as
   // Reserved blocks (no guest names on public views) — only on unscoped views
   if (!requested && (scope.includeBookings ?? true) && CALENDAR.bookings) {
-    const resources = (await repo.listResources()).filter((r) => r.showOnCalendar);
+    const resources = (await repo.listResources()).filter((r) => r.showOnCalendar && (!f || untaggedMatches(f, { roomId: r.id })));
     if (resources.length) {
       const booked = await repo.listBookings({ from: win.windowStartMs, to: win.windowEndMs, statuses: ['confirmed'], kinds: ['booking'] });
       const byId = new Map(resources.map((r) => [r.id, r]));
@@ -135,7 +151,7 @@ export async function collectViewEvents(
         const allDay = b.end - b.start >= 86_400_000 - 3_600_000;
         events.push({
           start: b.start, end: b.end, allDay, days: allDay ? Math.max(1, Math.round((b.end - b.start) / 86_400_000)) : 1,
-          title: scope.audience === 'admin' ? `${r.name} · ${b.name}` : `Reserved · ${r.name}`,
+          title: scope.audience === 'admin' ? `${r.name} · ${b.name}` : `${words.reserved} · ${r.name}`,
           location: r.name, description: '', cal: inScope.length, color: '#8e919a', calendarName: r.name,
           url: scope.audience === 'public' ? resourceUrl(r.slug) : undefined,
         });

package/src/lib/calendar/event-words.ts

@@ -4,6 +4,8 @@
 // describeRepeat). Plain strings with {date} and {place} slots (live/words.ts
 // `fill`); the repeat line is built by functions, since word order differs
 // per language. No server imports: the event editor shares the repeat line.
+// `calendar` holds the words of the /calendar page, embeds and the calendar
+// card (render.ts).
 // The event's own words (title, button, fields) stay as written. Spanish
 // matches the push notices ("Cancelado el …"). Other languages fall back to
 // English.
@@ -35,6 +37,58 @@ export interface EventStrings {
   fullCalendar: string;
   allDay: string;
   repeat: RepeatWords;
+  calendar: CalendarWords;
+}
+
+/** The calendar page, its filters, embeds and the calendar card. */
+export interface CalendarWords {
+  title: string;
+  /** under the title; {site} is the site's name */
+  lede: string;
+  /** landmark labels */
+  calendars: string;
+  filters: string;
+  views: string;
+  nextTwoWeeks: string;
+  agenda: string;
+  /** the chip for every calendar */
+  all: string;
+  month: string;
+  week: string;
+  list: string;
+  /** a filter chip: "Without Class", "Room: Chapel" (a tag chip is the tag alone) */
+  without: string;
+  room: string;
+  /** the × on a chip, for screen readers */
+  remove: string;
+  clear: string;
+  subscribe: string;
+  subscribeAll: string;
+  subscribeNamed: string;
+  subscribeFiltered: string;
+  copyLink: string;
+  comingUp: string;
+  /** the footer: {zone} is "Eastern Daylight Time" in the page's language */
+  timesIn: string;
+  feedErrors: string;
+  empty: string;
+  emptySoon: string;
+  noMatch: string;
+  /** a confirmed booking on the public calendar: "Reserved · {room}" */
+  reserved: string;
+  untitled: string;
+  /** the grid's toolbar and pop-up */
+  today: string;
+  previous: string;
+  next: string;
+  upcoming: string;
+  noUpcoming: string;
+  details: string;
+  close: string;
+  /** the calendar card's own messages */
+  noSource: string;
+  unavailable: string;
+  openGoogle: string;
 }
 
 /** Weekdays are 0 = Sunday; `n` is the interval (every n days/weeks/months/years). */
@@ -90,6 +144,20 @@ const STRINGS: Record<string, EventStrings> = {
       until: (d) => `, until ${d}`,
       other: 'Repeats',
     },
+    calendar: {
+      title: 'Calendar', lede: 'What’s happening at {site}. Subscribe to keep it in your own calendar.',
+      calendars: 'Calendars', filters: 'Filters', views: 'View', nextTwoWeeks: 'Next two weeks', agenda: 'Agenda',
+      all: 'All', month: 'Month', week: 'Week', list: 'List',
+      without: 'Without {tag}', room: 'Room: {room}', remove: 'Remove {filter}', clear: 'Clear filters',
+      subscribe: 'Subscribe', subscribeAll: 'Add this calendar to your calendar app. New events show up on their own.',
+      subscribeNamed: 'Add “{name}” to your calendar app. New events show up on their own.',
+      subscribeFiltered: 'Add these events to your calendar app. New ones show up on their own.',
+      copyLink: 'Copy link', comingUp: 'Coming up', timesIn: 'Times in {zone}', feedErrors: 'Some linked calendars couldn’t be loaded right now.',
+      empty: 'Nothing on the calendar yet.', emptySoon: 'Nothing in the next two months.', noMatch: 'Nothing matches these filters.',
+      reserved: 'Reserved', untitled: 'Untitled event',
+      today: 'Today', previous: 'Previous', next: 'Next', upcoming: 'Upcoming', noUpcoming: 'No upcoming events.', details: 'Details', close: 'Close',
+      noSource: 'No calendar connected.', unavailable: 'Calendar unavailable right now.', openGoogle: 'Open in Google Calendar ↗',
+    },
   },
   es: {
     cancelled: 'Cancelado', eventCancelled: 'Este evento está cancelado.', eventCancelledNote: 'Lo dejamos en la lista para que nadie se quede con la duda.',
@@ -108,6 +176,20 @@ const STRINGS: Record<string, EventStrings> = {
       until: (d) => `, hasta el ${d}`,
       other: 'Se repite',
     },
+    calendar: {
+      title: 'Calendario', lede: 'Lo que pasa en {site}. Suscríbete para tenerlo en tu propio calendario.',
+      calendars: 'Calendarios', filters: 'Filtros', views: 'Vista', nextTwoWeeks: 'Próximas dos semanas', agenda: 'Agenda',
+      all: 'Todos', month: 'Mes', week: 'Semana', list: 'Lista',
+      without: 'Sin {tag}', room: 'Sala: {room}', remove: 'Quitar {filter}', clear: 'Quitar filtros',
+      subscribe: 'Suscribirse', subscribeAll: 'Agrega este calendario a tu app de calendario. Los eventos nuevos aparecen solos.',
+      subscribeNamed: 'Agrega “{name}” a tu app de calendario. Los eventos nuevos aparecen solos.',
+      subscribeFiltered: 'Agrega estos eventos a tu app de calendario. Los nuevos aparecen solos.',
+      copyLink: 'Copiar enlace', comingUp: 'Próximamente', timesIn: 'Horario de {zone}', feedErrors: 'Algunos calendarios vinculados no se pudieron cargar en este momento.',
+      empty: 'Todavía no hay nada en el calendario.', emptySoon: 'Nada en los próximos dos meses.', noMatch: 'Nada coincide con estos filtros.',
+      reserved: 'Reservado', untitled: 'Evento sin título',
+      today: 'Hoy', previous: 'Anterior', next: 'Siguiente', upcoming: 'Próximos', noUpcoming: 'No hay eventos próximos.', details: 'Detalles', close: 'Cerrar',
+      noSource: 'No hay ningún calendario conectado.', unavailable: 'El calendario no está disponible en este momento.', openGoogle: 'Abrir en Google Calendar ↗',
+    },
   },
   fr: {
     cancelled: 'Annulé', eventCancelled: 'Cet événement est annulé.', eventCancelledNote: 'Il reste affiché pour que personne ne se pose de questions.',
@@ -126,6 +208,20 @@ const STRINGS: Record<string, EventStrings> = {
       until: (d) => `, jusqu’au ${d}`,
       other: 'Récurrent',
     },
+    calendar: {
+      title: 'Calendrier', lede: 'Ce qui se passe à {site}. Abonnez-vous pour le retrouver dans votre propre calendrier.',
+      calendars: 'Calendriers', filters: 'Filtres', views: 'Affichage', nextTwoWeeks: 'Les deux prochaines semaines', agenda: 'Agenda',
+      all: 'Tous', month: 'Mois', week: 'Semaine', list: 'Liste',
+      without: 'Sans {tag}', room: 'Salle : {room}', remove: 'Retirer {filter}', clear: 'Effacer les filtres',
+      subscribe: 'S’abonner', subscribeAll: 'Ajoutez ce calendrier à votre application de calendrier. Les nouveaux événements s’y ajoutent d’eux-mêmes.',
+      subscribeNamed: 'Ajoutez « {name} » à votre application de calendrier. Les nouveaux événements s’y ajoutent d’eux-mêmes.',
+      subscribeFiltered: 'Ajoutez ces événements à votre application de calendrier. Les nouveaux s’y ajoutent d’eux-mêmes.',
+      copyLink: 'Copier le lien', comingUp: 'À venir', timesIn: 'Heures : {zone}', feedErrors: 'Certains calendriers liés n’ont pas pu être chargés pour le moment.',
+      empty: 'Rien au calendrier pour l’instant.', emptySoon: 'Rien dans les deux prochains mois.', noMatch: 'Rien ne correspond à ces filtres.',
+      reserved: 'Réservé', untitled: 'Événement sans titre',
+      today: 'Aujourd’hui', previous: 'Précédent', next: 'Suivant', upcoming: 'À venir', noUpcoming: 'Aucun événement à venir.', details: 'Détails', close: 'Fermer',
+      noSource: 'Aucun calendrier connecté.', unavailable: 'Calendrier indisponible pour le moment.', openGoogle: 'Ouvrir dans Google Agenda ↗',
+    },
   },
   de: {
     cancelled: 'Abgesagt', eventCancelled: 'Diese Veranstaltung ist abgesagt.', eventCancelledNote: 'Sie bleibt sichtbar, damit sich niemand wundert.',
@@ -144,6 +240,20 @@ const STRINGS: Record<string, EventStrings> = {
       until: (d) => `, bis zum ${d}`,
       other: 'Wiederkehrend',
     },
+    calendar: {
+      title: 'Kalender', lede: 'Was bei {site} los ist. Abonnieren Sie den Kalender, um alles in Ihrem eigenen Kalender zu haben.',
+      calendars: 'Kalender', filters: 'Filter', views: 'Ansicht', nextTwoWeeks: 'Die nächsten zwei Wochen', agenda: 'Terminliste',
+      all: 'Alle', month: 'Monat', week: 'Woche', list: 'Liste',
+      without: 'Ohne {tag}', room: 'Raum: {room}', remove: '{filter} entfernen', clear: 'Filter löschen',
+      subscribe: 'Abonnieren', subscribeAll: 'Fügen Sie diesen Kalender Ihrer Kalender-App hinzu. Neue Veranstaltungen erscheinen automatisch.',
+      subscribeNamed: 'Fügen Sie „{name}“ Ihrer Kalender-App hinzu. Neue Veranstaltungen erscheinen automatisch.',
+      subscribeFiltered: 'Fügen Sie diese Veranstaltungen Ihrer Kalender-App hinzu. Neue erscheinen automatisch.',
+      copyLink: 'Link kopieren', comingUp: 'Demnächst', timesIn: 'Zeiten in {zone}', feedErrors: 'Einige verknüpfte Kalender konnten gerade nicht geladen werden.',
+      empty: 'Noch nichts im Kalender.', emptySoon: 'In den nächsten zwei Monaten steht nichts an.', noMatch: 'Nichts passt zu diesen Filtern.',
+      reserved: 'Reserviert', untitled: 'Unbenannte Veranstaltung',
+      today: 'Heute', previous: 'Zurück', next: 'Weiter', upcoming: 'Demnächst', noUpcoming: 'Keine anstehenden Veranstaltungen.', details: 'Details', close: 'Schließen',
+      noSource: 'Kein Kalender verbunden.', unavailable: 'Kalender gerade nicht verfügbar.', openGoogle: 'In Google Kalender öffnen ↗',
+    },
   },
   pt: {
     cancelled: 'Cancelado', eventCancelled: 'Este evento foi cancelado.', eventCancelledNote: 'Ele continua na lista para que ninguém fique na dúvida.',
@@ -164,6 +274,20 @@ const STRINGS: Record<string, EventStrings> = {
       until: (d) => `, até ${d}`,
       other: 'Repete',
     },
+    calendar: {
+      title: 'Calendário', lede: 'O que acontece em {site}. Assine para ter tudo no seu próprio calendário.',
+      calendars: 'Calendários', filters: 'Filtros', views: 'Visualização', nextTwoWeeks: 'Próximas duas semanas', agenda: 'Agenda',
+      all: 'Todos', month: 'Mês', week: 'Semana', list: 'Lista',
+      without: 'Sem {tag}', room: 'Sala: {room}', remove: 'Remover {filter}', clear: 'Limpar filtros',
+      subscribe: 'Assinar', subscribeAll: 'Adicione este calendário ao seu app de calendário. Os novos eventos aparecem sozinhos.',
+      subscribeNamed: 'Adicione “{name}” ao seu app de calendário. Os novos eventos aparecem sozinhos.',
+      subscribeFiltered: 'Adicione estes eventos ao seu app de calendário. Os novos aparecem sozinhos.',
+      copyLink: 'Copiar link', comingUp: 'Em breve', timesIn: 'Horário de {zone}', feedErrors: 'Alguns calendários vinculados não puderam ser carregados agora.',
+      empty: 'Ainda não há nada no calendário.', emptySoon: 'Nada nos próximos dois meses.', noMatch: 'Nada corresponde a estes filtros.',
+      reserved: 'Reservado', untitled: 'Evento sem título',
+      today: 'Hoje', previous: 'Anterior', next: 'Próximo', upcoming: 'Próximos', noUpcoming: 'Nenhum evento programado.', details: 'Detalhes', close: 'Fechar',
+      noSource: 'Nenhum calendário conectado.', unavailable: 'Calendário indisponível no momento.', openGoogle: 'Abrir no Google Agenda ↗',
+    },
   },
 };
 

package/src/lib/calendar/feeds.ts

@@ -5,6 +5,7 @@ import type { CalEvent, Calendar, Settings } from '../schema';
 import { buildFeed } from './ics-write';
 import { eventIsListed, eventIsPublic } from './events';
 import { eventUrl } from './config';
+import { eventMatches, type ResolvedEventFilter } from './filter';
 
 export function icsResponse(body: string, filename: string, cacheSeconds = 300): Response {
   return new Response(body, {
@@ -21,15 +22,22 @@ export async function feedFor(
   repo: ContentRepository,
   settings: Settings,
   origin: string,
-  scope: { calendar?: Calendar; allowPrivate?: boolean }
+  // filter: the address's cal/tag/notag/room (filter.ts); its calendars
+  // stand in for `calendar` on the site-wide feed
+  scope: { calendar?: Calendar; allowPrivate?: boolean; filter?: ResolvedEventFilter }
 ): Promise<{ events: CalEvent[]; body: string }> {
   const [published, calendars] = await Promise.all([repo.listPublishedEvents(), repo.listCalendars()]);
   const map = new Map(calendars.map((c) => [c.id, c]));
   const c = scope.calendar;
+  const f = scope.filter;
   const events = published.filter((e) =>
-    c
+    (c
       ? e.calendarIds.includes(c.id) && (scope.allowPrivate || eventIsPublic(e, map) || c.visibility !== 'private')
-      : eventIsListed(e, map)
+      : f?.calendarIds
+        ? eventIsPublic(e, map)
+        : eventIsListed(e, map))
+    // a feed lists series, so rooms are the series' own
+    && (!f || eventMatches(f, e))
   );
   const host = new URL(origin).host;
   const body = buildFeed(events, settings.timezone, {

package/src/lib/calendar/filter.ts

@@ -0,0 +1,140 @@
+// Which events a calendar view shows, read from its address. The /calendar
+// page, embeds, /api/v1/events, /api/calendar/events, the subscribe feeds
+// and the TV display all take the same parameters and apply the same rules:
+//   cal=youth,events   only these calendars (slugs); `calendar` is an alias
+//   tag=Class          only events with one of these tags
+//   notag=Class        never events with any of these; `excludeTag` is an alias
+//   room=chapel        only events held in one of these rooms (resource slugs)
+// Each can repeat (tag=a&tag=b) or be comma-separated (tag=a,b). A list
+// matches any of its values; different parameters must all match. Tags keep
+// the hasTag rules (a name in any case, or its slug); internal "#" tags only
+// match with allowPrivate. Publicly, private calendars and rooms not shown on
+// public events resolve exactly like slugs that don't exist, so a link can't
+// probe for them.
+import { hasTag, publicTags, type CalEvent, type Calendar, type Resource } from '../schema';
+
+export interface EventFilter {
+  cal: string[];
+  tag: string[];
+  notag: string[];
+  room: string[];
+}
+
+export const NO_FILTER: EventFilter = Object.freeze({ cal: [], tag: [], notag: [], room: [] }) as EventFilter;
+
+const NAMES: Record<keyof EventFilter, string[]> = {
+  cal: ['cal', 'calendar'],
+  tag: ['tag'],
+  notag: ['notag', 'excludeTag'],
+  room: ['room'],
+};
+const MAX_VALUES = 20;
+const MAX_LENGTH = 100;
+
+/** the filter in an address's query (`Astro.url.searchParams`, `url.searchParams`) */
+export function readEventFilter(params: URLSearchParams): EventFilter {
+  const read = (names: string[]) => {
+    const out: string[] = [];
+    for (const name of names) for (const raw of params.getAll(name)) for (const part of raw.split(',')) {
+      const v = part.trim().slice(0, MAX_LENGTH);
+      if (v && out.length < MAX_VALUES && !out.some((o) => o.toLowerCase() === v.toLowerCase())) out.push(v);
+    }
+    return out;
+  };
+  return { cal: read(NAMES.cal), tag: read(NAMES.tag), notag: read(NAMES.notag), room: read(NAMES.room) };
+}
+
+export const hasEventFilter = (f: EventFilter) => f.cal.length + f.tag.length + f.notag.length + f.room.length > 0;
+
+/**
+ * The filter as a query string without the "?" ('' when empty), in the
+ * canonical names with comma-separated values: "cal=events&notag=Class".
+ * For links, subscribe feeds and API calls that should show the same events.
+ */
+export function eventFilterQuery(f: EventFilter): string {
+  return (Object.keys(NAMES) as (keyof EventFilter)[])
+    .filter((k) => f[k].length)
+    .map((k) => `${k}=${f[k].map(encodeURIComponent).join(',')}`)
+    .join('&');
+}
+
+export interface ResolvedEventFilter {
+  /** null: no calendar filter; [] when `cal` was given but none resolved (the view is then empty) */
+  calendarIds: string[] | null;
+  /** null: no room filter; [] when `room` was given but none resolved */
+  roomIds: string[] | null;
+  /** the calendars and rooms that resolved, in the order the address gave them */
+  calendars: Calendar[];
+  rooms: Resource[];
+  tag: string[];
+  notag: string[];
+  /** internal "#" tags match (allowPrivate) */
+  internal: boolean;
+  /** some `cal` or `room` value didn't resolve (unknown, private or hidden) */
+  unknown: boolean;
+}
+
+
+/**
+ * Turns slugs into ids. Publicly, unlisted calendars resolve (as a direct
+ * `?cal=` link always has) but private ones don't, and only rooms shown on
+ * public events resolve. allowPrivate (API keys with events:read, saved
+ * screens) resolves every calendar and room and lets "#" tags match.
+ */
+export function resolveEventFilter(
+  f: EventFilter,
+  ctx: { calendars: Calendar[]; resources?: Resource[]; allowPrivate?: boolean }
+): ResolvedEventFilter {
+  const allowPrivate = ctx.allowPrivate ?? false;
+  const pick = <T extends { id: string; slug: string }>(slugs: string[], items: T[], visible: (item: T) => boolean) => {
+    const found: T[] = [];
+    for (const s of slugs) {
+      const item = items.find((i) => i.slug === s.toLowerCase() && visible(i));
+      if (item && !found.includes(item)) found.push(item);
+    }
+    return found;
+  };
+  const calendars = pick(f.cal, ctx.calendars, (c) => allowPrivate || c.visibility !== 'private');
+  const rooms = pick(f.room, ctx.resources ?? [], (r) => allowPrivate || r.showOnEvents);
+  return {
+    calendarIds: f.cal.length ? calendars.map((c) => c.id) : null,
+    roomIds: f.room.length ? rooms.map((r) => r.id) : null,
+    calendars, rooms,
+    tag: f.tag, notag: f.notag,
+    internal: allowPrivate,
+    unknown: calendars.length < f.cal.length || rooms.length < f.room.length,
+  };
+}
+
+/** `tag` (any of them, when given) and no `notag`; "#" tags only count when internal */
+export function tagsMatch(f: Pick<EventFilter, 'tag' | 'notag'>, names: string[], opts: { internal?: boolean } = {}): boolean {
+  const shown = opts.internal ? names : publicTags(names);
+  return (!f.tag.length || f.tag.some((t) => hasTag(shown, t))) && !f.notag.some((t) => hasTag(shown, t));
+}
+
+const overlaps = (wanted: string[] | null, have: string[]) => wanted === null || have.some((id) => wanted.includes(id));
+
+/**
+ * Does one event pass? `roomIds` are the rooms the date holds: the event's
+ * room hold unless a moved date changed them. Visibility (drafts, private
+ * calendars) is the caller's job; this only applies the filter.
+ */
+export function eventMatches(r: ResolvedEventFilter, e: Pick<CalEvent, 'calendarIds' | 'tags' | 'roomHold'>, roomIds: string[] = e.roomHold.resourceIds): boolean {
+  return overlaps(r.calendarIds, e.calendarIds) && overlaps(r.roomIds, roomIds) && tagsMatch(r, e.tags, { internal: r.internal });
+}
+
+/** eventMatches for one occurrence, using the rooms that date holds */
+export function occurrenceMatches(r: ResolvedEventFilter, o: { event: Pick<CalEvent, 'calendarIds' | 'tags' | 'roomHold'>; roomIds?: string[] }): boolean {
+  return eventMatches(r, o.event, o.roomIds ?? o.event.roomHold.resourceIds);
+}
+
+/**
+ * Entries without an event (feed calendars, Reserved blocks) have no tags:
+ * `tag` leaves them out and `notag` keeps them. A Reserved block passes a
+ * room filter for its own room; feed entries never do.
+ */
+export function untaggedMatches(r: ResolvedEventFilter, opts: { calendarId?: string; roomId?: string } = {}): boolean {
+  if (r.tag.length) return false;
+  if (r.roomIds !== null && !(opts.roomId && r.roomIds.includes(opts.roomId))) return false;
+  return r.calendarIds === null || Boolean(opts.calendarId && r.calendarIds.includes(opts.calendarId));
+}