@remit/web-client 0.0.324 → 0.0.326

package/dist/src/hooks/calendar/instance.js

@@ -0,0 +1,145 @@
+import { isoOnClock } from "./window";
+/** The device's own clock, the only zone a browser can honestly draw in. */
+export const deviceTimeZone = () => Intl.DateTimeFormat().resolvedOptions().timeZone;
+/** A collection that names no zone of its own, spelled the way the API spells it. */
+export const UNZONED_CALENDAR = "";
+/**
+ * The zone a write anchors an event in: the collection's, or where it names
+ * none, the device's — a weekly 09:00 written from New York into an unzoned
+ * calendar would otherwise be stored in UTC and meet at 10:00 once the clocks
+ * change. UTC itself has no name the server takes as a TZID, so a device on it
+ * sends nothing, which the server reads as UTC.
+ */
+export function anchorZoneFor(collectionZone) {
+    if (collectionZone !== UNZONED_CALENDAR)
+        return collectionZone;
+    const device = deviceTimeZone();
+    return Intl.supportedValuesOf("timeZone").includes(device)
+        ? device
+        : UNZONED_CALENDAR;
+}
+const COLORS = {
+    Cal1: "cal-1",
+    Cal2: "cal-2",
+    Cal3: "cal-3",
+    Cal4: "cal-4",
+    Cal5: "cal-5",
+    Cal6: "cal-6",
+};
+const ZONES = {
+    Local: "local",
+    Explicit: "explicit",
+    Ambiguous: "ambiguous",
+};
+/**
+ * The address of one occurrence, as a single string, because the grid selects
+ * an event by one id. A series draws many occurrences from one resource, so the
+ * resource id alone would key every Monday standup the same and select all of
+ * them at once.
+ */
+const OCCURRENCE_SEPARATOR = "#";
+export function calendarInstanceId(calendarObjectId, recurrenceId) {
+    return recurrenceId === ""
+        ? calendarObjectId
+        : `${calendarObjectId}${OCCURRENCE_SEPARATOR}${recurrenceId}`;
+}
+export function readCalendarInstanceId(id) {
+    const cut = id.indexOf(OCCURRENCE_SEPARATOR);
+    if (cut === -1)
+        return { calendarObjectId: id, recurrenceId: "" };
+    return {
+        calendarObjectId: id.slice(0, cut),
+        recurrenceId: id.slice(cut + 1),
+    };
+}
+const nextOrFirst = (events, now) => {
+    const ordered = [...events].sort((a, b) => Date.parse(a.start) - Date.parse(b.start));
+    return (ordered.find((event) => Date.parse(event.end) > Date.parse(now)) ??
+        ordered[0]);
+};
+/**
+ * The occurrence a series opens at when the address names only the series: the
+ * next one still to finish, or the first in the window where none is left.
+ */
+export function seriesOccurrenceOf(events, calendarObjectId, now) {
+    const picked = nextOrFirst(events.filter((event) => {
+        const ref = readCalendarInstanceId(event.id);
+        return (ref.calendarObjectId === calendarObjectId && ref.recurrenceId !== "");
+    }), now);
+    return picked ? readCalendarInstanceId(picked.id) : undefined;
+}
+/**
+ * Where a view has to move to show an event it does not hold: the day of its
+ * next occurrence still to finish, or of its first where none is left.
+ */
+export function calendarJumpOf(instances, calendarObjectId, now, clockZone) {
+    const picked = nextOrFirst(instances
+        .filter((instance) => instance.calendarObjectId === calendarObjectId &&
+        isDrawnInstance(instance))
+        .map((instance) => toCalendarEventData(instance, "", clockZone)), now);
+    if (!picked)
+        return undefined;
+    return {
+        ...readCalendarInstanceId(picked.id),
+        calendarId: picked.calendarId,
+        date: picked.start.slice(0, 10),
+    };
+}
+export function toCalendarDescriptor(calendar) {
+    return {
+        id: calendar.calendarId,
+        accountId: calendar.accountConfigId,
+        accountLabel: "",
+        name: calendar.displayName,
+        color: COLORS[calendar.color] ?? "cal-1",
+        ...(calendar.source === "Subscribed"
+            ? {
+                readOnly: true,
+                sync: calendar.subscriptionEnabled ? "live" : "paused",
+                syncError: calendar.subscriptionError,
+            }
+            : {}),
+    };
+}
+/**
+ * One occurrence, drawn. `location`, `notes` and the guest list are projections
+ * the listing does not carry — the reading pane fetches the resource itself for
+ * those, and a grid chip has no room for them anyway.
+ *
+ * A timed occurrence is re-read on `clockZone`, the clock every surface draws
+ * on. An all-day one is a civil date and keeps only its date: midnight with an
+ * offset is an instant, and a device west of it reads that instant as the day
+ * before.
+ */
+export function toCalendarEventData(instance, timeZone, clockZone) {
+    return {
+        id: calendarInstanceId(instance.calendarObjectId, instance.recurrenceId),
+        calendarId: instance.calendarId,
+        title: instance.summary,
+        start: instance.allDay
+            ? instance.start.slice(0, 10)
+            : isoOnClock(instance.start, clockZone),
+        end: instance.allDay
+            ? instance.end.slice(0, 10)
+            : isoOnClock(instance.end, clockZone),
+        allDay: instance.allDay,
+        location: "",
+        notes: "",
+        attendees: [],
+        myRsvp: "accepted",
+        threadId: "",
+        threadSubject: "",
+        timeZone,
+        zoneCertainty: ZONES[instance.zoneCertainty] ?? "explicit",
+        recurrenceRule: instance.hasRecurrence ? "Repeats" : "",
+        seriesId: instance.hasRecurrence ? instance.icalUid : "",
+        seriesException: false,
+        status: instance.status === "Tentative" ? "tentative" : "confirmed",
+    };
+}
+/**
+ * A cancelled occurrence is not a lighter shade of confirmed, and the kit has
+ * no third state to draw it in, so it is left off the calendar entirely rather
+ * than shown as an event that is still happening.
+ */
+export const isDrawnInstance = (instance) => instance.status !== "Cancelled";

