@remit/web-client 0.0.293 → 0.0.295

package/src/lib/calendar-suggestion.ts

@@ -0,0 +1,251 @@
+/**
+ * A suggestion the server read out of a message, as the calendar kit draws it.
+ *
+ * The API carries projections of the invitation and nothing about who is
+ * looking at it, so what the reader is asked — whether the card still wants an
+ * answer, what the span runs into, which half-hours are open — is decided here,
+ * in one place, rather than in each surface that shows a card.
+ */
+import type {
+	RemitImapCalendarFreeBusySpan,
+	RemitImapCalendarSuggestionResponse,
+} from "@remit/api-http-client/types.gen.ts";
+import {
+	type CalendarClash,
+	type CalendarEventData,
+	type CalendarInvite,
+	type CalendarInviteState,
+	type CalendarSlotPick,
+	type EventSuggestion,
+	formatMinute,
+	freeStretchesFromSpans,
+	type RsvpState,
+	type ZoneCertainty,
+} from "@remit/ui";
+import { addDays, busySpansByDate } from "@/hooks/calendar";
+import {
+	formatCivilDay,
+	formatClock,
+	formatDayLabel,
+	formatEventWhen,
+	formatInstantClock,
+} from "./calendar-format";
+import { isoDate } from "./calendar-route";
+
+export type CalendarSuggestion = RemitImapCalendarSuggestionResponse;
+
+/** Half an hour is what an offer of another time is worth. */
+export const OFFER_MINUTES = 30;
+
+/** More than a handful of offers is a timetable, not a reply. */
+const OFFER_LIMIT = 6;
+
+const ZONES: Record<CalendarSuggestion["zoneCertainty"], ZoneCertainty> = {
+	Local: "local",
+	Explicit: "explicit",
+	Ambiguous: "ambiguous",
+};
+
+const AMBIGUOUS_ZONE =
+	"The invitation named a time zone nothing could resolve, so this time may be hours out.";
+
+/** Where the card stands, or nothing when there is no card left to draw. */
+export interface InviteStanding {
+	state: CalendarInviteState;
+	rsvp: RsvpState;
+}
+
+/**
+ * What a suggestion's state means for its card.
+ *
+ * A dismissed card was waved away and is gone. A cancellation asks for an
+ * answer only while it is pending: once taken or kept, the event it named is
+ * settled and there is nothing left to say beside the message.
+ */
+export function inviteStanding(
+	suggestion: CalendarSuggestion,
+): InviteStanding | undefined {
+	if (suggestion.state === "Dismissed") return undefined;
+	if (suggestion.method === "Cancel")
+		return suggestion.state === "Pending"
+			? { state: "cancelled", rsvp: "noReply" }
+			: undefined;
+	if (suggestion.state === "Superseded")
+		return { state: "superseded", rsvp: "noReply" };
+	if (suggestion.state === "Accepted")
+		return { state: "answered", rsvp: "accepted" };
+	if (suggestion.state === "Declined")
+		return { state: "answered", rsvp: "declined" };
+	if (suggestion.state === "Tentative")
+		return { state: "answered", rsvp: "tentative" };
+	return { state: "pending", rsvp: "noReply" };
+}
+
+export const isFromInvitation = (suggestion: CalendarSuggestion): boolean =>
+	suggestion.source !== "TextHeuristic";
+
+/** The day a suggestion lands on, on the clock this device reads. */
+export function suggestionDate(suggestion: CalendarSuggestion): string {
+	if (suggestion.allDay) return suggestion.dtStart.slice(0, 10);
+	return isoDate(new Date(suggestion.dtStart));
+}
+
+export const suggestionTitle = (suggestion: CalendarSuggestion): string =>
+	suggestion.summary === "" ? "Untitled event" : suggestion.summary;
+
+export function suggestionWhen(suggestion: CalendarSuggestion): string {
+	if (suggestion.allDay) {
+		const first = suggestion.dtStart.slice(0, 10);
+		const end = suggestion.dtEnd.slice(0, 10);
+		const last = end > first ? addDays(end, -1) : first;
+		return last === first
+			? `${formatCivilDay(first)}, all day`
+			: `${formatCivilDay(first)} – ${formatCivilDay(last)}, all day`;
+	}
+	return formatEventWhen({
+		start: suggestion.dtStart,
+		end: suggestion.dtEnd,
+		allDay: suggestion.allDay,
+	});
+}
+
+export interface InviteContext {
+	threadId: string;
+	threadSubject: string;
+	/** Who the mail came from, for an invitation that names no organiser. */
+	senderName: string;
+	calendarId: string;
+}
+
+function proposedEvent(
+	suggestion: CalendarSuggestion,
+	context: InviteContext,
+): CalendarEventData {
+	return {
+		id: suggestion.suggestionId,
+		calendarId: context.calendarId,
+		title: suggestionTitle(suggestion),
+		start: suggestion.dtStart,
+		end: suggestion.dtEnd,
+		allDay: suggestion.allDay,
+		location: suggestion.location,
+		notes: "",
+		attendees: [],
+		myRsvp: "noReply",
+		threadId: context.threadId,
+		threadSubject: context.threadSubject,
+		timeZone: "",
+		zoneCertainty: ZONES[suggestion.zoneCertainty],
+		recurrenceRule: "",
+		seriesId: "",
+		seriesException: false,
+		status: "confirmed",
+	};
+}
+
+export function toCalendarInvite(
+	suggestion: CalendarSuggestion,
+	state: CalendarInviteState,
+	context: InviteContext,
+): CalendarInvite {
+	const organizer =
+		suggestion.organizer === "" ? context.senderName : suggestion.organizer;
+	return {
+		id: suggestion.suggestionId,
+		threadId: context.threadId,
+		proposed: proposedEvent(suggestion, context),
+		organizerName: organizer === "" ? "The sender" : organizer,
+		organizerEmail: suggestion.organizer,
+		method: "ics",
+		evidence: "",
+		state,
+		sequence: suggestion.sequence,
+	};
+}
+
+export function toEventSuggestion(
+	suggestion: CalendarSuggestion,
+	context: Omit<InviteContext, "senderName"> & { sender: string },
+): EventSuggestion {
+	return {
+		id: suggestion.suggestionId,
+		title: suggestionTitle(suggestion),
+		start: suggestion.dtStart,
+		end: suggestion.dtEnd,
+		allDay: suggestion.allDay,
+		location: suggestion.location,
+		threadId: context.threadId,
+		threadSubject: context.threadSubject,
+		sender: context.sender,
+		senderAddress: suggestion.organizer,
+		confidence: isFromInvitation(suggestion) ? 1 : 0.6,
+		ambiguity: suggestion.zoneCertainty === "Ambiguous" ? AMBIGUOUS_ZONE : "",
+		suggestedCalendarId: context.calendarId,
+		timeZone: "",
+		zoneCertainty: ZONES[suggestion.zoneCertainty],
+	};
+}
+
+const overlaps = (
+	span: { start: string; end: string },
+	busy: RemitImapCalendarFreeBusySpan,
+): boolean =>
+	Date.parse(busy.start) < Date.parse(span.end) &&
+	Date.parse(busy.end) > Date.parse(span.start);
+
+/**
+ * What is already booked over a span. Busy time is merged across every
+ * calendar on the server and carries no titles, so a clash names the hours it
+ * takes rather than the meeting in them.
+ */
+export function clashesOver(
+	span: { start: string; end: string },
+	busy: readonly RemitImapCalendarFreeBusySpan[],
+): CalendarClash[] {
+	return busy
+		.filter((entry) => overlaps(span, entry))
+		.map((entry) => ({
+			id: `${entry.start}/${entry.end}`,
+			label: `Busy ${formatInstantClock(entry.start)} – ${formatInstantClock(entry.end)}`,
+		}));
+}
+
+/** Half-hours still open on a day, cut out of the busy time the server merged. */
+export function slotOffersOn(
+	date: string,
+	busy: readonly RemitImapCalendarFreeBusySpan[],
+): CalendarSlotPick[] {
+	const spans = busySpansByDate([date], busy).get(date) ?? [];
+	const offers: CalendarSlotPick[] = [];
+	for (const stretch of freeStretchesFromSpans(date, spans, OFFER_MINUTES)) {
+		for (
+			let minute = stretch.startMinute;
+			minute + OFFER_MINUTES <= stretch.endMinute &&
+			offers.length < OFFER_LIMIT;
+			minute += OFFER_MINUTES
+		) {
+			offers.push({
+				date,
+				endDate: date,
+				startTime: formatMinute(minute),
+				endTime: formatMinute(minute + OFFER_MINUTES),
+				allDay: false,
+			});
+		}
+	}
+	return offers;
+}
+
+/** The picked half-hours as a line a reply can carry. */
+export function slotsAsText(
+	date: string,
+	slots: readonly CalendarSlotPick[],
+	picked: readonly string[],
+): string {
+	const times = slots
+		.filter((slot) => picked.includes(slot.startTime))
+		.map(
+			(slot) => `${formatClock(slot.startTime)} – ${formatClock(slot.endTime)}`,
+		);
+	return `${formatDayLabel(date)}: ${times.join(", ")}`;
+}

