Skip to content

Offline, privacy-first grammar checker. Fast, open-source, Rust-powered

feat(desktop): add debounce option (#3420)

Elijah Potterbe21ffed8370
diff --git a/harper-desktop/src-tauri/src/communication/client.rs b/harper-desktop/src-tauri/src/communication/client.rs
index 3d52bdeb9..2d90bdbfe 100644
--- a/harper-desktop/src-tauri/src/communication/client.rs
+++ b/harper-desktop/src-tauri/src/communication/client.rs
@@ -62,6 +62,15 @@ where
}
}
+ pub async fn get_debounce_ms(&mut self) -> Result<u64, ProtocolError> {
+ match self.send_request(Request::GetDebounceMs).await? {
+ Response::GetDebounceMs { debounce_ms } => Ok(debounce_ms),
+ _ => Err(ProtocolError::UnexpectedResponse {
+ expected: "GetDebounceMs",
+ }),
+ }
+ }
+
pub async fn get_ignored_lints(&mut self) -> Result<IgnoredLints, ProtocolError> {
match self.send_request(Request::GetIgnoredLints).await? {
Response::GetIgnoredLints { ignored_lints } => Ok(ignored_lints),
diff --git a/harper-desktop/src-tauri/src/communication/message.rs b/harper-desktop/src-tauri/src/communication/message.rs
index 4e62d0f7d..590efd974 100644
--- a/harper-desktop/src-tauri/src/communication/message.rs
+++ b/harper-desktop/src-tauri/src/communication/message.rs
@@ -8,6 +8,7 @@ pub enum Request {
GetLintConfig,
GetDictionary,
GetDialect,
+ GetDebounceMs,
GetIgnoredLints,
GetIntegrations,
SetLintConfig { config: FlatConfig },
@@ -24,6 +25,7 @@ pub enum Response {
GetLintConfig { config: FlatConfig },
GetDictionary { words: Vec<String> },
GetDialect { dialect: Dialect },
+ GetDebounceMs { debounce_ms: u64 },
GetIgnoredLints { ignored_lints: IgnoredLints },
GetIntegrations { integrations: Vec<Integration> },
Ack,
@@ -68,6 +70,14 @@ mod tests {
assert!(matches!(decoded, Request::GetDialect));
}
+ #[test]
+ fn get_debounce_ms_request_serializes_as_json() {
+ let encoded = serde_json::to_string(&Request::GetDebounceMs).unwrap();
+ let decoded: Request = serde_json::from_str(&encoded).unwrap();
+
+ assert!(matches!(decoded, Request::GetDebounceMs));
+ }
+
#[test]
fn get_ignored_lints_request_serializes_as_json() {
let encoded = serde_json::to_string(&Request::GetIgnoredLints).unwrap();
@@ -191,6 +201,15 @@ mod tests {
));
}
+ #[test]
+ fn debounce_ms_response_serializes_as_json() {
+ let response = Response::GetDebounceMs { debounce_ms: 250 };
+ let encoded = serde_json::to_string(&response).unwrap();
+ let decoded: Response = serde_json::from_str(&encoded).unwrap();
+
+ assert!(matches!(decoded, Response::GetDebounceMs { debounce_ms } if debounce_ms == 250));
+ }
+
#[test]
fn ignored_lints_response_serializes_as_json() {
let response = Response::GetIgnoredLints {
diff --git a/harper-desktop/src-tauri/src/communication/mod.rs b/harper-desktop/src-tauri/src/communication/mod.rs
index 4da75beb0..86838a698 100644
--- a/harper-desktop/src-tauri/src/communication/mod.rs
+++ b/harper-desktop/src-tauri/src/communication/mod.rs
@@ -72,6 +72,23 @@ mod tests {
assert!(matches!(request.unwrap(), Some(Request::GetDialect)));
}
+ #[tokio::test]
+ async fn client_receives_debounce_ms_from_server() {
+ let (client_request_writer, server_request_reader) = duplex(16_384);
+ let (server_response_writer, client_response_reader) = duplex(16_384);
+ let mut config = Config::new();
+ config.debounce_ms = 250;
+ let config = Arc::new(Mutex::new(config));
+ let mut client = Client::new(client_response_reader, client_request_writer);
+ let mut server = Server::new(server_request_reader, server_response_writer, config);
+
+ let (debounce_ms, request) =
+ tokio::join!(client.get_debounce_ms(), server.receive_request());
+
+ assert_eq!(debounce_ms.unwrap(), 250);
+ assert!(matches!(request.unwrap(), Some(Request::GetDebounceMs)));
+ }
+
#[tokio::test]
async fn client_receives_ignored_lints_from_server() {
let (client_request_writer, server_request_reader) = duplex(16_384);
diff --git a/harper-desktop/src-tauri/src/communication/server.rs b/harper-desktop/src-tauri/src/communication/server.rs
index 7bd96b811..5041146de 100644
--- a/harper-desktop/src-tauri/src/communication/server.rs
+++ b/harper-desktop/src-tauri/src/communication/server.rs
@@ -59,6 +59,9 @@ where
Request::GetDialect => Response::GetDialect {
dialect: self.config.lock().await.dialect,
},
+ Request::GetDebounceMs => Response::GetDebounceMs {
+ debounce_ms: self.config.lock().await.debounce_ms,
+ },
Request::GetIgnoredLints => Response::GetIgnoredLints {
ignored_lints: self.config.lock().await.ignored_lints.clone(),
},
diff --git a/harper-desktop/src-tauri/src/config.rs b/harper-desktop/src-tauri/src/config.rs
index 3ce628ada..911c62912 100644
--- a/harper-desktop/src-tauri/src/config.rs
+++ b/harper-desktop/src-tauri/src/config.rs
@@ -28,6 +28,7 @@ pub struct Config {
pub ignored_lints: IgnoredLints,
pub lint_config: FlatConfig,
pub integrations: Vec<Integration>,
+ pub debounce_ms: u64,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
@@ -44,6 +45,7 @@ impl Config {
ignored_lints: IgnoredLints::new(),
lint_config: FlatConfig::new_curated(),
integrations: Self::curated_integrations(),
+ debounce_ms: 0,
}
}
@@ -170,6 +172,7 @@ impl Config {
"ignored_lints": &self.ignored_lints,
"lint_config": &self.lint_config,
"integrations": &self.integrations,
+ "debounce_ms": self.debounce_ms,
}))
}
@@ -187,6 +190,7 @@ impl Config {
lint_config: deserialize_field(object, "lint_config")?,
integrations: deserialize_optional_field(object, "integrations")?
.unwrap_or_else(Self::curated_integrations),
+ debounce_ms: deserialize_optional_field(object, "debounce_ms")?.unwrap_or(0),
})
}
}
@@ -247,6 +251,7 @@ mod tests {
assert!(serialized.contains("ignored_lints"));
assert!(serialized.contains("lint_config"));
assert!(serialized.contains("integrations"));
+ assert!(serialized.contains("debounce_ms"));
}
#[test]
@@ -262,6 +267,7 @@ mod tests {
assert_eq!(deserialized.dialect, config.dialect);
assert_eq!(deserialized.lint_config, config.lint_config);
assert_eq!(deserialized.integrations, config.integrations);
+ assert_eq!(deserialized.debounce_ms, config.debounce_ms);
assert_eq!(
serde_json::from_str::<serde_json::Value>(&deserialized.serialize_main().unwrap())
.unwrap(),
@@ -292,6 +298,18 @@ mod tests {
assert_eq!(deserialized.integrations, Config::curated_integrations());
}
+ #[test]
+ fn deserialize_main_uses_zero_debounce_when_missing() {
+ let config = Config::new();
+ let mut value =
+ serde_json::from_str::<serde_json::Value>(&config.serialize_main().unwrap()).unwrap();
+ value.as_object_mut().unwrap().remove("debounce_ms");
+
+ let deserialized = Config::deserialize_main(&value.to_string()).unwrap();
+
+ assert_eq!(deserialized.debounce_ms, 0);
+ }
+
#[test]
fn deserialize_main_preserves_integrations() {
let mut config = Config::new();
diff --git a/harper-desktop/src-tauri/src/debounce.rs b/harper-desktop/src-tauri/src/debounce.rs
new file mode 100644
index 000000000..63d0ff238
--- /dev/null
+++ b/harper-desktop/src-tauri/src/debounce.rs
@@ -0,0 +1,65 @@
+use harper_core::linting::Lint;
+use std::{
+ collections::BTreeMap,
+ time::{Duration, Instant},
+};
+
+#[derive(Default)]
+pub(crate) struct DebounceState {
+ last_observed_text: Option<String>,
+ last_text_change: Option<Instant>,
+ last_linted_text: Option<String>,
+ last_lints: BTreeMap<String, Vec<Lint>>,
+}
+
+impl DebounceState {
+ pub(crate) fn status(&mut self, text: &str, debounce_ms: u64) -> DebounceStatus {
+ if debounce_ms == 0 {
+ return DebounceStatus::Ready;
+ }
+
+ let now = Instant::now();
+
+ if self.last_observed_text.as_deref() != Some(text) {
+ self.last_observed_text = Some(text.to_string());
+ self.last_text_change = Some(now);
+ self.last_linted_text = None;
+
+ return DebounceStatus::Cached(self.last_lints.clone());
+ }
+
+ if self.last_linted_text.as_deref() == Some(text) {
+ return DebounceStatus::Cached(self.last_lints.clone());
+ }
+
+ let Some(last_text_change) = self.last_text_change else {
+ self.last_text_change = Some(now);
+ return DebounceStatus::Cached(self.last_lints.clone());
+ };
+
+ if now.duration_since(last_text_change) < Duration::from_millis(debounce_ms) {
+ return DebounceStatus::Cached(self.last_lints.clone());
+ }
+
+ DebounceStatus::Ready
+ }
+
+ pub(crate) fn store_lints(
+ &mut self,
+ text: &str,
+ debounce_ms: u64,
+ lints: &BTreeMap<String, Vec<Lint>>,
+ ) {
+ if debounce_ms == 0 {
+ return;
+ }
+
+ self.last_linted_text = Some(text.to_string());
+ self.last_lints = lints.clone();
+ }
+}
+
+pub(crate) enum DebounceStatus {
+ Ready,
+ Cached(BTreeMap<String, Vec<Lint>>),
+}
diff --git a/harper-desktop/src-tauri/src/lib.rs b/harper-desktop/src-tauri/src/lib.rs
index c15f73e9f..9f629ba3e 100644
--- a/harper-desktop/src-tauri/src/lib.rs
+++ b/harper-desktop/src-tauri/src/lib.rs
@@ -2,6 +2,7 @@ use self::highlighter::Highlighter;
use self::highlighter_service::HighlighterService;
use crate::communication::{Client, ProtocolError};
use crate::config::{Config, Integration};
+use crate::debounce::{DebounceState, DebounceStatus};
use clap::{Parser, Subcommand};
use harper_core::{
Dialect, DictWordMetadata, Document, IgnoredLints,
@@ -26,6 +27,7 @@ use tokio::{
pub mod color;
pub mod communication;
pub mod config;
+mod debounce;
pub mod highlighter;
pub mod highlighter_process;
pub mod highlighter_service;
@@ -194,6 +196,26 @@ async fn get_dialect(config: State<'_, Arc<Mutex<Config>>>) -> Result<Dialect, S
Ok(config.lock().await.dialect)
}
+#[tauri::command]
+async fn get_debounce_ms(config: State<'_, Arc<Mutex<Config>>>) -> Result<u64, String> {
+ Ok(config.lock().await.debounce_ms)
+}
+
+#[tauri::command]
+async fn set_debounce_ms(
+ debounce_ms: u64,
+ config: State<'_, Arc<Mutex<Config>>>,
+) -> Result<(), String> {
+ let mut config = config.lock().await;
+ config.debounce_ms = debounce_ms;
+ config
+ .save_to_system()
+ .await
+ .map_err(|error| error.to_string())?;
+
+ Ok(())
+}
+
#[tauri::command]
async fn set_dialect(
dialect: Dialect,
@@ -412,6 +434,8 @@ pub fn run_tauri() {
.invoke_handler(tauri::generate_handler![
get_lint_config,
get_dialect,
+ get_debounce_ms,
+ set_debounce_ms,
set_dialect,
set_lint_config,
get_dictionary,
@@ -525,11 +549,14 @@ pub fn run_highlighter() {
let user_dictionary = Rc::new(RefCell::new(startup_config.mutable_dictionary));
let dialect = Rc::new(RefCell::new(startup_config.dialect));
let integrations = Rc::new(RefCell::new(startup_config.integrations));
+ let debounce_ms = Rc::new(RefCell::new(startup_config.debounce_ms));
let linter = Rc::new(RefCell::new(startup_linter));
let lint_ignored_lints = ignored_lints.clone();
let lint_linter = linter.clone();
let lint_user_dictionary = user_dictionary.clone();
+ let lint_debounce_ms = debounce_ms.clone();
+ let lint_debounce_state = Rc::new(RefCell::new(DebounceState::default()));
let ignore_client = client.clone();
let ignore_runtime = sync_runtime.clone();
@@ -540,6 +567,7 @@ pub fn run_highlighter() {
let dictionary_user_dictionary = user_dictionary.clone();
let dictionary_linter = linter.clone();
let dictionary_dialect = dialect.clone();
+ let dictionary_debounce_ms = debounce_ms.clone();
let disable_client = client.clone();
let disable_runtime = sync_runtime.clone();
@@ -551,9 +579,18 @@ pub fn run_highlighter() {
let refresh_user_dictionary = user_dictionary.clone();
let refresh_dialect = dialect.clone();
let refresh_integrations = integrations.clone();
+ let refresh_debounce_ms = debounce_ms.clone();
let refresh_linter = linter.clone();
let lint_text = move |text: &str| {
+ let debounce_ms = *lint_debounce_ms.borrow();
+ let mut debounce_state = lint_debounce_state.borrow_mut();
+
+ match debounce_state.status(text, debounce_ms) {
+ DebounceStatus::Cached(lints) => return lints,
+ DebounceStatus::Ready => {}
+ }
+
let dictionary =
Config::dictionary_from_user_dictionary(lint_user_dictionary.borrow().clone());
let doc = Document::new_markdown_default(text, &dictionary);
@@ -563,6 +600,8 @@ pub fn run_highlighter() {
lint_ignored_lints.borrow().remove_ignored(lints, &doc);
}
+ debounce_state.store_lints(text, debounce_ms, &organized_lints);
+
organized_lints
};
@@ -593,6 +632,7 @@ pub fn run_highlighter() {
ignored_lints: IgnoredLints::new(),
lint_config,
integrations: Vec::new(),
+ debounce_ms: *dictionary_debounce_ms.borrow(),
};
*dictionary_linter.borrow_mut() = config.create_linter();
@@ -620,6 +660,7 @@ pub fn run_highlighter() {
&refresh_user_dictionary,
&refresh_dialect,
&refresh_integrations,
+ &refresh_debounce_ms,
&refresh_linter,
),
Err(error) => eprintln!("failed to refresh highlighter config: {error}"),
@@ -656,6 +697,7 @@ fn fetch_highlighter_config(
let ignored_lints = client.get_ignored_lints().await?;
let lint_config = client.get_lint_config().await?;
let integrations = client.get_integrations().await?;
+ let debounce_ms = client.get_debounce_ms().await?;
Ok(Config {
dialect,
@@ -663,6 +705,7 @@ fn fetch_highlighter_config(
ignored_lints,
lint_config,
integrations,
+ debounce_ms,
})
})
}
@@ -673,6 +716,7 @@ fn apply_highlighter_config(
user_dictionary: &Rc<RefCell<MutableDictionary>>,
dialect: &Rc<RefCell<Dialect>>,
integrations: &Rc<RefCell<Vec<Integration>>>,
+ debounce_ms: &Rc<RefCell<u64>>,
linter: &Rc<RefCell<LintGroup>>,
) {
let linter_config = config.create_linter();
@@ -680,5 +724,6 @@ fn apply_highlighter_config(
*user_dictionary.borrow_mut() = config.mutable_dictionary;
*dialect.borrow_mut() = config.dialect;
*integrations.borrow_mut() = config.integrations;
+ *debounce_ms.borrow_mut() = config.debounce_ms;
*linter.borrow_mut() = linter_config;
}
diff --git a/harper-desktop/src/lib/client.ts b/harper-desktop/src/lib/client.ts
index 3532eb244..91b4a4517 100644
--- a/harper-desktop/src/lib/client.ts
+++ b/harper-desktop/src/lib/client.ts
@@ -68,6 +68,14 @@ export class Client {
await invoke('set_dialect', { dialect: dialectToRustDialect(dialect) });
}
+ static async getDebounceMs(): Promise<number> {
+ return await invoke<number>('get_debounce_ms');
+ }
+
+ static async setDebounceMs(debounceMs: number): Promise<void> {
+ await invoke('set_debounce_ms', { debounceMs });
+ }
+
static async getLaunchAtStartup(): Promise<boolean> {
return await isEnabled();
}
diff --git a/harper-desktop/src/lib/settings/pages/GeneralPage.svelte b/harper-desktop/src/lib/settings/pages/GeneralPage.svelte
index 9ca8ee6de..ec7c7c911 100644
--- a/harper-desktop/src/lib/settings/pages/GeneralPage.svelte
+++ b/harper-desktop/src/lib/settings/pages/GeneralPage.svelte
@@ -23,10 +23,16 @@ let dialectError = '';
let isLaunchAtStartupLoading = true;
let isLaunchAtStartupSaving = false;
let launchAtStartupError = '';
+let debounceMs = 0;
+let debounceMsInput = '0';
+let isDebounceLoading = true;
+let isDebounceSaving = false;
+let debounceError = '';
onMount(() => {
void loadDialect();
void loadLaunchAtStartup();
+ void loadDebounceMs();
const refreshSettings = () => {
if (!isDialectSaving) {
@@ -36,6 +42,10 @@ onMount(() => {
if (!isLaunchAtStartupSaving) {
void loadLaunchAtStartup();
}
+
+ if (!isDebounceSaving) {
+ void loadDebounceMs();
+ }
};
window.addEventListener('focus', refreshSettings);
@@ -105,6 +115,46 @@ async function setLaunchAtStartup(enabled: boolean) {
}
}
+async function loadDebounceMs() {
+ isDebounceLoading = true;
+ debounceError = '';
+
+ try {
+ debounceMs = await Client.getDebounceMs();
+ debounceMsInput = String(debounceMs);
+ } catch (error) {
+ debounceError = `Unable to load debounce delay: ${error}`;
+ } finally {
+ isDebounceLoading = false;
+ }
+}
+
+async function saveDebounceMs() {
+ const parsedDebounceMs = Number(debounceMsInput);
+
+ if (!Number.isInteger(parsedDebounceMs) || parsedDebounceMs < 0) {
+ debounceError = 'Debounce delay must be a non-negative whole number.';
+ debounceMsInput = String(debounceMs);
+ return;
+ }
+
+ const previousDebounceMs = debounceMs;
+ debounceMs = parsedDebounceMs;
+ debounceMsInput = String(parsedDebounceMs);
+ isDebounceSaving = true;
+ debounceError = '';
+
+ try {
+ await Client.setDebounceMs(parsedDebounceMs);
+ } catch (error) {
+ debounceMs = previousDebounceMs;
+ debounceMsInput = String(previousDebounceMs);
+ debounceError = `Unable to save debounce delay: ${error}`;
+ } finally {
+ isDebounceSaving = false;
+ }
+}
+
function dialectToSettingsValue(dialect: Dialect): string {
switch (dialect) {
case DialectValue.British:
@@ -251,6 +301,38 @@ function settingsValueToDialect(value: string): Dialect {
<div class="divider"></div>
+ <div class="stanza">
+ <div class="eyebrow">Writing</div>
+ <p class="section-copy">
+ Choose how long Harper waits after text changes before checking it. Use 0 ms for
+ immediate checking.
+ </p>
+ <div class="inline-row">
+ <label for="debounce-ms">Debounce delay:</label>
+ <input
+ id="debounce-ms"
+ class="select"
+ type="number"
+ min="0"
+ step="50"
+ disabled={isDebounceLoading || isDebounceSaving}
+ value={debounceMsInput}
+ on:input={(event) => (debounceMsInput = event.currentTarget.value)}
+ on:change={saveDebounceMs}
+ />
+ <span>ms</span>
+ </div>
+ {#if isDebounceLoading}
+ <p class="result-summary">Loading debounce delay...</p>
+ {:else if debounceError}
+ <p class="result-summary">{debounceError}</p>
+ {:else if isDebounceSaving}
+ <p class="result-summary">Saving debounce delay...</p>
+ {/if}
+ </div>
+
+ <div class="divider"></div>
+
<div class="stanza">
<div class="eyebrow">Updates</div>
<div class="row top">
diff --git a/harper-desktop/src/lib/settings/pages/WritingPage.svelte b/harper-desktop/src/lib/settings/pages/WritingPage.svelte
index 161261b08..4ebab5319 100644
--- a/harper-desktop/src/lib/settings/pages/WritingPage.svelte
+++ b/harper-desktop/src/lib/settings/pages/WritingPage.svelte
@@ -1,66 +1,6 @@
-<script lang="ts">
-let strictness = 'standard';
-let liveCheck = true;
-let respectCode = true;
-</script>
-
<section>
<div class="stanza">
- <div class="eyebrow">Grammar checking</div>
- <p class="section-copy">
- Tune how assertive Harper is. Lower strictness surfaces fewer suggestions.
- </p>
- <div class="rows">
- <div class="inline-row">
- <label for="strictness">Strictness:</label>
- <select
- id="strictness"
- class="select"
- disabled
- title="Not wired yet"
- bind:value={strictness}
- >
- <option value="relaxed">Relaxed</option>
- <option value="standard">Standard</option>
- <option value="strict">Strict</option>
- </select>
- </div>
-
- <div class="row">
- <div>
- <strong>Check while I type</strong>
- <p>Suggestions appear as you write.</p>
- </div>
- <button
- class:checked={liveCheck}
- class="checkbox"
- type="button"
- role="checkbox"
- disabled
- title="Not wired yet"
- aria-checked={liveCheck}
- >
- {#if liveCheck}<span class="settings-icon icon-check" aria-hidden="true"></span>{/if}
- </button>
- </div>
-
- <div class="row top">
- <div>
- <strong>Respect code blocks and quotes</strong>
- <p>Harper skips fenced code, inline code, and block quotes when checking Markdown.</p>
- </div>
- <button
- class:checked={respectCode}
- class="checkbox"
- type="button"
- role="checkbox"
- disabled
- title="Not wired yet"
- aria-checked={respectCode}
- >
- {#if respectCode}<span class="settings-icon icon-check" aria-hidden="true"></span>{/if}
- </button>
- </div>
- </div>
+ <div class="eyebrow">Writing</div>
+ <p class="section-copy">Writing preferences are currently shown on the General page.</p>
</div>
</section>