removed _e files completely

client/src/modes/canvas/edit.rs

@@ -1,8 +1,5 @@
 // src/modes/canvas/edit.rs
 use crate::config::binds::config::Config;
-use crate::functions::modes::edit::{
-    add_logic_e, add_table_e, form_e,
-};
 use crate::modes::handlers::event::EventHandler;
 use crate::services::grpc_client::GrpcClient;
 use crate::state::app::state::AppState;
@@ -127,6 +124,23 @@ pub async fn handle_form_edit_with_canvas(
     Ok(String::new())
 }
 
+/// Helper function to execute a specific action using canvas library
+async fn execute_canvas_action(
+    action: &str,
+    key: KeyEvent,
+    form_state: &mut FormState,
+    ideal_cursor_column: &mut usize,
+) -> Result<String> {
+    let canvas_action = CanvasAction::from_string(action);
+    match ActionDispatcher::dispatch(canvas_action, form_state, ideal_cursor_column).await {
+        Ok(ActionResult::Success(msg)) => Ok(msg.unwrap_or_default()),
+        Ok(ActionResult::HandledByFeature(msg)) => Ok(msg),
+        Ok(ActionResult::Error(msg)) => Ok(format!("Error: {}", msg)),
+        Ok(ActionResult::RequiresContext(msg)) => Ok(format!("Context needed: {}", msg)),
+        Err(e) => Ok(format!("Action failed: {}", e)),
+    }
+}
+
 /// NEW: Unified canvas action handler for any CanvasState (LoginState, RegisterState, etc.)
 /// This replaces the old auth_e::execute_edit_action calls with the new canvas library
 async fn handle_canvas_state_edit<S: CanvasState>(
@@ -291,8 +305,8 @@ pub async fn handle_edit_event(
                 } else {
                     "insert_char"
                 };
-                // FIX: Pass &mut event_handler.ideal_cursor_column
-                form_e::execute_edit_action(
+                // FIXED: Use canvas library instead of form_e::execute_edit_action
+                execute_canvas_action(
                     action,
                     key,
                     form_state,
@@ -321,8 +335,8 @@ pub async fn handle_edit_event(
     {
         // Handle Enter key (next field)
         if action_str == "enter_decider" {
-            // FIX: Pass &mut event_handler.ideal_cursor_column
-            let msg = form_e::execute_edit_action(
+            // FIXED: Use canvas library instead of form_e::execute_edit_action
+            let msg = execute_canvas_action(
                 "next_field",
                 key,
                 form_state,
@@ -375,8 +389,8 @@ pub async fn handle_edit_event(
             )
             .await?
         } else {
-            // FIX: Pass &mut event_handler.ideal_cursor_column
-            form_e::execute_edit_action(
+            // FIXED: Use canvas library instead of form_e::execute_edit_action
+            execute_canvas_action(
                 action_str,
                 key,
                 form_state,
@@ -426,8 +440,8 @@ pub async fn handle_edit_event(
             )
             .await?
         } else {
-            // FIX: Pass &mut event_handler.ideal_cursor_column
-            form_e::execute_edit_action(
+            // FIXED: Use canvas library instead of form_e::execute_edit_action
+            execute_canvas_action(
                 "insert_char",
                 key,
                 form_state,

client/src/modes/canvas/read_only.rs

@@ -53,6 +53,37 @@ async fn dispatch_to_active_state(
     }
 }
 
+/// Helper function to handle context-specific actions that need special treatment
+async fn handle_context_action(
+    action: &str,
+    app_state: &AppState,
+    form_state: &mut FormState,
+    grpc_client: &mut GrpcClient,
+    ideal_cursor_column: &mut usize,
+) -> Result<Option<String>> {
+    const CONTEXT_ACTIONS_FORM: &[&str] = &[
+        "previous_entry",
+        "next_entry",
+    ];
+    const CONTEXT_ACTIONS_LOGIN: &[&str] = &[
+        "previous_entry",
+        "next_entry",
+    ];
+
+    if app_state.ui.show_form && CONTEXT_ACTIONS_FORM.contains(&action) {
+        Ok(Some(crate::tui::functions::form::handle_action(
+            action,
+            form_state,
+            grpc_client,
+            ideal_cursor_column,
+        ).await?))
+    } else if app_state.ui.show_login && CONTEXT_ACTIONS_LOGIN.contains(&action) {
+        Ok(Some(crate::tui::functions::login::handle_action(action).await?))
+    } else {
+        Ok(None) // Not a context action, use regular canvas dispatch
+    }
+}
+
 pub async fn handle_form_readonly_with_canvas(
     key_event: KeyEvent,
     config: &Config,
@@ -171,32 +202,21 @@ pub async fn handle_read_only_event(
         return Ok((false, command_message.clone()));
     }
 
-    const CONTEXT_ACTIONS_FORM: &[&str] = &[
-        "previous_entry",
-        "next_entry",
-    ];
-    const CONTEXT_ACTIONS_LOGIN: &[&str] = &[
-        "previous_entry",
-        "next_entry",
-    ];
-
     if key.modifiers.is_empty() {
         key_sequence_tracker.add_key(key.code);
         let sequence = key_sequence_tracker.get_sequence();
 
         if let Some(action) = config.matches_key_sequence_generalized(&sequence).as_deref() {
-            let result = if app_state.ui.show_form && CONTEXT_ACTIONS_FORM.contains(&action) {
-                crate::tui::functions::form::handle_action(
-                    action,
-                    form_state,
-                    grpc_client,
-                    ideal_cursor_column,
-                )
-                .await?
-            } else if app_state.ui.show_login && CONTEXT_ACTIONS_LOGIN.contains(&action) {
-                crate::tui::functions::login::handle_action(action).await?
+            // Try context-specific actions first, otherwise use canvas dispatch
+            let result = if let Some(context_result) = handle_context_action(
+                action,
+                app_state,
+                form_state,
+                grpc_client,
+                ideal_cursor_column,
+            ).await? {
+                context_result
             } else {
-                // All canvas states handled uniformly
                 dispatch_to_active_state(
                     action,
                     app_state,
@@ -218,18 +238,16 @@ pub async fn handle_read_only_event(
 
         if sequence.len() == 1 && !config.is_key_sequence_prefix(&sequence) {
             if let Some(action) = config.get_read_only_action_for_key(key.code, key.modifiers).as_deref() {
-                let result = if app_state.ui.show_form && CONTEXT_ACTIONS_FORM.contains(&action) {
-                    crate::tui::functions::form::handle_action(
-                        action,
-                        form_state,
-                        grpc_client,
-                        ideal_cursor_column,
-                    )
-                    .await?
-                } else if app_state.ui.show_login && CONTEXT_ACTIONS_LOGIN.contains(&action) {
-                    crate::tui::functions::login::handle_action(action).await?
+                // Try context-specific actions first, otherwise use canvas dispatch
+                let result = if let Some(context_result) = handle_context_action(
+                    action,
+                    app_state,
+                    form_state,
+                    grpc_client,
+                    ideal_cursor_column,
+                ).await? {
+                    context_result
                 } else {
-                    // All canvas states handled uniformly
                     dispatch_to_active_state(
                         action,
                         app_state,
@@ -250,18 +268,16 @@ pub async fn handle_read_only_event(
         key_sequence_tracker.reset();
 
         if let Some(action) = config.get_read_only_action_for_key(key.code, key.modifiers).as_deref() {
-            let result = if app_state.ui.show_form && CONTEXT_ACTIONS_FORM.contains(&action) {
-                crate::tui::functions::form::handle_action(
-                    action,
-                    form_state,
-                    grpc_client,
-                    ideal_cursor_column,
-                )
-                .await?
-            } else if app_state.ui.show_login && CONTEXT_ACTIONS_LOGIN.contains(&action) {
-                crate::tui::functions::login::handle_action(action).await?
+            // Try context-specific actions first, otherwise use canvas dispatch
+            let result = if let Some(context_result) = handle_context_action(
+                action,
+                app_state,
+                form_state,
+                grpc_client,
+                ideal_cursor_column,
+            ).await? {
+                context_result
             } else {
-                // All canvas states handled uniformly
                 dispatch_to_active_state(
                     action,
                     app_state,