@remit/web-client 0.0.325 → 0.0.327

package/src/hooks/calendar/draft.ts

@@ -1,204 +0,0 @@
-/**
- * The editor's draft, and what the API makes of it.
- *
- * A refusal is returned rather than thrown, and it says which field is wrong and
- * what to do about it — a form that only greys its save button leaves the reader
- * hunting for the reason.
- *
- * An edit sends the fields that changed and nothing else. Absence means
- * untouched on this API, so patching every field would write back the empty
- * `location` and `description` a listing never carried and quietly erase them.
- */
-import type {
-	RemitImapCreateCalendarEventInput,
-	RemitImapUpdateCalendarEventInput,
-} from "@remit/api-http-client/types.gen.ts";
-import { type CalendarEventData, type EventDraft, lastDayOf } from "@remit/ui";
-import { moveRule, rruleFromText } from "./recurrence-rule";
-import { addDays, isoAtInZone, isoOnClock } from "./window";
-
-export type DraftRefusal = { ok: false; problem: string };
-
-/**
- * The two zones a write needs. `clock` is the one the form's digits were read
- * on — the device's, which every surface draws on — and it decides the offset,
- * so the instant saved is the instant shown. `anchor` is the zone the event is
- * stored in, written as the TZID a series keeps its wall time in across a DST
- * change (`anchorZoneFor`); `""` anchors it in UTC.
- */
-export interface DraftZones {
-	clock: string;
-	anchor: string;
-}
-
-export type CreateInput =
-	| { ok: true; input: RemitImapCreateCalendarEventInput }
-	| DraftRefusal;
-
-export type UpdatePatch =
-	| { ok: true; patch: RemitImapUpdateCalendarEventInput }
-	| DraftRefusal;
-
-/** A blank event, an hour long, at the start of a working day. */
-export function emptyDraft(date: string, calendarId: string): EventDraft {
-	return {
-		title: "",
-		date,
-		startTime: "09:00",
-		endDate: date,
-		endTime: "10:00",
-		allDay: false,
-		calendarId,
-		location: "",
-		guests: "",
-		notes: "",
-		repeat: "",
-	};
-}
-
-/**
- * The draft an event opens into, so an edit starts from what is stored rather
- * than from what a grid chip had room to draw. The occurrence listing carries
- * neither the location nor the notes, so those come from the resource.
- */
-export function draftFromEvent(
-	event: CalendarEventData,
-	stored: { repeat: string; location: string; notes: string },
-): EventDraft {
-	return {
-		title: event.title,
-		date: event.start.slice(0, 10),
-		startTime: event.allDay ? "" : event.start.slice(11, 16),
-		endDate: lastDayOf(event),
-		endTime: event.allDay ? "" : event.end.slice(11, 16),
-		allDay: event.allDay,
-		calendarId: event.calendarId,
-		location: stored.location,
-		guests: "",
-		notes: stored.notes,
-		repeat: stored.repeat,
-	};
-}
-
-/**
- * The draft's wall clock, pinned to an instant on the clock it was read on.
- * Stamping any other zone's offset onto those digits moves the event by the
- * difference between the two — silently, and only for whoever is travelling.
- */
-export function timesFor(
-	draft: EventDraft,
-	clock: string,
-): { start: string; end: string } {
-	if (draft.allDay)
-		return { start: draft.date, end: addDays(draft.endDate, 1) };
-	return {
-		start: isoAtInZone(draft.date, draft.startTime, clock),
-		end: isoAtInZone(draft.endDate, draft.endTime, clock),
-	};
-}
-
-/**
- * The picked rule, stored on the day the event's own zone starts it on rather
- * than on the day the device showed when it was picked.
- */
-function storedRule(
-	draft: EventDraft,
-	start: string,
-	zones: DraftZones,
-): string {
-	const rule = rruleFromText(draft.repeat) ?? "";
-	const anchorDate = draft.allDay
-		? draft.date
-		: isoOnClock(start, zones.anchor === "" ? "UTC" : zones.anchor).slice(
-				0,
-				10,
-			);
-	return moveRule(rule, draft.date, anchorDate);
-}
-
-/**
- * An unreadable rule is only a refusal where the reader chose it. An event that
- * arrived carrying a rule this client cannot put into words is still editable —
- * the rule is left where it is and every other field saves.
- */
-function refuse(draft: EventDraft, checkRepeat: boolean): string {
-	if (draft.title.trim() === "")
-		return "Give the event a title before saving it.";
-	if (draft.date === "") return "Pick the day the event is on.";
-	if (draft.endDate === "") return "Pick the day the event ends on.";
-	if (draft.calendarId === "") return "Pick the calendar to save the event in.";
-	if (!draft.allDay && (draft.startTime === "" || draft.endTime === ""))
-		return "Set a start and an end time, or mark the event all day.";
-	if (draft.allDay && draft.endDate < draft.date)
-		return "The last day is before the first. Move one of them.";
-	if (
-		!draft.allDay &&
-		`${draft.endDate}T${draft.endTime}` <= `${draft.date}T${draft.startTime}`
-	)
-		return "The end is not after the start. Move one of them.";
-	if (checkRepeat && rruleFromText(draft.repeat) === undefined)
-		return "This calendar can't store that repeat rule. Pick one of the offered rules, or turn the repeat off.";
-	return "";
-}
-
-export function createInputFromDraft(
-	draft: EventDraft,
-	zones: DraftZones,
-): CreateInput {
-	const problem = refuse(draft, true);
-	if (problem !== "") return { ok: false, problem };
-	const { start, end } = timesFor(draft, zones.clock);
-	return {
-		ok: true,
-		input: {
-			calendarId: draft.calendarId,
-			summary: draft.title.trim(),
-			description: draft.notes,
-			location: draft.location,
-			start,
-			end,
-			allDay: draft.allDay,
-			...(zones.anchor === "" ? {} : { timeZone: zones.anchor }),
-			recurrenceRule: storedRule(draft, start, zones),
-		},
-	};
-}
-
-export function patchFromDrafts(
-	before: EventDraft,
-	after: EventDraft,
-	zones: DraftZones,
-): UpdatePatch {
-	const repeatChanged = after.repeat !== before.repeat;
-	const allDayChanged = after.allDay !== before.allDay;
-	const startMoved =
-		allDayChanged ||
-		after.date !== before.date ||
-		after.startTime !== before.startTime;
-	const endMoved =
-		startMoved ||
-		after.endDate !== before.endDate ||
-		after.endTime !== before.endTime;
-	const problem = refuse(after, repeatChanged);
-	if (problem !== "") return { ok: false, problem };
-
-	const patch: RemitImapUpdateCalendarEventInput = {};
-	if (after.title.trim() !== before.title.trim())
-		patch.summary = after.title.trim();
-	if (after.location !== before.location) patch.location = after.location;
-	if (after.notes !== before.notes) patch.description = after.notes;
-
-	const { start, end } = timesFor(after, zones.clock);
-	if (startMoved) patch.start = start;
-	if (endMoved) {
-		patch.end = end;
-		patch.allDay = after.allDay;
-		// The offset pins the instant; the zone is what a series needs to keep
-		// meeting at nine when the clocks go back.
-		if (zones.anchor !== "") patch.timeZone = zones.anchor;
-	}
-
-	if (repeatChanged) patch.recurrenceRule = storedRule(after, start, zones);
-
-	return { ok: true, patch };
-}

