@remit/web-client 0.0.325 → 0.0.327

package/src/lib/hot-sync-window.test.ts

@@ -1,59 +0,0 @@
-import assert from "node:assert/strict";
-import { afterEach, describe, test } from "node:test";
-import {
-	__resetHotSyncWindow,
-	HOT_WINDOW_MS,
-	isHotSyncWindowActive,
-	startHotSyncWindow,
-	subscribeHotSyncWindow,
-} from "./hot-sync-window.js";
-
-const NOW = 1_700_000_000_000;
-
-describe("hot sync window", () => {
-	afterEach(__resetHotSyncWindow);
-
-	test("is closed until somebody presses refresh", () => {
-		assert.equal(isHotSyncWindowActive(NOW), false);
-	});
-
-	test("stays open for a few minutes after a press", () => {
-		startHotSyncWindow(NOW);
-
-		assert.equal(isHotSyncWindowActive(NOW), true);
-		assert.equal(isHotSyncWindowActive(NOW + HOT_WINDOW_MS - 1), true);
-	});
-
-	test("expires on its own", () => {
-		startHotSyncWindow(NOW);
-
-		assert.equal(isHotSyncWindowActive(NOW + HOT_WINDOW_MS), false);
-		assert.equal(isHotSyncWindowActive(NOW + HOT_WINDOW_MS + 1), false);
-	});
-
-	// Someone still pressing refresh is still waiting on mail.
-	test("a second press extends the window from that press", () => {
-		startHotSyncWindow(NOW);
-		startHotSyncWindow(NOW + 60_000);
-
-		assert.equal(isHotSyncWindowActive(NOW + HOT_WINDOW_MS), true);
-		assert.equal(isHotSyncWindowActive(NOW + HOT_WINDOW_MS + 60_000), false);
-	});
-
-	// The poll loop may already be asleep on a long ambient interval when the
-	// press lands; without this it would sit out the rest of that wait before
-	// the hot cadence took effect at all.
-	test("notifies subscribers on a press, and stops after unsubscribe", () => {
-		let presses = 0;
-		const unsubscribe = subscribeHotSyncWindow(() => {
-			presses += 1;
-		});
-
-		startHotSyncWindow(NOW);
-		assert.equal(presses, 1);
-
-		unsubscribe();
-		startHotSyncWindow(NOW);
-		assert.equal(presses, 1);
-	});
-});

package/src/lib/hot-sync-window.ts

@@ -1,48 +0,0 @@
-/**
- * A short window of faster background syncing, opened by a person pressing
- * refresh.
- *
- * Pressing refresh says "I am waiting on mail", and the reply people expect is
- * not one round but the next few minutes: a reply lands, a colleague answers,
- * the transfer confirms. The ambient cadence alone would leave that mail up to
- * a full interval away, so the press widens the tab's own poll for a few
- * minutes and then lets it fall back.
- *
- * Module state rather than context: the press happens in the refresh control
- * and the polling happens in `useStaleAccountSync`, two hooks with no common
- * ancestor that owns this, and the window belongs to the tab either way.
- */
-
-/** How long a press keeps the tab polling on the hot cadence. */
-export const HOT_WINDOW_MS = 3 * 60 * 1000;
-
-/** The cadence inside the window. Never faster: `POST /sync` skips the
- * server's per-mailbox freshness gate, so every tick is a real folder-by-folder
- * fan-out for every open account. */
-export const HOT_POLL_INTERVAL_MS = 30 * 1000;
-
-let hotUntil = 0;
-const listeners = new Set<() => void>();
-
-/** Open (or re-open) the window. Called on a refresh press, never on a timer. */
-export const startHotSyncWindow = (now: number = Date.now()): void => {
-	hotUntil = now + HOT_WINDOW_MS;
-	for (const listener of listeners) listener();
-};
-
-export const isHotSyncWindowActive = (now: number = Date.now()): boolean =>
-	now < hotUntil;
-
-/** Notifies on every press so a poll loop already asleep on the ambient
- * interval can reschedule onto the hot one instead of finishing its long wait
- * first. */
-export const subscribeHotSyncWindow = (listener: () => void): (() => void) => {
-	listeners.add(listener);
-	return () => {
-		listeners.delete(listener);
-	};
-};
-
-export const __resetHotSyncWindow = (): void => {
-	hotUntil = 0;
-};

