Skip to main content

tinyharness_ui/tui/
event.rs

1// ── Event system for the TUI ──────────────────────────────────────────────────
2//
3// Defines keyboard, mouse, and resize events, plus a cross-platform
4// event reader that parses raw terminal input into structured events.
5
6use std::io;
7use std::time::Duration;
8
9// ── Key and modifier types ─────────────────────────────────────────────────
10
11/// A keyboard key press event.
12#[derive(Clone, Debug, PartialEq, Eq, Hash)]
13pub struct KeyEvent {
14    pub key: Key,
15    pub modifiers: Modifiers,
16}
17
18/// A keyboard key.
19#[derive(Clone, Debug, PartialEq, Eq, Hash)]
20pub enum Key {
21    /// A printable character.
22    Char(char),
23    /// Enter/Return key.
24    Enter,
25    /// Escape key.
26    Escape,
27    /// Backspace key.
28    Backspace,
29    /// Delete key.
30    Delete,
31    /// Tab key.
32    Tab,
33    /// Backtab (Shift+Tab).
34    BackTab,
35    /// Arrow keys.
36    Up,
37    Down,
38    Left,
39    Right,
40    /// Home key.
41    Home,
42    /// End key.
43    End,
44    /// Page Up key.
45    PageUp,
46    /// Page Down key.
47    PageDown,
48    /// Insert key.
49    Insert,
50    /// Function keys F1–F12.
51    F(u8),
52}
53
54/// Keyboard modifier flags.
55#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
56pub struct Modifiers {
57    pub ctrl: bool,
58    pub alt: bool,
59    pub shift: bool,
60}
61
62impl Modifiers {
63    pub fn new() -> Self {
64        Self::default()
65    }
66
67    pub fn ctrl() -> Self {
68        Self {
69            ctrl: true,
70            ..Self::default()
71        }
72    }
73
74    pub fn alt() -> Self {
75        Self {
76            alt: true,
77            ..Self::default()
78        }
79    }
80
81    pub fn shift() -> Self {
82        Self {
83            shift: true,
84            ..Self::default()
85        }
86    }
87}
88
89// ── Mouse events ─────────────────────────────────────────────────────────────
90
91/// A mouse event.
92#[derive(Clone, Debug, PartialEq)]
93pub enum MouseEvent {
94    /// Mouse button pressed.
95    Press {
96        row: u16,
97        col: u16,
98        button: MouseButton,
99    },
100    /// Mouse button released.
101    Release { row: u16, col: u16 },
102    /// Mouse wheel scrolled up.
103    ScrollUp { row: u16, col: u16 },
104    /// Mouse wheel scrolled down.
105    ScrollDown { row: u16, col: u16 },
106    /// Mouse moved (hover/drag).
107    Move { row: u16, col: u16 },
108}
109
110/// Mouse button.
111#[derive(Clone, Copy, Debug, PartialEq, Eq)]
112pub enum MouseButton {
113    Left,
114    Right,
115    Middle,
116}
117
118// ── Top-level event enum ────────────────────────────────────────────────────
119
120/// An event from the terminal.
121#[derive(Clone, Debug, PartialEq)]
122pub enum Event {
123    /// A key was pressed.
124    Key(KeyEvent),
125    /// A mouse event occurred.
126    Mouse(MouseEvent),
127    /// The terminal was resized.
128    Resize { cols: u16, rows: u16 },
129    /// A paste event (bracketed paste mode).
130    Paste(String),
131}
132
133// ── Event parser ─────────────────────────────────────────────────────────────
134
135/// Parses raw bytes from stdin into events.
136///
137/// Terminal input arrives as a stream of bytes. Escape sequences can be
138/// multi-byte (e.g., `\x1b[A` for Up arrow, `\x1b[1;5C` for Ctrl+Right).
139/// The parser accumulates bytes until a complete sequence is recognized.
140#[derive(Default)]
141pub struct EventParser {
142    buf: Vec<u8>,
143}
144
145impl EventParser {
146    pub fn new() -> Self {
147        Self { buf: Vec::new() }
148    }
149
150    /// Feed bytes into the parser buffer.
151    pub fn feed(&mut self, bytes: &[u8]) {
152        self.buf.extend_from_slice(bytes);
153    }
154
155    /// Try to parse a complete event from the buffer.
156    ///
157    /// Returns `Some(event)` if a complete event was parsed, `None` if
158    /// more bytes are needed. Incomplete sequences remain in the buffer.
159    pub fn parse(&mut self) -> Option<Event> {
160        if self.buf.is_empty() {
161            return None;
162        }
163
164        // Check for escape sequences
165        if self.buf[0] == 0x1b && self.buf.len() > 1 {
166            return self.parse_escape_sequence();
167        }
168
169        // Single byte: control character or regular key
170        let byte = self.buf[0];
171        self.buf.drain(..1); // Consume only the first byte
172
173        match byte {
174            // Control characters
175            0x0D | 0x0A => Some(Event::Key(KeyEvent {
176                key: Key::Enter,
177                modifiers: Modifiers::new(),
178            })),
179            0x09 => Some(Event::Key(KeyEvent {
180                key: Key::Tab,
181                modifiers: Modifiers::new(),
182            })),
183            0x7F => Some(Event::Key(KeyEvent {
184                key: Key::Backspace,
185                modifiers: Modifiers::new(),
186            })),
187            0x1B => Some(Event::Key(KeyEvent {
188                key: Key::Escape,
189                modifiers: Modifiers::new(),
190            })),
191            // Ctrl+A through Ctrl+Z (0x01 through 0x1A)
192            0x01..=0x1A => Some(Event::Key(KeyEvent {
193                key: Key::Char((b'a' + (byte - 0x01)) as char),
194                modifiers: Modifiers::ctrl(),
195            })),
196            // Regular printable character
197            byte if byte >= 0x20 => Some(Event::Key(KeyEvent {
198                key: Key::Char(byte as char),
199                modifiers: Modifiers::new(),
200            })),
201            // Ignore other control characters
202            _ => None,
203        }
204    }
205
206    /// Parse an escape sequence starting with \x1b.
207    fn parse_escape_sequence(&mut self) -> Option<Event> {
208        let buf = &self.buf;
209
210        // Bracketed paste: \x1b[200~ ... \x1b[201~
211        if buf.len() >= 6 && &buf[0..6] == b"\x1b[200~" {
212            // Find the end marker
213            if let Some(end) = self.find_bracketed_paste_end() {
214                let paste_content = String::from_utf8_lossy(&buf[6..end]).to_string();
215                self.buf.drain(..end + 6);
216                return Some(Event::Paste(paste_content));
217            }
218            // Need more data
219            return None;
220        }
221
222        // CSI sequences: \x1b[ ...
223        if buf.len() >= 2 && buf[1] == b'[' {
224            return self.parse_csi_sequence();
225        }
226
227        // Alt + key: \x1b<key>
228        if buf.len() >= 2 {
229            let alt_key = buf[1];
230            self.buf.drain(..2);
231            match alt_key {
232                0x0D | 0x0A => Some(Event::Key(KeyEvent {
233                    key: Key::Enter,
234                    modifiers: Modifiers::alt(),
235                })),
236                0x7F => Some(Event::Key(KeyEvent {
237                    key: Key::Backspace,
238                    modifiers: Modifiers::alt(),
239                })),
240                byte if byte >= 0x20 => Some(Event::Key(KeyEvent {
241                    key: Key::Char(byte as char),
242                    modifiers: Modifiers::alt(),
243                })),
244                _ => None,
245            }
246        } else {
247            // Just escape — might be a standalone Escape key
248            // Wait a bit for more bytes; if none come, it's Escape
249            None
250        }
251    }
252
253    /// Parse a CSI (Control Sequence Introducer) sequence.
254    fn parse_csi_sequence(&mut self) -> Option<Event> {
255        // Find the terminating byte (0x40–0x7E for standard CSI)
256        let end_pos = self.buf[2..]
257            .iter()
258            .position(|&b| (0x40..=0x7E).contains(&b))
259            .map(|p| p + 2);
260
261        let end = match end_pos {
262            Some(p) => p,
263            None => {
264                // Need more bytes
265                // But if the buffer is getting long and still no terminator,
266                // it might be a malformed sequence. Give up after 20 bytes.
267                if self.buf.len() > 20 {
268                    self.buf.drain(..1); // Remove the ESC
269                    return None;
270                }
271                return None;
272            }
273        };
274
275        // Extract the parameter bytes and final byte before draining
276        let params = self.buf[2..end].to_vec();
277        let final_byte = self.buf[end];
278
279        // Consume the entire sequence
280        self.buf.drain(..=end);
281
282        // Parse the sequence
283        self.dispatch_csi(&params, final_byte)
284    }
285
286    /// Dispatch a parsed CSI sequence to the appropriate event.
287    fn dispatch_csi(&self, params: &[u8], final_byte: u8) -> Option<Event> {
288        // Parse parameter string (semicolon-separated numbers)
289        // For SGR mouse events, the format is `\x1b[<button;col;rowM`
290        // The `<` (0x3C) is part of the SGR mouse extension and appears
291        // as the first byte of the parameter string. We detect this and
292        // strip it so that the first number parses correctly.
293        let param_str = std::str::from_utf8(params).unwrap_or("");
294        let is_sgr_mouse = param_str.starts_with('<');
295        let clean_str = if is_sgr_mouse {
296            &param_str[1..]
297        } else {
298            param_str
299        };
300        let nums: Vec<u16> = clean_str
301            .split(';')
302            .filter_map(|s| s.parse().ok())
303            .collect();
304
305        let mods = Self::parse_modifiers(nums.get(1));
306
307        match final_byte {
308            // Arrow keys and special keys (VT100)
309            b'A' => Some(Event::Key(KeyEvent {
310                key: Key::Up,
311                modifiers: mods,
312            })),
313            b'B' => Some(Event::Key(KeyEvent {
314                key: Key::Down,
315                modifiers: mods,
316            })),
317            b'C' => Some(Event::Key(KeyEvent {
318                key: Key::Right,
319                modifiers: mods,
320            })),
321            b'D' => Some(Event::Key(KeyEvent {
322                key: Key::Left,
323                modifiers: mods,
324            })),
325            b'H' => Some(Event::Key(KeyEvent {
326                key: Key::Home,
327                modifiers: mods,
328            })),
329            b'F' => Some(Event::Key(KeyEvent {
330                key: Key::End,
331                modifiers: mods,
332            })),
333
334            // Function keys
335            b'P' => Some(Event::Key(KeyEvent {
336                key: Key::F(1),
337                modifiers: mods,
338            })),
339            b'Q' => Some(Event::Key(KeyEvent {
340                key: Key::F(2),
341                modifiers: mods,
342            })),
343            b'R' => Some(Event::Key(KeyEvent {
344                key: Key::F(3),
345                modifiers: mods,
346            })),
347            b'S' => Some(Event::Key(KeyEvent {
348                key: Key::F(4),
349                modifiers: mods,
350            })),
351
352            // Extended keys (with parameters)
353            b'~' => match nums.first().copied().unwrap_or(0) {
354                1 => Some(Event::Key(KeyEvent {
355                    key: Key::Home,
356                    modifiers: mods,
357                })),
358                2 => Some(Event::Key(KeyEvent {
359                    key: Key::Insert,
360                    modifiers: mods,
361                })),
362                3 => Some(Event::Key(KeyEvent {
363                    key: Key::Delete,
364                    modifiers: mods,
365                })),
366                4 => Some(Event::Key(KeyEvent {
367                    key: Key::End,
368                    modifiers: mods,
369                })),
370                5 => Some(Event::Key(KeyEvent {
371                    key: Key::PageUp,
372                    modifiers: mods,
373                })),
374                6 => Some(Event::Key(KeyEvent {
375                    key: Key::PageDown,
376                    modifiers: mods,
377                })),
378                11..=15 => Some(Event::Key(KeyEvent {
379                    key: Key::F((nums[0] - 10) as u8),
380                    modifiers: mods,
381                })),
382                17..=21 => Some(Event::Key(KeyEvent {
383                    key: Key::F((nums[0] - 11) as u8),
384                    modifiers: mods,
385                })),
386                23 => Some(Event::Key(KeyEvent {
387                    key: Key::F(12),
388                    modifiers: mods,
389                })),
390                _ => None,
391            },
392
393            // Mouse events (SGR mode: \x1b[<button;col;rowM or \x1b[<button;col;rowm)
394            b'M' => self.parse_xterm_mouse(&nums, false),
395            b'm' => self.parse_xterm_mouse(&nums, true),
396
397            _ => None,
398        }
399    }
400
401    /// Parse modifier flags from CSI parameter.
402    ///
403    /// CSI modifier encoding:
404    /// - No modifier field → no modifiers
405    /// - 2 = Shift
406    /// - 3 = Alt (Meta)
407    /// - 5 = Ctrl
408    /// - 6 = Ctrl+Shift
409    fn parse_modifiers(mod_code: Option<&u16>) -> Modifiers {
410        let code = mod_code.copied().unwrap_or(0);
411        Modifiers {
412            shift: code == 2 || code == 4 || code == 6 || code == 8,
413            alt: code == 3 || code == 7,
414            ctrl: code == 5 || code == 6 || code == 7 || code == 8,
415        }
416    }
417
418    /// Parse an xterm SGR mouse event.
419    ///
420    /// SGR mouse format: `\x1b[<button;col;rowM` or `\x1b[<button;col;rowm`
421    /// The `<` prefix is part of the SGR mouse extension and gets included
422    /// in the parameter string, causing the first number to fail parsing
423    /// (e.g., `"<64"` instead of `"64"`). We strip the leading `<` here.
424    fn parse_xterm_mouse(&self, nums: &[u16], release: bool) -> Option<Event> {
425        if nums.len() < 3 {
426            return None;
427        }
428        let button_code = nums[0];
429        let col = nums[1].saturating_sub(1);
430        let row = nums[2].saturating_sub(1);
431
432        if release {
433            Some(Event::Mouse(MouseEvent::Release { row, col }))
434        } else {
435            match button_code {
436                0 => Some(Event::Mouse(MouseEvent::Press {
437                    row,
438                    col,
439                    button: MouseButton::Left,
440                })),
441                1 => Some(Event::Mouse(MouseEvent::Press {
442                    row,
443                    col,
444                    button: MouseButton::Middle,
445                })),
446                2 => Some(Event::Mouse(MouseEvent::Press {
447                    row,
448                    col,
449                    button: MouseButton::Right,
450                })),
451                64 => Some(Event::Mouse(MouseEvent::ScrollUp { row, col })),
452                65 => Some(Event::Mouse(MouseEvent::ScrollDown { row, col })),
453                _ => None,
454            }
455        }
456    }
457
458    /// Find the end of a bracketed paste sequence.
459    fn find_bracketed_paste_end(&self) -> Option<usize> {
460        let end_marker = b"\x1b[201~";
461        self.buf
462            .windows(end_marker.len())
463            .position(|w| w == end_marker)
464    }
465}
466
467// ── Async event reader ───────────────────────────────────────────────────────
468
469/// Reads events from stdin asynchronously.
470///
471/// Uses a background thread to read raw bytes from stdin and parse them
472/// into events. Events are sent through a channel.
473pub struct EventReader {
474    #[allow(dead_code)]
475    tx: std::sync::mpsc::Sender<Event>,
476    rx: std::sync::mpsc::Receiver<Event>,
477}
478
479impl EventReader {
480    /// Create a new event reader.
481    ///
482    /// Spawns a background thread that reads from stdin in raw mode
483    /// and parses events.
484    pub fn new() -> io::Result<Self> {
485        let (tx, rx) = std::sync::mpsc::channel();
486        Ok(Self { tx, rx })
487    }
488
489    /// Start reading events from stdin.
490    ///
491    /// This spawns a background thread that reads raw bytes from stdin
492    /// and sends parsed events through the channel.
493    pub fn start(&self) {
494        // Event reading from stdin will be integrated with the
495        // tokio event loop in the app. For now, the parser can be
496        // used directly for testing.
497    }
498
499    /// Try to receive an event with a timeout.
500    pub fn recv_timeout(&self, timeout: Duration) -> Option<Event> {
501        self.rx.recv_timeout(timeout).ok()
502    }
503}
504
505#[cfg(test)]
506mod tests {
507    use super::*;
508
509    #[test]
510    fn test_parse_regular_char() {
511        let mut parser = EventParser::new();
512        parser.feed(b"a");
513        let event = parser.parse().unwrap();
514        assert_eq!(
515            event,
516            Event::Key(KeyEvent {
517                key: Key::Char('a'),
518                modifiers: Modifiers::new(),
519            })
520        );
521    }
522
523    #[test]
524    fn test_parse_enter() {
525        let mut parser = EventParser::new();
526        parser.feed(b"\r");
527        let event = parser.parse().unwrap();
528        assert_eq!(
529            event,
530            Event::Key(KeyEvent {
531                key: Key::Enter,
532                modifiers: Modifiers::new(),
533            })
534        );
535    }
536
537    #[test]
538    fn test_parse_tab() {
539        let mut parser = EventParser::new();
540        parser.feed(b"\t");
541        let event = parser.parse().unwrap();
542        assert_eq!(
543            event,
544            Event::Key(KeyEvent {
545                key: Key::Tab,
546                modifiers: Modifiers::new(),
547            })
548        );
549    }
550
551    #[test]
552    fn test_parse_backspace() {
553        let mut parser = EventParser::new();
554        parser.feed(b"\x7f");
555        let event = parser.parse().unwrap();
556        assert_eq!(
557            event,
558            Event::Key(KeyEvent {
559                key: Key::Backspace,
560                modifiers: Modifiers::new(),
561            })
562        );
563    }
564
565    #[test]
566    fn test_parse_ctrl_a() {
567        let mut parser = EventParser::new();
568        parser.feed(b"\x01");
569        let event = parser.parse().unwrap();
570        assert_eq!(
571            event,
572            Event::Key(KeyEvent {
573                key: Key::Char('a'),
574                modifiers: Modifiers::ctrl(),
575            })
576        );
577    }
578
579    #[test]
580    fn test_parse_ctrl_c() {
581        let mut parser = EventParser::new();
582        parser.feed(b"\x03");
583        let event = parser.parse().unwrap();
584        assert_eq!(
585            event,
586            Event::Key(KeyEvent {
587                key: Key::Char('c'),
588                modifiers: Modifiers::ctrl(),
589            })
590        );
591    }
592
593    #[test]
594    fn test_parse_arrow_up() {
595        let mut parser = EventParser::new();
596        parser.feed(b"\x1b[A");
597        let event = parser.parse().unwrap();
598        assert_eq!(
599            event,
600            Event::Key(KeyEvent {
601                key: Key::Up,
602                modifiers: Modifiers::new(),
603            })
604        );
605    }
606
607    #[test]
608    fn test_parse_arrow_down() {
609        let mut parser = EventParser::new();
610        parser.feed(b"\x1b[B");
611        let event = parser.parse().unwrap();
612        assert_eq!(
613            event,
614            Event::Key(KeyEvent {
615                key: Key::Down,
616                modifiers: Modifiers::new(),
617            })
618        );
619    }
620
621    #[test]
622    fn test_parse_arrow_right() {
623        let mut parser = EventParser::new();
624        parser.feed(b"\x1b[C");
625        let event = parser.parse().unwrap();
626        assert_eq!(
627            event,
628            Event::Key(KeyEvent {
629                key: Key::Right,
630                modifiers: Modifiers::new(),
631            })
632        );
633    }
634
635    #[test]
636    fn test_parse_arrow_left() {
637        let mut parser = EventParser::new();
638        parser.feed(b"\x1b[D");
639        let event = parser.parse().unwrap();
640        assert_eq!(
641            event,
642            Event::Key(KeyEvent {
643                key: Key::Left,
644                modifiers: Modifiers::new(),
645            })
646        );
647    }
648
649    #[test]
650    fn test_parse_ctrl_arrow_up() {
651        let mut parser = EventParser::new();
652        // \x1b[1;5A = Ctrl+Up
653        parser.feed(b"\x1b[1;5A");
654        let event = parser.parse().unwrap();
655        assert_eq!(
656            event,
657            Event::Key(KeyEvent {
658                key: Key::Up,
659                modifiers: Modifiers {
660                    ctrl: true,
661                    alt: false,
662                    shift: false
663                },
664            })
665        );
666    }
667
668    #[test]
669    fn test_parse_shift_arrow_up() {
670        let mut parser = EventParser::new();
671        // \x1b[1;2A = Shift+Up
672        parser.feed(b"\x1b[1;2A");
673        let event = parser.parse().unwrap();
674        assert_eq!(
675            event,
676            Event::Key(KeyEvent {
677                key: Key::Up,
678                modifiers: Modifiers {
679                    ctrl: false,
680                    alt: false,
681                    shift: true
682                },
683            })
684        );
685    }
686
687    #[test]
688    fn test_parse_alt_key() {
689        let mut parser = EventParser::new();
690        parser.feed(b"\x1ba");
691        let event = parser.parse().unwrap();
692        assert_eq!(
693            event,
694            Event::Key(KeyEvent {
695                key: Key::Char('a'),
696                modifiers: Modifiers::alt(),
697            })
698        );
699    }
700
701    #[test]
702    fn test_parse_home() {
703        let mut parser = EventParser::new();
704        parser.feed(b"\x1b[H");
705        let event = parser.parse().unwrap();
706        assert_eq!(
707            event,
708            Event::Key(KeyEvent {
709                key: Key::Home,
710                modifiers: Modifiers::new(),
711            })
712        );
713    }
714
715    #[test]
716    fn test_parse_end() {
717        let mut parser = EventParser::new();
718        parser.feed(b"\x1b[F");
719        let event = parser.parse().unwrap();
720        assert_eq!(
721            event,
722            Event::Key(KeyEvent {
723                key: Key::End,
724                modifiers: Modifiers::new(),
725            })
726        );
727    }
728
729    #[test]
730    fn test_parse_page_up() {
731        let mut parser = EventParser::new();
732        parser.feed(b"\x1b[5~");
733        let event = parser.parse().unwrap();
734        assert_eq!(
735            event,
736            Event::Key(KeyEvent {
737                key: Key::PageUp,
738                modifiers: Modifiers::new(),
739            })
740        );
741    }
742
743    #[test]
744    fn test_parse_page_down() {
745        let mut parser = EventParser::new();
746        parser.feed(b"\x1b[6~");
747        let event = parser.parse().unwrap();
748        assert_eq!(
749            event,
750            Event::Key(KeyEvent {
751                key: Key::PageDown,
752                modifiers: Modifiers::new(),
753            })
754        );
755    }
756
757    #[test]
758    fn test_parse_delete() {
759        let mut parser = EventParser::new();
760        parser.feed(b"\x1b[3~");
761        let event = parser.parse().unwrap();
762        assert_eq!(
763            event,
764            Event::Key(KeyEvent {
765                key: Key::Delete,
766                modifiers: Modifiers::new(),
767            })
768        );
769    }
770
771    #[test]
772    fn test_parse_multiple_events() {
773        let mut parser = EventParser::new();
774        parser.feed(b"abc");
775        let a = parser.parse().unwrap();
776        let b = parser.parse().unwrap();
777        let c = parser.parse().unwrap();
778        assert_eq!(
779            a,
780            Event::Key(KeyEvent {
781                key: Key::Char('a'),
782                modifiers: Modifiers::new()
783            })
784        );
785        assert_eq!(
786            b,
787            Event::Key(KeyEvent {
788                key: Key::Char('b'),
789                modifiers: Modifiers::new()
790            })
791        );
792        assert_eq!(
793            c,
794            Event::Key(KeyEvent {
795                key: Key::Char('c'),
796                modifiers: Modifiers::new()
797            })
798        );
799    }
800
801    #[test]
802    fn test_modifiers_ctrl() {
803        let mods = Modifiers::ctrl();
804        assert!(mods.ctrl);
805        assert!(!mods.alt);
806        assert!(!mods.shift);
807    }
808
809    #[test]
810    fn test_modifiers_alt() {
811        let mods = Modifiers::alt();
812        assert!(!mods.ctrl);
813        assert!(mods.alt);
814        assert!(!mods.shift);
815    }
816
817    #[test]
818    fn test_parse_sgr_mouse_scroll_up() {
819        // SGR mouse format: \x1b[<64;col;rowM
820        // Button 64 = scroll up
821        let mut parser = EventParser::new();
822        parser.feed(b"\x1b[<64;10;5M");
823        let event = parser.parse().unwrap();
824        assert_eq!(event, Event::Mouse(MouseEvent::ScrollUp { row: 4, col: 9 }));
825    }
826
827    #[test]
828    fn test_parse_sgr_mouse_scroll_down() {
829        // SGR mouse format: \x1b[<65;col;rowM
830        // Button 65 = scroll down
831        let mut parser = EventParser::new();
832        parser.feed(b"\x1b[<65;10;5M");
833        let event = parser.parse().unwrap();
834        assert_eq!(
835            event,
836            Event::Mouse(MouseEvent::ScrollDown { row: 4, col: 9 })
837        );
838    }
839
840    #[test]
841    fn test_parse_sgr_mouse_left_click() {
842        // SGR mouse format: \x1b[<0;col;rowM
843        let mut parser = EventParser::new();
844        parser.feed(b"\x1b[<0;1;1M");
845        let event = parser.parse().unwrap();
846        assert_eq!(
847            event,
848            Event::Mouse(MouseEvent::Press {
849                row: 0,
850                col: 0,
851                button: MouseButton::Left,
852            })
853        );
854    }
855}