@remit/web-client 0.0.279 → 0.0.280

package/src/hooks/useStarredThreads.ts

@@ -14,20 +14,28 @@
  * below the newest page rendered an empty list however much of it the
  * collection held (#308); the server answers the predicate over the whole
  * collection instead, and a page comes back full of matches.
+ *
+ * Free text is one of those parameters, so a search is this same paginated
+ * query rather than a second, single-page one beside it. The separate one had
+ * no error state of its own — an expired session read as "nothing matched" —
+ * no continuation, so "Load more" was a dead button under a query, and its own
+ * loading state, so a cached listing flashed the empty state while it was in
+ * flight.
  */
 import { unifiedThreadOperationsListAllThreadsQueryKey } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
 import { unifiedThreadOperationsListAllThreads } from "@remit/api-http-client/sdk.gen.ts";
 import type { RemitImapThreadMessageResponse } from "@remit/api-http-client/types.gen.ts";
 import { useInfiniteQuery, useQuery } from "@tanstack/react-query";
 import { useMemo } from "react";
-import type { InboxFilterParams } from "@/lib/inbox-filters";
+import type { ThreadSearchTokenParams } from "@/lib/thread-search-tokens";
 
 /** The criteria the Flagged view narrows its listing by, all server-applied. */
-export interface StarredCriteria extends InboxFilterParams {
-	/** Free text, matched against subject and From over the whole collection. */
+export interface StarredCriteria extends ThreadSearchTokenParams {
+	/**
+	 * Free text, matched against subject, From and the body preview over the
+	 * whole collection.
+	 */
 	query?: string;
-	/** Page size, set only by the single-page text search. */
-	limit?: number;
 }
 
 // `starred` and `order` are the view itself, not a criterion, so they are set
@@ -101,37 +109,6 @@ export function useStarredThreads(
 	};
 }
 
-/**
- * The server's own text match over the whole starred collection, as one page.
- *
- * The free-text filter has two halves that no single request covers: the server
- * matches subject and From over every starred message, and the client can also
- * match a snippet, but only on rows it has already loaded. The server's set is
- * the filter — it is the half that sees the mail below the newest page — and
- * the snippet pass complements it (#308). Same shape as the daily brief's
- * unscoped search, which merges the same two halves.
- */
-export function useStarredTextSearch(
-	criteria: StarredCriteria,
-	limit: number,
-): RemitImapThreadMessageResponse[] {
-	const text = criteria.query ?? "";
-	const query = { ...starredQuery(criteria), limit };
-	const { data } = useQuery({
-		queryKey: unifiedThreadOperationsListAllThreadsQueryKey({ query }),
-		queryFn: async () => {
-			const { data: page } = await unifiedThreadOperationsListAllThreads({
-				query,
-				throwOnError: true,
-			});
-			return page;
-		},
-		enabled: text.length > 0,
-		staleTime: 30_000,
-	});
-	return useMemo(() => data?.items ?? [], [data]);
-}
-
 /**
  * How many of the matching starred messages are unread, counted by the server.
  *

package/src/lib/brief-criteria.test.ts

@@ -21,8 +21,13 @@ const tokensOf = (query: string): SearchToken[] =>
 		mailboxesByName: new Map([["sent", "mb2"]]),
 	}).tokens;
 
-const criteriaOf = (query: string, attributes: string[] = []) =>
-	briefCriteria("all", new Set(attributes), tokensOf(query)).criteria;
+const criteriaOf = (
+	query: string,
+	attributes: string[] = [],
+	accountId?: string,
+) =>
+	briefCriteria("all", new Set(attributes), tokensOf(query), accountId)
+		.criteria;
 
 const residualTypes = (query: string, attributes: string[] = []) =>
 	briefCriteria("all", new Set(attributes), tokensOf(query)).residual.map(
@@ -30,13 +35,16 @@ const residualTypes = (query: string, attributes: string[] = []) =>
 	);
 
 describe("briefCriteria", () => {
-	test("an unnarrowed brief asks for nothing in particular", () => {
-		assert.deepEqual(criteriaOf(""), {});
+	// The brief renders no muted sender's mail, so every request it makes says
+	// so — the alternative is a header counting mail the list drops (#1137).
+	test("an unnarrowed brief still refuses muted senders", () => {
+		assert.deepEqual(criteriaOf(""), { muted: false });
 		assert.deepEqual(residualTypes(""), []);
 	});
 
 	test("the chips travel as parameters", () => {
 		assert.deepEqual(criteriaOf("", ["unread", "attachment"]), {
+			muted: false,
 			unread: true,
 			attachments: true,
 		});
@@ -44,6 +52,7 @@ describe("briefCriteria", () => {
 
 	test("a typed token asks for exactly what its chip asks for", () => {
 		assert.deepEqual(criteriaOf("is:unread has:attachment"), {
+			muted: false,
 			unread: true,
 			attachments: true,
 		});
@@ -51,20 +60,36 @@ describe("briefCriteria", () => {
 	});
 
 	test("is:read narrows the request rather than the rows", () => {
-		assert.deepEqual(criteriaOf("is:read"), { unread: false });
+		assert.deepEqual(criteriaOf("is:read"), { muted: false, unread: false });
 		assert.deepEqual(residualTypes("is:read"), []);
 	});
 
 	test("is:starred travels too", () => {
-		assert.deepEqual(criteriaOf("is:starred"), { starred: true });
+		assert.deepEqual(criteriaOf("is:starred"), { muted: false, starred: true });
 		assert.deepEqual(residualTypes("is:starred"), []);
 	});
 
+	// #1136: the pill used to narrow the rows after they arrived, so a count
+	// taken over every account was not the size of the list showing one.
+	test("the account pill travels as a parameter", () => {
+		assert.deepEqual(criteriaOf("", [], "acc_1"), {
+			muted: false,
+			accountId: "acc_1",
+		});
+	});
+
+	test("the cross-account brief names no account", () => {
+		assert.equal(Object.hasOwn(criteriaOf(""), "accountId"), false);
+	});
+
 	// The section supplies its own category, so the shared criteria must not
 	// carry one — two categories on one request is a request for neither.
 	test("the category never travels in the shared criteria", () => {
-		assert.deepEqual(criteriaOf("category:personal"), {});
-		assert.deepEqual(criteriaOf("", ["unread"]), { unread: true });
+		assert.deepEqual(criteriaOf("category:personal"), { muted: false });
+		assert.deepEqual(criteriaOf("", ["unread"]), {
+			muted: false,
+			unread: true,
+		});
 		assert.equal(
 			Object.hasOwn(
 				briefCriteria("personal", new Set(), []).criteria,
@@ -74,13 +99,32 @@ describe("briefCriteria", () => {
 		);
 	});
 
-	// `listAllThreads` has one text parameter matching subject and From at once,
-	// so neither token can be asked for on its own and both stay residue.
-	test("from: and subject: have no parameter here and come back as residue", () => {
-		assert.deepEqual(criteriaOf("from:alice"), {});
-		assert.deepEqual(residualTypes("from:alice"), ["from"]);
-		assert.deepEqual(residualTypes("subject:invoice"), ["subject"]);
-		assert.deepEqual(BRIEF_TOKEN_PARAMS.includes("from"), false);
+	// #1128: the free-text parameter matches subject and From at once, so
+	// neither token could be asked for on its own and both were applied over the
+	// rows a section had fetched. Each has its own parameter now.
+	test("from: and subject: travel as parameters", () => {
+		assert.deepEqual(criteriaOf("from:alice"), {
+			muted: false,
+			from: "alice",
+		});
+		assert.deepEqual(residualTypes("from:alice"), []);
+		assert.deepEqual(criteriaOf("subject:invoice"), {
+			muted: false,
+			subject: "invoice",
+		});
+		assert.deepEqual(residualTypes("subject:invoice"), []);
+		assert.equal(BRIEF_TOKEN_PARAMS.includes("from"), true);
+		assert.equal(BRIEF_TOKEN_PARAMS.includes("subject"), true);
+	});
+
+	// One parameter per field, so a second value cannot be expressed; it drops
+	// to the residue rather than being silently lost.
+	test("a second from: stays residue", () => {
+		assert.deepEqual(criteriaOf("from:alice from:bob"), {
+			muted: false,
+			from: "alice",
+		});
+		assert.deepEqual(residualTypes("from:alice from:bob"), ["from"]);
 	});
 
 	test("dates, the mailbox and the account stay residue", () => {
@@ -92,7 +136,10 @@ describe("briefCriteria", () => {
 	});
 
 	test("a chip beats the token that contradicts it", () => {
-		assert.deepEqual(criteriaOf("is:read", ["unread"]), { unread: true });
+		assert.deepEqual(criteriaOf("is:read", ["unread"]), {
+			muted: false,
+			unread: true,
+		});
 		assert.deepEqual(residualTypes("is:read", ["unread"]), ["isRead"]);
 	});
 });
@@ -102,7 +149,6 @@ describe("briefCountsMatchRows", () => {
 		briefCountsMatchRows({
 			residual: [],
 			attributes: new Set<string>(),
-			accountScoped: false,
 			...over,
 		});
 
@@ -112,11 +158,7 @@ describe("briefCountsMatchRows", () => {
 	});
 
 	test("a residual token makes the count wider than the list", () => {
-		assert.equal(reach({ residual: tokensOf("from:alice") }), false);
-	});
-
-	test("the account pills scope the rows and nothing else", () => {
-		assert.equal(reach({ accountScoped: true }), false);
+		assert.equal(reach({ residual: tokensOf("before:2024-01-01") }), false);
 	});
 
 	test("a chip with no parameter makes the count wider than the list", () => {

package/src/lib/brief-criteria.ts

@@ -4,13 +4,15 @@
  * The brief's category scope is not a criterion here: every section is its own
  * category-scoped request, so the category travels per section rather than in
  * the shared criteria. What is shared is the attribute chips and the tokens
- * typed in the field — `is:unread`, `has:attachment`, `is:starred` — all of them
- * columns on the ThreadMessage row, so all of them travel as query parameters
- * over the whole scope instead of as a pass over the rows already fetched
- * (#312).
+ * typed in the field — `from:`, `subject:`, `is:unread`, `has:attachment`,
+ * `is:starred` — all of them fields on the ThreadMessage row, so all of them
+ * travel as query parameters over the whole scope instead of as a pass over the
+ * rows already fetched (#312, #1128).
  *
- * `from:` and `subject:` stay residue: `listAllThreads` has one text parameter
- * that matches both at once, so neither can be asked for on its own.
+ * The account pill and mute travel with them. Both used to narrow the rows after
+ * they arrived, which is what took the number off every section header: a count
+ * over every account, muted senders included, is not the size of a list showing
+ * one account without them (#1136, #1137).
  *
  * Two chips have no parameter anywhere — "From contacts" reads `senderTrust`,
  * which is off-row (design D7), and "Today" is a date, which no listing
@@ -24,11 +26,14 @@ import { inboxFilterParams } from "./inbox-filters.js";
 import type { SearchToken } from "./search-tokens.js";
 import {
 	type ThreadSearchTokenParamName,
+	type ThreadSearchTokenParams,
 	threadSearchTokens,
 } from "./thread-search-tokens.js";
 
 /** The token parameters `listAllThreads` carries. */
 export const BRIEF_TOKEN_PARAMS: readonly ThreadSearchTokenParamName[] = [
+	"from",
+	"subject",
 	"category",
 	"unread",
 	"starred",
@@ -53,7 +58,12 @@ export const briefClientOnlyFilters = (
 	new Set(BRIEF_CLIENT_ONLY_FILTERS.filter((id) => attributes.has(id)));
 
 /** Everything a section request narrows by except its own category. */
-export type BriefSectionParams = Omit<InboxFilterParams, "category">;
+export type BriefSectionParams = Omit<ThreadSearchTokenParams, "category"> & {
+	/** The account the pills narrow to, or absent for the whole config. */
+	accountId?: string;
+	/** Always `false` here: the brief renders no muted sender's mail. */
+	muted?: boolean;
+};
 
 export interface BriefCriteria {
 	/** What every section request carries, chips and carried tokens together. */
@@ -66,19 +76,29 @@ export const briefCriteria = (
 	category: string,
 	attributes: ReadonlySet<string>,
 	tokens: readonly SearchToken[],
+	accountId?: string,
 ): BriefCriteria => {
-	const chipParams = inboxFilterParams({ category, attributes });
+	const chipParams: InboxFilterParams = inboxFilterParams({
+		category,
+		attributes,
+	});
 	const { params, residual } = threadSearchTokens(
 		tokens,
 		chipParams,
 		BRIEF_TOKEN_PARAMS,
 	);
 	const request = { ...params, ...chipParams };
-	const criteria: BriefSectionParams = {};
+	// Mute is not a control the reader sets: the brief is the view that hides
+	// muted senders, so every request it makes says so and every count it shows
+	// is a count of what it renders.
+	const criteria: BriefSectionParams = { muted: false };
+	if (request.from !== undefined) criteria.from = request.from;
+	if (request.subject !== undefined) criteria.subject = request.subject;
 	if (request.unread !== undefined) criteria.unread = request.unread;
 	if (request.starred !== undefined) criteria.starred = request.starred;
 	if (request.attachments !== undefined)
 		criteria.attachments = request.attachments;
+	if (accountId !== undefined) criteria.accountId = accountId;
 	return { criteria, residual };
 };
 
@@ -87,24 +107,23 @@ export interface BriefCountReach {
 	residual: readonly SearchToken[];
 	/** Attribute chips currently on. */
 	attributes: ReadonlySet<string>;
-	/** True while the reader has narrowed the brief to one account. */
-	accountScoped: boolean;
 }
 
 /**
  * Whether a section's server count is a count of what the section shows.
  *
  * The count answers the request. Anything narrowing the rows after they arrive —
- * a residual token, a chip with no parameter, the account pills, which no
- * listing endpoint scopes by — makes the count the size of a wider set than the
- * list. A wider number rendered as the section's size is a worse reading than no
- * number, so the caller asks for none.
+ * a residual token, or a chip with no parameter — makes the count the size of a
+ * wider set than the list. A wider number rendered as the section's size is a
+ * worse reading than no number, so the caller asks for none.
+ *
+ * The account pills are not among them any more, and neither is mute: both are
+ * parameters the request carries, so the count narrows exactly as the list does
+ * (#1136, #1137).
  */
 export const briefCountsMatchRows = ({
 	residual,
 	attributes,
-	accountScoped,
 }: BriefCountReach): boolean =>
 	residual.length === 0 &&
-	!accountScoped &&
 	!BRIEF_CLIENT_ONLY_FILTERS.some((id) => attributes.has(id));

package/src/lib/brief.test.ts

@@ -11,11 +11,7 @@ import {
 	BRIEF_CATEGORIES,
 	type BriefCategoryResult,
 	briefSections,
-	briefSectionTotal,
-	excludeMutedSenders,
-	matchesBriefSearch,
 	matchesSearchTokens,
-	mergeSearchRows,
 	toThreadRowData,
 } from "./brief.js";
 import type { SearchToken } from "./search-tokens.js";
@@ -288,157 +284,6 @@ describe("briefSections", () => {
 	});
 });
 
-// issue #301: `Address.flags.muted` is denormalized onto each row as
-// `muted`; the brief excludes those rows before grouping into sections.
-describe("excludeMutedSenders", () => {
-	test("drops a row whose sender is muted", () => {
-		const kept = threadResponse({ threadMessageId: "keep" });
-		const muted = threadResponse({ threadMessageId: "mute-me", muted: true });
-		const result = excludeMutedSenders([kept, muted]);
-		assert.deepStrictEqual(
-			result.map((t) => t.threadMessageId),
-			["keep"],
-		);
-	});
-
-	test("keeps rows whose sender is not muted", () => {
-		const rows = [
-			threadResponse({ threadMessageId: "a", muted: false }),
-			threadResponse({ threadMessageId: "b" }),
-		];
-		assert.strictEqual(excludeMutedSenders(rows).length, 2);
-	});
-
-	test("returns an empty array when every sender is muted", () => {
-		const rows = [
-			threadResponse({ threadMessageId: "a", muted: true }),
-			threadResponse({ threadMessageId: "b", muted: true }),
-		];
-		assert.deepStrictEqual(excludeMutedSenders(rows), []);
-	});
-
-	test("a muted sender's message is excluded from every section, not folded into uncategorized", () => {
-		const rows = [
-			threadResponse({
-				threadMessageId: "muted-personal",
-				messageId: "muted-personal",
-				category: "personal",
-				muted: true,
-			}),
-			threadResponse({
-				threadMessageId: "kept-personal",
-				messageId: "kept-personal",
-				category: "personal",
-			}),
-		];
-		const kept = excludeMutedSenders(rows).map(toThreadRowData);
-		const sections = briefSections([
-			{
-				category: "personal",
-				rows: kept,
-				total: { kind: "exact", value: kept.length },
-				atCap: false,
-				loading: false,
-				failed: false,
-			},
-		]);
-		const allIds = sections.flatMap((s) => s.threads.map((t) => t.id));
-		assert.deepStrictEqual(allIds, ["kept-personal"]);
-	});
-
-	test("muting every candidate row leaves no sections (brief empty state)", () => {
-		const rows = [
-			threadResponse({
-				threadMessageId: "a",
-				messageId: "a",
-				category: "personal",
-				muted: true,
-			}),
-			threadResponse({
-				threadMessageId: "b",
-				messageId: "b",
-				category: "newsletter",
-				muted: true,
-			}),
-		];
-		const kept = excludeMutedSenders(rows).map(toThreadRowData);
-		const sections = briefSections([
-			{
-				category: "personal",
-				rows: kept,
-				total: { kind: "exact", value: 0 },
-				atCap: false,
-				loading: false,
-				failed: false,
-			},
-		]);
-		assert.deepStrictEqual(sections, []);
-	});
-});
-
-// The count is the server's, taken over a scope that includes senders the reader
-// muted — `listAllThreads` has no `muted` parameter. The list drops their mail,
-// so the number would overstate what is on screen.
-describe("briefSectionTotal", () => {
-	const counted: ResultCount = { kind: "exact", value: 4753 };
-
-	test("keeps the count when no sender in the rows is muted", () => {
-		assert.deepStrictEqual(
-			briefSectionTotal(counted, [
-				threadResponse({ threadMessageId: "a" }),
-				threadResponse({ threadMessageId: "b", muted: false }),
-			]),
-			counted,
-		);
-	});
-
-	test("withholds the count when the rows show a muted sender", () => {
-		assert.deepStrictEqual(
-			briefSectionTotal(counted, [
-				threadResponse({ threadMessageId: "a" }),
-				threadResponse({ threadMessageId: "b", muted: true }),
-			]),
-			{ kind: "unknown" },
-		);
-	});
-
-	test("a count nobody took stays absent", () => {
-		assert.deepStrictEqual(briefSectionTotal({ kind: "unknown" }, []), {
-			kind: "unknown",
-		});
-	});
-});
-
-describe("matchesBriefSearch", () => {
-	const r = row({
-		id: "1",
-		fromName: "Alice Tan",
-		fromEmail: "alice@example.com",
-		subject: "Q3 roadmap",
-		snippet: "See the attached deck",
-	});
-
-	test("matches on fromName (case-insensitive)", () => {
-		assert.strictEqual(matchesBriefSearch(r, "alice"), true);
-	});
-
-	test("matches on fromEmail", () => {
-		assert.strictEqual(matchesBriefSearch(r, "alice@example"), true);
-	});
-
-	test("matches on subject", () => {
-		assert.strictEqual(matchesBriefSearch(r, "roadmap"), true);
-	});
-
-	test("matches on snippet", () => {
-		assert.strictEqual(matchesBriefSearch(r, "deck"), true);
-	});
-
-	test("returns false when query matches nothing", () => {
-		assert.strictEqual(matchesBriefSearch(r, "zyxwvuts"), false);
-	});
-});
-
 describe("matchesSearchTokens", () => {
 	const from = (value: string): SearchToken => ({
 		type: "from",
@@ -646,82 +491,3 @@ describe("matchesSearchTokens", () => {
 		);
 	});
 });
-
-// #49: a listing complete under its own criteria still cannot see a snippet
-// match, and the server's cross-folder search cannot see one either. The two
-// halves are merged. The brief no longer uses this — its sections are pages, and
-// merging a page with a search window orders two truncated lists (#312).
-describe("mergeSearchRows", () => {
-	test("keeps rows the server found in other folders", () => {
-		const merged = mergeSearchRows(
-			[row({ id: "inbox-hit", sentDate: 300 })],
-			[
-				row({ id: "archive-hit", sentDate: 200 }),
-				row({ id: "spam-hit", sentDate: 100 }),
-			],
-		);
-
-		assert.deepEqual(
-			merged.map((r) => r.id),
-			["inbox-hit", "archive-hit", "spam-hit"],
-		);
-	});
-
-	test("keeps a snippet-only match the server cannot see", () => {
-		const merged = mergeSearchRows(
-			[row({ id: "snippet-only", sentDate: 100 })],
-			[],
-		);
-
-		assert.deepEqual(
-			merged.map((r) => r.id),
-			["snippet-only"],
-		);
-	});
-
-	test("the two sources overlap on INBOX, so rows are deduped", () => {
-		const merged = mergeSearchRows(
-			[row({ id: "shared", sentDate: 200, subject: "from the brief" })],
-			[
-				row({ id: "shared", sentDate: 200, subject: "from the search" }),
-				row({ id: "archive-hit", sentDate: 100 }),
-			],
-		);
-
-		assert.deepEqual(
-			merged.map((r) => r.id),
-			["shared", "archive-hit"],
-		);
-		assert.equal(merged[0].subject, "from the brief");
-	});
-
-	test("the union reads newest first, interleaving both sources", () => {
-		const merged = mergeSearchRows(
-			[
-				row({ id: "brief-new", sentDate: 400 }),
-				row({ id: "brief-old", sentDate: 200 }),
-			],
-			[
-				row({ id: "search-mid", sentDate: 300 }),
-				row({ id: "search-oldest", sentDate: 100 }),
-			],
-		);
-
-		assert.deepEqual(
-			merged.map((r) => r.id),
-			["brief-new", "search-mid", "brief-old", "search-oldest"],
-		);
-	});
-
-	test("a row without a sentDate sorts last", () => {
-		const merged = mergeSearchRows(
-			[row({ id: "undated" })],
-			[row({ id: "dated", sentDate: 100 })],
-		);
-
-		assert.deepEqual(
-			merged.map((r) => r.id),
-			["dated", "undated"],
-		);
-	});
-});