package/src/hooks/calendar/index.ts

@@ -1,122 +0,0 @@
-/**
- * What every calendar surface reads and writes, in one module.
- *
- * The grid, the reading pane and the day strip all ask the same questions, so
- * they ask them through the same hooks: one window is fetched once however many
- * of them are on screen, and a write invalidates what all of them are showing.
- */
-export {
-	type AgendaRange,
-	busySpansByDate,
-	CAP_WEEKS,
-	datesInRange,
-	extendRangeEnd,
-	extendRangeStart,
-	type FreeLookup,
-	freeStretchesByDate,
-	LEAD_IN,
-	LEAD_OUT,
-	liftRangeCeiling,
-	liftRangeFloor,
-	PAGE,
-	rangeAround,
-	rangeAtCeiling,
-	rangeAtFloor,
-	rangeCovering,
-	weekKeyOf,
-	weekWindowsOver,
-} from "./agenda-window";
-export {
-	type CreateInput,
-	createInputFromDraft,
-	type DraftRefusal,
-	type DraftZones,
-	draftFromEvent,
-	emptyDraft,
-	patchFromDrafts,
-	type UpdatePatch,
-} from "./draft";
-export {
-	anchorZoneFor,
-	type CalendarInstanceRef,
-	type CalendarJump,
-	calendarInstanceId,
-	calendarJumpOf,
-	deviceTimeZone,
-	isDrawnInstance,
-	readCalendarInstanceId,
-	seriesOccurrenceOf,
-	toCalendarDescriptor,
-	toCalendarEventData,
-	UNZONED_CALENDAR,
-} from "./instance";
-export { moveRule, rruleFromText, textFromRrule } from "./recurrence-rule";
-export {
-	type CalendarResourceText,
-	rruleFromIcalData,
-	storedAnchorZone,
-	textFromIcalData,
-} from "./resource";
-export {
-	type CalendarSelection,
-	selectCalendarIds,
-	useCalendarSelection,
-	useDrawnEvents,
-} from "./selection";
-export {
-	type AcceptEditedInput,
-	acceptEditedInputFromDrafts,
-	draftFromSuggestion,
-} from "./suggestion-draft";
-export {
-	type CalendarCollectionOutcome,
-	type CalendarCollectionWrites,
-	useCalendarCollectionWrites,
-} from "./useCalendarCollectionWrites";
-export {
-	type CalendarEventResource,
-	useCalendarEvent,
-} from "./useCalendarEvent";
-export {
-	CALENDAR_WINDOW_STALE_TIME,
-	type CalendarEventWeeksResult,
-	type CalendarEventWindowRequest,
-	type CalendarEventWindowResult,
-	useCalendarEventWeeks,
-	useCalendarEventWindow,
-	usePrefetchAdjacentWindows,
-} from "./useCalendarEvents";
-export {
-	type CalendarFreeBusyResult,
-	useCalendarFreeBusyWeeks,
-} from "./useCalendarFreeBusy";
-export { type CalendarJumpSearch, useCalendarJump } from "./useCalendarJump";
-export {
-	type CalendarSuggestionAnswers,
-	type CalendarSuggestionsResult,
-	type PendingCalendarSuggestionResult,
-	type SuggestionAnswer,
-	useCalendarSuggestionAnswers,
-	useMessageCalendarSuggestions,
-	usePendingCalendarSuggestion,
-	usePendingCalendarSuggestions,
-} from "./useCalendarSuggestions";
-export { type CalendarsResult, useCalendars } from "./useCalendars";
-export {
-	type CalendarWriteOutcome,
-	type CalendarWrites,
-	type ScopedWrite,
-	useCalendarWrites,
-	useInvalidateCalendarReads,
-} from "./useCalendarWrites";
-export { useDraftClashes } from "./useDraftClashes";
-export {
-	addDays,
-	type CalendarWindow,
-	calendarWindow,
-	calendarWindowOfDays,
-	isoAt,
-	isoAtInZone,
-	isoOnClock,
-	startOfDay,
-} from "./window";