package/dist/src/hooks/calendar/recurrence-rule.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Repeat rules, between the sentence a person picks and the RRULE the API
+ * stores.
+ *
+ * The kit's picker deals only in sentences — "Every weekday, 09:15" — and the
+ * calendar API deals only in RFC 5545 rules. This is the single table read both
+ * ways, so a rule this client wrote reads back as the sentence it was picked
+ * from. A rule written by anything else, a native client or an invitation, is
+ * not forced into one of these sentences: it comes back unread, and the surface
+ * says the event repeats without claiming to know how.
+ */
+/**
+ * The RRULE a picked sentence means, or `undefined` for a sentence this table
+ * does not cover. A caller refuses the write rather than storing a rule it
+ * guessed at.
+ */
+export declare function rruleFromText(text: string): string | undefined;
+/** The sentence an RRULE was picked from, or `undefined` where it was not. */
+export declare function textFromRrule(rule: string, startTime: string): string | undefined;
+/**
+ * A rule picked on one civil date, rewritten for the same moment read on
+ * another. The picker offers rules off the day the device shows, and the
+ * server expands them on the day the event's own zone shows; 21:00 on a New
+ * York Sunday is a Tokyo Monday, so "every Sunday" has to be stored as BYDAY=MO
+ * or the series lands on Saturday evenings. Weekdays shift with the day; a
+ * monthly or yearly position is read off the new date itself, because the day
+ * after the second Wednesday is not always the second Thursday.
+ */
+export declare function moveRule(rule: string, fromDate: string, toDate: string): string;

package/dist/src/hooks/calendar/recurrence-rule.js

