@remit/web-client 0.0.325 → 0.0.326

package/src/lib/sender-address.ts

@@ -1,36 +0,0 @@
-import type { RemitImapAddressResponse } from "@remit/api-http-client/types.gen.ts";
-
-/**
- * `GET /addresses/search` matches the query as a substring of a display name, a
- * local part, a domain or a whole address, and answers in relevance order. A
- * query for one sender's address therefore returns several rows: everyone
- * sharing that domain matches it too.
- *
- * Asking for a single row and taking `items[0]` is therefore wrong twice over:
- * the row it returns may belong to a different sender, and the row we actually
- * want may be past the cut. Fetch a small window instead and pick the exact
- * address out of it.
- */
-export const SENDER_ADDRESS_SEARCH_LIMIT = 10;
-
-/** Query params for the sender-address lookup. One shape, used by every caller. */
-export const senderAddressSearchQuery = (
-	senderEmail: string | undefined,
-): { q: string; limit: number } => ({
-	q: senderEmail?.toLowerCase() ?? "",
-	limit: SENDER_ADDRESS_SEARCH_LIMIT,
-});
-
-/**
- * Select the address row for exactly this sender. Another sender under the same
- * domain is not this sender, so it resolves to `undefined` rather than the wrong
- * address — silently flagging the wrong sender is worse than not resolving.
- */
-export const pickSenderAddress = (
-	items: RemitImapAddressResponse[] | undefined,
-	senderEmail: string | undefined,
-): RemitImapAddressResponse | undefined => {
-	if (!senderEmail) return undefined;
-	const normalized = senderEmail.toLowerCase();
-	return items?.find((item) => item.normalizedEmail === normalized);
-};

package/src/lib/session-storage.ts

@@ -1,7 +0,0 @@
-export const sessionStore = (): Storage | null => {
-	try {
-		return globalThis.sessionStorage ?? null;
-	} catch {
-		return null;
-	}
-};

package/src/lib/spam-offer.test.ts