package/src/lib/i18n.ts

@@ -1,36 +0,0 @@
-import i18n from "i18next";
-import LanguageDetector from "i18next-browser-languagedetector";
-import Backend from "i18next-http-backend";
-import { initReactI18next } from "react-i18next";
-
-i18n
-	.use(Backend)
-	.use(LanguageDetector)
-	.use(initReactI18next)
-	.init({
-		fallbackLng: "en",
-		supportedLngs: ["en", "nl", "de", "fr"],
-
-		ns: ["common", "mail"],
-		defaultNS: "common",
-
-		backend: {
-			loadPath: "/locales/{{lng}}/{{ns}}.json",
-		},
-
-		detection: {
-			order: ["navigator", "htmlTag"],
-			caches: [],
-		},
-
-		interpolation: {
-			escapeValue: false,
-		},
-
-		react: {
-			useSuspense: true,
-			bindI18n: "languageChanged loaded",
-		},
-	});
-
-export default i18n;

package/src/lib/inbox-filters.test.ts

@@ -1,134 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, test } from "node:test";
-import {
-	filterReach,
-	hasInboxFilter,
-	type InboxFilterCriteria,
-	inboxFilterParams,
-	sameInboxFilter,
-} from "./inbox-filters.js";
-
-const criteria = (
-	category: string,
-	attributes: string[] = [],
-): InboxFilterCriteria => ({ category, attributes: new Set(attributes) });
-
-/** The shape `threadOperationsSearchThreadsQueryKey` produces. */
-const key = (query: Record<string, unknown>): unknown => [
-	{ _id: "threadOperationsSearchThreads", path: { mailboxId: "mb1" }, query },
-];
-
-describe("hasInboxFilter", () => {
-	test("an untouched chip row narrows nothing", () => {
-		assert.equal(hasInboxFilter(criteria("all")), false);
-	});
-
-	test("a category or an attribute is a filter", () => {
-		assert.equal(hasInboxFilter(criteria("personal")), true);
-		assert.equal(hasInboxFilter(criteria("all", ["unread"])), true);
-	});
-
-	test("an id that names no category narrows nothing", () => {
-		assert.equal(hasInboxFilter(criteria("nonsense")), false);
-	});
-});
-
-describe("inboxFilterParams", () => {
-	test("sends the category to the server instead of filtering here (#306)", () => {
-		assert.deepEqual(inboxFilterParams(criteria("personal")), {
-			category: ["personal"],
-		});
-	});
-
-	test("asks for unclassified mail by name, never as absence (#45)", () => {
-		assert.deepEqual(inboxFilterParams(criteria("uncategorized")), {
-			category: ["uncategorized"],
-		});
-	});
-
-	test("sets no category parameter for `all`", () => {
-		assert.deepEqual(inboxFilterParams(criteria("all")), {});
-	});
-
-	test("maps each attribute chip onto the parameter the API names", () => {
-		assert.deepEqual(
-			inboxFilterParams(criteria("all", ["unread", "flagged", "attachment"])),
-			{ unread: true, starred: true, attachments: true },
-		);
-	});
-
-	test("carries a category and its attributes together", () => {
-		assert.deepEqual(inboxFilterParams(criteria("social", ["unread"])), {
-			category: ["social"],
-			unread: true,
-		});
-	});
-
-	test("ignores an attribute id with no parameter behind it", () => {
-		assert.deepEqual(inboxFilterParams(criteria("all", ["nonsense"])), {});
-	});
-});
-
-describe("filterReach", () => {
-	test("a category is a column on the row, so the whole folder was read", () => {
-		assert.equal(
-			filterReach({ category: ["personal"], unread: true }),
-			"whole-folder",
-		);
-	});
-
-	test("an unfiltered request still reaches the whole folder", () => {
-		assert.equal(filterReach({ order: "desc" }), "whole-folder");
-	});
-
-	test("an off-row criterion bounds the read, whatever else is set", () => {
-		assert.equal(
-			filterReach({ category: ["personal"], senderTrust: ["unknown"] }),
-			"loaded-pages",
-		);
-		assert.equal(filterReach({ dkimMismatch: true }), "loaded-pages");
-		assert.equal(filterReach({ dkimMismatch: false }), "loaded-pages");
-	});
-
-	test("an empty trust list bounds nothing", () => {
-		assert.equal(filterReach({ senderTrust: [] }), "whole-folder");
-	});
-});
-
-describe("sameInboxFilter", () => {
-	test("holds across a query the user is still typing", () => {
-		assert.equal(
-			sameInboxFilter(key({ query: "inv", category: ["personal"] }), {
-				category: ["personal"],
-			}),
-			true,
-		);
-	});
-
-	test("fails the moment the category changes", () => {
-		assert.equal(
-			sameInboxFilter(key({ category: ["personal"] }), {
-				category: ["social"],
-			}),
-			false,
-		);
-	});
-
-	test("fails when a chip is cleared", () => {
-		assert.equal(sameInboxFilter(key({ category: ["personal"] }), {}), false);
-		assert.equal(
-			sameInboxFilter(key({ unread: true }), { category: ["personal"] }),
-			false,
-		);
-	});
-
-	test("holds between the unfiltered listing and an unfiltered search", () => {
-		assert.equal(sameInboxFilter(key({ order: "desc" }), {}), true);
-	});
-
-	test("answers false for a key it cannot read", () => {
-		assert.equal(sameInboxFilter(undefined, {}), false);
-		assert.equal(sameInboxFilter([], {}), false);
-		assert.equal(sameInboxFilter([{ path: { mailboxId: "mb1" } }], {}), false);
-	});
-});