@@ -0,0 +1,159 @@
+/**
+ * Repeat rules, between the sentence a person picks and the RRULE the API
+ * stores.
+ *
+ * The kit's picker deals only in sentences — "Every weekday, 09:15" — and the
+ * calendar API deals only in RFC 5545 rules. This is the single table read both
+ * ways, so a rule this client wrote reads back as the sentence it was picked
+ * from. A rule written by anything else, a native client or an invitation, is
+ * not forced into one of these sentences: it comes back unread, and the surface
+ * says the event repeats without claiming to know how.
+ */
+const WEEKDAYS = [
+    "Sunday",
+    "Monday",
+    "Tuesday",
+    "Wednesday",
+    "Thursday",
+    "Friday",
+    "Saturday",
+];
+const BYDAY = ["SU", "MO", "TU", "WE", "TH", "FR", "SA"];
+const MONTHS = [
+    "January",
+    "February",
+    "March",
+    "April",
+    "May",
+    "June",
+    "July",
+    "August",
+    "September",
+    "October",
+    "November",
+    "December",
+];
+const ORDINALS = ["first", "second", "third", "fourth", "last"];
+const ORDINAL_NUMBERS = [1, 2, 3, 4, -1];
+const WEEKDAY_SET = "MO,TU,WE,TH,FR";
+/** The clock the picker appends, stripped so the rule itself can be read. */
+const withoutClock = (text) => text.replace(/,\s*\d{2}:\d{2}$/, "").trim();
+/**
+ * The RRULE a picked sentence means, or `undefined` for a sentence this table
+ * does not cover. A caller refuses the write rather than storing a rule it
+ * guessed at.
+ */
+export function rruleFromText(text) {
+    const rule = withoutClock(text);
+    if (rule === "")
+        return "";
+    if (rule === "Every day")
+        return "FREQ=DAILY";
+    if (rule === "Every weekday")
+        return `FREQ=WEEKLY;BYDAY=${WEEKDAY_SET}`;
+    const weekly = rule.match(/^Every week on (\w+)$/);
+    if (weekly) {
+        const day = WEEKDAYS.indexOf(weekly[1]);
+        return day === -1 ? undefined : `FREQ=WEEKLY;BYDAY=${BYDAY[day]}`;
+    }
+    const monthly = rule.match(/^Every month on the (\w+) (\w+)$/);
+    if (monthly) {
+        const ordinal = ORDINALS.indexOf(monthly[1]);
+        const day = WEEKDAYS.indexOf(monthly[2]);
+        if (ordinal === -1 || day === -1)
+            return undefined;
+        return `FREQ=MONTHLY;BYDAY=${ORDINAL_NUMBERS[ordinal]}${BYDAY[day]}`;
+    }
+    const yearly = rule.match(/^Every year on (\d{1,2}) (\w+)$/);
+    if (yearly) {
+        const month = MONTHS.indexOf(yearly[2]);
+        if (month === -1)
+            return undefined;
+        return `FREQ=YEARLY;BYMONTH=${month + 1};BYMONTHDAY=${Number(yearly[1])}`;
+    }
+    return undefined;
+}
+const clockSuffix = (startTime) => startTime === "" ? "" : `, ${startTime}`;
+/** The sentence an RRULE was picked from, or `undefined` where it was not. */
+export function textFromRrule(rule, startTime) {
+    const parts = new Map(rule
+        .split(";")
+        .map((part) => part.split("="))
+        .filter((pair) => pair.length === 2)
+        .map(([name, value]) => [name.toUpperCase(), value.toUpperCase()]));
+    const clock = clockSuffix(startTime);
+    const frequency = parts.get("FREQ");
+    const byDay = parts.get("BYDAY");
+    if (parts.has("INTERVAL") && parts.get("INTERVAL") !== "1")
+        return undefined;
+    if (parts.has("UNTIL") || parts.has("COUNT"))
+        return undefined;
+    if (frequency === "DAILY")
+        return `Every day${clock}`;
+    if (frequency === "WEEKLY") {
+        if (byDay === undefined)
+            return undefined;
+        if (byDay === WEEKDAY_SET)
+            return `Every weekday${clock}`;
+        const day = BYDAY.indexOf(byDay);
+        return day === -1 ? undefined : `Every week on ${WEEKDAYS[day]}${clock}`;
+    }
+    if (frequency === "MONTHLY") {
+        const match = byDay?.match(/^(-?\d)([A-Z]{2})$/);
+        if (!match)
+            return undefined;
+        const ordinal = ORDINAL_NUMBERS.indexOf(Number(match[1]));
+        const day = BYDAY.indexOf(match[2]);
+        if (ordinal === -1 || day === -1)
+            return undefined;
+        return `Every month on the ${ORDINALS[ordinal]} ${WEEKDAYS[day]}${clock}`;
+    }
+    if (frequency === "YEARLY") {
+        const month = Number(parts.get("BYMONTH"));
+        const day = Number(parts.get("BYMONTHDAY"));
+        if (!month || !day || month > 12)
+            return undefined;
+        return `Every year on ${day} ${MONTHS[month - 1]}${clock}`;
+    }
+    return undefined;
+}
+const dayNumber = (date) => Date.parse(`${date}T00:00:00Z`) / 86_400_000;
+/**
+ * A rule picked on one civil date, rewritten for the same moment read on
+ * another. The picker offers rules off the day the device shows, and the
+ * server expands them on the day the event's own zone shows; 21:00 on a New
+ * York Sunday is a Tokyo Monday, so "every Sunday" has to be stored as BYDAY=MO
+ * or the series lands on Saturday evenings. Weekdays shift with the day; a
+ * monthly or yearly position is read off the new date itself, because the day
+ * after the second Wednesday is not always the second Thursday.
+ */
+export function moveRule(rule, fromDate, toDate) {
+    const shift = dayNumber(toDate) - dayNumber(fromDate);
+    if (rule === "" || shift === 0 || Number.isNaN(shift))
+        return rule;
+    const [year, month, dayOfMonth] = toDate.split("-").map(Number);
+    const weekday = new Date(Date.UTC(year, month - 1, dayOfMonth)).getUTCDay();
+    const frequency = /FREQ=(\w+)/i.exec(rule)?.[1]?.toUpperCase();
+    return rule
+        .split(";")
+        .map((part) => {
+        const [name, value = ""] = part.split("=");
+        const key = name.toUpperCase();
+        if (key === "BYDAY" && frequency === "MONTHLY")
+            return `BYDAY=${ORDINAL_NUMBERS[Math.min(Math.floor((dayOfMonth - 1) / 7), 4)]}${BYDAY[weekday]}`;
+        if (key === "BYDAY")
+            return `BYDAY=${value
+                .split(",")
+                .map((code) => {
+                const index = BYDAY.indexOf(code.toUpperCase());
+                return index === -1 ? code : BYDAY[(index + shift + 7) % 7];
+            })
+                .join(",")}`;
+        if (key === "BYMONTH")
+            return `BYMONTH=${month}`;
+        if (key === "BYMONTHDAY")
+            return `BYMONTHDAY=${dayOfMonth}`;
+        return part;
+    })
+        .join(";");
+}