@@ -1,192 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { type SpamMailboxCount, spamOfferFromCounts } from "./spam-offer";
-
-const exact = (mailboxId: string, value: number): SpamMailboxCount => ({
-	mailboxId,
-	count: { kind: "exact", value },
-	failed: false,
-});
-
-const uncounted = (mailboxId: string): SpamMailboxCount => ({
-	mailboxId,
-	count: { kind: "unknown" },
-	failed: false,
-});
-
-const errored = (mailboxId: string): SpamMailboxCount => ({
-	mailboxId,
-	count: { kind: "unknown" },
-	failed: true,
-});
-
-/** The loaded page held no junk row of its own. */
-const NO_PAGE_ROWS = { pageRowsByMailbox: new Map<string, number>() };
-
-const pageRows = (
-	entries: Record<string, number>,
-): { pageRowsByMailbox: ReadonlyMap<string, number> } => ({
-	pageRowsByMailbox: new Map(Object.entries(entries)),
-});
-
-describe("spamOfferFromCounts", () => {
-	it("makes no offer when there is no junk folder to count", () => {
-		assert.equal(spamOfferFromCounts([], NO_PAGE_ROWS), undefined);
-	});
-
-	it("makes no offer when every junk folder counted zero", () => {
-		assert.equal(
-			spamOfferFromCounts(
-				[exact("mb-junk-a", 0), exact("mb-junk-b", 0)],
-				NO_PAGE_ROWS,
-			),
-			undefined,
-		);
-	});
-
-	it("states the server's count for the one junk folder", () => {
-		assert.deepEqual(
-			spamOfferFromCounts([exact("mb-junk", 42)], NO_PAGE_ROWS),
-			{
-				mailboxId: "mb-junk",
-				count: { kind: "exact", value: 42 },
-			},
-		);
-	});
-
-	it("sums every junk folder, so several accounts read as one number", () => {
-		assert.deepEqual(
-			spamOfferFromCounts(
-				[exact("mb-junk-a", 3), exact("mb-junk-b", 7), exact("mb-junk-c", 2)],
-				NO_PAGE_ROWS,
-			),
-			{ mailboxId: "mb-junk-b", count: { kind: "exact", value: 12 } },
-		);
-	});
-
-	it("sends the reader to the junk folder holding the most matches", () => {
-		assert.equal(
-			spamOfferFromCounts(
-				[exact("mb-junk-a", 1), exact("mb-junk-b", 9)],
-				NO_PAGE_ROWS,
-			)?.mailboxId,
-			"mb-junk-b",
-		);
-	});
-
-	it("breaks a tie on folder order, so the destination does not flip", () => {
-		assert.equal(
-			spamOfferFromCounts(
-				[exact("mb-junk-a", 4), exact("mb-junk-b", 4)],
-				NO_PAGE_ROWS,
-			)?.mailboxId,
-			"mb-junk-a",
-		);
-	});
-
-	it("states no number when one junk folder went uncounted", () => {
-		// Summing only the folders that answered would state a figure that is exact
-		// in form and short in fact.
-		assert.deepEqual(
-			spamOfferFromCounts(
-				[exact("mb-junk-a", 5), uncounted("mb-junk-b")],
-				NO_PAGE_ROWS,
-			),
-			{ mailboxId: "mb-junk-a", count: { kind: "unknown" } },
-		);
-	});
-
-	it("stands down when nothing is known and the page held no spam either", () => {
-		assert.equal(
-			spamOfferFromCounts(
-				[uncounted("mb-junk-a"), uncounted("mb-junk-b")],
-				NO_PAGE_ROWS,
-			),
-			undefined,
-		);
-	});
-
-	// A failed count is not a folder saying it holds nothing. Dropping the offer
-	// on one would make a lapsed session look exactly like a clean search.
-	it("keeps the offer when a count request failed", () => {
-		assert.deepEqual(
-			spamOfferFromCounts(
-				[exact("mb-junk-a", 0), errored("mb-junk-b")],
-				NO_PAGE_ROWS,
-			),
-			{ mailboxId: "mb-junk-b", count: { kind: "unknown" } },
-		);
-	});
-
-	it("does not read an uncounted folder as an empty one", () => {
-		assert.deepEqual(
-			spamOfferFromCounts(
-				[exact("mb-junk-a", 0), uncounted("mb-junk-b")],
-				pageRows({ "mb-junk-b": 1 }),
-			),
-			{ mailboxId: "mb-junk-b", count: { kind: "unknown" } },
-		);
-	});
-});
-
-describe("spamOfferFromCounts destination", () => {
-	// The regression: with counts switched off, every folder is `unknown` and the
-	// destination fell to whichever folder happened to be first. Two accounts,
-	// every held-out row in B's Spam, and the button opened A's — "No matches"
-	// over mail the list was holding out on the very same screen.
-	it("follows the page's junk rows when no folder was counted", () => {
-		assert.equal(
-			spamOfferFromCounts(
-				[uncounted("mb-junk-a"), uncounted("mb-junk-b")],
-				pageRows({ "mb-junk-b": 3 }),
-			)?.mailboxId,
-			"mb-junk-b",
-		);
-	});
-
-	// An exact zero is the one folder known to hold nothing, so it is the one
-	// destination guaranteed to show an empty list — below a folder that simply
-	// has not answered.
-	it("never sends the reader to a folder that counted zero", () => {
-		assert.equal(
-			spamOfferFromCounts(
-				[exact("mb-junk-a", 0), uncounted("mb-junk-b"), errored("mb-junk-c")],
-				NO_PAGE_ROWS,
-			)?.mailboxId,
-			"mb-junk-b",
-		);
-	});
-
-	it("prefers a counted match over the folder the page's rows came from", () => {
-		assert.equal(
-			spamOfferFromCounts(
-				[exact("mb-junk-a", 9), uncounted("mb-junk-b")],
-				pageRows({ "mb-junk-b": 4 }),
-			)?.mailboxId,
-			"mb-junk-a",
-		);
-	});
-
-	// The mailbox lists are still loading, or the folder arrived after the count
-	// requests went out. Its rows are already held out of the list, so it has to
-	// be reachable.
-	it("offers a junk folder the page names and the counts do not", () => {
-		assert.deepEqual(spamOfferFromCounts([], pageRows({ "mb-junk-late": 2 })), {
-			mailboxId: "mb-junk-late",
-			count: { kind: "unknown" },
-		});
-	});
-
-	// A count that says nothing over a page that is holding junk rows is stale by
-	// up to its half-minute. The rows are on screen; the offer stands and states
-	// no figure rather than "0 results from Spam".
-	it("states no number when an exact zero contradicts the page's rows", () => {
-		assert.deepEqual(
-			spamOfferFromCounts(
-				[exact("mb-junk-a", 0), exact("mb-junk-b", 0)],
-				pageRows({ "mb-junk-b": 2 }),
-			),
-			{ mailboxId: "mb-junk-b", count: { kind: "unknown" } },
-		);
-	});
-});

