@bobfrankston/rmfmail 1.2.276 → 1.2.277

package/.commitmsg

@@ -1,26 +1,31 @@
-Preview hotkeys fired twice — Ctrl+F opened two compose windows
+TinyMCE UI language: 61 packs, auto-detected from the browser
 
-A keydown in the message preview reached app.ts by TWO routes on desktop
-WebView2: the iframe's own inline script posts every keydown to the parent as
-`previewKey` (app.ts re-dispatches it), and installPreviewControls ALSO attached
-a contentDocument listener that re-dispatched a synthetic keydown of its own.
-The srcdoc document is same-origin, so both are live. One Ctrl+F therefore ran
-openCompose("forward") twice and opened two compose popouts — the second never
-finished loading and sat blank and "(Not Responding)" until it was killed (Bob
-2026-08-23, "Compose: Fwd: FirstCare Slide Deck (Not Responding)"; the log shows
-openCompose-entry mode=forward twice in the same millisecond, two popoutCompose
-windows, and the loaded one exiting while the blank duplicate survived). Ctrl+D
-and Ctrl+P doubled the same way.
+The tinymce package ships no langs/ directory at all — the packs are a separate
+community package (tinymce-i18n), one file per language, each a plain
+tinymce.addI18n("de", {...}). build-tinymce.js now copies langs8/ next to
+tinymce.min.js, where TinyMCE's own <baseURL>/langs/<code>.js rule finds it, and
+writes langs/index.json listing what it copied. 61 packs, 1.6 MB; only the
+language in force is ever fetched.
 
-The inline forwarder is the mechanism that survives — it is the only one that
-works on Android WebView, where parent-side contentDocument listeners never
-fire. installPreviewControls keeps only what is genuinely iframe-local: zoom and
-Ctrl+A.
+TinyMCE has no detection of its own: `language` defaults to "en" and a missing
+langs/<code>.js raises a visible in-editor error notification. So "Auto" is
+ours (client/lib/tinymce-langs.ts): walk navigator.languages and take the first
+hit against the manifest — exact ("pt-BR"), then bare ("de-CH" → "de"), then
+any regional variant ("he" → "he-IL"). English short-circuits, since TinyMCE's
+built-in strings are English. Anything unmatched, and any pinned pack we no
+longer ship, stays English rather than provoking the error. Resolving against
+the manifest rather than a hardcoded list keeps the copied files the single
+source of truth, and follows a mailx-tinymce-cdn override for free because the
+manifest URL is derived from the script URL by the same rule TinyMCE uses.
 
