@remit/web-client 0.0.77 → 0.0.79

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/web-client",
-  "version": "0.0.77",
+  "version": "0.0.79",
   "type": "module",
   "description": "Remit web client, published as composable primitives — the app shell, auth shells, and runtime config. A distributor imports what it composes and bundles it.",
   "exports": {

package/src/components/mail/MailboxPane.tsx

@@ -100,6 +100,7 @@ import {
 	type ConversationTarget,
 } from "@/lib/conversation-target";
 import { dedupeThreadMessages } from "@/lib/dedupe-thread-messages";
+import { applyInboxFilters } from "@/lib/inbox-filters";
 import { readIntelligencePref } from "@/lib/intelligence-pref";
 import { useMailContext } from "@/lib/mail-context";
 import { isRescueCandidate } from "@/lib/rescue-candidates";
@@ -117,40 +118,6 @@ import { parseSearchTokens } from "@/lib/search-tokens";
 import { useTelemetry } from "@/lib/telemetry-context";
 import { MailViewChrome } from "./MailViewChrome";
 
-/* ------------------------------------------------------------------ */
-/* Inbox filter predicates — the inbox preset offers Unread / Starred /
-   Has attachment (never accounts; an inbox is one account already).
-   The `flagged` id is the wire name for IMAP \Flagged; the label is
-   "Starred".                                                           */
-/* ------------------------------------------------------------------ */
-
-const INBOX_FILTER_PREDICATES: Record<
-	string,
-	(t: RemitImapThreadMessageResponse) => boolean
-> = {
-	unread: (t) => !t.isRead,
-	flagged: (t) => t.hasStars === true,
-	attachment: (t) => Boolean(t.hasAttachment),
-};
-
-function applyInboxFilters(
-	threads: RemitImapThreadMessageResponse[],
-	category: string,
-	attributes: ReadonlySet<string>,
-): RemitImapThreadMessageResponse[] {
-	const predicates = Array.from(attributes)
-		.map((id) => INBOX_FILTER_PREDICATES[id])
-		.filter(
-			(p): p is (t: RemitImapThreadMessageResponse) => boolean => p != null,
-		);
-	if (category === "all" && predicates.length === 0) return threads;
-	return threads.filter(
-		(t) =>
-			(category === "all" || t.category === category) &&
-			predicates.every((p) => p(t)),
-	);
-}
-
 /* ------------------------------------------------------------------ */
 /* Context                                                              */
 /* ------------------------------------------------------------------ */

package/src/hooks/useToggleStar.test.ts

@@ -12,6 +12,7 @@ const make = (
 	hasStars: boolean,
 ): RemitImapThreadMessageResponse => ({
 	senderTrust: "unknown",
+	category: "uncategorized",
 	threadId: "t1",
 	threadMessageId: `tm-${messageId}`,
 	messageId,

package/src/hooks/useToggleTrusted.test.ts

@@ -77,6 +77,7 @@ describe("patchDescribeMessage", () => {
 				cc: [],
 				bcc: [],
 				replyTo: [],
+				category: "uncategorized",
 				senderTrust: "unknown",
 			},
 			flags: [],

package/src/lib/brief.test.ts

@@ -24,6 +24,7 @@ function threadResponse(
 		fromEmail: "sender@example.com",
 		subject: "Subject",
 		snippet: "Snippet",
+		category: "uncategorized",
 		sentDate: 1767225600,
 		isRead: false,
 		isDeleted: false,

package/src/lib/dedupe-thread-messages.test.ts

@@ -16,6 +16,7 @@ function threadMessage(
 		fromEmail: "sender@example.com",
 		subject: "Subject",
 		snippet: "Snippet",
+		category: "uncategorized",
 		sentDate: 1767225600,
 		isRead: false,
 		isDeleted: false,

package/src/lib/display-category.test.ts

@@ -10,7 +10,10 @@ describe("toDisplayCategory", () => {
 		assert.strictEqual(toDisplayCategory("uncategorized"), "uncategorized");
 	});
 
-	test("treats a row with no category as unclassified", () => {
+	test("treats an absent category as unclassified", () => {
+		// No caller can reach this today — both response fields are required —
+		// but an absent category must resolve to `uncategorized`, never to
+		// `personal`, wherever one arrives from.
 		assert.strictEqual(toDisplayCategory(undefined), "uncategorized");
 	});
 

package/src/lib/display-category.ts

@@ -11,8 +11,10 @@ import type { ThreadCategory } from "@remit/ui";
  * decided was personal, so a classification gap read as a large personal inbox
  * rather than as missing work (issue #45).
  *
- * Pre-migration rows that read `undefined` carry no category either, so they
- * map to `uncategorized` the same way.
+ * Both response fields that feed this are required, so no caller reaches the
+ * `undefined` branch. The parameter stays tolerant anyway: this is the one place
+ * an absent category is turned into a value, and the answer has to be
+ * `uncategorized` rather than a crash or a `personal` default.
  */
 export function toDisplayCategory(
 	category: RemitImapMessageCategory | undefined,

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

@@ -0,0 +1,106 @@
+import assert from "node:assert/strict";
+import { describe, test } from "node:test";
+import type { RemitImapThreadMessageResponse } from "@remit/api-http-client/types.gen.ts";
+import { applyInboxFilters } from "./inbox-filters.js";
+
+// Only the fields the filter reads, following the fixture idiom in
+// starred-rows.test.ts.
+const thread = (
+	fields: Partial<RemitImapThreadMessageResponse> & { messageId: string },
+): RemitImapThreadMessageResponse =>
+	({ isRead: false, ...fields }) as unknown as RemitImapThreadMessageResponse;
+
+const personal = thread({ messageId: "m1", category: "personal" });
+const unclassified = thread({ messageId: "m2", category: "uncategorized" });
+const preClassification = thread({ messageId: "m3" });
+
+const ids = (threads: RemitImapThreadMessageResponse[]): string[] =>
+	threads.map((t) => t.messageId);
+
+describe("applyInboxFilters", () => {
+	test("returns the loaded list when nothing narrows it", () => {
+		const threads = [personal, unclassified, preClassification];
+		assert.deepEqual(applyInboxFilters(threads, "all", new Set()), threads);
+	});
+
+	test("matches a thread whose category is set", () => {
+		assert.deepEqual(
+			ids(applyInboxFilters([personal, unclassified], "personal", new Set())),
+			["m1"],
+		);
+	});
+
+	test("counts a thread with no category as unclassified (#45)", () => {
+		// A pre-classification thread already renders an `uncategorized` badge,
+		// so the Unclassified chip has to find the row the user can see. Reading
+		// the response field raw made that row vanish under its own chip.
+		assert.deepEqual(
+			ids(
+				applyInboxFilters(
+					[personal, unclassified, preClassification],
+					"uncategorized",
+					new Set(),
+				),
+			),
+			["m2", "m3"],
+		);
+	});
+
+	test("never lets unclassified mail answer to personal (#45)", () => {
+		assert.deepEqual(
+			applyInboxFilters(
+				[unclassified, preClassification],
+				"personal",
+				new Set(),
+			),
+			[],
+		);
+	});
+
+	test("applies attribute predicates alongside a category", () => {
+		const read = thread({
+			messageId: "m4",
+			category: "personal",
+			isRead: true,
+		});
+		assert.deepEqual(
+			ids(applyInboxFilters([personal, read], "personal", new Set(["unread"]))),
+			["m1"],
+		);
+	});
+
+	test("applies attribute predicates without a category", () => {
+		const read = thread({
+			messageId: "m4",
+			category: "newsletter",
+			isRead: true,
+		});
+		assert.deepEqual(
+			ids(applyInboxFilters([personal, read], "all", new Set(["unread"]))),
+			["m1"],
+		);
+	});
+
+	test("matches starred and attachment threads", () => {
+		const starred = thread({ messageId: "m5", hasStars: true });
+		const withAttachment = thread({ messageId: "m6", hasAttachment: true });
+		const plain = thread({ messageId: "m7" });
+		const threads = [starred, withAttachment, plain];
+		assert.deepEqual(
+			ids(applyInboxFilters(threads, "all", new Set(["flagged"]))),
+			["m5"],
+		);
+		assert.deepEqual(
+			ids(applyInboxFilters(threads, "all", new Set(["attachment"]))),
+			["m6"],
+		);
+	});
+
+	test("ignores an attribute id with no predicate behind it", () => {
+		const threads = [personal, unclassified];
+		assert.deepEqual(
+			applyInboxFilters(threads, "all", new Set(["nonsense"])),
+			threads,
+		);
+	});
+});

package/src/lib/inbox-filters.ts

@@ -0,0 +1,44 @@
+import type { RemitImapThreadMessageResponse } from "@remit/api-http-client/types.gen.ts";
+import { toDisplayCategory } from "./display-category.js";
+
+/**
+ * Inbox filter predicates — the inbox preset offers Unread / Starred / Has
+ * attachment (never accounts; an inbox is one account already). The `flagged`
+ * id is the wire name for IMAP \Flagged; the label is "Starred".
+ */
+const INBOX_FILTER_PREDICATES: Record<
+	string,
+	(t: RemitImapThreadMessageResponse) => boolean
+> = {
+	unread: (t) => !t.isRead,
+	flagged: (t) => t.hasStars === true,
+	attachment: (t) => Boolean(t.hasAttachment),
+};
+
+/**
+ * Narrow the loaded threads to one category and a set of attributes. Applied
+ * over the loaded pages until #306 moves the predicate into the query.
+ *
+ * The category comparison goes through `toDisplayCategory` so the inbox agrees
+ * with Starred and the brief, which filter mapped rows. `category` is optional
+ * on the response and absent reads as `uncategorized` everywhere else — a
+ * pre-classification thread renders an `uncategorized` badge, so a raw
+ * comparison made the row you can see vanish under its own chip (#45).
+ */
+export function applyInboxFilters(
+	threads: RemitImapThreadMessageResponse[],
+	category: string,
+	attributes: ReadonlySet<string>,
+): RemitImapThreadMessageResponse[] {
+	const predicates = Array.from(attributes)
+		.map((id) => INBOX_FILTER_PREDICATES[id])
+		.filter(
+			(p): p is (t: RemitImapThreadMessageResponse) => boolean => p != null,
+		);
+	if (category === "all" && predicates.length === 0) return threads;
+	return threads.filter(
+		(t) =>
+			(category === "all" || toDisplayCategory(t.category) === category) &&
+			predicates.every((p) => p(t)),
+	);
+}

package/src/test-support/fixtures.ts

@@ -71,6 +71,7 @@ export const makeThreadMessage = (
 	fromEmail: "alice@example.com",
 	sentDate: 1_767_225_600_000,
 	snippet: "",
+	category: "uncategorized",
 	isRead: false,
 	hasAttachment: false,
 	star: "none",