package/src/lib/spam-offer.ts

@@ -1,163 +0,0 @@
-/**
- * The Spam offer: how much of a search sits in Spam, and where taking the offer
- * lands.
- *
- * Both answers come from one server count per junk folder the search reached
- * (`useSpamMatchCounts`). The number is their sum, because a search spans every
- * account and every account has its own Spam folder — "N in Spam" that named
- * one folder's share would be smaller than the mail the phrase describes.
- *
- * The destination is a single folder even so: scoping is a route and a route
- * names one mailbox. It is the folder holding the most matches, which is the
- * best a single click can do, and `SpamResultsOffer` says where the button goes
- * rather than promising to show every match. Where no count ranks the folders —
- * a short query, a residual token, a failed request — the page's own junk rows
- * do, because they are the only evidence left of where the mail is.
- *
- * This used to group the search results the header held and count each group.
- * That array is a page, so the figure was a count of the loaded window offered
- * as a count of a mailbox: a Spam match below the page was missing from it, and
- * the number climbed as further pages loaded (#313).
- *
- * A folder whose count did not arrive makes the total `unknown`. Summing the
- * ones that did would state a figure that is exact in form and short in fact,
- * and nothing distinguishes it from a true one on screen.
- */
-import type { ResultCount } from "@remit/ui";
-
-export interface SpamMailboxCount {
-	mailboxId: string;
-	count: ResultCount;
-	/**
-	 * The count request failed. Distinct from `unknown`, which also covers a
-	 * request still in flight or one nobody made: a failure is a folder that
-	 * could not answer, and it must never read as a folder holding nothing.
-	 */
-	failed: boolean;
-}
-
-export interface SpamOffer {
-	/** The junk folder "Go to Spam" scopes the search to. */
-	mailboxId: string;
-	/** Matches across every junk folder, or `unknown` if any went uncounted. */
-	count: ResultCount;
-}
-
-export interface SpamOfferEvidence {
-	/**
-	 * Junk rows the loaded page held, per junk folder.
-	 *
-	 * Never the number the offer states — a page is a page. It is what says
-	 * spam was reached at all while the counts are absent, and, crucially, WHICH
-	 * folder the reader is being sent to: with no count to rank the folders by,
-	 * the rows on screen are the only evidence of where the mail is, and a
-	 * "Go to Spam" that lands on the wrong account's folder shows "No matches"
-	 * over mail this very page is holding out.
-	 */
-	pageRowsByMailbox: ReadonlyMap<string, number>;
-}
-
-interface Candidate {
-	mailboxId: string;
-	count: ResultCount;
-	failed: boolean;
-	pageRows: number;
-}
-
-/**
- * How good a destination a folder is, before ties are broken.
- *
- * A counted match is the best evidence; junk rows on the page are the next
- * best, and they outrank the folder's own count because the rows are on screen
- * while the count may be half a minute old. A folder that answered zero and
- * shows no row ranks LAST — it is the only one known to hold nothing, so
- * sending the reader there is the one choice guaranteed to show an empty list.
- */
-const tier = (candidate: Candidate): number => {
-	if (candidate.count.kind === "exact" && candidate.count.value > 0) return 3;
-	if (candidate.pageRows > 0) return 2;
-	return candidate.count.kind === "unknown" ? 1 : 0;
-};
-
-const exactValue = (candidate: Candidate): number =>
-	candidate.count.kind === "exact" ? candidate.count.value : 0;
-
-/** Strict, so equal candidates leave the earlier one standing. */
-const isBetterDestination = (
-	candidate: Candidate,
-	standing: Candidate,
-): boolean => {
-	if (tier(candidate) !== tier(standing)) {
-		return tier(candidate) > tier(standing);
-	}
-	if (exactValue(candidate) !== exactValue(standing)) {
-		return exactValue(candidate) > exactValue(standing);
-	}
-	return candidate.pageRows > standing.pageRows;
-};
-
-/**
- * The offer these per-folder counts support, or none.
- *
- * None when every junk folder answered and they sum to zero with no junk row on
- * the page either — the search reaches no spam. Anything else is an offer: rows
- * held out of the list are always offered a way back, because hiding mail
- * without one is worse than hiding a number.
- *
- * The figure is the sum, and only when every folder answered. One folder
- * missing takes it off, because summing the folders that replied states a
- * number exact in form and short in fact. A sum of zero over a page that is
- * holding junk rows takes it off too: the two disagree, so neither is stated.
- */
-export function spamOfferFromCounts(
-	counts: readonly SpamMailboxCount[],
-	{ pageRowsByMailbox }: SpamOfferEvidence,
-): SpamOffer | undefined {
-	const candidates: Candidate[] = counts.map((entry) => ({
-		...entry,
-		pageRows: pageRowsByMailbox.get(entry.mailboxId) ?? 0,
-	}));
-	// A folder the page names but the counts do not — the mailbox lists are still
-	// loading, or the folder arrived after the requests went out. Its rows are
-	// already being held out of the list, so it has to be reachable.
-	for (const [mailboxId, pageRows] of pageRowsByMailbox) {
-		if (pageRows <= 0) continue;
-		if (candidates.some((entry) => entry.mailboxId === mailboxId)) continue;
-		candidates.push({
-			mailboxId,
-			count: { kind: "unknown" },
-			failed: false,
-			pageRows,
-		});
-	}
-
-	const first = candidates[0];
-	if (!first) return undefined;
-
-	let total = 0;
-	let everyFolderAnswered = true;
-	let best = first;
-	for (const candidate of candidates) {
-		if (candidate.count.kind === "unknown") everyFolderAnswered = false;
-		else total += candidate.count.value;
-		if (isBetterDestination(candidate, best)) best = candidate;
-	}
-
-	const pageHeldSpam = candidates.some((candidate) => candidate.pageRows > 0);
-	const anyFailed = candidates.some((candidate) => candidate.failed);
-	if (total === 0 && !pageHeldSpam && (everyFolderAnswered || !anyFailed)) {
-		return undefined;
-	}
-
-	// The count and the page disagree: an exact zero under rows the list is
-	// holding out. The rows are on screen and the count is up to half a minute
-	// old, so the offer stands and states nothing.
-	const contradicted = everyFolderAnswered && total === 0 && pageHeldSpam;
-	return {
-		mailboxId: best.mailboxId,
-		count:
-			everyFolderAnswered && !contradicted
-				? { kind: "exact", value: total }
-				: { kind: "unknown" },
-	};
-}

