emit LayoutChanged when selector mutations affect rendered height

Co-Authored-By: Oz <oz-agent@warp.dev>

Author: harryalbert

crates/warp_tui/src/option_selector.rs

@@ -52,6 +52,11 @@ pub(crate) enum TuiOptionSelectorEvent {
     /// The selector asked to be dismissed (element-level Escape fallback for
     /// hosts without their own Escape binding).
     Dismissed,
+    /// Something that affects the selector's rendered height changed: the
+    /// viewport scrolled (overflow markers), the row catalog refreshed, or
+    /// the custom-text error row toggled. Hosts whose measured height is
+    /// cached re-measure on this event.
+    LayoutChanged,
 }
 
 /// User interactions dispatched from the selector's element tree.
@@ -164,6 +169,8 @@ impl TuiOptionSelector {
             .or_else(|| self.snapshot.selected_id.clone());
         self.highlight_id(target);
         self.sync_after_items_changed();
+        // A refreshed catalog can change the row count and thus the height.
+        ctx.emit(TuiOptionSelectorEvent::LayoutChanged);
         ctx.notify();
     }
 
@@ -173,6 +180,26 @@ impl TuiOptionSelector {
         self.custom_text.is_some()
     }
 
+    /// Scrolls to keep `selected` visible, announcing the scroll change (it
+    /// toggles overflow markers, so the height may change) to the host.
+    fn scroll_to_keep_visible(
+        &mut self,
+        items_len: usize,
+        selected: usize,
+        ctx: &mut ViewContext<Self>,
+    ) {
+        let before = self.scroll_offset;
+        keep_selected_visible(
+            items_len,
+            selected,
+            MAX_VISIBLE_OPTION_ROWS,
+            &mut self.scroll_offset,
+        );
+        if self.scroll_offset != before {
+            ctx.emit(TuiOptionSelectorEvent::LayoutChanged);
+        }
+    }
+
     /// Confirms the highlighted item (Enter): enabled rows emit
     /// [`TuiOptionSelectorEvent::Confirmed`]; disabled rows are kept
     /// highlighted so their reason stays visible. While the
