@remit/web-client 0.0.325 → 0.0.327

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

@@ -1,189 +0,0 @@
-/**
- * The window a view asks the server about.
- *
- * What matters is that the window is a property of the screenful rather than of
- * the day the address happens to name: every day inside one week has to produce
- * the same `from` and `to`, because that is what makes stepping back to a week
- * already read a cache hit instead of a second request for the same days.
- *
- * A window carries the device's own offsets, so those assertions are about
- * civil dates and about windows agreeing with each other rather than about a
- * literal `+02:00` that would only hold on a runner in Amsterdam. The zoned
- * times below are the opposite: absolute, because the whole point of them is
- * that the runner's zone stays out.
- */
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import {
-	addDays,
-	calendarWindow,
-	calendarWindowOfDays,
-	isoAt,
-	isoAtInZone,
-	isoOnClock,
-} from "./window";
-
-const day = (iso: string): string => iso.slice(0, 10);
-
-const OFFSET = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:00[+-]\d{2}:\d{2}$/;
-
-describe("the window a view covers", () => {
-	it("takes the whole week a day falls in, starting Monday", () => {
-		const window = calendarWindow("week", "2026-06-10");
-		assert.equal(day(window.from), "2026-06-08");
-		assert.equal(day(window.to), "2026-06-15");
-	});
-
-	it("gives every day of one week the same window", () => {
-		const monday = calendarWindow("week", "2026-06-08");
-		for (const date of ["2026-06-09", "2026-06-11", "2026-06-14"]) {
-			assert.deepEqual(calendarWindow("week", date), monday);
-		}
-	});
-
-	it("takes one day at the day zoom", () => {
-		const window = calendarWindow("day", "2026-06-10");
-		assert.equal(day(window.from), "2026-06-10");
-		assert.equal(day(window.to), "2026-06-11");
-	});
-
-	it("takes every week the month touches, so the grid's edge days are read", () => {
-		const window = calendarWindow("month", "2026-07-10");
-		assert.equal(day(window.from), "2026-06-29");
-		assert.equal(day(window.to), "2026-08-03");
-	});
-
-	it("takes exactly the month when it starts on a Monday and ends on a Sunday", () => {
-		const window = calendarWindow("month", "2027-02-14");
-		assert.equal(day(window.from), "2027-02-01");
-		assert.equal(day(window.to), "2027-03-01");
-	});
-
-	it("gives every day of one month the same window", () => {
-		const first = calendarWindow("month", "2026-06-01");
-		for (const date of ["2026-06-15", "2026-06-30"]) {
-			assert.deepEqual(calendarWindow("month", date), first);
-		}
-	});
-
-	it("rolls a December month into the next year", () => {
-		assert.equal(day(calendarWindow("month", "2026-12-31").to), "2027-01-04");
-	});
-
-	it("takes the calendar year", () => {
-		const window = calendarWindow("year", "2026-06-10");
-		assert.equal(day(window.from), "2026-01-01");
-		assert.equal(day(window.to), "2027-01-01");
-	});
-
-	it("gives the agenda the week it steps by, so it shares the grid's entry", () => {
-		assert.deepEqual(
-			calendarWindow("agenda", "2026-06-10"),
-			calendarWindow("week", "2026-06-10"),
-		);
-	});
-
-	it("carries an explicit offset at both ends, as the API asks for", () => {
-		const window = calendarWindow("week", "2026-06-10");
-		assert.match(window.from, OFFSET);
-		assert.match(window.to, OFFSET);
-	});
-});
-
-describe("a window a surface rolls itself", () => {
-	it("runs whole days from the date it was given", () => {
-		const window = calendarWindowOfDays("2026-06-10", 3);
-		assert.equal(day(window.from), "2026-06-10");
-		assert.equal(day(window.to), "2026-06-13");
-	});
-});
-
-describe("civil dates", () => {
-	it("steps across a month boundary", () => {
-		assert.equal(addDays("2026-06-30", 1), "2026-07-01");
-		assert.equal(addDays("2026-03-01", -1), "2026-02-28");
-	});
-
-	it("puts a clock time on a day with the offset that day is on", () => {
-		assert.match(isoAt("2026-06-10", "09:15"), OFFSET);
-		assert.ok(isoAt("2026-06-10", "09:15").startsWith("2026-06-10T09:15:00"));
-	});
-});
-
-/**
- * A named zone's offset, read without touching the runner's own clock. Every
- * expectation here is absolute, because a test that reads the device offset
- * cannot see the bug where the device offset leaked in.
- */
-describe("a clock time in a named zone", () => {
-	it("carries that zone's summer offset", () => {
-		assert.equal(
-			isoAtInZone("2026-06-10", "09:15", "Europe/Amsterdam"),
-			"2026-06-10T09:15:00+02:00",
-		);
-		assert.equal(
-			isoAtInZone("2026-06-10", "09:15", "America/New_York"),
-			"2026-06-10T09:15:00-04:00",
-		);
-	});
-
-	it("carries its winter offset for a winter date", () => {
-		assert.equal(
-			isoAtInZone("2026-01-14", "09:15", "Europe/Amsterdam"),
-			"2026-01-14T09:15:00+01:00",
-		);
-	});
-
-	it("settles a time on the far side of a spring-forward", () => {
-		// The Netherlands moves to +02:00 at 02:00 on 29 March 2026.
-		assert.equal(
-			isoAtInZone("2026-03-29", "09:00", "Europe/Amsterdam"),
-			"2026-03-29T09:00:00+02:00",
-		);
-		assert.equal(
-			isoAtInZone("2026-03-29", "00:30", "Europe/Amsterdam"),
-			"2026-03-29T00:30:00+01:00",
-		);
-	});
-
-	it("handles a zone that is not a whole number of hours off", () => {
-		assert.equal(
-			isoAtInZone("2026-06-10", "09:15", "Asia/Kolkata"),
-			"2026-06-10T09:15:00+05:30",
-		);
-	});
-
-	it("falls back to the device rather than throwing on a zone nothing knows", () => {
-		assert.match(
-			isoAtInZone("2026-06-10", "09:15", "Mars/Olympus_Mons"),
-			OFFSET,
-		);
-	});
-});
-
-describe("an occurrence re-read on the device's clock", () => {
-	it("moves a Tokyo morning to the New York evening before", () => {
-		assert.equal(
-			isoOnClock("2034-02-22T08:00:00+09:00", "America/New_York"),
-			"2034-02-21T18:00:00-05:00",
-		);
-	});
-
-	it("reads each side of a spring-forward on its own offset", () => {
-		assert.equal(
-			isoOnClock("2034-03-20T08:00:00+00:00", "Europe/Amsterdam"),
-			"2034-03-20T09:00:00+01:00",
-		);
-		assert.equal(
-			isoOnClock("2034-03-27T07:00:00+00:00", "Europe/Amsterdam"),
-			"2034-03-27T09:00:00+02:00",
-		);
-	});
-
-	it("falls back to the device rather than throwing on a zone nothing knows", () => {
-		assert.match(
-			isoOnClock("2034-02-22T08:00:00+09:00", "Mars/Olympus_Mons"),
-			OFFSET,
-		);
-	});
-});

