paperos 0.2.0

A programmable editor built on the Runact actor runtime
Documentation
//! Conversion from crossterm `KeyEvent` to the canonical `Key`.
//!
//! This lives in extensions (not core) because it depends on crossterm —
//! AGENTS.md forbids crossterm in `src/core/`. The pure `Key`/`KeymapRegistry`
//! types in `keymap_registry.rs` have no such dependency and stay
//! core-agnostic.

use crate::extensions::keymap_registry::{Key, KeyCodeInner};
use crossterm::event::{KeyCode as CtKeyCode, KeyEvent as CtKeyEvent, KeyModifiers};

/// Convert a crossterm `KeyEvent` into a canonical `Key`.
///
/// Returns `None` for keys that have no meaningful binding representation
/// (unrecognized keycodes, modifier-only keypresses, etc.).
pub fn crossterm_to_key(event: CtKeyEvent) -> Option<Key> {
    let ctrl = event.modifiers.contains(KeyModifiers::CONTROL);
    let alt = event.modifiers.contains(KeyModifiers::ALT);
    // Note: Shift is folded into the char for letters (crossterm already
    // provides shifted chars like 'A' vs 'a'); we don't need a separate
    // flag for the registry.

    let code = match event.code {
        CtKeyCode::Char(c) => KeyCodeInner::Char(c),
        CtKeyCode::Left => KeyCodeInner::Left,
        CtKeyCode::Right => KeyCodeInner::Right,
        CtKeyCode::Up => KeyCodeInner::Up,
        CtKeyCode::Down => KeyCodeInner::Down,
        CtKeyCode::Home => KeyCodeInner::Home,
        CtKeyCode::End => KeyCodeInner::End,
        CtKeyCode::PageUp => KeyCodeInner::PageUp,
        CtKeyCode::PageDown => KeyCodeInner::PageDown,
        CtKeyCode::Enter => KeyCodeInner::Enter,
        CtKeyCode::Backspace => KeyCodeInner::Backspace,
        CtKeyCode::Tab => KeyCodeInner::Tab,
        CtKeyCode::Esc => KeyCodeInner::Escape,
        _ => return None,
    };

    Some(Key { code, ctrl, alt })
}

/// Convert a (crossterm KeyCode, KeyModifiers) pair to a canonical `Key`.
///
/// This is the non-event variant — used by `Keymap::to_layer` which iterates
/// over stored `(KeyCode, KeyModifiers)` bindings rather than live events.
pub fn crossterm_to_key_pair(code: CtKeyCode, modifiers: KeyModifiers) -> Option<Key> {
    let ctrl = modifiers.contains(KeyModifiers::CONTROL);
    let alt = modifiers.contains(KeyModifiers::ALT);

    let inner = match code {
        CtKeyCode::Char(c) => KeyCodeInner::Char(c),
        CtKeyCode::Left => KeyCodeInner::Left,
        CtKeyCode::Right => KeyCodeInner::Right,
        CtKeyCode::Up => KeyCodeInner::Up,
        CtKeyCode::Down => KeyCodeInner::Down,
        CtKeyCode::Home => KeyCodeInner::Home,
        CtKeyCode::End => KeyCodeInner::End,
        CtKeyCode::PageUp => KeyCodeInner::PageUp,
        CtKeyCode::PageDown => KeyCodeInner::PageDown,
        CtKeyCode::Enter => KeyCodeInner::Enter,
        CtKeyCode::Backspace => KeyCodeInner::Backspace,
        CtKeyCode::Tab => KeyCodeInner::Tab,
        CtKeyCode::Esc => KeyCodeInner::Escape,
        _ => return None,
    };

    Some(Key {
        code: inner,
        ctrl,
        alt,
    })
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_convert_simple_char() {
        let ev = CtKeyEvent::new(CtKeyCode::Char('a'), KeyModifiers::NONE);
        let k = crossterm_to_key(ev).unwrap();
        assert_eq!(k.code, KeyCodeInner::Char('a'));
        assert!(!k.ctrl);
        assert!(!k.alt);
    }

    #[test]
    fn test_convert_ctrl_char() {
        let ev = CtKeyEvent::new(CtKeyCode::Char('d'), KeyModifiers::CONTROL);
        let k = crossterm_to_key(ev).unwrap();
        assert_eq!(k.code, KeyCodeInner::Char('d'));
        assert!(k.ctrl);
    }

    #[test]
    fn test_convert_alt_char() {
        let ev = CtKeyEvent::new(CtKeyCode::Char('x'), KeyModifiers::ALT);
        let k = crossterm_to_key(ev).unwrap();
        assert_eq!(k.code, KeyCodeInner::Char('x'));
        assert!(k.alt);
    }

    #[test]
    fn test_convert_special_key() {
        let ev = CtKeyEvent::new(CtKeyCode::Enter, KeyModifiers::NONE);
        let k = crossterm_to_key(ev).unwrap();
        assert_eq!(k.code, KeyCodeInner::Enter);
    }

    #[test]
    fn test_convert_rejects_unknown() {
        let ev = CtKeyEvent::new(CtKeyCode::Null, KeyModifiers::NONE);
        assert!(crossterm_to_key(ev).is_none());
    }

    #[test]
    fn test_convert_roundtrip_with_parse() {
        // A key parsed from a string should match the crossterm conversion
        let parsed = Key::parse("C-d").unwrap();
        let ev = CtKeyEvent::new(CtKeyCode::Char('d'), KeyModifiers::CONTROL);
        let converted = crossterm_to_key(ev).unwrap();
        assert_eq!(parsed, converted);
    }
}