package/dist/src/hooks/calendar/resource.d.ts

@@ -0,0 +1,14 @@
+export declare const rruleFromIcalData: (icalData: string) => string;
+export interface CalendarResourceText {
+    location: string;
+    description: string;
+}
+export declare const textFromIcalData: (icalData: string) => CalendarResourceText;
+/**
+ * The zone an edit writes an existing event back in: the one its master's
+ * DTSTART is stored in. A UTC start stays UTC (`""`), a floating one stays in
+ * the collection's zone, and a TZID nothing can resolve is read the way the
+ * server reads it, in the collection's zone. Only a resource with no DTSTART
+ * falls back to where a new event would be anchored.
+ */
+export declare function storedAnchorZone(icalData: string, collectionZone: string): string;

package/dist/src/hooks/calendar/resource.js

@@ -0,0 +1,87 @@
+import { anchorZoneFor } from "./instance";
+/**
+ * The few properties a reading pane needs that the occurrence listing does not
+ * carry, read off the stored resource.
+ *
+ * This is not a parser and never becomes one. It reads three named properties
+ * of the master VEVENT so the pane can show a location and the editor can send
+ * one back unchanged; anything structural — recurrence expansion above all —
+ * belongs to the server, which is the only thing that expands a series.
+ */
+/**
+ * RFC 5545 breaks a long property across lines with a leading space or tab, so
+ * the folds are joined before anything is matched — a value read fold-first
+ * stops halfway through and looks like a shorter value rather than a broken one.
+ */
+const unfold = (icalData) => icalData.replace(/\r?\n[ \t]/g, "");
+/** RFC 5545 3.3.11: the four escapes a TEXT value carries. */
+const unescapeText = (value) => value
+    .replace(/\\n/gi, "\n")
+    .replace(/\\,/g, ",")
+    .replace(/\\;/g, ";")
+    .replace(/\\\\/g, "\\");
+/**
+ * Where a content line's parameters end and its value begins.
+ *
+ * The separator is the first colon outside a quoted string, not the first colon
+ * (RFC 5545 3.1). A parameter value is allowed to be quoted precisely so it can
+ * hold one — `ALTREP="cid:part1"` is ordinary — and splitting on the first
+ * colon hands back the tail of a URI as though it were the property's value.
+ */
+function valueAt(line, name) {
+    let quoted = false;
+    for (let index = name.length; index < line.length; index += 1) {
+        const character = line[index];
+        if (index === name.length && character !== ";" && character !== ":")
+            return undefined;
+        if (character === '"') {
+            quoted = !quoted;
+            continue;
+        }
+        if (!quoted && character === ":")
+            return line.slice(index + 1).trim();
+    }
+    return undefined;
+}
+/**
+ * The first occurrence of a property, parameters and all. The master VEVENT is
+ * written before its overrides, so the first match is the series' own value.
+ */
+function firstProperty(icalData, name) {
+    for (const line of unfold(icalData).split(/\r?\n/)) {
+        if (!line.startsWith(name))
+            continue;
+        const value = valueAt(line, name);
+        if (value !== undefined)
+            return value;
+    }
+    return "";
+}
+export const rruleFromIcalData = (icalData) => firstProperty(icalData, "RRULE");
+export const textFromIcalData = (icalData) => ({
+    location: unescapeText(firstProperty(icalData, "LOCATION")),
+    description: unescapeText(firstProperty(icalData, "DESCRIPTION")),
+});
+/**
+ * The zone an edit writes an existing event back in: the one its master's
+ * DTSTART is stored in. A UTC start stays UTC (`""`), a floating one stays in
+ * the collection's zone, and a TZID nothing can resolve is read the way the
+ * server reads it, in the collection's zone. Only a resource with no DTSTART
+ * falls back to where a new event would be anchored.
+ */
+export function storedAnchorZone(icalData, collectionZone) {
+    const line = unfold(icalData)
+        .split(/\r?\n/)
+        .find((candidate) => candidate.startsWith("DTSTART") &&
+        valueAt(candidate, "DTSTART") !== undefined);
+    if (line === undefined)
+        return anchorZoneFor(collectionZone);
+    const tzid = /;TZID="?([^;:"]+)"?/i.exec(line)?.[1];
+    if (tzid !== undefined)
+        return Intl.supportedValuesOf("timeZone").includes(tzid)
+            ? tzid
+            : collectionZone;
+    if (valueAt(line, "DTSTART")?.toUpperCase().endsWith("Z"))
+        return "";
+    return collectionZone;
+}