package/src/lib/calendar-suggestion.west.test.ts

@@ -0,0 +1,56 @@
+/**
+ * An all-day invitation read west of the zone it was sent from (#1277 review).
+ *
+ * Midnight in the organiser's zone is the previous evening in New York, so a
+ * date read as an instant lands a day early. The zone is set before the module
+ * loads, because a formatter settles its zone when it is built.
+ */
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+
+process.env.TZ = "America/New_York";
+const { suggestionDate, suggestionWhen } = await import(
+	"./calendar-suggestion"
+);
+
+const allDay = {
+	suggestionId: "sug-1",
+	accountConfigId: "cfg-1",
+	messageId: "msg-1",
+	bodyPartId: "part-1",
+	icalUid: "uid-1",
+	sequence: 0,
+	method: "Request",
+	source: "IcalendarPart",
+	state: "Pending",
+	summary: "Offsite",
+	dtStart: "2027-03-10T00:00:00+00:00",
+	dtEnd: "2027-03-11T00:00:00+00:00",
+	allDay: true,
+	location: "",
+	organizer: "organizer@example.test",
+	zoneCertainty: "Explicit",
+	acceptedCalendarObjectId: "",
+	createdAt: 0,
+	updatedAt: 0,
+} as const;
+
+describe("an all-day invitation, west of where it was sent", () => {
+	it("names the day it was sent for, not the evening before", () => {
+		const when = suggestionWhen(allDay);
+		assert.match(when, /Wed/);
+		assert.match(when, /\b10\b/);
+		assert.match(when, /all day$/);
+		assert.doesNotMatch(when, /Tue|\b9\b/);
+		assert.equal(suggestionDate(allDay), "2027-03-10");
+	});
+
+	it("names the last day of a multi-day one, not the exclusive end", () => {
+		const when = suggestionWhen({
+			...allDay,
+			dtEnd: "2027-03-13T00:00:00+00:00",
+		});
+		assert.match(when, /Wed.*\b10\b.*–.*Fri.*\b12\b/);
+		assert.doesNotMatch(when, /Sat|\b13\b/);
+	});
+});

