@bobfrankston/rmfmail 1.0.680 → 1.0.686

package/client/components/message-list.ts

@@ -70,6 +70,73 @@ function cacheKey(mode: "folder" | "search", a?: string, f?: number, flagged?: b
     return `search:${q}`;
 }
 
+/** Per-view position memory — remembered selected UID + scroll position
+ *  per folder / unified inbox / saved search. Keyed by the same string
+ *  `cacheKey()` uses so each view has its own slot.
+ *
+ *  Restore rule (Bob 2026-05-12): on return to a view, focus the saved
+ *  uid if it still exists; otherwise focus the first row whose uid is
+ *  less than the saved uid (next-older entry in a date-desc list — uid
+ *  is roughly monotonic with arrival time on most IMAP servers and on
+ *  Gmail's hash-derived ids). If no smaller uid exists either, fall
+ *  back to whatever row sits at the same numeric index. Survives a
+ *  session reload via sessionStorage. */
+interface ViewPosition { uid: number; scroll: number; }
+const positionMemory = new Map<string, ViewPosition>();
+const POSITION_STORAGE_KEY = "mailx-list-positions";
+try {
+    const raw = sessionStorage.getItem(POSITION_STORAGE_KEY);
+    if (raw) {
+        const parsed = JSON.parse(raw) as Record<string, ViewPosition>;
+        for (const [k, v] of Object.entries(parsed || {})) {
+            if (typeof v?.uid === "number") positionMemory.set(k, v);
+        }
+    }
+} catch { /* */ }
+function persistPositions(): void {
+    try {
+        const obj: Record<string, ViewPosition> = {};
+        for (const [k, v] of positionMemory) obj[k] = v;
+        sessionStorage.setItem(POSITION_STORAGE_KEY, JSON.stringify(obj));
+    } catch { /* */ }
+}
+function currentViewKey(): string | null {
+    if (searchMode) return cacheKey("search", undefined, undefined, undefined, currentSearchQuery);
+    if (unifiedMode) return CACHE_KEY_UNIFIED;
+    if (!currentAccountId || currentFolderId == null) return null;
+    const flaggedOnly = document.getElementById("ml-body")?.classList.contains("flagged-only") || false;
+    return cacheKey("folder", currentAccountId, currentFolderId, flaggedOnly);
+}
+function rememberPosition(): void {
+    const key = currentViewKey();
+    if (!key) return;
+    const body = document.getElementById("ml-body");
+    if (!body) return;
+    const sel = body.querySelector(".ml-row.selected") as HTMLElement | null;
+    if (!sel) return;
+    const uid = Number(sel.dataset.uid);
+    if (!Number.isFinite(uid)) return;
+    positionMemory.set(key, { uid, scroll: body.scrollTop });
+    persistPositions();
+}
+/** Choose the row to focus when re-entering a view with saved position.
+ *  Returns the uid to focus, or null to fall back to selectFirst. */
+function pickRestoreUid(items: any[], saved: number): number | null {
+    if (!items.length) return null;
+    if (items.some(m => m.uid === saved)) return saved;
+    // Next-older entry: largest remaining uid that is < saved. Stable
+    // even if list is unsorted by uid (loops through all rows).
+    let best = -1;
+    for (const m of items) {
+        if (typeof m.uid !== "number") continue;
+        if (m.uid < saved && m.uid > best) best = m.uid;
+    }
+    if (best >= 0) return best;
+    // No older entry — saved was the bottom of the list. Snap to the
+    // first row that sorts "after" via date-desc tie-break (top of list).
+    return typeof items[0]?.uid === "number" ? items[0].uid : null;
+}
+
 /** Quick equality check — same UID set, same flag pattern, same total.
  *  Skip re-render when this returns true to avoid DOM churn / scroll-
  *  jump on a refresh that didn't change anything. */