package/dist/src/hooks/calendar/selection.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Which calendars a surface is drawing, and how their occurrences become rows.
+ *
+ * Both readings of the calendar ask this and neither may answer it its own way:
+ * the grid reads one window and the strip reads many, but "which calendars did
+ * the address tick, and what does an occurrence look like once drawn" has one
+ * answer, and a second copy of it drifts into the two surfaces disagreeing
+ * about the same day.
+ */
+import type { RemitImapCalendarEventInstance } from "@remit/api-http-client/types.gen.ts";
+import type { CalendarColorId, CalendarDescriptor, CalendarEventData } from "@remit/ui";
+/**
+ * The calendars a request is asking about. An empty tick list is every
+ * calendar rather than none: a reader who has ticked nothing off is looking at
+ * all of them, and a URL naming a calendar that no longer exists shows the
+ * rest instead of an empty week.
+ */
+export declare function selectCalendarIds(calendars: readonly CalendarDescriptor[], ticked: readonly string[]): string[];
+export interface CalendarSelection {
+    calendars: CalendarDescriptor[];
+    colorByCalendarId: Record<string, CalendarColorId>;
+    timeZoneByCalendarId: Record<string, string>;
+    /** Every calendar this address draws, resolved against the real ones. */
+    shown: string[];
+    /** What to ask the server for: empty where that is every calendar. */
+    narrowed: string[];
+    /** False while the tick list still has no real calendars to resolve against. */
+    resolved: boolean;
+    isLoading: boolean;
+}
+export declare function useCalendarSelection(calendarIds: readonly string[]): CalendarSelection;
+/**
+ * Occurrences as rows: the ones on a calendar being drawn, on the device's
+ * clock, which is the one the grid, the strip and the free time all read. Each
+ * row still carries its collection's zone, unzoned where the collection names
+ * none, because that is the zone a write anchors the event in.
+ */
+export declare function useDrawnEvents(instances: readonly RemitImapCalendarEventInstance[], timeZoneByCalendarId: Record<string, string>, shown: readonly string[]): CalendarEventData[];

