@bobfrankston/rmfmail 1.2.112 → 1.2.114

package/client/app.ts

@@ -634,6 +634,63 @@ function scheduleSyncedStamp(): void {
     }, SYNC_SETTLE_MS);
 }
 
+// C121: connect-phase ticker. The daemon emits connectProgress per IMAP
+// connection attempt (socket → handshake → done/failed). While any attempt
+// has been in flight longer than CONNECT_SHOW_AFTER_MS, the status bar shows
+// "Connecting to <host> (<phase> <purpose>, 3.2s)" with a live elapsed
+// counter — so a stuck DNS/TLS/greeting/LOGIN is distinguishable at a glance
+// instead of an opaque frozen "Syncing…". Healthy sub-second connects never
+// surface (the delay gate kills the flicker).
+const activeConnects = new Map<string, { host: string; purpose: string; phase: string; startedAt: number }>();
+const CONNECT_SHOW_AFTER_MS = 1500;
+let connectTickTimer: ReturnType<typeof setInterval> | null = null;
+function handleConnectProgress(event: any): void {
+    const key = `${event.accountId}|${event.purpose}`;
+    if (event.phase === "done" || event.phase === "failed") {
+        activeConnects.delete(key);
+        if (activeConnects.size === 0 && connectTickTimer) {
+            clearInterval(connectTickTimer);
+            connectTickTimer = null;
+            // Leave the bar to the normal sync handlers; stamp settle so a
+            // lingering "Connecting…" flips to Synced when things go quiet.
+            scheduleSyncedStamp();
+        }
+        return;
+    }
+    const existing = activeConnects.get(key);
+    if (existing) {
+        existing.phase = event.phase;
+    } else {
+        activeConnects.set(key, {
+            host: event.host || event.accountId,
+            purpose: event.purpose || "",
+            phase: event.phase,
+            startedAt: Date.now() - (event.elapsedMs || 0),
+        });
+    }
+    if (!connectTickTimer) connectTickTimer = setInterval(renderConnectTick, 100);
+}
+function renderConnectTick(): void {
+    const el = document.getElementById("status-sync");
+    if (!el || activeConnects.size === 0) return;
+    // Staleness guard: if a done/failed event got lost (daemon restart,
+    // dropped IPC line) an entry would tick forever — expire at 10 min,
+    // well past any transport timeout.
+    const now = Date.now();
+    for (const [k, c] of activeConnects) {
+        if (now - c.startedAt > 600_000) activeConnects.delete(k);
+    }
+    // Show the LONGEST-waiting attempt — that's the one worth staring at.
+    let worst: { host: string; purpose: string; phase: string; startedAt: number } | null = null;
+    for (const c of activeConnects.values()) {
+        if (!worst || c.startedAt < worst.startedAt) worst = c;
+    }
+    if (!worst) return;
+    const elapsed = Date.now() - worst.startedAt;
+    if (elapsed < CONNECT_SHOW_AFTER_MS) return;
+    el.textContent = `Connecting to ${worst.host} (${worst.phase}${worst.purpose ? " " + worst.purpose : ""}, ${(elapsed / 1000).toFixed(1)}s)`;
+}
+
 // ── Auto two-line when message list is narrow ──
 const messageList = document.getElementById("message-list");
 if (messageList) {
@@ -3011,6 +3068,9 @@ onWsEvent((event) => {
             if (startupStatus) startupStatus.textContent = "Loading accounts...";
             // Don't refresh folder tree on connect — it's already loaded by initFolderTree
             break;
+        case "connectProgress":
+            handleConnectProgress(event);
+            break;
         case "syncProgress": {
             // Aggregate folders phases ("folders:<path>" when starting a folder,
             // "folders-done" between folders) print as a proportion so the user

package/client/compose/compose.bundle.js

@@ -1650,8 +1650,11 @@ __export(spellcheck_core_exports, {
   USER_DICT_KEY: () => USER_DICT_KEY,
   addToUserDict: () => addToUserDict,
   buildSuggestionList: () => buildSuggestionList,
+  findSkipRanges: () => findSkipRanges,
   getSpell: () => getSpell,
   getWordAtPoint: () => getWordAtPoint,
+  inSkipRange: () => inSkipRange,
+  isWordCorrect: () => isWordCorrect,
   showSuggestionsMenu: () => showSuggestionsMenu
 });
 async function getSpell() {
@@ -1714,6 +1717,34 @@ function addToUserDict(word, sp) {
   sp.add(word);
   addUserDictWord(word).catch((e) => console.error("[spell] addUserDictWord:", e));
 }
+function isWordCorrect(word, sp) {
+  let w = word.replace(/['’]+$/u, "");
+  w = w.replace(/['’][sS]$/u, "");
+  if (w.length < MIN_WORD_LEN)
+    return true;
+  return sp.correct(w);
+}
+function findSkipRanges(text) {
+  if (!/[.@:]/.test(text))
+    return [];
+  const ranges = [];
+  SKIP_SPAN_RE.lastIndex = 0;
+  let m;
+  while (m = SKIP_SPAN_RE.exec(text)) {
+    let end = m.index + m[0].length;
+    while (end > m.index && /[.,;:!?]/.test(text[end - 1]))
+      end--;
+    if (end > m.index)
+      ranges.push([m.index, end]);
+  }
+  return ranges;
+}
+function inSkipRange(ranges, start, end) {
+  for (const [s, e] of ranges)
+    if (start < e && end > s)
+      return true;
+  return false;
+}
 function buildSuggestionList(word, sp) {
   const transposed = [];
   for (let i = 0; i < word.length - 1; i++) {
@@ -1840,7 +1871,7 @@ function getWordAtPoint(root, x, y) {
   const text = node.data;
   if (offset > text.length)
     offset = text.length;
-  const isWordChar = (c) => /[\p{L}'’\-]/u.test(c);
+  const isWordChar = (c) => /[\p{L}'’]/u.test(c);
   let start = offset;
   while (start > 0 && isWordChar(text[start - 1]))
     start--;
@@ -1852,9 +1883,11 @@ function getWordAtPoint(root, x, y) {
   const word = text.slice(start, end);
   if (!/^[\p{L}]/u.test(word))
     return null;
+  if (inSkipRange(findSkipRanges(text), start, end))
+    return null;
   return { word, node, start, end };
 }
-var import_nspell, USER_DICT_KEY, MARKER_ATTR, MIN_WORD_LEN, SKIP_TAGS, spellPromise;
+var import_nspell, USER_DICT_KEY, MARKER_ATTR, MIN_WORD_LEN, SKIP_TAGS, spellPromise, URL_BODY, SKIP_SPAN_RE;
 var init_spellcheck_core = __esm({
   "client/compose/spellcheck-core.js"() {
     "use strict";
@@ -1865,6 +1898,15 @@ var init_spellcheck_core = __esm({
     MIN_WORD_LEN = 3;
     SKIP_TAGS = /* @__PURE__ */ new Set(["BLOCKQUOTE", "CODE", "PRE", "A", "SCRIPT", "STYLE", "KBD", "SAMP", "VAR"]);
     spellPromise = null;
+    URL_BODY = String.raw`[\w.\-~:/?#@$&+=%!*]`;
+    SKIP_SPAN_RE = new RegExp(
+      String.raw`(?:(?:[A-Za-z][A-Za-z\d.+-]{1,14}://|mailto:|tel:)${URL_BODY}+` + // scheme'd URL
+      String.raw`|www\.${URL_BODY}+` + // www.…
+      String.raw`|[\w.+\-]+@[\w\-]+(?:\.[\w\-]+)+` + // email
+      String.raw`|[\w\-]+(?:\.[A-Za-z][\w\-]*)+(?:/${URL_BODY}*)?)`,
+      // bare domain [+path]
+      "g"
+    );
   }
 });
 
@@ -2544,18 +2586,21 @@ function wireSpellcheck(editor2) {
     const sx = body.scrollLeft;
     const sy = body.scrollTop;
     const frag = doc.createDocumentFragment();
-    const wordRe = /[\p{L}][\p{L}'’-]*/gu;
+    const wordRe = /[\p{L}][\p{L}'’]*/gu;
     for (let n = walker.nextNode(); n; n = walker.nextNode()) {
       const text = n.data;
       if (!text || text.length < MIN_WORD_LEN)
         continue;
+      const skip = findSkipRanges(text);
       wordRe.lastIndex = 0;
       let m;
       while (m = wordRe.exec(text)) {
         const w = m[0];
         if (w.length < MIN_WORD_LEN)
           continue;
-        if (sp.correct(w))
+        if (inSkipRange(skip, m.index, m.index + w.length))
+          continue;
+        if (isWordCorrect(w, sp))
           continue;
         const r = doc.createRange();
         r.setStart(n, m.index);
@@ -2626,7 +2671,7 @@ function wireSpellcheck(editor2) {
     const hit = getWordAtPoint(body, e.clientX, e.clientY);
     if (!hit)
       return;
-    if (sp.correct(hit.word))
+    if (isWordCorrect(hit.word, sp))
       return;
     e.preventDefault();
     e.stopPropagation();