@@ -148,6 +215,8 @@ function focusRow(row: MessageRow): void {
     viewerShow(row.accountId, row.msg.uid, row.msg.folderId, undefined, false, row.msg);
     onMessageSelect(row.accountId, row.msg.uid, row.msg.folderId);
     document.dispatchEvent(new CustomEvent("mailx-focus-changed", { detail: row.msg }));
+    // Persist position so returning to this view re-focuses this row.
+    rememberPosition();
 }
 
 /** Read the currently-focused message envelope. Used by app-level
@@ -552,29 +621,26 @@ export async function loadUnifiedInbox(autoSelect = true): Promise<void> {
     const fromHeader = document.querySelector(".ml-col-from");
     if (fromHeader) fromHeader.textContent = "From";
 
-    const savedScroll = !autoSelect ? body.scrollTop : 0;
-    // Read selection LIVE — never store at function start. If we cache
-    // it then await an IPC, the user's mid-flight click is overwritten
-    // when the post-IPC re-render restores the stale value (Bob 2026-05-09:
-    // "I just selected the 10:03 message and it showed and then bounced
-    // back to the 15:49"). Live read picks up whatever the user clicked
-    // most recently, even during the await.
-    const currentSelectedUid = (): string | null =>
-        !autoSelect ? body.querySelector(".ml-row.selected")?.getAttribute("data-uid") || null : null;
+    // Saved per-view position wins over current DOM selection — same
+    // rationale as loadMessages.
+    const remembered = positionMemory.get(CACHE_KEY_UNIFIED);
+    const savedScroll = remembered?.scroll ?? (!autoSelect ? body.scrollTop : 0);
 
     // Instant first paint from cache. The IPC fires in background below
     // and only triggers a re-render if the result diverges from the
-    // cached snapshot. The cache lives for the session; no TTL — the
-    // re-render covers staleness. C126 part 1 (the part that doesn't
-    // need cross-restart persistence; cold-start pre-render is part 2).
+    // cached snapshot.
     const cached = listCache.get(CACHE_KEY_UNIFIED);
     if (cached) {
-        const preCacheUid = currentSelectedUid();
         totalMessages = cached.total;
         state.setMessages(cached.items);
         renderMessages(body, "", cached.items);
-        if (autoSelect) selectFirst(body);
-        else { body.scrollTop = savedScroll; restoreSelection(body, preCacheUid); }
+        const targetUid = remembered ? pickRestoreUid(cached.items, remembered.uid) : null;
+        if (targetUid != null) {
+            body.scrollTop = savedScroll;
+            restoreSelection(body, String(targetUid));
+        } else if (autoSelect) {
+            selectFirst(body);
+        }
     } else if (autoSelect) {
         body.innerHTML = `<div class="ml-empty">Loading...</div>`;
     }
@@ -596,17 +662,15 @@ export async function loadUnifiedInbox(autoSelect = true): Promise<void> {
             return;
         }
 
-        // Capture selection immediately before renderMessages clears it,
-        // not earlier — preserves any click made during the IPC await.
-        const preRenderUid = currentSelectedUid();
         state.setMessages(result.items);
         renderMessages(body, "", result.items);
 
-        if (autoSelect) {
-            selectFirst(body);
-        } else {
+        const targetUid = remembered ? pickRestoreUid(result.items, remembered.uid) : null;
+        if (targetUid != null) {
             body.scrollTop = savedScroll;
-            restoreSelection(body, preRenderUid);
+            restoreSelection(body, String(targetUid));
+        } else if (autoSelect) {
+            selectFirst(body);
         }
     } catch (e: any) {
         if (e.name === "AbortError") return;
@@ -735,26 +799,27 @@ export async function loadMessages(accountId: string, folderId: number, page = 1
     const fromHeader = document.querySelector(".ml-col-from");
     if (fromHeader) fromHeader.textContent = showToInsteadOfFrom ? "To" : "From";
 
-    const savedScroll = !autoSelect ? body.scrollTop : 0;
-    // Live read — see loadUnifiedInbox above for why this can't be
-    // captured at function start.
-    const currentSelectedUid = (): string | null =>
-        !autoSelect ? body.querySelector(".ml-row.selected")?.getAttribute("data-uid") || null : null;
-
     const flaggedOnly = document.getElementById("ml-body")?.classList.contains("flagged-only") || false;
     const cKey = cacheKey("folder", accountId, folderId, flaggedOnly);
+    // Saved per-view position takes priority over the DOM's current
+    // selection — when switching from folder A to B and back, the DOM
+    // shows B's selected row but we want to land on whatever was last
+    // focused in A.
+    const remembered = positionMemory.get(cKey);
+    const savedScroll = remembered?.scroll ?? (!autoSelect ? body.scrollTop : 0);
     const cached = listCache.get(cKey);
     if (cached) {
-        const preCacheUid = currentSelectedUid();
         totalMessages = cached.total;
         state.setMessages(cached.items);
         renderMessages(body, accountId, cached.items);
-        if (autoSelect) selectFirst(body);
-        else {
+        const targetUid = remembered ? pickRestoreUid(cached.items, remembered.uid) : null;
+        if (targetUid != null) {
             requestAnimationFrame(() => {
                 body.scrollTop = savedScroll;
-                restoreSelection(body, preCacheUid);
+                restoreSelection(body, String(targetUid));
             });
+        } else if (autoSelect) {
+            selectFirst(body);
         }
     } else if (autoSelect) {
         body.innerHTML = `<div class="ml-empty">Loading...</div>`;
@@ -778,19 +843,19 @@ export async function loadMessages(accountId: string, folderId: number, page = 1
             return;
         }
 
-        // Capture selection right before renderMessages clears it.
-        const preRenderUid = currentSelectedUid();
         state.setMessages(result.items);
         renderMessages(body, accountId, result.items);
 
-        if (autoSelect) {
-            selectFirst(body);
-        } else {
+        // Prefer saved position; otherwise default by autoSelect.
+        const targetUid = remembered ? pickRestoreUid(result.items, remembered.uid) : null;
+        if (targetUid != null) {
             requestAnimationFrame(() => {
                 if (myGen !== loadGen) return;
                 body.scrollTop = savedScroll;
-                restoreSelection(body, preRenderUid);
+                restoreSelection(body, String(targetUid));
             });
+        } else if (autoSelect) {
+            selectFirst(body);
         }
     } catch (e: any) {
         if (e.name === "AbortError") return;

package/client/compose/compose.bundle.js

@@ -85,6 +85,7 @@ __export(api_client_exports, {
   logClientEvent: () => logClientEvent,
   markAsSpamMessages: () => markAsSpamMessages,
   markFolderRead: () => markFolderRead,
+  moveFolderToTrash: () => moveFolderToTrash,
   moveMessage: () => moveMessage,
   moveMessages: () => moveMessages,
   onEvent: () => onEvent,
@@ -357,6 +358,9 @@ function renameFolder(accountId, folderId, newName) {
 function deleteFolder(accountId, folderId) {
   return ipc().deleteFolder?.(accountId, folderId);
 }
+function moveFolderToTrash(accountId, folderId) {
+  return ipc().moveFolderToTrash?.(accountId, folderId);
+}
 function emptyFolder(accountId, folderId) {
   return ipc().emptyFolder?.(accountId, folderId);
 }
@@ -617,7 +621,23 @@ async function createTinyMceEditor(container2, opts = {}) {
           return;
         args.content = args.content.replace(/(^|[\s(\[])((?:https?|ftp):\/\/[^\s<>"']+[^\s<>"'.,;:!?)\]])/gi, (_m, lead, url) => `${lead}<a href="${url}">${url}</a>`);
       },
-      content_style: "body { font-family: system-ui, sans-serif; font-size: 14px; }",
+      // Body font + quoted-reply styling. Without explicit rules for
+      // <blockquote> and div.reply the editor iframe renders the
+      // quoted block with no visual distinction from the user's own
+      // text — pasted reply quotes vanish into a wall of unformatted
+      // paragraphs (Bob 2026-05-12: "the body losing all formatting").
+      // The styles below match Thunderbird/Outlook conventions: a
+      // muted left-bar + indent on blockquotes, slight color shift on
+      // the "On … wrote:" attribution, untouched typography for
+      // everything else so genuine HTML formatting (bold / italic /
+      // tables / inline color) still comes through verbatim.
+      content_style: [
+        "body { font-family: system-ui, sans-serif; font-size: 14px; }",
+        "blockquote { border-left: 3px solid #c0c8d0; margin: 0 0 0 4px; padding: 2px 0 2px 10px; color: #555; }",
+        "div.reply { margin-top: 0.5em; }",
+        "div.reply > p:first-child { color: #666; font-size: 0.95em; margin: 0 0 4px 0; }",
+        "pre, code { font-family: ui-monospace, Consolas, Menlo, monospace; }"
+      ].join(" "),
       init_instance_callback: (ed) => resolve(ed),
       setup: (ed) => {
         if (opts.initialHtml)
@@ -714,10 +734,14 @@ async function createTinyMceEditor(container2, opts = {}) {
     focus() {
       editor2.focus();
     },
-    setCursor(_pos) {
+    setCursor(pos) {
       try {
         editor2.selection.select(editor2.getBody(), true);
-        editor2.selection.collapse(false);
+        editor2.selection.collapse(
+          pos === 0
+          /* true = start */
+        );
+        editor2.focus();
       } catch {
       }
     },
