Localize Tauri menus

Author: oldj

package.json

@@ -8,6 +8,8 @@
   "scripts": {
     "pretest": "rimraf ./test/tmp",
     "test": "vitest --config ./vitest.config.mts --watch=false",
+    "test:rust": "cargo test --manifest-path src-tauri/Cargo.toml",
+    "test:all": "npm run typecheck && npm test && npm run test:rust",
     "typecheck": "tsc --noEmit",
     "lint": "eslint \"src/**/*.{ts,tsx}\"",
     "lint:fix": "eslint \"src/**/*.{ts,tsx}\" --fix",

src-tauri/src/app_menu.rs

@@ -7,11 +7,11 @@
 //! events so the existing `useOnBroadcast` subscribers in the renderer
 //! fire unchanged.
 
-use tauri::menu::{
-    Menu, MenuItemBuilder, PredefinedMenuItem, Submenu, SubmenuBuilder,
-};
+use tauri::menu::{Menu, MenuItemBuilder, PredefinedMenuItem, Submenu, SubmenuBuilder};
 use tauri::{AppHandle, Runtime};
 
+use crate::i18n::{menu_labels, MenuLabels};
+
 // ---- menu item ids ---------------------------------------------------------
 // Every custom item gets a stable id routed through the global
 // `on_menu_event` handler in `lib.rs`.
@@ -30,24 +30,37 @@ pub const HOMEPAGE_URL: &str = "https://switchhosts.vercel.app/home/";
 /// Build and install the application menu. Called once from
 /// `lib.rs::run`'s setup hook.
 pub fn install<R: Runtime>(app: &AppHandle<R>) -> Result<(), tauri::Error> {
+    refresh(app)
+}
+
+/// Rebuild and reinstall the application menu after language changes.
+pub fn refresh<R: Runtime>(app: &AppHandle<R>) -> Result<(), tauri::Error> {
     let menu = build_menu(app)?;
     app.set_menu(menu)?;
     Ok(())
 }
 
 fn build_menu<R: Runtime>(app: &AppHandle<R>) -> Result<Menu<R>, tauri::Error> {
-    let file_menu = build_file_menu(app)?;
-    let edit_menu = build_edit_menu(app)?;
-    let view_menu = build_view_menu(app)?;
-    let window_menu = build_window_menu(app)?;
-    let help_menu = build_help_menu(app)?;
+    let labels = menu_labels(app);
+    let file_menu = build_file_menu(app, &labels)?;
+    let edit_menu = build_edit_menu(app, &labels)?;
+    let view_menu = build_view_menu(app, &labels)?;
+    let window_menu = build_window_menu(app, &labels)?;
+    let help_menu = build_help_menu(app, &labels)?;
 
     #[cfg(target_os = "macos")]
     {
-        let app_menu = build_macos_app_menu(app)?;
+        let app_menu = build_macos_app_menu(app, &labels)?;
         Menu::with_items(
             app,
-            &[&app_menu, &file_menu, &edit_menu, &view_menu, &window_menu, &help_menu],
+            &[
+                &app_menu,
+                &file_menu,
+                &edit_menu,
+                &view_menu,
+                &window_menu,
+                &help_menu,
+            ],
         )
     }
     #[cfg(not(target_os = "macos"))]
@@ -62,80 +75,96 @@ fn build_menu<R: Runtime>(app: &AppHandle<R>) -> Result<Menu<R>, tauri::Error> {
 // ---- macOS app submenu (About, Hide, Quit) --------------------------------
 
 #[cfg(target_os = "macos")]
-fn build_macos_app_menu<R: Runtime>(app: &AppHandle<R>) -> Result<Submenu<R>, tauri::Error> {
-    let about = MenuItemBuilder::with_id(MENU_ID_ABOUT, "About SwitchHosts").build(app)?;
+fn build_macos_app_menu<R: Runtime>(
+    app: &AppHandle<R>,
+    labels: &MenuLabels,
+) -> Result<Submenu<R>, tauri::Error> {
+    let about = MenuItemBuilder::with_id(MENU_ID_ABOUT, labels.about_app).build(app)?;
+    let services = PredefinedMenuItem::services(app, Some(labels.services))?;
+    let hide = PredefinedMenuItem::hide(app, Some(labels.hide_app))?;
+    let hide_others = PredefinedMenuItem::hide_others(app, Some(labels.hide_others))?;
+    let show_all = PredefinedMenuItem::show_all(app, Some(labels.show_all))?;
+    let quit = PredefinedMenuItem::quit(app, Some(labels.quit_app))?;
+
     SubmenuBuilder::new(app, "SwitchHosts")
         .item(&about)
         .separator()
-        .services()
+        .item(&services)
         .separator()
-        .hide()
-        .hide_others()
-        .show_all()
+        .item(&hide)
+        .item(&hide_others)
+        .item(&show_all)
         .separator()
-        .quit()
+        .item(&quit)
         .build()
 }
 
 // ---- File ------------------------------------------------------------------
 
-fn build_file_menu<R: Runtime>(app: &AppHandle<R>) -> Result<Submenu<R>, tauri::Error> {
-    let new_item = MenuItemBuilder::with_id(MENU_ID_NEW, "New")
+fn build_file_menu<R: Runtime>(
+    app: &AppHandle<R>,
+    labels: &MenuLabels,
+) -> Result<Submenu<R>, tauri::Error> {
+    let new_item = MenuItemBuilder::with_id(MENU_ID_NEW, labels.new)
         .accelerator("CmdOrCtrl+N")
         .build(app)?;
-    let prefs = MenuItemBuilder::with_id(MENU_ID_PREFERENCES, "Preferences\u{2026}")
+    let prefs = MenuItemBuilder::with_id(MENU_ID_PREFERENCES, labels.preferences)
         .accelerator("CmdOrCtrl+,")
         .build(app)?;
 
-    let mut builder = SubmenuBuilder::new(app, "File");
+    let mut builder = SubmenuBuilder::new(app, labels.file);
 
     // On Windows/Linux put About at the top of File (Electron does this)
     #[cfg(not(target_os = "macos"))]
     {
-        let about = MenuItemBuilder::with_id(MENU_ID_ABOUT, "About SwitchHosts").build(app)?;
+        let about = MenuItemBuilder::with_id(MENU_ID_ABOUT, labels.about_app).build(app)?;
         builder = builder.item(&about).separator();
     }
 
-    builder = builder
-        .item(&new_item)
-        .separator()
-        .item(&prefs);
+    builder = builder.item(&new_item).separator().item(&prefs);
 
     #[cfg(not(target_os = "macos"))]
     {
-        builder = builder
-            .separator()
-            .item(&PredefinedMenuItem::quit(app, None)?);
+        let quit = PredefinedMenuItem::quit(app, Some(labels.quit))?;
+        builder = builder.separator().item(&quit);
     }
 
     #[cfg(target_os = "macos")]
     {
-        builder = builder
-            .separator()
-            .item(&PredefinedMenuItem::close_window(app, None)?);
+        let close_window = PredefinedMenuItem::close_window(app, Some(labels.close_window))?;
+        builder = builder.separator().item(&close_window);
     }
 
     builder.build()
 }
 
 // ---- Edit ------------------------------------------------------------------
 
-fn build_edit_menu<R: Runtime>(app: &AppHandle<R>) -> Result<Submenu<R>, tauri::Error> {
-    let comment = MenuItemBuilder::with_id(MENU_ID_COMMENT, "Comment / Uncomment")
+fn build_edit_menu<R: Runtime>(
+    app: &AppHandle<R>,
+    labels: &MenuLabels,
+) -> Result<Submenu<R>, tauri::Error> {
+    let comment = MenuItemBuilder::with_id(MENU_ID_COMMENT, labels.comment_uncomment)
         .accelerator("CmdOrCtrl+/")
         .build(app)?;
-    let find = MenuItemBuilder::with_id(MENU_ID_FIND, "Find\u{2026}")
+    let find = MenuItemBuilder::with_id(MENU_ID_FIND, labels.find)
         .accelerator("CmdOrCtrl+F")
         .build(app)?;
-
-    SubmenuBuilder::new(app, "Edit")
-        .undo()
-        .redo()
+    let undo = PredefinedMenuItem::undo(app, Some(labels.undo))?;
+    let redo = PredefinedMenuItem::redo(app, Some(labels.redo))?;
+    let cut = PredefinedMenuItem::cut(app, Some(labels.cut))?;
+    let copy = PredefinedMenuItem::copy(app, Some(labels.copy))?;
+    let paste = PredefinedMenuItem::paste(app, Some(labels.paste))?;
+    let select_all = PredefinedMenuItem::select_all(app, Some(labels.select_all))?;
+
+    SubmenuBuilder::new(app, labels.edit)
+        .item(&undo)
+        .item(&redo)
         .separator()
-        .cut()
-        .copy()
-        .paste()
-        .select_all()
+        .item(&cut)
+        .item(&copy)
+        .item(&paste)
+        .item(&select_all)
         .separator()
         .item(&comment)
         .item(&find)
@@ -144,45 +173,53 @@ fn build_edit_menu<R: Runtime>(app: &AppHandle<R>) -> Result<Submenu<R>, tauri::
 
 // ---- View ------------------------------------------------------------------
 
-fn build_view_menu<R: Runtime>(app: &AppHandle<R>) -> Result<Submenu<R>, tauri::Error> {
-    let builder = SubmenuBuilder::new(app, "View");
+fn build_view_menu<R: Runtime>(
+    app: &AppHandle<R>,
+    labels: &MenuLabels,
+) -> Result<Submenu<R>, tauri::Error> {
+    let builder = SubmenuBuilder::new(app, labels.view);
 
     #[cfg(target_os = "macos")]
-    let builder = builder
-        .item(&PredefinedMenuItem::fullscreen(app, None)?)
-        .separator();
-
-    builder
-        .item(&PredefinedMenuItem::minimize(app, None)?)
-        .item(&PredefinedMenuItem::maximize(app, None)?)
-        .build()
+    let builder = {
+        let fullscreen = PredefinedMenuItem::fullscreen(app, Some(labels.fullscreen))?;
+        builder.item(&fullscreen).separator()
+    };
+
+    let minimize = PredefinedMenuItem::minimize(app, Some(labels.minimize))?;
+    let maximize = PredefinedMenuItem::maximize(app, Some(labels.maximize))?;
+    builder.item(&minimize).item(&maximize).build()
 }
 
 // ---- Window ----------------------------------------------------------------
 
-fn build_window_menu<R: Runtime>(app: &AppHandle<R>) -> Result<Submenu<R>, tauri::Error> {
-    let mut builder = SubmenuBuilder::new(app, "Window");
-    builder = builder.minimize().close_window();
+fn build_window_menu<R: Runtime>(
+    app: &AppHandle<R>,
+    labels: &MenuLabels,
+) -> Result<Submenu<R>, tauri::Error> {
+    let minimize = PredefinedMenuItem::minimize(app, Some(labels.minimize))?;
+    let close_window = PredefinedMenuItem::close_window(app, Some(labels.close_window))?;
+    let mut builder = SubmenuBuilder::new(app, labels.window);
+    builder = builder.item(&minimize).item(&close_window);
 
     #[cfg(target_os = "macos")]
     {
-        builder = builder
-            .separator()
-            .item(&PredefinedMenuItem::maximize(app, None)?);
+        let maximize = PredefinedMenuItem::maximize(app, Some(labels.maximize))?;
+        builder = builder.separator().item(&maximize);
     }
 
     builder.build()
 }
 
 // ---- Help ------------------------------------------------------------------
 
-fn build_help_menu<R: Runtime>(app: &AppHandle<R>) -> Result<Submenu<R>, tauri::Error> {
-    let feedback = MenuItemBuilder::with_id(MENU_ID_FEEDBACK, "Feedback")
-        .build(app)?;
-    let homepage = MenuItemBuilder::with_id(MENU_ID_HOMEPAGE, "Homepage")
-        .build(app)?;
+fn build_help_menu<R: Runtime>(
+    app: &AppHandle<R>,
+    labels: &MenuLabels,
+) -> Result<Submenu<R>, tauri::Error> {
+    let feedback = MenuItemBuilder::with_id(MENU_ID_FEEDBACK, labels.feedback).build(app)?;
+    let homepage = MenuItemBuilder::with_id(MENU_ID_HOMEPAGE, labels.homepage).build(app)?;
 
-    SubmenuBuilder::new(app, "Help")
+    SubmenuBuilder::new(app, labels.help)
         .item(&feedback)
         .item(&homepage)
         .build()

src-tauri/src/commands.rs

@@ -17,6 +17,7 @@ use tauri::menu::{MenuBuilder, MenuItemBuilder};
 use tauri::{AppHandle, Emitter, Manager, Runtime, State, WebviewWindow, Wry};
 use tauri_plugin_dialog::DialogExt;
 
+use crate::app_menu;
 use crate::find::{self, FindHistoryEntry, FindOptions};
 use crate::hosts_apply::{self, ApplyHistoryItem, HostsApplyError};
 use crate::http;
@@ -200,15 +201,16 @@ pub async fn config_update(
 ///
 /// - `http_api_on` / `http_api_only_local` → start, stop or rebind
 ///   the local HTTP API server.
+/// - `locale` → rebuild native application and tray menus.
+/// - `hide_dock_icon` → apply the macOS Dock policy and update the tray
+///   toggle label.
 ///
-/// More keys will land here as Phase 2 progresses (theme switch,
-/// hide_dock_icon, etc.). Always reads the *fresh* config snapshot
-/// rather than trusting the patch, so a rebind picks up both keys
-/// even if only one of them was in the patch.
+/// Always reads the *fresh* config snapshot rather than trusting the
+/// patch, so a rebind picks up both keys even if only one of them was
+/// in the patch.
 ///
-/// Pinned to `Wry` because the only side effect today is the HTTP
-/// API server, which is itself pinned to `Wry` (see the comment in
-/// `http_api.rs`).
+/// Pinned to `Wry` because the HTTP API server is itself pinned to
+/// `Wry` (see the comment in `http_api.rs`).
 fn apply_side_effects(
     app: &AppHandle<Wry>,
     state: &AppState,
@@ -217,6 +219,28 @@ fn apply_side_effects(
     let touches_http_api = touched_keys
         .iter()
         .any(|k| *k == "http_api_on" || *k == "http_api_only_local");
+    let touches_locale = touched_keys.iter().any(|k| *k == "locale");
+
+    if touches_locale {
+        if let Err(e) = app_menu::refresh(app) {
+            log::warn!("failed to refresh app menu: {e}");
+        }
+        tray::refresh_menu(app);
+    }
+
+    #[cfg(target_os = "macos")]
+    {
+        let touches_hide_dock_icon = touched_keys.iter().any(|k| *k == "hide_dock_icon");
+        if touches_hide_dock_icon {
+            let hide = {
+                let cfg = state.config.lock().expect("config mutex poisoned");
+                cfg.hide_dock_icon
+            };
+            lifecycle::apply_dock_icon_policy(app, hide);
+            tray::refresh_menu(app);
+        }
+    }
+
     if touches_http_api {
         let (on, only_local) = {
             let cfg = state.config.lock().expect("config mutex poisoned");