@acms-subir/core 0.3.56 → 0.3.58

package/src/components/editor/event/SingleDates.tsx

@@ -1,16 +1,32 @@
 import { useEffect, useState } from 'react';
 import { actions } from 'astro:actions';
 import { Section } from './Section';
+import { describeRepeat, rruleMap, WEEKDAY_CODES, weekdayOf } from '../../../lib/calendar/rrule';
 
 // Event settings → Single dates: the next dates of a saved repeating event,
-// each with Move… and Cancel (or Move back / Restore). These apply at once,
-// like on the Schedule, without touching unpublished edits: a moved date keeps
-// its sign-ups (they're emailed the new time) and its hosts
-// (lib/calendar/moves.ts). The list shows the event as saved.
+// each with Move…, From here on… and Cancel (or Move back / Restore). These
+// apply at once, like on the Schedule, without touching unpublished edits: a
+// moved date keeps its sign-ups (they're emailed the new time) and its hosts
+// (lib/calendar/moves.ts). From here on… changes the series from that date
+// on, and the dates before it stay (lib/calendar/segments.ts); the changes
+// are listed above the dates with Undo. The list shows the event as saved.
 
-interface DateRow { key: string; start: string; end: string; when: string; cancelled: boolean; moved: { from: string; note: string } | null; roomIds: string[] }
-interface Data { allDay: boolean; roomIds: string[]; dates: DateRow[]; rooms: { id: string; name: string }[] }
-interface Form { key: string; day: string; endDay: string; from: string; to: string; roomIds: string[]; note: string }
+interface DateRow { key: string; start: string; end: string; when: string; cancelled: boolean; partCancelled: boolean; moved: { from: string; note: string } | null; roomIds: string[] }
+interface SegmentRow { from: string; when: string; repeats: string; rooms: string[]; cancelled: boolean; note: string; current: boolean }
+interface Data { allDay: boolean; roomIds: string[]; dates: DateRow[]; rooms: { id: string; name: string }[]; segments: SegmentRow[] }
+interface Form { key: string; day: string; endDay: string; from: string; to: string; roomIds: string[]; note: string; following?: { rrule: string; keep: string } }
+
+// the repeats a change from a date on can take, for its first day: the rule
+// in effect moved there (`keep`), or a common one, ending as `keep` ends
+function repeatOptions(day: string, keep: string): { value: string; label: string }[] {
+  const wd = weekdayOf(day);
+  const code = WEEKDAY_CODES[wd.dow];
+  const p = rruleMap(keep);
+  const ends = p.COUNT ? `;COUNT=${p.COUNT}` : p.UNTIL ? `;UNTIL=${p.UNTIL}` : '';
+  const rules = [`FREQ=WEEKLY;BYDAY=${code}`, `FREQ=WEEKLY;INTERVAL=2;BYDAY=${code}`, `FREQ=MONTHLY;BYDAY=${wd.nth >= 5 ? -1 : wd.nth}${code}`, `FREQ=MONTHLY;BYMONTHDAY=${wd.day}`, 'FREQ=DAILY']
+    .map((r) => r + ends).filter((r) => r !== keep);
+  return [{ value: keep, label: `${describeRepeat(keep, day) || 'Same as now'} (as now)` }, ...rules.map((r) => ({ value: r, label: describeRepeat(r, day) })), { value: '', label: 'Just this date (no more after it)' }];
+}
 
 const datePart = (w: string) => w.slice(0, 10);
 const timePart = (w: string) => w.slice(11, 16);
