- {t("mail.attachments")}
+ {t("mail.attachments", { count: selected?.attachments.length ?? 1 })}
{selected.attachments.map((filename, idx) => (
diff --git a/services/webmail/src/lib/mailCounts.ts b/services/webmail/src/lib/mailCounts.ts
index f2081e9..adb3ebb 100644
--- a/services/webmail/src/lib/mailCounts.ts
+++ b/services/webmail/src/lib/mailCounts.ts
@@ -120,3 +120,77 @@ export function listHeaderCount(input: {
export function applySeen(messages: T[], uid: number, seen: boolean): T[] {
return messages.map((m) => (m.uid === uid ? { ...m, seen } : m));
}
+
+/** What the sidebar shows beside one folder. */
+export interface FolderBadge {
+ /** How many unread messages the folder holds. */
+ unread: number;
+ /** How many messages it holds in total. */
+ total: number;
+ /**
+ * Whether the unread number is worth showing at all.
+ *
+ * Kept apart from the number itself because the sidebar used to fall back to
+ * printing the total in the unread badge's place whenever nothing was
+ * unread. An inbox holding fourteen read messages therefore showed "14", and
+ * reading another message never moved it - the number was never counting
+ * what the user thought it was.
+ */
+ showsUnread: boolean;
+}
+
+/**
+ * The two numbers a sidebar folder has, and which of them to emphasise.
+ *
+ * Drafts deliberately has no unread badge: nothing marks a draft read, so its
+ * unread count is always zero and the number that matters there is how many
+ * unfinished messages are waiting - which is the total. Returning showsUnread
+ * false for it is what stops the sidebar rendering that same total twice, once
+ * as the size and once as the badge, which is where "Rascunhos 1 1" came from.
+ */
+export function folderBadge(
+ folders: FolderSummary[] | undefined | null,
+ route: string,
+): FolderBadge {
+ const { unread, total } = folderMetrics(folders, route);
+ const isDrafts = route.trim().toLowerCase() === "drafts";
+ return { unread, total, showsUnread: !isDrafts && unread > 0 };
+}
+
+/** Which actions a message offers, decided by the folder it is in. */
+export interface ReaderActions {
+ canReply: boolean;
+ canForward: boolean;
+ /** Reopen an unfinished message in the composer. */
+ canEdit: boolean;
+ canMarkUnread: boolean;
+ canDelete: boolean;
+ /** True in Trash, where delete destroys rather than moves. */
+ deleteIsPermanent: boolean;
+}
+
+/**
+ * The actions that make sense for a message, given where it lives.
+ *
+ * The reader offered the same four buttons everywhere, so a message the user
+ * had sent themselves could be "marked unread" - a flag nothing reads on a
+ * folder nothing delivers to - and a half-written draft offered Reply and
+ * Forward but no way to carry on writing it. Meanwhile delete was offered
+ * nowhere at all.
+ */
+export function readerActions(folder: string): ReaderActions {
+ const role = folder.trim().toLowerCase();
+ const isDrafts = role === "drafts";
+ const isOwnCopy = isDrafts || role === "sent";
+
+ return {
+ canReply: !isDrafts,
+ canForward: !isDrafts,
+ canEdit: isDrafts,
+ // Sent mail and drafts are the user's own copies. Nothing ever delivers
+ // to those folders, so an unread flag there conveys nothing.
+ canMarkUnread: !isOwnCopy,
+ canDelete: true,
+ deleteIsPermanent: role === "trash",
+ };
+}
diff --git a/services/webmail/src/mail-state-integrity.test.ts b/services/webmail/src/mail-state-integrity.test.ts
index 732be88..2c142f0 100644
--- a/services/webmail/src/mail-state-integrity.test.ts
+++ b/services/webmail/src/mail-state-integrity.test.ts
@@ -28,10 +28,21 @@ describe("the counters the sidebar shows", () => {
// The badge was computed inline from folders.find(...).unread_count, which
// missed folders with no special-use role and printed nothing for Drafts.
it("goes through the tested counting rules", () => {
- expect(code(USER_LAYOUT)).toContain("badgeCount");
+ // folderBadge, not badgeCount: the sidebar needs to know which of the two
+ // numbers to emphasise, not just what the number is. Rendering was where
+ // the defect lived - a folder with nothing unread printed its total in the
+ // unread badge's place, so reading a message never moved it.
+ expect(code(USER_LAYOUT)).toContain("folderBadge");
expect(code(USER_LAYOUT)).not.toMatch(/unread_count\s*\?\?/);
});
+ // The total was rendered twice for Drafts, where the badge and the size are
+ // the same number: "Rascunhos 1 1".
+ it("renders the folder size in exactly one place", () => {
+ const layout = code(USER_LAYOUT);
+ expect(layout.match(/\{badge\.total\}/g) ?? []).toHaveLength(1);
+ });
+
// The folder list was fetched once on mount, so every badge froze at the
// value it had when the tab was opened: new mail did not raise it and reading
// a message did not lower it.
diff --git a/services/webmail/src/mailCounts.test.ts b/services/webmail/src/mailCounts.test.ts
index 81553e6..e9f52f3 100644
--- a/services/webmail/src/mailCounts.test.ts
+++ b/services/webmail/src/mailCounts.test.ts
@@ -156,3 +156,103 @@ describe("marking a message read in the loaded list", () => {
expect(messages.find((m) => m.uid === 1)?.seen).toBe(false);
});
});
+
+// --- what the sidebar actually renders -----------------------------------
+
+import { folderBadge, readerActions } from "./lib/mailCounts";
+
+/**
+ * These reproduce what the running webmail shows, which the badgeCount tests
+ * above could not: they check the number, and the defect was in how the number
+ * is displayed.
+ */
+describe("the badge a sidebar folder renders", () => {
+ const folders = [
+ { special_use: "inbox", name: "INBOX", unread_count: 0, total_count: 14 },
+ { special_use: "drafts", name: "Drafts", unread_count: 0, total_count: 1 },
+ { special_use: "sent", name: "Sent", unread_count: 0, total_count: 1 },
+ { special_use: "junk", name: "Junk", unread_count: 3, total_count: 9 },
+ { special_use: "archive", name: "Archive", unread_count: 0, total_count: 0 },
+ ];
+
+ // The inbox showed "14" with nothing unread. Reading every message left it
+ // at 14, because 14 was the total wearing the unread badge's clothes.
+ it("does not show a total where an unread count belongs", () => {
+ const badge = folderBadge(folders, "inbox");
+ expect(badge.unread).toBe(0);
+ expect(badge.showsUnread).toBe(false);
+ });
+
+ it("still reports the folder size, separately from the unread count", () => {
+ expect(folderBadge(folders, "inbox").total).toBe(14);
+ });
+
+ // Drafts counted total as its badge, so total and badge were the same
+ // number and the sidebar printed it twice: "Rascunhos 1 1".
+ it("never renders the same number twice for drafts", () => {
+ const badge = folderBadge(folders, "drafts");
+ const rendered = [badge.showsUnread ? badge.unread : null, badge.total].filter(
+ (v) => v !== null,
+ );
+ expect(rendered).toEqual([1]);
+ });
+
+ it("shows the unread count when there really is unread mail", () => {
+ const badge = folderBadge(folders, "junk");
+ expect(badge.showsUnread).toBe(true);
+ expect(badge.unread).toBe(3);
+ expect(badge.total).toBe(9);
+ });
+
+ it("shows nothing at all for an empty folder", () => {
+ const badge = folderBadge(folders, "archive");
+ expect(badge.showsUnread).toBe(false);
+ expect(badge.total).toBe(0);
+ });
+});
+
+describe("the actions a message offers", () => {
+ // "Mark as unread" was offered on a message the user sent themselves and on
+ // their own half-written draft. Nothing reads those, so the flag means
+ // nothing there and the button only invites a pointless round trip.
+ it("does not offer mark-as-unread in Sent or Drafts", () => {
+ expect(readerActions("sent").canMarkUnread).toBe(false);
+ expect(readerActions("drafts").canMarkUnread).toBe(false);
+ });
+
+ it("offers mark-as-unread in the folders that receive mail", () => {
+ expect(readerActions("inbox").canMarkUnread).toBe(true);
+ expect(readerActions("archive").canMarkUnread).toBe(true);
+ });
+
+ // Reply and forward on your own unfinished draft make no sense either: the
+ // thing to do with a draft is finish it.
+ it("offers editing rather than replying on a draft", () => {
+ const draft = readerActions("drafts");
+ expect(draft.canEdit).toBe(true);
+ expect(draft.canReply).toBe(false);
+ expect(draft.canForward).toBe(false);
+ });
+
+ it("offers reply and forward on received mail", () => {
+ const inbox = readerActions("inbox");
+ expect(inbox.canReply).toBe(true);
+ expect(inbox.canForward).toBe(true);
+ expect(inbox.canEdit).toBe(false);
+ });
+
+ // Delete has to be offered everywhere: it was offered nowhere, which is why
+ // a draft left behind by a sent message could not be removed at all.
+ it("offers delete in every folder", () => {
+ for (const folder of ["inbox", "sent", "drafts", "archive", "junk", "trash"]) {
+ expect(readerActions(folder).canDelete).toBe(true);
+ }
+ });
+
+ // In Trash the same button has to say it destroys the message, because there
+ // it does - there is nowhere further to move it.
+ it("says delete is permanent once in Trash", () => {
+ expect(readerActions("trash").deleteIsPermanent).toBe(true);
+ expect(readerActions("inbox").deleteIsPermanent).toBe(false);
+ });
+});