From 923cb9571cc0842cb2370681fcd8eb1d7af77a7b Mon Sep 17 00:00:00 2001 From: Yuri Karamian Date: Mon, 28 Sep 2026 21:06:28 +0200 Subject: [PATCH] Improve search and show save errors - Show search results in the right notebook or All Notes list - Scroll to the selected note and highlight matching text - Keep unsaved edits safe and ignore old or cancelled searches - Show save errors with a Retry button - Run graph and vault statistics scans in the background - Fix folder checks when counting vault files - Keep desktop window-close code out of mobile builds --- .gitlab-ci.yml | 41 ++++ package.json | 3 +- src-tauri/Cargo.lock | 2 +- src-tauri/Cargo.toml | 2 +- src-tauri/src/commands.rs | 213 ++++++++++++++++-- src-tauri/src/lib.rs | 1 + src-tauri/src/search/mod.rs | 222 ++++++++++++++++++- src-tauri/src/types.rs | 22 ++ src-tauri/tauri.conf.json | 2 +- src/lib/components/AppLayout.svelte | 97 +++++++-- src/lib/components/Editor.svelte | 273 +++++++++++++++++++++--- src/lib/components/NoteList.svelte | 31 ++- src/lib/components/NoteWindow.svelte | 29 +-- src/lib/components/SearchPanel.svelte | 19 +- src/lib/editor/search-target.ts | 109 ++++++++++ src/lib/editor/titleVisibility.ts | 22 +- src/lib/types.ts | 10 + src/lib/utils/note-list-window.test.mjs | 30 ++- src/lib/utils/note-list-window.ts | 16 ++ tests/search-target.test.mjs | 182 ++++++++++++++++ tests/title-visibility.test.mjs | 15 ++ 21 files changed, 1224 insertions(+), 117 deletions(-) create mode 100644 .gitlab-ci.yml create mode 100644 src/lib/editor/search-target.ts create mode 100644 tests/search-target.test.mjs diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml new file mode 100644 index 0000000..b1b455d --- /dev/null +++ b/.gitlab-ci.yml @@ -0,0 +1,41 @@ +workflow: + rules: + - if: '$CI_PIPELINE_SOURCE == "merge_request_event"' + - if: '$CI_PIPELINE_SOURCE == "push" && $CI_COMMIT_BRANCH && $CI_OPEN_MERGE_REQUESTS' + when: never + - if: '$CI_PIPELINE_SOURCE == "push" && $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH' + +verify: + stage: test + image: node:24-bookworm + rules: + - when: on_success + variables: + DEBIAN_FRONTEND: noninteractive + CARGO_HOME: "$CI_PROJECT_DIR/.cargo" + RUST_VERSION: "1.97.1" + cache: + key: + prefix: linux-verification + files: + - pnpm-lock.yaml + - src-tauri/Cargo.lock + paths: + - .pnpm-store/ + - .cargo/registry/ + - .cargo/git/ + before_script: + - apt-get update + - >- + apt-get install --yes --no-install-recommends + build-essential ca-certificates curl pkg-config + libgtk-3-dev libwebkit2gtk-4.1-dev libayatana-appindicator3-dev + libxdo-dev libssl-dev librsvg2-dev + - curl --proto '=https' --tlsv1.2 --fail --silent --show-error https://sh.rustup.rs --output /tmp/rustup-init.sh + - sh /tmp/rustup-init.sh -y --profile minimal --default-toolchain "$RUST_VERSION" --component rustfmt --component clippy + - export PATH="$CARGO_HOME/bin:$PATH" + - npm install --global "$(node -p "require('./package.json').packageManager")" + - pnpm install --frozen-lockfile --store-dir .pnpm-store + - cargo fetch --locked --manifest-path src-tauri/Cargo.toml + script: + - pnpm verify diff --git a/package.json b/package.json index e464afa..3e29c2d 100644 --- a/package.json +++ b/package.json @@ -2,8 +2,9 @@ "name": "helixnotes", "private": true, "license": "AGPL-3.0-or-later", - "version": "1.3.5", + "version": "1.3.6", "type": "module", + "packageManager": "pnpm@11.18.0", "scripts": { "dev": "vite dev", "build": "vite build", diff --git a/src-tauri/Cargo.lock b/src-tauri/Cargo.lock index ad0aaeb..7455b99 100644 --- a/src-tauri/Cargo.lock +++ b/src-tauri/Cargo.lock @@ -1776,7 +1776,7 @@ checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" [[package]] name = "helixnotes" -version = "1.3.5" +version = "1.3.6" dependencies = [ "aho-corasick", "arboard", diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml index 0eeebac..e3700fc 100644 --- a/src-tauri/Cargo.toml +++ b/src-tauri/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "helixnotes" -version = "1.3.5" +version = "1.3.6" description = "Local markdown note-taking app" authors = ["HelixNotes"] license = "AGPL-3.0-or-later" diff --git a/src-tauri/src/commands.rs b/src-tauri/src/commands.rs index f714be6..6f020e4 100644 --- a/src-tauri/src/commands.rs +++ b/src-tauri/src/commands.rs @@ -366,21 +366,19 @@ pub fn get_pending_open_file(state: State<'_, AppState>) -> Result( window: tauri::Window, state: State<'_, AppState>, ) -> Result<(), String> { - #[cfg(desktop)] if state.should_hide_to_tray( window.label(), window.app_handle().tray_by_id("helixnotes").is_some(), )? { return window.hide().map_err(|error| error.to_string()); } - #[cfg(mobile)] - let _ = state; window.destroy().map_err(|error| error.to_string()) } @@ -996,14 +994,19 @@ pub async fn get_note_switcher_titles( // ── Graph ── #[tauri::command] -pub fn get_graph_data( +pub async fn get_graph_data( state: State<'_, AppState>, vault_path: String, ) -> Result { + state.validate_vault(&vault_path)?; + tauri::async_runtime::spawn_blocking(move || scan_graph_data(&vault_path)) + .await + .map_err(|error| error.to_string())? +} + +fn scan_graph_data(vault_path: &str) -> Result { use std::collections::{HashMap, HashSet}; - state.validate_vault(&vault_path)?; - let vault_path = vault_path.as_str(); let vault = std::path::Path::new(vault_path); // Pass 1: collect ALL notes as nodes (no title deduplication - every note must appear) @@ -2114,22 +2117,50 @@ pub async fn reorder_quick_access( } #[tauri::command] -pub fn get_vault_stats(state: State<'_, AppState>) -> Result { - use rayon::prelude::*; - let config = state.config.lock().map_err(|e| e.to_string())?; - let vault_path = config.active_vault.as_ref().ok_or("No active vault")?; +pub async fn get_vault_stats(state: State<'_, AppState>) -> Result { + let vault_path = state + .config + .lock() + .map_err(|error| error.to_string())? + .active_vault + .clone() + .ok_or("No active vault")?; + tauri::async_runtime::spawn_blocking(move || scan_vault_stats(&vault_path)) + .await + .map_err(|error| error.to_string())? +} - let paths: Vec = walkdir::WalkDir::new(vault_path) +fn scan_vault_stats(vault_path: &str) -> Result { + use rayon::prelude::*; + let vault = Path::new(vault_path); + + let paths: Vec = walkdir::WalkDir::new(vault) .into_iter() + .filter_entry(|entry| { + if entry.depth() == 0 { + return true; + } + let Ok(relative) = entry.path().strip_prefix(vault) else { + return false; + }; + let is_directory = entry.file_type().is_dir(); + if is_directory && entry.file_name() == ".trash" { + return false; + } + // Prune metadata children except the attachments directory. Inspect + // only vault-relative components, never names in the vault's parent. + if relative + .parent() + .and_then(Path::file_name) + .is_some_and(|name| name == ".helixnotes") + { + return is_directory && entry.file_name() == "attachments"; + } + true + }) .filter_map(|e| e.ok()) .filter(|e| e.file_type().is_file()) .map(|e| e.into_path()) - .filter(|p| { - // attachments under .helixnotes count; nothing else in .helixnotes or .trash does - let s = p.to_string_lossy(); - (!s.contains("/.helixnotes/") || s.contains("/.helixnotes/attachments/")) - && !s.contains("/.trash/") - }) .collect(); // Stat files in parallel; each metadata() is a FUSE round-trip on Android. @@ -2157,6 +2188,150 @@ pub fn get_vault_stats(state: State<'_, AppState>) -> Result }) } +#[cfg(test)] +mod vault_stats_tests { + use super::scan_vault_stats; + use std::path::Path; + + fn write_fixture(vault: &Path, files: &[(&[&str], &[u8])]) { + for (components, contents) in files { + let mut path = vault.to_path_buf(); + for component in *components { + path.push(component); + } + std::fs::create_dir_all(path.parent().unwrap()).unwrap(); + std::fs::write(path, contents).unwrap(); + } + } + + fn assert_stats(vault: &Path, expected: (u64, u64, u64, u64, u64)) { + let stats = scan_vault_stats(vault.to_str().unwrap()).unwrap(); + assert_eq!( + ( + stats.total_notes, + stats.total_attachments, + stats.notes_size, + stats.attachments_size, + stats.total_size, + ), + expected, + "vault: {}", + vault.display() + ); + } + + #[test] + fn vault_stats_preserve_file_classification_and_byte_totals() { + let vault = tempfile::tempdir().unwrap(); + write_fixture( + vault.path(), + &[ + (&["Note.md"], b"note"), + (&["Notebook", "Note.md"], "café".as_bytes()), + (&["Empty.md"], b""), + (&["Upper.MD"], b"upper"), + (&["Notebook", "data.bin"], b"\0\x01\xff"), + (&["README"], b"plain"), + ], + ); + + assert_stats(vault.path(), (3, 3, 9, 13, 22)); + } + + #[test] + fn vault_stats_include_only_attachment_subtrees_inside_metadata() { + let vault = tempfile::tempdir().unwrap(); + write_fixture( + vault.path(), + &[ + (&[".helixnotes", "attachments", "image.png"], b"123"), + (&[".helixnotes", "attachments", "Manual.md"], b"1234"), + ( + &[".helixnotes", "attachments", "Nested", "icon.svg"], + b"12345", + ), + ( + &[".helixnotes", "attachments", ".trash-backup", "backup.bin"], + b"123456", + ), + (&[".helixnotes", "settings.json"], b"excluded"), + (&[".helixnotes", "history", "Snapshot.md"], b"excluded"), + (&[".helixnotes", "trash", "Deleted.md"], b"excluded"), + (&[".helixnotes", "attachments-old", "old.png"], b"excluded"), + ( + &[".helixnotes", "attachments", ".trash", "deleted.png"], + b"excluded", + ), + ], + ); + + assert_stats(vault.path(), (1, 3, 4, 14, 18)); + } + + #[test] + fn vault_stats_match_exact_directory_boundaries() { + let vault = tempfile::tempdir().unwrap(); + write_fixture( + vault.path(), + &[ + (&[".trash-backup", "Note.md"], b"1"), + (&[".helixnotes-backup", "Note.md"], b"12"), + (&["attachments-old", "Note.md"], b"123"), + (&["Work.notebook", "attachments-old", "Note.md"], b"1234"), + (&["Work.notebook", ".trash-backup", "picture.png"], b"12345"), + (&["Files", ".trash"], b"123456"), + (&["Files", ".helixnotes"], b"1234567"), + ( + &["Work.notebook", ".helixnotes", "attachments", "photo.png"], + b"12345678", + ), + (&[".trash", "Deleted.md"], b"excluded"), + (&["Work.notebook", ".trash", "deleted.png"], b"excluded"), + ( + &["Work.notebook", ".helixnotes", "history", "Snapshot.md"], + b"excluded", + ), + ( + &["Work.notebook", ".helixnotes", "attachments-old", "old.png"], + b"excluded", + ), + ], + ); + + assert_stats(vault.path(), (4, 4, 10, 26, 36)); + } + + #[test] + fn vault_stats_ignore_excluded_names_outside_the_vault() { + let locations: &[&[&str]] = &[ + &[".trash", "vault"], + &[".helixnotes", "history", "vault"], + &[".helixnotes", "attachments-old", "vault"], + &[".trash"], + &[".helixnotes"], + ]; + for components in locations { + let root = tempfile::tempdir().unwrap(); + let mut vault = root.path().to_path_buf(); + for component in *components { + vault.push(component); + } + write_fixture( + &vault, + &[ + (&["Note.md"], b"hello"), + (&["Notebook", "photo.png"], b"123"), + (&[".helixnotes", "attachments", "photo.png"], b"12"), + (&[".helixnotes", "history", "Snapshot.md"], b"excluded"), + (&[".trash", "Deleted.md"], b"excluded"), + ], + ); + + assert_stats(&vault, (1, 2, 5, 5, 10)); + } + } +} + #[tauri::command] pub fn import_obsidian(app: AppHandle) -> Result<(), String> { let vault_path = { @@ -3840,7 +4015,7 @@ mod mutation_order_tests { .collect::>(), ["Alpha"] ); - let graph = get_graph_data(app.state(), a.clone()).unwrap(); + let graph = get_graph_data(app.state(), a.clone()).await.unwrap(); assert_eq!( graph .nodes diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs index dfa14d1..a60a50d 100644 --- a/src-tauri/src/lib.rs +++ b/src-tauri/src/lib.rs @@ -162,6 +162,7 @@ pub fn run() { commands::restore_external_vault, commands::remove_vault, commands::get_app_config, + #[cfg(desktop)] commands::complete_window_close, commands::set_theme, commands::set_system_themes, diff --git a/src-tauri/src/search/mod.rs b/src-tauri/src/search/mod.rs index d553f2c..d582064 100644 --- a/src-tauri/src/search/mod.rs +++ b/src-tauri/src/search/mod.rs @@ -1,4 +1,4 @@ -use crate::types::{SearchMatch, SearchPage, SearchResult}; +use crate::types::{SearchMatch, SearchPage, SearchResult, SearchTarget, SearchTargetField}; use crate::vault::frontmatter; use crate::vault::operations::helixnotes_dir; use parking_lot::{Condvar, Mutex}; @@ -29,6 +29,7 @@ const INDEX_BATCH_DELAY: Duration = Duration::from_millis(300); const MAX_PAGE_SIZE: usize = 100; const SNIPPET_CHARS: usize = 240; const SNIPPET_LEADING_CHARS: usize = 80; +const TARGET_CONTEXT_CHARS: usize = 32; /// Per-vault search index dir in local app-data, kept out of the (possibly synced) vault. #[cfg(desktop)] @@ -198,7 +199,7 @@ fn utf16_matches(text: &str, mut matches: Vec, prefix: usize) -> Ve matches } -fn title_matches( +fn title_byte_matches( title: &str, terms: &[SearchTerm], analyzer: &mut TextAnalyzer, @@ -211,14 +212,69 @@ fn title_matches( push_match(&mut matches, token.offset_from, token.offset_to); } } - utf16_matches(title, matches, 0) + matches +} + +fn first_tag_match( + tags: &str, + terms: &[SearchTerm], + analyzer: &mut TextAnalyzer, +) -> Option { + let mut first: Option = None; + let mut stream = analyzer.token_stream(tags); + while stream.advance() { + let token = stream.token(); + if first + .as_ref() + .is_some_and(|range| token.offset_from > range.end) + { + break; + } + if terms.iter().any(|term| term.matches(&token.text)) { + if let Some(range) = &mut first { + range.end = range.end.max(token.offset_to); + } else { + first = Some(SearchMatch { + start: token.offset_from, + end: token.offset_to, + }); + } + } + } + first +} + +fn match_target(text: &str, field: SearchTargetField, start: usize, end: usize) -> SearchTarget { + let end = text[start..end] + .char_indices() + .nth(SNIPPET_CHARS) + .map_or(end, |(offset, _)| start + offset); + let before = text[..start] + .char_indices() + .rev() + .nth(TARGET_CONTEXT_CHARS - 1) + .map_or(0, |(offset, _)| offset); + let after = text[end..] + .char_indices() + .nth(TARGET_CONTEXT_CHARS) + .map_or(text.len(), |(offset, _)| end + offset); + let matched = &text[start..end]; + let utf16_start = text[..start].encode_utf16().count(); + SearchTarget { + field, + start: utf16_start, + end: utf16_start + matched.encode_utf16().count(), + text: matched.to_owned(), + before: text[before..start].to_owned(), + after: text[end..after].to_owned(), + } } fn body_snippet( body: &str, terms: &[SearchTerm], analyzer: &mut TextAnalyzer, -) -> (String, Vec) { +) -> (String, Vec, Option) { let mut stream = analyzer.token_stream(body); let mut start = 0; let mut end = body @@ -253,6 +309,14 @@ fn body_snippet( token.offset_to.min(end) - start, ); } + let target = matches.first().map(|range| { + match_target( + body, + SearchTargetField::Body, + start + range.start, + start + range.end, + ) + }); let context = &body[start..end]; let prefix = usize::from(start > 0); let matches = utf16_matches(context, matches, prefix); @@ -264,7 +328,7 @@ fn body_snippet( if end < body.len() { snippet.push('…'); } - (snippet, matches) + (snippet, matches, target) } #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -886,8 +950,21 @@ impl SearchIndex { .get_first(self.body_field) .and_then(|v| v.as_str()) .unwrap_or(""); - let title_matches = title_matches(title, &terms, &mut analyzer); - let (snippet, snippet_matches) = body_snippet(body, &terms, &mut analyzer); + let title_ranges = title_byte_matches(title, &terms, &mut analyzer); + let (snippet, snippet_matches, body_target) = body_snippet(body, &terms, &mut analyzer); + let match_target = body_target + .or_else(|| { + title_ranges.first().map(|range| { + match_target(title, SearchTargetField::Title, range.start, range.end) + }) + }) + .or_else(|| { + let tags = doc.get_first(self.tags_field).and_then(|v| v.as_str())?; + first_tag_match(tags, &terms, &mut analyzer).map(|range| { + match_target(tags, SearchTargetField::Tags, range.start, range.end) + }) + }); + let title_matches = utf16_matches(title, title_ranges, 0); results.push(SearchResult { path: path.to_owned(), title: title.to_owned(), @@ -895,6 +972,7 @@ impl SearchIndex { score, title_matches, snippet_matches, + match_target, }); } Ok(SearchPage { results, total }) @@ -967,6 +1045,36 @@ mod tests { .collect() } + fn assert_target<'a>( + result: &'a SearchResult, + source: &str, + field: SearchTargetField, + matched: &str, + ) -> &'a SearchTarget { + let target = result.match_target.as_ref().unwrap(); + assert_eq!(target.field, field); + assert_eq!(target.text, matched); + assert!(target.text.chars().count() <= SNIPPET_CHARS); + let utf16: Vec<_> = source.encode_utf16().collect(); + assert_eq!( + String::from_utf16(&utf16[target.start..target.end]).unwrap(), + matched + ); + let before = String::from_utf16(&utf16[..target.start]).unwrap(); + let after = String::from_utf16(&utf16[target.end..]).unwrap(); + assert!(before.ends_with(&target.before)); + assert!(after.starts_with(&target.after)); + assert_eq!( + target.before.chars().count(), + before.chars().count().min(TARGET_CONTEXT_CHARS) + ); + assert_eq!( + target.after.chars().count(), + after.chars().count().min(TARGET_CONTEXT_CHARS) + ); + target + } + #[test] fn exact_and_title_matches_outrank_prefix_and_typo_body_matches() { let vault = TestVault::new(); @@ -1126,6 +1234,11 @@ mod tests { vec!["Café", "東京"] ); assert_eq!(result.title_matches[0], SearchMatch { start: 3, end: 7 }); + let target = assert_target(&result, &body, SearchTargetField::Body, "Café"); + assert_eq!( + target.start, + body[..body.find("Café").unwrap()].encode_utf16().count() + ); // Prefixes highlight the actual matched indexed token, not an invented // exact substring; overlapping CJK uni/bigrams become one range. let prefix = index.search("straw", 20, 0).unwrap().results.remove(0); @@ -1133,11 +1246,15 @@ mod tests { highlighted(&prefix.snippet, &prefix.snippet_matches), vec!["strawberry"] ); + assert_target(&prefix, &body, SearchTargetField::Body, "strawberry"); + let fuzzy = index.search("strawberyr", 20, 0).unwrap().results.remove(0); + assert_target(&fuzzy, &body, SearchTargetField::Body, "strawberry"); let cjk = index.search("東京大学", 20, 0).unwrap().results.remove(0); assert_eq!( highlighted(&cjk.snippet, &cjk.snippet_matches), vec!["東京大学"] ); + assert_target(&cjk, &body, SearchTargetField::Body, "東京大学"); } #[test] @@ -1163,20 +1280,99 @@ mod tests { unicode.title_matches, vec![SearchMatch { start: 3, end: 11 }] ); + let target = assert_target(&unicode, "🦊 İSTANBUL", SearchTargetField::Body, "İSTANBUL"); + assert_eq!((target.start, target.end), (3, 11)); let long = index.search("prefix", 20, 0).unwrap().results.remove(0); assert_eq!(long.snippet.chars().count(), SNIPPET_CHARS + 1); assert_eq!( highlighted(&long.snippet, &long.snippet_matches), vec![long_word[..SNIPPET_CHARS].to_owned()] ); + assert_target( + &long, + &long_word, + SearchTargetField::Body, + &long_word[..SNIPPET_CHARS], + ); for query in ["heading", "watermelon"] { let result = index.search(query, 20, 0).unwrap().results.remove(0); assert_eq!(result.path, tagged.to_str().unwrap()); assert_eq!(result.snippet, "Plain body without the requested token."); assert!(result.snippet_matches.is_empty()); + let (field, text) = if query == "heading" { + (SearchTargetField::Title, "Heading") + } else { + (SearchTargetField::Tags, "watermelon") + }; + assert_target(&result, text, field, text); } } + #[test] + fn targets_prefer_first_body_then_title_then_stored_tags() { + let vault = TestVault::new(); + let title = "🦊 Watermelon Strawberry"; + let body = "quiet 🦊 STRAWBERRY strawberry"; + let tags = "watermelon pineapple strawberry 東京大学"; + fs::write( + vault.0.join("priority.md"), + format!( + "---\ntitle: '{title}'\ntags: [watermelon, pineapple, strawberry, 東京大学]\n---\n{body}" + ), + ) + .unwrap(); + let index = vault.index(); + index.rebuild(vault.0.to_str().unwrap()).unwrap(); + let body_hit = index.search("straw", 20, 0).unwrap().results.remove(0); + let target = assert_target(&body_hit, body, SearchTargetField::Body, "STRAWBERRY"); + assert_eq!((target.start, target.end), (9, 19)); + let title_hit = index.search("watermelno", 20, 0).unwrap().results.remove(0); + let target = assert_target(&title_hit, title, SearchTargetField::Title, "Watermelon"); + assert_eq!((target.start, target.end), (3, 13)); + let tags_hit = index.search("pineap", 20, 0).unwrap().results.remove(0); + let target = assert_target(&tags_hit, tags, SearchTargetField::Tags, "pineapple"); + assert_eq!((target.start, target.end), (11, 20)); + let cjk_tags = index.search("東京大学", 20, 0).unwrap().results.remove(0); + assert_target(&cjk_tags, tags, SearchTargetField::Tags, "東京大学"); + } + + #[test] + fn title_and_tag_targets_bound_unicode_text_and_context() { + let vault = TestVault::new(); + let long_title = format!("heading{}", "é".repeat(300)); + let long_tag = format!("category{}", "é".repeat(300)); + let title = format!("{} {long_title} {}", "🦊".repeat(40), "🌊".repeat(40)); + let tags = format!( + "{} {long_tag} {} pineapple {}", + "🦊".repeat(40), + "🌊".repeat(40), + "🚀".repeat(40) + ); + fs::write( + vault.0.join("bounded.md"), + format!("---\ntitle: '{title}'\ntags: ['{tags}']\n---\nPlain content."), + ) + .unwrap(); + let index = vault.index(); + index.rebuild(vault.0.to_str().unwrap()).unwrap(); + for (query, source, field, word) in [ + ("head", &title, SearchTargetField::Title, &long_title), + ("categ", &tags, SearchTargetField::Tags, &long_tag), + ] { + let result = index.search(query, 20, 0).unwrap().results.remove(0); + let matched: String = word.chars().take(SNIPPET_CHARS).collect(); + let target = assert_target(&result, source, field, &matched); + assert_eq!(target.start, 81); + assert_eq!(target.end, 81 + SNIPPET_CHARS); + assert_eq!(target.before, format!("{} ", "🦊".repeat(31))); + assert_eq!(target.after, "é".repeat(TARGET_CONTEXT_CHARS)); + } + let result = index.search("pineap", 20, 0).unwrap().results.remove(0); + let target = assert_target(&result, &tags, SearchTargetField::Tags, "pineapple"); + assert_eq!(target.before, format!("{} ", "🌊".repeat(31))); + assert_eq!(target.after, format!(" {}", "🚀".repeat(31))); + } + #[test] fn stored_snippets_survive_reopen_and_refresh_without_reading_result_files() { let vault = TestVault::new(); @@ -1197,6 +1393,12 @@ mod tests { highlighted(&cached.snippet, &cached.snippet_matches), vec!["pineapple"] ); + assert_target( + &cached, + "🦊 pineapple context", + SearchTargetField::Body, + "pineapple", + ); write_search_note( &vault, "cached.md", @@ -1211,6 +1413,12 @@ mod tests { highlighted(&refreshed.snippet, &refreshed.snippet_matches), vec!["watermelon"] ); + assert_target( + &refreshed, + "🦊 watermelon changed context", + SearchTargetField::Body, + "watermelon", + ); index.refresh_vault(vault.0.to_str().unwrap()).unwrap(); assert_eq!(index.search("watermelno", 20, 0).unwrap().total, 1); } diff --git a/src-tauri/src/types.rs b/src-tauri/src/types.rs index fa42eab..36636af 100644 --- a/src-tauri/src/types.rs +++ b/src-tauri/src/types.rs @@ -457,6 +457,27 @@ pub struct SearchMatch { pub end: usize, } +#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)] +#[serde(rename_all = "lowercase")] +pub enum SearchTargetField { + Body, + Title, + Tags, +} + +/// Half-open UTF-16 offsets into the indexed field, with exact source context. +/// Body excludes frontmatter; tags use the indexed space-joined values. +/// Text is capped at 240 Unicode scalars and each context at 32 scalars. +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +pub struct SearchTarget { + pub field: SearchTargetField, + pub start: usize, + pub end: usize, + pub text: String, + pub before: String, + pub after: String, +} + #[derive(Debug, Clone, Serialize, Deserialize)] pub struct SearchResult { pub path: String, @@ -465,6 +486,7 @@ pub struct SearchResult { pub score: f32, pub title_matches: Vec, pub snippet_matches: Vec, + pub match_target: Option, } #[derive(Debug, Clone, Serialize, Deserialize, Default)] diff --git a/src-tauri/tauri.conf.json b/src-tauri/tauri.conf.json index 2fa3a4d..04f7987 100644 --- a/src-tauri/tauri.conf.json +++ b/src-tauri/tauri.conf.json @@ -1,7 +1,7 @@ { "$schema": "../node_modules/@tauri-apps/cli/config.schema.json", "productName": "HelixNotes", - "version": "1.3.5", + "version": "1.3.6", "identifier": "com.helixnotes.app", "build": { "frontendDist": "../build", diff --git a/src/lib/components/AppLayout.svelte b/src/lib/components/AppLayout.svelte index 24fcbe7..f2e678c 100644 --- a/src/lib/components/AppLayout.svelte +++ b/src/lib/components/AppLayout.svelte @@ -1,5 +1,5 @@