package/src/lib/inbox-filters.ts

@@ -1,154 +0,0 @@
-import type {
-	RemitImapMessageCategory,
-	ThreadOperationsSearchThreadsData,
-} from "@remit/api-http-client/types.gen.ts";
-import { MessageCategory } from "@remit/domain-enums";
-import { categoryLabels, type FilterReach, isThreadCategory } from "@remit/ui";
-
-/** The request `threadOperationsSearchThreads` takes, whole. */
-export type ThreadSearchQuery = NonNullable<
-	ThreadOperationsSearchThreadsData["query"]
->;
-
-/**
- * The parameters the filter chips set on a thread listing.
- *
- * Named for the inbox, which had them first, but shared: `listAllThreads` takes
- * the same four (#308), so the Flagged view sends the chips through this rather
- * than growing a second translation of the same chip ids.
- */
-export type InboxFilterParams = Pick<
-	ThreadSearchQuery,
-	"category" | "unread" | "starred" | "attachments"
->;
-
-/** The chip state a filtered list holds: one category, any number of attributes. */
-export interface InboxFilterCriteria {
-	/** A category id, or `"all"` when the category is cleared. */
-	category: string;
-	attributes: ReadonlySet<string>;
-}
-
-/**
- * The search parameter each attribute chip sets. `flagged` is the wire name for
- * IMAP \Flagged, which the API calls `starred`; the label is "Starred".
- */
-const ATTRIBUTE_PARAMS: Record<string, "unread" | "starred" | "attachments"> = {
-	unread: "unread",
-	flagged: "starred",
-	attachment: "attachments",
-};
-
-const CATEGORY_VALUES = new Set<string>(Object.values(MessageCategory));
-
-const isMessageCategory = (id: string): id is RemitImapMessageCategory =>
-	CATEGORY_VALUES.has(id);
-
-/** Whether the chips narrow the list at all — `"all"` and no attributes do not. */
-export const hasInboxFilter = (criteria: InboxFilterCriteria): boolean =>
-	isMessageCategory(criteria.category) || criteria.attributes.size > 0;
-
-/**
- * The chips as search parameters, so the server returns a page of matches
- * rather than a page the browser then thins out. A category chip that names no
- * category — `"all"`, or an id the enum no longer carries — sets no parameter,
- * and `uncategorized` is a category like any other: the pending state's name,
- * never the absence of one (issue #45).
- *
- * Only the parameters a chip switches on are present, so this merges with the
- * search tokens (`is:unread`, `has:attachment`) as a union: where a chip and a
- * token set the same parameter they agree on `true`.
- */
-export const inboxFilterParams = (
-	criteria: InboxFilterCriteria,
-): InboxFilterParams => {
-	const params: InboxFilterParams = {};
-	if (isMessageCategory(criteria.category)) {
-		params.category = [criteria.category];
-	}
-	for (const id of criteria.attributes) {
-		const param = ATTRIBUTE_PARAMS[id];
-		if (param) params[param] = true;
-	}
-	return params;
-};
-
-/**
- * How much of the mailbox a request reaches, read off the request itself.
- *
- * Every criterion the inbox sends today is a column on the row, so the server
- * answers with a `where` over the whole mailbox and an empty result means the
- * folder holds no matching mail. `senderTrust` and `dkimMismatch` are resolved
- * by enriching a bounded window instead (design D7, D10), so a request carrying
- * either has only seen the pages it read. Derived rather than declared: the
- * completeness sentence the empty state renders is true of the query that was
- * issued, not of the criteria that happen to ship today.
- */
-export const filterReach = (query: ThreadSearchQuery): FilterReach =>
-	(query.senderTrust?.length ?? 0) > 0 || query.dkimMismatch !== undefined
-		? "loaded-pages"
-		: "whole-folder";
-
-/**
- * A list request's narrowing parameters, as far as the previous-data guard
- * reads them. The chips, plus the two scopes a view sets for itself: the
- * account the pills name, and whether muted senders are in.
- *
- * The text parameters are deliberately absent, `from` and `subject` with the
- * free text: all three are typed in one field, and a query being refined is the
- * one change that may keep the previous answer on screen while the next is in
- * flight.
- */
-export type ListFilterParams = InboxFilterParams & {
-	accountId?: string;
-	muted?: boolean;
-};
-
-const FILTER_PARAM_NAMES = [
-	"category",
-	"unread",
-	"starred",
-	"attachments",
-	"accountId",
-	"muted",
-] as const;
-
-const filterIdentity = (query: Record<string, unknown> | undefined): string =>
-	JSON.stringify(FILTER_PARAM_NAMES.map((name) => query?.[name] ?? null));
-
-const queryOf = (queryKey: unknown): Record<string, unknown> | undefined => {
-	if (!Array.isArray(queryKey)) return undefined;
-	const [entry] = queryKey;
-	if (typeof entry !== "object" || entry === null) return undefined;
-	const query: unknown = (entry as { query?: unknown }).query;
-	if (typeof query !== "object" || query === null) return undefined;
-	return query as Record<string, unknown>;
-};
-
-/**
- * Whether a cached list query was fetched under the same filter the request
- * being made now carries.
- *
- * `keepPreviousData` renders the previous key's rows while a new page is in
- * flight. That is right for a query the user is still typing and wrong the
- * moment the filter changes: the previous predicate's mail would show under the
- * new chip for one round trip, which is the failure this correction is about
- * (design D18). An unrecognized key answers `false`, so the doubtful case
- * restarts the list rather than rendering rows it cannot vouch for.
- */
-export const sameInboxFilter = (
-	queryKey: unknown,
-	params: ListFilterParams,
-): boolean => {
-	const previous = queryOf(queryKey);
-	if (!previous) return false;
-	return filterIdentity(previous) === filterIdentity(params);
-};
-
-/**
- * The label the empty state names an active category filter by, or undefined
- * when the id names no category — `"all"` is how the category is cleared, not a
- * category.
- */
-export const categoryLabel = (id: string): string | undefined =>
-	isThreadCategory(id) ? categoryLabels[id] : undefined;