@@ -1766,7 +1790,7 @@ function decorate(editor2, sp) {
       p = p.parentNode;
     }
   }
-  const bookmark = editor2.selection?.getBookmark?.(2);
+  const savedAbs = caretAbsOffsetFromBody(body);
   try {
     editor2.undoManager?.ignore?.(() => {
       const old = body.querySelectorAll(`span[${MARKER_ATTR}]`);
@@ -1791,6 +1815,16 @@ function decorate(editor2, sp) {
           return NodeFilter.FILTER_ACCEPT;
         }
       });
+      let caretNode = null;
+      let caretOffset = 0;
+      const liveSel = doc.getSelection();
+      if (liveSel && liveSel.rangeCount > 0) {
+        const f = liveSel.focusNode;
+        if (f && f.nodeType === Node.TEXT_NODE) {
+          caretNode = f;
+          caretOffset = liveSel.focusOffset;
+        }
+      }
       const hits = [];
       let n = walker.nextNode();
       const WORD_RE = /[\p{L}][\p{L}'’\-]*/gu;
@@ -1803,6 +1837,9 @@ function decorate(editor2, sp) {
           const word = m[0];
           if (word.length < MIN_WORD_LEN)
             continue;
+          if (caretNode === tn && caretOffset >= m.index && caretOffset <= m.index + word.length) {
+            continue;
+          }
           if (sp.correct(word))
             continue;
           hits.push({ node: tn, start: m.index, end: m.index + word.length });
@@ -1823,11 +1860,72 @@ function decorate(editor2, sp) {
       }
     });
   } finally {
-    if (bookmark)
-      try {
-        editor2.selection?.moveToBookmark?.(bookmark);
-      } catch {
-      }
+    if (savedAbs != null)
+      restoreCaretFromAbsOffset(body, savedAbs);
+  }
+}
+function caretAbsOffsetFromBody(body) {
+  const doc = body.ownerDocument;
+  const sel = doc.getSelection();
+  if (!sel || sel.rangeCount === 0)
+    return null;
+  const focusNode = sel.focusNode;
+  const focusOffset = sel.focusOffset;
+  if (!focusNode)
+    return null;
+  if (focusNode.nodeType !== Node.TEXT_NODE) {
+    let abs2 = 0;
+    const walker2 = doc.createTreeWalker(body, NodeFilter.SHOW_TEXT);
+    let n2 = walker2.nextNode();
+    while (n2) {
+      if (focusNode.contains(n2))
+        break;
+      const cmp = focusNode.compareDocumentPosition(n2);
+      if (cmp & Node.DOCUMENT_POSITION_PRECEDING)
+        abs2 += n2.data.length;
+      n2 = walker2.nextNode();
+    }
+    return abs2;
+  }
+  let abs = 0;
+  const walker = doc.createTreeWalker(body, NodeFilter.SHOW_TEXT);
+  let n = walker.nextNode();
+  while (n) {
+    if (n === focusNode)
+      return abs + focusOffset;
+    abs += n.data.length;
+    n = walker.nextNode();
+  }
+  return null;
+}
+function restoreCaretFromAbsOffset(body, abs) {
+  const doc = body.ownerDocument;
+  const sel = doc.getSelection();
+  if (!sel)
+    return;
+  const walker = doc.createTreeWalker(body, NodeFilter.SHOW_TEXT);
+  let acc = 0;
+  let n = walker.nextNode();
+  while (n) {
+    const len = n.data.length;
+    if (acc + len >= abs) {
+      const range = doc.createRange();
+      range.setStart(n, Math.max(0, abs - acc));
+      range.collapse(true);
+      sel.removeAllRanges();
+      sel.addRange(range);
+      return;
+    }
+    acc += len;
+    n = walker.nextNode();
+  }
+  const last = walker.previousNode();
+  if (last) {
+    const range = doc.createRange();
+    range.setStart(last, last.data.length);
+    range.collapse(true);
+    sel.removeAllRanges();
+    sel.addRange(range);
   }
 }
 function installDecorationStyle(editor2) {
@@ -1920,18 +2018,37 @@ function showSuggestionsMenu(parentDoc, x, y, items) {
     menu.style.left = `${Math.max(8, window.innerWidth - r.width - 8)}px`;
   if (r.bottom > window.innerHeight)
     menu.style.top = `${Math.max(8, window.innerHeight - r.height - 8)}px`;
+  const docs = [parentDoc];
+  try {
+    const composeWin = parentDoc.defaultView;
+    if (composeWin?.frameElement && composeWin.parent?.document && composeWin.parent.document !== parentDoc) {
+      docs.push(composeWin.parent.document);
+    }
+  } catch {
+  }
+  try {
+    const editorIframe = parentDoc.querySelector("iframe.tox-edit-area__iframe") || parentDoc.querySelector("iframe");
+    const editorDoc = editorIframe?.contentDocument;
+    if (editorDoc && editorDoc !== parentDoc)
+      docs.push(editorDoc);
+  } catch {
+  }
   const dismiss2 = (e) => {
     if (e.type === "keydown" && e.key !== "Escape")
       return;
     if (e.type === "mousedown" && menu.contains(e.target))
       return;
     menu.remove();
-    parentDoc.removeEventListener("mousedown", dismiss2, true);
-    parentDoc.removeEventListener("keydown", dismiss2, true);
+    for (const d of docs) {
+      d.removeEventListener("mousedown", dismiss2, true);
+      d.removeEventListener("keydown", dismiss2, true);
+    }
   };
   setTimeout(() => {
-    parentDoc.addEventListener("mousedown", dismiss2, true);
-    parentDoc.addEventListener("keydown", dismiss2, true);
+    for (const d of docs) {
+      d.addEventListener("mousedown", dismiss2, true);
+      d.addEventListener("keydown", dismiss2, true);
+    }
   }, 0);
 }
 function replaceMarker(editor2, marker, replacement) {
@@ -1993,7 +2110,21 @@ function wireSpellcheck(editor2) {
       return;
     e.preventDefault();
     e.stopPropagation();
-    const sugs = sp.suggest(word).slice(0, 7);
+    const transposed = [];
+    for (let i = 0; i < word.length - 1; i++) {
+      const swapped = word.slice(0, i) + word[i + 1] + word[i] + word.slice(i + 2);
+      if (swapped !== word && sp.correct(swapped) && !transposed.includes(swapped)) {
+        transposed.push(swapped);
+      }
+    }
+    const nspellSugs = sp.suggest(word);
+    const sugs = [];
+    for (const s of [...transposed, ...nspellSugs]) {
+      if (!sugs.includes(s))
+        sugs.push(s);
+      if (sugs.length >= 7)
+        break;
+    }
     const iframeEl = editor2.iframeElement;
     const iframeRect = iframeEl ? iframeEl.getBoundingClientRect() : { left: 0, top: 0 };
     const items = [];
@@ -2040,7 +2171,7 @@ var init_spellcheck = __esm({
     import_nspell = __toESM(require_lib(), 1);
     USER_DICT_KEY = "mailx-user-dict";
     MARKER_ATTR = "data-mailx-spellerror";
-    DECORATE_DEBOUNCE_MS = 500;
+    DECORATE_DEBOUNCE_MS = 1200;
     MIN_WORD_LEN = 3;
     SKIP_TAGS = /* @__PURE__ */ new Set(["BLOCKQUOTE", "CODE", "PRE", "A", "SCRIPT", "STYLE", "KBD", "SAMP", "VAR"]);
     spellPromise = null;
@@ -2922,6 +3053,8 @@ function showContextMenu(x, y, items) {
     const el = document.createElement("div");
     el.className = "ctx-item" + (item.disabled ? " ctx-disabled" : "");
     el.textContent = item.label;
+    if (item.tooltip)
+      el.title = item.tooltip;
     if (!item.disabled) {
       el.addEventListener("click", () => {
         closeContextMenu();
@@ -2962,6 +3095,15 @@ document.addEventListener("contextmenu", () => {
 
 // client/compose/compose.ts
 logClientEvent("compose-module-loaded", { href: location.href, version: window.mailxVersion || "?" });
+var _composeT0 = performance.now();
+function _ctick(label) {
+  const ms = (performance.now() - _composeT0).toFixed(0).padStart(5);
+  try {
+    logClientEvent(`compose-tick ${ms}ms ${label}`);
+  } catch {
+  }
+}
+_ctick("module body executing");
 function closeCompose() {
   logClientEvent("compose-close");
   try {
@@ -3000,8 +3142,8 @@ async function loadEditorAssets(type) {
       loadScript(`${cdn}/@tiptap/extension-placeholder@2/dist/index.umd.js`)
     ]);
   } else {
-    loadCSS("https://cdn.jsdelivr.net/npm/quill@2/dist/quill.snow.css");
-    await loadScript("https://cdn.jsdelivr.net/npm/quill@2/dist/quill.js");
+    loadCSS("../lib/quill/quill.snow.css");
+    await loadScript("../lib/quill/quill.js");
   }
 }
 var editorType = "quill";
@@ -3083,7 +3225,9 @@ async function tryEditor(type) {
   }
 }
 var activeEditorType = editorType;
+_ctick(`editor load start (${editorType})`);
 editor = await tryEditor(editorType);
+_ctick(`editor load end (${editorType}, ok=${!!editor})`);
 if (!editor) {
   const fallbackType = editorType === "quill" ? "tiptap" : "quill";
   logClientEvent("compose-editor-fallback-other", { from: editorType, to: fallbackType });
@@ -3668,13 +3812,41 @@ function scheduleDraftSave() {
     });
   }, DRAFT_INPUT_DEBOUNCE_MS);
 }
+var _parentInitReady = !!sessionStorage.getItem("composeInit");
+var _parentInitListeners = [];
+window.addEventListener("message", (e) => {
+  if (e.data?.type !== "compose-init-ready") return;
+  _parentInitReady = true;
+  for (const fn of _parentInitListeners.splice(0)) fn();
+});
+function waitForParentInit(maxMs) {
+  if (_parentInitReady) return Promise.resolve();
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      _parentInitReady = true;
+      resolve();
+    }, maxMs);
+    _parentInitListeners.push(() => {
+      clearTimeout(timer);
+      resolve();
+    });
+  });
+}
 (async () => {
+  _ctick("init IIFE start");
+  if (!sessionStorage.getItem("composeInit")) {
+    _ctick("waiting for parent init");
+    await waitForParentInit(1500);
+    _ctick("parent init received");
+  }
   const stored = sessionStorage.getItem("composeInit");
   if (stored) {
     sessionStorage.removeItem("composeInit");
     const init = JSON.parse(stored);
+    _ctick(`init parsed (mode=${init.mode}, bodyHtml=${init.bodyHtml?.length || 0} bytes)`);
     if (init.accounts && init.accounts.length > 0) {
       applyInit(init);
+      _ctick("applyInit done \u2014 compose visible");
       getAccounts().then((fresh) => {
         if (Array.isArray(fresh) && fresh.length > 0) {
           init.accounts = fresh;