@remit/web-client 0.0.77 → 0.0.78

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/web-client",
-  "version": "0.0.77",
+  "version": "0.0.78",
   "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/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)),
+	);
+}