package/src/lib/stale-build.test.ts

@@ -1,52 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import {
-	reloadOnceForChunkFailure,
-	STALE_BUILD_RELOAD_KEY_PREFIX,
-} from "./stale-build";
-
-const memoryGuard = (): Pick<Storage, "getItem" | "setItem"> => {
-	const store = new Map<string, string>();
-	return {
-		getItem: (key) => store.get(key) ?? null,
-		setItem: (key, value) => {
-			store.set(key, value);
-		},
-	};
-};
-
-describe("reloadOnceForChunkFailure", () => {
-	it("reloads once per build, keyed by its commit", () => {
-		const guard = memoryGuard();
-		let reloads = 0;
-		const ports = {
-			reload: () => {
-				reloads += 1;
-			},
-			guard,
-			commit: "aaa",
-		};
-		assert.equal(reloadOnceForChunkFailure(ports), true);
-		assert.equal(reloadOnceForChunkFailure(ports), false);
-		assert.equal(reloads, 1);
-		assert.notEqual(guard.getItem(`${STALE_BUILD_RELOAD_KEY_PREFIX}aaa`), null);
-	});
-
-	it("reloads again for a different build", () => {
-		const guard = memoryGuard();
-		guard.setItem(`${STALE_BUILD_RELOAD_KEY_PREFIX}aaa`, "1");
-		let reloads = 0;
-		const reload = () => {
-			reloads += 1;
-		};
-		assert.equal(
-			reloadOnceForChunkFailure({ reload, guard, commit: "aaa" }),
-			false,
-		);
-		assert.equal(
-			reloadOnceForChunkFailure({ reload, guard, commit: "bbb" }),
-			true,
-		);
-		assert.equal(reloads, 1);
-	});
-});