package/src/hooks/calendar/window.ts

@@ -1,188 +0,0 @@
-/**
- * The stretch of time a calendar surface is asking the server about.
- *
- * A window is derived from the address rather than from the day the reader
- * happens to be on, so every day inside one week asks for the same window and
- * stepping back to a week already read is a cache hit rather than a request.
- *
- * Nothing here reads a clock: the caller passes the day it is drawing, and the
- * offsets come from that day rather than from today, so a window spanning a DST
- * change carries the right offset at each end.
- */
-import type { CalendarViewId } from "@remit/ui";
-
-export interface CalendarWindow {
-	/** ISO 8601 date-time with offset. Inclusive. */
-	from: string;
-	/** ISO 8601 date-time with offset. Exclusive. */
-	to: string;
-}
-
-const pad = (value: number): string => String(value).padStart(2, "0");
-
-const civil = (instant: Date): string =>
-	`${instant.getUTCFullYear()}-${pad(instant.getUTCMonth() + 1)}-${pad(
-		instant.getUTCDate(),
-	)}`;
-
-const formatOffset = (minutes: number): string => {
-	const sign = minutes < 0 ? "-" : "+";
-	const size = Math.abs(minutes);
-	return `${sign}${pad(Math.floor(size / 60))}:${pad(size % 60)}`;
-};
-
-/** A clock time on a civil date, carrying the offset the device is on then. */
-export function isoAt(date: string, time: string): string {
-	const local = new Date(`${date}T${time}:00`);
-	return `${date}T${time}:00${formatOffset(-local.getTimezoneOffset())}`;
-}
-
-const zoneReaders = new Map<string, Intl.DateTimeFormat | undefined>();
-
-/**
- * A zone nothing can resolve is not worth throwing over: the device's own clock
- * is the honest fallback, and the resource records how its start was zoned.
- */
-function zoneReader(timeZone: string): Intl.DateTimeFormat | undefined {
-	if (zoneReaders.has(timeZone)) return zoneReaders.get(timeZone);
-	let reader: Intl.DateTimeFormat | undefined;
-	try {
-		reader = new Intl.DateTimeFormat("en-US", {
-			timeZone,
-			hourCycle: "h23",
-			year: "numeric",
-			month: "2-digit",
-			day: "2-digit",
-			hour: "2-digit",
-			minute: "2-digit",
-			second: "2-digit",
-		});
-	} catch {
-		reader = undefined;
-	}
-	zoneReaders.set(timeZone, reader);
-	return reader;
-}
-
-/** How far ahead of UTC a zone is at one instant, in minutes. */
-function zoneOffsetAt(timeZone: string, instant: number): number {
-	const reader = zoneReader(timeZone);
-	if (!reader) return Number.NaN;
-	const parts = reader.formatToParts(new Date(instant));
-	const read = (type: Intl.DateTimeFormatPartTypes): number =>
-		Number(parts.find((part) => part.type === type)?.value);
-	const hour = read("hour") % 24;
-	const reading = Date.UTC(
-		read("year"),
-		read("month") - 1,
-		read("day"),
-		hour,
-		read("minute"),
-		read("second"),
-	);
-	return (reading - instant) / 60_000;
-}
-
-/**
- * A clock time on a civil date, carrying the offset **that zone** is on then.
- *
- * The device's own offset is the wrong one for a calendar anchored elsewhere: a
- * 10:00 Amsterdam meeting rewritten with a New York offset is a 16:00 Amsterdam
- * meeting, and nothing on screen says it moved.
- *
- * The offset is read twice because reading it needs an instant and the instant
- * needs the offset. The first pass is off only inside a DST transition, and the
- * second pass — taken at the instant the first one implies — settles it.
- */
-export function isoAtInZone(
-	date: string,
-	time: string,
-	timeZone: string,
-): string {
-	// A collection naming no zone reads as UTC at both ends, and UTC is the one
-	// zone the canonical IANA list holds no name for — so it is handled here
-	// rather than asked about.
-	if (timeZone === "") return `${date}T${time}:00+00:00`;
-	const asIfUtc = Date.parse(`${date}T${time}:00Z`);
-	const first = zoneOffsetAt(timeZone, asIfUtc);
-	if (Number.isNaN(first)) return isoAt(date, time);
-	const settled = zoneOffsetAt(timeZone, asIfUtc - first * 60_000);
-	return `${date}T${time}:00${formatOffset(
-		Number.isNaN(settled) ? first : settled,
-	)}`;
-}
-
-/**
- * An instant written again as the wall time it reads as on a zone's clock.
- *
- * The listing serves each occurrence on its collection's clock, and the grid,
- * the strip and the form all read the digits. Drawing those digits as they came
- * puts a Tokyo calendar's 08:00 at 08:00 in New York; re-reading the instant on
- * the device's clock is what puts it at 18:00 the evening before.
- */
-export function isoOnClock(iso: string, timeZone: string): string {
-	const instant = Date.parse(iso);
-	const zoned = zoneOffsetAt(timeZone, instant);
-	const offset = Number.isNaN(zoned)
-		? -new Date(instant).getTimezoneOffset()
-		: zoned;
-	const wall = new Date(instant + offset * 60_000);
-	return `${civil(wall)}T${pad(wall.getUTCHours())}:${pad(
-		wall.getUTCMinutes(),
-	)}:${pad(wall.getUTCSeconds())}${formatOffset(offset)}`;
-}
-
-/** Midnight on a civil date, carrying the offset the device is on that day. */
-export const startOfDay = (date: string): string => isoAt(date, "00:00");
-
-export function addDays(date: string, days: number): string {
-	const [year, month, day] = date.split("-").map(Number);
-	return civil(new Date(Date.UTC(year, month - 1, day + days)));
-}
-
-/** The Monday of the week a day falls in — the day the grid starts weeks on. */
-function weekStart(date: string): string {
-	const [year, month, day] = date.split("-").map(Number);
-	const instant = new Date(Date.UTC(year, month - 1, day));
-	return addDays(date, -((instant.getUTCDay() + 6) % 7));
-}
-
-function bounds(view: CalendarViewId, date: string): [string, string] {
-	const [year, month] = date.split("-").map(Number);
-	if (view === "year") return [`${year}-01-01`, `${year + 1}-01-01`];
-	if (view === "month") {
-		const first = `${year}-${pad(month)}-01`;
-		const next =
-			month === 12 ? `${year + 1}-01-01` : `${year}-${pad(month + 1)}-01`;
-		return [weekStart(first), addDays(weekStart(addDays(next, -1)), 7)];
-	}
-	if (view === "day") return [date, addDays(date, 1)];
-	const start = weekStart(date);
-	return [start, addDays(start, 7)];
-}
-
-/**
- * The window a view over a day covers.
- *
- * The week is the unit every surface reads in. A grid asks for the one week it
- * draws; the strip holds many days and asks for each of their weeks
- * (`weekWindowsOver`), because a single read may not cover more than a year and
- * a range that grows as the reader scrolls would eventually become one. Both
- * therefore key on the same entries, so dropping into the grid and coming back
- * out to the strip fetches nothing either of them already holds.
- */
-export function calendarWindow(
-	view: CalendarViewId,
-	date: string,
-): CalendarWindow {
-	const [from, to] = bounds(view, date);
-	return { from: startOfDay(from), to: startOfDay(to) };
-}
-
-/** A window of whole days from one civil date, for a surface rolling its own. */
-export function calendarWindowOfDays(
-	date: string,
-	days: number,
-): CalendarWindow {
-	return { from: startOfDay(date), to: startOfDay(addDays(date, days)) };
-}

