@bobfrankston/rmfmail 1.2.215 → 1.2.217

package/client/app.js

@@ -1790,11 +1790,24 @@ async function deleteSelectedMessages() {
         });
     }
 }
+/** Serialize Ctrl+Z presses. Each undo is several awaited IPCs plus a
+ *  revealMessage + folder reload; firing them concurrently (hold Ctrl and tap Z
+ *  three times to walk back three deletions) had them interleaving — two
+ *  reveals fighting over the list position, reloads landing out of order. The
+ *  stack is LIFO and each queued call pops its own entry when its turn comes,
+ *  so N presses undo the N most recent actions, in order. */
+let undoChain = Promise.resolve();
+function queueUndo() {
+    undoChain = undoChain.then(() => performUndo()).catch(() => { });
+}
 async function performUndo() {
     const op = popUndo();
     if (!op)
         return;
     const statusSync = document.getElementById("status-sync");
+    // "3 more to undo" — without it, a stack of undone deletions is invisible
+    // and the user can't tell whether pressing Ctrl+Z again will do anything.
+    const remaining = undoStack.length ? ` — ${undoStack.length} more to undo` : "";
     try {
         if (op.kind === "delete") {
             // payload is the full batch (was a single object pre-2026-06-12;
@@ -1805,9 +1818,9 @@ async function performUndo() {
                 await undeleteMessage(m.accountId, m.uid, m.folderId);
             }
             if (statusSync)
-                statusSync.textContent = msgs.length === 1
+                statusSync.textContent = (msgs.length === 1
                     ? "Message restored"
-                    : `Restored ${msgs.length} messages`;
+                    : `Restored ${msgs.length} messages`) + remaining;
             // Position at what was just restored — an undo whose effect lands
             // off-screen (or in a folder you've since left) reads as a no-op.
             // Reveal the first of the batch; the rest are in the same view.
@@ -1820,7 +1833,7 @@ async function performUndo() {
             }
         }
         else if (op.kind === "move") {
-            const { messages } = op.payload;
+            const { messages, targetFolderId } = op.payload;
             const byDest = new Map();
             for (const m of messages) {
                 const key = `${m.accountId}:${m.sourceFolderId}`;
@@ -1828,15 +1841,18 @@ async function performUndo() {
                     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");
+            const { moveMessages } = 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);
+                // The messages are sitting in targetFolderId right now, so that
+                // is their SOURCE for the reverse move — pass it explicitly.
+                // Without it the service resolves each row by (account, uid)
+                // alone and a same-numbered uid in another folder can be moved
+                // instead (the flag-clear / spam-move wrong-folder class).
+                const currentFolderIds = targetFolderId ? group.uids.map(() => targetFolderId) : undefined;
+                await moveMessages(group.accountId, group.uids, group.folderId, currentFolderIds);
             }
             if (statusSync)
-                statusSync.textContent = `Undid move of ${messages.length} message${messages.length !== 1 ? "s" : ""}`;
+                statusSync.textContent = `Undid move of ${messages.length} message${messages.length !== 1 ? "s" : ""}${remaining}`;
             // Same positioning rule as undo-delete: show the message back in
             // its original folder.
             const firstMoved = messages[0];
@@ -1861,7 +1877,7 @@ async function performUndo() {
                 messageState.updateMessageFlags(entry.accountId, entry.uid, flagsAfter);
             }
             if (statusSync)
-                statusSync.textContent = `Undid flag change on ${op.payload.length} message${op.payload.length !== 1 ? "s" : ""}`;
+                statusSync.textContent = `Undid flag change on ${op.payload.length} message${op.payload.length !== 1 ? "s" : ""}${remaining}`;
         }
         reloadCurrentFolder();
     }
@@ -2170,12 +2186,32 @@ async function spamSelectedMessages() {
         g.folderIds.push(msg.folderId);
         byAccount.set(msg.accountId, g);
     }
+    // Marking spam is just a move to the \Junk folder (service-side
+    // markAsSpamMessages), so its inverse is the move back — the same undo op
+    // a drag-to-folder move records. Pushed BEFORE the IPC, not in its `.then`:
+    // a misfired spam click is exactly the case where the user reaches for
+    // Ctrl+Z immediately, and the local move has already happened by then
+    // (Bob 2026-08-03: "^z should undo send-to-spam"). The move branch of
+    // performUndo restores each message to its own sourceFolderId, so a
+    // selection spanning folders comes back correctly; targetFolderId is only
+    // known once the service answers and the undo doesn't need it.
+    const spamUndo = {
+        messages: snapshot.map(m => ({ accountId: m.accountId, uid: m.uid, sourceFolderId: m.folderId })),
+        targetAccountId: snapshot[0].accountId,
+        targetFolderId: 0, // filled in below — only the service knows which folder is \Junk
+    };
+    pushUndo({ kind: "move", at: Date.now(), payload: spamUndo });
     if (statusSync)
-        statusSync.textContent = `Spam: ${snapshot.length} queued — pending server sync`;
+        statusSync.textContent = `Spam: ${snapshot.length} queued — Ctrl+Z to undo`;
     for (const [accountId, { uids, folderIds }] of byAccount) {
         markAsSpamMessages(accountId, uids, folderIds)
             .then(result => {
             console.log(`[spam] ${accountId}: moved ${result?.moved ?? uids.length} to folderId=${result?.targetFolderId}`);
+            // Now we know where they landed. The undo op is still on the
+            // stack (same object) — record it so the reverse move names the
+            // messages' current folder instead of guessing by uid alone.
+            if (result?.targetFolderId)
+                spamUndo.targetFolderId = result.targetFolderId;
         })
             .catch(e => {
             console.error(`[spam] ${accountId} failed:`, e);
@@ -4094,7 +4130,7 @@ document.addEventListener("keydown", (e) => {
         const composeOpen = !!document.querySelector(".compose-overlay");
         if (!inEditable && !composeOpen && undoStack.length > 0) {
             e.preventDefault();
-            performUndo();
+            queueUndo();
         }
     }
     // F5 = Sync
@@ -4333,7 +4369,7 @@ function openShortcutsDialog() {
                 ["Forward", "Ctrl+F"],
                 ["Sync", "F5"],
                 ["Delete selected", "Del or Ctrl+D"],
-                ["Undo last delete/move", "Ctrl+Z"],
+                ["Undo delete / move / spam / flag (repeat to go back further)", "Ctrl+Z"],
                 ["Toggle read/unread", "R"],
                 ["Toggle flag (★)", "(⚑ button in viewer)"],
                 ["Select all visible", "Ctrl+A"],