package/src/lib/stale-build.ts

@@ -1,36 +0,0 @@
-import { APP_SHA } from "@/lib/app-info";
-import { sessionStore } from "@/lib/session-storage";
-
-export const STALE_BUILD_RELOAD_KEY_PREFIX = "remit.stale-build-reload:";
-
-type ReloadGuard = Pick<Storage, "getItem" | "setItem">;
-
-export interface StaleBuildPorts {
-	reload: () => void;
-	guard: ReloadGuard | null;
-	commit: string;
-}
-
-export const reloadOnceForChunkFailure = ({
-	reload,
-	guard,
-	commit,
-}: StaleBuildPorts): boolean => {
-	if (guard === null) return false;
-	const key = `${STALE_BUILD_RELOAD_KEY_PREFIX}${commit}`;
-	if (guard.getItem(key) !== null) return false;
-	guard.setItem(key, String(Date.now()));
-	reload();
-	return true;
-};
-
-export const installStaleBuildReload = (): void => {
-	window.addEventListener("vite:preloadError", (event) => {
-		const reloaded = reloadOnceForChunkFailure({
-			reload: () => window.location.reload(),
-			guard: sessionStore(),
-			commit: APP_SHA,
-		});
-		if (reloaded) event.preventDefault();
-	});
-};

package/src/lib/starred-rows.test.ts

@@ -1,67 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, test } from "node:test";
-import type { RemitImapThreadMessageResponse } from "@remit/api-http-client/types.gen.ts";
-import { dedupeByThread } from "./starred-rows.js";
-
-// The starred listing returns one row per mailbox. The same mail filed in two
-// folders is two rows sharing a threadId, both starred server-side, so a
-// conversation would otherwise render twice.
-
-const row = (
-	threadId: string,
-	messageId: string,
-	mailboxId: string,
-): RemitImapThreadMessageResponse =>
-	({
-		threadId,
-		messageId,
-		mailboxId,
-	}) as unknown as RemitImapThreadMessageResponse;
-
-describe("dedupeByThread", () => {
-	test("collapses two copies of one conversation to a single row", () => {
-		const result = dedupeByThread([
-			row("t1", "m-inbox", "inbox"),
-			row("t1", "m-archive", "archive"),
-		]);
-
-		assert.deepEqual(
-			result.map((r) => r.messageId),
-			["m-inbox"],
-		);
-	});
-
-	test("keeps the first row, which is the newest under descending order", () => {
-		const result = dedupeByThread([
-			row("t1", "m-newest", "inbox"),
-			row("t1", "m-older", "archive"),
-		]);
-
-		assert.equal(result[0]?.messageId, "m-newest");
-	});
-
-	test("leaves distinct conversations alone and preserves order", () => {
-		const result = dedupeByThread([
-			row("t1", "m1", "inbox"),
-			row("t2", "m2", "inbox"),
-			row("t3", "m3", "inbox"),
-		]);
-
-		assert.deepEqual(
-			result.map((r) => r.threadId),
-			["t1", "t2", "t3"],
-		);
-	});
-
-	test("collapses copies that arrived on different pages", () => {
-		const pageOne = [row("t1", "m1", "inbox"), row("t2", "m2", "inbox")];
-		const pageTwo = [row("t2", "m2-copy", "archive"), row("t3", "m3", "inbox")];
-
-		const result = dedupeByThread([...pageOne, ...pageTwo]);
-
-		assert.deepEqual(
-			result.map((r) => r.threadId),
-			["t1", "t2", "t3"],
-		);
-	});
-});

