Merge pull request #70 from deyak360/preselect-matching-aliases-66

Fix overlapping title/alias matching and fix alias pre-selection in UI

Author: AlexW00

src/rs/matching/link_finder.rs

@@ -77,6 +77,9 @@ fn build_link_finder(target_note: &Note) -> LinkFinder {
     let escaped_title = escape(&*target_note.title()).to_string();
     escaped_search_strings.push(escaped_title);
 
+    // Sort by length (desc) to prioritize longer matches when alternatives overlap
+    escaped_search_strings.sort_by(|a, b| b.len().cmp(&a.len()));
+    
     let regex_string = concat_as_regex_string(&escaped_search_strings);
     //log(&format!("Regex string: {}", regex_string));
 
@@ -101,14 +104,23 @@ fn find_link_matches(target_note: &Note, note_to_check: &mut Note) -> Option<Vec
 /// If the link match is already in the list, it is merged with the existing link match.
 /// If the link match is not in the list, it is added to the list.
 fn merge_link_match_into_link_matches(mut merged_link_matches: Vec<LinkMatch>, link_match: LinkMatch) -> Vec<LinkMatch> {
+    // Find an existing match that starts at the same character position
     let index = merged_link_matches.iter()
-        .position(|m: &LinkMatch| m.position().is_equal_to(&link_match.position()));
+        .position(|m: &LinkMatch| m.position().start() == link_match.position().start());
 
     if let Some(index) = index {
-        // merge it into the existing match, if the position is the same
-        merged_link_matches[index].merge_link_target_candidates(link_match);
+        // For same-start matches, prefer the one that covers more characters
+        if link_match.position().end() > merged_link_matches[index].position().end() {
+            // New match is longer: make it the primary span and pull in old candidates
+            let mut new_link_match = link_match;
+            new_link_match.merge_link_target_candidates(merged_link_matches[index].clone());
+            merged_link_matches[index] = new_link_match;
+        } else {
+            // Existing match is longer or equal: keep its span, just add new candidates
+            merged_link_matches[index].merge_link_target_candidates(link_match);
+        }
     } else {
-        // otherwise push a new match
+        // No same-start match yet: add as a new entry
         merged_link_matches.push(link_match);
     }
     merged_link_matches

src/rs/matching/link_match.rs

@@ -52,7 +52,7 @@ impl LinkMatch {
           target_note.title(),
           target_note.path(),
           target_note.aliases_vec(),
-            regex_match.capture_index
+            &regex_match.matched_text
         )];
         Self::new(
             regex_match.position.clone(),

src/rs/matching/link_target_candidate.rs

@@ -1,4 +1,5 @@
 use js_sys::Array;
+use std::collections::HashSet;
 use serde::{Deserialize, Serialize};
 use wasm_bindgen::prelude::*;
 
@@ -37,20 +38,49 @@ impl LinkTargetCandidate {
 }
 
 impl LinkTargetCandidate {
-    pub fn new(title: String, path: String, aliases: &[String], selected_index: usize) -> Self {
+    pub fn new(title: String, path: String, aliases: &[String], matched_text: &str) -> Self {
+        let mut seen_candidates: HashSet<String> = HashSet::new();
         let mut _replacement_candidates: Vec<PreferrableItem> = vec![];
-        let replacement_candidate_title = PreferrableItem::new(title.clone(), true);
-        _replacement_candidates.push(replacement_candidate_title);
-
-        aliases.iter().enumerate().for_each(|(index, alias)| {
-            let replacement_candidate_alias = PreferrableItem::new(
-                alias.clone(),
-                // add one because the index starts with the title at 0
-                true,
-            );
+
+        let mut case_sensitive_match_index: Option<usize> = None;
+        let mut case_insensitive_match_index: Option<usize> = None;
+
+        seen_candidates.insert(title.clone());
+        _replacement_candidates.push(PreferrableItem::new(title.clone(), false));
+        if title == matched_text {
+            case_sensitive_match_index = Some(0);
+        } else if title.eq_ignore_ascii_case(matched_text) {
+            case_insensitive_match_index = Some(0);
+        }
+
+        aliases.iter().for_each(|alias| {
+            if seen_candidates.contains(alias) {
+                return;
+            }
+
+            let candidate_index = _replacement_candidates.len();
+
+            if alias == matched_text && case_sensitive_match_index.is_none() {
+                case_sensitive_match_index = Some(candidate_index);
+            } else if alias.eq_ignore_ascii_case(matched_text)
+                && case_insensitive_match_index.is_none()
+            {
+                case_insensitive_match_index = Some(candidate_index);
+            }
+
+            seen_candidates.insert(alias.clone());
+            let replacement_candidate_alias = PreferrableItem::new(alias.clone(), false);
             _replacement_candidates.push(replacement_candidate_alias);
         });
 
+        let preferred_index = case_sensitive_match_index
+            .or(case_insensitive_match_index)
+            .unwrap_or(0);
+
+        if let Some(preferred_candidate) = _replacement_candidates.get_mut(preferred_index) {
+            preferred_candidate.is_preferred = true;
+        }
+
         LinkTargetCandidate {
             title,
             path,
@@ -65,4 +95,4 @@ pub fn link_target_candidate_vec_into_array(link_target_candidates: Vec<LinkTarg
         link_target_candidates_array.push(&link_target_candidate.into());
     }
     link_target_candidates_array
-}
+}