package/src/lib/intelligence-pref.test.ts

@@ -1,201 +0,0 @@
-import assert from "node:assert/strict";
-import { afterEach, beforeEach, describe, it } from "node:test";
-import {
-	readIntelligencePref,
-	resolveRailOpen,
-	writeIntelligencePref,
-} from "./intelligence-pref.js";
-
-const installMemoryStorage = (): void => {
-	const store = new Map<string, string>();
-	(globalThis as { localStorage?: Storage }).localStorage = {
-		getItem: (key: string) => store.get(key) ?? null,
-		setItem: (key: string, value: string) => {
-			store.set(key, value);
-		},
-		removeItem: (key: string) => {
-			store.delete(key);
-		},
-		clear: () => {
-			store.clear();
-		},
-		key: (index: number) => Array.from(store.keys())[index] ?? null,
-		get length() {
-			return store.size;
-		},
-	} as Storage;
-};
-
-describe("intelligence-pref (#782)", () => {
-	beforeEach(() => {
-		installMemoryStorage();
-	});
-
-	afterEach(() => {
-		(globalThis as { localStorage?: Storage }).localStorage = undefined;
-	});
-
-	it("defaults to open when nothing is stored", () => {
-		assert.equal(readIntelligencePref(), true);
-	});
-
-	it("honours a stored collapse", () => {
-		writeIntelligencePref(false);
-		assert.equal(readIntelligencePref(), false);
-	});
-
-	it("round-trips an explicit open", () => {
-		writeIntelligencePref(false);
-		writeIntelligencePref(true);
-		assert.equal(readIntelligencePref(), true);
-	});
-
-	it("falls back to open when storage is unavailable", () => {
-		(globalThis as { localStorage?: Storage }).localStorage = undefined;
-		assert.equal(readIntelligencePref(), true);
-		assert.doesNotThrow(() => writeIntelligencePref(false));
-	});
-});
-
-describe("resolveRailOpen (#722)", () => {
-	const OPEN_MESSAGE = "thread-1/msg-1";
-	// No raise live, and a message on screen for one to be measured against.
-	const unraised = { raisedFor: null, openMessage: OPEN_MESSAGE };
-	const withThread = { hasThread: true, isDesktop: true, ...unraised };
-
-	it("opens the rail with the thread where the address says nothing", () => {
-		assert.equal(
-			resolveRailOpen({ ...withThread, panels: [], prefersOpen: true }),
-			true,
-		);
-	});
-
-	it("leaves the rail down where the address says nothing and the reader collapsed it", () => {
-		assert.equal(
-			resolveRailOpen({ ...withThread, panels: [], prefersOpen: false }),
-			false,
-		);
-	});
-
-	it("never seeds the rail below the tier that has one", () => {
-		assert.equal(
-			resolveRailOpen({
-				panels: [],
-				prefersOpen: true,
-				isDesktop: false,
-				hasThread: true,
-				...unraised,
-			}),
-			false,
-		);
-	});
-
-	// Otherwise the address claims a pane the shell has nothing to put in it.
-	it("never seeds the rail with no conversation open", () => {
-		assert.equal(
-			resolveRailOpen({
-				panels: [],
-				prefersOpen: true,
-				isDesktop: true,
-				hasThread: false,
-				...unraised,
-			}),
-			false,
-		);
-	});
-
-	// A shared link naming another panel is an address that has spoken: the
-	// recipient's own preference does not get to add the rail to it.
-	it("hands a shared link's panels to the reader who opened it", () => {
-		assert.equal(
-			resolveRailOpen({
-				...withThread,
-				panels: ["shortcuts"],
-				prefersOpen: true,
-			}),
-			false,
-		);
-		assert.equal(
-			resolveRailOpen({
-				...withThread,
-				panels: ["intelligence", "shortcuts"],
-				prefersOpen: false,
-			}),
-			true,
-		);
-	});
-
-	it("opens the rail from an address on any tier", () => {
-		assert.equal(
-			resolveRailOpen({
-				panels: ["intelligence"],
-				prefersOpen: false,
-				isDesktop: false,
-				hasThread: true,
-				...unraised,
-			}),
-			true,
-		);
-	});
-});
-
-/**
- * A DKIM mismatch, or the banner's "Why?", puts the rail up for the message the
- * reader is looking at. It is measured against that message rather than stored,
- * so it reaches neither the address nor the preference, and the next thread the
- * reader opens is not carrying it (#778).
- */
-describe("a raised rail belongs to its message (#778)", () => {
-	const OPEN_MESSAGE = "thread-1/msg-1";
-	const collapsed = {
-		hasThread: true,
-		isDesktop: true,
-		panels: [] as const,
-		prefersOpen: false,
-	};
-
-	it("puts the rail up over a collapse for the message it was raised for", () => {
-		assert.equal(
-			resolveRailOpen({
-				...collapsed,
-				raisedFor: OPEN_MESSAGE,
-				openMessage: OPEN_MESSAGE,
-			}),
-			true,
-		);
-	});
-
-	it("ends with the message, so the next thread opens as the reader left it", () => {
-		assert.equal(
-			resolveRailOpen({
-				...collapsed,
-				raisedFor: OPEN_MESSAGE,
-				openMessage: "thread-2/msg-2",
-			}),
-			false,
-		);
-		assert.equal(
-			resolveRailOpen({
-				...collapsed,
-				hasThread: false,
-				raisedFor: OPEN_MESSAGE,
-				openMessage: null,
-			}),
-			false,
-		);
-	});
-
-	// The reader is being shown something about the message in front of them, so
-	// a link that named other panels does not get to suppress it.
-	it("surfaces over an address that named another panel", () => {
-		assert.equal(
-			resolveRailOpen({
-				...collapsed,
-				panels: ["shortcuts"],
-				raisedFor: OPEN_MESSAGE,
-				openMessage: OPEN_MESSAGE,
-			}),
-			true,
-		);
-	});
-});