package/src/lib/starred-rows.ts

@@ -1,32 +0,0 @@
-/**
- * Collapse rows that are the same conversation.
- *
- * A message's identity includes its mailbox, so the same mail filed in two
- * folders is two rows carrying the same server-side star. The starred scope
- * already excludes the folder that causes this wholesale (Gmail's All Mail),
- * but an ordinary copy in a user folder still produces a pair.
- *
- * 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: 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
- * definitions of "same conversation" is one too many. A row that names no
- * thread is never merged: there is nothing to say it is the same conversation
- * as any other.
- */
-export const dedupeByThread = <T extends { threadId?: string }>(
-	items: T[],
-): T[] => {
-	const seen = new Set<string>();
-	return items.filter((item) => {
-		if (item.threadId === undefined) return true;
-		if (seen.has(item.threadId)) return false;
-		seen.add(item.threadId);
-		return true;
-	});
-};

package/src/lib/sync-warning-entries.ts

@@ -1,33 +0,0 @@
-import type { RemitImapSyncWarningResponse } from "@remit/api-http-client/types.gen.ts";
-import { syncWarningState } from "@remit/data-ports/sync-warning-state";
-import {
-	canonicalRoleLabel,
-	folderLeaf,
-	type ResultFolder,
-	type SyncWarningEntry,
-} from "@remit/ui";
-
-export const UNLISTED_FOLDER_LABEL = "A folder no longer listed";
-
-function folderLabel(folder: ResultFolder | undefined): string {
-	if (folder?.role) return canonicalRoleLabel(folder.role);
-	if (folder?.providerPath) {
-		return folderLeaf(folder.providerPath, folder.hierarchyDelimiter);
-	}
-	return UNLISTED_FOLDER_LABEL;
-}
-
-export function toSyncWarningEntry(
-	wire: RemitImapSyncWarningResponse,
-	folder: ResultFolder | undefined,
-): SyncWarningEntry {
-	return {
-		syncWarningId: wire.syncWarningId,
-		uid: wire.uid,
-		stage: wire.stage,
-		state: syncWarningState(wire.stage, wire.attempts),
-		attempts: wire.attempts,
-		createdAt: wire.createdAt,
-		folderLabel: folderLabel(folder),
-	};
-}

package/src/lib/telemetry-context.tsx

@@ -1,9 +0,0 @@
-import { createContext, useContext } from "react";
-import type { Telemetry } from "./telemetry";
-import { noopTelemetry } from "./telemetry";
-
-export const TelemetryContext = createContext<Telemetry>(noopTelemetry);
-
-export function useTelemetry(): Telemetry {
-	return useContext(TelemetryContext);
-}

package/src/lib/telemetry.ts

@@ -1,17 +0,0 @@
-export interface Telemetry {
-	recordPageView(path: string): void;
-	recordError(error: Error, context?: Record<string, string>): void;
-	recordEvent(name: string, attributes?: Record<string, string>): void;
-	recordTiming(
-		name: string,
-		durationMs: number,
-		attributes?: Record<string, string>,
-	): void;
-}
-
-export const noopTelemetry: Telemetry = {
-	recordPageView: () => undefined,
-	recordError: () => undefined,
-	recordEvent: () => undefined,
-	recordTiming: () => undefined,
-};