package/dist/src/hooks/calendar/selection.js

@@ -0,0 +1,54 @@
+import { useMemo } from "react";
+import { deviceTimeZone, isDrawnInstance, toCalendarEventData, UNZONED_CALENDAR, } from "./instance";
+import { useCalendars } from "./useCalendars";
+/**
+ * The calendars a request is asking about. An empty tick list is every
+ * calendar rather than none: a reader who has ticked nothing off is looking at
+ * all of them, and a URL naming a calendar that no longer exists shows the
+ * rest instead of an empty week.
+ */
+export function selectCalendarIds(calendars, ticked) {
+    const known = calendars.map((calendar) => calendar.id);
+    if (ticked.length === 0)
+        return known;
+    const wanted = new Set(ticked);
+    const shown = known.filter((id) => wanted.has(id));
+    return shown.length === 0 ? known : shown;
+}
+export function useCalendarSelection(calendarIds) {
+    const { calendars, colorByCalendarId, timeZoneByCalendarId, isLoading } = useCalendars();
+    const shown = selectCalendarIds(calendars, calendarIds);
+    // Asking for every calendar by name and asking for all of them are the same
+    // question, so they are the same cache entry: the address ticking each one
+    // off must not refetch the week the address ticking none already holds.
+    const narrowed = shown.length === calendars.length ? [] : shown;
+    // A tick list can only be resolved against calendars that have loaded, so a
+    // narrowed address waits for them rather than asking about ids it cannot
+    // know are real.
+    const resolved = calendarIds.length === 0 || calendars.length > 0;
+    return {
+        calendars,
+        colorByCalendarId,
+        timeZoneByCalendarId,
+        shown,
+        narrowed,
+        resolved,
+        isLoading,
+    };
+}
+/**
+ * Occurrences as rows: the ones on a calendar being drawn, on the device's
+ * clock, which is the one the grid, the strip and the free time all read. Each
+ * row still carries its collection's zone, unzoned where the collection names
+ * none, because that is the zone a write anchors the event in.
+ */
+export function useDrawnEvents(instances, timeZoneByCalendarId, shown) {
+    const shownKey = shown.join(",");
+    return useMemo(() => {
+        const clockZone = deviceTimeZone();
+        const drawn = new Set(shownKey === "" ? [] : shownKey.split(","));
+        return instances
+            .filter((instance) => isDrawnInstance(instance) && drawn.has(instance.calendarId))
+            .map((instance) => toCalendarEventData(instance, timeZoneByCalendarId[instance.calendarId] ?? UNZONED_CALENDAR, clockZone));
+    }, [instances, timeZoneByCalendarId, shownKey]);
+}

package/dist/src/hooks/calendar/suggestion-draft.d.ts

