cleared codebase

canvas/src/validation/limits.rs

@@ -125,39 +125,56 @@ impl CharacterLimits {
         position: usize,
         character: char,
     ) -> Option<ValidationResult> {
-        let current_count = self.count(current_text);
-        let char_count = match self.count_mode {
-            CountMode::Characters => 1,
-            CountMode::DisplayWidth => {
-                let char_str = character.to_string();
-                char_str.width()
-            },
-            CountMode::Bytes => character.len_utf8(),
-        };
-        let new_count = current_count + char_count;
+        // FIX: Actually simulate the insertion at the specified position
+        // This makes the `position` parameter essential to the logic
         
+        // 1. Create the new string by inserting the character at the correct position
+        let mut new_text = String::with_capacity(current_text.len() + character.len_utf8());
+        let mut chars = current_text.chars();
+
+        // Append characters from the original string that come before the insertion point
+        // We clamp the position to be safe
+        let clamped_pos = position.min(current_text.chars().count());
+        for _ in 0..clamped_pos {
+            if let Some(ch) = chars.next() {
+                new_text.push(ch);
+            }
+        }
+
+        // Insert the new character
+        new_text.push(character);
+
+        // Append the rest of the original string
+        for ch in chars {
+            new_text.push(ch);
+        }
+
+        // 2. Now perform all validation on the *actual* resulting text
+        let new_count = self.count(&new_text);
+        let current_count = self.count(current_text);
+
         // Check max length
         if let Some(max) = self.max_length {
             if new_count > max {
                 return Some(ValidationResult::error(format!(
-                    "Character limit exceeded: {}/{}", 
-                    new_count, 
+                    "Character limit exceeded: {}/{}",
+                    new_count,
                     max
                 )));
             }
-            
+
             // Check warning threshold
             if let Some(warning_threshold) = self.warning_threshold {
                 if new_count >= warning_threshold && current_count < warning_threshold {
                     return Some(ValidationResult::warning(format!(
-                        "Approaching character limit: {}/{}", 
-                        new_count, 
+                        "Approaching character limit: {}/{}",
+                        new_count,
                         max
                     )));
                 }
             }
         }
-        
+
         None // No validation issues
     }