package/src/lib/starred-rows.ts

@@ -8,8 +8,10 @@
  *
  * Deduping over the accumulated pages rather than inside one keeps a
  * conversation single even when its copies straddle a page boundary — a single
- * page cannot know what earlier pages already showed. The first row wins, which
- * is the newest under the server's descending order.
+ * page cannot know what earlier pages already showed. The first row wins: the
+ * newest under a plain listing, and under a search the one the server ranked
+ * highest, so a sender's own older message beats a newer reply that mentions
+ * them.
  *
  * Generic over anything naming its thread, so the same collapse runs over the
  * API rows and over the merged display rows a text search produces — two

package/src/routes/calendar/$view.$date.tsx

@@ -25,6 +25,7 @@ import { AgendaView } from "@/components/calendar/AgendaView";
 import { CalendarComposeSeedProvider } from "@/components/calendar/CalendarComposeSeed";
 import { CalendarShell } from "@/components/calendar/CalendarShell";
 import { CalendarWorkspace } from "@/components/calendar/CalendarWorkspace";
+import { PendingSuggestions } from "@/components/calendar/PendingSuggestions";
 import { calendarInstanceId, deviceTimeZone } from "@/hooks/calendar";
 import { useCalendarData } from "@/hooks/useCalendarData";
 import { useLayoutTier } from "@/hooks/useLayoutTier";
@@ -122,6 +123,7 @@ function CalendarView({ isPhone }: { isPhone: boolean }) {
 			events={events}
 			colorByCalendarId={colorByCalendarId}
 			agenda={<AgendaView density={density} onPickSlot={pickSlot} />}
+			waiting={<PendingSuggestions />}
 			isLoading={isLoading}
 			error={error}
 			onRetry={retry}

package/src/routing/calendar.ts

@@ -165,3 +165,32 @@ export function useCalendarNavigation(): CalendarNavigation {
 		[goTo, navigate, retainPanels, view, date],
 	);
 }
+
+/**
+ * Leave the mail for one event on the calendar, on the day it falls, so the
+ * reader lands where the grid already shows what is around it. The panes are
+ * not carried: the calendar is a different surface, as the nav treats it.
+ */
+export function useOpenEventOnCalendar(): (
+	date: string,
+	calendarObjectId: string,
+	recurrenceId: string,
+) => void {
+	const navigate = useNavigate();
+	return useCallback(
+		(date: string, calendarObjectId: string, recurrenceId: string) => {
+			if (recurrenceId === "") {
+				navigate({
+					to: "/calendar/$view/$date/$calendarObjectId",
+					params: { view: "day", date, calendarObjectId },
+				});
+				return;
+			}
+			navigate({
+				to: "/calendar/$view/$date/$calendarObjectId/$recurrenceId",
+				params: { view: "day", date, calendarObjectId, recurrenceId },
+			});
+		},
+		[navigate],
+	);
+}

package/src/routing/index.ts

@@ -11,6 +11,7 @@ export {
 	useCalendarNavigation,
 	useIsWritingEvent,
 	useOpenCalendarEvent,
+	useOpenEventOnCalendar,
 } from "./calendar";
 export {
 	useAdoptComposeDraft,

package/src/test-support/fixtures.ts

@@ -40,6 +40,7 @@ export const makeAccount = (
 	username: "alice@example.com",
 	email: "alice@example.com",
 	authType: "password",
+	syncedServices: ["Mail"],
 	imapHost: "imap.example.com",
 	imapPort: 993,
 	imapTls: true,