Skip to main content

ftui_widgets/
table.rs

1use crate::block::{Alignment, Block};
2use crate::mouse::MouseResult;
3use crate::undo_support::{TableUndoExt, UndoSupport, UndoWidgetId};
4use crate::{
5    MeasurableWidget, SizeConstraints, StatefulWidget, Widget, apply_style, clear_text_area,
6    set_style_area,
7};
8use ftui_core::event::{MouseButton, MouseEvent, MouseEventKind};
9use ftui_core::geometry::{Rect, Size};
10use ftui_layout::{Constraint, Flex};
11use ftui_render::buffer::Buffer;
12use ftui_render::cell::Cell;
13use ftui_render::frame::{Frame, HitId, HitRegion};
14use ftui_style::{
15    Style, StyleSheet, TableEffectResolver, TableEffectScope, TableEffectTarget, TablePresetId,
16    TableSection, TableTheme,
17};
18use ftui_text::{Line, Span, Text};
19use std::any::Any;
20
21fn text_into_owned(text: Text<'_>) -> Text<'static> {
22    Text::from_lines(
23        text.into_iter()
24            .map(|line| Line::from_spans(line.into_iter().map(Span::into_owned))),
25    )
26}
27
28/// A row in a table.
29#[derive(Debug, Clone, Default)]
30pub struct Row {
31    cells: Vec<Text<'static>>,
32    height: u16,
33    style: Style,
34    bottom_margin: u16,
35}
36
37impl Row {
38    /// Create a new row from an iterator of cell contents.
39    #[must_use]
40    pub fn new<'a>(cells: impl IntoIterator<Item = impl Into<Text<'a>>>) -> Self {
41        Self {
42            cells: cells
43                .into_iter()
44                .map(|c| text_into_owned(c.into()))
45                .collect(),
46            height: 1,
47            style: Style::default(),
48            bottom_margin: 0,
49        }
50    }
51
52    /// Set the row height in lines.
53    ///
54    /// Values below 1 clamp to a single visible line so rows always consume
55    /// vertical space deterministically.
56    #[must_use]
57    pub fn height(mut self, height: u16) -> Self {
58        self.height = height.max(1);
59        self
60    }
61
62    /// Set the row style.
63    #[must_use]
64    pub fn style(mut self, style: Style) -> Self {
65        self.style = style;
66        self
67    }
68
69    /// Set the bottom margin after this row.
70    #[must_use]
71    pub fn bottom_margin(mut self, margin: u16) -> Self {
72        self.bottom_margin = margin;
73        self
74    }
75}
76
77/// Text truncation policy for table columns.
78#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
79pub enum Truncate {
80    /// Hard clip at column boundary without ellipsis.
81    #[default]
82    Clip,
83    /// Truncate with an ellipsis (`…` or `...` for ASCII themes) when text exceeds column width.
84    Ellipsis,
85    /// Wrap text across multiple lines up to `TableTheme::row_height` lines.
86    Wrap,
87}
88
89/// Layout and formatting specifications for an individual table column.
90#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
91pub struct ColumnSpec {
92    /// Truncation policy for cells in this column.
93    pub truncation: Truncate,
94    /// Text alignment within the column.
95    pub alignment: Alignment,
96}
97
98impl ColumnSpec {
99    /// Create a new column specification.
100    #[must_use]
101    pub const fn new(truncation: Truncate, alignment: Alignment) -> Self {
102        Self {
103            truncation,
104            alignment,
105        }
106    }
107}
108
109/// A widget to display data in a table.
110#[derive(Debug, Clone, Default)]
111pub struct Table<'a> {
112    rows: Vec<Row>,
113    widths: Vec<Constraint>,
114    column_specs: Vec<ColumnSpec>,
115    header: Option<Row>,
116    block: Option<Block<'a>>,
117    style: Style,
118    highlight_style: Style,
119    theme: TableTheme,
120    theme_phase: f32,
121    column_spacing: u16,
122    /// Optional hit ID for mouse interaction.
123    /// When set, each table row registers a hit region with the hit grid.
124    hit_id: Option<HitId>,
125    /// Optional data hash to enable caching of filtered and sorted indices.
126    data_hash: Option<u64>,
127}
128
129impl<'a> Table<'a> {
130    /// Create a new table with the given rows and column width constraints.
131    #[must_use]
132    pub fn new(
133        rows: impl IntoIterator<Item = Row>,
134        widths: impl IntoIterator<Item = Constraint>,
135    ) -> Self {
136        let rows: Vec<Row> = rows.into_iter().collect();
137        let widths: Vec<Constraint> = widths.into_iter().collect();
138
139        Self {
140            rows,
141            widths,
142            column_specs: Vec::new(),
143            header: None,
144            block: None,
145            style: Style::default(),
146            highlight_style: Style::default(),
147            theme: TableTheme::default(),
148            theme_phase: 0.0,
149            column_spacing: 1,
150            hit_id: None,
151            data_hash: None,
152        }
153    }
154
155    /// Set the specification for a column by index.
156    #[must_use]
157    pub fn with_column_spec(mut self, col: usize, spec: ColumnSpec) -> Self {
158        if col >= self.column_specs.len() {
159            self.column_specs.resize(col + 1, ColumnSpec::default());
160        }
161        self.column_specs[col] = spec;
162        self
163    }
164
165    /// Set the truncation mode for a column by index.
166    #[must_use]
167    pub fn with_column_truncation(mut self, col: usize, truncation: Truncate) -> Self {
168        if col >= self.column_specs.len() {
169            self.column_specs.resize(col + 1, ColumnSpec::default());
170        }
171        self.column_specs[col].truncation = truncation;
172        self
173    }
174
175    /// Set the text alignment for a column by index.
176    #[must_use]
177    pub fn with_column_alignment(mut self, col: usize, alignment: Alignment) -> Self {
178        if col >= self.column_specs.len() {
179            self.column_specs.resize(col + 1, ColumnSpec::default());
180        }
181        self.column_specs[col].alignment = alignment;
182        self
183    }
184
185    /// Set an explicit data hash to enable caching of filtered and sorted indices.
186    ///
187    /// This is highly recommended for large tables. When provided, the table widget
188    /// will cache the result of filtering and sorting in the `TableState`, skipping
189    /// expensive O(N) re-evaluation on frames where the hash, filter, and sort
190    /// parameters have not changed.
191    #[must_use]
192    pub fn data_hash(mut self, hash: u64) -> Self {
193        self.data_hash = Some(hash);
194        self
195    }
196
197    /// Set the header row.
198    #[must_use]
199    pub fn header(mut self, header: Row) -> Self {
200        self.header = Some(header);
201        self
202    }
203
204    /// Set the surrounding block.
205    #[must_use]
206    pub fn block(mut self, block: Block<'a>) -> Self {
207        self.block = Some(block);
208        self
209    }
210
211    /// Set the base table style.
212    #[must_use]
213    pub fn style(mut self, style: Style) -> Self {
214        self.style = style;
215        self
216    }
217
218    /// Set the style for the selected row.
219    #[must_use]
220    pub fn highlight_style(mut self, style: Style) -> Self {
221        self.highlight_style = style;
222        self
223    }
224
225    /// Set the table theme (base/states/effects).
226    #[must_use]
227    pub fn theme(mut self, theme: TableTheme) -> Self {
228        self.theme = theme;
229        self
230    }
231
232    /// Get a reference to the table theme.
233    #[must_use]
234    pub const fn table_theme(&self) -> &TableTheme {
235        &self.theme
236    }
237
238    /// Apply styles from a [`StyleSheet`] using the default prefix `"table"`.
239    ///
240    /// Looks up styles with names like `"table.border"`, `"table.header"`, `"table.row"`,
241    /// `"table.row_alt"`, `"table.row_selected"`, `"table.row_hover"`, and `"table.divider"`.
242    /// Only roles defined in the stylesheet will override the current theme's styles.
243    #[must_use]
244    pub fn with_stylesheet(self, sheet: &StyleSheet) -> Self {
245        self.with_stylesheet_prefix(sheet, crate::style_names::TABLE_PREFIX)
246    }
247
248    /// Apply styles from a [`StyleSheet`] using a custom prefix.
249    ///
250    /// For each standard role (`border`, `header`, `row`, `row_alt`, `row_selected`,
251    /// `row_hover`, `divider`), if `{prefix}.{role}` is defined in the stylesheet,
252    /// it replaces that style in the table's theme.
253    #[must_use]
254    pub fn with_stylesheet_prefix(mut self, sheet: &StyleSheet, prefix: &str) -> Self {
255        if let Some(s) = sheet.get(&format!("{prefix}.{}", crate::style_names::TABLE_BORDER)) {
256            self.theme.border = s;
257        }
258        if let Some(s) = sheet.get(&format!("{prefix}.{}", crate::style_names::TABLE_HEADER)) {
259            self.theme.header = s;
260        }
261        if let Some(s) = sheet.get(&format!("{prefix}.{}", crate::style_names::TABLE_ROW)) {
262            self.theme.row = s;
263        }
264        if let Some(s) = sheet.get(&format!("{prefix}.{}", crate::style_names::TABLE_ROW_ALT)) {
265            self.theme.row_alt = s;
266        }
267        if let Some(s) = sheet.get(&format!(
268            "{prefix}.{}",
269            crate::style_names::TABLE_ROW_SELECTED
270        )) {
271            self.theme.row_selected = s;
272        }
273        if let Some(s) = sheet.get(&format!("{prefix}.{}", crate::style_names::TABLE_ROW_HOVER)) {
274            self.theme.row_hover = s;
275        }
276        if let Some(s) = sheet.get(&format!("{prefix}.{}", crate::style_names::TABLE_DIVIDER)) {
277            self.theme.divider = s;
278        }
279        self
280    }
281
282    /// Set the explicit animation phase for theme effects.
283    ///
284    /// Phase is deterministic and should be supplied by the caller (e.g. from tick count).
285    #[must_use]
286    pub fn theme_phase(mut self, phase: f32) -> Self {
287        self.theme_phase = phase;
288        self
289    }
290
291    /// Set the spacing between columns.
292    #[must_use]
293    pub fn column_spacing(mut self, spacing: u16) -> Self {
294        self.column_spacing = spacing;
295        self
296    }
297
298    /// Set a hit ID for mouse interaction.
299    ///
300    /// When set, each table row will register a hit region with the frame's
301    /// hit grid (if enabled). The hit data will be the row's index, allowing
302    /// click handlers to determine which row was clicked.
303    #[must_use]
304    pub fn hit_id(mut self, id: HitId) -> Self {
305        self.hit_id = Some(id);
306        self
307    }
308
309    fn filtered_and_sorted_indices(&self, state: &mut TableState) -> std::sync::Arc<[usize]> {
310        if let Some(hash) = self.data_hash
311            && let Some((cached_hash, cached_filter, cached_sort_col, cached_sort_asc, indices)) =
312                &state.cached_display_indices
313            && *cached_hash == hash
314            && *cached_filter == state.filter
315            && *cached_sort_col == state.sort_column
316            && *cached_sort_asc == state.sort_ascending
317        {
318            return std::sync::Arc::clone(indices);
319        }
320
321        let mut indices: Vec<usize> = (0..self.rows.len()).collect();
322
323        // 1. Filter
324        if !state.filter.trim().is_empty() {
325            let query = state.filter.trim().to_lowercase();
326            indices.retain(|&i| {
327                let row = &self.rows[i];
328                row.cells.iter().any(|cell| {
329                    // Optimization: check single-span content directly to avoid allocation
330                    // from to_plain_text().
331                    if let Some(line) = cell.lines().first()
332                        && cell.lines().len() == 1
333                        && line.spans().len() == 1
334                    {
335                        return crate::contains_ignore_case(&line.spans()[0].content, &query);
336                    }
337                    crate::contains_ignore_case(&cell.to_plain_text(), &query)
338                })
339            });
340        }
341
342        // 2. Sort
343        if let Some(col_idx) = state.sort_column {
344            use std::borrow::Cow;
345            let mut sort_keys: Vec<(usize, Cow<str>)> = indices
346                .iter()
347                .map(|&i| {
348                    let cell_text = self.rows[i].cells.get(col_idx);
349                    let key = match cell_text {
350                        Some(text) => {
351                            // Optimization: Borrow content directly if simple (1 line, 1 span)
352                            if let Some(line) = text.lines().first() {
353                                if text.lines().len() == 1 && line.spans().len() == 1 {
354                                    Cow::Borrowed(line.spans()[0].content.as_ref())
355                                } else {
356                                    Cow::Owned(text.to_plain_text())
357                                }
358                            } else {
359                                Cow::Borrowed("")
360                            }
361                        }
362                        None => Cow::Borrowed(""),
363                    };
364                    (i, key)
365                })
366                .collect();
367
368            if state.sort_ascending {
369                sort_keys.sort_unstable_by(|a, b| a.1.cmp(&b.1));
370            } else {
371                sort_keys.sort_unstable_by(|a, b| b.1.cmp(&a.1));
372            }
373
374            indices = sort_keys.into_iter().map(|(i, _)| i).collect();
375        }
376
377        let arc_indices: std::sync::Arc<[usize]> = indices.into();
378
379        if let Some(hash) = self.data_hash {
380            state.cached_display_indices = Some((
381                hash,
382                state.filter.clone(),
383                state.sort_column,
384                state.sort_ascending,
385                std::sync::Arc::clone(&arc_indices),
386            ));
387        }
388
389        arc_indices
390    }
391
392    fn requires_measurement(constraints: &[Constraint]) -> bool {
393        constraints.iter().any(|c| {
394            matches!(
395                c,
396                Constraint::FitContent | Constraint::FitContentBounded { .. } | Constraint::FitMin
397            )
398        })
399    }
400
401    fn compute_intrinsic_widths(rows: &[Row], header: Option<&Row>, col_count: usize) -> Vec<u16> {
402        if col_count == 0 {
403            return Vec::new();
404        }
405
406        let mut col_widths: Vec<u16> = vec![0; col_count];
407
408        if let Some(header) = header {
409            for (i, cell) in header.cells.iter().enumerate().take(col_count) {
410                let cell_width = cell
411                    .lines()
412                    .iter()
413                    .take(header.height as usize)
414                    .map(|l| l.width())
415                    .max()
416                    .unwrap_or(0)
417                    .min(u16::MAX as usize) as u16;
418                col_widths[i] = col_widths[i].max(cell_width);
419            }
420        }
421
422        for row in rows {
423            for (i, cell) in row.cells.iter().enumerate().take(col_count) {
424                let cell_width = cell
425                    .lines()
426                    .iter()
427                    .take(row.height as usize)
428                    .map(|l| l.width())
429                    .max()
430                    .unwrap_or(0)
431                    .min(u16::MAX as usize) as u16;
432                col_widths[i] = col_widths[i].max(cell_width);
433            }
434        }
435
436        col_widths
437    }
438}
439
440impl<'a> Widget for Table<'a> {
441    fn render(&self, area: Rect, frame: &mut Frame) {
442        let mut state = TableState::default();
443        StatefulWidget::render(self, area, frame, &mut state);
444    }
445}
446
447impl ftui_a11y::Accessible for Table<'_> {
448    fn accessibility_nodes(&self, area: Rect) -> Vec<ftui_a11y::node::A11yNodeInfo> {
449        use ftui_a11y::node::{A11yNodeInfo, A11yRole};
450
451        let base_id = crate::a11y_node_id(area);
452        let row_count = self.rows.len();
453        let col_count = self.widths.len();
454
455        let title = self
456            .block
457            .as_ref()
458            .and_then(|b| b.title_text())
459            .unwrap_or_default();
460
461        let mut table_node = A11yNodeInfo::new(base_id, A11yRole::Table, area)
462            .with_description(format!("{row_count} rows, {col_count} columns"));
463        if !title.is_empty() {
464            table_node = table_node.with_name(title);
465        }
466
467        vec![table_node]
468    }
469}
470
471pub type CachedTableDisplayIndices = (u64, String, Option<usize>, bool, std::sync::Arc<[usize]>);
472
473/// Mutable state for a [`Table`] widget.
474#[derive(Debug, Clone, Default)]
475pub struct TableState {
476    /// Unique ID for undo tracking.
477    #[allow(dead_code)]
478    undo_id: UndoWidgetId,
479    /// Index of the currently selected row, if any.
480    pub selected: Option<usize>,
481    /// Index of the currently hovered row, if any.
482    pub hovered: Option<usize>,
483    /// Scroll offset (first visible row index).
484    pub offset: usize,
485    /// Optional persistence ID for state saving/restoration.
486    /// When set, this state can be persisted via the [`Stateful`] trait.
487    persistence_id: Option<String>,
488    /// Current sort column (for undo support).
489    pub sort_column: Option<usize>,
490    /// Sort ascending (for undo support).
491    pub sort_ascending: bool,
492    /// Filter text (for undo support).
493    pub filter: String,
494    /// Cache for stable layout resizing (temporal coherence).
495    coherence: ftui_layout::CoherenceCache,
496    /// Cached display indices (data_hash, filter, sort_column, sort_ascending, indices)
497    #[doc(hidden)]
498    pub cached_display_indices: Option<CachedTableDisplayIndices>,
499    /// Cached intrinsic column widths (data_hash, widths)
500    #[doc(hidden)]
501    pub cached_intrinsic_widths: Option<(u64, std::sync::Arc<[u16]>)>,
502}
503
504impl TableState {
505    /// Set the selected row index.
506    pub fn select(&mut self, index: Option<usize>) {
507        self.selected = index;
508    }
509
510    /// Create a new TableState with a persistence ID for state saving. Without
511    /// one the table has no [`StateKey`](crate::stateful::StateKey) and its
512    /// state is not persisted.
513    #[must_use]
514    pub fn with_persistence_id(mut self, id: impl Into<String>) -> Self {
515        self.persistence_id = Some(id.into());
516        self
517    }
518
519    /// Get the persistence ID, if set.
520    #[must_use = "use the persistence id (if any)"]
521    pub fn persistence_id(&self) -> Option<&str> {
522        self.persistence_id.as_deref()
523    }
524}
525
526// ============================================================================
527// Stateful Persistence Implementation
528// ============================================================================
529
530/// Persistable state for a [`TableState`].
531///
532/// This struct contains only the fields that should be persisted across
533/// sessions. Derived/cached values are not included.
534#[derive(Clone, Debug, Default, PartialEq)]
535#[cfg_attr(
536    feature = "state-persistence",
537    derive(serde::Serialize, serde::Deserialize)
538)]
539pub struct TablePersistState {
540    /// Selected row index.
541    pub selected: Option<usize>,
542    /// Scroll offset (first visible row).
543    pub offset: usize,
544    /// Current sort column index.
545    pub sort_column: Option<usize>,
546    /// Sort direction (true = ascending, false = descending).
547    pub sort_ascending: bool,
548    /// Active filter text.
549    pub filter: String,
550}
551
552impl crate::stateful::Stateful for TableState {
553    type State = TablePersistState;
554
555    fn state_key(&self) -> Option<crate::stateful::StateKey> {
556        // No persistence_id, no identity: two unnamed tables must not share one.
557        self.persistence_id
558            .as_deref()
559            .map(|id| crate::stateful::StateKey::new("Table", id))
560    }
561
562    fn save_state(&self) -> TablePersistState {
563        TablePersistState {
564            selected: self.selected,
565            offset: self.offset,
566            sort_column: self.sort_column,
567            sort_ascending: self.sort_ascending,
568            filter: self.filter.clone(),
569        }
570    }
571
572    fn restore_state(&mut self, state: TablePersistState) {
573        // Restore values directly; clamping to valid ranges happens during render
574        self.selected = state.selected;
575        self.hovered = None;
576        self.offset = state.offset;
577        self.sort_column = state.sort_column;
578        self.sort_ascending = state.sort_ascending;
579        self.filter = state.filter;
580    }
581}
582
583// ============================================================================
584// Undo Support Implementation
585// ============================================================================
586
587/// Snapshot of TableState for undo.
588#[derive(Debug, Clone)]
589pub struct TableStateSnapshot {
590    selected: Option<usize>,
591    offset: usize,
592    sort_column: Option<usize>,
593    sort_ascending: bool,
594    filter: String,
595}
596
597impl UndoSupport for TableState {
598    fn undo_widget_id(&self) -> UndoWidgetId {
599        self.undo_id
600    }
601
602    fn create_snapshot(&self) -> Box<dyn Any + Send> {
603        Box::new(TableStateSnapshot {
604            selected: self.selected,
605            offset: self.offset,
606            sort_column: self.sort_column,
607            sort_ascending: self.sort_ascending,
608            filter: self.filter.clone(),
609        })
610    }
611
612    fn restore_snapshot(&mut self, snapshot: &dyn Any) -> bool {
613        if let Some(snap) = snapshot.downcast_ref::<TableStateSnapshot>() {
614            self.selected = snap.selected;
615            self.hovered = None;
616            self.offset = snap.offset;
617            self.sort_column = snap.sort_column;
618            self.sort_ascending = snap.sort_ascending;
619            self.filter = snap.filter.clone();
620            true
621        } else {
622            false
623        }
624    }
625}
626
627impl TableUndoExt for TableState {
628    fn sort_state(&self) -> (Option<usize>, bool) {
629        (self.sort_column, self.sort_ascending)
630    }
631
632    fn set_sort_state(&mut self, column: Option<usize>, ascending: bool) {
633        self.sort_column = column;
634        self.sort_ascending = ascending;
635    }
636
637    fn filter_text(&self) -> &str {
638        &self.filter
639    }
640
641    fn set_filter_text(&mut self, filter: &str) {
642        self.filter = filter.to_string();
643    }
644}
645
646impl TableState {
647    /// Get the undo widget ID.
648    ///
649    /// This can be used to associate undo commands with this state instance.
650    #[must_use]
651    pub fn undo_id(&self) -> UndoWidgetId {
652        self.undo_id
653    }
654
655    /// Get the current sort column.
656    #[must_use = "use the sort column (if any)"]
657    pub fn sort_column(&self) -> Option<usize> {
658        self.sort_column
659    }
660
661    /// Get whether the sort is ascending.
662    #[must_use]
663    pub fn sort_ascending(&self) -> bool {
664        self.sort_ascending
665    }
666
667    /// Set the sort state.
668    pub fn set_sort(&mut self, column: Option<usize>, ascending: bool) {
669        self.sort_column = column;
670        self.sort_ascending = ascending;
671    }
672
673    /// Get the filter text.
674    #[must_use]
675    pub fn filter(&self) -> &str {
676        &self.filter
677    }
678
679    /// Set the filter text.
680    pub fn set_filter(&mut self, filter: impl Into<String>) {
681        self.filter = filter.into();
682    }
683
684    /// Handle a mouse event for this table.
685    ///
686    /// # Hit data convention
687    ///
688    /// The hit data (`u64`) encodes the row index. When the table renders with
689    /// a `hit_id`, each visible row registers `HitRegion::Content` with
690    /// `data = row_index as u64`.
691    ///
692    /// # Arguments
693    ///
694    /// * `event` — the mouse event from the terminal
695    /// * `hit` — result of `frame.hit_test(event.x, event.y)`, if available
696    /// * `expected_id` — the `HitId` this table was rendered with
697    /// * `row_count` — total number of rows in the table
698    pub fn handle_mouse(
699        &mut self,
700        event: &MouseEvent,
701        hit: Option<(HitId, HitRegion, u64)>,
702        expected_id: HitId,
703        row_count: usize,
704    ) -> MouseResult {
705        match event.kind {
706            MouseEventKind::Down(MouseButton::Left) => {
707                if let Some((id, HitRegion::Content, data)) = hit
708                    && id == expected_id
709                {
710                    let index = data as usize;
711                    if index < row_count {
712                        // Deterministic "double click": second click on the already-selected row activates.
713                        if self.selected == Some(index) {
714                            return MouseResult::Activated(index);
715                        }
716                        self.select(Some(index));
717                        return MouseResult::Selected(index);
718                    }
719                }
720                MouseResult::Ignored
721            }
722            MouseEventKind::Moved => {
723                if let Some((id, HitRegion::Content, data)) = hit
724                    && id == expected_id
725                {
726                    let index = data as usize;
727                    if index < row_count {
728                        let changed = self.hovered != Some(index);
729                        self.hovered = Some(index);
730                        return if changed {
731                            MouseResult::HoverChanged
732                        } else {
733                            MouseResult::Ignored
734                        };
735                    }
736                }
737                // Mouse moved off the widget or to non-content region
738                if self.hovered.is_some() {
739                    self.hovered = None;
740                    MouseResult::HoverChanged
741                } else {
742                    MouseResult::Ignored
743                }
744            }
745            MouseEventKind::ScrollUp => {
746                self.scroll_up(3);
747                MouseResult::Scrolled
748            }
749            MouseEventKind::ScrollDown => {
750                self.scroll_down(3, row_count);
751                MouseResult::Scrolled
752            }
753            _ => MouseResult::Ignored,
754        }
755    }
756
757    /// Scroll the table up by the given number of rows.
758    pub fn scroll_up(&mut self, rows: usize) {
759        self.offset = self.offset.saturating_sub(rows);
760    }
761
762    /// Scroll the table down by the given number of rows.
763    ///
764    /// Clamps so that the last row can still appear at the top of the viewport.
765    pub fn scroll_down(&mut self, rows: usize, row_count: usize) {
766        self.offset = self
767            .offset
768            .saturating_add(rows)
769            .min(row_count.saturating_sub(1));
770    }
771}
772
773impl<'a> StatefulWidget for Table<'a> {
774    type State = TableState;
775
776    fn render(&self, area: Rect, frame: &mut Frame, state: &mut Self::State) {
777        #[cfg(feature = "tracing")]
778        let _widget_span = tracing::debug_span!(
779            "widget_render",
780            widget = "Table",
781            x = area.x,
782            y = area.y,
783            w = area.width,
784            h = area.height
785        )
786        .entered();
787
788        if area.is_empty() {
789            return;
790        }
791
792        // After the emptiness check: nothing is drawn for an empty area, so a
793        // node for it describes a widget that was never on screen, and every
794        // such node collides on the id of the same empty rect
795        // (bd-a11y-sibling-id-collision-6zqd2).
796        if frame.a11y_enabled() {
797            frame.push_a11y_nodes(ftui_a11y::Accessible::accessibility_nodes(self, area));
798        }
799
800        let apply_styling = frame.degradation.apply_styling();
801        let theme = &self.theme;
802        let effects_enabled = apply_styling && !theme.effects.is_empty();
803        let has_column_effects = effects_enabled && theme_has_column_effects(theme);
804        let effect_resolver = theme.effect_resolver();
805        let effects = if effects_enabled {
806            Some((&effect_resolver, self.theme_phase))
807        } else {
808            None
809        };
810
811        // Render block if present
812        let table_area = match &self.block {
813            Some(b) => {
814                let mut block = b.clone();
815                if apply_styling {
816                    block = block.border_style(theme.border);
817                }
818                crate::render_block_without_a11y(&block, area, frame);
819                block.inner(area)
820            }
821            None => area,
822        };
823
824        if table_area.is_empty() {
825            return;
826        }
827
828        // Push scissor to prevent rows from spilling out of the table area.
829        // This is critical for rows with height > 1 that are partially visible at the bottom.
830        frame.buffer.push_scissor(table_area);
831
832        // Clear the full owned viewport up front so empty tables, shorter rows,
833        // and shorter headers cannot leak prior buffer content.
834        let fill_style = if apply_styling {
835            self.style.merge(&theme.row)
836        } else {
837            Style::default()
838        };
839        clear_text_area(frame, table_area, fill_style);
840
841        let header_height = self
842            .header
843            .as_ref()
844            .map(|h| h.height.saturating_add(h.bottom_margin))
845            .unwrap_or(0);
846
847        if header_height > table_area.height {
848            frame.buffer.pop_scissor();
849            return;
850        }
851
852        // Calculate column widths
853        let flex = Flex::horizontal()
854            .constraints(self.widths.clone())
855            .gap(self.column_spacing);
856
857        let intrinsic_col_widths = if Self::requires_measurement(&self.widths) {
858            if let Some(hash) = self.data_hash {
859                if let Some((cached_hash, ref widths)) = state.cached_intrinsic_widths
860                    && cached_hash == hash
861                    && widths.len() == self.widths.len()
862                {
863                    widths.clone()
864                } else {
865                    let widths: std::sync::Arc<[u16]> =
866                        Self::compute_intrinsic_widths(&self.rows, None, self.widths.len()).into();
867                    state.cached_intrinsic_widths = Some((hash, widths.clone()));
868                    widths
869                }
870            } else {
871                Self::compute_intrinsic_widths(&self.rows, None, self.widths.len()).into()
872            }
873        } else {
874            std::sync::Arc::new([])
875        };
876
877        // Solve column widths across table area
878        let column_rects = flex.split_with_measurer_stably(
879            Rect::new(table_area.x, table_area.y, table_area.width, 1),
880            |idx, _| {
881                let row_width = intrinsic_col_widths.get(idx).copied().unwrap_or(0);
882                let header_width = self
883                    .header
884                    .as_ref()
885                    .and_then(|h| h.cells.get(idx))
886                    .map(|c| c.width().min(u16::MAX as usize) as u16)
887                    .unwrap_or(0);
888                ftui_layout::LayoutSizeHint::exact(row_width.max(header_width))
889            },
890            &mut state.coherence,
891        );
892
893        // Viewport geometry for rows (below the header).
894        let rows_height = table_area.height.saturating_sub(header_height);
895        let rows_top = table_area.y.saturating_add(header_height);
896        let rows_max_y = table_area.bottom();
897
898        // Calculate display indices (filtered & sorted)
899        let display_indices = self.filtered_and_sorted_indices(state);
900        let row_count = display_indices.len();
901
902        // Clamp offset to valid range
903        if row_count == 0 {
904            state.offset = 0;
905        } else {
906            state.offset = state.offset.min(row_count.saturating_sub(1));
907
908            // If we're scrolled near the end and the viewport grows, keep the bottom
909            // visible and pull the offset back to fill the viewport with as much
910            // context as fits (avoids rendering a mostly-empty table).
911            let available_height = rows_height;
912            let mut accumulated = 0u16;
913            let mut bottom_offset = row_count.saturating_sub(1);
914            for i in (0..row_count).rev() {
915                let row = &self.rows[display_indices[i]];
916                let eff_h =
917                    effective_row_height(row, &column_rects, &self.column_specs, theme.row_height);
918                let total_row_height = if i == row_count - 1 {
919                    eff_h
920                } else {
921                    eff_h.saturating_add(row.bottom_margin)
922                };
923
924                if total_row_height > available_height.saturating_sub(accumulated) {
925                    break;
926                }
927
928                accumulated = accumulated.saturating_add(total_row_height);
929                bottom_offset = i;
930            }
931
932            state.offset = state.offset.min(bottom_offset);
933        }
934
935        // Ensure selection is valid and present in current filtered view
936        if let Some(selected) = state.selected {
937            if display_indices.is_empty() {
938                state.selected = None;
939            } else if !display_indices.contains(&selected) {
940                state.selected = display_indices.first().copied();
941            }
942        }
943
944        // Ensure visible range includes selected item
945        if let Some(selected) = state.selected
946            && let Some(selected_display_idx) =
947                display_indices.iter().position(|&idx| idx == selected)
948        {
949            if selected_display_idx < state.offset {
950                state.offset = selected_display_idx;
951            } else {
952                // Check if selected is visible; if not, scroll down
953                let mut current_y = rows_top;
954                let max_y = rows_max_y;
955                let mut last_visible = state.offset;
956
957                for (i, &row_idx) in display_indices.iter().enumerate().skip(state.offset) {
958                    let row = &self.rows[row_idx];
959                    let eff_h = effective_row_height(
960                        row,
961                        &column_rects,
962                        &self.column_specs,
963                        theme.row_height,
964                    );
965                    if eff_h > max_y.saturating_sub(current_y) {
966                        break;
967                    }
968                    current_y = current_y
969                        .saturating_add(eff_h)
970                        .saturating_add(row.bottom_margin);
971                    last_visible = i;
972                }
973
974                if selected_display_idx > last_visible {
975                    let mut new_offset = selected_display_idx;
976                    let mut accumulated_height: u16 = 0;
977                    let available_height = rows_height;
978
979                    for i in (0..=selected_display_idx).rev() {
980                        let row = &self.rows[display_indices[i]];
981                        let eff_h = effective_row_height(
982                            row,
983                            &column_rects,
984                            &self.column_specs,
985                            theme.row_height,
986                        );
987                        let total_row_height = if i == selected_display_idx {
988                            eff_h
989                        } else {
990                            eff_h.saturating_add(row.bottom_margin)
991                        };
992
993                        if total_row_height > available_height.saturating_sub(accumulated_height) {
994                            if i == selected_display_idx {
995                                new_offset = selected_display_idx;
996                            } else {
997                                new_offset = i + 1;
998                            }
999                            break;
1000                        }
1001
1002                        accumulated_height = accumulated_height.saturating_add(total_row_height);
1003                        new_offset = i;
1004                    }
1005                    state.offset = new_offset;
1006                }
1007            }
1008        }
1009
1010        #[cfg(feature = "tracing")]
1011        let table_span = tracing::debug_span!(
1012            "table.render",
1013            total_rows = self.rows.len(),
1014            visible_rows = row_count,
1015            offset = state.offset,
1016            viewport_height = rows_height,
1017            rendered_rows = tracing::field::Empty,
1018        );
1019        #[cfg(feature = "tracing")]
1020        let _table_span_guard = table_span.clone().entered();
1021
1022        let mut y = table_area.y;
1023        let max_y = table_area.bottom();
1024        let divider_char = divider_char(self.block.as_ref());
1025
1026        // Render header
1027        if let Some(header) = &self.header {
1028            if y >= max_y {
1029                frame.buffer.pop_scissor();
1030                return;
1031            }
1032            let row_area = Rect::new(table_area.x, y, table_area.width, header.height);
1033            // Include bottom margin for dividers to avoid gaps
1034            let divider_area = Rect::new(
1035                table_area.x,
1036                y,
1037                table_area.width,
1038                header.height.saturating_add(header.bottom_margin),
1039            );
1040
1041            let header_style = if apply_styling {
1042                let mut style = self.style;
1043                style = theme.header.merge(&style);
1044                header.style.merge(&style)
1045            } else {
1046                Style::default()
1047            };
1048
1049            clear_text_area(frame, row_area, header_style);
1050
1051            if apply_styling && let Some((resolver, phase)) = effects {
1052                for (col_idx, rect) in column_rects.iter().enumerate() {
1053                    let cell_area = Rect::new(rect.x, y, rect.width, header.height);
1054                    let scope = TableEffectScope {
1055                        section: TableSection::Header,
1056                        row: None,
1057                        column: Some(col_idx),
1058                    };
1059                    let style = resolver.resolve(header_style, scope, phase);
1060                    set_style_area(&mut frame.buffer, cell_area, style);
1061                }
1062            }
1063
1064            let divider_style = if apply_styling {
1065                theme.divider.merge(&header_style)
1066            } else {
1067                Style::default()
1068            };
1069            draw_vertical_dividers(
1070                &mut frame.buffer,
1071                divider_area,
1072                &column_rects,
1073                divider_char,
1074                divider_style,
1075            );
1076
1077            render_row(
1078                header,
1079                &column_rects,
1080                frame,
1081                y,
1082                header_style,
1083                TableSection::Header,
1084                None,
1085                effects,
1086                effects.is_some(),
1087                &self.column_specs,
1088                header.height,
1089                theme.preset_id,
1090            );
1091
1092            // Draw sort indicator
1093            if let Some(col) = state.sort_column
1094                && col < column_rects.len()
1095            {
1096                let rect = column_rects[col];
1097                let symbol = if state.sort_ascending { "▲" } else { "▼" };
1098                // Draw at end of cell
1099                let x = rect.right().saturating_sub(1);
1100                if x >= rect.x {
1101                    crate::draw_text_span(frame, x, y, symbol, header_style, rect.right());
1102                }
1103            }
1104
1105            y = y
1106                .saturating_add(header.height)
1107                .saturating_add(header.bottom_margin);
1108        }
1109
1110        // Render rows
1111        if row_count == 0 {
1112            #[cfg(feature = "tracing")]
1113            table_span.record("rendered_rows", 0_u64);
1114            frame.buffer.pop_scissor();
1115            return;
1116        }
1117
1118        let mut rendered_rows = 0usize;
1119        for (i, &row_idx) in display_indices.iter().enumerate().skip(state.offset) {
1120            if y >= max_y {
1121                break;
1122            }
1123
1124            let row = &self.rows[row_idx];
1125            let eff_height =
1126                effective_row_height(row, &column_rects, &self.column_specs, theme.row_height);
1127            let is_selected = state.selected == Some(row_idx);
1128            let is_hovered = state.hovered == Some(row_idx);
1129            let row_area = Rect::new(table_area.x, y, table_area.width, eff_height);
1130            // Include bottom margin for dividers
1131            let divider_area = Rect::new(
1132                table_area.x,
1133                y,
1134                table_area.width,
1135                eff_height.saturating_add(row.bottom_margin),
1136            );
1137
1138            let row_style = if apply_styling {
1139                // 1. Base: Table style
1140                let mut style = self.style;
1141                // 2. Theme Stripe
1142                let stripe = if theme.stripe_period > 0
1143                    && (i % (theme.stripe_period as usize)) == (theme.stripe_period as usize - 1)
1144                {
1145                    theme.row_alt
1146                } else {
1147                    theme.row
1148                };
1149                style = stripe.merge(&style);
1150                // 3. Row Specific
1151                style = row.style.merge(&style);
1152                // 4. Theme Hover
1153                if is_hovered {
1154                    style = theme.row_hover.merge(&style);
1155                }
1156                // 5. Theme Selection
1157                if is_selected {
1158                    style = theme.row_selected.merge(&style);
1159                }
1160                // 6. Manual Highlight
1161                if is_selected {
1162                    style = self.highlight_style.merge(&style);
1163                }
1164                style
1165            } else {
1166                Style::default()
1167            };
1168
1169            clear_text_area(frame, row_area, row_style);
1170
1171            if apply_styling && let Some((resolver, phase)) = effects {
1172                if has_column_effects {
1173                    for (col_idx, rect) in column_rects.iter().enumerate() {
1174                        let cell_area = Rect::new(rect.x, y, rect.width, eff_height);
1175                        let scope = TableEffectScope {
1176                            section: TableSection::Body,
1177                            row: Some(i),
1178                            column: Some(col_idx),
1179                        };
1180                        let style = resolver.resolve(row_style, scope, phase);
1181                        set_style_area(&mut frame.buffer, cell_area, style);
1182                    }
1183                } else {
1184                    let scope = TableEffectScope::row(TableSection::Body, i);
1185                    let style = resolver.resolve(row_style, scope, phase);
1186                    set_style_area(&mut frame.buffer, row_area, style);
1187                }
1188            }
1189
1190            let divider_style = if apply_styling {
1191                theme.divider.merge(&row_style)
1192            } else {
1193                Style::default()
1194            };
1195            draw_vertical_dividers(
1196                &mut frame.buffer,
1197                divider_area,
1198                &column_rects,
1199                divider_char,
1200                divider_style,
1201            );
1202
1203            render_row(
1204                row,
1205                &column_rects,
1206                frame,
1207                y,
1208                row_style,
1209                TableSection::Body,
1210                Some(i),
1211                effects,
1212                has_column_effects,
1213                &self.column_specs,
1214                eff_height,
1215                theme.preset_id,
1216            );
1217
1218            // Register hit region for this row (if hit testing enabled)
1219            if let Some(id) = self.hit_id {
1220                // Register the original row_idx so click handlers know the actual data item
1221                frame.register_hit(row_area, id, HitRegion::Content, row_idx as u64);
1222            }
1223
1224            rendered_rows = rendered_rows.saturating_add(1);
1225            y = y
1226                .saturating_add(eff_height)
1227                .saturating_add(row.bottom_margin);
1228        }
1229
1230        #[cfg(feature = "tracing")]
1231        table_span.record("rendered_rows", rendered_rows as u64);
1232        frame.buffer.pop_scissor();
1233    }
1234}
1235
1236/// Compute effective row height taking into account any wrapped columns,
1237/// capped at `theme_row_height` (or `row.height` if already larger).
1238fn effective_row_height(
1239    row: &Row,
1240    col_rects: &[Rect],
1241    column_specs: &[ColumnSpec],
1242    theme_row_height: u8,
1243) -> u16 {
1244    let mut h = row.height;
1245    for (col_idx, cell) in row.cells.iter().enumerate() {
1246        let spec = column_specs.get(col_idx).copied().unwrap_or_default();
1247        if spec.truncation == Truncate::Wrap && col_idx < col_rects.len() {
1248            let col_w = col_rects[col_idx].width as usize;
1249            if col_w > 0 {
1250                let mut cell_lines = 0usize;
1251                for line in cell.lines() {
1252                    let wrapped = line.wrap(col_w, ftui_text::WrapMode::WordChar);
1253                    cell_lines = cell_lines.saturating_add(wrapped.len().max(1));
1254                }
1255                h = h.max(cell_lines as u16);
1256            }
1257        }
1258    }
1259    let max_h = (theme_row_height as u16).max(row.height);
1260    h.min(max_h)
1261}
1262
1263#[allow(clippy::too_many_arguments)]
1264fn render_row(
1265    row: &Row,
1266    col_rects: &[Rect],
1267    frame: &mut Frame,
1268    y: u16,
1269    base_style: Style,
1270    section: TableSection,
1271    row_idx: Option<usize>,
1272    effects: Option<(&TableEffectResolver<'_>, f32)>,
1273    column_effects: bool,
1274    column_specs: &[ColumnSpec],
1275    rendered_height: u16,
1276    preset_id: Option<TablePresetId>,
1277) {
1278    let apply_styling = frame.degradation.apply_styling();
1279    let row_effect_base = if apply_styling {
1280        if let Some((resolver, phase)) = effects {
1281            if !column_effects {
1282                let scope = TableEffectScope {
1283                    section,
1284                    row: row_idx,
1285                    column: None,
1286                };
1287                Some(resolver.resolve(base_style, scope, phase))
1288            } else {
1289                None
1290            }
1291        } else {
1292            None
1293        }
1294    } else {
1295        None
1296    };
1297
1298    let is_ascii_theme = preset_id == Some(TablePresetId::TerminalClassic);
1299    let (ellipsis_str, ellipsis_width) = if is_ascii_theme {
1300        ("...", 3)
1301    } else {
1302        ("…", 1)
1303    };
1304
1305    for (col_idx, cell_text) in row.cells.iter().enumerate() {
1306        if col_idx >= col_rects.len() {
1307            break;
1308        }
1309        let rect = col_rects[col_idx];
1310        let cell_area = Rect::new(rect.x, y, rect.width, rendered_height);
1311        if cell_area.width == 0 {
1312            continue;
1313        }
1314        let scope = if effects.is_some() {
1315            Some(TableEffectScope {
1316                section,
1317                row: row_idx,
1318                column: if column_effects { Some(col_idx) } else { None },
1319            })
1320        } else {
1321            None
1322        };
1323        let column_effect_base = if apply_styling && column_effects {
1324            if let (Some((resolver, phase)), Some(scope)) = (effects, scope) {
1325                Some(resolver.resolve(base_style, scope, phase))
1326            } else {
1327                None
1328            }
1329        } else {
1330            None
1331        };
1332
1333        let spec = column_specs.get(col_idx).copied().unwrap_or_default();
1334        let max_w = cell_area.width as usize;
1335
1336        let lines_to_render: Vec<Line<'static>> = match spec.truncation {
1337            Truncate::Wrap => {
1338                let mut out_lines = Vec::new();
1339                for line in cell_text.lines() {
1340                    let wrapped = line.wrap(max_w, ftui_text::WrapMode::WordChar);
1341                    if wrapped.is_empty() {
1342                        out_lines.push(Line::new());
1343                    } else {
1344                        out_lines.extend(wrapped);
1345                    }
1346                }
1347                out_lines
1348            }
1349            Truncate::Ellipsis => cell_text
1350                .lines()
1351                .iter()
1352                .map(|line| {
1353                    let line_width = line
1354                        .spans()
1355                        .iter()
1356                        .map(|s| ftui_core::text_width::display_width(&s.content))
1357                        .sum::<usize>();
1358                    if line_width <= max_w {
1359                        line.clone()
1360                    } else if max_w <= ellipsis_width {
1361                        let s = if is_ascii_theme {
1362                            &ellipsis_str[..max_w.min(ellipsis_str.len())]
1363                        } else if max_w >= 1 {
1364                            "…"
1365                        } else {
1366                            ""
1367                        };
1368                        Line::from_spans([Span::raw(s.to_string())])
1369                    } else {
1370                        let budget = max_w - ellipsis_width;
1371                        let mut truncated_spans = Vec::new();
1372                        let mut used = 0usize;
1373                        let mut hit_limit = false;
1374                        for span in line.spans() {
1375                            let mut span_text = String::new();
1376                            for g in unicode_segmentation::UnicodeSegmentation::graphemes(
1377                                span.content.as_ref(),
1378                                true,
1379                            ) {
1380                                let gw = ftui_core::text_width::grapheme_width(g);
1381                                if gw == 0 {
1382                                    span_text.push_str(g);
1383                                    continue;
1384                                }
1385                                if used + gw > budget {
1386                                    hit_limit = true;
1387                                    break;
1388                                }
1389                                span_text.push_str(g);
1390                                used += gw;
1391                            }
1392                            if !span_text.is_empty() {
1393                                let mut s = Span::styled(span_text, span.style.unwrap_or_default());
1394                                s.link = span.link.clone();
1395                                truncated_spans.push(s);
1396                            }
1397                            if hit_limit {
1398                                break;
1399                            }
1400                        }
1401                        let last_style = truncated_spans
1402                            .last()
1403                            .and_then(|s| s.style)
1404                            .unwrap_or(base_style);
1405                        truncated_spans.push(Span::styled(ellipsis_str.to_string(), last_style));
1406                        Line::from_spans(truncated_spans)
1407                    }
1408                })
1409                .collect(),
1410            Truncate::Clip => cell_text.lines().to_vec(),
1411        };
1412
1413        for (line_idx, line) in lines_to_render
1414            .into_iter()
1415            .take(rendered_height as usize)
1416            .enumerate()
1417        {
1418            let line_width = line
1419                .spans()
1420                .iter()
1421                .map(|s| ftui_core::text_width::display_width(&s.content))
1422                .sum::<usize>();
1423
1424            let left_offset = match spec.alignment {
1425                Alignment::Left => 0,
1426                Alignment::Center => (cell_area.width as usize).saturating_sub(line_width) / 2,
1427                Alignment::Right => (cell_area.width as usize).saturating_sub(line_width),
1428            };
1429
1430            let mut x = cell_area.x.saturating_add(left_offset as u16);
1431            let line_y = cell_area.y.saturating_add(line_idx as u16);
1432
1433            for span in line.spans() {
1434                let mut span_style = if apply_styling {
1435                    match span.style {
1436                        Some(s) => s.merge(&base_style),
1437                        None => base_style,
1438                    }
1439                } else {
1440                    Style::default()
1441                };
1442
1443                if let (Some((resolver, phase)), Some(scope)) = (effects, scope) {
1444                    if span.style.is_none() {
1445                        if let Some(base_effect) = column_effect_base.or(row_effect_base) {
1446                            span_style = base_effect;
1447                        } else {
1448                            span_style = resolver.resolve(span_style, scope, phase);
1449                        }
1450                    } else {
1451                        span_style = resolver.resolve(span_style, scope, phase);
1452                    }
1453                }
1454
1455                x = crate::draw_text_span_with_link(
1456                    frame,
1457                    x,
1458                    line_y,
1459                    &span.content,
1460                    span_style,
1461                    cell_area.right(),
1462                    span.link.as_deref(),
1463                );
1464                if x >= cell_area.right() {
1465                    break;
1466                }
1467            }
1468        }
1469    }
1470}
1471
1472fn theme_has_column_effects(theme: &TableTheme) -> bool {
1473    theme.effects.iter().any(|rule| {
1474        matches!(
1475            rule.target,
1476            TableEffectTarget::Column(_) | TableEffectTarget::ColumnRange { .. }
1477        )
1478    })
1479}
1480
1481fn divider_char(block: Option<&Block<'_>>) -> char {
1482    block
1483        .map(|b| b.border_set().vertical)
1484        .unwrap_or(crate::borders::BorderSet::SQUARE.vertical)
1485}
1486
1487fn draw_vertical_dividers(
1488    buf: &mut Buffer,
1489    row_area: Rect,
1490    col_rects: &[Rect],
1491    divider_char: char,
1492    style: Style,
1493) {
1494    if col_rects.len() < 2 || row_area.is_empty() {
1495        return;
1496    }
1497
1498    for pair in col_rects.windows(2) {
1499        let left = pair[0];
1500        let right = pair[1];
1501        let gap = right.x.saturating_sub(left.right());
1502        if gap == 0 {
1503            continue;
1504        }
1505        let x = left.right();
1506        if x >= row_area.right() {
1507            continue;
1508        }
1509        let mut cell = Cell::from_char(divider_char);
1510        apply_style(&mut cell, style);
1511        for y in row_area.y..row_area.bottom() {
1512            buf.set_fast(x, y, cell);
1513        }
1514    }
1515}
1516
1517impl MeasurableWidget for Table<'_> {
1518    fn measure(&self, _available: Size) -> SizeConstraints {
1519        if self.rows.is_empty() && self.header.is_none() {
1520            return SizeConstraints::ZERO;
1521        }
1522
1523        let col_count = self.widths.len();
1524        if col_count == 0 {
1525            return SizeConstraints::ZERO;
1526        }
1527
1528        let row_widths = Self::compute_intrinsic_widths(&self.rows, None, col_count);
1529
1530        // Total width = sum of max(row_width, header_width) + column spacing
1531        let separator_width = if col_count > 1 {
1532            ((col_count - 1) as u16).saturating_mul(self.column_spacing)
1533        } else {
1534            0
1535        };
1536
1537        let mut summed_col_width = 0u16;
1538        for (i, &r_w) in row_widths.iter().enumerate() {
1539            let h_w = self
1540                .header
1541                .as_ref()
1542                .and_then(|h| h.cells.get(i))
1543                .map(|c| c.width().min(u16::MAX as usize) as u16)
1544                .unwrap_or(0);
1545            summed_col_width = summed_col_width.saturating_add(r_w.max(h_w));
1546        }
1547
1548        let content_width = summed_col_width.saturating_add(separator_width);
1549
1550        // Total height = header height + row heights + margins
1551        // Use saturating arithmetic to prevent overflow with many rows
1552        let header_height = self
1553            .header
1554            .as_ref()
1555            .map(|h| h.height.saturating_add(h.bottom_margin))
1556            .unwrap_or(0);
1557
1558        let rows_height: u16 = self.rows.iter().fold(0u16, |acc, r| {
1559            acc.saturating_add(r.height.saturating_add(r.bottom_margin))
1560        });
1561
1562        let content_height = header_height.saturating_add(rows_height);
1563
1564        // Add block overhead if present
1565        let (block_width, block_height) = self
1566            .block
1567            .as_ref()
1568            .map(|b| {
1569                let inner = b.inner(Rect::new(0, 0, 100, 100));
1570                let w_overhead = 100u16.saturating_sub(inner.width);
1571                let h_overhead = 100u16.saturating_sub(inner.height);
1572                (w_overhead, h_overhead)
1573            })
1574            .unwrap_or((0, 0));
1575
1576        let total_width = content_width.saturating_add(block_width);
1577        let total_height = content_height.saturating_add(block_height);
1578
1579        SizeConstraints {
1580            min: Size::new(
1581                (col_count as u16).saturating_add(block_width),
1582                header_height.max(1).saturating_add(block_height),
1583            ),
1584            preferred: Size::new(total_width, total_height),
1585            max: Some(Size::new(total_width, total_height)), // Fixed content size
1586        }
1587    }
1588
1589    fn has_intrinsic_size(&self) -> bool {
1590        !self.rows.is_empty() || self.header.is_some()
1591    }
1592}
1593
1594#[cfg(test)]
1595mod tests {
1596    use super::*;
1597    use ftui_render::buffer::Buffer;
1598    use ftui_render::cell::PackedRgba;
1599    use ftui_render::grapheme_pool::GraphemePool;
1600    use ftui_text::{Line, Span};
1601    #[cfg(feature = "tracing")]
1602    use std::sync::{Arc, Mutex};
1603    #[cfg(feature = "tracing")]
1604    use tracing::Subscriber;
1605    #[cfg(feature = "tracing")]
1606    use tracing_subscriber::Layer;
1607    #[cfg(feature = "tracing")]
1608    use tracing_subscriber::layer::{Context, SubscriberExt};
1609
1610    fn cell_char(buf: &Buffer, x: u16, y: u16) -> Option<char> {
1611        buf.get(x, y).and_then(|c| c.content.as_char())
1612    }
1613
1614    fn cell_fg(buf: &Buffer, x: u16, y: u16) -> Option<PackedRgba> {
1615        buf.get(x, y).map(|c| c.fg)
1616    }
1617
1618    fn row_text(buf: &Buffer, y: u16) -> String {
1619        let width = buf.width();
1620        let mut actual = String::new();
1621        for x in 0..width {
1622            let ch = buf
1623                .get(x, y)
1624                .and_then(|cell| cell.content.as_char())
1625                .unwrap_or(' ');
1626            actual.push(ch);
1627        }
1628        actual.trim().to_string()
1629    }
1630
1631    fn raw_row_text(buf: &Buffer, y: u16) -> String {
1632        let width = buf.width();
1633        let mut actual = String::new();
1634        for x in 0..width {
1635            let ch = buf
1636                .get(x, y)
1637                .and_then(|cell| cell.content.as_char())
1638                .unwrap_or(' ');
1639            actual.push(ch);
1640        }
1641        actual
1642    }
1643
1644    #[cfg(feature = "tracing")]
1645    #[derive(Debug, Default)]
1646    struct TableTraceState {
1647        span_count: usize,
1648        has_total_rows_field: bool,
1649        has_rendered_rows_field: bool,
1650        total_rows: Vec<u64>,
1651        rendered_rows: Vec<u64>,
1652    }
1653
1654    #[cfg(feature = "tracing")]
1655    struct TableTraceCapture {
1656        state: Arc<Mutex<TableTraceState>>,
1657    }
1658
1659    #[cfg(feature = "tracing")]
1660    #[derive(Default)]
1661    struct TableRenderVisitor {
1662        total_rows: Option<u64>,
1663        rendered_rows: Option<u64>,
1664    }
1665
1666    #[cfg(feature = "tracing")]
1667    impl tracing::field::Visit for TableRenderVisitor {
1668        fn record_u64(&mut self, field: &tracing::field::Field, value: u64) {
1669            match field.name() {
1670                "total_rows" => self.total_rows = Some(value),
1671                "rendered_rows" => self.rendered_rows = Some(value),
1672                _ => {}
1673            }
1674        }
1675
1676        fn record_i64(&mut self, field: &tracing::field::Field, value: i64) {
1677            if let Ok(value) = u64::try_from(value) {
1678                self.record_u64(field, value);
1679            }
1680        }
1681
1682        fn record_debug(&mut self, field: &tracing::field::Field, value: &dyn std::fmt::Debug) {
1683            let value = format!("{value:?}");
1684            if let Ok(parsed) = value.parse::<u64>() {
1685                self.record_u64(field, parsed);
1686            }
1687        }
1688    }
1689
1690    #[cfg(feature = "tracing")]
1691    impl<S> Layer<S> for TableTraceCapture
1692    where
1693        S: Subscriber + for<'lookup> tracing_subscriber::registry::LookupSpan<'lookup>,
1694    {
1695        fn on_new_span(
1696            &self,
1697            attrs: &tracing::span::Attributes<'_>,
1698            _id: &tracing::Id,
1699            _ctx: Context<'_, S>,
1700        ) {
1701            if attrs.metadata().name() != "table.render" {
1702                return;
1703            }
1704
1705            let mut visitor = TableRenderVisitor::default();
1706            attrs.record(&mut visitor);
1707            let fields = attrs.metadata().fields();
1708
1709            let mut state = self.state.lock().expect("table trace state lock");
1710            state.span_count += 1;
1711            state.has_total_rows_field |= fields.field("total_rows").is_some();
1712            state.has_rendered_rows_field |= fields.field("rendered_rows").is_some();
1713            if let Some(total_rows) = visitor.total_rows {
1714                state.total_rows.push(total_rows);
1715            }
1716            if let Some(rendered_rows) = visitor.rendered_rows {
1717                state.rendered_rows.push(rendered_rows);
1718            }
1719        }
1720
1721        fn on_record(
1722            &self,
1723            id: &tracing::Id,
1724            values: &tracing::span::Record<'_>,
1725            ctx: Context<'_, S>,
1726        ) {
1727            let Some(span_ref) = ctx.span(id) else {
1728                return;
1729            };
1730            if span_ref.metadata().name() != "table.render" {
1731                return;
1732            }
1733
1734            let mut visitor = TableRenderVisitor::default();
1735            values.record(&mut visitor);
1736
1737            let mut state = self.state.lock().expect("table trace state lock");
1738            if let Some(total_rows) = visitor.total_rows {
1739                state.total_rows.push(total_rows);
1740            }
1741            if let Some(rendered_rows) = visitor.rendered_rows {
1742                state.rendered_rows.push(rendered_rows);
1743            }
1744        }
1745    }
1746
1747    // --- Row builder tests ---
1748
1749    #[test]
1750    fn row_new_from_strings() {
1751        let row = Row::new(["A", "B", "C"]);
1752        assert_eq!(row.cells.len(), 3);
1753        assert_eq!(row.height, 1);
1754        assert_eq!(row.bottom_margin, 0);
1755    }
1756
1757    #[test]
1758    fn row_builder_methods() {
1759        let row = Row::new(["X"])
1760            .height(3)
1761            .bottom_margin(1)
1762            .style(Style::new().bold());
1763        assert_eq!(row.height, 3);
1764        assert_eq!(row.bottom_margin, 1);
1765        assert!(row.style.has_attr(ftui_style::StyleFlags::BOLD));
1766    }
1767
1768    #[test]
1769    fn row_height_zero_clamps_to_one() {
1770        let row = Row::new(["X"]).height(0);
1771        assert_eq!(row.height, 1);
1772    }
1773
1774    // --- TableState tests ---
1775
1776    #[test]
1777    fn table_state_default() {
1778        let state = TableState::default();
1779        assert_eq!(state.selected, None);
1780        assert_eq!(state.offset, 0);
1781    }
1782
1783    #[test]
1784    fn table_state_select() {
1785        let mut state = TableState::default();
1786        state.select(Some(5));
1787        assert_eq!(state.selected, Some(5));
1788        assert_eq!(state.offset, 0);
1789    }
1790
1791    #[test]
1792    fn table_state_deselect_preserves_offset() {
1793        let mut state = TableState {
1794            offset: 10,
1795            ..Default::default()
1796        };
1797        state.select(Some(3));
1798        assert_eq!(state.selected, Some(3));
1799        state.select(None);
1800        assert_eq!(state.selected, None);
1801        assert_eq!(state.offset, 10);
1802    }
1803
1804    #[test]
1805    fn table_state_scroll_down_is_overflow_safe() {
1806        // Ensure `scroll_down` cannot wrap on invalid persisted offsets.
1807        let mut state = TableState {
1808            offset: usize::MAX - 1,
1809            ..Default::default()
1810        };
1811        state.scroll_down(10, 100);
1812        assert_eq!(state.offset, 99);
1813    }
1814
1815    // --- Table rendering tests ---
1816
1817    #[test]
1818    fn render_zero_area() {
1819        let table = Table::new([Row::new(["A"])], [Constraint::Fixed(5)]);
1820        let area = Rect::new(0, 0, 0, 0);
1821        let mut pool = GraphemePool::new();
1822        let mut frame = Frame::new(1, 1, &mut pool);
1823        Widget::render(&table, area, &mut frame);
1824        // Should not panic
1825    }
1826
1827    #[test]
1828    fn render_empty_rows() {
1829        let table = Table::new(Vec::<Row>::new(), [Constraint::Fixed(5)]);
1830        let area = Rect::new(0, 0, 10, 5);
1831        let mut pool = GraphemePool::new();
1832        let mut frame = Frame::new(10, 5, &mut pool);
1833        Widget::render(&table, area, &mut frame);
1834        // Should not panic; no content rendered
1835    }
1836
1837    #[test]
1838    fn render_empty_rows_clears_stale_viewport() {
1839        let table = Table::new(Vec::<Row>::new(), [Constraint::Fixed(5)]);
1840        let area = Rect::new(0, 0, 10, 3);
1841        let mut pool = GraphemePool::new();
1842        let mut frame = Frame::new(10, 3, &mut pool);
1843        frame.buffer.fill(area, Cell::from_char('X'));
1844
1845        Widget::render(&table, area, &mut frame);
1846
1847        assert_eq!(raw_row_text(&frame.buffer, 0), "          ");
1848        assert_eq!(raw_row_text(&frame.buffer, 1), "          ");
1849        assert_eq!(raw_row_text(&frame.buffer, 2), "          ");
1850    }
1851
1852    #[test]
1853    fn render_single_row_single_column() {
1854        let table = Table::new([Row::new(["Hello"])], [Constraint::Fixed(10)]);
1855        let area = Rect::new(0, 0, 10, 3);
1856        let mut pool = GraphemePool::new();
1857        let mut frame = Frame::new(10, 3, &mut pool);
1858        Widget::render(&table, area, &mut frame);
1859
1860        assert_eq!(cell_char(&frame.buffer, 0, 0), Some('H'));
1861        assert_eq!(cell_char(&frame.buffer, 1, 0), Some('e'));
1862        assert_eq!(cell_char(&frame.buffer, 4, 0), Some('o'));
1863    }
1864
1865    #[test]
1866    fn render_shorter_cell_clears_stale_suffix() {
1867        let area = Rect::new(0, 0, 10, 1);
1868        let mut pool = GraphemePool::new();
1869        let mut frame = Frame::new(10, 1, &mut pool);
1870
1871        let long = Table::new([Row::new(["Hello"])], [Constraint::Fixed(10)]);
1872        Widget::render(&long, area, &mut frame);
1873
1874        let short = Table::new([Row::new(["Hi"])], [Constraint::Fixed(10)]);
1875        Widget::render(&short, area, &mut frame);
1876
1877        assert_eq!(raw_row_text(&frame.buffer, 0), "Hi        ");
1878    }
1879
1880    #[test]
1881    fn render_multiple_rows() {
1882        let table = Table::new(
1883            [Row::new(["AA", "BB"]), Row::new(["CC", "DD"])],
1884            [Constraint::Fixed(4), Constraint::Fixed(4)],
1885        );
1886        let area = Rect::new(0, 0, 10, 3);
1887        let mut pool = GraphemePool::new();
1888        let mut frame = Frame::new(10, 3, &mut pool);
1889        Widget::render(&table, area, &mut frame);
1890
1891        // First row
1892        assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
1893        // Second row
1894        assert_eq!(cell_char(&frame.buffer, 0, 1), Some('C'));
1895    }
1896
1897    #[test]
1898    fn render_with_header() {
1899        let header = Row::new(["Name", "Val"]);
1900        let table = Table::new(
1901            [Row::new(["foo", "42"])],
1902            [Constraint::Fixed(5), Constraint::Fixed(4)],
1903        )
1904        .header(header);
1905
1906        let area = Rect::new(0, 0, 10, 3);
1907        let mut pool = GraphemePool::new();
1908        let mut frame = Frame::new(10, 3, &mut pool);
1909        Widget::render(&table, area, &mut frame);
1910
1911        // Header on row 0
1912        assert_eq!(cell_char(&frame.buffer, 0, 0), Some('N'));
1913        // Data on row 1
1914        assert_eq!(cell_char(&frame.buffer, 0, 1), Some('f'));
1915    }
1916
1917    #[test]
1918    fn render_shorter_header_clears_stale_suffix() {
1919        let area = Rect::new(0, 0, 10, 2);
1920        let mut pool = GraphemePool::new();
1921        let mut frame = Frame::new(10, 2, &mut pool);
1922
1923        let long =
1924            Table::new([Row::new(["row"])], [Constraint::Fixed(10)]).header(Row::new(["Header"]));
1925        Widget::render(&long, area, &mut frame);
1926
1927        let short =
1928            Table::new([Row::new(["row"])], [Constraint::Fixed(10)]).header(Row::new(["H"]));
1929        Widget::render(&short, area, &mut frame);
1930
1931        assert_eq!(raw_row_text(&frame.buffer, 0), "H         ");
1932    }
1933
1934    #[test]
1935    fn zero_height_row_clamps_and_preserves_vertical_flow() {
1936        let table = Table::new(
1937            [Row::new(["A"]).height(0), Row::new(["B"])],
1938            [Constraint::Fixed(3)],
1939        );
1940        let area = Rect::new(0, 0, 3, 2);
1941        let mut pool = GraphemePool::new();
1942        let mut frame = Frame::new(3, 2, &mut pool);
1943        Widget::render(&table, area, &mut frame);
1944
1945        assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
1946        assert_eq!(cell_char(&frame.buffer, 0, 1), Some('B'));
1947    }
1948
1949    #[test]
1950    fn zero_height_header_clamps_to_one_and_offsets_rows() {
1951        let header = Row::new(["H"]).height(0);
1952        let table = Table::new([Row::new(["D"])], [Constraint::Fixed(3)]).header(header);
1953
1954        let area = Rect::new(0, 0, 3, 2);
1955        let mut pool = GraphemePool::new();
1956        let mut frame = Frame::new(3, 2, &mut pool);
1957        Widget::render(&table, area, &mut frame);
1958
1959        assert_eq!(cell_char(&frame.buffer, 0, 0), Some('H'));
1960        assert_eq!(cell_char(&frame.buffer, 0, 1), Some('D'));
1961    }
1962
1963    #[test]
1964    fn render_with_block() {
1965        let table = Table::new([Row::new(["X"])], [Constraint::Fixed(5)]).block(Block::bordered());
1966
1967        let area = Rect::new(0, 0, 10, 5);
1968        let mut pool = GraphemePool::new();
1969        let mut frame = Frame::new(10, 5, &mut pool);
1970        Widget::render(&table, area, &mut frame);
1971
1972        // Content should be inside the block border + padding
1973        assert_eq!(cell_char(&frame.buffer, 2, 2), Some('X'));
1974    }
1975
1976    #[test]
1977    fn stateful_render_with_selection() {
1978        let table = Table::new(
1979            [Row::new(["A"]), Row::new(["B"]), Row::new(["C"])],
1980            [Constraint::Fixed(5)],
1981        )
1982        .highlight_style(Style::new().bold());
1983
1984        let area = Rect::new(0, 0, 5, 3);
1985        let mut pool = GraphemePool::new();
1986        let mut frame = Frame::new(5, 3, &mut pool);
1987        let mut state = TableState::default();
1988        state.select(Some(1));
1989
1990        StatefulWidget::render(&table, area, &mut frame, &mut state);
1991        // Selected row should have the highlight style applied
1992        // Row 1 (index 1) should render "B"
1993        assert_eq!(cell_char(&frame.buffer, 0, 1), Some('B'));
1994    }
1995
1996    #[test]
1997    fn row_style_merge_precedence_and_span_override() {
1998        let base_fg = PackedRgba::rgb(10, 0, 0);
1999        let selected_fg = PackedRgba::rgb(20, 0, 0);
2000        let hovered_fg = PackedRgba::rgb(30, 0, 0);
2001        let table_fg = PackedRgba::rgb(40, 0, 0);
2002        let row_fg = PackedRgba::rgb(50, 0, 0);
2003        let highlight_fg = PackedRgba::rgb(60, 0, 0);
2004        let span_fg = PackedRgba::rgb(70, 0, 0);
2005
2006        let base_row = Style::new().fg(base_fg);
2007        let theme = TableTheme {
2008            row: base_row,
2009            row_alt: base_row,
2010            row_selected: Style::new().fg(selected_fg),
2011            row_hover: Style::new().fg(hovered_fg),
2012            ..Default::default()
2013        };
2014
2015        let text = Text::from_line(Line::from_spans([
2016            Span::raw("A"),
2017            Span::styled("B", Style::new().fg(span_fg)),
2018        ]));
2019
2020        let table = Table::new(
2021            [Row::new([text]).style(Style::new().fg(row_fg))],
2022            [Constraint::Fixed(2)],
2023        )
2024        .style(Style::new().fg(table_fg))
2025        .highlight_style(Style::new().fg(highlight_fg))
2026        .theme(theme);
2027
2028        let area = Rect::new(0, 0, 2, 1);
2029        let mut pool = GraphemePool::new();
2030        let mut frame = Frame::new(2, 1, &mut pool);
2031        let mut state = TableState {
2032            selected: Some(0),
2033            hovered: Some(0),
2034            ..Default::default()
2035        };
2036
2037        StatefulWidget::render(&table, area, &mut frame, &mut state);
2038
2039        assert_eq!(cell_fg(&frame.buffer, 0, 0), Some(highlight_fg));
2040        assert_eq!(cell_fg(&frame.buffer, 1, 0), Some(span_fg));
2041    }
2042
2043    #[test]
2044    fn selection_below_offset_adjusts_offset() {
2045        let mut state = TableState {
2046            offset: 5,
2047            selected: Some(2), // Selected is below offset
2048            persistence_id: None,
2049            ..Default::default()
2050        };
2051
2052        let table = Table::new(
2053            (0..10).map(|i| Row::new([format!("Row {i}")])),
2054            [Constraint::Fixed(10)],
2055        );
2056        let area = Rect::new(0, 0, 10, 3);
2057        let mut pool = GraphemePool::new();
2058        let mut frame = Frame::new(10, 3, &mut pool);
2059        StatefulWidget::render(&table, area, &mut frame, &mut state);
2060
2061        // Offset should have been adjusted down to selected
2062        assert_eq!(state.offset, 2);
2063    }
2064
2065    #[test]
2066    fn table_clamps_offset_to_fill_viewport_on_resize() {
2067        let rows: Vec<Row> = (0..10).map(|i| Row::new([format!("Row {i}")])).collect();
2068        let table = Table::new(rows, [Constraint::Min(10)]);
2069
2070        let mut pool = GraphemePool::new();
2071        let mut state = TableState {
2072            offset: 7,
2073            ..Default::default()
2074        };
2075
2076        // Small viewport: show 7, 8, 9.
2077        let area_small = Rect::new(0, 0, 10, 3);
2078        let mut frame_small = Frame::new(10, 3, &mut pool);
2079        StatefulWidget::render(&table, area_small, &mut frame_small, &mut state);
2080        assert_eq!(state.offset, 7);
2081        assert_eq!(row_text(&frame_small.buffer, 0), "Row 7");
2082        assert_eq!(row_text(&frame_small.buffer, 2), "Row 9");
2083
2084        // Larger viewport: offset should pull back to fill (5..9).
2085        let area_large = Rect::new(0, 0, 10, 5);
2086        let mut frame_large = Frame::new(10, 5, &mut pool);
2087        StatefulWidget::render(&table, area_large, &mut frame_large, &mut state);
2088        assert_eq!(state.offset, 5);
2089        assert_eq!(row_text(&frame_large.buffer, 0), "Row 5");
2090        assert_eq!(row_text(&frame_large.buffer, 4), "Row 9");
2091    }
2092
2093    #[test]
2094    fn table_clamps_offset_to_fill_viewport_with_variable_row_heights() {
2095        // Rows 0..8: height 1
2096        // Row 9: height 5
2097        // View height 10 should show rows 4..9 (with row 9 taking 5 lines).
2098        let mut rows: Vec<Row> = (0..9).map(|i| Row::new([format!("Row {i}")])).collect();
2099        rows.push(Row::new(["Row 9"]).height(5));
2100        let table = Table::new(rows, [Constraint::Min(10)]);
2101
2102        let mut pool = GraphemePool::new();
2103        let mut state = TableState {
2104            offset: 9,
2105            ..Default::default()
2106        };
2107
2108        let area = Rect::new(0, 0, 10, 10);
2109        let mut frame = Frame::new(10, 10, &mut pool);
2110        StatefulWidget::render(&table, area, &mut frame, &mut state);
2111
2112        assert_eq!(state.offset, 4);
2113        assert_eq!(row_text(&frame.buffer, 0), "Row 4");
2114    }
2115
2116    #[test]
2117    fn selection_invalid_index_falls_back_to_first_row() {
2118        let table = Table::new([Row::new(["A"]), Row::new(["B"])], [Constraint::Fixed(5)]);
2119        let area = Rect::new(0, 0, 5, 2);
2120        let mut pool = GraphemePool::new();
2121        let mut frame = Frame::new(5, 2, &mut pool);
2122        let mut state = TableState {
2123            offset: 0,
2124            selected: Some(99),
2125            persistence_id: None,
2126            ..Default::default()
2127        };
2128
2129        StatefulWidget::render(&table, area, &mut frame, &mut state);
2130        assert_eq!(state.selected, Some(0));
2131    }
2132
2133    #[test]
2134    fn selection_with_header_accounts_for_header_height() {
2135        let header = Row::new(["H"]);
2136        let table =
2137            Table::new([Row::new(["A"]), Row::new(["B"])], [Constraint::Fixed(5)]).header(header);
2138
2139        let area = Rect::new(0, 0, 5, 2);
2140        let mut pool = GraphemePool::new();
2141        let mut frame = Frame::new(5, 2, &mut pool);
2142        let mut state = TableState {
2143            offset: 0,
2144            selected: Some(1),
2145            persistence_id: None,
2146            ..Default::default()
2147        };
2148
2149        StatefulWidget::render(&table, area, &mut frame, &mut state);
2150        assert_eq!(state.offset, 1);
2151    }
2152
2153    #[test]
2154    fn rows_overflow_area_truncated() {
2155        let table = Table::new(
2156            (0..20).map(|i| Row::new([format!("R{i}")])),
2157            [Constraint::Fixed(5)],
2158        );
2159        let area = Rect::new(0, 0, 5, 3);
2160        let mut pool = GraphemePool::new();
2161        let mut frame = Frame::new(5, 3, &mut pool);
2162        Widget::render(&table, area, &mut frame);
2163
2164        // Only first 3 rows fit
2165        assert_eq!(cell_char(&frame.buffer, 0, 0), Some('R'));
2166        assert_eq!(cell_char(&frame.buffer, 1, 0), Some('0'));
2167        assert_eq!(cell_char(&frame.buffer, 1, 2), Some('2'));
2168    }
2169
2170    #[test]
2171    fn column_spacing_applied() {
2172        let table = Table::new(
2173            [Row::new(["A", "B"])],
2174            [Constraint::Fixed(3), Constraint::Fixed(3)],
2175        )
2176        .column_spacing(2);
2177
2178        let area = Rect::new(0, 0, 10, 1);
2179        let mut pool = GraphemePool::new();
2180        let mut frame = Frame::new(10, 1, &mut pool);
2181        Widget::render(&table, area, &mut frame);
2182
2183        // "A" starts at x=0, "B" starts at x=3+2=5 (column width + gap)
2184        assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
2185    }
2186
2187    #[test]
2188    fn divider_style_overrides_row_style() {
2189        let row_fg = PackedRgba::rgb(120, 10, 10);
2190        let divider_fg = PackedRgba::rgb(0, 200, 0);
2191        let row_style = Style::new().fg(row_fg);
2192        let theme = TableTheme {
2193            row: row_style,
2194            row_alt: row_style,
2195            divider: Style::new().fg(divider_fg),
2196            ..Default::default()
2197        };
2198
2199        let table = Table::new(
2200            [Row::new(["AA", "BB"])],
2201            [Constraint::Fixed(2), Constraint::Fixed(2)],
2202        )
2203        .theme(theme);
2204
2205        let area = Rect::new(0, 0, 5, 1);
2206        let mut pool = GraphemePool::new();
2207        let mut frame = Frame::new(5, 1, &mut pool);
2208        Widget::render(&table, area, &mut frame);
2209
2210        assert_eq!(cell_fg(&frame.buffer, 2, 0), Some(divider_fg));
2211    }
2212
2213    #[test]
2214    fn block_border_uses_theme_border_style() {
2215        let border_fg = PackedRgba::rgb(1, 2, 3);
2216        let theme = TableTheme {
2217            border: Style::new().fg(border_fg),
2218            ..Default::default()
2219        };
2220
2221        let table = Table::new([Row::new(["X"])], [Constraint::Fixed(1)])
2222            .block(Block::bordered())
2223            .theme(theme);
2224
2225        let area = Rect::new(0, 0, 3, 3);
2226        let mut pool = GraphemePool::new();
2227        let mut frame = Frame::new(3, 3, &mut pool);
2228        Widget::render(&table, area, &mut frame);
2229
2230        assert_eq!(cell_fg(&frame.buffer, 0, 0), Some(border_fg));
2231    }
2232
2233    #[test]
2234    fn render_clips_long_cell_to_column_width() {
2235        let table = Table::new([Row::new(["ABCDE"])], [Constraint::Fixed(3)]);
2236        let area = Rect::new(0, 0, 3, 1);
2237        let mut pool = GraphemePool::new();
2238        let mut frame = Frame::new(4, 1, &mut pool);
2239        Widget::render(&table, area, &mut frame);
2240
2241        assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
2242        assert_eq!(cell_char(&frame.buffer, 1, 0), Some('B'));
2243        assert_eq!(cell_char(&frame.buffer, 2, 0), Some('C'));
2244        assert_ne!(cell_char(&frame.buffer, 3, 0), Some('D'));
2245    }
2246
2247    #[test]
2248    fn render_multiline_cell_respects_row_height() {
2249        let table = Table::new([Row::new(["A\nB"]).height(1)], [Constraint::Fixed(3)]);
2250        let area = Rect::new(0, 0, 3, 2);
2251        let mut pool = GraphemePool::new();
2252        let mut frame = Frame::new(3, 2, &mut pool);
2253        Widget::render(&table, area, &mut frame);
2254
2255        assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
2256        assert_ne!(cell_char(&frame.buffer, 0, 1), Some('B'));
2257    }
2258
2259    #[test]
2260    fn render_multiline_cell_draws_second_line_when_height_allows() {
2261        let table = Table::new([Row::new(["A\nB"]).height(2)], [Constraint::Fixed(3)]);
2262        let area = Rect::new(0, 0, 3, 2);
2263        let mut pool = GraphemePool::new();
2264        let mut frame = Frame::new(3, 2, &mut pool);
2265        Widget::render(&table, area, &mut frame);
2266
2267        assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
2268        assert_eq!(cell_char(&frame.buffer, 0, 1), Some('B'));
2269    }
2270
2271    #[test]
2272    fn more_cells_than_columns_truncated() {
2273        let table = Table::new(
2274            [Row::new(["A", "B", "C", "D"])],
2275            [Constraint::Fixed(3), Constraint::Fixed(3)],
2276        );
2277        let area = Rect::new(0, 0, 8, 1);
2278        let mut pool = GraphemePool::new();
2279        let mut frame = Frame::new(8, 1, &mut pool);
2280        Widget::render(&table, area, &mut frame);
2281        // Should not panic; extra cells beyond column count are skipped
2282    }
2283
2284    #[test]
2285    fn header_too_tall_for_area() {
2286        let header = Row::new(["H"]).height(10);
2287        let table = Table::new([Row::new(["X"])], [Constraint::Fixed(5)]).header(header);
2288
2289        let area = Rect::new(0, 0, 5, 3);
2290        let mut pool = GraphemePool::new();
2291        let mut frame = Frame::new(5, 3, &mut pool);
2292        Widget::render(&table, area, &mut frame);
2293        // Header doesn't fit; should return early without rendering data
2294    }
2295
2296    #[test]
2297    fn row_with_bottom_margin() {
2298        let table = Table::new(
2299            [Row::new(["A"]).bottom_margin(1), Row::new(["B"])],
2300            [Constraint::Fixed(5)],
2301        );
2302        let area = Rect::new(0, 0, 5, 4);
2303        let mut pool = GraphemePool::new();
2304        let mut frame = Frame::new(5, 4, &mut pool);
2305        Widget::render(&table, area, &mut frame);
2306
2307        // Row "A" at y=0, margin leaves y=1 empty, row "B" at y=2
2308        assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
2309        assert_eq!(cell_char(&frame.buffer, 0, 2), Some('B'));
2310    }
2311
2312    #[test]
2313    fn table_registers_hit_regions() {
2314        let table = Table::new(
2315            [Row::new(["A"]), Row::new(["B"]), Row::new(["C"])],
2316            [Constraint::Fixed(5)],
2317        )
2318        .hit_id(HitId::new(99));
2319
2320        let area = Rect::new(0, 0, 5, 3);
2321        let mut pool = GraphemePool::new();
2322        let mut frame = Frame::with_hit_grid(5, 3, &mut pool);
2323        let mut state = TableState::default();
2324        StatefulWidget::render(&table, area, &mut frame, &mut state);
2325
2326        // Each row should have a hit region with the row index as data
2327        let hit0 = frame.hit_test(2, 0);
2328        let hit1 = frame.hit_test(2, 1);
2329        let hit2 = frame.hit_test(2, 2);
2330
2331        assert_eq!(hit0, Some((HitId::new(99), HitRegion::Content, 0)));
2332        assert_eq!(hit1, Some((HitId::new(99), HitRegion::Content, 1)));
2333        assert_eq!(hit2, Some((HitId::new(99), HitRegion::Content, 2)));
2334    }
2335
2336    #[test]
2337    fn table_no_hit_without_hit_id() {
2338        let table = Table::new([Row::new(["A"])], [Constraint::Fixed(5)]);
2339        let area = Rect::new(0, 0, 5, 1);
2340        let mut pool = GraphemePool::new();
2341        let mut frame = Frame::with_hit_grid(5, 1, &mut pool);
2342        let mut state = TableState::default();
2343        StatefulWidget::render(&table, area, &mut frame, &mut state);
2344
2345        // No hit region should be registered
2346        assert!(frame.hit_test(2, 0).is_none());
2347    }
2348
2349    #[test]
2350    fn table_no_hit_without_hit_grid() {
2351        let table = Table::new([Row::new(["A"])], [Constraint::Fixed(5)]).hit_id(HitId::new(1));
2352        let area = Rect::new(0, 0, 5, 1);
2353        let mut pool = GraphemePool::new();
2354        let mut frame = Frame::new(5, 1, &mut pool); // No hit grid
2355        let mut state = TableState::default();
2356        StatefulWidget::render(&table, area, &mut frame, &mut state);
2357
2358        // hit_test returns None when no hit grid
2359        assert!(frame.hit_test(2, 0).is_none());
2360    }
2361
2362    // --- MeasurableWidget tests ---
2363
2364    #[test]
2365    fn measure_empty_table() {
2366        let table = Table::new(Vec::<Row>::new(), [Constraint::Fixed(5)]);
2367        let c = table.measure(Size::MAX);
2368        assert_eq!(c, SizeConstraints::ZERO);
2369    }
2370
2371    #[test]
2372    fn measure_empty_columns() {
2373        let table = Table::new([Row::new(["A"])], Vec::<Constraint>::new());
2374        let c = table.measure(Size::MAX);
2375        assert_eq!(c, SizeConstraints::ZERO);
2376    }
2377
2378    #[test]
2379    fn measure_single_row() {
2380        let table = Table::new([Row::new(["Hello"])], [Constraint::Fixed(10)]);
2381        let c = table.measure(Size::MAX);
2382
2383        assert_eq!(c.preferred.width, 5); // "Hello" is 5 chars
2384        assert_eq!(c.preferred.height, 1); // 1 row
2385        assert!(table.has_intrinsic_size());
2386    }
2387
2388    #[test]
2389    fn measure_multiple_columns() {
2390        let table = Table::new(
2391            [Row::new(["A", "BB", "CCC"])],
2392            [
2393                Constraint::Fixed(5),
2394                Constraint::Fixed(5),
2395                Constraint::Fixed(5),
2396            ],
2397        )
2398        .column_spacing(2);
2399
2400        let c = table.measure(Size::MAX);
2401
2402        // Widths: 1 + 2 + 3 = 6, plus 2 gaps of 2 = 4 → total 10
2403        assert_eq!(c.preferred.width, 10);
2404        assert_eq!(c.preferred.height, 1);
2405    }
2406
2407    #[test]
2408    fn measure_respects_row_height_and_column_spacing() {
2409        let table = Table::new(
2410            [Row::new(["A", "BB"]).height(2)],
2411            [Constraint::FitContent, Constraint::FitContent],
2412        )
2413        .column_spacing(2);
2414
2415        let c = table.measure(Size::MAX);
2416
2417        assert_eq!(c.preferred.width, 5);
2418        assert_eq!(c.preferred.height, 2);
2419    }
2420
2421    #[test]
2422    fn measure_accounts_for_wide_glyphs() {
2423        let table = Table::new(
2424            [Row::new(["界", "A"])],
2425            [Constraint::FitContent, Constraint::FitContent],
2426        )
2427        .column_spacing(1);
2428
2429        let c = table.measure(Size::MAX);
2430
2431        assert_eq!(c.preferred.width, 4);
2432        assert_eq!(c.preferred.height, 1);
2433    }
2434
2435    #[test]
2436    fn measure_with_header() {
2437        let header = Row::new(["Name", "Value"]);
2438        let table = Table::new(
2439            [Row::new(["foo", "42"])],
2440            [Constraint::Fixed(5), Constraint::Fixed(5)],
2441        )
2442        .header(header);
2443
2444        let c = table.measure(Size::MAX);
2445
2446        // Header "Name" and "Value" are wider than "foo" and "42"
2447        // Widths: max(4, 3) = 4, max(5, 2) = 5, plus 1 gap = 10
2448        assert_eq!(c.preferred.width, 10);
2449        // Height: 1 header + 1 data row = 2
2450        assert_eq!(c.preferred.height, 2);
2451    }
2452
2453    #[test]
2454    fn measure_with_row_margins() {
2455        let table = Table::new(
2456            [
2457                Row::new(["A"]).bottom_margin(2),
2458                Row::new(["B"]).bottom_margin(1),
2459            ],
2460            [Constraint::Fixed(5)],
2461        );
2462
2463        let c = table.measure(Size::MAX);
2464
2465        // Heights: (1 + 2) + (1 + 1) = 5
2466        assert_eq!(c.preferred.height, 5);
2467    }
2468
2469    #[test]
2470    fn measure_column_widths_from_max_cell() {
2471        let table = Table::new(
2472            [Row::new(["A", "BB"]), Row::new(["CCC", "D"])],
2473            [Constraint::Fixed(5), Constraint::Fixed(5)],
2474        )
2475        .column_spacing(1);
2476
2477        let c = table.measure(Size::MAX);
2478
2479        // Column 0: max(1, 3) = 3
2480        // Column 1: max(2, 1) = 2
2481        // Total: 3 + 2 + 1 gap = 6
2482        assert_eq!(c.preferred.width, 6);
2483        assert_eq!(c.preferred.height, 2);
2484    }
2485
2486    #[test]
2487    fn measure_min_is_column_count() {
2488        let table = Table::new(
2489            [Row::new(["A", "B", "C"])],
2490            [
2491                Constraint::Fixed(5),
2492                Constraint::Fixed(5),
2493                Constraint::Fixed(5),
2494            ],
2495        );
2496
2497        let c = table.measure(Size::MAX);
2498
2499        // Minimum width should be at least the number of columns
2500        assert_eq!(c.min.width, 3);
2501        assert_eq!(c.min.height, 1);
2502    }
2503
2504    #[test]
2505    fn measure_has_intrinsic_size() {
2506        let empty = Table::new(Vec::<Row>::new(), [Constraint::Fixed(5)]);
2507        assert!(!empty.has_intrinsic_size());
2508
2509        let with_rows = Table::new([Row::new(["X"])], [Constraint::Fixed(5)]);
2510        assert!(with_rows.has_intrinsic_size());
2511
2512        let header_only =
2513            Table::new(Vec::<Row>::new(), [Constraint::Fixed(5)]).header(Row::new(["Header"]));
2514        assert!(header_only.has_intrinsic_size());
2515    }
2516
2517    // --- Stateful Persistence tests ---
2518
2519    use crate::stateful::Stateful;
2520
2521    #[test]
2522    fn table_state_with_persistence_id() {
2523        let state = TableState::default().with_persistence_id("my-table");
2524        assert_eq!(state.persistence_id(), Some("my-table"));
2525    }
2526
2527    #[test]
2528    fn table_state_default_no_persistence_id() {
2529        let state = TableState::default();
2530        assert_eq!(state.persistence_id(), None);
2531    }
2532
2533    #[test]
2534    fn table_state_save_restore_round_trip() {
2535        let mut state = TableState::default().with_persistence_id("test");
2536        state.select(Some(5));
2537        state.offset = 3;
2538        state.set_sort(Some(2), true);
2539        state.set_filter("search term");
2540
2541        let saved = state.save_state();
2542        assert_eq!(saved.selected, Some(5));
2543        assert_eq!(saved.offset, 3);
2544        assert_eq!(saved.sort_column, Some(2));
2545        assert!(saved.sort_ascending);
2546        assert_eq!(saved.filter, "search term");
2547
2548        // Reset state
2549        state.select(None);
2550        state.offset = 0;
2551        state.set_sort(None, false);
2552        state.set_filter("");
2553        assert_eq!(state.selected, None);
2554        assert_eq!(state.offset, 0);
2555        assert_eq!(state.sort_column(), None);
2556        assert!(!state.sort_ascending());
2557        assert!(state.filter().is_empty());
2558
2559        // Restore
2560        state.restore_state(saved);
2561        assert_eq!(state.selected, Some(5));
2562        assert_eq!(state.offset, 3);
2563        assert_eq!(state.sort_column(), Some(2));
2564        assert!(state.sort_ascending());
2565        assert_eq!(state.filter(), "search term");
2566    }
2567
2568    #[test]
2569    fn table_state_key_uses_persistence_id() {
2570        let state = TableState::default().with_persistence_id("main-data-table");
2571        let key = state.state_key().expect("named table has a key");
2572        assert_eq!(key.widget_type, "Table");
2573        assert_eq!(key.instance_id, "main-data-table");
2574    }
2575
2576    #[test]
2577    fn table_state_without_id_is_not_persisted() {
2578        assert!(TableState::default().state_key().is_none());
2579    }
2580
2581    #[test]
2582    fn table_persist_state_default() {
2583        let persist = TablePersistState::default();
2584        assert_eq!(persist.selected, None);
2585        assert_eq!(persist.offset, 0);
2586        assert_eq!(persist.sort_column, None);
2587        assert!(!persist.sort_ascending);
2588        assert!(persist.filter.is_empty());
2589    }
2590
2591    // ============================================================================
2592    // Undo Support Tests
2593    // ============================================================================
2594
2595    #[test]
2596    fn table_state_undo_widget_id_unique() {
2597        let state1 = TableState::default();
2598        let state2 = TableState::default();
2599        assert_ne!(state1.undo_id(), state2.undo_id());
2600    }
2601
2602    #[test]
2603    fn table_state_undo_snapshot_and_restore() {
2604        let mut state = TableState::default();
2605        state.select(Some(5));
2606        state.offset = 2;
2607        state.set_sort(Some(1), false);
2608        state.set_filter("test filter");
2609
2610        // Create snapshot
2611        let snapshot = state.create_snapshot();
2612
2613        // Modify state
2614        state.select(Some(10));
2615        state.offset = 7;
2616        state.set_sort(Some(3), true);
2617        state.set_filter("new filter");
2618
2619        assert_eq!(state.selected, Some(10));
2620        assert_eq!(state.offset, 7);
2621        assert_eq!(state.sort_column(), Some(3));
2622        assert!(state.sort_ascending());
2623        assert_eq!(state.filter(), "new filter");
2624
2625        // Restore snapshot
2626        assert!(state.restore_snapshot(&*snapshot));
2627
2628        // Verify restored state
2629        assert_eq!(state.selected, Some(5));
2630        assert_eq!(state.offset, 2);
2631        assert_eq!(state.sort_column(), Some(1));
2632        assert!(!state.sort_ascending());
2633        assert_eq!(state.filter(), "test filter");
2634    }
2635
2636    #[test]
2637    fn table_state_undo_ext_sort() {
2638        let mut state = TableState::default();
2639
2640        // Initial state
2641        assert_eq!(state.sort_state(), (None, false));
2642
2643        // Set sort
2644        state.set_sort_state(Some(2), true);
2645        assert_eq!(state.sort_state(), (Some(2), true));
2646
2647        // Change sort
2648        state.set_sort_state(Some(0), false);
2649        assert_eq!(state.sort_state(), (Some(0), false));
2650    }
2651
2652    #[test]
2653    fn table_state_undo_ext_filter() {
2654        let mut state = TableState::default();
2655
2656        // Initial state
2657        assert_eq!(state.filter_text(), "");
2658
2659        // Set filter
2660        state.set_filter_text("search term");
2661        assert_eq!(state.filter_text(), "search term");
2662
2663        // Clear filter
2664        state.set_filter_text("");
2665        assert_eq!(state.filter_text(), "");
2666    }
2667
2668    #[test]
2669    fn table_state_restore_wrong_snapshot_type_fails() {
2670        use std::any::Any;
2671        let mut state = TableState::default();
2672        let wrong_snapshot: Box<dyn Any + Send> = Box::new(42i32);
2673        assert!(!state.restore_snapshot(&*wrong_snapshot));
2674    }
2675
2676    // --- Mouse handling tests ---
2677
2678    use crate::mouse::MouseResult;
2679    use ftui_core::event::{MouseButton, MouseEvent, MouseEventKind};
2680
2681    #[test]
2682    fn table_state_click_selects() {
2683        let mut state = TableState::default();
2684        let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Left), 5, 2);
2685        let hit = Some((HitId::new(1), HitRegion::Content, 4u64));
2686        let result = state.handle_mouse(&event, hit, HitId::new(1), 10);
2687        assert_eq!(result, MouseResult::Selected(4));
2688        assert_eq!(state.selected, Some(4));
2689    }
2690
2691    #[test]
2692    fn table_state_second_click_activates() {
2693        let mut state = TableState::default();
2694        state.select(Some(4));
2695
2696        let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Left), 5, 2);
2697        let hit = Some((HitId::new(1), HitRegion::Content, 4u64));
2698        let result = state.handle_mouse(&event, hit, HitId::new(1), 10);
2699        assert_eq!(result, MouseResult::Activated(4));
2700        assert_eq!(state.selected, Some(4));
2701    }
2702
2703    #[test]
2704    fn table_state_click_wrong_id_ignored() {
2705        let mut state = TableState::default();
2706        let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Left), 5, 2);
2707        let hit = Some((HitId::new(99), HitRegion::Content, 4u64));
2708        let result = state.handle_mouse(&event, hit, HitId::new(1), 10);
2709        assert_eq!(result, MouseResult::Ignored);
2710    }
2711
2712    #[test]
2713    fn table_state_hover_updates() {
2714        let mut state = TableState::default();
2715        let event = MouseEvent::new(MouseEventKind::Moved, 5, 2);
2716        let hit = Some((HitId::new(1), HitRegion::Content, 3u64));
2717        let result = state.handle_mouse(&event, hit, HitId::new(1), 10);
2718        assert_eq!(result, MouseResult::HoverChanged);
2719        assert_eq!(state.hovered, Some(3));
2720    }
2721
2722    #[test]
2723    #[allow(clippy::field_reassign_with_default)]
2724    fn table_state_hover_same_index_ignored() {
2725        let mut state = {
2726            let mut s = TableState::default();
2727            s.hovered = Some(3);
2728            s
2729        };
2730        let event = MouseEvent::new(MouseEventKind::Moved, 5, 2);
2731        let hit = Some((HitId::new(1), HitRegion::Content, 3u64));
2732        let result = state.handle_mouse(&event, hit, HitId::new(1), 10);
2733        assert_eq!(result, MouseResult::Ignored);
2734        assert_eq!(state.hovered, Some(3));
2735    }
2736
2737    #[test]
2738    #[allow(clippy::field_reassign_with_default)]
2739    fn table_state_hover_clears() {
2740        let mut state = {
2741            let mut s = TableState::default();
2742            s.hovered = Some(5);
2743            s
2744        };
2745        let event = MouseEvent::new(MouseEventKind::Moved, 5, 2);
2746        // No hit (mouse moved off the table)
2747        let result = state.handle_mouse(&event, None, HitId::new(1), 10);
2748        assert_eq!(result, MouseResult::HoverChanged);
2749        assert_eq!(state.hovered, None);
2750    }
2751
2752    #[test]
2753    fn table_state_hover_clear_when_already_none() {
2754        let mut state = TableState::default();
2755        let event = MouseEvent::new(MouseEventKind::Moved, 5, 2);
2756        let result = state.handle_mouse(&event, None, HitId::new(1), 10);
2757        assert_eq!(result, MouseResult::Ignored);
2758    }
2759
2760    #[test]
2761    #[allow(clippy::field_reassign_with_default)]
2762    fn table_state_scroll_wheel_up() {
2763        let mut state = {
2764            let mut s = TableState::default();
2765            s.offset = 10;
2766            s
2767        };
2768        let event = MouseEvent::new(MouseEventKind::ScrollUp, 0, 0);
2769        let result = state.handle_mouse(&event, None, HitId::new(1), 20);
2770        assert_eq!(result, MouseResult::Scrolled);
2771        assert_eq!(state.offset, 7);
2772    }
2773
2774    #[test]
2775    fn table_state_scroll_wheel_down() {
2776        let mut state = TableState::default();
2777        let event = MouseEvent::new(MouseEventKind::ScrollDown, 0, 0);
2778        let result = state.handle_mouse(&event, None, HitId::new(1), 20);
2779        assert_eq!(result, MouseResult::Scrolled);
2780        assert_eq!(state.offset, 3);
2781    }
2782
2783    #[test]
2784    #[allow(clippy::field_reassign_with_default)]
2785    fn table_state_scroll_down_clamps() {
2786        let mut state = {
2787            let mut s = TableState::default();
2788            s.offset = 18;
2789            s
2790        };
2791        state.scroll_down(5, 20);
2792        assert_eq!(state.offset, 19);
2793    }
2794
2795    #[test]
2796    #[allow(clippy::field_reassign_with_default)]
2797    fn table_state_scroll_up_clamps() {
2798        let mut state = {
2799            let mut s = TableState::default();
2800            s.offset = 1;
2801            s
2802        };
2803        state.scroll_up(5);
2804        assert_eq!(state.offset, 0);
2805    }
2806
2807    // ============================================================================
2808    // Edge-Case Tests (bd-2rvwb)
2809    // ============================================================================
2810
2811    #[test]
2812    fn row_with_fewer_cells_than_columns() {
2813        // Row has 1 cell but table declares 3 columns — extra columns should be empty
2814        let table = Table::new(
2815            [Row::new(["A"])],
2816            [
2817                Constraint::Fixed(3),
2818                Constraint::Fixed(3),
2819                Constraint::Fixed(3),
2820            ],
2821        );
2822        let area = Rect::new(0, 0, 12, 1);
2823        let mut pool = GraphemePool::new();
2824        let mut frame = Frame::new(12, 1, &mut pool);
2825        Widget::render(&table, area, &mut frame);
2826
2827        assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
2828        // Columns 2 and 3 should not contain data characters
2829        assert_ne!(cell_char(&frame.buffer, 4, 0), Some('A'));
2830    }
2831
2832    #[test]
2833    fn column_spacing_zero() {
2834        // No gap between columns — cells should be adjacent
2835        let table = Table::new(
2836            [Row::new(["AB", "CD"])],
2837            [Constraint::Fixed(2), Constraint::Fixed(2)],
2838        )
2839        .column_spacing(0);
2840
2841        let area = Rect::new(0, 0, 4, 1);
2842        let mut pool = GraphemePool::new();
2843        let mut frame = Frame::new(4, 1, &mut pool);
2844        Widget::render(&table, area, &mut frame);
2845
2846        assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
2847        assert_eq!(cell_char(&frame.buffer, 1, 0), Some('B'));
2848        assert_eq!(cell_char(&frame.buffer, 2, 0), Some('C'));
2849        assert_eq!(cell_char(&frame.buffer, 3, 0), Some('D'));
2850    }
2851
2852    #[test]
2853    fn render_with_nonzero_origin() {
2854        // Table rendered at offset position, not (0,0)
2855        let table = Table::new([Row::new(["X"])], [Constraint::Fixed(3)]);
2856        let area = Rect::new(5, 3, 3, 1);
2857        let mut pool = GraphemePool::new();
2858        let mut frame = Frame::new(10, 6, &mut pool);
2859        Widget::render(&table, area, &mut frame);
2860
2861        assert_eq!(cell_char(&frame.buffer, 5, 3), Some('X'));
2862        // Nothing at (0,0)
2863        assert_ne!(cell_char(&frame.buffer, 0, 0), Some('X'));
2864    }
2865
2866    #[test]
2867    fn single_row_height_exceeds_area() {
2868        // Row is taller than the viewport — should be clipped via scissor
2869        let table = Table::new([Row::new(["T"]).height(10)], [Constraint::Fixed(3)]);
2870        let area = Rect::new(0, 0, 3, 2);
2871        let mut pool = GraphemePool::new();
2872        let mut frame = Frame::new(3, 2, &mut pool);
2873        Widget::render(&table, area, &mut frame);
2874
2875        // First line of the row should still render
2876        assert_eq!(cell_char(&frame.buffer, 0, 0), Some('T'));
2877    }
2878
2879    #[test]
2880    fn selection_and_hover_on_same_row() {
2881        // Both selected and hovered on same row — both styles should merge
2882        let selected_fg = PackedRgba::rgb(100, 0, 0);
2883        let hovered_fg = PackedRgba::rgb(0, 100, 0);
2884        let highlight_fg = PackedRgba::rgb(0, 0, 100);
2885
2886        let theme = TableTheme {
2887            row_selected: Style::new().fg(selected_fg),
2888            row_hover: Style::new().fg(hovered_fg),
2889            ..Default::default()
2890        };
2891
2892        let table = Table::new([Row::new(["X"])], [Constraint::Fixed(3)])
2893            .highlight_style(Style::new().fg(highlight_fg))
2894            .theme(theme);
2895
2896        let area = Rect::new(0, 0, 3, 1);
2897        let mut pool = GraphemePool::new();
2898        let mut frame = Frame::new(3, 1, &mut pool);
2899        let mut state = TableState {
2900            selected: Some(0),
2901            hovered: Some(0),
2902            ..Default::default()
2903        };
2904
2905        StatefulWidget::render(&table, area, &mut frame, &mut state);
2906        // Highlight style wins (applied last in merge chain)
2907        assert_eq!(cell_fg(&frame.buffer, 0, 0), Some(highlight_fg));
2908    }
2909
2910    #[test]
2911    fn alternating_row_styles() {
2912        // Even/odd rows should get different theme styles
2913        let even_fg = PackedRgba::rgb(10, 10, 10);
2914        let odd_fg = PackedRgba::rgb(20, 20, 20);
2915        let theme = TableTheme {
2916            row: Style::new().fg(even_fg),
2917            row_alt: Style::new().fg(odd_fg),
2918            ..Default::default()
2919        };
2920
2921        let table = Table::new(
2922            [Row::new(["E"]), Row::new(["O"]), Row::new(["E2"])],
2923            [Constraint::Fixed(3)],
2924        )
2925        .theme(theme);
2926
2927        let area = Rect::new(0, 0, 3, 3);
2928        let mut pool = GraphemePool::new();
2929        let mut frame = Frame::new(3, 3, &mut pool);
2930        Widget::render(&table, area, &mut frame);
2931
2932        // Row 0 is even, row 1 is odd, row 2 is even
2933        assert_eq!(cell_fg(&frame.buffer, 0, 0), Some(even_fg));
2934        assert_eq!(cell_fg(&frame.buffer, 0, 1), Some(odd_fg));
2935        assert_eq!(cell_fg(&frame.buffer, 0, 2), Some(even_fg));
2936    }
2937
2938    #[test]
2939    fn scroll_up_from_zero_stays_zero() {
2940        let mut state = TableState::default();
2941        state.scroll_up(10);
2942        assert_eq!(state.offset, 0);
2943    }
2944
2945    #[test]
2946    fn scroll_down_with_zero_rows() {
2947        let mut state = TableState::default();
2948        state.scroll_down(5, 0);
2949        assert_eq!(state.offset, 0);
2950    }
2951
2952    #[test]
2953    fn scroll_down_with_single_row() {
2954        let mut state = TableState::default();
2955        state.scroll_down(5, 1);
2956        assert_eq!(state.offset, 0);
2957    }
2958
2959    #[test]
2960    fn mouse_click_on_row_exceeding_row_count() {
2961        // Hit data row index >= row_count should be ignored
2962        let mut state = TableState::default();
2963        let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Left), 0, 0);
2964        let hit = Some((HitId::new(1), HitRegion::Content, 100u64));
2965        let result = state.handle_mouse(&event, hit, HitId::new(1), 5);
2966        assert_eq!(result, MouseResult::Ignored);
2967        assert_eq!(state.selected, None);
2968    }
2969
2970    #[test]
2971    fn mouse_right_click_ignored() {
2972        let mut state = TableState::default();
2973        let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Right), 0, 0);
2974        let hit = Some((HitId::new(1), HitRegion::Content, 2u64));
2975        let result = state.handle_mouse(&event, hit, HitId::new(1), 5);
2976        assert_eq!(result, MouseResult::Ignored);
2977    }
2978
2979    #[test]
2980    fn mouse_hover_on_row_exceeding_row_count() {
2981        let mut state = TableState::default();
2982        let event = MouseEvent::new(MouseEventKind::Moved, 0, 0);
2983        let hit = Some((HitId::new(1), HitRegion::Content, 100u64));
2984        let result = state.handle_mouse(&event, hit, HitId::new(1), 5);
2985        // Moves off widget, hover cleared (was None, stays None)
2986        assert_eq!(result, MouseResult::Ignored);
2987        assert_eq!(state.hovered, None);
2988    }
2989
2990    #[test]
2991    fn select_deselect_preserves_offset_then_reselect() {
2992        let mut state = TableState {
2993            offset: 15,
2994            ..Default::default()
2995        };
2996        state.select(Some(20));
2997        assert_eq!(state.selected, Some(20));
2998        assert_eq!(state.offset, 15); // offset not reset on select
2999
3000        state.select(None);
3001        assert_eq!(state.offset, 15); // preserve viewport on deselect
3002
3003        state.select(Some(3));
3004        assert_eq!(state.selected, Some(3));
3005        assert_eq!(state.offset, 15); // still preserved after reselect
3006    }
3007
3008    #[test]
3009    fn offset_clamped_when_rows_empty() {
3010        let table = Table::new(Vec::<Row>::new(), [Constraint::Fixed(5)]);
3011        let area = Rect::new(0, 0, 5, 3);
3012        let mut pool = GraphemePool::new();
3013        let mut frame = Frame::new(5, 3, &mut pool);
3014        let mut state = TableState {
3015            offset: 999,
3016            ..Default::default()
3017        };
3018        StatefulWidget::render(&table, area, &mut frame, &mut state);
3019        assert_eq!(state.offset, 0);
3020    }
3021
3022    #[test]
3023    fn selection_clamps_when_rows_empty() {
3024        let table = Table::new(Vec::<Row>::new(), [Constraint::Fixed(5)]);
3025        let area = Rect::new(0, 0, 5, 3);
3026        let mut pool = GraphemePool::new();
3027        let mut frame = Frame::new(5, 3, &mut pool);
3028        let mut state = TableState {
3029            selected: Some(5),
3030            ..Default::default()
3031        };
3032        StatefulWidget::render(&table, area, &mut frame, &mut state);
3033        assert_eq!(state.selected, None);
3034    }
3035
3036    #[test]
3037    fn header_with_bottom_margin_offsets_rows() {
3038        let header = Row::new(["H"]).bottom_margin(2);
3039        let table = Table::new([Row::new(["D"])], [Constraint::Fixed(3)]).header(header);
3040
3041        let area = Rect::new(0, 0, 3, 5);
3042        let mut pool = GraphemePool::new();
3043        let mut frame = Frame::new(3, 5, &mut pool);
3044        Widget::render(&table, area, &mut frame);
3045
3046        // Header at y=0, margin of 2, data at y=3
3047        assert_eq!(cell_char(&frame.buffer, 0, 0), Some('H'));
3048        assert_eq!(cell_char(&frame.buffer, 0, 3), Some('D'));
3049    }
3050
3051    #[test]
3052    fn block_plus_header_fill_entire_area() {
3053        // Block chrome is 4 rows (borders + padding), header takes 1 row — 5 rows total.
3054        // With area height=5, no data rows should render.
3055        let header = Row::new(["H"]);
3056        let table = Table::new([Row::new(["X"])], [Constraint::Fixed(3)])
3057            .block(Block::bordered())
3058            .header(header);
3059
3060        let area = Rect::new(0, 0, 5, 5);
3061        let mut pool = GraphemePool::new();
3062        let mut frame = Frame::new(5, 5, &mut pool);
3063        Widget::render(&table, area, &mut frame);
3064
3065        // Header should render inside the border + padding
3066        assert_eq!(cell_char(&frame.buffer, 2, 2), Some('H'));
3067        // Data row "X" should NOT appear (no room)
3068        let data_rendered =
3069            (0..5).any(|x| (0..5).any(|y| cell_char(&frame.buffer, x, y) == Some('X')));
3070        assert!(!data_rendered);
3071    }
3072
3073    #[test]
3074    fn min_constraint_measure() {
3075        let table = Table::new([Row::new(["AB"])], [Constraint::Min(10)]);
3076        let c = table.measure(Size::MAX);
3077        // Preferred width based on content, not the constraint minimum
3078        assert_eq!(c.preferred.width, 2);
3079        assert_eq!(c.preferred.height, 1);
3080    }
3081
3082    #[test]
3083    fn percentage_constraint_render() {
3084        // Percentage constraints should not panic and produce reasonable layout
3085        let table = Table::new(
3086            [Row::new(["A", "B"])],
3087            [Constraint::Percentage(50.0), Constraint::Percentage(50.0)],
3088        );
3089        let area = Rect::new(0, 0, 20, 1);
3090        let mut pool = GraphemePool::new();
3091        let mut frame = Frame::new(20, 1, &mut pool);
3092        Widget::render(&table, area, &mut frame);
3093
3094        assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
3095    }
3096
3097    #[test]
3098    fn fit_content_constraint_measure() {
3099        let table = Table::new(
3100            [Row::new(["Hello", "World"])],
3101            [Constraint::FitContent, Constraint::FitContent],
3102        )
3103        .column_spacing(1);
3104
3105        let c = table.measure(Size::MAX);
3106        // "Hello" = 5, "World" = 5, spacing = 1 → 11
3107        assert_eq!(c.preferred.width, 11);
3108    }
3109
3110    #[test]
3111    fn measure_with_block_adds_overhead() {
3112        let table_no_block = Table::new([Row::new(["X"])], [Constraint::Fixed(3)]);
3113        let table_with_block =
3114            Table::new([Row::new(["X"])], [Constraint::Fixed(3)]).block(Block::bordered());
3115
3116        let c_no = table_no_block.measure(Size::MAX);
3117        let c_with = table_with_block.measure(Size::MAX);
3118
3119        // Block chrome (borders + padding) adds 4 to width and 4 to height.
3120        assert_eq!(c_with.preferred.width, c_no.preferred.width + 4);
3121        assert_eq!(c_with.preferred.height, c_no.preferred.height + 4);
3122    }
3123
3124    #[test]
3125    fn variable_height_rows_selection_scrolls_down() {
3126        // Rows: height 1, 1, 5, 1, 1. Viewport=4 rows.
3127        // Select row 4 (past the tall row) should adjust offset.
3128        let rows = vec![
3129            Row::new(["A"]),
3130            Row::new(["B"]),
3131            Row::new(["C"]).height(5),
3132            Row::new(["D"]),
3133            Row::new(["E"]),
3134        ];
3135        let table = Table::new(rows, [Constraint::Fixed(5)]);
3136        let area = Rect::new(0, 0, 5, 4);
3137        let mut pool = GraphemePool::new();
3138        let mut frame = Frame::new(5, 4, &mut pool);
3139        let mut state = TableState {
3140            selected: Some(4),
3141            ..Default::default()
3142        };
3143        StatefulWidget::render(&table, area, &mut frame, &mut state);
3144
3145        // Selection should be visible; offset adjusted
3146        assert!(state.offset > 0);
3147        assert_eq!(state.selected, Some(4));
3148    }
3149
3150    #[test]
3151    fn many_rows_with_margins_viewport_clamping() {
3152        // 20 rows each with bottom_margin=1, viewport=5 lines.
3153        // Each row occupies 2 lines (1 content + 1 margin). Max 2 rows visible.
3154        let rows: Vec<Row> = (0..20)
3155            .map(|i| Row::new([format!("R{i}")]).bottom_margin(1))
3156            .collect();
3157        let table = Table::new(rows, [Constraint::Fixed(5)]);
3158        let area = Rect::new(0, 0, 5, 5);
3159        let mut pool = GraphemePool::new();
3160        let mut frame = Frame::new(5, 5, &mut pool);
3161        let mut state = TableState {
3162            offset: 19,
3163            ..Default::default()
3164        };
3165        StatefulWidget::render(&table, area, &mut frame, &mut state);
3166
3167        // Offset should be clamped back to fill viewport
3168        assert!(state.offset < 19);
3169    }
3170
3171    #[test]
3172    fn render_area_width_one() {
3173        // Extremely narrow area — should not panic
3174        let table = Table::new([Row::new(["Hello"])], [Constraint::Fixed(5)]);
3175        let area = Rect::new(0, 0, 1, 1);
3176        let mut pool = GraphemePool::new();
3177        let mut frame = Frame::new(1, 1, &mut pool);
3178        Widget::render(&table, area, &mut frame);
3179
3180        assert_eq!(cell_char(&frame.buffer, 0, 0), Some('H'));
3181    }
3182
3183    #[test]
3184    fn render_area_height_one() {
3185        // Minimal height — should show first row
3186        let table = Table::new([Row::new(["A"]), Row::new(["B"])], [Constraint::Fixed(3)]);
3187        let area = Rect::new(0, 0, 3, 1);
3188        let mut pool = GraphemePool::new();
3189        let mut frame = Frame::new(3, 1, &mut pool);
3190        Widget::render(&table, area, &mut frame);
3191
3192        assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
3193    }
3194
3195    #[test]
3196    fn hit_regions_with_offset() {
3197        // When scrolled, hit data should still encode logical row index
3198        let table = Table::new(
3199            (0..10).map(|i| Row::new([format!("R{i}")])),
3200            [Constraint::Fixed(5)],
3201        )
3202        .hit_id(HitId::new(42));
3203
3204        let area = Rect::new(0, 0, 5, 3);
3205        let mut pool = GraphemePool::new();
3206        let mut frame = Frame::with_hit_grid(5, 3, &mut pool);
3207        let mut state = TableState {
3208            offset: 5,
3209            ..Default::default()
3210        };
3211        StatefulWidget::render(&table, area, &mut frame, &mut state);
3212
3213        // Row at y=0 should be logical row 5
3214        let hit0 = frame.hit_test(2, 0);
3215        assert_eq!(hit0, Some((HitId::new(42), HitRegion::Content, 5)));
3216
3217        let hit1 = frame.hit_test(2, 1);
3218        assert_eq!(hit1, Some((HitId::new(42), HitRegion::Content, 6)));
3219    }
3220
3221    #[test]
3222    fn table_state_sort_defaults() {
3223        let state = TableState::default();
3224        assert_eq!(state.sort_column(), None);
3225        assert!(!state.sort_ascending());
3226        assert!(state.filter().is_empty());
3227    }
3228
3229    #[test]
3230    fn table_state_set_sort_toggle() {
3231        let mut state = TableState::default();
3232        state.set_sort(Some(0), true);
3233        assert_eq!(state.sort_column(), Some(0));
3234        assert!(state.sort_ascending());
3235
3236        // Toggle direction
3237        state.set_sort(Some(0), false);
3238        assert!(!state.sort_ascending());
3239
3240        // Change column
3241        state.set_sort(Some(3), true);
3242        assert_eq!(state.sort_column(), Some(3));
3243
3244        // Clear sort
3245        state.set_sort(None, false);
3246        assert_eq!(state.sort_column(), None);
3247    }
3248
3249    #[test]
3250    fn table_persist_round_trip_preserves_hovered_none() {
3251        let mut state = TableState::default().with_persistence_id("t");
3252        state.select(Some(3));
3253        state.hovered = Some(7);
3254        state.offset = 2;
3255
3256        let saved = state.save_state();
3257        state.restore_state(saved);
3258
3259        // hovered is deliberately NOT persisted (transient state)
3260        assert_eq!(state.hovered, None);
3261        assert_eq!(state.selected, Some(3));
3262        assert_eq!(state.offset, 2);
3263    }
3264
3265    #[test]
3266    fn undo_snapshot_clears_hovered() {
3267        let mut state = TableState::default();
3268        state.select(Some(2));
3269        state.hovered = Some(5);
3270
3271        let snap = state.create_snapshot();
3272
3273        // Modify
3274        state.select(Some(9));
3275        state.hovered = Some(8);
3276
3277        // Restore
3278        assert!(state.restore_snapshot(&*snap));
3279        assert_eq!(state.selected, Some(2));
3280        // hovered is cleared on restore (not preserved in snapshot)
3281        assert_eq!(state.hovered, None);
3282    }
3283
3284    #[test]
3285    fn wide_chars_in_render() {
3286        // CJK characters are 2 cells wide — should clip correctly.
3287        // Wide chars may use the grapheme pool, so we check the cell is populated.
3288        let table = Table::new([Row::new(["界界界"])], [Constraint::Fixed(4)]);
3289        let area = Rect::new(0, 0, 4, 1);
3290        let mut pool = GraphemePool::new();
3291        let mut frame = Frame::new(4, 1, &mut pool);
3292        Widget::render(&table, area, &mut frame);
3293
3294        // "界界界" needs 6 cells but only 4 available — first two wide chars fit.
3295        // The cell at (0,0) should have content (not empty).
3296        let cell = frame.buffer.get(0, 0).unwrap();
3297        assert!(
3298            !cell.content.is_empty(),
3299            "first cell should contain CJK content, not be empty"
3300        );
3301        // Cell at (1,0) should be a continuation marker for the wide char
3302        let cell1 = frame.buffer.get(1, 0).unwrap();
3303        assert!(
3304            cell1.content.is_continuation(),
3305            "second cell should be continuation of wide char"
3306        );
3307    }
3308
3309    #[test]
3310    fn empty_row_cells() {
3311        // Row with empty strings — should render without panic
3312        let table = Table::new(
3313            [Row::new(["", "", ""])],
3314            [
3315                Constraint::Fixed(3),
3316                Constraint::Fixed(3),
3317                Constraint::Fixed(3),
3318            ],
3319        );
3320        let area = Rect::new(0, 0, 11, 1);
3321        let mut pool = GraphemePool::new();
3322        let mut frame = Frame::new(11, 1, &mut pool);
3323        Widget::render(&table, area, &mut frame);
3324        // Should not panic; cells empty
3325    }
3326
3327    #[test]
3328    fn measure_with_many_rows_saturates() {
3329        // Height computation should use saturating arithmetic
3330        let rows: Vec<Row> = (0..10000).map(|_| Row::new(["X"]).height(100)).collect();
3331        let table = Table::new(rows, [Constraint::Fixed(3)]);
3332        let c = table.measure(Size::MAX);
3333
3334        // Should not overflow — saturates at u16::MAX
3335        assert!(c.preferred.height > 0);
3336    }
3337
3338    #[test]
3339    fn variable_height_rows_respect_viewport_visible_range() {
3340        let rows = vec![
3341            Row::new(["R0"]),
3342            Row::new(["R1"]).height(2),
3343            Row::new(["R2"]),
3344            Row::new(["R3"]),
3345        ];
3346        let table = Table::new(rows, [Constraint::Fixed(4)]);
3347        let area = Rect::new(0, 0, 4, 3);
3348        let mut pool = GraphemePool::new();
3349        let mut frame = Frame::new(4, 3, &mut pool);
3350        let mut state = TableState {
3351            offset: 1,
3352            ..Default::default()
3353        };
3354
3355        StatefulWidget::render(&table, area, &mut frame, &mut state);
3356
3357        assert_eq!(state.offset, 1);
3358        assert_eq!(row_text(&frame.buffer, 0), "R1");
3359        assert_eq!(row_text(&frame.buffer, 1), "");
3360        assert_eq!(row_text(&frame.buffer, 2), "R2");
3361    }
3362
3363    #[test]
3364    fn render_100k_rows_stays_within_8ms_frame_budget() {
3365        use std::time::{Duration, Instant};
3366
3367        let rows: Vec<Row> = (0..100_000).map(|_| Row::new(["row"])).collect();
3368        let table = Table::new(rows, [Constraint::Fixed(12)]);
3369        let area = Rect::new(0, 0, 12, 24);
3370        let mut state = TableState {
3371            offset: 50_000,
3372            ..Default::default()
3373        };
3374        let mut pool = GraphemePool::new();
3375
3376        // Warm up branch prediction and caches.
3377        let mut warmup = Frame::new(12, 24, &mut pool);
3378        StatefulWidget::render(&table, area, &mut warmup, &mut state);
3379
3380        let iterations = 20u32;
3381        let start = Instant::now();
3382        for _ in 0..iterations {
3383            let mut frame = Frame::new(12, 24, &mut pool);
3384            StatefulWidget::render(&table, area, &mut frame, &mut state);
3385        }
3386        let per_frame = start.elapsed() / iterations;
3387
3388        assert!(
3389            per_frame <= Duration::from_millis(8),
3390            "100k-row table render exceeded 8ms budget: {per_frame:?}"
3391        );
3392    }
3393
3394    #[cfg(feature = "tracing")]
3395    #[test]
3396    fn tracing_table_render_span_reports_row_counts() {
3397        let trace_state = Arc::new(Mutex::new(TableTraceState::default()));
3398        let _trace_test_guard = crate::tracing_test_support::acquire();
3399        let subscriber = tracing_subscriber::registry().with(TableTraceCapture {
3400            state: Arc::clone(&trace_state),
3401        });
3402        let _guard = tracing::subscriber::set_default(subscriber);
3403        tracing::callsite::rebuild_interest_cache();
3404
3405        let rows: Vec<Row> = (0..20).map(|i| Row::new([format!("R{i}")])).collect();
3406        let table = Table::new(rows, [Constraint::Fixed(6)]);
3407        let area = Rect::new(0, 0, 6, 4);
3408        let mut state = TableState {
3409            offset: 3,
3410            ..Default::default()
3411        };
3412        let mut pool = GraphemePool::new();
3413        let mut frame = Frame::new(6, 4, &mut pool);
3414        // Parallel workspace tests can perturb callsite interest after the
3415        // subscriber is installed, so rebuild immediately before the traced render.
3416        tracing::callsite::rebuild_interest_cache();
3417        StatefulWidget::render(&table, area, &mut frame, &mut state);
3418
3419        tracing::callsite::rebuild_interest_cache();
3420        let snapshot = trace_state.lock().expect("table trace state lock");
3421        assert!(
3422            snapshot.span_count >= 1,
3423            "expected at least one table.render span, got {}",
3424            snapshot.span_count
3425        );
3426        assert!(
3427            snapshot.has_total_rows_field,
3428            "table.render span missing total_rows field"
3429        );
3430        assert!(
3431            snapshot.has_rendered_rows_field,
3432            "table.render span missing rendered_rows field"
3433        );
3434        assert!(
3435            snapshot.total_rows.contains(&20),
3436            "expected total_rows=20 in span fields, got {:?}",
3437            snapshot.total_rows
3438        );
3439        assert!(
3440            snapshot.rendered_rows.iter().any(|&n| n > 0 && n <= 4),
3441            "expected rendered_rows between 1 and 4, got {:?}",
3442            snapshot.rendered_rows
3443        );
3444    }
3445
3446    #[test]
3447    fn stripe_period_zero_disables_alt_rows() {
3448        let row_fg = PackedRgba::WHITE;
3449        let row_alt_fg = PackedRgba::rgb(255, 255, 0);
3450        let theme = TableTheme::default()
3451            .with_stripe_period(0)
3452            .with_row(Style::new().fg(row_fg))
3453            .with_row_alt(Style::new().fg(row_alt_fg));
3454
3455        let rows = (0..6).map(|i| Row::new([format!("r{i}")]));
3456        let table = Table::new(rows, [Constraint::Fixed(10)]).theme(theme);
3457        let area = Rect::new(0, 0, 10, 6);
3458        let mut pool = GraphemePool::new();
3459        let mut frame = Frame::new(10, 6, &mut pool);
3460        Widget::render(&table, area, &mut frame);
3461
3462        for y in 0..6 {
3463            assert_eq!(
3464                cell_fg(&frame.buffer, 0, y),
3465                Some(row_fg),
3466                "row {y} cell fg should be row_fg when stripe_period is 0"
3467            );
3468        }
3469    }
3470
3471    #[test]
3472    fn stripe_period_two_matches_previous_behaviour() {
3473        let row_fg = PackedRgba::WHITE;
3474        let row_alt_fg = PackedRgba::rgb(255, 255, 0);
3475        let theme = TableTheme::default()
3476            .with_stripe_period(2)
3477            .with_row(Style::new().fg(row_fg))
3478            .with_row_alt(Style::new().fg(row_alt_fg));
3479
3480        let rows = (0..6).map(|i| Row::new([format!("r{i}")]));
3481        let table = Table::new(rows, [Constraint::Fixed(10)]).theme(theme);
3482        let area = Rect::new(0, 0, 10, 6);
3483        let mut pool = GraphemePool::new();
3484        let mut frame = Frame::new(10, 6, &mut pool);
3485        Widget::render(&table, area, &mut frame);
3486
3487        for y in 0..6 {
3488            let expected_fg = if y % 2 == 1 { row_alt_fg } else { row_fg };
3489            assert_eq!(
3490                cell_fg(&frame.buffer, 0, y),
3491                Some(expected_fg),
3492                "row {y} cell fg unexpected for stripe_period 2"
3493            );
3494        }
3495    }
3496
3497    #[test]
3498    fn stripe_period_three_pattern() {
3499        let row_fg = PackedRgba::WHITE;
3500        let row_alt_fg = PackedRgba::rgb(255, 255, 0);
3501        let theme = TableTheme::default()
3502            .with_stripe_period(3)
3503            .with_row(Style::new().fg(row_fg))
3504            .with_row_alt(Style::new().fg(row_alt_fg));
3505
3506        let rows = (0..6).map(|i| Row::new([format!("r{i}")]));
3507        let table = Table::new(rows, [Constraint::Fixed(10)]).theme(theme);
3508        let area = Rect::new(0, 0, 10, 6);
3509        let mut pool = GraphemePool::new();
3510        let mut frame = Frame::new(10, 6, &mut pool);
3511        Widget::render(&table, area, &mut frame);
3512
3513        // With period 3, row_index % 3 == 2 gets row_alt (rows 2 and 5)
3514        for y in 0..6 {
3515            let expected_fg = if y % 3 == 2 { row_alt_fg } else { row_fg };
3516            assert_eq!(
3517                cell_fg(&frame.buffer, 0, y),
3518                Some(expected_fg),
3519                "row {y} cell fg unexpected for stripe_period 3"
3520            );
3521        }
3522    }
3523
3524    #[test]
3525    fn header_style_applied_to_header_row() {
3526        let cyan = PackedRgba::rgb(0, 205, 205);
3527        let theme = TableTheme::default()
3528            .with_header_style(Style::new().bold().fg(cyan))
3529            .with_row(Style::new().fg(PackedRgba::WHITE));
3530
3531        let table = Table::new([Row::new(["B0"])], [Constraint::Fixed(10)])
3532            .header(Row::new(["H0"]))
3533            .theme(theme);
3534
3535        let area = Rect::new(0, 0, 10, 2);
3536        let mut pool = GraphemePool::new();
3537        let mut frame = Frame::new(10, 2, &mut pool);
3538        Widget::render(&table, area, &mut frame);
3539
3540        // Header at y=0
3541        let header_cell = frame.buffer.get(0, 0).copied().unwrap();
3542        assert_eq!(header_cell.fg, cyan);
3543        assert!(
3544            header_cell
3545                .attrs
3546                .has_flag(ftui_render::cell::StyleFlags::BOLD)
3547        );
3548
3549        // Body at y=1
3550        let body_cell = frame.buffer.get(0, 1).copied().unwrap();
3551        assert_eq!(body_cell.fg, PackedRgba::WHITE);
3552        assert!(
3553            !body_cell
3554                .attrs
3555                .has_flag(ftui_render::cell::StyleFlags::BOLD)
3556        );
3557    }
3558
3559    #[test]
3560    fn selection_style_over_stripe() {
3561        let stripe_bg = PackedRgba::rgb(30, 30, 30);
3562        let selected_bg = PackedRgba::rgb(100, 100, 0);
3563
3564        let theme = TableTheme::default()
3565            .with_stripe_period(2)
3566            .with_row_alt(Style::new().bg(stripe_bg))
3567            .with_selection_style(Style::new().bg(selected_bg));
3568
3569        let rows = (0..4).map(|i| Row::new([format!("r{i}")]));
3570        let table = Table::new(rows, [Constraint::Fixed(10)]).theme(theme);
3571
3572        let area = Rect::new(0, 0, 10, 4);
3573        let mut pool = GraphemePool::new();
3574        let mut frame = Frame::new(10, 4, &mut pool);
3575        let mut state = TableState::default();
3576        state.select(Some(1)); // r1 would normally get row_alt (stripe_bg)
3577
3578        StatefulWidget::render(&table, area, &mut frame, &mut state);
3579
3580        let r1_cell = frame.buffer.get(0, 1).copied().unwrap();
3581        assert_eq!(
3582            r1_cell.bg, selected_bg,
3583            "selected row bg should override stripe bg"
3584        );
3585    }
3586
3587    #[test]
3588    fn truncate_clip() {
3589        let table = Table::new([Row::new(["abcdef"])], [Constraint::Fixed(4)])
3590            .with_column_truncation(0, Truncate::Clip);
3591
3592        let area = Rect::new(0, 0, 4, 1);
3593        let mut pool = GraphemePool::new();
3594        let mut frame = Frame::new(4, 1, &mut pool);
3595        Widget::render(&table, area, &mut frame);
3596
3597        assert_eq!(raw_row_text(&frame.buffer, 0), "abcd");
3598    }
3599
3600    #[test]
3601    fn truncate_ellipsis_cjk_width() {
3602        // In a 6-wide column, "日本語テキスト" (each glyph width 2) with Ellipsis:
3603        // Budget = 6 - 1 = 5. Fits "日本" (width 4) + "…" (width 1) = 5 cells.
3604        // The remaining cell 5 is blank (' '), avoiding half-glyph splitting of "語".
3605        let table = Table::new([Row::new(["日本語テキスト"])], [Constraint::Fixed(6)])
3606            .with_column_truncation(0, Truncate::Ellipsis);
3607
3608        let area = Rect::new(0, 0, 6, 1);
3609        let mut pool = GraphemePool::new();
3610        let mut frame = Frame::new(6, 1, &mut pool);
3611        Widget::render(&table, area, &mut frame);
3612
3613        let c4 = frame.buffer.get(4, 0).and_then(|c| c.content.as_char());
3614        assert_eq!(c4, Some('…'), "cell 4 should be ellipsis glyph");
3615        let c5 = frame.buffer.get(5, 0).and_then(|c| c.content.as_char());
3616        assert_eq!(
3617            c5,
3618            Some(' '),
3619            "cell 5 should be trailing blank cell, not a split half glyph"
3620        );
3621    }
3622
3623    #[test]
3624    fn truncate_ellipsis_ascii_fallback() {
3625        // Theme preset TerminalClassic uses ASCII fallback "..." (width 3).
3626        // In a 5-wide column, "abcdef" with Ellipsis:
3627        // Budget = 5 - 3 = 2. Fits "ab" + "..." = "ab...".
3628        let theme = TableTheme::preset(TablePresetId::TerminalClassic);
3629        let table = Table::new([Row::new(["abcdef"])], [Constraint::Fixed(5)])
3630            .theme(theme)
3631            .with_column_truncation(0, Truncate::Ellipsis);
3632
3633        let area = Rect::new(0, 0, 5, 1);
3634        let mut pool = GraphemePool::new();
3635        let mut frame = Frame::new(5, 1, &mut pool);
3636        Widget::render(&table, area, &mut frame);
3637
3638        assert_eq!(raw_row_text(&frame.buffer, 0), "ab...");
3639    }
3640
3641    #[test]
3642    fn truncate_wrap_increases_row_height() {
3643        let theme = TableTheme::default().with_row_height(2);
3644        let table = Table::new([Row::new(["abcdefgh"])], [Constraint::Fixed(4)])
3645            .theme(theme.clone())
3646            .with_column_truncation(0, Truncate::Wrap);
3647
3648        let area = Rect::new(0, 0, 4, 3);
3649        let mut pool = GraphemePool::new();
3650        let mut frame = Frame::new(4, 3, &mut pool);
3651        Widget::render(&table, area, &mut frame);
3652
3653        assert_eq!(raw_row_text(&frame.buffer, 0), "abcd");
3654        assert_eq!(raw_row_text(&frame.buffer, 1), "efgh");
3655
3656        // Now test that longer text (12 chars) is capped at row_height = 2 lines
3657        let table_capped = Table::new([Row::new(["abcdefghijkl"])], [Constraint::Fixed(4)])
3658            .theme(theme)
3659            .with_column_truncation(0, Truncate::Wrap);
3660
3661        let mut frame2 = Frame::new(4, 3, &mut pool);
3662        Widget::render(&table_capped, area, &mut frame2);
3663        assert_eq!(raw_row_text(&frame2.buffer, 0), "abcd");
3664        assert_eq!(raw_row_text(&frame2.buffer, 1), "efgh");
3665        assert_eq!(raw_row_text(&frame2.buffer, 2), "    "); // Not rendered beyond row_height
3666    }
3667
3668    #[test]
3669    fn align_right_unicode_width() {
3670        // "12😀": "12" is 2 cells, "😀" is 2 cells. Total display width is 4.
3671        // Width 8, right-aligned: left offset is 8 - 4 = 4.
3672        // Cells 0..4 are blank, cell 4 is '1', cell 5 is '2', cell 6 is '😀', cell 7 is continuation/empty.
3673        let table = Table::new([Row::new(["12😀"])], [Constraint::Fixed(8)])
3674            .with_column_alignment(0, Alignment::Right);
3675
3676        let area = Rect::new(0, 0, 8, 1);
3677        let mut pool = GraphemePool::new();
3678        let mut frame = Frame::new(8, 1, &mut pool);
3679        Widget::render(&table, area, &mut frame);
3680
3681        for x in 0..4 {
3682            assert_eq!(
3683                cell_char(&frame.buffer, x, 0),
3684                Some(' '),
3685                "cell {x} should be blank"
3686            );
3687        }
3688        assert_eq!(cell_char(&frame.buffer, 4, 0), Some('1'));
3689        assert_eq!(cell_char(&frame.buffer, 5, 0), Some('2'));
3690        // Cell 6 holds the emoji grapheme
3691        assert!(
3692            frame
3693                .buffer
3694                .get(6, 0)
3695                .is_some_and(|c| c.content.is_grapheme())
3696        );
3697        // Cell 7 is the trailing cell of the 2-cell emoji
3698        assert!(
3699            frame
3700                .buffer
3701                .get(7, 0)
3702                .is_some_and(|c| c.content.is_continuation())
3703        );
3704    }
3705
3706    #[test]
3707    fn align_center_odd_padding() {
3708        // Width 7, text "ab" (width 2). Center offset = (7 - 2) / 2 = 2.
3709        let table = Table::new([Row::new(["ab"])], [Constraint::Fixed(7)])
3710            .with_column_alignment(0, Alignment::Center);
3711
3712        let area = Rect::new(0, 0, 7, 1);
3713        let mut pool = GraphemePool::new();
3714        let mut frame = Frame::new(7, 1, &mut pool);
3715        Widget::render(&table, area, &mut frame);
3716
3717        assert_eq!(cell_char(&frame.buffer, 0, 0), Some(' '));
3718        assert_eq!(cell_char(&frame.buffer, 1, 0), Some(' '));
3719        assert_eq!(cell_char(&frame.buffer, 2, 0), Some('a'));
3720        assert_eq!(cell_char(&frame.buffer, 3, 0), Some('b'));
3721        assert_eq!(cell_char(&frame.buffer, 4, 0), Some(' '));
3722        assert_eq!(cell_char(&frame.buffer, 5, 0), Some(' '));
3723        assert_eq!(cell_char(&frame.buffer, 6, 0), Some(' '));
3724    }
3725
3726    #[test]
3727    fn column_spec_out_of_range_is_ignored() {
3728        let table = Table::new(
3729            [Row::new(["c0", "c1"])],
3730            [Constraint::Fixed(5), Constraint::Fixed(5)],
3731        )
3732        .with_column_alignment(9, Alignment::Right);
3733
3734        let area = Rect::new(0, 0, 11, 1);
3735        let mut pool = GraphemePool::new();
3736        let mut frame = Frame::new(11, 1, &mut pool);
3737        // Should not panic and should render normally
3738        Widget::render(&table, area, &mut frame);
3739
3740        assert_eq!(cell_char(&frame.buffer, 0, 0), Some('c'));
3741        assert_eq!(cell_char(&frame.buffer, 1, 0), Some('0'));
3742    }
3743
3744    use proptest::prelude::*;
3745
3746    fn prop_unicode_strategy() -> impl Strategy<Value = String> {
3747        let ascii = "[a-zA-Z0-9 _-]{1,15}";
3748        let cjk = "[\\u{4e00}-\\u{4e20}]{1,6}";
3749        let emoji = prop_oneof![
3750            Just("😀".to_string()),
3751            Just("🎉".to_string()),
3752            Just("🚀".to_string()),
3753            Just("🦀".to_string()),
3754            Just("✨".to_string()),
3755        ];
3756        let part = prop_oneof![
3757            3 => ascii.prop_map(String::from),
3758            2 => cjk.prop_map(String::from),
3759            1 => emoji,
3760        ];
3761        proptest::collection::vec(part, 1..=4).prop_map(|parts| parts.concat())
3762    }
3763
3764    proptest! {
3765        #![proptest_config(ProptestConfig::with_cases(256))]
3766        #[test]
3767        fn prop_truncation_never_exceeds_width(
3768            s in prop_unicode_strategy(),
3769            w in 1u16..=20u16,
3770            mode_idx in 0u8..3u8,
3771        ) {
3772            let mode = match mode_idx {
3773                0 => Truncate::Clip,
3774                1 => Truncate::Ellipsis,
3775                _ => Truncate::Wrap,
3776            };
3777
3778            let table = Table::new([Row::new([s])], [Constraint::Fixed(w)])
3779                .with_column_truncation(0, mode);
3780
3781            let area = Rect::new(0, 0, w + 4, 3);
3782            let mut pool = GraphemePool::new();
3783            let mut frame = Frame::new(w + 4, 3, &mut pool);
3784            Widget::render(&table, area, &mut frame);
3785
3786            for y in 0..3 {
3787                for x in w..frame.buffer.width() {
3788                    let ch = frame.buffer.get(x, y).and_then(|c| c.content.as_char());
3789                    prop_assert!(ch.is_none() || ch == Some(' '));
3790                }
3791            }
3792        }
3793    }
3794
3795    #[test]
3796    fn table_with_stylesheet_maps_roles() {
3797        let sheet = StyleSheet::new();
3798        let yellow = PackedRgba::rgb(255, 255, 0);
3799        let grey = PackedRgba::rgb(128, 128, 128);
3800
3801        sheet.define("table.header", Style::new().bold());
3802        sheet.define("table.row_alt", Style::new().fg(yellow));
3803        sheet.define("table.divider", Style::new().fg(grey));
3804
3805        let rows = [Row::new(["A"]), Row::new(["B"]), Row::new(["C"])];
3806        let widths = [Constraint::Fixed(10)];
3807        let table = Table::new(rows, widths)
3808            .header(Row::new(["H"]))
3809            .with_stylesheet(&sheet);
3810
3811        let area = Rect::new(0, 0, 10, 5);
3812        let mut pool = GraphemePool::new();
3813        let mut frame = Frame::new(10, 5, &mut pool);
3814        Widget::render(&table, area, &mut frame);
3815
3816        // Header at y=0 is bold
3817        let header_cell = frame.buffer.get(0, 0).unwrap();
3818        assert!(
3819            header_cell
3820                .attrs
3821                .has_flag(ftui_render::cell::StyleFlags::BOLD)
3822        );
3823
3824        // Row 1 (first body row, y=1) has default row style
3825        // Row 2 (second body row, y=2) has yellow fg
3826        let row1_cell = frame.buffer.get(0, 2).unwrap();
3827        assert_eq!(row1_cell.fg, yellow);
3828
3829        // Undefined role (e.g. row_selected) equals default theme value
3830        assert_eq!(
3831            table.table_theme().row_selected,
3832            TableTheme::default().row_selected
3833        );
3834    }
3835
3836    #[test]
3837    fn table_stylesheet_prefix_isolates() {
3838        let sheet = StyleSheet::new();
3839        let cyan = PackedRgba::rgb(0, 255, 255);
3840        let magenta = PackedRgba::rgb(255, 0, 255);
3841
3842        sheet.define("tools.header", Style::new().fg(cyan));
3843        sheet.define("logs.header", Style::new().fg(magenta));
3844
3845        let rows1 = [Row::new(["A"])];
3846        let rows2 = [Row::new(["B"])];
3847        let widths = [Constraint::Fixed(10)];
3848
3849        let t1 = Table::new(rows1, widths)
3850            .header(Row::new(["H1"]))
3851            .with_stylesheet_prefix(&sheet, "tools");
3852
3853        let t2 = Table::new(rows2, widths)
3854            .header(Row::new(["H2"]))
3855            .with_stylesheet_prefix(&sheet, "logs");
3856
3857        assert_eq!(t1.table_theme().header.fg, Some(cyan));
3858        assert_eq!(t2.table_theme().header.fg, Some(magenta));
3859    }
3860
3861    #[test]
3862    fn table_stylesheet_missing_roles_keep_theme() {
3863        let sheet = StyleSheet::new();
3864        sheet.define("table.header", Style::new().bold());
3865
3866        let rows = [Row::new(["A"])];
3867        let widths = [Constraint::Fixed(10)];
3868        let table = Table::new(rows, widths).with_stylesheet(&sheet);
3869
3870        let default_theme = TableTheme::default();
3871        assert_eq!(table.table_theme().border, default_theme.border);
3872        assert_eq!(table.table_theme().row, default_theme.row);
3873        assert_eq!(table.table_theme().row_alt, default_theme.row_alt);
3874        assert_eq!(table.table_theme().row_selected, default_theme.row_selected);
3875        assert_eq!(table.table_theme().row_hover, default_theme.row_hover);
3876        assert_eq!(table.table_theme().divider, default_theme.divider);
3877    }
3878}