package/src/lib/intelligence-pref.ts

@@ -1,71 +0,0 @@
-/**
- * Persistence for the intelligence-pane open/closed preference (#782), and the
- * precedence between it and the address (#722).
- *
- * The pane opens with the thread by default; a manual collapse sticks across
- * sessions. Storage failures (private mode / quota) fall back to the default
- * (open) rather than crashing.
- */
-import type { PanelFragment } from "@/routing";
-
-export const INTELLIGENCE_PREF_KEY = "remit:intelligence-open";
-
-export function readIntelligencePref(): boolean {
-	try {
-		return localStorage.getItem(INTELLIGENCE_PREF_KEY) !== "closed";
-	} catch {
-		return true;
-	}
-}
-
-export function writeIntelligencePref(open: boolean): void {
-	try {
-		localStorage.setItem(INTELLIGENCE_PREF_KEY, open ? "open" : "closed");
-	} catch {
-		// Storage unavailable — the in-memory default stands.
-	}
-}
-
-export interface RailVisibility {
-	/** The panels the address names. */
-	panels: readonly PanelFragment[];
-	prefersOpen: boolean;
-	/** The rail is a pane of the desktop shell; narrower tiers have a drawer. */
-	isDesktop: boolean;
-	/** The rail reads a conversation, so with none open there is nothing to be up. */
-	hasThread: boolean;
-	/** The message a transient raise was made for, if one is live. */
-	raisedFor: string | null;
-	/** The message on screen, which is what a raise is measured against. */
-	openMessage: string | null;
-}
-
-/**
- * Whether the rail is up.
- *
- * A raise answers first, and only for the message it was made for: a DKIM
- * mismatch or the banner's "Why?" surfaces the rail over a collapse, because
- * the reader is being shown something about what is in front of them — and
- * opening anything else ends it, so one mismatched signature is not the chrome
- * of the whole session (#778). It is measured rather than stored, which is why
- * it never reaches the address or the preference.
- *
- * Otherwise an address that names any panel is the only owner of what is open,
- * so a shared link showing the shortcuts sheet is not overwritten by the
- * recipient's own preference. The preference speaks only where the address is
- * silent, and only with a conversation open on the tier that has a rail — it
- * opens with the thread there (#782), while a phone would get a full-screen
- * drawer over a message nobody asked to cover.
- */
-export function resolveRailOpen({
-	panels,
-	prefersOpen,
-	isDesktop,
-	hasThread,
-	raisedFor,
-	openMessage,
-}: RailVisibility): boolean {
-	if (raisedFor !== null && raisedFor === openMessage) return true;
-	if (panels.length > 0) return panels.includes("intelligence");
-	return isDesktop && hasThread && prefersOpen;
-}