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