@@ -193,7 +220,10 @@ impl TuiOptionSelector {
     /// editing and reports whether the key was consumed, so the card only
     /// leaves the page when the selector had nothing to unwind.
     pub(crate) fn handle_back(&mut self, ctx: &mut ViewContext<Self>) -> bool {
-        if self.custom_text.take().is_some() {
+        if let Some(editor) = self.custom_text.take() {
+            if editor.error.is_some() {
+                ctx.emit(TuiOptionSelectorEvent::LayoutChanged);
+            }
             ctx.notify();
             return true;
         }
@@ -291,12 +321,7 @@ impl TuiOptionSelector {
             self.selection.select_previous(items_len, |_| true);
         }
         if let Some(selected) = self.selection.selected_index() {
-            keep_selected_visible(
-                items_len,
-                selected,
-                MAX_VISIBLE_OPTION_ROWS,
-                &mut self.scroll_offset,
-            );
+            self.scroll_to_keep_visible(items_len, selected, ctx);
         }
         ctx.notify();
     }
@@ -309,12 +334,7 @@ impl TuiOptionSelector {
             return;
         };
         self.selection.select(index, items.len(), |_| true);
-        keep_selected_visible(
-            items.len(),
-            index,
-            MAX_VISIBLE_OPTION_ROWS,
-            &mut self.scroll_offset,
-        );
+        self.scroll_to_keep_visible(items.len(), index, ctx);
         if !self.item_is_confirmable(item) {
             ctx.notify();
             return;
@@ -344,8 +364,14 @@ impl TuiOptionSelector {
         };
         let value = editor.buffer.trim().to_string();
         if value.is_empty() {
-            editor.error = Some(CUSTOM_TEXT_EMPTY_ERROR.to_string());
+            if editor.error.is_none() {
+                editor.error = Some(CUSTOM_TEXT_EMPTY_ERROR.to_string());
+                ctx.emit(TuiOptionSelectorEvent::LayoutChanged);
+            }
         } else {
+            if editor.error.is_some() {
+                ctx.emit(TuiOptionSelectorEvent::LayoutChanged);
+            }
             self.custom_text = None;
             self.snapshot.selected_id = Some(value.clone());
             self.custom_text_value = Some(value.clone());
@@ -359,10 +385,14 @@ impl TuiOptionSelector {
     fn scroll_by(&mut self, rows: isize, ctx: &mut ViewContext<Self>) {
         let items_len = self.items().len();
         let max_offset = items_len.saturating_sub(MAX_VISIBLE_OPTION_ROWS);
+        let before = self.scroll_offset;
         self.scroll_offset = self
             .scroll_offset
             .saturating_add_signed(rows)
             .min(max_offset);
+        if self.scroll_offset != before {
+            ctx.emit(TuiOptionSelectorEvent::LayoutChanged);
+        }
         ctx.notify();
     }
 
@@ -661,14 +691,18 @@ impl TypedActionView for TuiOptionSelector {
             TuiOptionSelectorAction::InsertChar(c) => {
                 if let Some(editor) = &mut self.custom_text {
                     editor.buffer.push(*c);
-                    editor.error = None;
+                    if editor.error.take().is_some() {
+                        ctx.emit(TuiOptionSelectorEvent::LayoutChanged);
+                    }
                     ctx.notify();
                 }
             }
             TuiOptionSelectorAction::Backspace => {
                 if let Some(editor) = &mut self.custom_text {
                     editor.buffer.pop();
-                    editor.error = None;
+                    if editor.error.take().is_some() {
+                        ctx.emit(TuiOptionSelectorEvent::LayoutChanged);
+                    }
                     ctx.notify();
                 }
             }

crates/warp_tui/src/option_selector_tests.rs

@@ -64,6 +64,17 @@ fn header() -> OptionSelectorHeader {
 
 type CapturedEvents = Rc<RefCell<Vec<TuiOptionSelectorEvent>>>;
 
+/// The captured events with `LayoutChanged` filtered out, for tests that
+/// assert on the primary confirmation flow.
+fn primary_events(events: &CapturedEvents) -> Vec<TuiOptionSelectorEvent> {
+    events
+        .borrow()
+        .iter()
+        .filter(|event| **event != TuiOptionSelectorEvent::LayoutChanged)
+        .cloned()
+        .collect()
+}
+
 /// Adds a selector in a fresh TUI window and captures its emitted events.
 fn add_selector(app: &mut App) -> (ViewHandle<TuiOptionSelector>, CapturedEvents) {
     app.add_singleton_model(|_| Appearance::mock());
@@ -285,7 +296,7 @@ fn digits_are_viewport_relative_in_scrolled_lists() {
             TuiOptionSelectorAction::SelectNumberedOption(1),
         );
         assert_eq!(
-            events.borrow().as_slice(),
+            primary_events(&events),
             [TuiOptionSelectorEvent::Confirmed {
                 id: "row-2".to_string()
             }],
@@ -438,7 +449,7 @@ fn custom_text_editor_trims_validates_and_submits() {
             TuiOptionSelectorAction::InsertChar(' '),
         );
         confirm(&mut app, &selector);
-        assert!(events.borrow().is_empty());
+        assert!(primary_events(&events).is_empty());
         assert!(render_lines(&app, &selector, 60)
             .iter()
             .any(|line| line.contains("Enter a value to continue.")));
@@ -450,7 +461,7 @@ fn custom_text_editor_trims_validates_and_submits() {
         act(&mut app, &selector, TuiOptionSelectorAction::Backspace);
         confirm(&mut app, &selector);
         assert_eq!(
-            events.borrow().as_slice(),
+            primary_events(&events),
             [TuiOptionSelectorEvent::CustomTextSubmitted {
                 value: "my-host".to_string()
             }],
@@ -503,6 +514,69 @@ fn create_new_auth_secret_footer_is_ignored() {
     });
 }
 
+#[test]
+fn layout_changed_is_emitted_only_when_overflow_markers_toggle() {
+    App::test((), |mut app| async move {
+        let (selector, events) = add_selector(&mut app);
+        set_page(
+            &mut app,
+            &selector,
+            snapshot(&["a", "b", "c", "d", "e", "f"], Some("a")),
+        );
+        events.borrow_mut().clear();
+
+        // Moves within the viewport do not scroll, so nothing is emitted.
+        for _ in 0..3 {
+            act(&mut app, &selector, TuiOptionSelectorAction::MoveDown);
+        }
+        assert!(!events
+            .borrow()
+            .contains(&TuiOptionSelectorEvent::LayoutChanged));
+
+        // Scrolling past the viewport reveals the `↑` marker: one event.
+        act(&mut app, &selector, TuiOptionSelectorAction::MoveDown);
+        assert_eq!(
+            events
+                .borrow()
+                .iter()
+                .filter(|event| **event == TuiOptionSelectorEvent::LayoutChanged)
+                .count(),
+            1,
+        );
+    });
+}
+
+#[test]
+fn layout_changed_is_emitted_when_the_custom_text_error_row_toggles() {
+    App::test((), |mut app| async move {
+        let (selector, events) = add_selector(&mut app);
+        let mut with_footer = snapshot(&["warp"], Some("warp"));
+        with_footer.footer = Some(OptionFooter::CustomText {
+            label: "Custom host…".to_string(),
+        });
+        set_page(&mut app, &selector, with_footer);
+        act(&mut app, &selector, TuiOptionSelectorAction::SelectItem(1));
+        events.borrow_mut().clear();
+
+        // An empty submit adds the validation-error row.
+        confirm(&mut app, &selector);
+        assert!(events
+            .borrow()
+            .contains(&TuiOptionSelectorEvent::LayoutChanged));
+        events.borrow_mut().clear();
+
+        // Typing clears the error row.
+        act(
+            &mut app,
+            &selector,
+            TuiOptionSelectorAction::InsertChar('x'),
+        );
+        assert!(events
+            .borrow()
+            .contains(&TuiOptionSelectorEvent::LayoutChanged));
+    });
+}
+
 #[test]
 fn snapshot_refresh_preserves_the_highlighted_row() {
     App::test((), |mut app| async move {
@@ -517,7 +591,7 @@ fn snapshot_refresh_preserves_the_highlighted_row() {
         });
         confirm(&mut app, &selector);
         assert_eq!(
-            events.borrow().as_slice(),
+            primary_events(&events),
             [TuiOptionSelectorEvent::Confirmed {
                 id: "c".to_string()
             }],
@@ -539,7 +613,7 @@ fn snapshot_refresh_falls_back_to_the_selected_value_when_the_highlight_vanishes
         });
         confirm(&mut app, &selector);
         assert_eq!(
-            events.borrow().as_slice(),
+            primary_events(&events),
             [TuiOptionSelectorEvent::Confirmed {
                 id: "a".to_string()
             }],