@@ -54,15 +70,50 @@ export function SingleDates({ eventId, repeats }: { eventId: string; repeats: bo
     setNote({ text: warning ? `${done} ${warning}` : done });
     await load();
   };
+  // From here on…: the date's times, the rule in effect there and its rooms to start with
+  const openFollowing = async (d: DateRow) => {
+    setNote(null);
+    const r = await actions.events.fromDateDefaults({ id: eventId, key: d.key });
+    if (r.error || !r.data) { setNote({ text: r.error?.message ?? 'Couldn’t open that date.', error: true }); return; }
+    const x = r.data;
+    setForm({ key: d.key, day: datePart(x.start), endDay: datePart(x.end), from: timePart(x.start), to: timePart(x.end), roomIds: x.roomIds, note: '', following: { rrule: x.rrule, keep: x.rrule } });
+  };
   const save = (f: Form) => {
     const start = data.allDay ? f.day : `${f.day}T${f.from}`;
     // a time that ends before it starts runs past midnight
     const end = data.allDay ? (f.endDay >= f.day ? f.endDay : f.day) : `${f.to <= f.from ? nextDay(f.day) : f.day}T${f.to}`;
+    if (f.following) {
+      // the kept rule follows the new first day on the server; a chosen one is sent as it is
+      const rrule = f.following.rrule === f.following.keep ? undefined : f.following.rrule;
+      return run(f.key, async () => {
+        const r = await actions.events.changeFromDate({ id: eventId, key: f.key, start, end, rrule, roomIds: f.roomIds, note: f.note });
+        if (r.data && !r.data.changed) return { data: { warning: '' } };
+        return r;
+      }, 'Changed from this date on. Dates before it stay as they were, and people who signed up were emailed their new dates.');
+    }
     return run(f.key, () => actions.events.moveDate({ id: eventId, key: f.key, start, end, roomIds: f.roomIds, note: f.note }), 'Moved. People who signed up were emailed the new time.');
   };
 
   return (
-    <Section id="ev-dates" title="Single dates" help="Move or cancel one date. It applies at once, even on a published event, and people who signed up for it are emailed.">
+    <Section id="ev-dates" title="Single dates" help="Move or cancel one date, or change every date from one on. It applies at once, even on a published event, and people who signed up are emailed.">
+      {data.segments.length > 0 && (
+        <ul className="pe-evd pe-evd-segs">
+          {data.segments.map((g) => (
+            <li key={g.from} className={`pe-evd-row${g.cancelled ? ' is-cancelled' : ' is-moved'}`}>
+              <div className="pe-evd-main">
+                <span className="pe-evd-when">{g.cancelled ? `Cancelled from ${g.when}` : `From ${g.when}: ${g.repeats}`}</span>
+                {(g.rooms.length > 0 || g.note) && <small className="pe-evd-state">{[g.rooms.join(', '), g.note && `“${g.note}”`].filter(Boolean).join(' · ')}</small>}
+              </div>
+              {!g.current && (
+                <div className="pe-evd-acts">
+                  <button type="button" className="pe-btn sm" disabled={busy === g.from}
+                    onClick={() => { if (confirm(`Undo the change from ${g.when}? Those dates go back to the pattern before it, and people who signed up are emailed.`)) void run(g.from, () => actions.events.revertFromDate({ id: eventId, from: g.from }), 'Change undone.'); }}>Undo</button>
+                </div>
+              )}
+            </li>
+          ))}
+        </ul>
+      )}
       <ul className="pe-evd">
         {data.dates.map((d) => (
           <li key={d.key} className={`pe-evd-row${d.cancelled ? ' is-cancelled' : d.moved ? ' is-moved' : ''}`}>
@@ -72,11 +123,12 @@ export function SingleDates({ eventId, repeats }: { eventId: string; repeats: bo
               {d.moved && <small className="pe-evd-state">Moved from {d.moved.from}{d.moved.note ? ` · “${d.moved.note}”` : ''}</small>}
             </div>
             <div className="pe-evd-acts">
-              {d.cancelled ? (
+              {d.partCancelled ? null : d.cancelled ? (
                 <button type="button" className="pe-btn sm" disabled={busy === d.key} onClick={() => run(d.key, () => actions.events.cancelDate({ id: eventId, occurrence: d.key, restore: true }), 'Restored.')}>Restore</button>
               ) : (
                 <>
-                  <button type="button" className="pe-btn sm" onClick={() => (form?.key === d.key ? setForm(null) : open(d))} aria-expanded={form?.key === d.key}>Move…</button>
+                  <button type="button" className="pe-btn sm" onClick={() => (form?.key === d.key && !form.following ? setForm(null) : open(d))} aria-expanded={form?.key === d.key && !form.following}>Move…</button>
+                  <button type="button" className="pe-btn sm" onClick={() => (form?.key === d.key && form.following ? setForm(null) : void openFollowing(d))} aria-expanded={Boolean(form?.key === d.key && form.following)}>From here on…</button>
                   {d.moved && <button type="button" className="pe-btn sm" disabled={busy === d.key} onClick={() => run(d.key, () => actions.events.moveDateBack({ id: eventId, key: d.key }), 'Moved back. People who signed up were emailed.')}>Move back</button>}
                   <button type="button" className="pe-btn ghost sm" disabled={busy === d.key}
                     onClick={() => { if (confirm(`Cancel ${d.when}? It shows as cancelled straight away, and people who signed up are emailed.`)) void run(d.key, () => actions.events.cancelDate({ id: eventId, occurrence: d.key, restore: false }), 'Cancelled.'); }}>Cancel date</button>
@@ -86,7 +138,7 @@ export function SingleDates({ eventId, repeats }: { eventId: string; repeats: bo
             {form?.key === d.key && (
               <form className="pe-evd-form" onSubmit={(e) => { e.preventDefault(); void save(form); }}>
                 <div className="pe-evd-fields">
-                  <label className="pe-field"><span>{data.allDay ? 'From' : 'Date'}</span><input type="date" required value={form.day} onChange={(e) => setForm({ ...form, day: e.target.value })} /></label>
+                  <label className="pe-field"><span>{form.following ? 'First date' : data.allDay ? 'From' : 'Date'}</span><input type="date" required value={form.day} onChange={(e) => setForm({ ...form, day: e.target.value })} /></label>
                   {data.allDay ? (
                     <label className="pe-field"><span>To</span><input type="date" required value={form.endDay} min={form.day} onChange={(e) => setForm({ ...form, endDay: e.target.value })} /></label>
                   ) : (
@@ -96,9 +148,17 @@ export function SingleDates({ eventId, repeats }: { eventId: string; repeats: bo
                     </>
                   )}
                 </div>
+                {form.following && (
+                  <label className="pe-field"><span>Repeats</span>
+                    <select value={form.following.rrule} onChange={(e) => setForm({ ...form, following: { ...form.following!, rrule: e.target.value } })}>
+                      {repeatOptions(form.day, form.following.keep).map((o) => <option key={o.value} value={o.value}>{o.label}</option>)}
+                    </select>
+                  </label>
+                )}
+                {form.following && <p className="pe-evd-hint">The new first date can be in the same week as this one. Dates before it stay as they are. Sign-ups, cancelled and moved dates go to the nearest new date within 3½ days; sign-ups with none are cancelled. People are emailed.</p>}
                 {data.rooms.length > 0 && (
                   <fieldset className="pe-evd-rooms">
-                    <legend>Rooms for this date</legend>
+                    <legend>{form.following ? 'Rooms from then on' : 'Rooms for this date'}</legend>
                     {data.rooms.map((r) => (
                       <label key={r.id} className="pe-evd-room">
                         <input type="checkbox" checked={form.roomIds.includes(r.id)}
@@ -108,11 +168,11 @@ export function SingleDates({ eventId, repeats }: { eventId: string; repeats: bo
                     ))}
                   </fieldset>
                 )}
-                <label className="pe-field"><span>Note <em>shown with the date, optional</em></span>
-                  <input type="text" maxLength={500} value={form.note} placeholder="Moved for the youth retreat" onChange={(e) => setForm({ ...form, note: e.target.value })} />
+                <label className="pe-field"><span>Note <em>{form.following ? 'in the email to people who signed up, optional' : 'shown with the date, optional'}</em></span>
+                  <input type="text" maxLength={500} value={form.note} placeholder={form.following ? 'We meet on Wednesdays from now on' : 'Moved for the youth retreat'} onChange={(e) => setForm({ ...form, note: e.target.value })} />
                 </label>
                 <div className="pe-evd-formacts">
-                  <button type="submit" className="pe-btn primary sm" disabled={busy === form.key}>{busy === form.key ? 'Moving…' : 'Move this date'}</button>
+                  <button type="submit" className="pe-btn primary sm" disabled={busy === form.key}>{busy === form.key ? (form.following ? 'Changing…' : 'Moving…') : form.following ? 'Change from this date on' : 'Move this date'}</button>
                   <button type="button" className="pe-btn ghost sm" onClick={() => setForm(null)}>Never mind</button>
                 </div>
               </form>

package/src/lib/booking/service.ts

@@ -5,6 +5,7 @@ import { collectResponse, displayAnswers } from '../forms/service';
 // calendar immediately); the rest wait as "pending" for staff.
 import type { ContentRepository } from '../repo/types';
 import type { Booking, BookingLink, BookingStatus, CalEvent, Resource, Settings } from '../schema';
+import { roomName } from '../schema';
 import { loadFeed, expandVEvents } from '../calendar/ics';
 import { emitWebhook } from '../webhooks';
 import { parseFrom } from '../email/config';
@@ -108,8 +109,9 @@ async function describe(repo: ContentRepository, b: Booking, settings: Settings,
   const tz = resource ? resourceZone(resource, settings.timezone) : settings.timezone || 'UTC';
   return {
     resource, link, event: null as CalEvent | null, tz,
-    title: [resource?.name, link?.name].filter(Boolean).join(' · ') || 'Booking',
-    location: resource?.name ?? '',
+    // the room in the booking's language (its main name without one)
+    title: [resource && roomName(resource, locale), link?.name].filter(Boolean).join(' · ') || 'Booking',
+    location: resource ? roomName(resource, locale) : '',
     when: whenText(b, tz, settings, link?.mode === 'day'),
   };
 }

package/src/lib/calendar/api.ts

@@ -3,10 +3,11 @@
 // everywhere. Drafts, internal ids of private calendars, staging data and
 // private custom fields (unless a staff caller asks for them) never appear
 // here. Rooms are named only when set to show on public events (or for staff).
-import { roomColor, type CalEvent, type Calendar, type MovedDate, type Resource } from '../schema';
+import { roomColor, roomName, type CalEvent, type Calendar, type MovedDate, type Resource } from '../schema';
 import { calendarFeedUrl, eventIcsUrl, eventUrl, publicEventFields } from './config';
 import { describeRepeat } from './rrule';
 import { localizeForm } from '../forms/localize';
+import { currentPart, seriesParts } from './events';
 
 export interface EventJson {
   id: string;
@@ -23,7 +24,10 @@ export interface EventJson {
   allDay: boolean;
   timezone: string;
   rrule: string;
+  // the repeat in words for the part of the series in effect now (a segment's, once it took over)
   repeats: string;
+  // the series changed from a date on (CalEvent.segments), in order; [] = never
+  segments: SegmentJson[];
   exdates: string[];
   cancelledDates: string[];
   // single dates at another time, by original occurrence key: the new wall
@@ -44,6 +48,18 @@ export interface EventJson {
 }
 
 export interface RoomJson { slug: string; name: string; color: string | null }
+/** One segment of a series: from which date (an occurrence key), its first date, rule, words, rooms and place (null = the event's) */
+export interface SegmentJson {
+  from: string;
+  start: string;
+  end: string;
+  rrule: string;
+  repeats: string;
+  cancelled: boolean;
+  note: string;
+  location: Pick<CalEvent['location'], 'name' | 'address' | 'url'> | null;
+  rooms: RoomJson[];
+}
 export type PublicMovedDate = Pick<MovedDate, 'start' | 'end' | 'note'> & Partial<MovedDate>;
 
 /** moved dates as public data: where and why, not who */
@@ -51,11 +67,11 @@ export function movedDatesToJson(e: Pick<CalEvent, 'movedDates'>, includePrivate
   return Object.fromEntries(Object.entries(e.movedDates ?? {}).map(([k, m]) => [k, includePrivate ? m : { start: m.start, end: m.end, note: m.note }]));
 }
 
-/** Rooms as public data: only those set to show on public events, unless `includePrivate` (staff). Unknown ids are skipped. */
-export function roomsToJson(ids: string[], resources: Map<string, Resource> | undefined, includePrivate = false): RoomJson[] {
+/** Rooms as public data: only those set to show on public events, unless `includePrivate` (staff); named in `locale` when they have a name in it. Unknown ids are skipped. */
+export function roomsToJson(ids: string[], resources: Map<string, Resource> | undefined, includePrivate = false, locale?: string | null): RoomJson[] {
   if (!resources) return [];
   return ids.map((id) => resources.get(id)).filter((r): r is Resource => Boolean(r) && (includePrivate || r!.showOnEvents))
-    .map((r) => ({ slug: r.slug, name: r.name, color: roomColor(r) || null }));
+    .map((r) => ({ slug: r.slug, name: roomName(r, locale), color: roomColor(r) || null }));
 }
 
 const abs = (origin: string, path: string) => (/^https?:\/\//.test(path) ? path : origin + path);
@@ -68,7 +84,7 @@ const untilDate = (locale: string) => (ymd: string) => {
 };
 
 // resources: every room by id (rooms stay [] without it); locale: the
-// language of the repeat line ("Cada semana el sábado"; English without it)
+// language of the repeat line and the room names ("Cada semana el sábado"; English without it)
 export function eventToJson(e: CalEvent, origin: string, calendars: Map<string, Calendar>, siteTz = '', opts: { includePrivate?: boolean; resources?: Map<string, Resource>; locale?: string } = {}): EventJson {
   return {
     id: e.id,
@@ -85,8 +101,13 @@ export function eventToJson(e: CalEvent, origin: string, calendars: Map<string,
     allDay: e.allDay,
     timezone: e.timezone || siteTz || 'UTC',
     rrule: e.rrule,
-    repeats: describeRepeat(e.rrule, e.start, opts.locale ? untilDate(opts.locale) : undefined, opts.locale),
-    exdates: e.exdates,
+    // the part of the series in effect now (a change from a date on, once it took over), in the request's language
+    repeats: ((p) => describeRepeat(p.rrule, p.start, opts.locale ? untilDate(opts.locale) : undefined, opts.locale))(currentPart(e, { timezone: siteTz })),
+    segments: seriesParts(e).slice(1).map((p) => ({
+      from: p.from, start: p.start, end: p.end, rrule: p.rrule, repeats: describeRepeat(p.rrule, p.start, opts.locale ? untilDate(opts.locale) : undefined, opts.locale), cancelled: p.cancelled, note: p.note,
+      location: p.location ? { name: p.location.name, address: p.location.address, url: p.location.url } : null,
+      rooms: roomsToJson(p.roomIds, opts.resources, opts.includePrivate, opts.locale),
+    })),    exdates: e.exdates,
     cancelledDates: e.cancelledDates ?? [],
     movedDates: movedDatesToJson(e, opts.includePrivate),
     location: e.location,
@@ -100,7 +121,7 @@ export function eventToJson(e: CalEvent, origin: string, calendars: Map<string,
       .map((id) => calendars.get(id))
       .filter((c): c is Calendar => Boolean(c) && c!.visibility !== 'private')
       .map((c) => ({ id: c.id, slug: c.slug, name: c.name, color: c.color })),
-    rooms: roomsToJson(e.roomHold.resourceIds, opts.resources, opts.includePrivate),
+    rooms: roomsToJson(e.roomHold.resourceIds, opts.resources, opts.includePrivate, opts.locale),
     fields: opts.includePrivate ? e.fields : publicEventFields(e.fields),
     updatedAt: new Date(e.updatedAt).toISOString(),
   };

package/src/lib/calendar/board.ts

@@ -5,7 +5,7 @@
 import type { ContentRepository } from '../repo/types';
 import type { CalEvent, Settings } from '../schema';
 import { collectViewEvents } from './data';
-import { occurrenceKey, safeColor } from './events';
+import { occurrenceKey, partOf, safeColor } from './events';
 import { tzParts, zonedToUtc } from './ics';
 import { addDays, isIsoDay, type GridItem, type Iso } from './grid';
 import { bookingsEnabled } from './config';
@@ -134,7 +134,8 @@ export async function loadBoard(repo: ContentRepository, settings: Settings, fro
       calendarName: cal?.name ?? '',
       status: e ? eventBoardStatus(e) : 'feed',
       recurring: Boolean(e?.rrule),
-      repeat: e?.rrule ? describeRepeat(e.rrule, e.start) : '',
+      // the rule of the part of the series this date is in (CalEvent.segments)
+      repeat: e?.rrule ? ((p) => describeRepeat(p.rrule, p.start))(partOf(e, { segment: v.segment })) : '',
       rooms: e ? (v.rooms?.map((r) => r.id) ?? e.roomHold.resourceIds).map((id) => roomName.get(id)).filter((n): n is string => Boolean(n)) : [],
       roomsHeld: e ? holdsRooms(e) : false,
       occurrence,

package/src/lib/calendar/cards.ts

@@ -28,7 +28,7 @@ const esc = (s: string) =>
 export const safeHref = (h: string) => (/^(https?:\/\/|\/(?!\/)|mailto:|tel:|#)/i.test(h.trim()) ? h.trim() : '');
 
 export function eventCardHtml(
-  o: Pick<Occurrence, 'event' | 'start' | 'end' | 'allDay' | 'days'> & { cancelled?: boolean; moved?: Occurrence['moved'] },
+  o: Pick<Occurrence, 'event' | 'start' | 'end' | 'allDay' | 'days'> & { cancelled?: boolean; moved?: Occurrence['moved']; location?: Occurrence['location'] },
   settings: Settings,
   opts: { showImage: boolean; showCta?: boolean; href?: string; heading?: 'h2' | 'h3' }
 ): string {
@@ -48,7 +48,7 @@ export function eventCardHtml(
       ? `<a class="pc-ev-card-media" href="${esc(href)}" tabindex="-1" aria-hidden="true"><img src="${esc(image.src)}" alt="${esc(image.alt)}" loading="lazy" /></a>`
       : `<a class="pc-ev-card-media is-tile" href="${esc(href)}" tabindex="-1" aria-hidden="true"><span class="pc-ev-tile"><b>${esc(f.month)}</b><span>${esc(f.day)}</span></span></a>`
     : '';
-  const loc = locationLine(o.moved?.location ?? e.location);
+  const loc = locationLine(o.location ?? e.location);
   const ctaHref = safeHref(e.cta.href);
   const cta =
     opts.showCta && e.cta.label && ctaHref && !cancelled
@@ -80,11 +80,11 @@ export async function upcomingEvents(
     displayTz: tz, now, windowStartMs: now, windowEndMs: now + (opts.horizonDays ?? 400) * 86_400_000,
   }, { 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'> & Pick<Partial<Occurrence>, 'moved'> & Pick<ViewEvent, 'rooms'>)[] = [];
+  const out: (Pick<Occurrence, 'event' | 'start' | 'end' | 'allDay' | 'days' | 'cancelled'> & Pick<Partial<Occurrence>, 'moved' | 'location'> & Pick<ViewEvent, 'rooms'>)[] = [];
   for (const v of events) {
     if (!v.event || v.end <= now || seen.has(v.event.id) || !tagged(v.event.tags)) continue;
     seen.add(v.event.id);
-    out.push({ event: v.event, start: v.start, end: v.end, allDay: v.allDay, days: v.days, cancelled: Boolean(v.cancelled), ...(v.moved ? { moved: v.moved } : {}), rooms: v.rooms ?? [] });
+    out.push({ event: v.event, start: v.start, end: v.end, allDay: v.allDay, days: v.days, cancelled: Boolean(v.cancelled), ...(v.moved ? { moved: v.moved } : {}), ...(v.place ? { location: v.place } : {}), rooms: v.rooms ?? [] });
     if (out.length >= opts.limit) break;
   }
   return out;

package/src/lib/calendar/change-migration.ts

@@ -15,7 +15,8 @@
 //
 // Each migration's column lists are frozen: a later events column joins by a
 // new migration that recreates these triggers through eventChangeTriggers()
-// (the test that sorts every column fails until then). v66 added moved_dates.
+// (the test that sorts every column fails until then). v66 added moved_dates,
+// v70 segments.
 const now = "CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER)";
 
 // v65's lists
@@ -27,9 +28,9 @@ const V65_COLUMNS = ['slug', 'title', 'body_json', 'body_html', 'excerpt', 'cove
   'location', 'cta', 'calendar_ids', 'fields', 'rsvp', 'translations', 'room_hold', 'start_at', 'end_at'];
 
 /** the columns copied into each snapshot (what the webhook payload and push rules read) */
-export const EVENT_CHANGE_SNAPSHOT = [...V65_SNAPSHOT, 'moved_dates'];
+export const EVENT_CHANGE_SNAPSHOT = [...V65_SNAPSHOT, 'moved_dates', 'segments'];
 /** the columns whose change counts (published_at and scheduled_at follow status; room_hold names the rooms public data shows) */
-export const EVENT_CHANGE_COLUMNS = [...V65_COLUMNS, 'moved_dates'];
+export const EVENT_CHANGE_COLUMNS = [...V65_COLUMNS, 'moved_dates', 'segments'];
 /** columns no change is recorded for */
 export const EVENT_CHANGE_IGNORED = ['id', 'draft', 'host_ids', 'request', 'source_uid', 'published_at', 'scheduled_at', 'created_at', 'updated_at'];
 
@@ -88,3 +89,16 @@ export const MOVED_DATES_MIGRATION = (contentVersionUpdate: string) => ({ versio
   `DROP TRIGGER event_changes_delete`,
   ...eventChangeTriggers([...V65_SNAPSHOT, 'moved_dates'], [...V65_COLUMNS, 'moved_dates']),
 ] });
+
+// v70: a series changed from one date on (CalEvent.segments: its rule, times,
+// rooms and place from then), a column on the row like moved_dates: public,
+// so it bumps the content version and its changes are recorded
+export const SEGMENTS_MIGRATION = (contentVersionUpdate: string) => ({ version: 70, statements: [
+  `ALTER TABLE events ADD COLUMN segments TEXT NOT NULL DEFAULT '[]'`,
+  `DROP TRIGGER content_version_events_update`,
+  contentVersionUpdate,
+  `DROP TRIGGER event_changes_insert`,
+  `DROP TRIGGER event_changes_update`,
+  `DROP TRIGGER event_changes_delete`,
+  ...eventChangeTriggers([...V65_SNAPSHOT, 'moved_dates', 'segments'], [...V65_COLUMNS, 'moved_dates', 'segments']),
+] });

package/src/lib/calendar/data.ts

@@ -7,7 +7,7 @@
 // details, lib/display: published events only, private calendars when it
 // names them, bookings with the booker's name, never emails, phones or notes).
 import type { ContentRepository } from '../repo/types';
-import { roomColor, type BookingLink, type CalEvent, type Calendar, type Resource, type Settings } from '../schema';
+import { roomColor, roomName, type BookingLink, type CalEvent, type Calendar, type EventLocation, type Resource, type Settings } from '../schema';
 import { eventIsListed, eventIsPublic, eventRoomIds, expandEvents, locationLine, safeColor, type OccurrenceMove } from './events';
 import { expandVEvents, loadFeed, tzParts, type CalendarEvent, type CalendarWindow } from './ics';
 import { CALENDAR, eventUrl, resourceUrl, withoutPrivateFields } from './config';
@@ -31,6 +31,10 @@ export interface ViewEvent extends CalendarEvent {
   key?: string;
   // this date was moved here: where it was (UTC ms) and the public note
   moved?: OccurrenceMove;
+  // native events changed from a date on: the segment this date belongs to (its `from` key)
+  segment?: string;
+  // native events: the date's own place (moved there, or its segment's), when not the event's
+  place?: EventLocation;
 }
 
 // color: '#rrggbb', or '' when the room has none
@@ -103,7 +107,7 @@ export async function collectViewEvents(
   const rooms = (ids: string[]) => ids.map((id) => resources.get(id))
     // staff views and screens with private details name every room
     .filter((r): r is Resource => Boolean(r) && (scope.audience !== 'public' || r!.showOnEvents))
-    .map((r) => ({ id: r.id, slug: r.slug, name: r.name, color: roomColor(r) }));
+    .map((r) => ({ id: r.id, slug: r.slug, name: roomName(r, scope.locale), color: roomColor(r) }));
   const words = eventStrings(scope.locale).calendar;
   for (const o of expandEvents(natives, settings, win)) {
     // rooms are per date (a moved date can change them)
@@ -115,7 +119,8 @@ export async function collectViewEvents(
     events.push({
       start: o.start, end: o.end, allDay: o.allDay, days: o.days,
       title: e.title || words.untitled,
-      location: locationLine(o.moved?.location ?? e.location),
+      // the date's own place (moved there, or its segment's), else the event's
+      location: locationLine(o.location ?? e.location),
       description: e.excerpt,
       cal: cal ? idx.get(cal.id) ?? 0 : 0,
       ref: e.id,
@@ -129,6 +134,8 @@ export async function collectViewEvents(
       rooms: rooms(o.roomIds),
       key: o.key,
       ...(o.moved ? { moved: o.moved } : {}),
+      ...(o.segment ? { segment: o.segment } : {}),
+      ...(o.location ? { place: o.location } : {}),
     });
   }
 
@@ -169,14 +176,16 @@ export async function collectViewEvents(
         const r = byId.get(b.resourceId);
         if (!r) continue;
         const allDay = b.end - b.start >= 86_400_000 - 3_600_000;
+        // the room in the view's language (its main name without one)
+        const room = roomName(r, scope.locale);
         const title = scope.audience === 'admin' ? `${r.name} · ${b.name}`
-          : scope.audience === 'screen' ? [linkName.get(b.linkId) || r.name, b.name].filter(Boolean).join(' · ')
-          : `${words.reserved} · ${r.name}`;
+          : scope.audience === 'screen' ? [linkName.get(b.linkId) || room, b.name].filter(Boolean).join(' · ')
+          : `${words.reserved} · ${room}`;
         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, location: r.name, description: '', cal: inScope.length, color: '#8e919a', calendarName: r.name,
+          title, location: room, description: '', cal: inScope.length, color: '#8e919a', calendarName: room,
           url: scope.audience === 'public' ? resourceUrl(r.slug) : undefined,
-          rooms: [{ id: r.id, slug: r.slug, name: r.name, color: roomColor(r) }],
+          rooms: [{ id: r.id, slug: r.slug, name: room, color: roomColor(r) }],
         });
       }
     }

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

@@ -22,6 +22,9 @@ export interface EventStrings {
   moved: string;
   dateMoved: string;
   dateMovedNote: string;
+  /** the series changed from a date on (describeSeries): "From {date}: {repeat}", and every date cancelled from one on */
+  fromDate: string;
+  cancelledFrom: string;
   /** the side column's landmark label */
   details: string;
   joinOnline: string;
@@ -135,6 +138,7 @@ const STRINGS: Record<string, EventStrings> = {
     cancelled: 'Cancelled', eventCancelled: 'This event is cancelled.', eventCancelledNote: 'It stays listed so nobody is left wondering.',
     dateCancelled: 'Cancelled on {date}.', dateCancelledNote: 'Other dates go ahead as usual.',
     moved: 'Moved', dateMoved: 'Moved from {from}.', dateMovedNote: 'Other dates stay as usual.',
+    fromDate: 'From {date}: {repeat}', cancelledFrom: 'Cancelled from {date}',
     details: 'Event details', joinOnline: 'Join online', map: 'Map', directionsTo: 'Directions to {place}', mapOf: 'Map of {place}',
     directionsHere: 'Directions to the location', mapHere: 'Map of the location', showing: 'Showing {date}',
     addToCalendar: 'Add to calendar', downloadIcs: 'Download .ics', share: 'Share', linkCopied: 'Link copied',
@@ -168,6 +172,7 @@ const STRINGS: Record<string, EventStrings> = {
     cancelled: 'Cancelado', eventCancelled: 'Este evento está cancelado.', eventCancelledNote: 'Lo dejamos en la lista para que nadie se quede con la duda.',
     dateCancelled: 'Cancelado el {date}.', dateCancelledNote: 'Las demás fechas siguen como siempre.',
     moved: 'Cambio de horario', dateMoved: 'Cambió de horario: antes era el {from}.', dateMovedNote: 'Las demás fechas siguen como siempre.',
+    fromDate: 'Desde el {date}: {repeat}', cancelledFrom: 'Cancelado desde el {date}',
     details: 'Detalles del evento', joinOnline: 'Unirse en línea', map: 'Mapa', directionsTo: 'Cómo llegar a {place}', mapOf: 'Mapa de {place}',
     directionsHere: 'Cómo llegar al lugar', mapHere: 'Mapa del lugar', showing: 'Mostrando el {date}',
     addToCalendar: 'Agregar al calendario', downloadIcs: 'Descargar .ics', share: 'Compartir', linkCopied: 'Enlace copiado',
@@ -201,6 +206,7 @@ const STRINGS: Record<string, EventStrings> = {
     cancelled: 'Annulé', eventCancelled: 'Cet événement est annulé.', eventCancelledNote: 'Il reste affiché pour que personne ne se pose de questions.',
     dateCancelled: 'Annulé le {date}.', dateCancelledNote: 'Les autres dates sont maintenues.',
     moved: 'Déplacé', dateMoved: 'Déplacé : prévu initialement le {from}.', dateMovedNote: 'Les autres dates sont maintenues.',
+    fromDate: 'À partir du {date} : {repeat}', cancelledFrom: 'Annulé à partir du {date}',
     details: 'Détails de l’événement', joinOnline: 'Rejoindre en ligne', map: 'Carte', directionsTo: 'Itinéraire vers {place}', mapOf: 'Carte de {place}',
     directionsHere: 'Itinéraire vers le lieu', mapHere: 'Carte du lieu', showing: 'Date affichée : {date}',
     addToCalendar: 'Ajouter au calendrier', downloadIcs: 'Télécharger le .ics', share: 'Partager', linkCopied: 'Lien copié',
@@ -234,6 +240,7 @@ const STRINGS: Record<string, EventStrings> = {
     cancelled: 'Abgesagt', eventCancelled: 'Diese Veranstaltung ist abgesagt.', eventCancelledNote: 'Sie bleibt sichtbar, damit sich niemand wundert.',
     dateCancelled: 'Abgesagt am {date}.', dateCancelledNote: 'Die anderen Termine finden wie gewohnt statt.',
     moved: 'Verschoben', dateMoved: 'Verschoben: ursprünglich am {from}.', dateMovedNote: 'Die anderen Termine finden wie gewohnt statt.',
+    fromDate: 'Ab {date}: {repeat}', cancelledFrom: 'Abgesagt ab {date}',
     details: 'Veranstaltungsdetails', joinOnline: 'Online teilnehmen', map: 'Karte', directionsTo: 'Route zu {place}', mapOf: 'Karte von {place}',
     directionsHere: 'Route zum Ort', mapHere: 'Karte des Ortes', showing: 'Angezeigt: {date}',
     addToCalendar: 'Zum Kalender hinzufügen', downloadIcs: '.ics herunterladen', share: 'Teilen', linkCopied: 'Link kopiert',
@@ -267,6 +274,7 @@ const STRINGS: Record<string, EventStrings> = {
     cancelled: 'Cancelado', eventCancelled: 'Este evento foi cancelado.', eventCancelledNote: 'Ele continua na lista para que ninguém fique na dúvida.',
     dateCancelled: 'Cancelado em {date}.', dateCancelledNote: 'As outras datas continuam normalmente.',
     moved: 'Remarcado', dateMoved: 'Remarcado: antes era em {from}.', dateMovedNote: 'As outras datas continuam normalmente.',
+    fromDate: 'A partir de {date}: {repeat}', cancelledFrom: 'Cancelado a partir de {date}',
     details: 'Detalhes do evento', joinOnline: 'Participar on-line', map: 'Mapa', directionsTo: 'Como chegar a {place}', mapOf: 'Mapa de {place}',
     directionsHere: 'Como chegar ao local', mapHere: 'Mapa do local', showing: 'Exibindo {date}',
     addToCalendar: 'Adicionar ao calendário', downloadIcs: 'Baixar .ics', share: 'Compartilhar', linkCopied: 'Link copiado',