-Also: push the Windows taskbar overlay only when the unread count CHANGES.
-Windows holds the overlay icon until the next SetOverlayIcon, so the host cannot
-free the icon it just handed over; re-sending an identical badge every few
-seconds cost GDI objects for nothing and helped drive rmfmail.exe to the
-10,000-object per-process cap (measured at GDI=9995, with 3423
-"CreateIconIndirect failed: Not enough memory resources" in one day's log).
-msger 0.1.429 fixes the leak itself by freeing the retired icon.
+Settings → Editor → Editor language: Auto (naming what it resolves to right
+now), English, then every pack, named via Intl.DisplayNames so no name table is
+maintained here. Stored as ui.editorLanguage; same synchronous-localStorage-
+then-persist shape as the editor type, so the next compose-open is correct.
+
+Scope, stated in the menu tooltip and docs/editor.md: these translate the
+editor CHROME only. Message content, the spellcheck dictionary (English) and
+Harper (English only) are untouched, and Quill/tiptap have no localized chrome.
+
+tests/tinymce-langs.test.ts pins the resolution against the real manifest.
+Needs rmf-tiny 0.1.52 for the adapter's `language` option.

package/bin/build-tinymce.js

@@ -10,6 +10,13 @@ import path from "node:path";
 const root = path.resolve(import.meta.dirname, "..");
 const src = path.join(root, "node_modules", "tinymce");
 const dst = path.join(root, "client", "lib", "tinymce");
+// UI translations. The tinymce package itself ships NO langs/ directory —
+// the packs are a separate community package, one file per language, each
+// a plain `tinymce.addI18n("de", {...})` call. TinyMCE resolves them
+// itself as `<baseURL>/langs/<code>.js`, so dropping them beside the
+// script is the whole integration (Claude Code 2026-08-23).
+const langSrc = path.join(root, "node_modules", "tinymce-i18n", "langs8");
+const langDst = path.join(dst, "langs");
 
 if (!fs.existsSync(src)) {
     console.error(`build-tinymce: source not found at ${src} — run npm install first`);
@@ -32,6 +39,26 @@ function copyTree(s, d) {
 fs.rmSync(dst, { recursive: true, force: true });
 copyTree(src, dst);
 
+// Language packs. Only the one language in force is ever fetched at
+// runtime, so shipping every pack costs disk and nothing else. The manifest
+// is what the client resolves "auto" against — the copied files ARE the list
+// of what can be offered, so nothing hardcodes a second copy of it.
+let langs = [];
+if (fs.existsSync(langSrc)) {
+    fs.mkdirSync(langDst, { recursive: true });
+    for (const name of fs.readdirSync(langSrc)) {
+        if (!name.endsWith(".js")) continue;
+        fs.copyFileSync(path.join(langSrc, name), path.join(langDst, name));
+        langs.push(name.slice(0, -3));
+    }
+    langs.sort();
+    fs.writeFileSync(path.join(langDst, "index.json"), JSON.stringify(langs, null, 2) + "\n");
+    console.log(`build-tinymce: copied ${langs.length} language packs → client/lib/tinymce/langs/`);
+} else {
+    // Never silently ship an editor whose language menu is empty.
+    console.error(`build-tinymce: WARNING no language packs at ${langSrc} — run npm install; the editor will be English-only`);
+}
+
 let count = 0, bytes = 0;
 function tally(p) {
     const st = fs.statSync(p);

package/client/app.bundle.js

@@ -7937,6 +7937,67 @@ whatever it finds.</p>
   }
 });
 
+// client/lib/tinymce-langs.js
+var tinymce_langs_exports = {};
+__export(tinymce_langs_exports, {
+  LANGUAGE_AUTO: () => LANGUAGE_AUTO,
+  LANGUAGE_ENGLISH: () => LANGUAGE_ENGLISH,
+  availableLanguages: () => availableLanguages,
+  langManifestUrl: () => langManifestUrl,
+  languageLabel: () => languageLabel,
+  resolveLanguage: () => resolveLanguage
+});
+function langManifestUrl(tinymceScriptUrl) {
+  return new URL("langs/index.json", new URL(tinymceScriptUrl, location.href)).href;
+}
+async function availableLanguages(tinymceScriptUrl) {
+  try {
+    const r = await fetch(langManifestUrl(tinymceScriptUrl));
+    if (!r.ok)
+      return [];
+    const list = await r.json();
+    return Array.isArray(list) ? list.filter((x) => typeof x === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function resolveLanguage(setting, available, preferred = navigator.languages || [navigator.language]) {
+  const byLower = new Map(available.map((code) => [code.toLowerCase(), code]));
+  if (setting && setting !== LANGUAGE_AUTO) {
+    if (setting === LANGUAGE_ENGLISH)
+      return LANGUAGE_ENGLISH;
+    return byLower.get(setting.toLowerCase()) || LANGUAGE_ENGLISH;
+  }
+  for (const tag of preferred) {
+    if (!tag)
+      continue;
+    const lower = tag.toLowerCase();
+    const base = lower.split("-")[0];
+    if (base === LANGUAGE_ENGLISH)
+      return LANGUAGE_ENGLISH;
+    const hit = byLower.get(lower) || byLower.get(base) || available.find((code) => code.toLowerCase().split("-")[0] === base);
+    if (hit)
+      return hit;
+  }
+  return LANGUAGE_ENGLISH;
+}
+function languageLabel(code) {
+  try {
+    const names = new Intl.DisplayNames(navigator.languages || void 0, { type: "language" });
+    return names.of(code) || code;
+  } catch {
+    return code;
+  }
+}
+var LANGUAGE_AUTO, LANGUAGE_ENGLISH;
+var init_tinymce_langs = __esm({
+  "client/lib/tinymce-langs.js"() {
+    "use strict";
+    LANGUAGE_AUTO = "auto";
+    LANGUAGE_ENGLISH = "en";
+  }
+});
+
 // client/components/folder-tree.js
 init_api_client();
 init_context_menu();
@@ -13475,6 +13536,53 @@ document.getElementById("opt-compose-font-size")?.addEventListener("change", (e)
   }).catch(() => {
   });
 });
+var optEditorLanguage = document.getElementById("opt-editor-language");
+if (optEditorLanguage) {
+  (async () => {
+    const scriptUrl = localStorage.getItem("mailx-tinymce-cdn") || "lib/tinymce/tinymce.min.js";
+    const { availableLanguages: availableLanguages2, resolveLanguage: resolveLanguage2, languageLabel: languageLabel2, LANGUAGE_AUTO: LANGUAGE_AUTO2, LANGUAGE_ENGLISH: LANGUAGE_ENGLISH2 } = await Promise.resolve().then(() => (init_tinymce_langs(), tinymce_langs_exports));
+    const available = await availableLanguages2(scriptUrl);
+    const autoPick = resolveLanguage2(LANGUAGE_AUTO2, available);
+    const add = (value, text) => {
+      const o = document.createElement("option");
+      o.value = value;
+      o.textContent = text;
+      optEditorLanguage.appendChild(o);
+    };
+    add(LANGUAGE_AUTO2, `Auto \u2014 ${languageLabel2(autoPick)}`);
+    add(LANGUAGE_ENGLISH2, languageLabel2(LANGUAGE_ENGLISH2));
+    for (const code of [...available].sort((a, b) => languageLabel2(a).localeCompare(languageLabel2(b)))) {
+      add(code, `${languageLabel2(code)} (${code})`);
+    }
+    if (!available.length) {
+      optEditorLanguage.disabled = true;
+      optEditorLanguage.title = "No language packs found next to tinymce.min.js \u2014 English only";
+    }
+    let current = LANGUAGE_AUTO2;
+    try {
+      current = localStorage.getItem("mailx-editor-language") || LANGUAGE_AUTO2;
+    } catch {
+    }
+    try {
+      const settings = await getSettings();
+      if (typeof settings?.ui?.editorLanguage === "string" && settings.ui.editorLanguage) current = settings.ui.editorLanguage;
+    } catch {
+    }
+    optEditorLanguage.value = current;
+    if (!optEditorLanguage.value) optEditorLanguage.value = LANGUAGE_AUTO2;
+  })().catch((e) => console.error("[settings] editor-language menu failed:", e?.message || e));
+  optEditorLanguage.addEventListener("change", () => {
+    const value = optEditorLanguage.value;
+    try {
+      localStorage.setItem("mailx-editor-language", value);
+    } catch {
+    }
+    getSettings().then((settings) => {
+      settings.ui = { ...settings.ui, editorLanguage: value };
+      saveSettings(settings);
+    }).catch((e) => console.error("[settings] editor language save failed:", e?.message || e));
+  });
+}
 function saveEditorSetting(editor) {
   try {
     localStorage.setItem("mailx-editor-type", editor);