ublx 0.1.1

TUI to index once, enrich with metadata, and browse a flat snapshot in a 3-pane layout with multiple modes.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

//! **Command Mode** (after **Ctrl+A**): the next letter runs the matching shortcut (d, t, s, r, x, l, p),
//! or after a short timeout a centered menu lists them. Viewer search is **Shift+S**, not Command Mode.
//! Jump-by-10 stays **Ctrl+j** / **Ctrl+k** (or arrows), not Command Mode.
//! **Ctrl+Space** toggles middle-pane multi-select when contents are focused; Command Mode uses **Ctrl+A**.

use std::time::{Duration, Instant};

use crossterm::event::{KeyCode, KeyEvent, KeyEventKind};

use crate::app::RunUblxParams;
use crate::handlers::state_transitions;
use crate::layout::setup::{
    CtrlChordState, MainMode, RightPaneContent, UblxState, ViewData, ViewerChrome,
};
use crate::modules;
use crate::ui::{COMMAND_MODE_DESCRIPTIONS, MainTabFlags, keymap::UblxAction};

/// After leader, show the menu if no second key within this duration.
pub const CHORD_MENU_DELAY: Duration = Duration::from_millis(480);

fn chord_blocked(state: &UblxState) -> bool {
    state.chrome.help_visible
        || state.theme.selector_visible
        || state.qa_menu.visible
        || state.open_menu.visible
        || state.lens_menu.visible
        || state.enhance_policy_menu.visible
        || state.startup_prompt.is_some()
        || state.file_rename_input.is_some()
        || state.file_delete_confirm.visible
        || state.multiselect.bulk_menu_visible
        || state.lens_confirm.delete_visible
        || state.lens_confirm.rename_input.is_some()
}

/// Start chord wait (highlight chrome); caller must ensure key was Ctrl+A.
pub fn try_begin_chord(state: &mut UblxState) -> bool {
    if chord_blocked(state) || state.search.active {
        return false;
    }
    let cc = &mut state.chrome.ctrl_chord;
    cc.pending = true;
    cc.menu_visible = false;
    cc.started = Some(Instant::now());
    true
}

pub fn end_chord(state: &mut UblxState) {
    state.chrome.ctrl_chord = CtrlChordState::default();
}

pub fn tick_chord_menu_timeout(state: &mut UblxState, now: Instant) {
    let cc = &mut state.chrome.ctrl_chord;
    if !cc.pending || cc.menu_visible {
        return;
    }
    let Some(started) = cc.started else {
        return;
    };
    if now.duration_since(started) >= CHORD_MENU_DELAY {
        cc.menu_visible = true;
    }
}

fn chord_action_for_key(c: char) -> Option<UblxAction> {
    let c = c.to_ascii_lowercase();
    match c {
        'd' => Some(UblxAction::LoadDuplicates),
        't' => Some(UblxAction::ThemeSelector),
        's' => Some(UblxAction::TakeSnapshot),
        'r' => Some(UblxAction::ReloadConfig),
        'x' => Some(UblxAction::ExportZahirJson),
        'l' => Some(UblxAction::ExportLensMarkdown),
        _ => None,
    }
}

fn apply_chord_action(
    state: &mut UblxState,
    view: &ViewData,
    right: &RightPaneContent,
    action: UblxAction,
    tabs: MainTabFlags,
    params: &mut RunUblxParams<'_>,
) -> bool {
    let mode_before = state.main_mode;
    let ctx = state_transitions::UblxActionContext::new(view, right);
    let quit = ctx.apply_action_to_state(state, action, tabs.has_duplicates, tabs.has_lenses);
    if state.main_mode == MainMode::Settings && mode_before != MainMode::Settings {
        modules::settings::on_enter_settings(state, params);
    }
    quit
}

/// If Command Mode is active, handle the key and return `Some(quit)`; `None` means not in Command Mode.
#[must_use]
pub fn handle_chord_key_event(
    state: &mut UblxState,
    e: &KeyEvent,
    view: &ViewData,
    right_content: &RightPaneContent,
    params: &mut RunUblxParams<'_>,
    tabs: MainTabFlags,
    theme_ctx: &modules::theme_selector::ThemeContext,
) -> Option<bool> {
    if !state.chrome.ctrl_chord.is_active() {
        return None;
    }
    if e.kind != KeyEventKind::Press {
        return Some(false);
    }

    match e.code {
        KeyCode::Esc => {
            end_chord(state);
            Some(false)
        }
        KeyCode::Char(c) => {
            if c.eq_ignore_ascii_case(&'p') {
                end_chord(state);
                modules::ublx_switch::open(state, params);
                return Some(false);
            }
            let Some(action) = chord_action_for_key(c) else {
                end_chord(state);
                return Some(false);
            };
            end_chord(state);
            if matches!(action, UblxAction::ThemeSelector) && !state.theme.selector_visible {
                modules::theme_selector::open(state, theme_ctx);
                return Some(false);
            }
            let quit = apply_chord_action(state, view, right_content, action, tabs, params);
            Some(quit)
        }
        _ => Some(false),
    }
}

/// `ViewerChrome` chord highlight for tabs / status.
#[must_use]
pub fn chord_chrome_active(chrome: &ViewerChrome) -> bool {
    chrome.ctrl_chord.is_active()
}

/// Labels for the centered Command Mode menu (letter → description). Descriptions: [`crate::ui::COMMAND_MODE_DESCRIPTIONS`].
pub const CTRL_MENU_ROWS: &[(&str, &str)] = &[
    ("d", COMMAND_MODE_DESCRIPTIONS.duplicates),
    ("t", COMMAND_MODE_DESCRIPTIONS.theme),
    ("s", COMMAND_MODE_DESCRIPTIONS.snapshot),
    ("r", COMMAND_MODE_DESCRIPTIONS.reload),
    ("x", COMMAND_MODE_DESCRIPTIONS.export_zahir),
    ("l", COMMAND_MODE_DESCRIPTIONS.export_lenses),
    ("p", COMMAND_MODE_DESCRIPTIONS.project),
];