pkgs/lf-make-map: Implement an interactive mode

This mode effectively replaces the display lf gives you for mappings.

1 files changed, 174 insertions, 0 deletions

diff --git a/pkgs/by-name/lf/lf-make-map/src/mapping/interactive.rs b/pkgs/by-name/lf/lf-make-map/src/mapping/interactive.rs
new file mode 100644
index 00000000..31324e1d
--- /dev/null
+++ b/pkgs/by-name/lf/lf-make-map/src/mapping/interactive.rs
@@ -0,0 +1,174 @@
+// nixos-config - My current NixOS configuration
+//
+// Copyright (C) 2025 Benedikt Peetz <benedikt.peetz@b-peetz.de>
+// SPDX-License-Identifier: GPL-3.0-or-later
+//
+// This file is part of my nixos-config.
+//
+// You should have received a copy of the License along with this program.
+// If not, see <https://www.gnu.org/licenses/gpl-3.0.txt>.
+
+use std::{io::stdout, path::PathBuf};
+
+use anyhow::Result;
+use crossterm::{
+    cursor::{MoveToRow, MoveUp},
+    event::{
+        Event, KeyEventKind, KeyModifiers, KeyboardEnhancementFlags, PopKeyboardEnhancementFlags,
+        PushKeyboardEnhancementFlags, read,
+    },
+    execute,
+    style::Print,
+    terminal::{self, Clear, ClearType, EnterAlternateScreen, LeaveAlternateScreen},
+};
+
+use crate::mapping::map_key::MapKey;
+
+use super::MappingsTrie;
+
+enum Status {
+    Done(PathBuf),
+    Stop,
+}
+
+impl MappingsTrie {
+    pub fn interactive_start(&self, home_path: PathBuf) -> Result<()> {
+        terminal::enable_raw_mode()?;
+        execute!(
+            stdout(),
+            EnterAlternateScreen,
+            PushKeyboardEnhancementFlags(KeyboardEnhancementFlags::DISAMBIGUATE_ESCAPE_CODES),
+            MoveToRow(0)
+        )?;
+
+        let output = self.interactive_start_inner(home_path);
+
+        execute!(stdout(), LeaveAlternateScreen, PopKeyboardEnhancementFlags)?;
+        terminal::disable_raw_mode()?;
+
+        match output? {
+            Status::Done(path_buf) => {
+                println!("{}", path_buf.display())
+            }
+            Status::Stop => (),
+        }
+
+        Ok(())
+    }
+
+    fn interactive_start_inner(&self, home_path: PathBuf) -> Result<Status> {
+        macro_rules! done {
+            ($state:ident, $last_length:ident) => {{
+                let value = self
+                    .0
+                    .get(&$state)
+                    .expect("Is some")
+                    .value()
+                    .expect("is some");
+
+                let path = home_path.join(&value.path);
+
+                terminal::disable_raw_mode()?;
+                execute!(
+                    stdout(),
+                    MoveUp($last_length as u16),
+                    Clear(ClearType::FromCursorDown),
+                    Print(format!("{}\n", path.display()))
+                )?;
+                terminal::enable_raw_mode()?;
+
+                return Ok(Status::Done(path));
+            }};
+        }
+
+        let mut state: Vec<MapKey> = vec![];
+        let mut last_length: usize = 1;
+        while let (trie, matched) = self.0.try_get(&state)
+            && matched == state
+        {
+            if trie.value().is_some() {
+                done!(state, last_length);
+            } else {
+                if let Some(last) = state.last_mut()
+                    && let Some(mlast) = matched.last()
+                {
+                    last.resolution = mlast.resolution;
+                    mlast.part_path.clone_into(&mut last.part_path);
+                }
+            }
+
+            {
+                terminal::disable_raw_mode()?;
+                let string = trie.to_string();
+                execute!(
+                    stdout(),
+                    MoveUp(last_length as u16),
+                    Clear(ClearType::FromCursorDown),
+                    Print(format!(
+                        "Current state: {}\n",
+                        self.current_progress(home_path.display().to_string(), &state)
+                    )),
+                    Print(&string)
+                )?;
+                last_length = string.lines().count() + 1;
+                terminal::enable_raw_mode()?;
+            }
+
+            if let Event::Key(event) = read()?
+                && event.kind == KeyEventKind::Press
+            {
+                match event.code {
+                    crossterm::event::KeyCode::Backspace => {
+                        state.pop();
+                    }
+                    crossterm::event::KeyCode::Enter => done!(state, last_length),
+                    crossterm::event::KeyCode::Esc => break,
+                    crossterm::event::KeyCode::Char(char) => {
+                        if event.modifiers == KeyModifiers::CONTROL && char == 'c' {
+                            break;
+                        } else {
+                            state.push(MapKey {
+                                key: char,
+                                resolution: 0,
+                                part_path: String::new(),
+                            });
+                        }
+                    }
+
+                    crossterm::event::KeyCode::Left
+                    | crossterm::event::KeyCode::Right
+                    | crossterm::event::KeyCode::Up
+                    | crossterm::event::KeyCode::Down
+                    | crossterm::event::KeyCode::Home
+                    | crossterm::event::KeyCode::End
+                    | crossterm::event::KeyCode::PageUp
+                    | crossterm::event::KeyCode::PageDown
+                    | crossterm::event::KeyCode::Tab
+                    | crossterm::event::KeyCode::BackTab
+                    | crossterm::event::KeyCode::Delete
+                    | crossterm::event::KeyCode::Insert
+                    | crossterm::event::KeyCode::F(_)
+                    | crossterm::event::KeyCode::Null
+                    | crossterm::event::KeyCode::CapsLock
+                    | crossterm::event::KeyCode::ScrollLock
+                    | crossterm::event::KeyCode::NumLock
+                    | crossterm::event::KeyCode::PrintScreen
+                    | crossterm::event::KeyCode::Pause
+                    | crossterm::event::KeyCode::Menu
+                    | crossterm::event::KeyCode::KeypadBegin
+                    | crossterm::event::KeyCode::Media(_)
+                    | crossterm::event::KeyCode::Modifier(_) => (),
+                }
+            }
+        }
+
+        Ok(Status::Stop)
+    }
+
+    fn current_progress(&self, home_path: String, state: &[MapKey]) -> String {
+        state
+            .iter()
+            .map(|mk| &mk.part_path)
+            .fold(home_path, |acc, part| format!("{acc}/{part}"))
+    }
+}