@remit/web-client 0.0.279 → 0.0.280

package/src/lib/brief.ts

@@ -28,11 +28,11 @@
  * a high-volume mailbox read≠handled and unread≠important; unread is a
  * user-selectable filter chip instead.
  *
- * Muted senders and categories the scope holds none of are excluded. Mute
- * filtering happens in `excludeMutedSenders`, applied by the caller to the raw
- * thread rows before `toThreadRowData` — the server denormalizes `muted` onto
- * each row from the From address's flags (RFC 039 Decision 3, issue #301), so no
- * client-side Address lookup is needed.
+ * Muted senders and categories the scope holds none of are excluded. Mute is
+ * `muted=false` on each section's request, so the rows and the count answer the
+ * same predicate — dropping muted rows here instead left a header stating a
+ * number larger than the list under it, and a "Show all" that opened mail the
+ * brief would not render (#1137).
  */
 
 import type { RemitImapThreadMessageResponse } from "@remit/api-http-client/types.gen.ts";
@@ -80,71 +80,6 @@ export function toThreadRowData(
 	};
 }
 
-/**
- * Excludes rows whose From address is muted (`thread.muted === true`,
- * denormalized server-side from `Address.flags.muted`). Muting hides a
- * sender from the brief only — it never deletes, marks read, or moves their
- * mail, so callers outside the brief (mailbox listings, search) must not
- * apply this filter.
- */
-/**
- * The section's count, or no number, once mute is taken into account.
- *
- * Mute is the one criterion the request cannot be asked about: `listAllThreads`
- * has no `muted` parameter, so a scope holding a muted sender is counted with
- * that sender's mail in it while the list renders without it. The header would
- * overstate, and "Show all" would offer rows the brief will not show.
- *
- * Withheld per section rather than for the whole brief — one muted marketer must
- * not take the number off Personal — and only where a mute is visible in the
- * rows on hand. A muted sender below a section's page is not visible, so this
- * suppresses a number known to be wrong rather than certifying the rest.
- */
-export function briefSectionTotal(
-	total: ResultCount,
-	rows: RemitImapThreadMessageResponse[],
-): ResultCount {
-	return rows.some((row) => row.muted === true) ? { kind: "unknown" } : total;
-}
-
-export function excludeMutedSenders(
-	threads: RemitImapThreadMessageResponse[],
-): RemitImapThreadMessageResponse[] {
-	return threads.filter((t) => t.muted !== true);
-}
-
-/**
- * Union of a complete server-filtered listing with the rows the server's
- * cross-folder text search returned, newest first.
- *
- * Both lists are needed where the listing itself is complete under its criteria
- * — the Flagged collection is, and pages to its end. The server matches subject
- * and From only, so a row whose snippet carries the term is found only by the
- * client-side pass; the server pass is the only one that reaches Archive, Sent,
- * Spam and custom folders. The two overlap, so rows are deduped by id, the first
- * occurrence winning.
- *
- * Not for a paginated prefix. The brief's sections are per-category pages, so
- * merging one with a search window and re-sorting would order two truncated
- * lists against each other and call the result newest-first (#312).
- *
- * Rows without a `sentDate` sort last; the brief's own list is already newest
- * first, so this only has to re-interleave the two sources.
- */
-export function mergeSearchRows(
-	briefRows: ThreadRowData[],
-	searchRows: ThreadRowData[],
-): ThreadRowData[] {
-	const seen = new Set<string>();
-	const merged: ThreadRowData[] = [];
-	for (const row of [...briefRows, ...searchRows]) {
-		if (seen.has(row.id)) continue;
-		seen.add(row.id);
-		merged.push(row);
-	}
-	return merged.sort((a, b) => (b.sentDate ?? 0) - (a.sentDate ?? 0));
-}
-
 /**
  * The categories the brief asks for, in the order it renders them. A category
  * is both the section's own scope and the query parameter its request carries;
@@ -210,19 +145,6 @@ export function briefSections(
 	return sections;
 }
 
-/**
- * Returns true when `t` matches the free-text `query` (lower-cased).
- * Checked against fromName, fromEmail, subject, and snippet.
- */
-export function matchesBriefSearch(t: ThreadRowData, query: string): boolean {
-	return (
-		t.fromName.toLowerCase().includes(query) ||
-		t.fromEmail.toLowerCase().includes(query) ||
-		t.subject.toLowerCase().includes(query) ||
-		t.snippet.toLowerCase().includes(query)
-	);
-}
-
 /**
  * Returns true when `t` satisfies every token handed to it.
  *
@@ -234,10 +156,12 @@ export function matchesBriefSearch(t: ThreadRowData, query: string): boolean {
  * the rows fetched so far" (#312).
  *
  * Every token is implemented so that a request carrying fewer parameters still
- * has somewhere to put the rest: `listAllThreads` has no `from` or `subject` of
- * its own, and no endpoint has `before:`, `after:`, `in:` or `account:`. A row
- * without the data a token needs (no `sentDate` for `before:`/`after:`) never
- * matches it, so it drops out rather than showing under an unverifiable filter.
+ * has somewhere to put the rest: no endpoint has `before:`, `after:`, `in:` or
+ * `account:` in the set these tokens are split against, and each takes one
+ * `from` and one `subject`, so a second of either — or one a chip overruled —
+ * lands here. A row without the data a token needs (no `sentDate` for
+ * `before:`/`after:`) never matches it, so it drops out rather than showing
+ * under an unverifiable filter.
  */
 export function matchesSearchTokens(
 	t: ThreadRowData,

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

@@ -71,16 +71,31 @@ describe("flaggedCriteria", () => {
 		assert.deepEqual(residualTypes("is:starred"), []);
 	});
 
-	// No `from`/`subject` parameter on this endpoint: its one text parameter
-	// matches both at once, so these stay a pass over the returned rows rather
-	// than being dropped from a request that never carried them.
+	// #1128: the free-text parameter matches subject and From at once, so
+	// neither token could be asked for on its own. Both applied over the pages
+	// already fetched, and a starred collection is paged — a match below them
+	// never appeared. Each has its own parameter now.
+	test("from: and subject: travel as parameters", () => {
+		assert.deepEqual(criteriaOf("from:alice"), { from: "alice" });
+		assert.deepEqual(residualTypes("from:alice"), []);
+		assert.deepEqual(criteriaOf("subject:invoice"), { subject: "invoice" });
+		assert.deepEqual(residualTypes("subject:invoice"), []);
+	});
+
 	test("keeps the tokens no parameter carries", () => {
-		assert.deepEqual(residualTypes("from:alice"), ["from"]);
 		assert.deepEqual(residualTypes("before:2026-01-01"), ["before"]);
 		assert.deepEqual(residualTypes("in:sent"), ["in"]);
 		assert.deepEqual(residualTypes("account:alice"), ["account"]);
 	});
 
+	// One parameter per field, so only the first value can be expressed.
+	test("a second subject: stays residue", () => {
+		assert.deepEqual(criteriaOf("subject:one subject:two"), {
+			subject: "one",
+		});
+		assert.deepEqual(residualTypes("subject:one subject:two"), ["subject"]);
+	});
+
 	test("the chip wins over a token that contradicts it", () => {
 		const { criteria, residual } = flaggedCriteria(
 			chips("all", ["unread"]),

package/src/lib/flagged-criteria.ts

@@ -2,12 +2,12 @@
  * What the Flagged view asks `listAllThreads` for, and what is left over.
  *
  * Every criterion the view offers — the category chip, the Unread and Has
- * attachment chips, and the `category:` / `is:unread` / `is:read` /
- * `has:attachment` / `is:starred` tokens typed in the field — is a column on
- * the ThreadMessage row, so all of them travel as query parameters. A criterion
- * applied over the pages loaded so far is the defect this replaces: a starred
- * collection is paged, so anything below the newest page was invisible to it
- * (#308).
+ * attachment chips, and the `from:` / `subject:` / `category:` / `is:unread` /
+ * `is:read` / `has:attachment` / `is:starred` tokens typed in the field — is a
+ * field on the ThreadMessage row, so all of them travel as query parameters. A
+ * criterion applied over the pages loaded so far is the defect this replaces: a
+ * starred collection is paged, so anything below the newest page was invisible
+ * to it (#308, #1128).
  *
  * `starred` is the view rather than a criterion: the request always carries it,
  * which is what makes `is:starred` a carried token instead of residue.
@@ -16,24 +16,25 @@
  * beats text in a field — and the overruled token drops to the residue, where
  * it matches nothing, which is the honest answer to a contradiction.
  */
-import type {
-	InboxFilterCriteria,
-	InboxFilterParams,
-} from "./inbox-filters.js";
+import type { InboxFilterCriteria } from "./inbox-filters.js";
 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. It has no `from` or `subject`
- * of its own — its one text parameter matches both at once — so those two
- * tokens stay residue rather than being dropped from a request that never had
- * them.
+ * The token parameters `listAllThreads` carries, which is every parameter it
+ * takes. `from` and `subject` joined them once the operation grew a parameter
+ * for each field: its one free-text parameter matches both at once, so neither
+ * token could be asked for on its own and both were applied over the pages
+ * already fetched — a match below them never appeared (#1128).
  */
 export const FLAGGED_TOKEN_PARAMS: readonly ThreadSearchTokenParamName[] = [
+	"from",
+	"subject",
 	"category",
 	"unread",
 	"starred",
@@ -42,7 +43,7 @@ export const FLAGGED_TOKEN_PARAMS: readonly ThreadSearchTokenParamName[] = [
 
 export interface FlaggedCriteria {
 	/** What the request narrows by, chips and carried tokens together. */
-	criteria: InboxFilterParams;
+	criteria: ThreadSearchTokenParams;
 	/** The tokens no parameter carries; apply these over the returned rows. */
 	residual: SearchToken[];
 }

package/src/lib/inbox-filters.ts

@@ -89,11 +89,28 @@ export const filterReach = (query: ThreadSearchQuery): FilterReach =>
 		? "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 =>
@@ -121,7 +138,7 @@ const queryOf = (queryKey: unknown): Record<string, unknown> | undefined => {
  */
 export const sameInboxFilter = (
 	queryKey: unknown,
-	params: InboxFilterParams,
+	params: ListFilterParams,
 ): boolean => {
 	const previous = queryOf(queryKey);
 	if (!previous) return false;

package/src/lib/thread-search-tokens.ts

@@ -39,9 +39,10 @@ export type ThreadSearchTokenParamName = keyof ThreadSearchTokenParams;
 /**
  * Every parameter `searchThreads` takes, the default set.
  *
- * `listAllThreads` takes all of these except `from` and `subject`, so a caller
- * on that endpoint names its own set and the two tokens come back as residue
- * rather than being silently dropped from a request that never carried them.
+ * `listAllThreads` takes all six as well (#1128), so both callers carry the
+ * same tokens. A caller still names its own set rather than inheriting this
+ * one: the set is what decides which tokens come back as residue, and an
+ * endpoint that grows or loses a parameter has to say so where it is called.
  */
 export const THREAD_SEARCH_TOKEN_PARAMS: readonly ThreadSearchTokenParamName[] =
 	["from", "subject", "category", "unread", "starred", "attachments"];