Add online dictionary lookup (Free Dictionary API) and macOS Edit menu

- Add lookup_word_online command using dictionaryapi.dev (free, no auth)
- Returns structured DictionaryEntry (same as AI) with source name
  extracted from sourceUrls (e.g. "Wiktionary")
- Unify online + AI rendering into single renderDictEntry() function
- Lookup chain: offline → online → AI, with green badge for online source
- Add macOS Edit menu with Undo/Redo/Cut/Copy/Paste/Select All so
  Cmd+C/V/X/A/Z work natively
- Fix offline dict content overflow with CSS containment

Author: liuchengxu

crates/markdown_preview_core/js/styles.css

@@ -3042,6 +3042,7 @@ body.presentation-mode #reading-progress {
     }
 
     .dict-source-badge.offline { background: #0d2240; color: #58a6ff; }
+    .dict-source-badge.online { background: #0d2d1a; color: #3fb950; }
     .dict-source-badge.ai { background: #3d2e00; color: #d29922; }
     .dict-offline-entry { border-bottom-color: #30363d; }
     .dict-ai-loading { color: #8b949e; }
@@ -3064,6 +3065,7 @@ body.presentation-mode #reading-progress {
     margin-bottom: 12px;
 }
 .dict-source-badge.offline { background: #ddf4ff; color: #0969da; }
+.dict-source-badge.online { background: #dafbe1; color: #116329; }
 .dict-source-badge.ai { background: #fff8c5; color: #9a6700; }
 
 /* Offline dictionary entry container */
@@ -3072,14 +3074,14 @@ body.presentation-mode #reading-progress {
     padding-bottom: 20px;
     border-bottom: 1px solid #d0d7de;
 }
-.dict-offline-content { font-size: 14px; line-height: 1.6; }
+.dict-offline-content { font-size: 14px; line-height: 1.6; overflow: auto; position: relative; }
 
 /* AI loading indicator */
 .dict-ai-loading {
     font-size: 12px; color: #656d76; padding: 12px 0;
     font-style: italic;
 }
-.dict-ai-entry {
+.dict-entry {
     margin-top: 8px;
 }
 

crates/markdown_preview_core/js/tauri-app.js

@@ -2352,8 +2352,12 @@
         if (btn) btn.disabled = true;
 
         let hasOfflineResults = false;
+        let hasOnlineResults = false;
         let hasAiResults = false;
 
+        // Helper: returns true when we already have at least one source of results.
+        const hasAnyResults = () => hasOfflineResults || hasOnlineResults;
+
         // 1. Offline lookup (fast, in-memory)
         try {
             const offlineResults = await invoke('lookup_word_offline', { word });
@@ -2369,9 +2373,28 @@
             if (isStale()) { if (btn) btn.disabled = false; return; }
         }
 
-        // 2. AI lookup (slow, async) — only if configured
+        // 2. Online dictionary API (Free Dictionary)
+        try {
+            const onlineEntry = await invoke('lookup_word_online', { word });
+            if (isStale()) { if (btn) btn.disabled = false; return; }
+            if (onlineEntry) {
+                hasOnlineResults = true;
+                const onlineHtml = renderDictEntry(onlineEntry, 'online', onlineEntry.source || 'Online');
+                if (hasOfflineResults) {
+                    resultsEl.insertAdjacentHTML('beforeend', onlineHtml);
+                } else {
+                    resultsEl.innerHTML = onlineHtml;
+                }
+                wireUpDictTags(resultsEl);
+                wireUpPronounceButtons(resultsEl);
+            }
+        } catch (_err) {
+            if (isStale()) { if (btn) btn.disabled = false; return; }
+        }
+
+        // 3. AI lookup (slow, async) — only if configured
         try {
-            if (hasOfflineResults) {
+            if (hasAnyResults()) {
                 resultsEl.insertAdjacentHTML('beforeend',
                     '<div class="dict-ai-loading">Loading AI definition...</div>');
             }
@@ -2389,22 +2412,23 @@
             const aiLoadingEl = resultsEl.querySelector('.dict-ai-loading');
             if (aiLoadingEl) aiLoadingEl.remove();
 
-            if (hasOfflineResults) {
-                resultsEl.insertAdjacentHTML('beforeend', renderAiDictEntry(entry));
+            const aiHtml = renderDictEntry(entry, 'ai', 'AI');
+            if (hasAnyResults()) {
+                resultsEl.insertAdjacentHTML('beforeend', aiHtml);
             } else {
-                resultsEl.innerHTML = renderAiDictEntry(entry);
+                resultsEl.innerHTML = aiHtml;
             }
             wireUpDictTags(resultsEl);
             wireUpPronounceButtons(resultsEl);
         } catch (err) {
             if (isStale()) { if (btn) btn.disabled = false; return; }
             const aiLoadingEl = resultsEl.querySelector('.dict-ai-loading');
             if (aiLoadingEl) aiLoadingEl.remove();
-            if (!hasOfflineResults) {
+            if (!hasAnyResults()) {
                 const errStr = String(err);
                 if (errStr.includes('not configured')) {
                     resultsEl.innerHTML = '<div class="dict-empty-state">'
-                        + '<p>No offline dictionaries matched.</p>'
+                        + '<p>No dictionaries matched.</p>'
                         + '<p>AI provider not configured. Set one in Settings.</p></div>';
                 } else {
                     resultsEl.innerHTML = `<div class="dict-error">${escapeHtml(errStr)}</div>`;
@@ -2415,7 +2439,7 @@
         }
 
         if (isStale()) return;
-        if (!hasOfflineResults && !hasAiResults) {
+        if (!hasAnyResults() && !hasAiResults) {
             resultsEl.innerHTML = '<div class="dict-empty-state">No results found</div>';
         }
     }
@@ -2430,9 +2454,15 @@
         }).join('');
     }
 
-    function renderAiDictEntry(entry) {
-        let html = '<div class="dict-ai-entry">';
-        html += '<div class="dict-source-badge ai">AI</div>';
+    /**
+     * Render a structured dictionary entry (used for both online and AI sources).
+     * @param {Object} entry - DictionaryEntry {word, phonetic, definitions, synonyms, antonyms}
+     * @param {string} badgeClass - CSS class for the source badge (e.g. 'ai', 'online')
+     * @param {string} badgeLabel - Display text for the source badge
+     */
+    function renderDictEntry(entry, badgeClass, badgeLabel) {
+        let html = `<div class="dict-entry">`;
+        html += `<div class="dict-source-badge ${escapeHtml(badgeClass)}">${escapeHtml(badgeLabel)}</div>`;
 
         // Word header with phonetic and pronounce button
         html += '<div class="dict-word-header">';

maple_desk/src/commands/dictionary.rs

@@ -1,12 +1,13 @@
-//! Dictionary lookup commands: AI-powered and offline (StarDict/MDict).
+//! Dictionary lookup commands: AI-powered, online (Free Dictionary API),
+//! and offline (StarDict/MDict).
 
 use std::sync::Arc;
 
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use tauri::State;
 use tokio::sync::RwLock;
 
-use crate::ai::{self, AiConfig, DictionaryEntry};
+use crate::ai::{self, AiConfig, DictionaryDefinition, DictionaryEntry};
 use crate::state::{AppState, DictLoadResult, OfflineDictState};
 
 /// Type alias for the managed dictionary load serializer.
@@ -118,6 +119,182 @@ pub async fn ask_ai(
     ai::ask_ai(&config, &question).await
 }
 
+// ---------------------------------------------------------------------------
+// Free Dictionary API (dictionaryapi.dev) — online lookup
+// ---------------------------------------------------------------------------
+
+/// Response from an online dictionary lookup, pairing the structured entry
+/// with the original source name (e.g. "Wiktionary").
+#[derive(Serialize)]
+pub struct OnlineLookupResult {
+    /// The dictionary entry (same shape as AI lookups).
+    #[serde(flatten)]
+    pub entry: DictionaryEntry,
+    /// Human-readable source name extracted from `sourceUrls`.
+    pub source: String,
+}
+
+/// Top-level entry from the Free Dictionary API response.
+#[derive(Deserialize)]
+struct FreeDictEntry {
+    phonetic: Option<String>,
+    #[serde(default)]
+    meanings: Vec<FreeDictMeaning>,
+    #[serde(default, rename = "sourceUrls")]
+    source_urls: Vec<String>,
+}
+
+/// A meaning group (one per part of speech).
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct FreeDictMeaning {
+    part_of_speech: String,
+    #[serde(default)]
+    definitions: Vec<FreeDictDefinition>,
+    #[serde(default)]
+    synonyms: Vec<String>,
+    #[serde(default)]
+    antonyms: Vec<String>,
+}
+
+/// A single definition inside a meaning group.
+#[derive(Deserialize)]
+struct FreeDictDefinition {
+    definition: String,
+    example: Option<String>,
+    #[serde(default)]
+    synonyms: Vec<String>,
+    #[serde(default)]
+    antonyms: Vec<String>,
+}
+
+/// Convert Free Dictionary API entries into a [`DictionaryEntry`].
+///
+/// Merges all entries into a single result, collecting synonyms/antonyms from
+/// both the meaning-group and per-definition levels.
+fn free_dict_to_entry(word: String, raw: &[FreeDictEntry]) -> DictionaryEntry {
+    let phonetic = raw
+        .iter()
+        .find_map(|e| e.phonetic.clone())
+        .unwrap_or_default();
+
+    let mut definitions = Vec::new();
+    let mut synonyms = Vec::new();
+    let mut antonyms = Vec::new();
+
+    for entry in raw {
+        for meaning in &entry.meanings {
+            // Collect top-level synonyms/antonyms from the meaning group.
+            synonyms.extend(meaning.synonyms.iter().cloned());
+            antonyms.extend(meaning.antonyms.iter().cloned());
+
+            for def in &meaning.definitions {
+                definitions.push(DictionaryDefinition {
+                    part_of_speech: meaning.part_of_speech.clone(),
+                    meaning: def.definition.clone(),
+                    example: def.example.clone().unwrap_or_default(),
+                });
+                synonyms.extend(def.synonyms.iter().cloned());
+                antonyms.extend(def.antonyms.iter().cloned());
+            }
+        }
+    }
+
+    // De-duplicate while preserving order.
+    synonyms.dedup();
+    antonyms.dedup();
+
+    DictionaryEntry {
+        word,
+        phonetic,
+        definitions,
+        synonyms,
+        antonyms,
+    }
+}
+
+/// Extract a human-readable source name from a URL.
+///
+/// For example, `https://en.wiktionary.org/wiki/hello` → `"Wiktionary"`.
+/// Falls back to the domain segment if the name isn't recognised.
+fn source_name_from_url(url: &str) -> Option<String> {
+    // Extract host from URL: skip "https://" or "http://", take up to next '/'.
+    let after_scheme = url.split("://").nth(1)?;
+    let host = after_scheme.split('/').next()?;
+
+    // Strip leading "en." / "www." etc.
+    let base = host
+        .strip_prefix("en.")
+        .or_else(|| host.strip_prefix("www."))
+        .unwrap_or(host);
+
+    // Capitalise the first segment before the first dot.
+    let name = base.split('.').next().unwrap_or(base);
+    let mut chars = name.chars();
+    let capitalised: String = match chars.next() {
+        Some(c) => c.to_uppercase().chain(chars).collect(),
+        None => return None,
+    };
+    Some(capitalised)
+}
+
+/// Look up a word using the Free Dictionary API (dictionaryapi.dev).
+///
+/// Returns an [`OnlineLookupResult`] containing the structured entry and the
+/// original source name (e.g. "Wiktionary").
+/// Returns `None` when the word is not found (HTTP 404).
+#[tauri::command]
+pub async fn lookup_word_online(word: String) -> Result<Option<OnlineLookupResult>, String> {
+    let word = word.trim().to_string();
+    if word.is_empty() {
+        return Err("No word provided".to_string());
+    }
+
+    let url = format!("https://api.dictionaryapi.dev/api/v2/entries/en/{word}");
+
+    let client = reqwest::Client::builder()
+        .timeout(std::time::Duration::from_secs(10))
+        .build()
+        .map_err(|error| format!("HTTP client error: {error}"))?;
+
+    let response = client
+        .get(&url)
+        .send()
+        .await
+        .map_err(|error| format!("Network error: {error}"))?;
+
+    if response.status() == reqwest::StatusCode::NOT_FOUND {
+        return Ok(None);
+    }
+
+    if !response.status().is_success() {
+        return Err(format!(
+            "Free Dictionary API returned status {}",
+            response.status()
+        ));
+    }
+
+    let entries: Vec<FreeDictEntry> = response
+        .json()
+        .await
+        .map_err(|error| format!("Failed to parse Free Dictionary response: {error}"))?;
+
+    if entries.is_empty() {
+        return Ok(None);
+    }
+
+    let source = entries
+        .iter()
+        .flat_map(|e| e.source_urls.iter())
+        .find_map(|u| source_name_from_url(u))
+        .unwrap_or_else(|| "Free Dictionary".to_string());
+
+    Ok(Some(OnlineLookupResult {
+        entry: free_dict_to_entry(word, &entries),
+        source,
+    }))
+}
+
 /// Look up a word in all loaded offline dictionaries.
 #[tauri::command]
 pub async fn lookup_word_offline(

maple_desk/src/main.rs

@@ -196,6 +196,7 @@ fn main() {
             commands::terminal::resize_terminal,
             commands::terminal::kill_terminal,
             commands::dictionary::lookup_word,
+            commands::dictionary::lookup_word_online,
             commands::dictionary::lookup_word_offline,
             commands::dictionary::get_loaded_dictionaries,
             commands::dictionary::ask_ai,

maple_desk/src/menu.rs

@@ -1,6 +1,6 @@
 //! Native menu implementation for the markdown preview app.
 
-use tauri::menu::{Menu, MenuBuilder, MenuEvent, MenuItem, SubmenuBuilder};
+use tauri::menu::{Menu, MenuBuilder, MenuEvent, MenuItem, PredefinedMenuItem, SubmenuBuilder};
 use tauri::{AppHandle, Emitter, Manager, Runtime};
 
 /// Create the application menu.
@@ -23,6 +23,17 @@ pub fn create_menu<R: Runtime>(app: &AppHandle<R>) -> Result<Menu<R>, tauri::Err
         .item(&close_item)
         .build()?;
 
+    // Edit menu (required on macOS for Cmd+C/V/X/A/Z to work)
+    let edit_menu = SubmenuBuilder::new(app, "Edit")
+        .item(&PredefinedMenuItem::undo(app, None)?)
+        .item(&PredefinedMenuItem::redo(app, None)?)
+        .separator()
+        .item(&PredefinedMenuItem::cut(app, None)?)
+        .item(&PredefinedMenuItem::copy(app, None)?)
+        .item(&PredefinedMenuItem::paste(app, None)?)
+        .item(&PredefinedMenuItem::select_all(app, None)?)
+        .build()?;
+
     // View menu
     let reload_item = MenuItem::with_id(app, "reload", "Reload", true, Some("CmdOrCtrl+R"))?;
 
@@ -75,6 +86,7 @@ pub fn create_menu<R: Runtime>(app: &AppHandle<R>) -> Result<Menu<R>, tauri::Err
     // Build the complete menu
     MenuBuilder::new(app)
         .item(&file_menu)
+        .item(&edit_menu)
         .item(&view_menu)
         .item(&theme_menu)
         .item(&help_menu)