@remit/web-client 0.0.325 → 0.0.327

package/src/lib/calendar-route.test.ts

@@ -1,224 +0,0 @@
-/**
- * The calendar's address, rule by rule — which tier holds which fact, what a
- * segment the calendar cannot read resolves to, and what a query string it did
- * not write is allowed to say.
- */
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import {
-	calendarSearchSchema,
-	calendarViewMountsAgenda,
-	calendarViewMountsGrid,
-	calendarViews,
-	canonicalCalendarParams,
-	DEFAULT_CALENDAR_VIEW,
-	isoDate,
-	parseCalendarDate,
-	parseCalendarView,
-	readCalendarIds,
-	stepCalendarDate,
-} from "./calendar-route.js";
-
-const TODAY = "2026-06-10";
-
-describe("parseCalendarView", () => {
-	it("reads every zoom the ladder has", () => {
-		for (const view of calendarViews) {
-			assert.equal(parseCalendarView(view), view);
-		}
-	});
-
-	it("reads a segment that names no zoom as none", () => {
-		assert.equal(parseCalendarView("fortnight"), undefined);
-		assert.equal(parseCalendarView("Week"), undefined);
-		assert.equal(parseCalendarView(""), undefined);
-	});
-});
-
-describe("parseCalendarDate", () => {
-	it("reads a day the calendar has", () => {
-		assert.equal(parseCalendarDate("2026-06-10"), "2026-06-10");
-		assert.equal(parseCalendarDate("2024-02-29"), "2024-02-29");
-	});
-
-	it("refuses a day the calendar does not have", () => {
-		assert.equal(parseCalendarDate("2026-02-30"), undefined);
-		assert.equal(parseCalendarDate("2026-13-01"), undefined);
-		assert.equal(parseCalendarDate("2025-02-29"), undefined);
-	});
-
-	it("refuses anything that is not the one spelling", () => {
-		assert.equal(parseCalendarDate("2026-6-10"), undefined);
-		assert.equal(parseCalendarDate("10-06-2026"), undefined);
-		assert.equal(parseCalendarDate("2026-06-10T09:30"), undefined);
-		assert.equal(parseCalendarDate("today"), undefined);
-		assert.equal(parseCalendarDate(""), undefined);
-	});
-});
-
-describe("canonicalCalendarParams", () => {
-	it("leaves an address it can read alone", () => {
-		assert.deepEqual(
-			canonicalCalendarParams({ view: "day", date: "2026-06-10" }, TODAY),
-			{ view: "day", date: "2026-06-10" },
-		);
-	});
-
-	it("keeps the half it could read", () => {
-		assert.deepEqual(
-			canonicalCalendarParams({ view: "fortnight", date: "2026-06-10" }, TODAY),
-			{ view: DEFAULT_CALENDAR_VIEW, date: "2026-06-10" },
-		);
-		assert.deepEqual(
-			canonicalCalendarParams({ view: "day", date: "yesterday" }, TODAY),
-			{ view: "day", date: TODAY },
-		);
-	});
-
-	it("sends an address it can read nothing of to this week", () => {
-		assert.deepEqual(canonicalCalendarParams({ view: "", date: "" }, TODAY), {
-			view: DEFAULT_CALENDAR_VIEW,
-			date: TODAY,
-		});
-	});
-});
-
-describe("calendarViewMountsGrid", () => {
-	it("draws the month, the week and the day", () => {
-		assert.equal(calendarViewMountsGrid("month"), true);
-		assert.equal(calendarViewMountsGrid("week"), true);
-		assert.equal(calendarViewMountsGrid("day"), true);
-	});
-
-	it("leaves the agenda to the strip and the year to a later stage", () => {
-		assert.equal(calendarViewMountsGrid("year"), false);
-		assert.equal(calendarViewMountsGrid("agenda"), false);
-	});
-});
-
-describe("calendarViewMountsAgenda", () => {
-	it("draws the strip at one zoom and at no other", () => {
-		for (const view of calendarViews) {
-			assert.equal(calendarViewMountsAgenda(view), view === "agenda");
-		}
-	});
-
-	it("never draws the same zoom as the grid", () => {
-		for (const view of calendarViews) {
-			assert.equal(
-				calendarViewMountsAgenda(view) && calendarViewMountsGrid(view),
-				false,
-				`${view} claimed two surfaces`,
-			);
-		}
-	});
-});
-
-describe("stepCalendarDate", () => {
-	it("steps a screenful in the view's own unit", () => {
-		assert.equal(stepCalendarDate("2026-06-10", "day", 1), "2026-06-11");
-		assert.equal(stepCalendarDate("2026-06-10", "week", 1), "2026-06-17");
-		assert.equal(stepCalendarDate("2026-06-10", "agenda", 1), "2026-06-17");
-		assert.equal(stepCalendarDate("2026-06-10", "month", 1), "2026-07-10");
-		assert.equal(stepCalendarDate("2026-06-10", "year", 1), "2027-06-10");
-	});
-
-	it("steps back the same distance it steps forward", () => {
-		for (const view of calendarViews) {
-			const forward = stepCalendarDate("2026-06-10", view, 1);
-			assert.equal(stepCalendarDate(forward, view, -1), "2026-06-10");
-		}
-	});
-
-	it("crosses a month, a year and a leap day", () => {
-		assert.equal(stepCalendarDate("2026-12-31", "day", 1), "2027-01-01");
-		assert.equal(stepCalendarDate("2026-01-01", "day", -1), "2025-12-31");
-		assert.equal(stepCalendarDate("2024-02-28", "day", 1), "2024-02-29");
-		assert.equal(stepCalendarDate("2026-12-15", "month", 1), "2027-01-15");
-		assert.equal(stepCalendarDate("2026-01-15", "month", -1), "2025-12-15");
-	});
-
-	it("holds a month step to a day that month has", () => {
-		assert.equal(stepCalendarDate("2026-03-31", "month", -1), "2026-02-28");
-		assert.equal(stepCalendarDate("2026-01-31", "month", 1), "2026-02-28");
-		assert.equal(stepCalendarDate("2024-01-31", "month", 1), "2024-02-29");
-		assert.equal(stepCalendarDate("2024-02-29", "year", 1), "2025-02-28");
-	});
-});
-
-describe("isoDate", () => {
-	it("names the day an instant falls on by the device's own clock", () => {
-		assert.equal(isoDate(new Date(2026, 5, 10, 9, 30)), "2026-06-10");
-		assert.equal(isoDate(new Date(2026, 0, 1, 0, 0)), "2026-01-01");
-		assert.equal(isoDate(new Date(2026, 11, 31, 23, 59)), "2026-12-31");
-	});
-});
-
-describe("readCalendarIds", () => {
-	it("reads repeated params, a single one, and none", () => {
-		assert.deepEqual(readCalendarIds(["cal_a", "cal_b"]), ["cal_a", "cal_b"]);
-		assert.deepEqual(readCalendarIds("cal_a"), ["cal_a"]);
-		assert.deepEqual(readCalendarIds(undefined), []);
-	});
-
-	it("spells one set of ticked calendars one way", () => {
-		assert.deepEqual(readCalendarIds(["cal_b", "cal_a", "cal_b"]), [
-			"cal_a",
-			"cal_b",
-		]);
-	});
-
-	it("keeps a numeric-looking id the router handed through as a number", () => {
-		assert.deepEqual(readCalendarIds([12, "cal_a"]), ["12", "cal_a"]);
-	});
-
-	it("drops what is not an id rather than refusing the address", () => {
-		assert.deepEqual(readCalendarIds(["", "cal_a", null, { id: "x" }]), [
-			"cal_a",
-		]);
-	});
-});
-
-describe("calendarSearchSchema", () => {
-	it("carries the ticked calendars", () => {
-		assert.deepEqual(calendarSearchSchema.parse({ calendarId: "cal_a" }), {
-			calendarId: ["cal_a"],
-		});
-		assert.deepEqual(
-			calendarSearchSchema.parse({ calendarId: ["cal_b", "cal_a"] }),
-			{ calendarId: ["cal_a", "cal_b"] },
-		);
-	});
-
-	it("leaves the param out where nothing is ticked off", () => {
-		// Absent rather than empty: the router writes no param for `undefined`, so
-		// a calendar showing everything is one the query says nothing about.
-		assert.equal(calendarSearchSchema.parse({}).calendarId, undefined);
-		assert.equal(
-			calendarSearchSchema.parse({ calendarId: [] }).calendarId,
-			undefined,
-		);
-		assert.equal(
-			calendarSearchSchema.parse({ calendarId: ["", null] }).calendarId,
-			undefined,
-		);
-	});
-
-	it("strips a param that is not the calendar's to carry", () => {
-		const parsed = calendarSearchSchema.parse({
-			calendarId: ["cal_a"],
-			q: "invoice",
-			// Density is a device preference, so an address naming one is ignored
-			// rather than obeyed: a link must not resize another reader's day.
-			density: "compact",
-			date: "2026-06-10",
-		});
-		assert.deepEqual(parsed, { calendarId: ["cal_a"] });
-	});
-});
-
-describe("density is not URL state", () => {
-	it("has no reading in the query", () => {
-		assert.deepEqual(calendarSearchSchema.parse({ density: "compact" }), {});
-	});
-});