package/src/hooks/calendar/instance.test.ts

@@ -1,206 +0,0 @@
-/** An occurrence as the calendar draws it, and the zone a write anchors it in. */
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import type { RemitImapCalendarEventInstance } from "@remit/api-http-client/types.gen.ts";
-import {
-	anchorZoneFor,
-	calendarJumpOf,
-	seriesOccurrenceOf,
-	toCalendarEventData,
-} from "./instance";
-
-const instance = (
-	over: Partial<RemitImapCalendarEventInstance>,
-): RemitImapCalendarEventInstance =>
-	({
-		calendarId: "cal_work",
-		calendarObjectId: "obj_1",
-		recurrenceId: "",
-		icalUid: "uid-1",
-		summary: "Audit day",
-		start: "2034-03-01T00:00:00+09:00",
-		end: "2034-03-02T00:00:00+09:00",
-		allDay: true,
-		status: "Confirmed",
-		transparency: "Opaque",
-		zoneCertainty: "Explicit",
-		etag: "etag-1",
-		hasRecurrence: false,
-		...over,
-	}) as RemitImapCalendarEventInstance;
-
-describe("an occurrence drawn on a device", () => {
-	it("keeps an all-day occurrence on its civil date wherever the device is", () => {
-		const drawn = toCalendarEventData(
-			instance({}),
-			"Asia/Tokyo",
-			"Pacific/Pago_Pago",
-		);
-		assert.equal(drawn.start, "2034-03-01");
-		assert.equal(drawn.end, "2034-03-02");
-	});
-
-	it("re-reads a timed occurrence on the device's clock", () => {
-		const drawn = toCalendarEventData(
-			instance({
-				allDay: false,
-				start: "2034-02-22T08:00:00+09:00",
-				end: "2034-02-22T09:00:00+09:00",
-			}),
-			"Asia/Tokyo",
-			"America/New_York",
-		);
-		assert.equal(drawn.start, "2034-02-21T18:00:00-05:00");
-		assert.equal(drawn.end, "2034-02-21T19:00:00-05:00");
-	});
-});
-
-describe("the zone a write anchors an event in", () => {
-	it("is the collection's where it names one", () => {
-		assert.equal(anchorZoneFor("Asia/Tokyo"), "Asia/Tokyo");
-	});
-
-	it("is the device's where the collection names none, and nothing on UTC", () => {
-		const runner = process.env.TZ;
-		try {
-			process.env.TZ = "America/New_York";
-			assert.equal(anchorZoneFor(""), "America/New_York");
-			process.env.TZ = "UTC";
-			assert.equal(anchorZoneFor(""), "");
-		} finally {
-			if (runner === undefined) Reflect.deleteProperty(process.env, "TZ");
-			else process.env.TZ = runner;
-		}
-	});
-});
-
-describe("the occurrence a series opens at from its plain address", () => {
-	const weekly = ["06", "13", "20"].map((day) =>
-		toCalendarEventData(
-			instance({
-				recurrenceId: `203403${day}T090000Z`,
-				hasRecurrence: true,
-				allDay: false,
-				start: `2034-03-${day}T09:00:00+00:00`,
-				end: `2034-03-${day}T10:00:00+00:00`,
-			}),
-			"UTC",
-			"UTC",
-		),
-	);
-	const shuffled = [...weekly].reverse();
-
-	it("is the next one still to finish", () => {
-		assert.deepEqual(
-			seriesOccurrenceOf(shuffled, "obj_1", "2034-03-13T09:30:00Z"),
-			{ calendarObjectId: "obj_1", recurrenceId: "20340313T090000Z" },
-		);
-	});
-
-	it("is the first in the window once every one has passed", () => {
-		assert.deepEqual(
-			seriesOccurrenceOf(shuffled, "obj_1", "2034-04-01T00:00:00Z"),
-			{ calendarObjectId: "obj_1", recurrenceId: "20340306T090000Z" },
-		);
-	});
-
-	it("is nothing for an event that does not recur or is not in the window", () => {
-		const oneOff = toCalendarEventData(
-			instance({ calendarObjectId: "obj_2" }),
-			"UTC",
-			"UTC",
-		);
-		assert.equal(
-			seriesOccurrenceOf(
-				[oneOff, ...shuffled],
-				"obj_2",
-				"2034-03-01T00:00:00Z",
-			),
-			undefined,
-		);
-		assert.equal(
-			seriesOccurrenceOf(shuffled, "obj_3", "2034-03-01T00:00:00Z"),
-			undefined,
-		);
-	});
-});
-
-describe("the day a view moves to for an event it does not hold", () => {
-	const weekly = ["06", "13", "20"].map((day) =>
-		instance({
-			recurrenceId: `2034-03-${day}T01:00:00Z`,
-			hasRecurrence: true,
-			allDay: false,
-			start: `2034-03-${day}T01:00:00+00:00`,
-			end: `2034-03-${day}T02:00:00+00:00`,
-		}),
-	);
-	const shuffled = [...weekly].reverse();
-
-	it("is the day of the next occurrence still to finish, on the device's clock", () => {
-		assert.deepEqual(
-			calendarJumpOf(
-				shuffled,
-				"obj_1",
-				"2034-03-10T00:00:00Z",
-				"America/New_York",
-			),
-			{
-				calendarObjectId: "obj_1",
-				recurrenceId: "2034-03-13T01:00:00Z",
-				calendarId: "cal_work",
-				date: "2034-03-12",
-			},
-		);
-	});
-
-	it("is the day of the first occurrence once every one has passed", () => {
-		assert.deepEqual(
-			calendarJumpOf(shuffled, "obj_1", "2035-01-01T00:00:00Z", "UTC"),
-			{
-				calendarObjectId: "obj_1",
-				recurrenceId: "2034-03-06T01:00:00Z",
-				calendarId: "cal_work",
-				date: "2034-03-06",
-			},
-		);
-	});
-
-	it("skips a cancelled occurrence", () => {
-		const [first, ...rest] = weekly;
-		if (!first) throw new Error("no first occurrence");
-		assert.equal(
-			calendarJumpOf(
-				[{ ...first, status: "Cancelled" }, ...rest],
-				"obj_1",
-				"2034-03-01T00:00:00Z",
-				"UTC",
-			)?.date,
-			"2034-03-13",
-		);
-	});
-
-	it("keeps a one-off event unaddressed by an occurrence", () => {
-		assert.deepEqual(
-			calendarJumpOf(
-				[instance({ calendarObjectId: "obj_2" })],
-				"obj_2",
-				"2034-01-01T00:00:00Z",
-				"Pacific/Pago_Pago",
-			),
-			{
-				calendarObjectId: "obj_2",
-				recurrenceId: "",
-				calendarId: "cal_work",
-				date: "2034-03-01",
-			},
-		);
-	});
-
-	it("is nothing when the series has no occurrence", () => {
-		assert.equal(
-			calendarJumpOf(shuffled, "obj_3", "2034-03-01T00:00:00Z", "UTC"),
-			undefined,
-		);
-	});
-});