@remit/web-client 0.0.324 → 0.0.326

package/src/hooks/calendar/agenda-window.test.ts

@@ -1,392 +0,0 @@
-/**
- * The rolling range, and the busy time it is measured against.
- *
- * The strip never paginates, so the claims here are about continuity: reaching
- * an end grows the run rather than replacing it, a day already held keeps the
- * days either side of it, and a jump opens a window where it landed. The
- * free-time half asserts that busy spans the strip did not draw still take the
- * hours they cover — the rule itself is `@remit/ui`'s, and this only decides
- * which spans a day gets.
- *
- * The window a day names is a civil date, and the clock time carried on it is
- * the device's own — so every case here is asserted in more than one zone. A
- * window boundary asserted only in UTC would miss the hour a DST change hides
- * from anything that measures it as elapsed time instead of a calendar date.
- */
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { freeStretchesFromSpans } from "@remit/ui";
-import {
-	busySpansByDate,
-	CAP_WEEKS,
-	datesInRange,
-	extendRangeEnd,
-	extendRangeStart,
-	freeStretchesByDate,
-	LEAD_IN,
-	LEAD_OUT,
-	liftRangeCeiling,
-	liftRangeFloor,
-	PAGE,
-	rangeAround,
-	rangeAtCeiling,
-	rangeAtFloor,
-	rangeCovering,
-	weekKeyOf,
-	weekWindowsOver,
-} from "./agenda-window.js";
-import { addDays, calendarWindow, startOfDay } from "./window.js";
-
-const DATE = "2026-06-10";
-
-/** The offset this machine is on, so a fixture reads the same in any zone. */
-const offsetOn = (date: string): string => startOfDay(date).slice(19);
-
-const at = (date: string, time: string): string =>
-	`${date}T${time}:00${offsetOn(date)}`;
-
-const clocks = (
-	stretches: readonly { startMinute: number; endMinute: number }[],
-): string[] =>
-	stretches.map(
-		(stretch) =>
-			`${Math.floor(stretch.startMinute / 60)}–${Math.floor(stretch.endMinute / 60)}`,
-	);
-
-/** The days between two civil dates, ignoring whatever offset each one carries. */
-const daysBetween = (from: string, to: string): number =>
-	(Date.parse(to.slice(0, 10)) - Date.parse(from.slice(0, 10))) / 86_400_000;
-
-/** The zones a reader's device might be on, asserted so a body cannot pass silently. */
-const ZONES = [
-	{ name: "UTC", hourAtNoonUtc: 12 },
-	{ name: "Europe/Amsterdam", hourAtNoonUtc: 14 },
-	{ name: "America/New_York", hourAtNoonUtc: 8 },
-];
-
-function inEveryZone(body: () => void): void {
-	const before = process.env.TZ;
-	try {
-		for (const zone of ZONES) {
-			process.env.TZ = zone.name;
-			assert.equal(
-				new Date("2026-06-11T12:00:00Z").getHours(),
-				zone.hourAtNoonUtc,
-				`the machine never moved to ${zone.name}`,
-			);
-			body();
-		}
-	} finally {
-		if (before === undefined) delete process.env.TZ;
-		else process.env.TZ = before;
-	}
-}
-
-describe("the days the strip holds", () => {
-	it("opens further ahead than behind, because a diary is read forwards", () => {
-		inEveryZone(() => {
-			const range = rangeAround(DATE);
-			assert.equal(range.from, "2026-05-31");
-			assert.equal(range.to, "2026-07-04");
-			assert.equal(datesInRange(range).length, LEAD_IN + LEAD_OUT + 1);
-		});
-	});
-
-	it("grows the run at whichever end was reached, keeping the other", () => {
-		inEveryZone(() => {
-			const range = rangeAround(DATE);
-			assert.deepEqual(extendRangeStart(range), {
-				...range,
-				from: "2026-05-24",
-			});
-			assert.deepEqual(extendRangeEnd(range), { ...range, to: "2026-07-11" });
-			assert.equal(
-				datesInRange(extendRangeEnd(range)).length,
-				datesInRange(range).length + PAGE,
-			);
-		});
-	});
-
-	it("keeps the run a day is already in, so a scroll refetches nothing", () => {
-		inEveryZone(() => {
-			const range = rangeAround(DATE);
-			for (const day of ["2026-05-31", DATE, "2026-06-28", "2026-07-04"]) {
-				assert.equal(rangeCovering(range, day), range, `${day} moved the run`);
-			}
-		});
-	});
-
-	it("opens a window where a jump landed rather than stretching to it", () => {
-		inEveryZone(() => {
-			const range = rangeAround(DATE);
-			assert.deepEqual(
-				rangeCovering(range, "2026-11-02"),
-				rangeAround("2026-11-02"),
-			);
-			assert.deepEqual(
-				rangeCovering(range, "2026-01-05"),
-				rangeAround("2026-01-05"),
-			);
-		});
-	});
-});
-
-/**
- * The strip is shorter than the distance it fetches at whenever the diary is
- * sparse, so an end measured off the content is reached on the first layout
- * pass and stays reached however many days arrive. What stops that is the
- * strip only growing on a scroll the reader drove; this is the backstop that
- * makes the runaway it caused — a two-event diary walking out to 2032, with the
- * address following it — arithmetically impossible rather than merely unlikely.
- */
-describe("how far the run grows before it asks", () => {
-	const CAP_DAYS = CAP_WEEKS * 7;
-
-	/** Far more reaches than a year of weeks needs, so the cap is what stops it. */
-	const reachEnd = (range = rangeAround(DATE), times = 200) => {
-		let grown = range;
-		for (let reach = 0; reach < times; reach += 1)
-			grown = extendRangeEnd(grown);
-		return grown;
-	};
-
-	const reachStart = (range = rangeAround(DATE), times = 200) => {
-		let grown = range;
-		for (let reach = 0; reach < times; reach += 1)
-			grown = extendRangeStart(grown);
-		return grown;
-	};
-
-	it("stops a year either way, however often an end is reached", () => {
-		inEveryZone(() => {
-			const range = reachEnd(reachStart());
-			assert.equal(range.from, addDays(DATE, -CAP_DAYS));
-			assert.equal(range.to, addDays(DATE, CAP_DAYS));
-			assert.equal(rangeAtFloor(range), true);
-			assert.equal(rangeAtCeiling(range), true);
-		});
-	});
-
-	it("hands back the run it was given at the cap, so nothing refetches", () => {
-		inEveryZone(() => {
-			const capped = reachEnd();
-			assert.equal(extendRangeEnd(capped), capped);
-			const behind = reachStart();
-			assert.equal(extendRangeStart(behind), behind);
-		});
-	});
-
-	it("opens the next year where the reader asked, keeping the days held", () => {
-		inEveryZone(() => {
-			const capped = reachEnd();
-			const more = liftRangeCeiling(capped);
-			assert.equal(more.from, capped.from);
-			assert.equal(more.to, addDays(capped.to, PAGE));
-			assert.equal(rangeAtCeiling(more), false);
-			assert.equal(rangeAtFloor(more), false);
-		});
-	});
-
-	it("does the same behind, without moving the end ahead", () => {
-		inEveryZone(() => {
-			const capped = reachStart();
-			const more = liftRangeFloor(capped);
-			assert.equal(more.to, capped.to);
-			assert.equal(more.from, addDays(capped.from, -PAGE));
-			assert.equal(rangeAtFloor(more), false);
-		});
-	});
-
-	it("gives a jump its own year, measured from where it landed", () => {
-		inEveryZone(() => {
-			const jumped = rangeCovering(reachEnd(), "2028-03-01");
-			assert.deepEqual(jumped, rangeAround("2028-03-01"));
-			assert.equal(rangeAtCeiling(jumped), false);
-		});
-	});
-});
-
-/**
- * The range is not a window. A read may not cover more than a year
- * (`CALENDAR_MAX_WINDOW_DAYS`), and the strip's range grows every time the
- * reader reaches an end, so the range names weeks to fetch rather than being
- * one request that eventually gets refused.
- */
-describe("the weeks a range is fetched as", () => {
-	it("is the grid's own window for each week, once each", () => {
-		inEveryZone(() => {
-			const windows = weekWindowsOver(datesInRange(rangeAround(DATE)));
-			for (const window of windows) {
-				assert.deepEqual(
-					window,
-					calendarWindow("week", window.from.slice(0, 10)),
-				);
-			}
-			assert.equal(new Set(windows.map((w) => w.from)).size, windows.length);
-		});
-	});
-
-	/**
-	 * What a strip that has just opened issues, and all it issues: the six weeks
-	 * its opening run falls in. Anything past those is a week the reader has
-	 * scrolled to.
-	 */
-	it("is the six weeks the opening run falls in, and no more", () => {
-		inEveryZone(() => {
-			assert.equal(weekWindowsOver(datesInRange(rangeAround(DATE))).length, 6);
-		});
-	});
-
-	it("covers every day the strip holds and nothing before or after", () => {
-		inEveryZone(() => {
-			const dates = datesInRange(rangeAround(DATE));
-			const held = new Set(weekWindowsOver(dates).map((window) => window.from));
-			for (const date of dates) assert.ok(held.has(weekKeyOf(date)));
-		});
-	});
-
-	it("names the week a day belongs to, Monday to Monday", () => {
-		inEveryZone(() => {
-			// 2026-06-10 is a Wednesday; its week opens on the 8th.
-			assert.equal(weekKeyOf("2026-06-10"), startOfDay("2026-06-08"));
-			assert.equal(weekKeyOf("2026-06-08"), startOfDay("2026-06-08"));
-			assert.equal(weekKeyOf("2026-06-14"), startOfDay("2026-06-08"));
-			assert.equal(weekKeyOf("2026-06-15"), startOfDay("2026-06-15"));
-		});
-	});
-
-	it("asks for one week however far the reader scrolls", () => {
-		inEveryZone(() => {
-			// Past the server's 366-day ceiling in both directions.
-			let range = rangeAround(DATE);
-			for (let reach = 0; reach < 30; reach += 1) {
-				range = extendRangeEnd(extendRangeStart(range));
-			}
-			const dates = datesInRange(range);
-			assert.ok(dates.length > 366, "the range never grew past the ceiling");
-
-			for (const window of weekWindowsOver(dates)) {
-				const days = daysBetween(window.from, window.to);
-				assert.equal(days, 7, `a window covered ${days} days`);
-			}
-		});
-	});
-
-	it("grows by adding weeks rather than by widening one", () => {
-		inEveryZone(() => {
-			const opening = weekWindowsOver(datesInRange(rangeAround(DATE)));
-			const wider = weekWindowsOver(
-				datesInRange(extendRangeStart(rangeAround(DATE))),
-			);
-			const kept = new Set(wider.map((window) => window.from));
-			for (const window of opening) {
-				assert.ok(kept.has(window.from), `${window.from} was given up`);
-			}
-			assert.ok(wider.length > opening.length);
-		});
-	});
-});
-
-describe("busy time, split into the days it covers", () => {
-	const dates = ["2026-06-10", "2026-06-11", "2026-06-12"];
-
-	it("reads a span as minutes of the day it falls on", () => {
-		inEveryZone(() => {
-			const byDate = busySpansByDate(dates, [
-				{ start: at("2026-06-10", "09:00"), end: at("2026-06-10", "10:30") },
-			]);
-			assert.deepEqual(byDate.get("2026-06-10"), [{ from: 540, to: 630 }]);
-			assert.equal(byDate.get("2026-06-11"), undefined);
-		});
-	});
-
-	it("gives a span crossing midnight one entry per day it touches", () => {
-		inEveryZone(() => {
-			const byDate = busySpansByDate(dates, [
-				{ start: at("2026-06-10", "22:00"), end: at("2026-06-11", "02:00") },
-			]);
-			assert.deepEqual(byDate.get("2026-06-10"), [{ from: 1320, to: 1440 }]);
-			assert.deepEqual(byDate.get("2026-06-11"), [{ from: 0, to: 120 }]);
-		});
-	});
-
-	it("leaves no entry on the day a span merely ends at midnight of", () => {
-		inEveryZone(() => {
-			const byDate = busySpansByDate(dates, [
-				{ start: at("2026-06-10", "22:00"), end: at("2026-06-11", "00:00") },
-			]);
-			assert.deepEqual(byDate.get("2026-06-10"), [{ from: 1320, to: 1440 }]);
-			assert.equal(byDate.get("2026-06-11"), undefined);
-		});
-	});
-
-	it("merges spans that run into each other into the hours they cover", () => {
-		inEveryZone(() => {
-			const byDate = busySpansByDate(dates, [
-				{ start: at("2026-06-10", "11:00"), end: at("2026-06-10", "12:00") },
-				{ start: at("2026-06-10", "09:00"), end: at("2026-06-10", "11:30") },
-			]);
-			assert.deepEqual(byDate.get("2026-06-10"), [{ from: 540, to: 720 }]);
-		});
-	});
-
-	it("drops a span that is not a stretch of time at all", () => {
-		inEveryZone(() => {
-			const byDate = busySpansByDate(dates, [
-				{ start: at("2026-06-10", "11:00"), end: at("2026-06-10", "11:00") },
-				{ start: "not a date", end: at("2026-06-10", "12:00") },
-			]);
-			assert.equal(byDate.size, 0);
-		});
-	});
-
-	it("ignores busy time outside the days on screen", () => {
-		inEveryZone(() => {
-			const byDate = busySpansByDate(dates, [
-				{ start: at("2026-07-01", "09:00"), end: at("2026-07-01", "10:00") },
-			]);
-			assert.equal(byDate.size, 0);
-		});
-	});
-});
-
-describe("free time, off the spans the server merged", () => {
-	const dates = ["2026-06-10", "2026-06-11"];
-
-	it("answers every day the strip holds, including the untouched ones", () => {
-		inEveryZone(() => {
-			const free = freeStretchesByDate(dates, []);
-			assert.deepEqual([...free.keys()], dates);
-			assert.equal(free.get("2026-06-11")?.[0].wholeDay, true);
-		});
-	});
-
-	/**
-	 * The reader unticked work, so the strip draws nothing on the 10th. They are
-	 * still in meetings all morning, and "Free all day" would be the one thing
-	 * this view must never say.
-	 */
-	it("takes hours out of a day the strip is drawing nothing on", () => {
-		inEveryZone(() => {
-			const free = freeStretchesByDate(dates, [
-				{ start: at("2026-06-10", "09:00"), end: at("2026-06-10", "12:00") },
-				{ start: at("2026-06-10", "13:00"), end: at("2026-06-10", "16:00") },
-			]);
-			assert.deepEqual(clocks(free.get("2026-06-10") ?? []), ["16–22"]);
-			assert.equal(free.get("2026-06-10")?.[0].wholeDay, false);
-		});
-	});
-
-	it("is the rule `@remit/ui` states, applied to those spans", () => {
-		inEveryZone(() => {
-			const spans = [{ from: 9 * 60, to: 12 * 60 }];
-			const free = freeStretchesByDate(dates, [
-				{ start: at("2026-06-10", "09:00"), end: at("2026-06-10", "12:00") },
-			]);
-			assert.deepEqual(
-				free.get("2026-06-10"),
-				freeStretchesFromSpans("2026-06-10", spans),
-			);
-		});
-	});
-});