package/src/lib/calendar-route.ts

@@ -1,197 +0,0 @@
-/**
- * The calendar's address, read and written in one place.
- *
- * `/calendar/{view}/{date}` and, under it, the event a reader has open. The
- * five zoom levels are mutually exclusive and each is a different surface, so
- * the view is a path segment (R5); the date is one too, because the strip is
- * infinite and the address has to name where it opened — a `?date=` param
- * would be a query compensating for a missing segment (R4). What the reader
- * has ticked off modifies the view without changing what is mounted, so the
- * calendar filter is query (R2), validated here rather than at the read site
- * (R7).
- *
- * Nothing here reads a clock. Every function takes the instant it needs, so
- * "today" is a decision the caller makes once and this module can be tested
- * without one.
- */
-import type { CalendarViewId } from "@remit/ui";
-import { z } from "zod";
-
-/** The zoom ladder, widest first. The union `@remit/ui` already publishes. */
-export const calendarViews = [
-	"year",
-	"month",
-	"week",
-	"day",
-	"agenda",
-] as const satisfies readonly CalendarViewId[];
-
-const calendarViewSchema = z.enum(calendarViews);
-
-/** Where `/calendar` sends a reader who named no zoom of their own. */
-export const DEFAULT_CALENDAR_VIEW: CalendarViewId = "week";
-
-/**
- * The views the grid draws. The year is a named surface that arrives in a later
- * stage, and it says so on screen rather than matching a route that renders
- * nothing.
- */
-const GRID_VIEWS = new Set<CalendarViewId>(["month", "week", "day"]);
-
-export const calendarViewMountsGrid = (view: CalendarViewId): boolean =>
-	GRID_VIEWS.has(view);
-
-/**
- * The one view the strip draws. It is a zoom of the same ladder rather than a
- * different screen: the grid is what a reader drops into for a day that has
- * earned it, and the strip is what they come back out to, with the day and the
- * ticked calendars they left with.
- */
-export const calendarViewMountsAgenda = (view: CalendarViewId): boolean =>
-	view === "agenda";
-
-/** The view a segment names, or `undefined` where it names none. */
-export function parseCalendarView(segment: string): CalendarViewId | undefined {
-	const parsed = calendarViewSchema.safeParse(segment);
-	return parsed.success ? parsed.data : undefined;
-}
-
-const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
-
-/**
- * The day a segment names, or `undefined`. A date the calendar does not have —
- * the 31st of February, the 13th month — is not a day, so it is rejected
- * rather than rolled forward into one the reader did not ask for.
- */
-export function parseCalendarDate(segment: string): string | undefined {
-	if (!ISO_DATE.test(segment)) return undefined;
-	const [year, month, day] = segment.split("-").map(Number);
-	const instant = Date.UTC(year, month - 1, day);
-	const round = new Date(instant);
-	if (round.getUTCFullYear() !== year) return undefined;
-	if (round.getUTCMonth() !== month - 1) return undefined;
-	if (round.getUTCDate() !== day) return undefined;
-	return segment;
-}
-
-const pad = (value: number): string => String(value).padStart(2, "0");
-
-/** The day an instant falls on, by the clock the reader's device is running. */
-export function isoDate(instant: Date): string {
-	return `${instant.getFullYear()}-${pad(instant.getMonth() + 1)}-${pad(
-		instant.getDate(),
-	)}`;
-}
-
-export interface CalendarParams {
-	view: CalendarViewId;
-	date: string;
-}
-
-/**
- * The address a pair of segments resolves to.
- *
- * A hand-edited or stale URL is a normal thing to receive, so an unreadable
- * segment is replaced rather than thrown: the half that was readable is kept,
- * and the reader lands on a calendar instead of an error. The caller compares
- * this with what it was given and redirects when they differ, so the address
- * bar ends up naming exactly what is on screen.
- */
-export function canonicalCalendarParams(
-	segments: { view: string; date: string },
-	today: string,
-): CalendarParams {
-	return {
-		view: parseCalendarView(segments.view) ?? DEFAULT_CALENDAR_VIEW,
-		date: parseCalendarDate(segments.date) ?? today,
-	};
-}
-
-/**
- * The day the previous or next screenful starts on. A step is measured in the
- * view's own unit, which is what makes back-and-forward land where the reader
- * came from at every zoom. Agenda steps a week, which is far enough to be worth
- * a press and near enough to stay inside the days it is already holding.
- */
-export function stepCalendarDate(
-	date: string,
-	view: CalendarViewId,
-	direction: -1 | 1,
-): string {
-	const [year, month, day] = date.split("-").map(Number);
-	if (view === "year") return clampedDate(year + direction, month, day);
-	if (view === "month") return clampedDate(year, month + direction, day);
-	const days = view === "day" ? 1 : 7;
-	const stepped = new Date(Date.UTC(year, month - 1, day + days * direction));
-	return isoDateUtc(stepped);
-}
-
-const isoDateUtc = (instant: Date): string =>
-	`${instant.getUTCFullYear()}-${pad(instant.getUTCMonth() + 1)}-${pad(
-		instant.getUTCDate(),
-	)}`;
-
-/**
- * A month or a year away from a date, held to a day that month has. Stepping
- * off the 31st of March must land in February rather than skipping it.
- */
-function clampedDate(year: number, month: number, day: number): string {
-	const normalisedYear = year + Math.floor((month - 1) / 12);
-	const normalisedMonth = ((((month - 1) % 12) + 12) % 12) + 1;
-	const lastDay = new Date(
-		Date.UTC(normalisedYear, normalisedMonth, 0),
-	).getUTCDate();
-	return `${normalisedYear}-${pad(normalisedMonth)}-${pad(
-		Math.min(day, lastDay),
-	)}`;
-}
-
-/**
- * A calendar's id, as the URL carries it.
- *
- * Deliberately looser than the id the API mints. An address is something people
- * paste, bookmark and hand-edit, and what to do with an id that names no
- * calendar is already settled downstream: the reader is shown the calendars
- * that do exist. Refusing the segment here would turn a stale link into an
- * error page instead of a calendar.
- */
-const calendarIdSchema = z.string().min(1);
-
-/**
- * The calendars a query string has ticked.
- *
- * Repeated `calendarId=` params are the shape, and the shape the address is
- * written back in (`lib/search-params.ts`). They arrive here in three readings
- * all the same: a list from repeated params, a scalar from a single one, and a
- * number where the id looked like one. One set of ticked calendars has one
- * spelling, which is what deduplicating and sorting is for.
- */
-export function readCalendarIds(value: unknown): string[] {
-	const raw = value === undefined || value === null ? [] : [value].flat();
-	const named = new Set<string>();
-	for (const entry of raw) {
-		if (typeof entry !== "string" && typeof entry !== "number") continue;
-		const id = calendarIdSchema.safeParse(String(entry));
-		if (id.success) named.add(id.data);
-	}
-	return [...named].sort();
-}
-
-/**
- * What the calendar reads out of the query, and all of it.
- *
- * Ticking nothing off leaves the param out rather than writing an empty list:
- * the address states what a reader has narrowed to, so a calendar showing
- * everything is a calendar the query has nothing to say about.
- *
- * Density is absent on purpose: it is how much of a day this device fits on
- * screen, which is a preference the device holds (`lib/calendar-density.ts`)
- * rather than a fact about the view, so it belongs to no tier of the address.
- */
-export const calendarSearchSchema = z.object({
-	calendarId: z
-		.preprocess(readCalendarIds, z.array(calendarIdSchema))
-		.transform((ids) => (ids.length === 0 ? undefined : ids)),
-});
-
-export type CalendarSearch = z.infer<typeof calendarSearchSchema>;

