@bobfrankston/rmfmail 1.2.49 → 1.2.65

package/client/components/message-list.js

@@ -51,6 +51,16 @@ function applyLiveFilter(body) {
     }
 }
 let currentSearchQuery = "";
+/** Empty-list placeholder text. When a search is active, name the query so an
+ *  empty list reads as "nothing matched THIS search" rather than a bare,
+ *  alarming "No messages" (Bob 2026-06-25). Covers paths other than the
+ *  search loader itself — e.g. deleting the last surviving search hit. */
+function emptyListMessage() {
+    if (searchMode && currentSearchQuery) {
+        return `No messages found by "${escapeHtmlText(currentSearchQuery)}"`;
+    }
+    return "No messages";
+}
 // Remember the pre-search view mode so clearSearchMode() can restore it.
 // Without this, searching from "All Inboxes" loses the unified-mode flag
 // (loadSearchResults sets unifiedMode=false), and clearing the search
@@ -387,6 +397,166 @@ export function setRowSeen(accountId, uid, yes) {
     if (row)
         row.setUnreadClass(!yes);
 }
+/** Resolve currently-selected rows to MessageRow objects (skips any not in
+ *  the loaded DOM). */
+function selectedRows() {
+    const out = [];
+    for (const s of getSelectedMessages()) {
+        const row = rowByKey.get(rowKey(s.accountId, s.uid));
+        if (row)
+            out.push(row);
+    }
+    return out;
+}
+/** Every row currently shown (visible = matches search + view filters, and
+ *  loaded — the list lazy-loads). */
+function visibleRowObjs() {
+    const body = document.getElementById("ml-body");
+    if (!body)
+        return [];
+    return Array.from(body.querySelectorAll(".ml-row:not(.filter-hidden)"))
+        .map(el => rowByKey.get(rowKey(el.dataset.accountId || "", Number(el.dataset.uid))))
+        .filter((r) => !!r);
+}
+/** The set a bulk action targets: the SELECTED rows if any are marked,
+ *  otherwise ALL shown rows. This is the "act on selected, else all filtered"
+ *  rule Bob asked for (2026-06-24). */
+function bulkTargets() {
+    const sel = selectedRows();
+    return sel.length > 0 ? sel : visibleRowObjs();
+}
+/** Flag / unflag a set of rows. Captures the prior flagged state per row and
+ *  emits `mailx-flagged-batch` so app.ts can register ONE Ctrl+Z undo entry
+ *  for the whole batch (Bob 2026-06-24: bulk ops need undo for safety). */
+async function bulkSetFlagged(rows, flagged) {
+    const undo = [];
+    await Promise.all(rows.map(async (row) => {
+        // Read current state from the VISIBLE class via row.isFlagged — NOT
+        // flaggedOf(row.msg). The two can drift, and a stale `msg.flags` made
+        // Unflag skip flagged rows as "already unflagged" (Bob 2026-06-24
+        // "unflag is not removing the flag"). The class is the source of truth
+        // the single-star toggle already trusts.
+        const prev = row.isFlagged;
+        if (prev === flagged)
+            return; // already in the target state
+        const prevFlags = [...(row.msg.flags || [])];
+        row.isFlagged = flagged; // setter: updates class + msg.flags
+        try {
+            await updateFlags(row.accountId, row.msg.uid, row.msg.flags);
+            state.updateMessageFlags(row.accountId, row.msg.uid, row.msg.flags);
+            undo.push({ accountId: row.accountId, uid: row.msg.uid, prevFlagged: prev });
+        }
+        catch {
+            row.msg.flags = prevFlags; // revert on server failure
+            row.setFlaggedClass(prev);
+        }
+    }));
+    if (undo.length)
+        document.dispatchEvent(new CustomEvent("mailx-flagged-batch", { detail: undo }));
+}
+/** Mark a set of rows read / unread. Low-risk + trivially reversible, so no
+ *  undo entry (unlike flag, move, delete). State read from the class too. */
+async function bulkSetSeen(rows, seen) {
+    await Promise.all(rows.map(async (row) => {
+        const prev = row.isSeen;
+        if (prev === seen)
+            return;
+        const prevFlags = [...(row.msg.flags || [])];
+        row.isSeen = seen; // setter: updates class + msg.flags
+        try {
+            await updateFlags(row.accountId, row.msg.uid, row.msg.flags);
+            state.updateMessageFlags(row.accountId, row.msg.uid, row.msg.flags);
+        }
+        catch {
+            row.msg.flags = prevFlags;
+            row.setUnreadClass(!prev);
+        }
+    }));
+}
+/** Move every selected message (of the first selected row's account) to a
+ *  picked folder. Local-first: optimistic remove + fire-and-forget IPC, same
+ *  as the row context menu's "Move to folder…". */
+async function bulkMoveSelection() {
+    const targets = bulkTargets();
+    if (targets.length === 0)
+        return;
+    const accountId = targets[0].accountId;
+    const same = targets.filter(r => r.accountId === accountId);
+    const pick = await pickFolder(accountId, { excludeFolderIds: [same[0].msg.folderId] });
+    if (!pick)
+        return;
+    const uids = same.map(r => r.msg.uid);
+    removeMessagesAndReconcile(uids.map(u => ({ accountId, uid: u })));
+    const statusSync = document.getElementById("status-sync");
+    if (statusSync)
+        statusSync.textContent = `Moving ${uids.length} message${uids.length !== 1 ? "s" : ""} to ${pick.folderName}…`;
+    apiMoveMessages(accountId, uids, pick.folderId)
+        .then(() => { if (statusSync)
+        statusSync.textContent = `Moved ${uids.length} to ${pick.folderName}`; })
+        .catch((err) => { if (statusSync)
+        statusSync.textContent = `Move sync issue: ${err?.message || err}`; });
+    exitMultiSelect();
+}
+/** Toolbar "Filtered" menu — home for bulk operations. Two concepts, kept
+ *  separate (Bob 2026-06-24): SHOWN = rows the current folder/search/filters
+ *  make visible (lazy-loaded, so it's what's loaded now); SELECTED = rows
+ *  you've clicked. Actions auto-target: if anything is SELECTED they act on
+ *  that, otherwise on ALL SHOWN — the header says which is in effect. Delete
+ *  and Mark-as-spam are omitted: the toolbar's own buttons already do those on
+ *  the selection. Flag/unflag and move are Ctrl+Z-undoable. */
+export async function showSelectionMenu(x, y) {
+    const { showContextMenu } = await import("./context-menu.js");
+    const body = document.getElementById("ml-body");
+    const visibleRows = body
+        ? Array.from(body.querySelectorAll(".ml-row:not(.filter-hidden)"))
+        : [];
+    const enterMulti = () => body?.classList.add("multi-select-on");
+    const shownCount = visibleRows.length;
+    const selCount = getSelectedMessages().length;
+    const hasShown = shownCount > 0;
+    // Auto-target: selected if any, else all shown. The action labels carry
+    // the effective target count so there's no ambiguity about what runs.
+    const targetN = selCount > 0 ? selCount : shownCount;
+    const onWhat = selCount > 0 ? `selected (${selCount})` : `all shown (${shownCount})`;
+    const canAct = targetN > 0;
+    const items = [
+        { label: `Acting on ${onWhat}`, action: () => { }, disabled: true },
+        { label: "", action: () => { }, separator: true },
+        {
+            label: `Select all shown (${shownCount})`,
+            action: () => { if (!body)
+                return; enterMulti(); for (const r of visibleRows)
+                r.classList.add("selected"); lastClickedRow = visibleRows[visibleRows.length - 1] || null; updateBulkBar(); },
+            disabled: !hasShown,
+        },
+        {
+            label: "Select flagged ★ among shown",
+            action: () => { if (!body)
+                return; enterMulti(); for (const r of visibleRows)
+                r.classList.toggle("selected", r.classList.contains("flagged")); lastClickedRow = null; updateBulkBar(); },
+            disabled: !hasShown,
+        },
+        {
+            label: "Invert selection among shown",
+            action: () => { if (!body)
+                return; enterMulti(); for (const r of visibleRows)
+                r.classList.toggle("selected"); updateBulkBar(); },
+            disabled: !hasShown,
+        },
+        { label: `Deselect all (${selCount})`, action: () => exitMultiSelect(), disabled: selCount === 0 },
+        { label: "", action: () => { }, separator: true },
+        // Actions — auto-targeted (selected else all shown). No count on the
+        // verb itself (a number on "Flag" reads as ambiguous, Bob 2026-06-24);
+        // the "Acting on …" header above carries the target count.
+        { label: "Flag", action: () => bulkSetFlagged(bulkTargets(), true), disabled: !canAct },
+        { label: "Unflag", action: () => bulkSetFlagged(bulkTargets(), false), disabled: !canAct },
+        { label: "Mark read", action: () => bulkSetSeen(bulkTargets(), true), disabled: !canAct },
+        { label: "Mark unread", action: () => bulkSetSeen(bulkTargets(), false), disabled: !canAct },
+        { label: "", action: () => { }, separator: true },
+        { label: "Move to folder…", action: () => bulkMoveSelection(), disabled: !canAct },
+    ];
+    showContextMenu(x, y, items);
+}
 /** Scroll the focused row into view. Wired to a keyboard shortcut so the
  *  user can recover after scrolling the list away from the preview.
  *
@@ -815,7 +985,7 @@ export function removeMessagesAndReconcile(uids) {
             }
         }
         if (state.getMessages().length === 0) {
-            body.innerHTML = `<div class="ml-empty">No messages</div>`;
+            body.innerHTML = `<div class="ml-empty">${emptyListMessage()}</div>`;
         }
     }
     if (outcome.focusedWasRemoved) {
@@ -908,10 +1078,17 @@ export async function loadUnifiedInbox(autoSelect = true) {
     if (cached) {
         totalMessages = cached.total;
         state.setMessages(cached.items);
-        renderMessages(body, "", cached.items, { background: !autoSelect });
+        // See loadMessages: anchor the cache render on background reloads so a
+        // scrolled reader isn't yanked to the top when new mail arrives.
+        const renderCached = () => renderMessages(body, "", cached.items, { background: !autoSelect });
+        if (!autoSelect)
+            withScrollAnchor(body, renderCached);
+        else
+            renderCached();
         const targetUuid = remembered ? pickRestoreUid(cached.items, remembered) : null;
         if (targetUuid) {
-            body.scrollTop = savedScroll;
+            if (autoSelect)
+                body.scrollTop = savedScroll;
             restoreSelection(body, targetUuid);
         }
         else if (autoSelect) {
@@ -1034,7 +1211,7 @@ export async function loadSearchResults(query, scope = "all", accountId = "", fo
             totalMessages = matches.length;
             state.setMessages(matches);
             if (matches.length === 0) {
-                body.innerHTML = `<div class="ml-empty">No regex matches</div>`;
+                body.innerHTML = `<div class="ml-empty">No messages found by "${escapeHtmlText(query)}"</div>`;
                 return;
             }
             body.innerHTML = "";
@@ -1060,7 +1237,7 @@ export async function loadSearchResults(query, scope = "all", accountId = "", fo
         if (result.items.length === 0) {
             state.setMessages([]);
             body.innerHTML = partialNote +
-                `<div class="ml-empty">No results for "${query}"${partial ? " in the folders that responded" : ""}</div>`;
+                `<div class="ml-empty">No messages found by "${escapeHtmlText(query)}"${partial ? " in the folders that responded" : ""}</div>`;
             return;
         }
         state.setMessages(result.items);
@@ -1074,7 +1251,15 @@ export async function loadSearchResults(query, scope = "all", accountId = "", fo
         body.innerHTML = `<div class="ml-empty">Search error: ${e.message}</div>`;
     }
 }
-export async function loadMessages(accountId, folderId, page = 1, specialUse = "", autoSelect = true) {
+/** Search-as-find: leave search and reveal a specific message in its own
+ *  folder. Loads the folder list, selects the message, and scrolls it into
+ *  view. Used when the user closes search while a result is selected — they
+ *  "stay at" that message in its real folder instead of bouncing back to the
+ *  pre-search view (Bob 2026-06-25). */
+export function revealMessage(accountId, folderId, uid, specialUse = "") {
+    loadMessages(accountId, folderId, 1, specialUse, true, uid);
+}
+export async function loadMessages(accountId, folderId, page = 1, specialUse = "", autoSelect = true, focusUid) {
     const myGen = ++loadGen;
     searchMode = false;
     unifiedMode = false;
@@ -1117,11 +1302,31 @@ export async function loadMessages(accountId, folderId, page = 1, specialUse = "
     if (cached) {
         totalMessages = cached.total;
         state.setMessages(cached.items);
-        renderMessages(body, accountId, cached.items, { background: !autoSelect });
+        // Background reload (new mail / sync): a bare renderMessages rebuilds
+        // innerHTML and resets scrollTop to 0, which then makes the follow-up
+        // network anchor think the user is at the top and reveal new mail there
+        // — yanking a scrolled-down reader to the top (Bob 2026-06-24 "the list
+        // jumps when a new message is added ... must not move while I'm
+        // viewing it"). Anchor the cache render too so the visible rows stay put.
+        const renderCached = () => renderMessages(body, accountId, cached.items, { background: !autoSelect });
+        if (!autoSelect)
+            withScrollAnchor(body, renderCached);
+        else
+            renderCached();
         const targetUuid = remembered ? pickRestoreUid(cached.items, remembered) : null;
-        if (targetUuid) {
+        if (focusUid != null) {
+            // Search-as-find: jump to the specific message the user selected.
             requestAnimationFrame(() => {
-                body.scrollTop = savedScroll;
+                if (!focusByIdentity(accountId, focusUid, { scroll: true }) && autoSelect)
+                    selectFirst(body);
+            });
+        }
+        else if (targetUuid) {
+            requestAnimationFrame(() => {
+                // Folder switch restores saved pixels; a background reload was
+                // already placed by the anchor — don't override it.
+                if (autoSelect)
+                    body.scrollTop = savedScroll;
                 restoreSelection(body, targetUuid);
             });
         }
@@ -1173,7 +1378,16 @@ export async function loadMessages(accountId, folderId, page = 1, specialUse = "
         }
         // Prefer saved position; otherwise default by autoSelect.
         const targetUuid = remembered ? pickRestoreUid(result.items, remembered) : null;
-        if (targetUuid) {
+        if (focusUid != null) {
+            // Search-as-find: select the message the user picked from results.
+            requestAnimationFrame(() => {
+                if (myGen !== loadGen)
+                    return;
+                if (!focusByIdentity(accountId, focusUid, { scroll: true }) && autoSelect)
+                    selectFirst(body);
+            });
+        }
+        else if (targetUuid) {
             requestAnimationFrame(() => {
                 if (myGen !== loadGen)
                     return;
@@ -1204,6 +1418,15 @@ async function loadMoreMessages() {
         return;
     loading = true;
     currentPage++;
+    // Diagnostics for the "scroll near the bottom does nothing" report
+    // (Bob 2026-06-22: position-dependent, "go up a tad and it works"). The
+    // suspect is a loadMore that doesn't grow scrollHeight — duplicate/empty
+    // page, end-of-list overshoot — leaving the user pinned. Capture
+    // before/after geometry + how many rows the page actually added so the
+    // log shows whether the list grew, stalled, or the page came back empty.
+    const t0 = Date.now();
+    const heightBefore = body.scrollHeight;
+    const rowsBefore = body.querySelectorAll(".ml-row").length;
     try {
         const flaggedOnly = body.classList.contains("flagged-only");
         const result = searchMode
@@ -1215,6 +1438,11 @@ async function loadMoreMessages() {
         const current = state.getMessages();
         state.setMessages([...current, ...result.items]);
         appendMessages(body, unifiedMode ? "" : currentAccountId, result.items);
+        const rowsAfter = body.querySelectorAll(".ml-row").length;
+        const heightAfter = body.scrollHeight;
+        const elapsed = Date.now() - t0;
+        const grew = heightAfter > heightBefore;
+        console.log(`  [ml-loadmore] page=${currentPage} got=${result.items?.length ?? 0} rows ${rowsBefore}->${rowsAfter} height ${heightBefore}->${heightAfter} grew=${grew} total=${totalMessages} ${elapsed}ms${grew ? "" : "  ⚠ NO GROWTH — scroll will appear stuck"}`);
     }
     catch (e) {
         console.error(`Load more error: ${e.message}`);
@@ -1225,12 +1453,30 @@ async function loadMoreMessages() {
 }
 /** Replace body contents with rendered rows */
 function renderMessages(body, accountId, items, opts = {}) {
+    // MULTI-SELECT SURVIVAL: replaceChildren below builds fresh rows with no
+    // `.selected`, so a sync/new-mail rebuild would collapse an active
+    // multi-selection down to the single focused row restoreSelection re-binds
+    // (Bob 2026-06-22: "selected multiple NMLS spam, suddenly seeing only one —
+    // a new message arrived and confused you"). The `multi-select-on` class
+    // lives on the body and survives the rebuild, so when it's set we snapshot
+    // the selected rows' stable uuids and re-apply `.selected` to whichever
+    // survive the new render. Keyed on uuid, so a folder switch (different
+    // uuids) matches nothing and correctly drops the stale highlight.
+    const preserveSel = body.classList.contains("multi-select-on")
+        ? new Set(Array.from(body.querySelectorAll(".ml-row.selected"))
+            .map(r => r.dataset.uuid || "").filter(Boolean))
+        : null;
     const fragment = document.createDocumentFragment();
     const tempDiv = document.createElement("div");
     appendMessages(tempDiv, accountId, items);
     while (tempDiv.firstChild)
         fragment.appendChild(tempDiv.firstChild);
     body.replaceChildren(fragment);
+    if (preserveSel && preserveSel.size > 0) {
+        for (const uuid of preserveSel) {
+            body.querySelector(`.ml-row[data-uuid="${CSS.escape(uuid)}"]`)?.classList.add("selected");
+        }
+    }
     // A filter (flagged-only / priority-only) that hides EVERY row makes the
     // list look broken — identical to an empty/failed load. Bob 2026-05-27
     // lost an afternoon to this: the flagged-only filter was stuck on (it
@@ -1674,6 +1920,19 @@ class MessageRow {
     }
     onFlagClick(e) {
         e.stopPropagation();
+        // Multi-select: clicking the ★ on one of several highlighted rows acts
+        // on the WHOLE selection, not just this row — same as the context-menu
+        // Flag/Unflag (Bob 2026-06-26: "clear the * only clears one not the
+        // selection"). Target state is the toggle of the clicked row, so a
+        // flagged row clears the lot and an unflagged row flags the lot.
+        const body = this.el.parentElement;
+        if (body?.classList.contains("multi-select-on") && this.el.classList.contains("selected")) {
+            const sel = selectedRows();
+            if (sel.length > 1) {
+                void bulkSetFlagged(sel, !this.el.classList.contains("flagged"));
+                return;
+            }
+        }
         // Local-first: flip the visual class + in-memory flag array NOW so the
         // star toggles under the cursor with zero latency, then mirror to the
         // server in the background. The earlier `await updateFlags(...)`
@@ -1854,38 +2113,23 @@ class MessageRow {
         const accountId = this.accountId;
         const msg = this.msg;
         const self = this;
+        // Count of selected rows — when >1, the read/flag actions apply to the
+        // whole selection and the label says so (e.g. "Unflag (5)"). The row
+        // menu's fallback (nothing selected) is the clicked row, NOT all shown.
+        const selCount = getSelectedMessages().length;
+        const countSfx = selCount > 1 ? ` (${selCount})` : "";
+        const rowTargets = () => { const s = selectedRows(); return s.length > 0 ? s : [self]; };
         const items = [
             {
-                label: isSeen ? "Mark unread" : "Mark read",
-                action: async () => {
-                    // Target state = inverse of what the menu showed,
-                    // matching what the user clicked. Visual-state-based
-                    // labels stay coherent with the auto-mark-as-read
-                    // debounce; the new flag array is computed via the
-                    // typed setter and sent to the server.
-                    const probe = { flags: [...(msg.flags || [])] };
-                    setSeen(probe, !isSeen);
-                    try {
-                        await updateFlags(accountId, msg.uid, probe.flags);
-                        msg.flags = probe.flags;
-                        state.updateMessageFlags(accountId, msg.uid, probe.flags);
-                        self.setUnreadClass(isSeen);
-                    }
-                    catch { /* ignore */ }
-                },
+                // Target state = inverse of what the menu showed, matching what
+                // the user clicked. Visual-state-based labels stay coherent with
+                // the auto-mark-as-read debounce. Applies to the whole selection.
+                label: (isSeen ? "Mark unread" : "Mark read") + countSfx,
+                action: () => bulkSetSeen(rowTargets(), !isSeen),
             },
             {
-                label: isFlagged ? "Unflag" : "Flag",
-                action: async () => {
-                    const probe = { flags: [...(msg.flags || [])] };
-                    setFlagged(probe, !isFlagged);
-                    try {
-                        await updateFlags(accountId, msg.uid, probe.flags);
-                        msg.flags = probe.flags;
-                        self.setFlaggedClass(!isFlagged);
-                    }
-                    catch { /* ignore */ }
-                },
+                label: (isFlagged ? "Unflag" : "Flag") + countSfx,
+                action: () => bulkSetFlagged(rowTargets(), !isFlagged),
             },
             { label: "", action: () => { }, separator: true },
             // Drafts get an explicit "Edit draft" entry as the primary action —