@bobfrankston/rmfmail 1.1.131 → 1.1.133

package/client/app.js

@@ -1303,9 +1303,24 @@ function forwardBody(msg) {
     const body = sanitizeQuotedBody(msg);
     return `<p></p><br><br><div class="reply"><p>---------- Forwarded message ----------<br>From: ${from}<br>Date: ${date}<br>Subject: ${msg.subject}<br>To: ${to}</p>${body}</div>`;
 }
-let lastDeleted = null;
-let lastMoved = null;
-let undoTimeout = null;
+const undoStack = [];
+const UNDO_MAX = 50;
+const UNDO_TTL_MS = 10 * 60_000;
+function pushUndo(op) {
+    undoStack.push(op);
+    if (undoStack.length > UNDO_MAX)
+        undoStack.shift();
+}
+function popUndo() {
+    const now = Date.now();
+    while (undoStack.length > 0) {
+        const op = undoStack.pop();
+        if (now - op.at < UNDO_TTL_MS)
+            return op;
+        // Expired — drop silently and try the next one.
+    }
+    return null;
+}
 /** Route a "delete the selection" action (Delete key, Ctrl+D, top trash
  *  button) to whichever pane has a selection. Tasks take priority — if
  *  any task rows are selected, delete those; otherwise fall through to
@@ -1341,24 +1356,19 @@ async function deleteSelectedMessages() {
     const snapshot = [...selected];
     removeMessagesAndReconcile(selected);
     // Undo support set immediately too — Ctrl+Z works the moment rows
-    // disappear from the list, not only after the daemon ACKs.
+    // disappear from the list, not only after the daemon ACKs. Multi-select
+    // deletes only support undo for the first message today (consistent with
+    // the previous single-slot semantics); the loop+push pattern can be
+    // generalized later if Bob hits it.
     if (snapshot.length === 1) {
-        lastDeleted = { ...snapshot[0], subject: "" };
+        pushUndo({ kind: "delete", at: Date.now(), payload: { ...snapshot[0], subject: "" } });
         if (statusSync)
             statusSync.textContent = `Trashed 1 message (syncing) — Ctrl+Z to undo`;
     }
     else {
-        lastDeleted = null;
         if (statusSync)
             statusSync.textContent = `Trashed ${snapshot.length} messages (syncing)`;
     }
-    if (undoTimeout)
-        clearTimeout(undoTimeout);
-    undoTimeout = setTimeout(() => {
-        lastDeleted = null;
-        if (statusSync?.textContent?.includes("undo"))
-            statusSync.textContent = "";
-    }, 30000);
     // Fire-and-forget per local-first: optimistic remove above already
     // updated the UI; the daemon-side trash is sync DB + queued IMAP.
     // An IPC 120s timeout doesn't mean the trash failed — surfacing it
@@ -1378,66 +1388,66 @@ async function deleteSelectedMessages() {
         });
     }
 }
-async function undoDelete() {
-    if (!lastDeleted)
-        return;
-    const { accountId, uid, folderId } = lastDeleted;
-    try {
-        await undeleteMessage(accountId, uid, folderId);
-        const statusSync = document.getElementById("status-sync");
-        if (statusSync)
-            statusSync.textContent = "Message restored";
-        lastDeleted = null;
-        if (undoTimeout)
-            clearTimeout(undoTimeout);
-        reloadCurrentFolder();
-    }
-    catch (e) {
-        console.error(`Undo failed: ${e.message}`);
-    }
-}
-async function undoMove() {
-    if (!lastMoved)
+async function performUndo() {
+    const op = popUndo();
+    if (!op)
         return;
-    const { messages } = lastMoved;
     const statusSync = document.getElementById("status-sync");
     try {
-        // Group by (sourceAccountId, sourceFolderId) and move each group back
-        const byDest = new Map();
-        for (const m of messages) {
-            const key = `${m.accountId}:${m.sourceFolderId}`;
-            if (!byDest.has(key))
-                byDest.set(key, { accountId: m.accountId, folderId: m.sourceFolderId, uids: [] });
-            byDest.get(key).uids.push(m.uid);
+        if (op.kind === "delete") {
+            const { accountId, uid, folderId } = op.payload;
+            await undeleteMessage(accountId, uid, folderId);
+            if (statusSync)
+                statusSync.textContent = "Message restored";
         }
-        const { moveMessages, moveMessage } = await import("./lib/api-client.js");
-        for (const group of byDest.values()) {
-            if (group.uids.length === 1)
-                await moveMessage(group.accountId, group.uids[0], group.folderId);
-            else
-                await moveMessages(group.accountId, group.uids, group.folderId);
+        else if (op.kind === "move") {
+            const { messages } = op.payload;
+            const byDest = new Map();
+            for (const m of messages) {
+                const key = `${m.accountId}:${m.sourceFolderId}`;
+                if (!byDest.has(key))
+                    byDest.set(key, { accountId: m.accountId, folderId: m.sourceFolderId, uids: [] });
+                byDest.get(key).uids.push(m.uid);
+            }
+            const { moveMessages, moveMessage } = await import("./lib/api-client.js");
+            for (const group of byDest.values()) {
+                if (group.uids.length === 1)
+                    await moveMessage(group.accountId, group.uids[0], group.folderId);
+                else
+                    await moveMessages(group.accountId, group.uids, group.folderId);
+            }
+            if (statusSync)
+                statusSync.textContent = `Undid move of ${messages.length} message${messages.length !== 1 ? "s" : ""}`;
+        }
+        else if (op.kind === "flag") {
+            const { updateFlags } = await import("./lib/api-client.js");
+            // Restore each row's prior \Flagged state. Mutates message-state
+            // flags arrays directly via the per-row helper so the list paints
+            // immediately; the daemon STORE happens via updateFlags.
+            for (const entry of op.payload) {
+                const flag = "\\Flagged";
+                const flagsAfter = entry.prevFlagged
+                    ? [flag] // simplest restore — full set is unknown here
+                    : [];
+                await updateFlags(entry.accountId, entry.uid, flagsAfter);
+                setRowFlagged(entry.accountId, entry.uid, entry.prevFlagged);
+                messageState.updateMessageFlags(entry.accountId, entry.uid, flagsAfter);
+            }
+            if (statusSync)
+                statusSync.textContent = `Undid flag change on ${op.payload.length} message${op.payload.length !== 1 ? "s" : ""}`;
         }
-        if (statusSync)
-            statusSync.textContent = `Undid move of ${messages.length} message${messages.length !== 1 ? "s" : ""}`;
-        lastMoved = null;
-        if (undoTimeout)
-            clearTimeout(undoTimeout);
         reloadCurrentFolder();
     }
     catch (e) {
-        console.error(`Undo move failed: ${e.message}`);
+        console.error(`Undo failed: ${e.message}`);
         if (statusSync)
-            statusSync.textContent = `Undo move failed: ${e.message}`;
+            statusSync.textContent = `Undo failed: ${e.message}`;
     }
 }
 // Listen for the "mailx-moved" custom event emitted by folder-tree's drop
 // handler so Ctrl+Z can reverse the most recent move.
 document.addEventListener("mailx-moved", (e) => {
-    lastMoved = e.detail;
-    lastDeleted = null; // Ctrl+Z undoes whichever came last
-    if (undoTimeout)
-        clearTimeout(undoTimeout);
-    undoTimeout = setTimeout(() => { lastMoved = null; }, 60000);
+    pushUndo({ kind: "move", at: Date.now(), payload: e.detail });
 });
 document.getElementById("btn-delete")?.addEventListener("click", deleteSelection);
 // Same handlers also bound to the top-toolbar icons so delete/spam work
@@ -1459,6 +1469,58 @@ function updateFlagButton() {
     btn.textContent = yes ? "★" : "☆";
 }
 document.addEventListener("mailx-message-shown", updateFlagButton);
+/** Bulk-flag the current message-list selection (toolbar ★). If every
+ *  selected row is already flagged, unflag them all; otherwise flag any
+ *  unflagged rows. Pushes a single undo entry capturing each row's prior
+ *  state so Ctrl+Z restores the exact mix. Falls back to the viewer's
+ *  focused message when no list selection exists. */
+async function bulkFlagSelected() {
+    const selected = getSelectedMessages();
+    if (selected.length === 0) {
+        const cur = getCurrentMessage();
+        if (!cur)
+            return;
+        selected.push({ accountId: cur.accountId, uid: cur.message.uid, folderId: cur.message.folderId });
+    }
+    const statusSync = document.getElementById("status-sync");
+    // Pull current message objects from state so we know each row's existing
+    // flags + flagged state. Anything not in current state is silently skipped.
+    const messages = messageState.getMessages();
+    const byKey = new Map();
+    for (const m of messages)
+        byKey.set(`${m.accountId}:${m.uid}`, m);
+    const rows = selected
+        .map(s => byKey.get(`${s.accountId}:${s.uid}`))
+        .filter(Boolean);
+    if (rows.length === 0)
+        return;
+    const anyUnflagged = rows.some(r => !flaggedOf(r));
+    const targetFlagged = anyUnflagged; // mixed or all-unflagged → flag; all-flagged → unflag
+    const undoPayload = rows.map(r => ({
+        accountId: r.accountId, uid: r.uid, prevFlagged: flaggedOf(r),
+    }));
+    const { updateFlags } = await import("./lib/api-client.js");
+    for (const r of rows) {
+        if (flaggedOf(r) === targetFlagged)
+            continue;
+        setFlagged(r, targetFlagged);
+        setRowFlagged(r.accountId, r.uid, targetFlagged);
+        messageState.updateMessageFlags(r.accountId, r.uid, r.flags);
+        try {
+            await updateFlags(r.accountId, r.uid, r.flags);
+        }
+        catch (e) {
+            console.error(`Bulk flag failed for ${r.accountId}/${r.uid}: ${e?.message || e}`);
+        }
+    }
+    pushUndo({ kind: "flag", at: Date.now(), payload: undoPayload });
+    updateFlagButton();
+    if (statusSync) {
+        const verb = targetFlagged ? "Flagged" : "Unflagged";
+        statusSync.textContent = `${verb} ${rows.length} message${rows.length !== 1 ? "s" : ""} — Ctrl+Z to undo`;
+    }
+}
+document.getElementById("btn-tb-flag")?.addEventListener("click", bulkFlagSelected);
 document.getElementById("btn-flag")?.addEventListener("click", async () => {
     const sel = getCurrentFocused();
     if (!sel)
@@ -3148,15 +3210,11 @@ document.addEventListener("keydown", (e) => {
         e.preventDefault();
         deleteSelection();
     }
-    // Ctrl+Z = Undo the most recent delete or move
+    // Ctrl+Z = pop the top of the undo stack (delete / move / flag).
     if (e.ctrlKey && e.key === "z") {
-        if (lastMoved) {
-            e.preventDefault();
-            undoMove();
-        }
-        else if (lastDeleted) {
+        if (undoStack.length > 0) {
             e.preventDefault();
-            undoDelete();
+            performUndo();
         }
     }
     // F5 = Sync
@@ -4486,15 +4544,38 @@ optThreaded?.addEventListener("change", () => {
 // Flagged-only filter — keeps the CSS-level hiding for instant feedback on
 // the current page AND re-queries the folder so flagged messages that live
 // outside the currently-loaded page show up.
-optFlagged?.addEventListener("change", () => {
+/** Sync the search-bar ★ button's pressed state to the current
+ *  `flagged-only` filter setting. Visible UI parallel to the menu
+ *  checkbox so the filter is reachable without diving into the View
+ *  dropdown. */
+function syncFilterFlaggedButton() {
+    const btn = document.getElementById("btn-filter-flagged");
+    if (!btn)
+        return;
+    btn.classList.toggle("active", !!optFlagged?.checked);
+    btn.setAttribute("aria-pressed", optFlagged?.checked ? "true" : "false");
+}
+function applyFlaggedFilter(on) {
+    if (optFlagged)
+        optFlagged.checked = on;
     const body = document.getElementById("ml-body");
-    if (optFlagged.checked)
+    if (on)
         body?.classList.add("flagged-only");
     else
         body?.classList.remove("flagged-only");
-    localStorage.setItem("mailx-flagged", String(optFlagged.checked));
+    localStorage.setItem("mailx-flagged", String(on));
+    syncFilterFlaggedButton();
     reloadCurrentFolder();
+}
+optFlagged?.addEventListener("change", () => {
+    applyFlaggedFilter(!!optFlagged.checked);
+});
+document.getElementById("btn-filter-flagged")?.addEventListener("click", () => {
+    applyFlaggedFilter(!(optFlagged?.checked));
 });
+// Initial paint of the button's pressed state (covers the localStorage-restored
+// value loaded earlier in this file).
+syncFilterFlaggedButton();
 // Priority-senders-only filter — same pattern as flagged-only. Adds
 // .priority-only to the list body; CSS hides any row without .priority.
 const optPriorityOnly = document.getElementById("opt-priority-only");