package/src/lib/calendar-subscription.ts

@@ -1,11 +0,0 @@
-/**
- * Where a subscribed calendar's events come from, named by host alone. For a
- * Google feed the full address is the credential, so no surface draws it.
- */
-export const subscriptionHostOf = (subscriptionUrl: string): string =>
-	URL.canParse(subscriptionUrl)
-		? new URL(subscriptionUrl).host
-		: "an iCalendar feed";
-
-export const subscriptionReadOnlyNote = (subscriptionUrl: string): string =>
-	`Read-only: from ${subscriptionHostOf(subscriptionUrl)}. Change it where the feed comes from.`;

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

@@ -1,189 +0,0 @@
-/**
- * What a suggestion's state asks of its card, and what the day it lands on
- * already holds (#1277).
- *
- * The card is drawn off these answers alone, so a state mapped wrong is a card
- * that asks for an answer the server will refuse — a button that can only fail.
- */
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import {
-	type CalendarSuggestion,
-	clashesOver,
-	inviteStanding,
-	slotOffersOn,
-	toCalendarInvite,
-	toEventSuggestion,
-} from "./calendar-suggestion";
-
-const suggestion = (
-	over: Partial<CalendarSuggestion> = {},
-): CalendarSuggestion => ({
-	suggestionId: "sug-1",
-	accountConfigId: "cfg-1",
-	messageId: "msg-1",
-	bodyPartId: "part-1",
-	icalUid: "uid-1",
-	sequence: 0,
-	method: "Request",
-	source: "IcalendarPart",
-	state: "Pending",
-	summary: "Quarterly review",
-	dtStart: "2026-09-01T08:00:00+00:00",
-	dtEnd: "2026-09-01T09:00:00+00:00",
-	endsAtUtc: "2026-09-01T09:00:00Z",
-	allDay: false,
-	location: "",
-	organizer: "organizer@example.test",
-	zoneCertainty: "Explicit",
-	acceptedCalendarObjectId: "",
-	supersededByMessageId: "",
-	supersededByThreadId: "",
-	createdAt: 0,
-	updatedAt: 0,
-	answerOvertakenBy: "None",
-	...over,
-});
-
-const context = {
-	threadId: "thr-1",
-	threadSubject: "Quarterly review",
-	senderName: "Organizer",
-	calendarId: "cal-1",
-};
-
-describe("inviteStanding", () => {
-	it("asks for an answer only while the suggestion is pending", () => {
-		assert.deepEqual(inviteStanding(suggestion()), {
-			state: "pending",
-			rsvp: "noReply",
-		});
-		assert.deepEqual(inviteStanding(suggestion({ state: "Accepted" })), {
-			state: "answered",
-			rsvp: "accepted",
-		});
-		assert.deepEqual(inviteStanding(suggestion({ state: "Declined" })), {
-			state: "answered",
-			rsvp: "declined",
-		});
-		assert.deepEqual(inviteStanding(suggestion({ state: "Superseded" })), {
-			state: "superseded",
-			rsvp: "noReply",
-		});
-	});
-
-	it("keeps a card the reader waved away, so it can be taken back", () => {
-		assert.deepEqual(inviteStanding(suggestion({ state: "Dismissed" })), {
-			state: "dismissed",
-			rsvp: "noReply",
-		});
-		assert.equal(
-			inviteStanding(suggestion({ method: "Cancel", state: "Dismissed" })),
-			undefined,
-		);
-	});
-
-	it("asks about a cancellation only until it is taken or kept", () => {
-		assert.deepEqual(inviteStanding(suggestion({ method: "Cancel" })), {
-			state: "cancelled",
-			rsvp: "noReply",
-		});
-		assert.equal(
-			inviteStanding(suggestion({ method: "Cancel", state: "Accepted" })),
-			undefined,
-		);
-	});
-});
-
-describe("toCalendarInvite", () => {
-	it("names the organiser, and the sender when the invitation names none", () => {
-		assert.equal(
-			toCalendarInvite(suggestion(), "pending", context).organizerName,
-			"organizer@example.test",
-		);
-		assert.equal(
-			toCalendarInvite(suggestion({ organizer: "" }), "pending", context)
-				.organizerName,
-			"Organizer",
-		);
-	});
-
-	it("gives an untitled event a title rather than a blank heading", () => {
-		const invite = toCalendarInvite(
-			suggestion({ summary: "" }),
-			"pending",
-			context,
-		);
-		assert.equal(invite.proposed.title, "Untitled event");
-	});
-});
-
-describe("toEventSuggestion", () => {
-	it("says so when the zone the time was read on could not be resolved", () => {
-		const reading = toEventSuggestion(
-			suggestion({ zoneCertainty: "Ambiguous", source: "TextHeuristic" }),
-			{ ...context, sender: "Organizer" },
-		);
-		assert.match(reading.ambiguity, /Add opens the editor/);
-		assert.equal(reading.zoneCertainty, "ambiguous");
-		assert.ok(reading.confidence < 1);
-	});
-
-	it("promises no editor for a cancellation, which Add applies as it is", () => {
-		const reading = toEventSuggestion(
-			suggestion({ zoneCertainty: "Ambiguous", method: "Cancel" }),
-			{ ...context, sender: "Organizer" },
-		);
-		assert.match(reading.ambiguity, /could not be resolved/);
-		assert.doesNotMatch(reading.ambiguity, /editor/);
-	});
-});
-
-describe("clashesOver", () => {
-	it("names every busy stretch the span runs into and nothing beside it", () => {
-		const clashes = clashesOver(
-			{ start: "2026-09-01T08:00:00+00:00", end: "2026-09-01T09:00:00+00:00" },
-			[
-				{
-					start: "2026-09-01T07:00:00+00:00",
-					end: "2026-09-01T08:00:00+00:00",
-				},
-				{
-					start: "2026-09-01T08:30:00+00:00",
-					end: "2026-09-01T09:30:00+00:00",
-				},
-				{
-					start: "2026-09-01T09:00:00+00:00",
-					end: "2026-09-01T10:00:00+00:00",
-				},
-			],
-		);
-		assert.equal(clashes.length, 1);
-		assert.match(clashes[0].label, /^Busy /);
-	});
-});
-
-describe("slotOffersOn", () => {
-	it("offers half-hours out of the free time only", () => {
-		const date = "2026-09-01";
-		const offers = slotOffersOn(date, []);
-		assert.ok(offers.length > 0);
-		assert.ok(offers.length <= 6);
-		for (const offer of offers) {
-			assert.equal(offer.date, date);
-			const [h1, m1] = offer.startTime.split(":").map(Number);
-			const [h2, m2] = offer.endTime.split(":").map(Number);
-			assert.equal(h2 * 60 + m2 - (h1 * 60 + m1), 30);
-		}
-	});
-
-	it("offers nothing on a day booked from end to end", () => {
-		const offers = slotOffersOn("2026-09-01", [
-			{
-				start: new Date("2026-08-31T12:00:00").toISOString(),
-				end: new Date("2026-09-02T12:00:00").toISOString(),
-			},
-		]);
-		assert.deepEqual(offers, []);
-	});
-});