package/src/hooks/calendar/agenda-window.ts

@@ -1,210 +0,0 @@
-/**
- * The days the strip currently holds, and the arithmetic that grows them.
- *
- * The agenda never paginates. It holds one contiguous run of days around the
- * day the address names and grows it at whichever end the reader reaches, so
- * there are no page boundaries to lose a place at and no request that throws
- * away what is already on screen. The range is the only thing a window is: what
- * to ask `/calendar-events` and `/calendar-free-busy` for falls out of it.
- *
- * Nothing here reads a clock or a router. Every function takes the day it works
- * from, which is what lets the rules be asserted without either.
- */
-import {
-	type BusySpan,
-	type CalendarDay,
-	datesBetween,
-	type FreeStretch,
-	freeStretchesFromSpans,
-	mergeBusySpans,
-} from "@remit/ui";
-import { isoDate } from "@/lib/calendar-route";
-import { addDays, type CalendarWindow, calendarWindow } from "./window";
-
-/**
- * Days held behind and ahead of the day the address opened on. More ahead than
- * behind: a reader lands on a calendar to look forward, and the days behind are
- * there so scrolling back a little does not immediately fetch.
- */
-export const LEAD_IN = 10;
-export const LEAD_OUT = 24;
-
-/** What reaching an end adds to it: the next week, and no more. */
-export const PAGE = 7;
-
-/**
- * How far the run grows on the reader's scroll before it stops and asks.
- *
- * A year either way is further than anyone scrolls in one sitting, so the cap
- * costs a reader nothing and bounds the damage of anything that asks for more
- * days without one behind it. The strip is shorter than the reach it fetches at
- * whenever the diary is sparse, and a run that grew on that alone walked out to
- * a decade of empty weeks and took the address with it.
- */
-export const CAP_WEEKS = 52;
-const CAP_DAYS = CAP_WEEKS * 7;
-
-export interface AgendaRange {
-	/** `YYYY-MM-DD`, inclusive. */
-	from: string;
-	/** `YYYY-MM-DD`, inclusive. */
-	to: string;
-	/** The earliest day scrolling alone may reach. */
-	floor: string;
-	/** The latest. */
-	ceiling: string;
-}
-
-export const rangeAround = (date: string): AgendaRange => ({
-	from: addDays(date, -LEAD_IN),
-	to: addDays(date, LEAD_OUT),
-	floor: addDays(date, -CAP_DAYS),
-	ceiling: addDays(date, CAP_DAYS),
-});
-
-/** The run has grown as far back as it may on its own. */
-export const rangeAtFloor = (range: AgendaRange): boolean =>
-	range.from <= range.floor;
-
-export const rangeAtCeiling = (range: AgendaRange): boolean =>
-	range.to >= range.ceiling;
-
-const later = (a: string, b: string): string => (a > b ? a : b);
-const earlier = (a: string, b: string): string => (a < b ? a : b);
-
-/** At the cap this is the range it was given, identically, so nothing refetches. */
-export const extendRangeStart = (range: AgendaRange): AgendaRange =>
-	rangeAtFloor(range)
-		? range
-		: { ...range, from: later(addDays(range.from, -PAGE), range.floor) };
-
-export const extendRangeEnd = (range: AgendaRange): AgendaRange =>
-	rangeAtCeiling(range)
-		? range
-		: { ...range, to: earlier(addDays(range.to, PAGE), range.ceiling) };
-
-/**
- * The cap lifted, by a reader who said so. Another year opens behind the day
- * the run has reached and the days already held stay where they are, so the
- * strip keeps growing on the scroll from there.
- */
-export const liftRangeFloor = (range: AgendaRange): AgendaRange =>
-	extendRangeStart({ ...range, floor: addDays(range.from, -CAP_DAYS) });
-
-export const liftRangeCeiling = (range: AgendaRange): AgendaRange =>
-	extendRangeEnd({ ...range, ceiling: addDays(range.to, CAP_DAYS) });
-
-/**
- * The range that has a day in it. A day already held keeps the range it is in —
- * identically, so a scroll that moved the address does not throw away the days
- * either side of it and refetch them. A day outside it is a jump, and a jump
- * opens a window around where it landed rather than stretching one across the
- * months in between.
- */
-export function rangeCovering(range: AgendaRange, date: string): AgendaRange {
-	if (date >= range.from && date <= range.to) return range;
-	return rangeAround(date);
-}
-
-/**
- * The week each day of the range is served by, deduplicated and in order.
- *
- * The strip holds more days than one read may ask for — the server refuses a
- * window over a year — so the range says which weeks to fetch rather than being
- * a window itself. Reaching an end then adds a week to this list instead of
- * widening a single request, which is what keeps the days already on screen
- * where they are.
- *
- * The weeks are `calendarWindow("week", …)` exactly, so they are the grid's own
- * cache entries: a reader who drops into the week grid and comes back out draws
- * from what the strip fetched, and a week the grid has already read costs the
- * strip nothing.
- */
-export function weekWindowsOver(dates: readonly string[]): CalendarWindow[] {
-	const byStart = new Map<string, CalendarWindow>();
-	for (const date of dates) {
-		const week = calendarWindow("week", date);
-		if (!byStart.has(week.from)) byStart.set(week.from, week);
-	}
-	return [...byStart.values()];
-}
-
-/** The week window a day belongs to, named by its `from`. */
-export const weekKeyOf = (date: string): string =>
-	calendarWindow("week", date).from;
-
-const MINUTES_IN_DAY = 24 * 60;
-
-const minuteOfInstant = (instant: Date): number =>
-	instant.getHours() * 60 + instant.getMinutes();
-
-/**
- * Busy spans as minutes of the days they cross, on the clock this device is
- * reading. The API answers in UTC instants because a busy stretch is an
- * interval rather than a civil date, so the split into days happens here, where
- * the zone the strip is drawn in is known.
- *
- * A span crossing midnight becomes one entry per day it touches. Each day's
- * entries come back sorted and merged, which is the shape the free-time rule
- * takes.
- */
-export function busySpansByDate(
-	dates: readonly string[],
-	spans: readonly { start: string; end: string }[],
-): Map<string, BusySpan[]> {
-	const held = new Set(dates);
-	const byDate = new Map<string, BusySpan[]>();
-
-	for (const span of spans) {
-		const start = new Date(span.start);
-		const end = new Date(span.end);
-		if (Number.isNaN(start.getTime()) || Number.isNaN(end.getTime())) continue;
-		if (end.getTime() <= start.getTime()) continue;
-
-		const firstDate = isoDate(start);
-		// The instant before the end, so a span ending at midnight belongs to the
-		// day it ran through rather than opening an empty entry on the next one.
-		const lastDate = isoDate(new Date(end.getTime() - 1));
-		for (let date = firstDate; date <= lastDate; date = addDays(date, 1)) {
-			if (!held.has(date)) continue;
-			const from = date === firstDate ? minuteOfInstant(start) : 0;
-			// Read off the end's own day rather than off the loop: a span ending at
-			// midnight belongs to the day it ran through, where its end is the end
-			// of that day and not minute zero of the next one.
-			const to = isoDate(end) === date ? minuteOfInstant(end) : MINUTES_IN_DAY;
-			if (to <= from) continue;
-			const day = byDate.get(date);
-			if (day) day.push({ from, to });
-			else byDate.set(date, [{ from, to }]);
-		}
-	}
-
-	for (const [date, day] of byDate) byDate.set(date, mergeBusySpans(day));
-	return byDate;
-}
-
-/**
- * The free time on every day the strip holds, out of the busy spans the server
- * merged across every calendar. It is `freeStretchesFromSpans` and nothing
- * else: the rule lives in `@remit/ui` beside the strip that draws it, so this
- * only decides which spans a day gets.
- */
-export function freeStretchesByDate(
-	dates: readonly string[],
-	spans: readonly { start: string; end: string }[],
-): Map<string, FreeStretch[]> {
-	const busy = busySpansByDate(dates, spans);
-	return new Map(
-		dates.map((date) => [
-			date,
-			freeStretchesFromSpans(date, busy.get(date) ?? []),
-		]),
-	);
-}
-
-/** The days a range names, in order. */
-export const datesInRange = (range: AgendaRange): string[] =>
-	datesBetween(range.from, range.to);
-
-/** How the strip asks a day what is still open on it. */
-export type FreeLookup = (day: CalendarDay) => FreeStretch[];