1#![forbid(unsafe_code)]
2
3pub mod scorer;
37
38#[cfg(feature = "experimental")]
39pub use scorer::ConformalRanker;
40pub use scorer::{
41 BayesianScorer, EvidenceKind, EvidenceLedger, IncrementalScorer, IncrementalStats, MatchResult,
42 MatchType, RankConfidence, RankStability, RankedItem, RankedResults, RankingSummary,
43};
44
45use ftui_core::event::{Event, KeyCode, KeyEvent, KeyEventKind, Modifiers};
46use ftui_core::geometry::Rect;
47use ftui_render::cell::{Cell, CellAttrs, CellContent, PackedRgba, StyleFlags as CellStyleFlags};
48use ftui_render::frame::Frame;
49use ftui_style::Style;
50use ftui_text::{display_width, grapheme_width, graphemes};
51
52use crate::Widget;
53use crate::adaptive_radix::AdaptiveRadixTree;
54
55#[cfg(feature = "tracing")]
56use tracing::{debug, info};
57#[cfg(feature = "tracing")]
58use web_time::Instant;
59
60#[cfg(feature = "tracing")]
61const TELEMETRY_TARGET: &str = "ftui_widgets::command_palette";
62
63#[cfg(feature = "tracing")]
64fn emit_palette_opened(action_count: usize, result_count: usize) {
65 info!(
66 target: TELEMETRY_TARGET,
67 event = "palette_opened",
68 action_count,
69 result_count
70 );
71}
72
73#[cfg(feature = "tracing")]
74fn emit_palette_query_updated(query: &str, match_count: usize, latency_ms: u128) {
75 info!(
76 target: TELEMETRY_TARGET,
77 event = "palette_query_updated",
78 query_len = query.len(),
79 match_count,
80 latency_ms
81 );
82 if tracing::enabled!(target: TELEMETRY_TARGET, tracing::Level::DEBUG) {
83 debug!(
84 target: TELEMETRY_TARGET,
85 event = "palette_query_text",
86 query
87 );
88 }
89}
90
91#[cfg(feature = "tracing")]
92fn emit_palette_action_executed(action_id: &str, latency_ms: Option<u128>) {
93 if let Some(latency_ms) = latency_ms {
94 info!(
95 target: TELEMETRY_TARGET,
96 event = "palette_action_executed",
97 action_id,
98 latency_ms
99 );
100 } else {
101 info!(
102 target: TELEMETRY_TARGET,
103 event = "palette_action_executed",
104 action_id
105 );
106 }
107}
108
109#[cfg(feature = "tracing")]
110fn emit_palette_closed(reason: PaletteCloseReason) {
111 info!(
112 target: TELEMETRY_TARGET,
113 event = "palette_closed",
114 reason = reason.as_str()
115 );
116}
117
118#[derive(Debug, Clone)]
124pub struct ActionItem {
125 pub id: String,
127 pub title: String,
129 pub description: Option<String>,
131 pub tags: Vec<String>,
133 pub category: Option<String>,
135}
136
137impl ActionItem {
138 pub fn new(id: impl Into<String>, title: impl Into<String>) -> Self {
140 Self {
141 id: id.into(),
142 title: title.into(),
143 description: None,
144 tags: Vec::new(),
145 category: None,
146 }
147 }
148
149 #[must_use]
151 pub fn with_description(mut self, desc: impl Into<String>) -> Self {
152 self.description = Some(desc.into());
153 self
154 }
155
156 #[must_use]
158 pub fn with_tags(mut self, tags: &[&str]) -> Self {
159 self.tags = tags.iter().map(|s| (*s).to_string()).collect();
160 self
161 }
162
163 #[must_use]
165 pub fn with_category(mut self, cat: impl Into<String>) -> Self {
166 self.category = Some(cat.into());
167 self
168 }
169}
170
171#[derive(Debug, Clone, PartialEq, Eq)]
177pub enum PaletteAction {
178 Execute(String),
180 Dismiss,
182}
183
184#[derive(Debug, Clone, Copy, PartialEq, Eq)]
185enum PaletteCloseReason {
186 Dismiss,
187 Execute,
188 Toggle,
189 Programmatic,
190}
191
192impl PaletteCloseReason {
193 #[cfg(feature = "tracing")]
194 const fn as_str(self) -> &'static str {
195 match self {
196 Self::Dismiss => "dismiss",
197 Self::Execute => "execute",
198 Self::Toggle => "toggle",
199 Self::Programmatic => "programmatic",
200 }
201 }
202}
203
204fn compute_word_starts(title_lower: &str) -> Vec<usize> {
205 let bytes = title_lower.as_bytes();
206 title_lower
207 .char_indices()
208 .filter_map(|(i, _)| {
209 let is_word_start = i == 0 || {
210 let prev = bytes.get(i.saturating_sub(1)).copied().unwrap_or(b' ');
211 prev == b' ' || prev == b'-' || prev == b'_'
212 };
213 is_word_start.then_some(i)
214 })
215 .collect()
216}
217
218#[derive(Debug, Clone)]
224pub struct PaletteStyle {
225 pub border: Style,
227 pub input: Style,
229 pub item: Style,
231 pub item_selected: Style,
233 pub match_highlight: Style,
235 pub description: Style,
237 pub category: Style,
239 pub hint: Style,
241}
242
243impl Default for PaletteStyle {
244 fn default() -> Self {
245 Self {
251 border: Style::new().fg(PackedRgba::rgb(100, 100, 120)),
252 input: Style::new().fg(PackedRgba::rgb(220, 220, 230)),
253 item: Style::new().fg(PackedRgba::rgb(190, 190, 200)),
254 item_selected: Style::new()
255 .fg(PackedRgba::rgb(255, 255, 255))
256 .bg(PackedRgba::rgb(50, 50, 75)),
257 match_highlight: Style::new().fg(PackedRgba::rgb(255, 210, 60)),
258 description: Style::new().fg(PackedRgba::rgb(140, 140, 160)),
259 category: Style::new().fg(PackedRgba::rgb(100, 180, 255)),
260 hint: Style::new().fg(PackedRgba::rgb(100, 100, 120)),
261 }
262 }
263}
264
265#[derive(Debug)]
271struct ScoredItem {
272 action_index: usize,
274 result: MatchResult,
276}
277
278#[derive(Debug, Clone, Copy)]
284pub struct PaletteMatch<'a> {
285 pub action: &'a ActionItem,
287 pub result: &'a MatchResult,
289}
290
291#[derive(Debug, Clone, Copy, PartialEq, Eq)]
297pub enum MatchFilter {
298 All,
300 Exact,
302 Prefix,
304 WordStart,
306 Substring,
308 Fuzzy,
310}
311
312impl MatchFilter {
313 fn allows(self, match_type: MatchType) -> bool {
314 matches!(
315 (self, match_type),
316 (Self::All, _)
317 | (Self::Exact, MatchType::Exact)
318 | (Self::Prefix, MatchType::Prefix)
319 | (Self::WordStart, MatchType::WordStart)
320 | (Self::Substring, MatchType::Substring)
321 | (Self::Fuzzy, MatchType::Fuzzy)
322 )
323 }
324}
325
326#[derive(Debug)]
342pub struct CommandPalette {
343 actions: Vec<ActionItem>,
345 titles_cache: Vec<String>,
347 titles_lower: Vec<String>,
349 titles_word_starts: Vec<Vec<usize>>,
351 prefix_index: AdaptiveRadixTree<usize>,
353 query: String,
355 cursor: usize,
357 selected: usize,
359 scroll_offset: usize,
361 visible: bool,
363 style: PaletteStyle,
365 scorer: IncrementalScorer,
367 filtered: Vec<ScoredItem>,
369 match_filter: MatchFilter,
371 generation: u64,
373 max_visible: usize,
375 title: String,
377 fill_area: bool,
380 #[cfg(feature = "tracing")]
382 opened_at: Option<Instant>,
383}
384
385impl Default for CommandPalette {
386 fn default() -> Self {
387 Self::new()
388 }
389}
390
391impl CommandPalette {
392 pub fn new() -> Self {
394 Self {
395 actions: Vec::new(),
396 titles_cache: Vec::new(),
397 titles_lower: Vec::new(),
398 titles_word_starts: Vec::new(),
399 prefix_index: AdaptiveRadixTree::new(),
400 query: String::new(),
401 cursor: 0,
402 selected: 0,
403 scroll_offset: 0,
404 visible: false,
405 style: PaletteStyle::default(),
406 scorer: IncrementalScorer::new(),
407 filtered: Vec::new(),
408 match_filter: MatchFilter::All,
409 generation: 0,
410 max_visible: 10,
411 title: " Command Palette ".to_string(),
412 fill_area: false,
413 #[cfg(feature = "tracing")]
414 opened_at: None,
415 }
416 }
417
418 #[must_use]
420 pub fn with_style(mut self, style: PaletteStyle) -> Self {
421 self.style = style;
422 self
423 }
424
425 pub fn set_style(&mut self, style: PaletteStyle) {
427 self.style = style;
428 }
429
430 #[must_use]
432 pub fn with_max_visible(mut self, n: usize) -> Self {
433 self.max_visible = n;
434 self
435 }
436
437 #[must_use]
442 pub fn with_title(mut self, title: impl Into<String>) -> Self {
443 self.title = title.into();
444 self
445 }
446
447 pub fn set_title(&mut self, title: impl Into<String>) {
449 self.title = title.into();
450 }
451
452 #[must_use]
460 pub fn with_fill_area(mut self, fill: bool) -> Self {
461 self.fill_area = fill;
462 self
463 }
464
465 pub fn set_fill_area(&mut self, fill: bool) {
467 self.fill_area = fill;
468 }
469
470 pub fn enable_evidence_tracking(&mut self, enabled: bool) {
472 self.scorer = if enabled {
473 IncrementalScorer::with_scorer(BayesianScorer::new())
474 } else {
475 IncrementalScorer::new()
476 };
477 self.update_filtered(false);
478 }
479
480 fn push_title_cache_into(
483 titles_cache: &mut Vec<String>,
484 titles_lower: &mut Vec<String>,
485 titles_word_starts: &mut Vec<Vec<usize>>,
486 title: &str,
487 ) {
488 titles_cache.push(title.to_string());
489 let lower = title.to_lowercase();
490 titles_word_starts.push(compute_word_starts(&lower));
491 titles_lower.push(lower);
492 }
493
494 fn push_title_cache(&mut self, title: &str) {
495 Self::push_title_cache_into(
496 &mut self.titles_cache,
497 &mut self.titles_lower,
498 &mut self.titles_word_starts,
499 title,
500 );
501 }
502
503 fn prefix_index_key(title_lower: &str, action_index: usize) -> String {
504 format!("{title_lower}\u{1f}{action_index:020}")
505 }
506
507 fn insert_prefix_index_entry(&mut self, action_index: usize) {
508 let key = self
509 .titles_lower
510 .get(action_index)
511 .map(|title_lower| Self::prefix_index_key(title_lower, action_index));
512 if let Some(key) = key {
513 self.prefix_index.insert(&key, action_index);
514 }
515 }
516
517 fn rebuild_prefix_index(&mut self) {
518 let mut prefix_index = AdaptiveRadixTree::new();
519 for (action_index, title_lower) in self.titles_lower.iter().enumerate() {
520 let key = Self::prefix_index_key(title_lower, action_index);
521 prefix_index.insert(&key, action_index);
522 }
523 self.prefix_index = prefix_index;
524 }
525
526 fn rebuild_title_cache(&mut self) {
527 self.titles_cache.clear();
528 self.titles_lower.clear();
529 self.titles_word_starts.clear();
530
531 self.titles_cache.reserve(self.actions.len());
532 self.titles_lower.reserve(self.actions.len());
533 self.titles_word_starts.reserve(self.actions.len());
534
535 let titles_cache = &mut self.titles_cache;
536 let titles_lower = &mut self.titles_lower;
537 let titles_word_starts = &mut self.titles_word_starts;
538 for action in &self.actions {
539 Self::push_title_cache_into(
540 titles_cache,
541 titles_lower,
542 titles_word_starts,
543 &action.title,
544 );
545 }
546 }
547
548 fn rebuild_search_cache(&mut self) {
549 self.rebuild_title_cache();
550 self.rebuild_prefix_index();
551 }
552
553 pub fn register(
555 &mut self,
556 title: impl Into<String>,
557 description: Option<&str>,
558 tags: &[&str],
559 ) -> &mut Self {
560 let title = title.into();
561 let id = title.to_lowercase().replace(' ', "_");
562 let mut item = ActionItem::new(id, title);
563 if let Some(desc) = description {
564 item.description = Some(desc.to_string());
565 }
566 item.tags = tags.iter().map(|s| (*s).to_string()).collect();
567 let action_index = self.actions.len();
568 self.push_title_cache(&item.title);
569 self.insert_prefix_index_entry(action_index);
570 self.actions.push(item);
571 self.generation = self.generation.wrapping_add(1);
572 self.refresh_filtered_after_action_change();
573 self
574 }
575
576 pub fn register_action(&mut self, action: ActionItem) -> &mut Self {
578 let action_index = self.actions.len();
579 self.push_title_cache(&action.title);
580 self.insert_prefix_index_entry(action_index);
581 self.actions.push(action);
582 self.generation = self.generation.wrapping_add(1);
583 self.refresh_filtered_after_action_change();
584 self
585 }
586
587 pub fn replace_actions(&mut self, actions: Vec<ActionItem>) {
591 self.actions = actions;
592 self.rebuild_search_cache();
593 self.generation = self.generation.wrapping_add(1);
594 self.scorer.invalidate();
595 self.selected = 0;
596 self.scroll_offset = 0;
597 self.update_filtered(false);
598 }
599
600 pub fn clear_actions(&mut self) {
602 self.replace_actions(Vec::new());
603 }
604
605 pub fn action_count(&self) -> usize {
607 self.actions.len()
608 }
609
610 fn refresh_filtered_after_action_change(&mut self) {
611 if self.visible
612 || !self.query.is_empty()
613 || !self.filtered.is_empty()
614 || self.match_filter != MatchFilter::All
615 {
616 self.update_filtered(false);
617 }
618 }
619
620 pub fn open(&mut self) {
624 self.visible = true;
625 self.query.clear();
626 self.cursor = 0;
627 self.selected = 0;
628 self.scroll_offset = 0;
629 self.scorer.invalidate();
630 #[cfg(feature = "tracing")]
631 {
632 self.opened_at = Some(Instant::now());
633 }
634 self.update_filtered(false);
635 #[cfg(feature = "tracing")]
636 emit_palette_opened(self.actions.len(), self.filtered.len());
637 }
638
639 pub fn close(&mut self) {
641 self.close_with_reason(PaletteCloseReason::Programmatic);
642 }
643
644 pub fn toggle(&mut self) {
646 if self.visible {
647 self.close_with_reason(PaletteCloseReason::Toggle);
648 } else {
649 self.open();
650 }
651 }
652
653 #[inline]
655 pub fn is_visible(&self) -> bool {
656 self.visible
657 }
658
659 pub fn query(&self) -> &str {
663 &self.query
664 }
665
666 pub fn set_query(&mut self, query: impl Into<String>) {
668 self.query = query.into();
669 self.cursor = self.query.len();
670 self.selected = 0;
671 self.scroll_offset = 0;
672 self.scorer.invalidate();
673 self.update_filtered(false);
674 }
675
676 pub fn result_count(&self) -> usize {
678 self.filtered.len()
679 }
680
681 #[inline]
683 pub fn selected_index(&self) -> usize {
684 self.selected
685 }
686
687 #[must_use = "use the selected action (if any)"]
689 pub fn selected_action(&self) -> Option<&ActionItem> {
690 self.filtered
691 .get(self.selected)
692 .map(|si| &self.actions[si.action_index])
693 }
694
695 #[must_use = "use the selected match (if any)"]
697 pub fn selected_match(&self) -> Option<PaletteMatch<'_>> {
698 self.filtered.get(self.selected).map(|si| PaletteMatch {
699 action: &self.actions[si.action_index],
700 result: &si.result,
701 })
702 }
703
704 pub fn results(&self) -> impl Iterator<Item = PaletteMatch<'_>> {
706 self.filtered.iter().map(|si| PaletteMatch {
707 action: &self.actions[si.action_index],
708 result: &si.result,
709 })
710 }
711
712 pub fn set_match_filter(&mut self, filter: MatchFilter) {
714 if self.match_filter == filter {
715 return;
716 }
717 self.match_filter = filter;
718 self.selected = 0;
719 self.scroll_offset = 0;
720 self.update_filtered(false);
721 }
722
723 pub fn scorer_stats(&self) -> &IncrementalStats {
725 self.scorer.stats()
726 }
727
728 #[must_use = "use the returned action (if any) to execute or dismiss"]
736 pub fn handle_event(&mut self, event: &Event) -> Option<PaletteAction> {
737 if !self.visible {
738 if let Event::Key(KeyEvent {
740 code: KeyCode::Char('p'),
741 modifiers,
742 kind: KeyEventKind::Press,
743 }) = event
744 && modifiers.contains(Modifiers::CTRL)
745 {
746 self.open();
747 }
748 return None;
749 }
750
751 match event {
752 Event::Key(KeyEvent {
753 code,
754 modifiers,
755 kind: KeyEventKind::Press,
756 }) => self.handle_key(*code, *modifiers),
757 _ => None,
758 }
759 }
760
761 fn handle_key(&mut self, code: KeyCode, modifiers: Modifiers) -> Option<PaletteAction> {
763 match code {
764 KeyCode::Escape => {
765 self.close_with_reason(PaletteCloseReason::Dismiss);
766 return Some(PaletteAction::Dismiss);
767 }
768
769 KeyCode::Enter => {
770 if let Some(si) = self.filtered.get(self.selected) {
771 let id = self.actions[si.action_index].id.clone();
772 #[cfg(feature = "tracing")]
773 {
774 let latency_ms = self.opened_at.map(|start| start.elapsed().as_millis());
775 emit_palette_action_executed(&id, latency_ms);
776 }
777 self.close_with_reason(PaletteCloseReason::Execute);
778 return Some(PaletteAction::Execute(id));
779 }
780 }
781
782 KeyCode::Up if self.selected > 0 => {
783 self.selected -= 1;
784 self.adjust_scroll();
785 }
786
787 KeyCode::Down
788 if !self.filtered.is_empty() && self.selected < self.filtered.len() - 1 =>
789 {
790 self.selected += 1;
791 self.adjust_scroll();
792 }
793
794 KeyCode::PageUp => {
795 self.selected = self.selected.saturating_sub(self.max_visible);
796 self.adjust_scroll();
797 }
798
799 KeyCode::PageDown if !self.filtered.is_empty() => {
800 self.selected = (self.selected + self.max_visible).min(self.filtered.len() - 1);
801 self.adjust_scroll();
802 }
803
804 KeyCode::Home => {
805 self.selected = 0;
806 self.scroll_offset = 0;
807 }
808
809 KeyCode::End if !self.filtered.is_empty() => {
810 self.selected = self.filtered.len() - 1;
811 self.adjust_scroll();
812 }
813
814 KeyCode::Backspace if self.cursor > 0 => {
815 let prev = self.query[..self.cursor]
817 .char_indices()
818 .next_back()
819 .map(|(i, _)| i)
820 .unwrap_or(0);
821 self.query.drain(prev..self.cursor);
822 self.cursor = prev;
823 self.selected = 0;
824 self.scroll_offset = 0;
825 self.update_filtered(true);
826 }
827
828 KeyCode::Delete if self.cursor < self.query.len() => {
829 let next = self.query[self.cursor..]
831 .char_indices()
832 .nth(1)
833 .map(|(i, _)| self.cursor + i)
834 .unwrap_or(self.query.len());
835 self.query.drain(self.cursor..next);
836 self.selected = 0;
837 self.scroll_offset = 0;
838 self.update_filtered(true);
839 }
840
841 KeyCode::Left if self.cursor > 0 => {
842 self.cursor = self.query[..self.cursor]
844 .char_indices()
845 .next_back()
846 .map(|(i, _)| i)
847 .unwrap_or(0);
848 }
849
850 KeyCode::Right if self.cursor < self.query.len() => {
851 self.cursor = self.query[self.cursor..]
853 .char_indices()
854 .nth(1)
855 .map(|(i, _)| self.cursor + i)
856 .unwrap_or(self.query.len());
857 }
858
859 KeyCode::Char(c) => {
860 if modifiers.contains(Modifiers::CTRL) {
861 if c == 'a' {
863 self.cursor = 0;
864 }
865 if c == 'e' {
867 self.cursor = self.query.len();
868 }
869 if c == 'u' {
871 self.query.clear();
872 self.cursor = 0;
873 self.selected = 0;
874 self.scroll_offset = 0;
875 self.update_filtered(true);
876 }
877 } else {
878 self.query.insert(self.cursor, c);
880 self.cursor += c.len_utf8();
881 self.selected = 0;
882 self.scroll_offset = 0;
883 self.update_filtered(true);
884 }
885 }
886
887 _ => {}
888 }
889
890 None
891 }
892
893 fn update_filtered(&mut self, _emit_telemetry: bool) {
895 #[cfg(feature = "tracing")]
896 let start = _emit_telemetry.then(Instant::now);
900
901 if self.titles_cache.len() != self.actions.len()
902 || self.titles_lower.len() != self.actions.len()
903 || self.titles_word_starts.len() != self.actions.len()
904 || self.prefix_index.len() != self.actions.len()
905 {
906 self.rebuild_search_cache();
907 }
908
909 let results = if self.match_filter == MatchFilter::Prefix && !self.query.is_empty() {
910 let query_lower = self.query.to_lowercase();
911 let candidate_indices: Vec<usize> = self
912 .prefix_index
913 .prefix_scan(&query_lower)
914 .into_iter()
915 .map(|(_, action_index)| *action_index)
916 .collect();
917 self.scorer.score_candidate_indices_with_lowered_and_words(
918 &self.query,
919 &self.titles_cache,
920 &self.titles_lower,
921 &self.titles_word_starts,
922 &candidate_indices,
923 Some(self.generation),
924 )
925 } else {
926 self.scorer.score_corpus_with_lowered_and_words(
927 &self.query,
928 &self.titles_cache,
929 &self.titles_lower,
930 &self.titles_word_starts,
931 Some(self.generation),
932 )
933 };
934
935 self.filtered = results
936 .into_iter()
937 .filter(|(_, result)| self.match_filter.allows(result.match_type))
938 .map(|(idx, result)| ScoredItem {
939 action_index: idx,
940 result,
941 })
942 .collect();
943
944 if !self.filtered.is_empty() {
946 self.selected = self.selected.min(self.filtered.len() - 1);
947 self.adjust_scroll();
948 } else {
949 self.selected = 0;
950 self.scroll_offset = 0;
951 }
952
953 #[cfg(feature = "tracing")]
954 if let Some(start) = start {
955 emit_palette_query_updated(
956 &self.query,
957 self.filtered.len(),
958 start.elapsed().as_millis(),
959 );
960 }
961 }
962
963 fn close_with_reason(&mut self, _reason: PaletteCloseReason) {
964 self.visible = false;
965 self.query.clear();
966 self.cursor = 0;
967 self.filtered.clear();
968 #[cfg(feature = "tracing")]
969 {
970 self.opened_at = None;
971 emit_palette_closed(_reason);
972 }
973 }
974
975 fn adjust_scroll(&mut self) {
977 if self.selected < self.scroll_offset {
978 self.scroll_offset = self.selected;
979 } else if self.selected >= self.scroll_offset.saturating_add(self.max_visible) {
980 self.scroll_offset = self
981 .selected
982 .saturating_sub(self.max_visible.saturating_sub(1));
983 }
984 }
985}
986
987impl Widget for CommandPalette {
992 fn render(&self, area: Rect, frame: &mut Frame) {
993 if !self.visible || area.width < 10 || area.height < 5 {
994 return;
995 }
996
997 let palette_area = if self.fill_area {
998 area
1000 } else {
1001 let palette_width = (area.width * 3 / 5).max(30).min(area.width - 2);
1003 let result_rows = self.filtered.len().min(self.max_visible);
1004 let palette_height = (result_rows as u16 + 3)
1006 .max(5)
1007 .min(area.height.saturating_sub(2));
1008 let palette_x = area.x + (area.width.saturating_sub(palette_width)) / 2;
1009 let palette_y = area.y + area.height / 6; Rect::new(palette_x, palette_y, palette_width, palette_height)
1011 };
1012
1013 self.clear_area(palette_area, frame);
1015
1016 self.draw_border(palette_area, frame);
1018
1019 let input_area = Rect::new(
1021 palette_area.x + 2,
1022 palette_area.y + 1,
1023 palette_area.width.saturating_sub(4),
1024 1,
1025 );
1026 self.draw_query_input(input_area, frame);
1027
1028 let results_y = palette_area.y + 2;
1030 let results_height = palette_area.height.saturating_sub(3);
1031 let results_area = Rect::new(
1032 palette_area.x + 1,
1033 results_y,
1034 palette_area.width.saturating_sub(2),
1035 results_height,
1036 );
1037 self.draw_results(results_area, frame);
1038
1039 let cursor_visual_pos = display_width(&self.query[..self.cursor.min(self.query.len())]);
1043 let cursor_x = input_area.x + cursor_visual_pos.min(input_area.width as usize) as u16;
1044 frame.cursor_position = Some((cursor_x, input_area.y));
1045 frame.cursor_visible = true;
1046 }
1047
1048 fn is_essential(&self) -> bool {
1049 true
1050 }
1051}
1052
1053impl CommandPalette {
1054 fn palette_background(&self) -> PackedRgba {
1059 self.style
1060 .border
1061 .bg
1062 .or(self.style.input.bg)
1063 .or(self.style.item.bg)
1064 .or(self.style.hint.bg)
1065 .or(self.style.item_selected.bg)
1066 .unwrap_or(PackedRgba::rgb(30, 30, 40))
1067 }
1068
1069 fn clear_area(&self, area: Rect, frame: &mut Frame) {
1071 let bg = self.palette_background();
1072 for y in area.y..area.bottom() {
1073 for x in area.x..area.right() {
1074 if let Some(cell) = frame.buffer.get_mut(x, y) {
1075 *cell = Cell::from_char(' ');
1076 cell.bg = bg;
1077 }
1078 }
1079 }
1080 }
1081
1082 fn draw_border(&self, area: Rect, frame: &mut Frame) {
1084 let border_fg = self
1085 .style
1086 .border
1087 .fg
1088 .unwrap_or(PackedRgba::rgb(100, 100, 120));
1089 let bg = self.palette_background();
1090
1091 let mut cell = Cell::from_char('╭');
1093 cell.fg = border_fg;
1094 cell.bg = bg;
1095 frame.buffer.set_fast(area.x, area.y, cell);
1096
1097 for x in (area.x + 1)..area.right().saturating_sub(1) {
1098 let mut cell = Cell::from_char('─');
1099 cell.fg = border_fg;
1100 cell.bg = bg;
1101 frame.buffer.set_fast(x, area.y, cell);
1102 }
1103 if area.width > 1 {
1104 let mut cell = Cell::from_char('╮');
1105 cell.fg = border_fg;
1106 cell.bg = bg;
1107 frame.buffer.set_fast(area.right() - 1, area.y, cell);
1108 }
1109
1110 let title = &self.title;
1112 let title_width = display_width(title).min(area.width as usize);
1113 let title_x = area.x + (area.width.saturating_sub(title_width as u16)) / 2;
1114 let title_style = Style::new().fg(PackedRgba::rgb(200, 200, 220)).bg(bg);
1115 crate::draw_text_span(frame, title_x, area.y, title, title_style, area.right());
1116
1117 for y in (area.y + 1)..area.bottom().saturating_sub(1) {
1119 let mut cell_l = Cell::from_char('│');
1120 cell_l.fg = border_fg;
1121 cell_l.bg = bg;
1122 frame.buffer.set_fast(area.x, y, cell_l);
1123
1124 if area.width > 1 {
1125 let mut cell_r = Cell::from_char('│');
1126 cell_r.fg = border_fg;
1127 cell_r.bg = bg;
1128 frame.buffer.set_fast(area.right() - 1, y, cell_r);
1129 }
1130 }
1131
1132 if area.height > 1 {
1134 let by = area.bottom() - 1;
1135 let mut cell_bl = Cell::from_char('╰');
1136 cell_bl.fg = border_fg;
1137 cell_bl.bg = bg;
1138 frame.buffer.set_fast(area.x, by, cell_bl);
1139
1140 for x in (area.x + 1)..area.right().saturating_sub(1) {
1141 let mut cell = Cell::from_char('─');
1142 cell.fg = border_fg;
1143 cell.bg = bg;
1144 frame.buffer.set_fast(x, by, cell);
1145 }
1146 if area.width > 1 {
1147 let mut cell_br = Cell::from_char('╯');
1148 cell_br.fg = border_fg;
1149 cell_br.bg = bg;
1150 frame.buffer.set_fast(area.right() - 1, by, cell_br);
1151 }
1152 }
1153 }
1154
1155 fn draw_query_input(&self, area: Rect, frame: &mut Frame) {
1157 let input_fg = self
1158 .style
1159 .input
1160 .fg
1161 .unwrap_or(PackedRgba::rgb(220, 220, 230));
1162 let bg = self.palette_background();
1163 let prompt_fg = PackedRgba::rgb(100, 180, 255);
1164
1165 if let Some(cell) = frame.buffer.get_mut(area.x.saturating_sub(1), area.y) {
1167 cell.content = CellContent::from_char('>');
1168 cell.fg = prompt_fg;
1169 cell.bg = bg;
1170 }
1171
1172 if self.query.is_empty() {
1174 let hint = "Type to search...";
1176 let hint_fg = self.style.hint.fg.unwrap_or(PackedRgba::rgb(100, 100, 120));
1177 for (i, ch) in hint.chars().enumerate() {
1178 let x = area.x + i as u16;
1179 if x >= area.right() {
1180 break;
1181 }
1182 if let Some(cell) = frame.buffer.get_mut(x, area.y) {
1183 cell.content = CellContent::from_char(ch);
1184 cell.fg = hint_fg;
1185 cell.bg = bg;
1186 }
1187 }
1188 } else {
1189 let mut col = area.x;
1191 for grapheme in graphemes(&self.query) {
1192 let w = grapheme_width(grapheme);
1193 if w == 0 {
1194 continue;
1195 }
1196 if col >= area.right() {
1197 break;
1198 }
1199 if col.saturating_add(w as u16) > area.right() {
1200 break;
1201 }
1202 let content = if w > 1 || grapheme.chars().count() > 1 {
1203 let id = frame.intern_with_width(grapheme, w as u8);
1204 CellContent::from_grapheme(id)
1205 } else if let Some(ch) = grapheme.chars().next() {
1206 CellContent::from_char(ch)
1207 } else {
1208 continue;
1209 };
1210 let mut cell = Cell::new(content);
1211 cell.fg = input_fg;
1212 cell.bg = bg;
1213 frame.buffer.set_fast(col, area.y, cell);
1214 col = col.saturating_add(w as u16);
1215 }
1216 }
1217 }
1218
1219 fn draw_results(&self, area: Rect, frame: &mut Frame) {
1221 if self.filtered.is_empty() {
1222 let msg = if self.query.is_empty() {
1224 "No actions registered"
1225 } else {
1226 "No results"
1227 };
1228 let hint_fg = self.style.hint.fg.unwrap_or(PackedRgba::rgb(100, 100, 120));
1229 let bg = self.palette_background();
1230 for (i, ch) in msg.chars().enumerate() {
1231 let x = area.x + 1 + i as u16;
1232 if x >= area.right() {
1233 break;
1234 }
1235 if let Some(cell) = frame.buffer.get_mut(x, area.y) {
1236 cell.content = CellContent::from_char(ch);
1237 cell.fg = hint_fg;
1238 cell.bg = bg;
1239 }
1240 }
1241 return;
1242 }
1243
1244 let item_fg = self.style.item.fg.unwrap_or(PackedRgba::rgb(180, 180, 190));
1245 let selected_fg = self
1246 .style
1247 .item_selected
1248 .fg
1249 .unwrap_or(PackedRgba::rgb(255, 255, 255));
1250 let selected_bg = self
1251 .style
1252 .item_selected
1253 .bg
1254 .unwrap_or(PackedRgba::rgb(60, 60, 80));
1255 let highlight_fg = self
1256 .style
1257 .match_highlight
1258 .fg
1259 .unwrap_or(PackedRgba::rgb(255, 200, 50));
1260 let desc_fg = self
1261 .style
1262 .description
1263 .fg
1264 .unwrap_or(PackedRgba::rgb(120, 120, 140));
1265 let cat_fg = self
1266 .style
1267 .category
1268 .fg
1269 .unwrap_or(PackedRgba::rgb(100, 180, 255));
1270 let bg = self.palette_background();
1271
1272 let visible_end = (self.scroll_offset + area.height as usize).min(self.filtered.len());
1273
1274 for (row_idx, si) in self.filtered[self.scroll_offset..visible_end]
1275 .iter()
1276 .enumerate()
1277 {
1278 let y = area.y + row_idx as u16;
1279 if y >= area.bottom() {
1280 break;
1281 }
1282
1283 let action = &self.actions[si.action_index];
1284 let is_selected = (self.scroll_offset + row_idx) == self.selected;
1285
1286 let row_fg = if is_selected { selected_fg } else { item_fg };
1287 let row_bg = if is_selected { selected_bg } else { bg };
1288
1289 let row_attrs = if is_selected {
1291 CellAttrs::new(CellStyleFlags::BOLD, 0)
1292 } else {
1293 CellAttrs::default()
1294 };
1295
1296 for x in area.x..area.right() {
1298 if let Some(cell) = frame.buffer.get_mut(x, y) {
1299 cell.content = CellContent::from_char(' ');
1300 cell.fg = row_fg;
1301 cell.bg = row_bg;
1302 cell.attrs = row_attrs;
1303 }
1304 }
1305
1306 let mut col = area.x;
1308 if is_selected && let Some(cell) = frame.buffer.get_mut(col, y) {
1309 cell.content = CellContent::from_char('>');
1310 cell.fg = highlight_fg;
1311 cell.bg = row_bg;
1312 cell.attrs = CellAttrs::new(CellStyleFlags::BOLD, 0);
1313 }
1314 col += 2;
1315
1316 if let Some(ref cat) = action.category {
1318 let badge = format!("[{}] ", cat);
1319 for grapheme in graphemes(&badge) {
1320 let w = grapheme_width(grapheme);
1321 if w == 0 {
1322 continue;
1323 }
1324 if col >= area.right() || col.saturating_add(w as u16) > area.right() {
1325 break;
1326 }
1327 let content = if w > 1 || grapheme.chars().count() > 1 {
1328 let id = frame.intern_with_width(grapheme, w as u8);
1329 CellContent::from_grapheme(id)
1330 } else if let Some(ch) = grapheme.chars().next() {
1331 CellContent::from_char(ch)
1332 } else {
1333 continue;
1334 };
1335 let mut cell = Cell::new(content);
1336 cell.fg = cat_fg;
1337 cell.bg = row_bg;
1338 cell.attrs = row_attrs;
1339 frame.buffer.set_fast(col, y, cell);
1340 col = col.saturating_add(w as u16);
1341 }
1342 }
1343
1344 let title_max_width = area.right().saturating_sub(col) as usize;
1346 let title_width = display_width(action.title.as_str());
1347 let needs_ellipsis = title_width > title_max_width && title_max_width > 3;
1348 let title_display_width = if needs_ellipsis {
1349 title_max_width.saturating_sub(1) } else {
1351 title_max_width
1352 };
1353
1354 let mut title_used_width = 0usize;
1355 let mut char_idx = 0usize;
1356 let mut match_cursor = 0usize;
1357 let match_positions = &si.result.match_positions;
1358 for grapheme in graphemes(action.title.as_str()) {
1359 let g_chars = grapheme.chars().count();
1360 let char_end = char_idx + g_chars;
1361 while match_cursor < match_positions.len()
1362 && match_positions[match_cursor] < char_idx
1363 {
1364 match_cursor += 1;
1365 }
1366 let is_match = match_cursor < match_positions.len()
1367 && match_positions[match_cursor] < char_end;
1368
1369 let w = grapheme_width(grapheme);
1370 if w == 0 {
1371 char_idx = char_end;
1372 continue;
1373 }
1374 if title_used_width + w > title_display_width || col >= area.right() {
1375 break;
1376 }
1377 if col.saturating_add(w as u16) > area.right() {
1378 break;
1379 }
1380
1381 let content = if w > 1 || grapheme.chars().count() > 1 {
1382 let id = frame.intern_with_width(grapheme, w as u8);
1383 CellContent::from_grapheme(id)
1384 } else if let Some(ch) = grapheme.chars().next() {
1385 CellContent::from_char(ch)
1386 } else {
1387 char_idx = char_end;
1388 continue;
1389 };
1390
1391 let mut cell = Cell::new(content);
1392 cell.fg = if is_match { highlight_fg } else { row_fg };
1393 cell.bg = row_bg;
1394 cell.attrs = row_attrs;
1395 frame.buffer.set_fast(col, y, cell);
1396
1397 col = col.saturating_add(w as u16);
1398 title_used_width += w;
1399 char_idx = char_end;
1400 }
1401
1402 if needs_ellipsis && col < area.right() {
1404 if let Some(cell) = frame.buffer.get_mut(col, y) {
1405 cell.content = CellContent::from_char('\u{2026}'); cell.fg = row_fg;
1407 cell.bg = row_bg;
1408 cell.attrs = row_attrs;
1409 }
1410 col += 1;
1411 }
1412
1413 if let Some(ref desc) = action.description {
1415 col += 2; let max_desc_width = area.right().saturating_sub(col) as usize;
1417 if max_desc_width > 5 {
1418 let desc_width = display_width(desc.as_str());
1419 let desc_needs_ellipsis = desc_width > max_desc_width && max_desc_width > 3;
1420 let desc_display_width = if desc_needs_ellipsis {
1421 max_desc_width.saturating_sub(1)
1422 } else {
1423 max_desc_width
1424 };
1425
1426 let mut desc_used_width = 0usize;
1427 for grapheme in graphemes(desc.as_str()) {
1428 let w = grapheme_width(grapheme);
1429 if w == 0 {
1430 continue;
1431 }
1432 if desc_used_width + w > desc_display_width || col >= area.right() {
1433 break;
1434 }
1435 if col.saturating_add(w as u16) > area.right() {
1436 break;
1437 }
1438 let content = if w > 1 || grapheme.chars().count() > 1 {
1439 let id = frame.intern_with_width(grapheme, w as u8);
1440 CellContent::from_grapheme(id)
1441 } else if let Some(ch) = grapheme.chars().next() {
1442 CellContent::from_char(ch)
1443 } else {
1444 continue;
1445 };
1446 let mut cell = Cell::new(content);
1447 cell.fg = desc_fg;
1448 cell.bg = row_bg;
1449 cell.attrs = row_attrs;
1450 frame.buffer.set_fast(col, y, cell);
1451 col = col.saturating_add(w as u16);
1452 desc_used_width += w;
1453 }
1454
1455 if desc_needs_ellipsis
1456 && col < area.right()
1457 && let Some(cell) = frame.buffer.get_mut(col, y)
1458 {
1459 cell.content = CellContent::from_char('\u{2026}');
1460 cell.fg = desc_fg;
1461 cell.bg = row_bg;
1462 cell.attrs = row_attrs;
1463 }
1464 }
1465 }
1466 }
1467 }
1468}
1469
1470#[cfg(test)]
1475mod widget_tests {
1476 use super::*;
1477
1478 #[test]
1479 fn new_palette_is_hidden() {
1480 let palette = CommandPalette::new();
1481 assert!(!palette.is_visible());
1482 assert_eq!(palette.action_count(), 0);
1483 }
1484
1485 #[test]
1486 fn register_actions() {
1487 let mut palette = CommandPalette::new();
1488 palette.register("Open File", Some("Open a file"), &["file"]);
1489 palette.register("Save File", None, &[]);
1490 assert_eq!(palette.action_count(), 2);
1491 }
1492
1493 #[test]
1494 fn open_shows_all_actions() {
1495 let mut palette = CommandPalette::new();
1496 palette.register("Open File", None, &[]);
1497 palette.register("Save File", None, &[]);
1498 palette.register("Close Tab", None, &[]);
1499 palette.open();
1500 assert!(palette.is_visible());
1501 assert_eq!(palette.result_count(), 3);
1502 }
1503
1504 #[test]
1505 fn close_hides_palette() {
1506 let mut palette = CommandPalette::new();
1507 palette.open();
1508 assert!(palette.is_visible());
1509 palette.close();
1510 assert!(!palette.is_visible());
1511 }
1512
1513 #[test]
1514 fn toggle_visibility() {
1515 let mut palette = CommandPalette::new();
1516 palette.toggle();
1517 assert!(palette.is_visible());
1518 palette.toggle();
1519 assert!(!palette.is_visible());
1520 }
1521
1522 #[test]
1523 fn typing_filters_results() {
1524 let mut palette = CommandPalette::new();
1525 palette.register("Open File", None, &[]);
1526 palette.register("Save File", None, &[]);
1527 palette.register("Git: Commit", None, &[]);
1528 palette.open();
1529 assert_eq!(palette.result_count(), 3);
1530
1531 let g = Event::Key(KeyEvent {
1533 code: KeyCode::Char('g'),
1534 modifiers: Modifiers::empty(),
1535 kind: KeyEventKind::Press,
1536 });
1537 let i = Event::Key(KeyEvent {
1538 code: KeyCode::Char('i'),
1539 modifiers: Modifiers::empty(),
1540 kind: KeyEventKind::Press,
1541 });
1542 let t = Event::Key(KeyEvent {
1543 code: KeyCode::Char('t'),
1544 modifiers: Modifiers::empty(),
1545 kind: KeyEventKind::Press,
1546 });
1547
1548 let _ = palette.handle_event(&g);
1549 let _ = palette.handle_event(&i);
1550 let _ = palette.handle_event(&t);
1551
1552 assert_eq!(palette.query(), "git");
1553 assert!(palette.result_count() >= 1);
1555 }
1556
1557 #[test]
1558 fn backspace_removes_character() {
1559 let mut palette = CommandPalette::new();
1560 palette.register("Open File", None, &[]);
1561 palette.open();
1562
1563 let o = Event::Key(KeyEvent {
1564 code: KeyCode::Char('o'),
1565 modifiers: Modifiers::empty(),
1566 kind: KeyEventKind::Press,
1567 });
1568 let bs = Event::Key(KeyEvent {
1569 code: KeyCode::Backspace,
1570 modifiers: Modifiers::empty(),
1571 kind: KeyEventKind::Press,
1572 });
1573
1574 let _ = palette.handle_event(&o);
1575 assert_eq!(palette.query(), "o");
1576 let _ = palette.handle_event(&bs);
1577 assert_eq!(palette.query(), "");
1578 }
1579
1580 #[test]
1581 fn esc_dismisses_palette() {
1582 let mut palette = CommandPalette::new();
1583 palette.open();
1584
1585 let esc = Event::Key(KeyEvent {
1586 code: KeyCode::Escape,
1587 modifiers: Modifiers::empty(),
1588 kind: KeyEventKind::Press,
1589 });
1590
1591 let result = palette.handle_event(&esc);
1592 assert_eq!(result, Some(PaletteAction::Dismiss));
1593 assert!(!palette.is_visible());
1594 }
1595
1596 #[test]
1597 fn enter_executes_selected() {
1598 let mut palette = CommandPalette::new();
1599 palette.register("Open File", None, &[]);
1600 palette.open();
1601
1602 let enter = Event::Key(KeyEvent {
1603 code: KeyCode::Enter,
1604 modifiers: Modifiers::empty(),
1605 kind: KeyEventKind::Press,
1606 });
1607
1608 let result = palette.handle_event(&enter);
1609 assert_eq!(result, Some(PaletteAction::Execute("open_file".into())));
1610 }
1611
1612 #[test]
1613 fn arrow_keys_navigate() {
1614 let mut palette = CommandPalette::new();
1615 palette.register("A", None, &[]);
1616 palette.register("B", None, &[]);
1617 palette.register("C", None, &[]);
1618 palette.open();
1619
1620 assert_eq!(palette.selected_index(), 0);
1621
1622 let down = Event::Key(KeyEvent {
1623 code: KeyCode::Down,
1624 modifiers: Modifiers::empty(),
1625 kind: KeyEventKind::Press,
1626 });
1627 let up = Event::Key(KeyEvent {
1628 code: KeyCode::Up,
1629 modifiers: Modifiers::empty(),
1630 kind: KeyEventKind::Press,
1631 });
1632
1633 let _ = palette.handle_event(&down);
1634 assert_eq!(palette.selected_index(), 1);
1635 let _ = palette.handle_event(&down);
1636 assert_eq!(palette.selected_index(), 2);
1637 let _ = palette.handle_event(&down);
1639 assert_eq!(palette.selected_index(), 2);
1640
1641 let _ = palette.handle_event(&up);
1642 assert_eq!(palette.selected_index(), 1);
1643 let _ = palette.handle_event(&up);
1644 assert_eq!(palette.selected_index(), 0);
1645 let _ = palette.handle_event(&up);
1647 assert_eq!(palette.selected_index(), 0);
1648 }
1649
1650 #[test]
1651 fn home_end_navigation() {
1652 let mut palette = CommandPalette::new();
1653 for i in 0..20 {
1654 palette.register(format!("Action {}", i), None, &[]);
1655 }
1656 palette.open();
1657
1658 let end = Event::Key(KeyEvent {
1659 code: KeyCode::End,
1660 modifiers: Modifiers::empty(),
1661 kind: KeyEventKind::Press,
1662 });
1663 let home = Event::Key(KeyEvent {
1664 code: KeyCode::Home,
1665 modifiers: Modifiers::empty(),
1666 kind: KeyEventKind::Press,
1667 });
1668
1669 let _ = palette.handle_event(&end);
1670 assert_eq!(palette.selected_index(), 19);
1671
1672 let _ = palette.handle_event(&home);
1673 assert_eq!(palette.selected_index(), 0);
1674 }
1675
1676 #[test]
1677 fn ctrl_u_clears_query() {
1678 let mut palette = CommandPalette::new();
1679 palette.register("Open File", None, &[]);
1680 palette.open();
1681
1682 let o = Event::Key(KeyEvent {
1683 code: KeyCode::Char('o'),
1684 modifiers: Modifiers::empty(),
1685 kind: KeyEventKind::Press,
1686 });
1687 let _ = palette.handle_event(&o);
1688 assert_eq!(palette.query(), "o");
1689
1690 let ctrl_u = Event::Key(KeyEvent {
1691 code: KeyCode::Char('u'),
1692 modifiers: Modifiers::CTRL,
1693 kind: KeyEventKind::Press,
1694 });
1695 let _ = palette.handle_event(&ctrl_u);
1696 assert_eq!(palette.query(), "");
1697 }
1698
1699 #[test]
1700 fn ctrl_p_opens_palette() {
1701 let mut palette = CommandPalette::new();
1702 assert!(!palette.is_visible());
1703
1704 let ctrl_p = Event::Key(KeyEvent {
1705 code: KeyCode::Char('p'),
1706 modifiers: Modifiers::CTRL,
1707 kind: KeyEventKind::Press,
1708 });
1709 let _ = palette.handle_event(&ctrl_p);
1710 assert!(palette.is_visible());
1711 }
1712
1713 #[test]
1714 fn selected_action_returns_correct_item() {
1715 let mut palette = CommandPalette::new();
1716 palette.register("Alpha", None, &[]);
1717 palette.register("Beta", None, &[]);
1718 palette.open();
1719
1720 let action = palette.selected_action().unwrap();
1721 assert!(!action.title.is_empty());
1723 }
1724
1725 #[test]
1726 fn register_action_item_directly() {
1727 let mut palette = CommandPalette::new();
1728 let item = ActionItem::new("custom_id", "Custom Action")
1729 .with_description("A custom action")
1730 .with_tags(&["custom", "test"])
1731 .with_category("Testing");
1732
1733 palette.register_action(item);
1734 assert_eq!(palette.action_count(), 1);
1735 }
1736
1737 #[test]
1738 fn register_refreshes_visible_filtered_results() {
1739 let mut palette = CommandPalette::new();
1740 palette.register("Alpha", None, &[]);
1741 palette.open();
1742 palette.set_query("Beta");
1743 assert!(palette.selected_action().is_none());
1744
1745 palette.register("Beta", None, &[]);
1746
1747 assert_eq!(palette.result_count(), 1);
1748 assert_eq!(
1749 palette
1750 .selected_action()
1751 .map(|action| action.title.as_str()),
1752 Some("Beta")
1753 );
1754 }
1755
1756 #[test]
1757 fn register_action_refreshes_visible_filtered_results() {
1758 let mut palette = CommandPalette::new();
1759 palette.register("Alpha", None, &[]);
1760 palette.open();
1761 palette.set_query("Beta");
1762 assert!(palette.selected_action().is_none());
1763
1764 palette.register_action(ActionItem::new("beta", "Beta"));
1765
1766 assert_eq!(palette.result_count(), 1);
1767 assert_eq!(
1768 palette
1769 .selected_action()
1770 .map(|action| action.title.as_str()),
1771 Some("Beta")
1772 );
1773 }
1774
1775 #[test]
1776 fn replace_actions_refreshes_results() {
1777 let mut palette = CommandPalette::new();
1778 palette.register("Alpha", None, &[]);
1779 palette.register("Beta", None, &[]);
1780 palette.open();
1781 palette.set_query("Beta");
1782 assert_eq!(
1783 palette.selected_action().map(|a| a.title.as_str()),
1784 Some("Beta")
1785 );
1786
1787 let actions = vec![
1788 ActionItem::new("gamma", "Gamma"),
1789 ActionItem::new("delta", "Delta"),
1790 ];
1791 palette.replace_actions(actions);
1792 palette.set_query("Delta");
1793 assert_eq!(
1794 palette.selected_action().map(|a| a.title.as_str()),
1795 Some("Delta")
1796 );
1797 }
1798
1799 #[test]
1800 fn clear_actions_resets_results() {
1801 let mut palette = CommandPalette::new();
1802 palette.register("Alpha", None, &[]);
1803 palette.register("Beta", None, &[]);
1804 palette.open();
1805 palette.set_query("Alpha");
1806 assert!(palette.selected_action().is_some());
1807
1808 palette.clear_actions();
1809 assert_eq!(palette.action_count(), 0);
1810 assert!(palette.selected_action().is_none());
1811 }
1812
1813 #[test]
1814 fn set_query_refilters() {
1815 let mut palette = CommandPalette::new();
1816 palette.register("Alpha", None, &[]);
1817 palette.register("Beta", None, &[]);
1818 palette.open();
1819 palette.set_query("Alpha");
1820 assert_eq!(palette.query(), "Alpha");
1821 assert_eq!(
1822 palette.selected_action().map(|a| a.title.as_str()),
1823 Some("Alpha")
1824 );
1825 palette.set_query("Beta");
1826 assert_eq!(palette.query(), "Beta");
1827 assert_eq!(
1828 palette.selected_action().map(|a| a.title.as_str()),
1829 Some("Beta")
1830 );
1831 }
1832
1833 #[test]
1834 fn events_ignored_when_hidden() {
1835 let mut palette = CommandPalette::new();
1836 let a = Event::Key(KeyEvent {
1838 code: KeyCode::Char('a'),
1839 modifiers: Modifiers::empty(),
1840 kind: KeyEventKind::Press,
1841 });
1842 assert!(palette.handle_event(&a).is_none());
1843 assert!(!palette.is_visible());
1844 }
1845
1846 #[test]
1851 fn selected_row_has_bold_attribute() {
1852 use ftui_render::grapheme_pool::GraphemePool;
1853
1854 let mut palette = CommandPalette::new();
1855 palette.register("Alpha", None, &[]);
1856 palette.register("Beta", None, &[]);
1857 palette.open();
1858
1859 let area = Rect::from_size(60, 10);
1860 let mut pool = GraphemePool::new();
1861 let mut frame = Frame::new(60, 10, &mut pool);
1862 palette.render(area, &mut frame);
1863
1864 let palette_y = area.y + area.height / 6;
1867 let result_y = palette_y + 2;
1868
1869 let mut found_bold = false;
1871 for x in 0..60u16 {
1872 if let Some(cell) = frame.buffer.get(x, result_y)
1873 && cell.attrs.flags().contains(CellStyleFlags::BOLD)
1874 {
1875 found_bold = true;
1876 break;
1877 }
1878 }
1879 assert!(
1880 found_bold,
1881 "Selected row should have bold attribute for accessibility"
1882 );
1883 }
1884
1885 #[test]
1886 fn selection_marker_visible() {
1887 use ftui_render::grapheme_pool::GraphemePool;
1888
1889 let mut palette = CommandPalette::new();
1890 palette.register("Alpha", None, &[]);
1891 palette.open();
1892
1893 let area = Rect::from_size(60, 10);
1894 let mut pool = GraphemePool::new();
1895 let mut frame = Frame::new(60, 10, &mut pool);
1896 palette.render(area, &mut frame);
1897
1898 let palette_y = area.y + area.height / 6;
1900 let result_y = palette_y + 2;
1901 let mut found_marker = false;
1902 for x in 0..60u16 {
1903 if let Some(cell) = frame.buffer.get(x, result_y)
1904 && cell.content.as_char() == Some('>')
1905 {
1906 found_marker = true;
1907 break;
1908 }
1909 }
1910 assert!(
1911 found_marker,
1912 "Selection marker '>' should be visible (color-independent indicator)"
1913 );
1914 }
1915
1916 #[test]
1917 fn long_title_truncated_with_ellipsis() {
1918 use ftui_render::grapheme_pool::GraphemePool;
1919
1920 let mut palette = CommandPalette::new().with_max_visible(5);
1921 palette.register(
1922 "This Is A Very Long Action Title That Should Be Truncated With Ellipsis",
1923 None,
1924 &[],
1925 );
1926 palette.open();
1927
1928 let area = Rect::from_size(40, 10);
1930 let mut pool = GraphemePool::new();
1931 let mut frame = Frame::new(40, 10, &mut pool);
1932 palette.render(area, &mut frame);
1933
1934 let palette_y = area.y + area.height / 6;
1936 let result_y = palette_y + 2;
1937 let mut found_ellipsis = false;
1938 for x in 0..40u16 {
1939 if let Some(cell) = frame.buffer.get(x, result_y)
1940 && cell.content.as_char() == Some('\u{2026}')
1941 {
1942 found_ellipsis = true;
1943 break;
1944 }
1945 }
1946 assert!(
1947 found_ellipsis,
1948 "Long titles should be truncated with '…' ellipsis"
1949 );
1950 }
1951
1952 #[test]
1953 fn keyboard_only_flow_end_to_end() {
1954 let mut palette = CommandPalette::new();
1955 palette.register("Open File", Some("Open a file from disk"), &["file"]);
1956 palette.register("Save File", Some("Save current file"), &["file"]);
1957 palette.register("Git: Commit", Some("Commit changes"), &["git"]);
1958
1959 let ctrl_p = Event::Key(KeyEvent {
1961 code: KeyCode::Char('p'),
1962 modifiers: Modifiers::CTRL,
1963 kind: KeyEventKind::Press,
1964 });
1965 let _ = palette.handle_event(&ctrl_p);
1966 assert!(palette.is_visible());
1967 assert_eq!(palette.result_count(), 3);
1968
1969 for ch in "git".chars() {
1971 let event = Event::Key(KeyEvent {
1972 code: KeyCode::Char(ch),
1973 modifiers: Modifiers::empty(),
1974 kind: KeyEventKind::Press,
1975 });
1976 let _ = palette.handle_event(&event);
1977 }
1978 assert!(palette.result_count() >= 1);
1979
1980 let down = Event::Key(KeyEvent {
1982 code: KeyCode::Down,
1983 modifiers: Modifiers::empty(),
1984 kind: KeyEventKind::Press,
1985 });
1986 let _ = palette.handle_event(&down);
1987
1988 let up = Event::Key(KeyEvent {
1990 code: KeyCode::Up,
1991 modifiers: Modifiers::empty(),
1992 kind: KeyEventKind::Press,
1993 });
1994 let _ = palette.handle_event(&up);
1995 assert_eq!(palette.selected_index(), 0);
1996
1997 let enter = Event::Key(KeyEvent {
1999 code: KeyCode::Enter,
2000 modifiers: Modifiers::empty(),
2001 kind: KeyEventKind::Press,
2002 });
2003 let result = palette.handle_event(&enter);
2004 assert!(matches!(result, Some(PaletteAction::Execute(_))));
2005 assert!(!palette.is_visible());
2006 }
2007
2008 #[test]
2009 fn no_focus_trap_esc_always_dismisses() {
2010 let mut palette = CommandPalette::new();
2011 palette.register("Alpha", None, &[]);
2012 palette.open();
2013
2014 for ch in "xyz".chars() {
2016 let event = Event::Key(KeyEvent {
2017 code: KeyCode::Char(ch),
2018 modifiers: Modifiers::empty(),
2019 kind: KeyEventKind::Press,
2020 });
2021 let _ = palette.handle_event(&event);
2022 }
2023 assert_eq!(palette.result_count(), 0); let esc = Event::Key(KeyEvent {
2027 code: KeyCode::Escape,
2028 modifiers: Modifiers::empty(),
2029 kind: KeyEventKind::Press,
2030 });
2031 let result = palette.handle_event(&esc);
2032 assert_eq!(result, Some(PaletteAction::Dismiss));
2033 assert!(!palette.is_visible());
2034 }
2035
2036 #[test]
2037 fn unicode_query_renders_correctly() {
2038 use ftui_render::grapheme_pool::GraphemePool;
2039
2040 let mut palette = CommandPalette::new();
2041 palette.register("Café Menu", None, &["food"]);
2042 palette.open();
2043 palette.set_query("café");
2044
2045 assert_eq!(palette.query(), "café");
2046
2047 let area = Rect::from_size(60, 10);
2048 let mut pool = GraphemePool::new();
2049 let mut frame = Frame::new(60, 10, &mut pool);
2050 palette.render(area, &mut frame);
2051
2052 let palette_y = area.y + area.height / 6;
2055 let input_y = palette_y + 1;
2056
2057 let mut found_query_chars = 0;
2059 for x in 0..60u16 {
2060 if let Some(cell) = frame.buffer.get(x, input_y)
2061 && let Some(ch) = cell.content.as_char()
2062 && "café".contains(ch)
2063 {
2064 found_query_chars += 1;
2065 }
2066 }
2067 assert!(
2069 found_query_chars >= 3,
2070 "Unicode query should render (found {} chars)",
2071 found_query_chars
2072 );
2073 }
2074
2075 #[test]
2076 fn wide_char_query_renders_correctly() {
2077 use ftui_render::grapheme_pool::GraphemePool;
2078
2079 let mut palette = CommandPalette::new();
2080 palette.register("日本語メニュー", None, &["japanese"]);
2081 palette.open();
2082 palette.set_query("日本");
2083
2084 assert_eq!(palette.query(), "日本");
2085
2086 let area = Rect::from_size(60, 10);
2087 let mut pool = GraphemePool::new();
2088 let mut frame = Frame::new(60, 10, &mut pool);
2089 palette.render(area, &mut frame);
2090
2091 let palette_y = area.y + area.height / 6;
2093 let input_y = palette_y + 1;
2094
2095 let mut found_grapheme = false;
2097 for x in 0..60u16 {
2098 if let Some(cell) = frame.buffer.get(x, input_y)
2099 && cell.content.is_grapheme()
2100 {
2101 found_grapheme = true;
2102 break;
2103 }
2104 }
2105 assert!(
2106 found_grapheme,
2107 "Wide character query should render as graphemes"
2108 );
2109 }
2110
2111 #[test]
2112 fn wcag_aa_contrast_ratios() {
2113 let style = PaletteStyle::default();
2116 let bg = PackedRgba::rgb(30, 30, 40);
2117
2118 fn relative_luminance(color: PackedRgba) -> f64 {
2120 fn linearize(c: u8) -> f64 {
2121 let v = c as f64 / 255.0;
2122 if v <= 0.04045 {
2123 v / 12.92
2124 } else {
2125 ((v + 0.055) / 1.055).powf(2.4)
2126 }
2127 }
2128 let r = linearize(color.r());
2129 let g = linearize(color.g());
2130 let b = linearize(color.b());
2131 0.2126 * r + 0.7152 * g + 0.0722 * b
2132 }
2133
2134 fn contrast_ratio(fg: PackedRgba, bg: PackedRgba) -> f64 {
2135 let l1 = relative_luminance(fg);
2136 let l2 = relative_luminance(bg);
2137 let (lighter, darker) = if l1 > l2 { (l1, l2) } else { (l2, l1) };
2138 (lighter + 0.05) / (darker + 0.05)
2139 }
2140
2141 let item_fg = style.item.fg.unwrap();
2143 let item_ratio = contrast_ratio(item_fg, bg);
2144 assert!(
2145 item_ratio >= 4.5,
2146 "Item text contrast {:.1}:1 < 4.5:1 (WCAG AA)",
2147 item_ratio
2148 );
2149
2150 let sel_fg = style.item_selected.fg.unwrap();
2152 let sel_bg = style.item_selected.bg.unwrap();
2153 let sel_ratio = contrast_ratio(sel_fg, sel_bg);
2154 assert!(
2155 sel_ratio >= 4.5,
2156 "Selected text contrast {:.1}:1 < 4.5:1 (WCAG AA)",
2157 sel_ratio
2158 );
2159
2160 let hl_fg = style.match_highlight.fg.unwrap();
2162 let hl_ratio = contrast_ratio(hl_fg, bg);
2163 assert!(
2164 hl_ratio >= 4.5,
2165 "Highlight text contrast {:.1}:1 < 4.5:1 (WCAG AA)",
2166 hl_ratio
2167 );
2168
2169 let desc_fg = style.description.fg.unwrap();
2171 let desc_ratio = contrast_ratio(desc_fg, bg);
2172 assert!(
2173 desc_ratio >= 4.5,
2174 "Description text contrast {:.1}:1 < 4.5:1 (WCAG AA)",
2175 desc_ratio
2176 );
2177 }
2178
2179 #[test]
2180 fn action_item_builder_fields() {
2181 let item = ActionItem::new("my_id", "My Action")
2182 .with_description("A description")
2183 .with_tags(&["tag1", "tag2"])
2184 .with_category("Category");
2185
2186 assert_eq!(item.id, "my_id");
2187 assert_eq!(item.title, "My Action");
2188 assert_eq!(item.description.as_deref(), Some("A description"));
2189 assert_eq!(item.tags, vec!["tag1", "tag2"]);
2190 assert_eq!(item.category.as_deref(), Some("Category"));
2191 }
2192
2193 #[test]
2194 fn action_item_defaults_none() {
2195 let item = ActionItem::new("id", "title");
2196 assert!(item.description.is_none());
2197 assert!(item.tags.is_empty());
2198 assert!(item.category.is_none());
2199 }
2200
2201 #[test]
2202 fn palette_action_equality() {
2203 assert_eq!(PaletteAction::Dismiss, PaletteAction::Dismiss);
2204 assert_eq!(
2205 PaletteAction::Execute("x".into()),
2206 PaletteAction::Execute("x".into())
2207 );
2208 assert_ne!(PaletteAction::Dismiss, PaletteAction::Execute("x".into()));
2209 }
2210
2211 #[test]
2212 fn match_filter_allows_all() {
2213 assert!(MatchFilter::All.allows(MatchType::Exact));
2214 assert!(MatchFilter::All.allows(MatchType::Prefix));
2215 assert!(MatchFilter::All.allows(MatchType::WordStart));
2216 assert!(MatchFilter::All.allows(MatchType::Substring));
2217 assert!(MatchFilter::All.allows(MatchType::Fuzzy));
2218 }
2219
2220 #[test]
2221 fn match_filter_specific_types() {
2222 assert!(MatchFilter::Exact.allows(MatchType::Exact));
2223 assert!(!MatchFilter::Exact.allows(MatchType::Fuzzy));
2224 assert!(MatchFilter::Fuzzy.allows(MatchType::Fuzzy));
2225 assert!(!MatchFilter::Fuzzy.allows(MatchType::Exact));
2226 }
2227
2228 #[test]
2229 fn palette_default_trait() {
2230 let palette = CommandPalette::default();
2231 assert!(!palette.is_visible());
2232 assert_eq!(palette.action_count(), 0);
2233 assert_eq!(palette.query(), "");
2234 }
2235
2236 #[test]
2237 fn with_max_visible_builder() {
2238 let palette = CommandPalette::new().with_max_visible(5);
2239 let mut palette = palette;
2241 for i in 0..10 {
2242 palette.register(format!("Action {i}"), None, &[]);
2243 }
2244 palette.open();
2245 assert_eq!(palette.result_count(), 10);
2246 }
2247
2248 #[test]
2249 fn scorer_stats_accessible() {
2250 let mut palette = CommandPalette::new();
2251 palette.register("Alpha", None, &[]);
2252 palette.open();
2253 palette.set_query("a");
2254 let stats = palette.scorer_stats();
2255 assert!(stats.full_scans + stats.incremental_scans >= 1);
2256 }
2257
2258 #[test]
2259 fn selected_match_returns_match() {
2260 let mut palette = CommandPalette::new();
2261 palette.register("Hello World", None, &[]);
2262 palette.open();
2263 palette.set_query("hello");
2264 let m = palette.selected_match();
2265 assert!(m.is_some());
2266 assert_eq!(m.unwrap().action.title, "Hello World");
2267 }
2268
2269 #[test]
2270 fn results_iterator_returns_matches() {
2271 let mut palette = CommandPalette::new();
2272 palette.register("Alpha", None, &[]);
2273 palette.register("Beta", None, &[]);
2274 palette.open();
2275 let count = palette.results().count();
2276 assert_eq!(count, 2);
2277 }
2278
2279 #[test]
2280 fn set_match_filter_narrows_results() {
2281 let mut palette = CommandPalette::new();
2282 palette.register("Open File", None, &[]);
2283 palette.register("Save File", None, &[]);
2284 palette.open();
2285 palette.set_query("open");
2286 let before = palette.result_count();
2287
2288 palette.set_match_filter(MatchFilter::Exact);
2290 let after = palette.result_count();
2291 assert!(after <= before);
2292 }
2293
2294 #[test]
2295 fn prefix_filter_uses_art_candidate_set() {
2296 let mut palette = CommandPalette::new();
2297 for idx in 0..40 {
2298 palette.register_action(ActionItem::new(
2299 format!("file-{idx:02}"),
2300 format!("File Command {idx:02}"),
2301 ));
2302 }
2303 for idx in 0..80 {
2304 palette.register_action(ActionItem::new(
2305 format!("edit-{idx:02}"),
2306 format!("Edit Command {idx:02}"),
2307 ));
2308 }
2309
2310 palette.open();
2311 palette.set_match_filter(MatchFilter::Prefix);
2312
2313 let before = palette.scorer_stats().total_evaluated;
2314 palette.set_query("file");
2315 let evaluated_for_query = palette.scorer_stats().total_evaluated - before;
2316
2317 assert_eq!(palette.result_count(), 40);
2318 assert_eq!(evaluated_for_query, 40);
2319 }
2320
2321 #[test]
2322 fn prefix_filter_preserves_duplicate_titles() {
2323 let mut palette = CommandPalette::new();
2324 palette.register_action(ActionItem::new("open-file-a", "Open File"));
2325 palette.register_action(ActionItem::new("open-file-b", "Open File"));
2326 palette.register_action(ActionItem::new("open-folder", "Open Folder"));
2327
2328 palette.open();
2329 palette.set_match_filter(MatchFilter::Prefix);
2330 palette.set_query("open f");
2331
2332 let ids: Vec<&str> = palette.results().map(|m| m.action.id.as_str()).collect();
2333 assert_eq!(ids.len(), 3);
2334 assert!(ids.contains(&"open-file-a"));
2335 assert!(ids.contains(&"open-file-b"));
2336 assert!(ids.contains(&"open-folder"));
2337 }
2338
2339 #[test]
2340 fn prefix_filter_does_not_poison_all_match_cache() {
2341 let mut palette = CommandPalette::new();
2342 palette.register("Open Preferences", None, &[]);
2343 palette.register("Preferences: Open", None, &[]);
2344
2345 palette.open();
2346 palette.set_match_filter(MatchFilter::Prefix);
2347 palette.set_query("pref");
2348 assert_eq!(palette.result_count(), 1);
2349
2350 palette.set_match_filter(MatchFilter::All);
2351 let titles: Vec<&str> = palette.results().map(|m| m.action.title.as_str()).collect();
2352 assert!(titles.contains(&"Open Preferences"));
2353 assert!(titles.contains(&"Preferences: Open"));
2354 }
2355
2356 #[test]
2357 fn replace_actions_rebuilds_prefix_index() {
2358 let mut palette = CommandPalette::new();
2359 palette.register_action(ActionItem::new("open-file", "Open File"));
2360
2361 palette.open();
2362 palette.set_match_filter(MatchFilter::Prefix);
2363 palette.set_query("open");
2364 assert_eq!(palette.result_count(), 1);
2365
2366 palette.replace_actions(vec![ActionItem::new("save-file", "Save File")]);
2367 assert_eq!(palette.result_count(), 0);
2368
2369 palette.set_query("save");
2370 assert_eq!(palette.result_count(), 1);
2371 assert_eq!(
2372 palette.selected_action().map(|action| action.id.as_str()),
2373 Some("save-file")
2374 );
2375 }
2376
2377 #[test]
2378 fn enter_with_no_results_returns_none() {
2379 let mut palette = CommandPalette::new();
2380 palette.register("Alpha", None, &[]);
2381 palette.open();
2382 palette.set_query("zzzznotfound");
2383 assert_eq!(palette.result_count(), 0);
2384
2385 let enter = Event::Key(KeyEvent {
2386 code: KeyCode::Enter,
2387 modifiers: Modifiers::empty(),
2388 kind: KeyEventKind::Press,
2389 });
2390 let result = palette.handle_event(&enter);
2391 assert!(result.is_none());
2392 }
2393
2394 #[cfg(feature = "tracing")]
2395 #[test]
2396 fn telemetry_emits_in_order() {
2397 use std::sync::{Arc, Mutex};
2398 use tracing::Subscriber;
2399 use tracing_subscriber::Layer;
2400 use tracing_subscriber::filter::Targets;
2401 use tracing_subscriber::layer::{Context, SubscriberExt};
2402
2403 #[derive(Default)]
2404 struct EventCapture {
2405 events: Arc<Mutex<Vec<String>>>,
2406 }
2407
2408 impl<S> Layer<S> for EventCapture
2409 where
2410 S: Subscriber,
2411 {
2412 fn on_event(&self, event: &tracing::Event<'_>, _ctx: Context<'_, S>) {
2413 use tracing::field::{Field, Visit};
2414
2415 struct EventVisitor {
2416 name: Option<String>,
2417 }
2418
2419 impl Visit for EventVisitor {
2420 fn record_str(&mut self, field: &Field, value: &str) {
2421 if field.name() == "event" {
2422 self.name = Some(value.to_string());
2423 }
2424 }
2425
2426 fn record_debug(&mut self, field: &Field, value: &dyn std::fmt::Debug) {
2427 if field.name() == "event" {
2428 let raw = format!("{value:?}");
2429 let normalized = raw.trim_matches('\"').to_string();
2430 self.name = Some(normalized);
2431 }
2432 }
2433 }
2434
2435 let mut visitor = EventVisitor { name: None };
2436 event.record(&mut visitor);
2437 if let Some(name) = visitor.name {
2438 self.events
2439 .lock()
2440 .expect("lock telemetry events")
2441 .push(name);
2442 }
2443 }
2444 }
2445
2446 let events = Arc::new(Mutex::new(Vec::new()));
2447 let capture = EventCapture {
2448 events: Arc::clone(&events),
2449 };
2450 let _trace_test_guard = crate::tracing_test_support::acquire();
2451
2452 let subscriber = tracing_subscriber::registry()
2453 .with(capture)
2454 .with(Targets::new().with_target(TELEMETRY_TARGET, tracing::Level::INFO));
2455 let _guard = tracing::subscriber::set_default(subscriber);
2456
2457 let mut palette = CommandPalette::new();
2461 palette.register("Alpha", None, &[]);
2462 tracing::callsite::rebuild_interest_cache();
2463 palette.open();
2464
2465 let a = Event::Key(KeyEvent {
2466 code: KeyCode::Char('a'),
2467 modifiers: Modifiers::empty(),
2468 kind: KeyEventKind::Press,
2469 });
2470 tracing::callsite::rebuild_interest_cache();
2471 let _ = palette.handle_event(&a);
2472
2473 let enter = Event::Key(KeyEvent {
2474 code: KeyCode::Enter,
2475 modifiers: Modifiers::empty(),
2476 kind: KeyEventKind::Press,
2477 });
2478 tracing::callsite::rebuild_interest_cache();
2479 let _ = palette.handle_event(&enter);
2480 tracing::callsite::rebuild_interest_cache();
2481 palette.close();
2482
2483 let events = events.lock().expect("lock telemetry events");
2484 let open_idx = events
2485 .iter()
2486 .position(|e| e == "palette_opened")
2487 .expect("palette_opened missing");
2488 let query_idx = events
2489 .iter()
2490 .position(|e| e == "palette_query_updated")
2491 .expect("palette_query_updated missing");
2492 let exec_idx = events
2493 .iter()
2494 .position(|e| e == "palette_action_executed")
2495 .expect("palette_action_executed missing");
2496 let close_idx = events
2497 .iter()
2498 .position(|e| e == "palette_closed")
2499 .expect("palette_closed missing");
2500
2501 assert!(open_idx < query_idx);
2502 assert!(query_idx < exec_idx);
2503 assert!(exec_idx < close_idx);
2504 }
2505
2506 #[test]
2511 fn compute_word_starts_empty() {
2512 let starts = compute_word_starts("");
2513 assert!(starts.is_empty());
2514 }
2515
2516 #[test]
2517 fn compute_word_starts_single_word() {
2518 let starts = compute_word_starts("hello");
2519 assert_eq!(starts, vec![0]);
2520 }
2521
2522 #[test]
2523 fn compute_word_starts_spaces() {
2524 let starts = compute_word_starts("open file now");
2525 assert_eq!(starts, vec![0, 5, 10]);
2526 }
2527
2528 #[test]
2529 fn compute_word_starts_hyphen_underscore() {
2530 let starts = compute_word_starts("git-commit_push");
2531 assert_eq!(starts, vec![0, 4, 11]);
2533 }
2534
2535 #[test]
2536 fn compute_word_starts_all_separators() {
2537 let starts = compute_word_starts("- _");
2538 assert_eq!(starts, vec![0, 1, 2]);
2541 }
2542
2543 #[test]
2544 fn backspace_on_empty_query_is_noop() {
2545 let mut palette = CommandPalette::new();
2546 palette.register("Alpha", None, &[]);
2547 palette.open();
2548 assert_eq!(palette.query(), "");
2549
2550 let bs = Event::Key(KeyEvent {
2551 code: KeyCode::Backspace,
2552 modifiers: Modifiers::empty(),
2553 kind: KeyEventKind::Press,
2554 });
2555 let _ = palette.handle_event(&bs);
2556 assert_eq!(palette.query(), "");
2557 assert_eq!(palette.result_count(), 1);
2559 }
2560
2561 #[test]
2562 fn ctrl_a_moves_cursor_to_start() {
2563 let mut palette = CommandPalette::new();
2564 palette.register("Alpha", None, &[]);
2565 palette.open();
2566
2567 for ch in "abc".chars() {
2569 let event = Event::Key(KeyEvent {
2570 code: KeyCode::Char(ch),
2571 modifiers: Modifiers::empty(),
2572 kind: KeyEventKind::Press,
2573 });
2574 let _ = palette.handle_event(&event);
2575 }
2576 assert_eq!(palette.query(), "abc");
2577
2578 let ctrl_a = Event::Key(KeyEvent {
2579 code: KeyCode::Char('a'),
2580 modifiers: Modifiers::CTRL,
2581 kind: KeyEventKind::Press,
2582 });
2583 let _ = palette.handle_event(&ctrl_a);
2584 assert_eq!(palette.query(), "abc");
2586 }
2587
2588 #[test]
2589 fn key_release_events_ignored() {
2590 let mut palette = CommandPalette::new();
2591 palette.register("Alpha", None, &[]);
2592 palette.open();
2593
2594 let release = Event::Key(KeyEvent {
2595 code: KeyCode::Char('x'),
2596 modifiers: Modifiers::empty(),
2597 kind: KeyEventKind::Release,
2598 });
2599 let result = palette.handle_event(&release);
2600 assert!(result.is_none());
2601 assert_eq!(palette.query(), "");
2602 }
2603
2604 #[test]
2605 fn resize_event_ignored() {
2606 let mut palette = CommandPalette::new();
2607 palette.open();
2608
2609 let resize = Event::Resize {
2610 width: 80,
2611 height: 24,
2612 };
2613 let result = palette.handle_event(&resize);
2614 assert!(result.is_none());
2615 }
2616
2617 #[test]
2618 fn is_essential_returns_true() {
2619 let palette = CommandPalette::new();
2620 assert!(palette.is_essential());
2621 }
2622
2623 #[test]
2624 fn render_too_small_area_noop() {
2625 use ftui_render::grapheme_pool::GraphemePool;
2626
2627 let mut palette = CommandPalette::new();
2628 palette.register("Alpha", None, &[]);
2629 palette.open();
2630
2631 let area = Rect::new(0, 0, 9, 10);
2633 let mut pool = GraphemePool::new();
2634 let mut frame = Frame::new(20, 20, &mut pool);
2635 palette.render(area, &mut frame);
2636 assert!(frame.cursor_position.is_none());
2638 }
2639
2640 #[test]
2641 fn render_too_short_area_noop() {
2642 use ftui_render::grapheme_pool::GraphemePool;
2643
2644 let mut palette = CommandPalette::new();
2645 palette.register("Alpha", None, &[]);
2646 palette.open();
2647
2648 let area = Rect::new(0, 0, 60, 4);
2650 let mut pool = GraphemePool::new();
2651 let mut frame = Frame::new(60, 10, &mut pool);
2652 palette.render(area, &mut frame);
2653 assert!(frame.cursor_position.is_none());
2654 }
2655
2656 #[test]
2657 fn render_hidden_palette_noop() {
2658 use ftui_render::grapheme_pool::GraphemePool;
2659
2660 let palette = CommandPalette::new();
2661 assert!(!palette.is_visible());
2662
2663 let area = Rect::from_size(60, 10);
2664 let mut pool = GraphemePool::new();
2665 let mut frame = Frame::new(60, 10, &mut pool);
2666 palette.render(area, &mut frame);
2667 assert!(frame.cursor_position.is_none());
2668 }
2669
2670 #[test]
2671 fn render_empty_palette_shows_no_actions_hint() {
2672 use ftui_render::grapheme_pool::GraphemePool;
2673
2674 let mut palette = CommandPalette::new();
2675 palette.open();
2677
2678 let area = Rect::from_size(60, 15);
2679 let mut pool = GraphemePool::new();
2680 let mut frame = Frame::new(60, 15, &mut pool);
2681 palette.render(area, &mut frame);
2682
2683 let palette_y = area.y + area.height / 6;
2685 let result_y = palette_y + 2;
2686 let mut found_n = false;
2687 for x in 0..60u16 {
2688 if let Some(cell) = frame.buffer.get(x, result_y)
2689 && cell.content.as_char() == Some('N')
2690 {
2691 found_n = true;
2692 break;
2693 }
2694 }
2695 assert!(found_n, "Should render 'No actions registered' hint");
2696 }
2697
2698 #[test]
2699 fn render_query_no_results_shows_hint() {
2700 use ftui_render::grapheme_pool::GraphemePool;
2701
2702 let mut palette = CommandPalette::new();
2703 palette.register("Alpha", None, &[]);
2704 palette.open();
2705 palette.set_query("zzzznotfound");
2706 assert_eq!(palette.result_count(), 0);
2707
2708 let area = Rect::from_size(60, 15);
2709 let mut pool = GraphemePool::new();
2710 let mut frame = Frame::new(60, 15, &mut pool);
2711 palette.render(area, &mut frame);
2712
2713 let palette_y = area.y + area.height / 6;
2715 let result_y = palette_y + 2;
2716 let mut found_n = false;
2717 for x in 0..60u16 {
2718 if let Some(cell) = frame.buffer.get(x, result_y)
2719 && cell.content.as_char() == Some('N')
2720 {
2721 found_n = true;
2722 break;
2723 }
2724 }
2725 assert!(found_n, "Should render 'No results' hint");
2726 }
2727
2728 #[test]
2729 fn render_with_category_badge() {
2730 use ftui_render::grapheme_pool::GraphemePool;
2731
2732 let mut palette = CommandPalette::new();
2733 let item = ActionItem::new("git_commit", "Commit Changes").with_category("Git");
2734 palette.register_action(item);
2735 palette.open();
2736
2737 let area = Rect::from_size(80, 15);
2738 let mut pool = GraphemePool::new();
2739 let mut frame = Frame::new(80, 15, &mut pool);
2740 palette.render(area, &mut frame);
2741
2742 let palette_y = area.y + area.height / 6;
2744 let result_y = palette_y + 2;
2745 let mut found_bracket = false;
2746 for x in 0..80u16 {
2747 if let Some(cell) = frame.buffer.get(x, result_y)
2748 && cell.content.as_char() == Some('[')
2749 {
2750 found_bracket = true;
2751 break;
2752 }
2753 }
2754 assert!(found_bracket, "Should render category badge '[Git]'");
2755 }
2756
2757 #[test]
2758 fn render_with_description_text() {
2759 use ftui_render::grapheme_pool::GraphemePool;
2760
2761 let mut palette = CommandPalette::new();
2762 palette.register("Open File", Some("Opens a file from disk"), &[]);
2763 palette.open();
2764
2765 let area = Rect::from_size(80, 15);
2766 let mut pool = GraphemePool::new();
2767 let mut frame = Frame::new(80, 15, &mut pool);
2768 palette.render(area, &mut frame);
2769
2770 let palette_y = area.y + area.height / 6;
2772 let result_y = palette_y + 2;
2773 let mut found_desc_char = false;
2774 for x in 20..80u16 {
2776 if let Some(cell) = frame.buffer.get(x, result_y)
2777 && cell.content.as_char() == Some('O')
2778 {
2779 found_desc_char = true;
2780 break;
2781 }
2782 }
2783 assert!(found_desc_char, "Description text should be rendered");
2784 }
2785
2786 #[test]
2787 fn open_resets_previous_state() {
2788 let mut palette = CommandPalette::new();
2789 palette.register("Alpha", None, &[]);
2790 palette.register("Beta", None, &[]);
2791 palette.open();
2792 palette.set_query("Alpha");
2793
2794 let down = Event::Key(KeyEvent {
2796 code: KeyCode::Down,
2797 modifiers: Modifiers::empty(),
2798 kind: KeyEventKind::Press,
2799 });
2800 let _ = palette.handle_event(&down);
2801
2802 palette.open();
2804 assert_eq!(palette.query(), "");
2805 assert_eq!(palette.selected_index(), 0);
2806 assert_eq!(palette.result_count(), 2);
2807 }
2808
2809 #[test]
2810 fn set_match_filter_same_value_is_noop() {
2811 let mut palette = CommandPalette::new();
2812 palette.register("Alpha", None, &[]);
2813 palette.open();
2814 palette.set_query("alpha");
2815
2816 palette.set_match_filter(MatchFilter::All);
2817 let count1 = palette.result_count();
2818 palette.set_match_filter(MatchFilter::All);
2820 assert_eq!(palette.result_count(), count1);
2821 }
2822
2823 #[test]
2824 fn generation_increments_on_register() {
2825 let mut palette = CommandPalette::new();
2826 palette.register("A", None, &[]);
2827 palette.register("B", None, &[]);
2828 palette.replace_actions(vec![ActionItem::new("c", "C")]);
2831 palette.open();
2832 assert_eq!(palette.action_count(), 1);
2833 }
2834
2835 #[test]
2836 fn enable_evidence_tracking_toggle() {
2837 let mut palette = CommandPalette::new();
2838 palette.register("Alpha", None, &[]);
2839 palette.open();
2840
2841 palette.enable_evidence_tracking(true);
2842 palette.set_query("alpha");
2843 assert!(palette.result_count() >= 1);
2844
2845 palette.enable_evidence_tracking(false);
2846 palette.set_query("alpha");
2847 assert!(palette.result_count() >= 1);
2848 }
2849
2850 #[test]
2851 fn register_chaining() {
2852 let mut palette = CommandPalette::new();
2853 palette
2854 .register("A", None, &[])
2855 .register("B", None, &[])
2856 .register("C", Some("desc"), &["tag"]);
2857 assert_eq!(palette.action_count(), 3);
2858 }
2859
2860 #[test]
2861 fn register_action_chaining() {
2862 let mut palette = CommandPalette::new();
2863 palette
2864 .register_action(ActionItem::new("a", "A"))
2865 .register_action(ActionItem::new("b", "B"));
2866 assert_eq!(palette.action_count(), 2);
2867 }
2868
2869 #[test]
2870 fn page_up_down_navigation() {
2871 let mut palette = CommandPalette::new().with_max_visible(3);
2872 for i in 0..10 {
2873 palette.register(format!("Action {i}"), None, &[]);
2874 }
2875 palette.open();
2876 assert_eq!(palette.selected_index(), 0);
2877
2878 let pgdn = Event::Key(KeyEvent {
2879 code: KeyCode::PageDown,
2880 modifiers: Modifiers::empty(),
2881 kind: KeyEventKind::Press,
2882 });
2883 let _ = palette.handle_event(&pgdn);
2884 assert_eq!(palette.selected_index(), 3); let _ = palette.handle_event(&pgdn);
2887 assert_eq!(palette.selected_index(), 6);
2888
2889 let _ = palette.handle_event(&pgdn);
2890 assert_eq!(palette.selected_index(), 9); let pgup = Event::Key(KeyEvent {
2893 code: KeyCode::PageUp,
2894 modifiers: Modifiers::empty(),
2895 kind: KeyEventKind::Press,
2896 });
2897 let _ = palette.handle_event(&pgup);
2898 assert_eq!(palette.selected_index(), 6); let _ = palette.handle_event(&pgup);
2901 assert_eq!(palette.selected_index(), 3);
2902
2903 let _ = palette.handle_event(&pgup);
2904 assert_eq!(palette.selected_index(), 0);
2905 }
2906
2907 #[test]
2908 fn page_down_empty_results_is_noop() {
2909 let mut palette = CommandPalette::new();
2910 palette.open();
2911 assert_eq!(palette.result_count(), 0);
2912
2913 let pgdn = Event::Key(KeyEvent {
2914 code: KeyCode::PageDown,
2915 modifiers: Modifiers::empty(),
2916 kind: KeyEventKind::Press,
2917 });
2918 let _ = palette.handle_event(&pgdn);
2919 assert_eq!(palette.selected_index(), 0);
2920 }
2921
2922 #[test]
2923 fn end_empty_results_is_noop() {
2924 let mut palette = CommandPalette::new();
2925 palette.open();
2926 assert_eq!(palette.result_count(), 0);
2927
2928 let end = Event::Key(KeyEvent {
2929 code: KeyCode::End,
2930 modifiers: Modifiers::empty(),
2931 kind: KeyEventKind::Press,
2932 });
2933 let _ = palette.handle_event(&end);
2934 assert_eq!(palette.selected_index(), 0);
2935 }
2936
2937 #[test]
2938 fn down_empty_results_is_noop() {
2939 let mut palette = CommandPalette::new();
2940 palette.open();
2941 assert_eq!(palette.result_count(), 0);
2942
2943 let down = Event::Key(KeyEvent {
2944 code: KeyCode::Down,
2945 modifiers: Modifiers::empty(),
2946 kind: KeyEventKind::Press,
2947 });
2948 let _ = palette.handle_event(&down);
2949 assert_eq!(palette.selected_index(), 0);
2950 }
2951
2952 #[test]
2953 fn selected_action_none_when_empty() {
2954 let mut palette = CommandPalette::new();
2955 palette.open();
2956 assert!(palette.selected_action().is_none());
2957 assert!(palette.selected_match().is_none());
2958 }
2959
2960 #[test]
2961 fn results_iterator_empty() {
2962 let mut palette = CommandPalette::new();
2963 palette.open();
2964 assert_eq!(palette.results().count(), 0);
2965 }
2966
2967 #[test]
2968 fn scroll_adjust_keeps_selection_visible() {
2969 let mut palette = CommandPalette::new().with_max_visible(3);
2970 for i in 0..10 {
2971 palette.register(format!("Action {i}"), None, &[]);
2972 }
2973 palette.open();
2974
2975 let end = Event::Key(KeyEvent {
2976 code: KeyCode::End,
2977 modifiers: Modifiers::empty(),
2978 kind: KeyEventKind::Press,
2979 });
2980 let _ = palette.handle_event(&end);
2981 assert_eq!(palette.selected_index(), 9);
2982 let home = Event::Key(KeyEvent {
2986 code: KeyCode::Home,
2987 modifiers: Modifiers::empty(),
2988 kind: KeyEventKind::Press,
2989 });
2990 let _ = palette.handle_event(&home);
2991 assert_eq!(palette.selected_index(), 0);
2992 }
2993
2994 #[test]
2995 fn update_filtered_clamps_scroll_offset_after_results_shrink() {
2996 let mut palette = CommandPalette::new().with_max_visible(3);
2997 for i in 0..10 {
2998 palette.register(format!("Action {i}"), None, &[]);
2999 }
3000 palette.open();
3001
3002 let end = Event::Key(KeyEvent {
3003 code: KeyCode::End,
3004 modifiers: Modifiers::empty(),
3005 kind: KeyEventKind::Press,
3006 });
3007 let _ = palette.handle_event(&end);
3008 assert!(palette.scroll_offset > 0);
3009
3010 palette.actions.truncate(1);
3011 palette.rebuild_title_cache();
3012 palette.generation = palette.generation.wrapping_add(1);
3013 palette.update_filtered(false);
3014
3015 assert_eq!(palette.result_count(), 1);
3016 assert_eq!(palette.selected, 0);
3017 assert_eq!(palette.scroll_offset, 0);
3018 assert_eq!(
3019 palette
3020 .selected_action()
3021 .map(|action| action.title.as_str()),
3022 Some("Action 0")
3023 );
3024 }
3025
3026 #[test]
3027 fn action_item_clone() {
3028 let item = ActionItem::new("id", "Title")
3029 .with_description("Desc")
3030 .with_tags(&["a", "b"])
3031 .with_category("Cat");
3032 let cloned = item.clone();
3033 assert_eq!(cloned.id, "id");
3034 assert_eq!(cloned.title, "Title");
3035 assert_eq!(cloned.description.as_deref(), Some("Desc"));
3036 assert_eq!(cloned.tags, vec!["a", "b"]);
3037 assert_eq!(cloned.category.as_deref(), Some("Cat"));
3038 }
3039
3040 #[test]
3041 fn action_item_debug() {
3042 let item = ActionItem::new("id", "Title");
3043 let debug = format!("{:?}", item);
3044 assert!(debug.contains("ActionItem"));
3045 assert!(debug.contains("Title"));
3046 }
3047
3048 #[test]
3049 fn palette_action_clone_and_debug() {
3050 let exec = PaletteAction::Execute("test".into());
3051 let cloned = exec.clone();
3052 assert_eq!(exec, cloned);
3053
3054 let dismiss = PaletteAction::Dismiss;
3055 let debug = format!("{:?}", dismiss);
3056 assert!(debug.contains("Dismiss"));
3057 }
3058
3059 #[test]
3060 fn match_filter_traits() {
3061 let f = MatchFilter::Fuzzy;
3063 let debug = format!("{:?}", f);
3064 assert!(debug.contains("Fuzzy"));
3065
3066 let f2 = f;
3068 assert_eq!(f, f2);
3069
3070 assert_eq!(MatchFilter::All, MatchFilter::All);
3072 assert_ne!(MatchFilter::Exact, MatchFilter::Prefix);
3073 }
3074
3075 #[test]
3076 fn match_filter_specific_allows() {
3077 assert!(MatchFilter::Prefix.allows(MatchType::Prefix));
3078 assert!(!MatchFilter::Prefix.allows(MatchType::Exact));
3079 assert!(!MatchFilter::Prefix.allows(MatchType::Substring));
3080
3081 assert!(MatchFilter::WordStart.allows(MatchType::WordStart));
3082 assert!(!MatchFilter::WordStart.allows(MatchType::Fuzzy));
3083
3084 assert!(MatchFilter::Substring.allows(MatchType::Substring));
3085 assert!(!MatchFilter::Substring.allows(MatchType::WordStart));
3086 }
3087
3088 #[test]
3089 fn palette_style_default_has_all_colors() {
3090 let style = PaletteStyle::default();
3091 assert!(style.border.fg.is_some());
3092 assert!(style.input.fg.is_some());
3093 assert!(style.item.fg.is_some());
3094 assert!(style.item_selected.fg.is_some());
3095 assert!(style.item_selected.bg.is_some());
3096 assert!(style.match_highlight.fg.is_some());
3097 assert!(style.description.fg.is_some());
3098 assert!(style.category.fg.is_some());
3099 assert!(style.hint.fg.is_some());
3100 }
3101
3102 #[test]
3103 fn palette_style_debug_and_clone() {
3104 let style = PaletteStyle::default();
3105 let debug = format!("{:?}", style);
3106 assert!(debug.contains("PaletteStyle"));
3107
3108 let cloned = style.clone();
3109 assert_eq!(cloned.border.fg, style.border.fg);
3111 }
3112
3113 #[test]
3114 fn with_style_builder() {
3115 let style = PaletteStyle::default();
3116 let palette = CommandPalette::new().with_style(style);
3117 assert!(!palette.is_visible());
3119 }
3120
3121 #[test]
3122 fn command_palette_debug() {
3123 let mut palette = CommandPalette::new();
3124 palette.register("Alpha", None, &[]);
3125 let debug = format!("{:?}", palette);
3126 assert!(debug.contains("CommandPalette"));
3127 }
3128
3129 #[test]
3130 fn unrecognized_key_returns_none() {
3131 let mut palette = CommandPalette::new();
3132 palette.open();
3133
3134 let tab = Event::Key(KeyEvent {
3135 code: KeyCode::Tab,
3136 modifiers: Modifiers::empty(),
3137 kind: KeyEventKind::Press,
3138 });
3139 let result = palette.handle_event(&tab);
3140 assert!(result.is_none());
3141 }
3142
3143 #[test]
3144 fn ctrl_p_when_visible_does_not_reopen() {
3145 let mut palette = CommandPalette::new();
3146 palette.register("Alpha", None, &[]);
3147 palette.open();
3148 palette.set_query("test");
3149
3150 let ctrl_p = Event::Key(KeyEvent {
3152 code: KeyCode::Char('p'),
3153 modifiers: Modifiers::CTRL,
3154 kind: KeyEventKind::Press,
3155 });
3156 let _ = palette.handle_event(&ctrl_p);
3157 assert!(palette.is_visible());
3159 }
3160
3161 #[test]
3162 fn close_clears_query_and_results() {
3163 let mut palette = CommandPalette::new();
3164 palette.register("Alpha", None, &[]);
3165 palette.open();
3166 palette.set_query("alpha");
3167 assert!(!palette.query().is_empty());
3168 assert!(palette.result_count() > 0);
3169
3170 palette.close();
3171 assert!(!palette.is_visible());
3172 assert_eq!(palette.query(), "");
3173 assert_eq!(palette.result_count(), 0);
3174 }
3175
3176 #[test]
3177 fn render_cursor_position_set() {
3178 use ftui_render::grapheme_pool::GraphemePool;
3179
3180 let mut palette = CommandPalette::new();
3181 palette.register("Alpha", None, &[]);
3182 palette.open();
3183
3184 let area = Rect::from_size(60, 15);
3185 let mut pool = GraphemePool::new();
3186 let mut frame = Frame::new(60, 15, &mut pool);
3187 palette.render(area, &mut frame);
3188
3189 assert!(frame.cursor_position.is_some());
3190 assert!(frame.cursor_visible);
3191 }
3192
3193 #[test]
3194 fn render_uses_rounded_corners_for_overlay_border() {
3195 use ftui_render::grapheme_pool::GraphemePool;
3196
3197 let mut palette = CommandPalette::new();
3198 palette.register("Alpha", None, &[]);
3199 palette.open();
3200
3201 let area = Rect::from_size(60, 15);
3202 let mut pool = GraphemePool::new();
3203 let mut frame = Frame::new(60, 15, &mut pool);
3204 palette.render(area, &mut frame);
3205
3206 let palette_width = (area.width * 3 / 5).max(30).min(area.width - 2);
3207 let result_rows = palette.result_count().min(palette.max_visible);
3208 let palette_height = (result_rows as u16 + 3)
3209 .max(5)
3210 .min(area.height.saturating_sub(2));
3211 let palette_x = area.x + (area.width.saturating_sub(palette_width)) / 2;
3212 let palette_y = area.y + area.height / 6;
3213 let right = palette_x + palette_width - 1;
3214 let bottom = palette_y + palette_height - 1;
3215
3216 assert_eq!(
3217 frame
3218 .buffer
3219 .get(palette_x, palette_y)
3220 .and_then(|c| c.content.as_char()),
3221 Some('╭')
3222 );
3223 assert_eq!(
3224 frame
3225 .buffer
3226 .get(right, palette_y)
3227 .and_then(|c| c.content.as_char()),
3228 Some('╮')
3229 );
3230 assert_eq!(
3231 frame
3232 .buffer
3233 .get(palette_x, bottom)
3234 .and_then(|c| c.content.as_char()),
3235 Some('╰')
3236 );
3237 assert_eq!(
3238 frame
3239 .buffer
3240 .get(right, bottom)
3241 .and_then(|c| c.content.as_char()),
3242 Some('╯')
3243 );
3244 }
3245
3246 #[test]
3247 fn render_many_items_with_scroll() {
3248 use ftui_render::grapheme_pool::GraphemePool;
3249
3250 let mut palette = CommandPalette::new().with_max_visible(3);
3251 for i in 0..20 {
3252 palette.register(format!("Action {i}"), None, &[]);
3253 }
3254 palette.open();
3255
3256 let end = Event::Key(KeyEvent {
3258 code: KeyCode::End,
3259 modifiers: Modifiers::empty(),
3260 kind: KeyEventKind::Press,
3261 });
3262 let _ = palette.handle_event(&end);
3263
3264 let area = Rect::from_size(60, 15);
3265 let mut pool = GraphemePool::new();
3266 let mut frame = Frame::new(60, 15, &mut pool);
3267 palette.render(area, &mut frame);
3269 assert!(frame.cursor_position.is_some());
3270 }
3271}
3272mod property_tests;