router4 compiled

client/src/modes/common/command_mode.rs

@@ -3,20 +3,20 @@
 use crossterm::event::{KeyEvent, KeyCode, KeyModifiers};
 use crate::config::binds::config::Config;
 use crate::services::grpc_client::GrpcClient;
-use crate::state::{app::state::AppState, pages::auth::LoginState, pages::auth::RegisterState};
+use crate::state::app::state::AppState;
 use crate::modes::common::commands::CommandHandler;
 use crate::tui::terminal::core::TerminalCore;
 use crate::tui::functions::common::form::{save, revert};
 use crate::modes::handlers::event::EventOutcome;
 use crate::tui::functions::common::form::SaveOutcome;
+use crate::pages::routing::{Router, Page};
 use anyhow::Result;
 
 pub async fn handle_command_event(
     key: KeyEvent,
     config: &Config,
     app_state: &mut AppState,
-    login_state: &LoginState,
-    register_state: &RegisterState,
+    router: &mut Router,
     command_input: &mut String,
     command_message: &mut String,
     grpc_client: &mut GrpcClient,
@@ -25,20 +25,19 @@ pub async fn handle_command_event(
     current_position: &mut u64,
     total_count: u64,
 ) -> Result<EventOutcome> {
-    // Exit command mode (via configurable keybinding)
+    // Exit command mode
     if config.is_exit_command_mode(key.code, key.modifiers) {
         command_input.clear();
         *command_message = "".to_string();
         return Ok(EventOutcome::Ok("Exited command mode".to_string()));
     }
 
-    // Execute command (via configurable keybinding, defaults to Enter)
+    // Execute command
     if config.is_command_execute(key.code, key.modifiers) {
         return process_command(
             config,
             app_state,
-            login_state,
-            register_state,
+            router,
             command_input,
             command_message,
             grpc_client,
@@ -46,33 +45,31 @@ pub async fn handle_command_event(
             terminal,
             current_position,
             total_count,
-        ).await;
+        )
+        .await;
     }
 
-    // Backspace (via configurable keybinding, defaults to Backspace)
+    // Backspace
     if config.is_command_backspace(key.code, key.modifiers) {
         command_input.pop();
         return Ok(EventOutcome::Ok("".to_string()));
     }
 
-    // Regular character input - accept any character in command mode
+    // Regular character input
     if let KeyCode::Char(c) = key.code {
-        // Accept regular or shifted characters (e.g., 'a' or 'A')
         if key.modifiers.is_empty() || key.modifiers == KeyModifiers::SHIFT {
             command_input.push(c);
             return Ok(EventOutcome::Ok("".to_string()));
         }
     }
 
-    // Ignore all other keys
     Ok(EventOutcome::Ok("".to_string()))
 }
 
 async fn process_command(
     config: &Config,
     app_state: &mut AppState,
-    login_state: &LoginState,
-    register_state: &RegisterState,
+    router: &mut Router,
     command_input: &mut String,
     command_message: &mut String,
     grpc_client: &mut GrpcClient,
@@ -81,27 +78,18 @@ async fn process_command(
     current_position: &mut u64,
     total_count: u64,
 ) -> Result<EventOutcome> {
-    // Clone the trimmed command to avoid borrow issues
     let command = command_input.trim().to_string();
     if command.is_empty() {
         *command_message = "Empty command".to_string();
         return Ok(EventOutcome::Ok(command_message.clone()));
     }
 
-    // Get the action for the command (now checks global and common bindings too)
-    let action = config.get_action_for_command(&command)
-        .unwrap_or("unknown");
+    let action = config.get_action_for_command(&command).unwrap_or("unknown");
 
     match action {
         "force_quit" | "save_and_quit" | "quit" => {
             let (should_exit, message) = command_handler
-                .handle_command(
-                    action,
-                    terminal,
-                    app_state,
-                    login_state,
-                    register_state,
-                )
+                .handle_command(action, terminal, app_state, router)
                 .await?;
             command_input.clear();
             if should_exit {
@@ -109,12 +97,9 @@ async fn process_command(
             } else {
                 Ok(EventOutcome::Ok(message))
             }
-        },
+        }
         "save" => {
-            let outcome = save(
-                app_state,
-                grpc_client,
-            ).await?;
+            let outcome = save(app_state, grpc_client).await?;
             let message = match outcome {
                 SaveOutcome::CreatedNew(_) => "New entry created".to_string(),
                 SaveOutcome::UpdatedExisting => "Entry updated".to_string(),
@@ -122,15 +107,12 @@ async fn process_command(
             };
             command_input.clear();
             Ok(EventOutcome::DataSaved(outcome, message))
-        },
+        }
         "revert" => {
-            let message = revert(
-                app_state,
-                grpc_client,
-            ).await?;
+            let message = revert(app_state, grpc_client).await?;
             command_input.clear();
             Ok(EventOutcome::Ok(message))
-        },
+        }
         _ => {
             let message = format!("Unhandled action: {}", action);
             command_input.clear();