fix(dioxus): Prevent list item editing from losing trailing newlines

When editing a list item bullet in Dioxus, making no changes, and exiting
focus, the bullet would be combined with the following bullet (losing the
newline between them).

Root cause: In block.rs for ListItem editing, the content was extracted
from `line.full` and `.trim_end()` was applied, removing the trailing
newline. But when committing, EditorBlock used `block.node_range` which
included the newline. This mismatch caused the newline to be lost.

Changes:
- Add optional `edit_range` parameter to EditorBlock that defaults to
  `block.node_range` but allows callers to override it
- Remove `.trim_end()` from ListItem content extraction in block.rs
- Pass `line.full` as the `edit_range` for ListItem so range matches content
- Add no-op check to skip commits when content hasn't changed
- Rename `block_range` to `edit_range` in helper functions for clarity
- Add test verifying `line.full` includes trailing newline (round-trip invariant)

Prompts:
- "dioxus editing is a bit hosed. editing a bullet, changing nothing and
  exiting focus results in the bullet being combined with the following
  bullet (i.e. loses the newline between them)"

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: timabell

crates/markdown-neuraxis-dioxus/src/ui/components/block.rs

@@ -78,12 +78,11 @@ pub fn BlockRenderer(
         BlockKind::ListItem { .. } => {
             if is_focused {
                 // Use first line only - node_range includes nested children
-                let content_text = block
-                    .lines
-                    .first()
+                let first_line = block.lines.first();
+                let edit_range = first_line.map(|line| line.full.clone());
+                let content_text = first_line
                     .and_then(|line| source.get(line.full.clone()))
                     .unwrap_or("")
-                    .trim_end()
                     .to_string();
                 let block_clone = block.clone();
                 rsx! {
@@ -92,6 +91,7 @@ pub fn BlockRenderer(
                         EditorBlock {
                             block: block_clone,
                             content_text,
+                            edit_range,
                             on_command,
                             on_cancel: {
                                 let mut focused_anchor_id = focused_anchor_id;

crates/markdown-neuraxis-dioxus/src/ui/components/editor_block.rs

@@ -8,23 +8,31 @@ use markdown_neuraxis_engine::editing::{Block, BlockKind, Cmd};
 pub fn EditorBlock(
     block: Block,
     content_text: String,
+    /// Optional override for the edit range. Defaults to block.node_range.
+    /// Used for ListItems where we edit only the first line, not nested children.
+    edit_range: Option<std::ops::Range<usize>>,
     on_command: Callback<Cmd>,
     on_cancel: Callback<()>,
 ) -> Element {
     // Local state for textarea content - only commit changes on specific events
+    let original_content = content_text.clone();
     let local_content = use_signal(|| content_text.clone());
+    let edit_range = edit_range.unwrap_or_else(|| block.node_range.clone());
 
     // Helper to commit current changes to the document
     let commit_changes = {
         let on_command = on_command;
-        let block_range = block.node_range.clone();
+        let edit_range = edit_range.clone();
         move || {
             let current_text = local_content.read().clone();
-            let replace_cmd = Cmd::ReplaceRange {
-                range: block_range.clone(),
-                text: current_text,
-            };
-            on_command.call(replace_cmd);
+            // Only commit if content actually changed to avoid no-op replacements
+            if current_text != original_content {
+                let replace_cmd = Cmd::ReplaceRange {
+                    range: edit_range.clone(),
+                    text: current_text,
+                };
+                on_command.call(replace_cmd);
+            }
         }
     };
 
@@ -50,15 +58,15 @@ pub fn EditorBlock(
 
                 // Handle special keyboard commands via keydown (Tab, Shift+Tab, Enter, Escape)
                 onkeydown: {
-                    let block_range = block.node_range.clone();
+                    let edit_range = edit_range.clone();
                     let block_kind = block.kind.clone();
                     let on_command = on_command;
                     let on_cancel = on_cancel;
                     let commit_changes = commit_changes.clone();
                     move |event: Event<KeyboardData>| {
                         handle_editor_keydown(
                             event,
-                            &block_range,
+                            &edit_range,
                             &block_kind,
                             &on_command,
                             &on_cancel,
@@ -93,15 +101,15 @@ fn calculate_textarea_rows(content: &str) -> u32 {
 // Helper function to handle editor keyboard events
 fn handle_editor_keydown(
     event: Event<KeyboardData>,
-    block_range: &std::ops::Range<usize>,
+    edit_range: &std::ops::Range<usize>,
     block_kind: &BlockKind,
     on_command: &Callback<Cmd>,
     on_cancel: &Callback<()>,
     commit_changes: &impl Fn(),
 ) {
     match event.key() {
-        Key::Tab => handle_tab_key(event, block_range, on_command, commit_changes),
-        Key::Enter => handle_enter_key(event, block_range, block_kind, on_command, commit_changes),
+        Key::Tab => handle_tab_key(event, edit_range, on_command, commit_changes),
+        Key::Enter => handle_enter_key(event, edit_range, block_kind, on_command, commit_changes),
         Key::Escape => {
             commit_changes();
             on_cancel.call(());
@@ -113,7 +121,7 @@ fn handle_editor_keydown(
 // Handle Tab key press for indentation
 fn handle_tab_key(
     event: Event<KeyboardData>,
-    block_range: &std::ops::Range<usize>,
+    edit_range: &std::ops::Range<usize>,
     on_command: &Callback<Cmd>,
     commit_changes: &impl Fn(),
 ) {
@@ -122,11 +130,11 @@ fn handle_tab_key(
 
     let cmd = if event.modifiers().shift() {
         Cmd::OutdentLines {
-            range: block_range.clone(),
+            range: edit_range.clone(),
         }
     } else {
         Cmd::IndentLines {
-            range: block_range.clone(),
+            range: edit_range.clone(),
         }
     };
     on_command.call(cmd);
@@ -135,7 +143,7 @@ fn handle_tab_key(
 // Handle Enter key press for new lines or list item splitting
 fn handle_enter_key(
     event: Event<KeyboardData>,
-    block_range: &std::ops::Range<usize>,
+    edit_range: &std::ops::Range<usize>,
     block_kind: &BlockKind,
     on_command: &Callback<Cmd>,
     commit_changes: &impl Fn(),
@@ -149,11 +157,9 @@ fn handle_enter_key(
     commit_changes();
 
     let cmd = match block_kind {
-        BlockKind::ListItem { .. } => Cmd::SplitListItem {
-            at: block_range.end,
-        },
+        BlockKind::ListItem { .. } => Cmd::SplitListItem { at: edit_range.end },
         _ => Cmd::InsertText {
-            at: block_range.end,
+            at: edit_range.end,
             text: "\n".to_string(),
         },
     };

crates/markdown-neuraxis-engine/src/editing/snapshot.rs

@@ -2271,4 +2271,57 @@ mod tests {
             panic!("Expected Strong, got {:?}", block.segments[0].kind);
         }
     }
+
+    #[test]
+    fn test_list_item_line_full_includes_trailing_newline() {
+        // Verifies that line.full range includes trailing newline, so extracting
+        // source[line.full] and replacing range line.full is a no-op.
+        // This is critical for the editing workflow where focusing/unfocusing
+        // a list item without changes should not modify the document.
+        let text = "- Item 1\n- Item 2\n";
+        let mut doc = Document::from_bytes(text.as_bytes()).unwrap();
+        doc.create_anchors_from_tree();
+        let snapshot = doc.snapshot();
+
+        // Find the first list item
+        fn find_first_list_item(blocks: &[Block]) -> Option<&Block> {
+            for block in blocks {
+                if matches!(block.kind, BlockKind::ListItem { .. }) {
+                    return Some(block);
+                }
+                if let BlockContent::Children(children) = &block.content
+                    && let Some(found) = find_first_list_item(children)
+                {
+                    return Some(found);
+                }
+            }
+            None
+        }
+
+        let item = find_first_list_item(&snapshot.blocks).expect("Should have list item");
+
+        // The first line's full range should capture "- Item 1\n" exactly
+        assert!(
+            !item.lines.is_empty(),
+            "List item should have at least one line"
+        );
+        let first_line = &item.lines[0];
+
+        // Extract content using line.full (what the UI does for editing)
+        let extracted = &text[first_line.full.clone()];
+
+        // Verify it includes the trailing newline
+        assert_eq!(
+            extracted, "- Item 1\n",
+            "line.full should include trailing newline"
+        );
+
+        // Verify that replacing first_line.full with extracted content is a no-op
+        let mut modified = text.to_string();
+        modified.replace_range(first_line.full.clone(), extracted);
+        assert_eq!(
+            modified, text,
+            "Replacing line.full with its content should be a no-op"
+        );
+    }
 }