package/src/hooks/cross-account-bulk.render.test.ts

@@ -1,164 +0,0 @@
-/**
- * The brief and Flagged are the two cross-account lists, and both offer Delete
- * and Mark read over whatever is ticked (#872).
- *
- * The bulk endpoints refuse a batch spanning accounts before applying any of
- * it, so a selection with one row from each account deleted nothing at all and
- * marked nothing read — the user got "Couldn't delete these messages" and no
- * mail moved. The split has to happen where the call is made, so this mounts
- * the real hook against the real fetch seam and reads the requests that
- * actually left: every batch carries one account, and between them they carry
- * every ticked row.
- *
- * Which account each ticked row belongs to is the surfaces' half of the same
- * fix, and it is pinned in `../lib/wizard-selection.test.ts`. How the run
- * sequences the batches it splits into — progress over the whole selection,
- * cancellation at whichever boundary comes next — is `../lib/bulk-actions.test.ts`,
- * where a batch is a value rather than a request in flight.
- */
-
-import assert from "node:assert/strict";
-import { afterEach, beforeEach, describe, it } from "node:test";
-import { act, createElement } from "react";
-import type { BulkActionTarget, EscalatedAction } from "../lib/bulk-actions";
-import { ranOutcome } from "../test-support/bulk-run";
-import { createDomHarness, type DomHarness } from "../test-support/dom";
-import { type HttpMock, httpError, mockFetch } from "../test-support/http";
-import {
-	type UseEscalatedActionsResult,
-	useEscalatedActions,
-} from "./useEscalatedActions";
-
-const ACCOUNT_A = "acc-work";
-const ACCOUNT_B = "acc-personal";
-
-/** A brief selection: two rows from one account, one from another. */
-const MIXED: BulkActionTarget[] = [
-	{ id: "msg-work-1", accountId: ACCOUNT_A },
-	{ id: "msg-personal-1", accountId: ACCOUNT_B },
-	{ id: "msg-work-2", accountId: ACCOUNT_A },
-];
-
-let harness: DomHarness | undefined;
-let http: HttpMock;
-
-const mountRunner = (): (() => UseEscalatedActionsResult) => {
-	let value: UseEscalatedActionsResult | undefined;
-	const Probe = () => {
-		value = useEscalatedActions({
-			// The brief's selection belongs to no single mailbox, which is how the
-			// wizard mounts this hook over a cross-account list.
-			mailboxId: "",
-			enabled: false,
-			predicateKey: "selection-wizard",
-			searchQuery: {},
-		});
-		return null;
-	};
-	harness = createDomHarness();
-	harness.renderApp(createElement(Probe));
-	return () => {
-		if (!value) throw new Error("hook did not render");
-		return value;
-	};
-};
-
-/** Enough turns for a run of sequential batches to finish. */
-const settle = async (): Promise<void> => {
-	if (!harness) throw new Error("nothing mounted");
-	for (let round = 0; round < 10; round += 1) await harness.flush();
-};
-
-const run = async (
-	hook: () => UseEscalatedActionsResult,
-	action: EscalatedAction,
-	targets: readonly BulkActionTarget[],
-) => {
-	let started: ReturnType<UseEscalatedActionsResult["runAction"]> | undefined;
-	act(() => {
-		started = hook().runAction(action, targets);
-	});
-	await settle();
-	if (!started) throw new Error("the run never started");
-	return ranOutcome(await started);
-};
-
-/** The message-id list of every bulk request that left, in order. */
-const batches = (suffix: string): string[][] =>
-	http
-		.to(suffix)
-		.map((call) => (call.body as { messageIds?: string[] })?.messageIds ?? []);
-
-const accountOf = (id: string): string | undefined =>
-	MIXED.find((target) => target.id === id)?.accountId;
-
-const assertOneBatchPerAccount = (sent: string[][]): void => {
-	assert.equal(sent.length, 2, "the selection was not split by account");
-	for (const batch of sent) {
-		assert.equal(
-			new Set(batch.map(accountOf)).size,
-			1,
-			"a batch spanned accounts, which the endpoint refuses whole",
-		);
-	}
-	assert.deepEqual(
-		[...sent.flat()].sort(),
-		MIXED.map((target) => target.id).sort(),
-		"a ticked row was never sent",
-	);
-};
-
-beforeEach(() => {
-	http = mockFetch(() => ({ successCount: 1, failureCount: 0 }));
-});
-
-afterEach(() => {
-	harness?.close();
-	harness = undefined;
-	http.restore();
-});
-
-describe("a selection spanning accounts", () => {
-	it("deletes every ticked row, one batch per account", async () => {
-		const hook = mountRunner();
-
-		const outcome = await run(hook, { kind: "delete" }, MIXED);
-
-		assertOneBatchPerAccount(batches("/messages/delete"));
-		assert.equal(outcome.done, MIXED.length);
-		assert.deepEqual(outcome.failedIds, []);
-	});
-
-	it("marks every ticked row read, one batch per account", async () => {
-		const hook = mountRunner();
-
-		const outcome = await run(hook, { kind: "markRead" }, MIXED);
-
-		assertOneBatchPerAccount(batches("/messages/flags"));
-		for (const call of http.calls) {
-			assert.equal((call.body as { isRead?: boolean })?.isRead, true);
-		}
-		assert.equal(outcome.done, MIXED.length);
-	});
-
-	it("reports how far it got when one account's batch fails", async () => {
-		http.restore();
-		http = mockFetch((call) =>
-			(call.body as { messageIds?: string[] })?.messageIds?.[0] ===
-			"msg-personal-1"
-				? httpError(409, "mailbox is locked")
-				: { successCount: 1, failureCount: 0 },
-		);
-		const hook = mountRunner();
-
-		const outcome = await run(hook, { kind: "delete" }, MIXED);
-
-		assert.equal(outcome.done, 2, "the account that succeeded is not counted");
-		assert.deepEqual(
-			outcome.failedIds,
-			["msg-personal-1"],
-			"the untouched rows are not handed back to retry",
-		);
-		assert.notEqual(outcome.error, undefined);
-	});
-});