@@ -0,0 +1,11 @@
+import type { RemitImapAcceptCalendarSuggestionInput, RemitImapCalendarSuggestionResponse } from "@remit/api-http-client/types.gen.ts";
+import type { EventDraft } from "@remit/ui";
+import { type DraftRefusal, type DraftZones } from "./draft";
+export type AcceptEditedInput = {
+    ok: true;
+    input: RemitImapAcceptCalendarSuggestionInput;
+} | DraftRefusal;
+type Suggestion = Pick<RemitImapCalendarSuggestionResponse, "summary" | "location" | "dtStart" | "dtEnd" | "allDay" | "zoneCertainty">;
+export declare function draftFromSuggestion(suggestion: Suggestion, calendarId: string, clock: string): EventDraft;
+export declare function acceptEditedInputFromDrafts(suggestion: Suggestion, seed: EventDraft, draft: EventDraft, zones: DraftZones): AcceptEditedInput;
+export {};

package/dist/src/hooks/calendar/suggestion-draft.js

@@ -0,0 +1,45 @@
+import { emptyDraft, patchFromDrafts, timesFor, } from "./draft";
+import { addDays, isoOnClock } from "./window";
+export function draftFromSuggestion(suggestion, calendarId, clock) {
+    const base = {
+        title: suggestion.summary,
+        location: suggestion.location,
+    };
+    if (suggestion.allDay) {
+        const date = suggestion.dtStart.slice(0, 10);
+        const end = suggestion.dtEnd.slice(0, 10);
+        return {
+            ...emptyDraft(date, calendarId),
+            ...base,
+            allDay: true,
+            startTime: "",
+            endDate: end > date ? addDays(end, -1) : date,
+            endTime: "",
+        };
+    }
+    const wall = (iso) => suggestion.zoneCertainty === "Ambiguous" ? iso : isoOnClock(iso, clock);
+    const start = wall(suggestion.dtStart);
+    const end = wall(suggestion.dtEnd);
+    return {
+        ...emptyDraft(start.slice(0, 10), calendarId),
+        ...base,
+        startTime: start.slice(11, 16),
+        endDate: end.slice(0, 10),
+        endTime: end.slice(11, 16),
+    };
+}
+export function acceptEditedInputFromDrafts(suggestion, seed, draft, zones) {
+    const built = patchFromDrafts(seed, draft, zones);
+    if (!built.ok)
+        return built;
+    const placed = suggestion.zoneCertainty === "Ambiguous" || built.patch.start !== undefined;
+    const event = placed
+        ? {
+            ...built.patch,
+            ...timesFor(draft, zones.clock),
+            allDay: draft.allDay,
+            timeZone: zones.anchor,
+        }
+        : built.patch;
+    return { ok: true, input: { calendarId: draft.calendarId, event } };
+}

package/dist/src/hooks/calendar/useCalendarCollectionWrites.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Creating, renaming, rezoning and deleting a calendar collection.
+ *
+ * A refusal comes back as an outcome carrying the server's own words — a url
+ * segment already taken, a zone it cannot resolve, the default calendar that
+ * cannot be removed — so the settings card states it where the reader acted.
+ * A lapsed session is not among the statuses owned here and escalates.
+ *
+ * Every write invalidates the listing, which is what the settings page, the
+ * editor's picker and the address filter all read. A delete or a rezone also
+ * moves or removes occurrences, so the event reads are invalidated with it.
+ */
+import type { RemitImapCreateCalendarInput, RemitImapUpdateCalendarInput } from "@remit/api-http-client/types.gen.ts";
+export type CalendarCollectionOutcome = {
+    kind: "written";
+} | {
+    kind: "refused";
+    message: string;
+};
+export interface CalendarCollectionWrites {
+    createCalendar: (input: RemitImapCreateCalendarInput) => Promise<CalendarCollectionOutcome>;
+    updateCalendar: (calendarId: string, patch: RemitImapUpdateCalendarInput) => Promise<CalendarCollectionOutcome>;
+    deleteCalendar: (calendarId: string) => Promise<CalendarCollectionOutcome>;
+    isWriting: boolean;
+}
+export declare function useCalendarCollectionWrites(): CalendarCollectionWrites;