use crate::domain::{MenuAction, Result, Selection, Theme};
use crate::ports::{KeyCode, KeyEvent};
pub const DEFAULT_GROUPS: &[(&str, &[(&str, &str)])] = &[
(
"essentials",
&[
("Send", "Enter"),
("Focus scrollback", "Tab"),
("Cancel turn", "Ctrl+c"),
("Cycle mode", "Shift+Tab"),
("Quit", "Ctrl+q / Ctrl+d"),
("Command palette", "Ctrl+p / ?"),
("Keyboard shortcuts", "Ctrl+x / Ctrl+."),
("Open the settings modal", "F2 / Ctrl+, / Cmd+,"),
],
),
(
"input",
&[
("Send now while running", "Ctrl+Enter / Ctrl+i"),
("Voice dictation", "Ctrl+Space / F8"),
("Search prompt history", "Ctrl+r"),
("Toggle multiline", "Ctrl+m"),
("Shell mode (type ! on empty prompt)", "!"),
],
),
(
"session",
&[
("New session", "Ctrl+n"),
("Resume session", "Ctrl+s"),
("New worktree", "Ctrl+w"),
],
),
];
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ShortcutsItem {
pub action: String,
pub keys: String,
}
impl ShortcutsItem {
pub fn new(action: impl Into<String>, keys: impl Into<String>) -> Self {
Self {
action: action.into(),
keys: keys.into(),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ShortcutsGroup {
pub id: String,
pub label: String,
pub items: Vec<ShortcutsItem>,
pub count: Option<usize>,
}
impl ShortcutsGroup {
pub fn new(id: impl Into<String>, label: impl Into<String>, items: Vec<ShortcutsItem>) -> Self {
Self {
id: id.into(),
label: label.into(),
items,
count: None,
}
}
#[must_use]
pub const fn with_count(mut self, count: usize) -> Self {
self.count = Some(count);
self
}
#[must_use]
pub const fn collapsed_count(&self) -> usize {
match self.count {
Some(c) => c,
None => self.items.len(),
}
}
}
pub fn default_groups() -> Result<Vec<ShortcutsGroup>> {
Ok(DEFAULT_GROUPS
.iter()
.map(|(id, items)| {
let items = items
.iter()
.map(|(action, keys)| ShortcutsItem::new(*action, *keys))
.collect();
ShortcutsGroup::new(*id, *id, items)
})
.collect())
}
#[derive(Debug, Clone)]
pub struct ShortcutsModal {
groups: Vec<ShortcutsGroup>,
selection: Selection,
expanded: Option<usize>,
theme: Theme,
show_scrollbar: bool,
}
impl ShortcutsModal {
#[must_use]
pub fn builder() -> ShortcutsModalBuilder {
ShortcutsModalBuilder::default()
}
pub fn with_defaults() -> Result<Self> {
Self::builder().with_defaults()?.build()
}
#[must_use]
pub const fn groups(&self) -> &[ShortcutsGroup] {
self.groups.as_slice()
}
#[must_use]
pub const fn selection(&self) -> usize {
self.selection.index()
}
#[must_use]
pub const fn expanded(&self) -> Option<usize> {
match self.expanded {
Some(i) => Some(i),
None => None,
}
}
#[must_use]
pub const fn theme(&self) -> Theme {
self.theme
}
#[must_use]
pub const fn show_scrollbar(&self) -> bool {
self.show_scrollbar
}
pub const fn update(&mut self, event: KeyEvent) -> MenuAction {
match event.code {
KeyCode::Up => {
self.selection.up();
MenuAction::None
}
KeyCode::Down => {
self.selection.down();
MenuAction::None
}
KeyCode::Enter | KeyCode::Right => {
self.expanded = Some(self.selection.index());
MenuAction::None
}
KeyCode::Left => {
self.expanded = None;
MenuAction::None
}
KeyCode::Esc => {
if self.expanded.is_some() {
self.expanded = None;
MenuAction::None
} else {
MenuAction::Cancelled
}
}
_ => MenuAction::None,
}
}
pub fn dispatch(&mut self, event: impl Into<crate::ports::MenuEvent>) -> MenuAction {
crate::ports::dispatch(self, event)
}
}
impl crate::ports::MenuDispatch for ShortcutsModal {
fn key_input(&mut self, event: KeyEvent) -> MenuAction {
self.update(event)
}
fn on_mouse(&mut self, event: crate::ports::MouseEvent) -> MenuAction {
let _ = event;
MenuAction::None
}
}
#[derive(Debug, Clone, Default)]
pub struct ShortcutsModalBuilder {
groups: Vec<ShortcutsGroup>,
theme: Theme,
show_scrollbar: bool,
}
impl ShortcutsModalBuilder {
#[must_use]
pub fn groups<I>(mut self, groups: I) -> Self
where
I: IntoIterator<Item = ShortcutsGroup>,
{
self.groups = groups.into_iter().collect();
self
}
#[must_use]
pub fn group(mut self, group: ShortcutsGroup) -> Self {
self.groups.push(group);
self
}
pub fn with_defaults(mut self) -> Result<Self> {
self.groups = default_groups()?;
Ok(self)
}
#[must_use]
pub const fn theme(mut self, theme: Theme) -> Self {
self.theme = theme;
self
}
#[must_use]
pub const fn show_scrollbar(mut self, on: bool) -> Self {
self.show_scrollbar = on;
self
}
pub fn build(self) -> Result<ShortcutsModal> {
let count = self.groups.len();
Ok(ShortcutsModal {
groups: self.groups,
selection: Selection::new(count),
expanded: None,
theme: self.theme,
show_scrollbar: self.show_scrollbar,
})
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::ports::KeyModifiers;
fn ev(code: KeyCode) -> KeyEvent {
KeyEvent::new(code, KeyModifiers::NONE)
}
#[test]
fn defaults_have_three_groups() -> Result<()> {
let m = ShortcutsModal::with_defaults()?;
assert_eq!(m.groups().len(), 3);
Ok(())
}
#[test]
fn enter_expands_current_group() -> Result<()> {
let mut m = ShortcutsModal::with_defaults()?;
let _ = m.update(ev(KeyCode::Enter));
assert_eq!(m.expanded(), Some(0));
Ok(())
}
#[test]
fn left_collapses() -> Result<()> {
let mut m = ShortcutsModal::with_defaults()?;
let _ = m.update(ev(KeyCode::Enter));
let _ = m.update(ev(KeyCode::Left));
assert_eq!(m.expanded(), None);
Ok(())
}
#[test]
fn esc_collapses_then_cancels() -> Result<()> {
let mut m = ShortcutsModal::with_defaults()?;
let _ = m.update(ev(KeyCode::Enter)); assert_eq!(m.update(ev(KeyCode::Esc)), MenuAction::None); assert_eq!(m.update(ev(KeyCode::Esc)), MenuAction::Cancelled); Ok(())
}
#[test]
fn collapsed_count_defaults_to_items_len() -> Result<()> {
let m = ShortcutsModal::with_defaults()?;
let first = m.groups().first();
match first {
Some(g) => assert_eq!(g.collapsed_count(), g.items.len()),
None => return Err(crate::domain::Error::EmptyMenu),
}
Ok(())
}
}