Struct Table 

pub struct Table<'a, TData> { /* private fields */ }

Implementations

impl<'a, TData> Table<'a, TData>

pub fn builder(data: &'a [TData]) -> TableBuilder<'a, TData>

pub fn data(&self) -> &'a [TData]

pub fn columns(&self) -> &[ColumnDef<TData>]

pub fn render_fallback_value(&self) -> &TanStackValue

TanStack-aligned: options.renderFallbackValue used by cell.renderValue().

pub fn column_tree(&self) -> &[ColumnDef<TData>]

pub fn column(&self, id: &str) -> Option<&ColumnDef<TData>>

pub fn cell_value( &self, row_key: RowKey, column_id: &str, ) -> Option<TanStackValue>

TanStack-aligned: cell.getValue() equivalent for the current row model.

This returns a [TanStackValue] representation and currently uses the column’s sort_value accessor when available.

pub fn cell_render_value( &self, row_key: RowKey, column_id: &str, ) -> Option<TanStackValue>

TanStack-aligned: cell.renderValue() equivalent: getValue() ?? renderFallbackValue.

pub fn row_unique_values( &self, row_key: RowKey, column_id: &str, ) -> Option<Vec<TanStackValue>>

TanStack-aligned: row.getUniqueValues(columnId) for a leaf row in the core row model.

Notes:

• If column.unique_values_fn is configured, it is used (matches TanStack columnDef.getUniqueValues).
• Otherwise, returns a single-element array containing getValue(columnId).
• If the column has no value source in the Rust engine, this returns None.

pub fn row(&self, row_key: RowKey, search_all: bool) -> Option<&Row<'a, TData>>

TanStack-aligned: resolve a row by id, optionally searching outside the current paginated row model (e.g. pinned rows).

pub fn row_by_id( &self, row_id: &str, search_all: bool, ) -> Option<&Row<'a, TData>>

TanStack-aligned: resolve a row by string id, optionally searching outside the current paginated row model.

pub fn row_key_for_id(&self, row_id: &str, search_all: bool) -> Option<RowKey>

pub fn row_id_for_key(&self, row_key: RowKey) -> Option<RowId>

pub fn cell_context( &self, row_key: RowKey, column_id: &str, ) -> Option<CellContextSnapshot>

Rust-native equivalent of TanStack cell.getContext().

pub fn state(&self) -> &TableState

pub fn options(&self) -> TableOptions

pub fn column_visibility(&self) -> &HashMap<Arc<str>, bool>

pub fn is_column_visible(&self, column_id: &str) -> Option<bool>

pub fn column_can_hide(&self, column_id: &str) -> Option<bool>

pub fn all_flat_columns(&self) -> Vec<&ColumnDef<TData>>

TanStack-aligned: table.getAllFlatColumns().

This returns the full column tree in a pre-order DFS flattening (column, then its descendants). It does not apply columnOrder reordering, matching upstream semantics.

pub fn visible_flat_columns(&self) -> Vec<&ColumnDef<TData>>

TanStack-aligned: table.getVisibleFlatColumns().

Visibility rules match TanStack:

• leaf columns consult state.column_visibility (default visible),
• group columns are visible if any descendant is visible.

pub fn hideable_columns(&self) -> Vec<&ColumnDef<TData>>

pub fn is_all_columns_visible(&self) -> bool

pub fn is_some_columns_visible(&self) -> bool

pub fn toggled_column_visibility( &self, column_id: &str, visible: Option<bool>, ) -> Option<HashMap<Arc<str>, bool>>

pub fn toggled_all_columns_visible( &self, visible: Option<bool>, ) -> HashMap<Arc<str>, bool>

pub fn is_some_rows_expanded(&self) -> bool

pub fn toggled_all_rows_expanded(&self, value: Option<bool>) -> ExpandingState

pub fn toggled_row_expanded( &self, row_key: RowKey, value: Option<bool>, ) -> ExpandingState

pub fn row_expanding_updater( &self, row_key: RowKey, value: Option<bool>, ) -> Updater<ExpandingState>

pub fn row_expanding_updater_by_id( &self, row_id: &str, search_all: bool, value: Option<bool>, ) -> Option<Updater<ExpandingState>>

pub fn toggled_row_expanded_by_id( &self, row_id: &str, search_all: bool, value: Option<bool>, ) -> Option<ExpandingState>

pub fn should_auto_reset_expanded(&self) -> bool

TanStack-aligned: autoResetAll ?? autoResetExpanded ?? !manualExpanding.

pub fn reset_expanded(&self, default_state: bool) -> ExpandingState

TanStack-aligned: table.resetExpanded(defaultState?).

pub fn should_auto_reset_page_index(&self) -> bool

TanStack-aligned: autoResetAll ?? autoResetPageIndex ?? !manualPagination.

pub fn reset_page_index(&self, default_state: bool) -> PaginationState

TanStack-aligned: table.resetPageIndex(defaultState?).

pub fn reset_page_size(&self, default_state: bool) -> PaginationState

TanStack-aligned: table.resetPageSize(defaultState?).

pub fn reset_pagination(&self, default_state: bool) -> PaginationState

TanStack-aligned: table.resetPagination(defaultState?).

pub fn set_page_index(&self, page_index: i32) -> PaginationState

TanStack-aligned: table.setPageIndex(updater), with clamping based on options.pageCount.

pub fn pagination_updater_set_page_index( &self, page_index: i32, ) -> Updater<PaginationState>

pub fn set_page_size(&self, page_size: i32) -> PaginationState

TanStack-aligned: table.setPageSize(updater).

pub fn pagination_updater_set_page_size( &self, page_size: i32, ) -> Updater<PaginationState>

pub fn previous_page(&self) -> PaginationState

TanStack-aligned: table.previousPage().

pub fn next_page(&self) -> PaginationState

TanStack-aligned: table.nextPage().

pub fn first_page(&self) -> PaginationState

TanStack-aligned: table.firstPage().

pub fn last_page(&self) -> PaginationState

TanStack-aligned: table.lastPage().

pub fn row_count(&self) -> usize

TanStack-aligned: table.getRowCount().

pub fn page_count(&self) -> i32

TanStack-aligned: table.getPageCount().

pub fn can_previous_page(&self) -> bool

TanStack-aligned: table.getCanPreviousPage().

pub fn can_next_page(&self) -> bool

TanStack-aligned: table.getCanNextPage().

pub fn page_options(&self) -> Vec<usize>

TanStack-aligned: table.getPageOptions().

pub fn grouping(&self) -> &Vec<Arc<str>>

pub fn column_can_group(&self, column_id: &str) -> Option<bool>

pub fn is_column_grouped(&self, column_id: &str) -> Option<bool>

pub fn column_grouped_index(&self, column_id: &str) -> Option<usize>

pub fn toggled_column_grouping( &self, column_id: &str, grouped: Option<bool>, ) -> Option<Vec<Arc<str>>>

pub fn grouping_updater( &self, column_id: &str, grouped: Option<bool>, ) -> Option<Updater<Vec<Arc<str>>>>

TanStack-aligned: compute the Updater that a controlled onGroupingChange hook would receive for a “toggle this column” interaction.

pub fn grouping_handler_updater( &self, column_id: &str, ) -> Option<Updater<Vec<Arc<str>>>>

TanStack-aligned: compute the Updater that a controlled onGroupingChange hook would receive for a getToggleGroupingHandler() interaction.

pub fn pre_grouped_row_model(&self) -> &RowModel<'a, TData>

pub fn grouped_row_model(&self) -> &GroupedRowModel

pub fn grouped_u64_aggregations( &self, ) -> &HashMap<RowKey, Arc<[(Arc<str>, u64)]>>

pub fn grouped_aggregations_any( &self, ) -> &HashMap<RowKey, Arc<[(Arc<str>, TanStackValue)]>>

pub fn is_all_rows_expanded(&self) -> bool

pub fn can_some_rows_expand(&self) -> bool

pub fn expanded_depth(&self) -> u16

pub fn row_can_expand(&self, row_key: RowKey) -> bool

pub fn row_is_all_parents_expanded(&self, row_key: RowKey) -> bool

pub fn is_some_rows_pinned(&self, position: Option<RowPinPosition>) -> bool

pub fn reset_row_pinning(&self, default_state: bool) -> RowPinningState

TanStack-aligned: table.resetRowPinning(defaultState?).

pub fn is_some_columns_pinned( &self, position: Option<ColumnPinPosition>, ) -> bool

pub fn reset_column_pinning(&self, default_state: bool) -> ColumnPinningState

TanStack-aligned: table.resetColumnPinning(defaultState?).

pub fn reset_row_selection(&self, default_state: bool) -> HashSet<RowKey>

TanStack-aligned: table.resetRowSelection(defaultState?).

pub fn reset_sorting(&self, default_state: bool) -> Vec<SortSpec>

TanStack-aligned: table.resetSorting(defaultState?).

pub fn tanstack_sorted_flat_row_order_with_cache( &self, items_revision: u64, cache: &mut TanStackSortedFlatRowOrderCache, ) -> (Arc<[FlatRowOrderEntry]>, bool)

Returns a stable, memoized ordering of the root row list after filtering + sorting.

This helper exists to support “rebuild each frame” callers: they can rebuild a fresh Table while keeping a persistent memo cache (TanStack-style) outside the ephemeral instance.

Notes:

• The returned ordering is based on the flat core row model (no grouping, no sub-rows).
• Cache invalidation is driven by items_revision plus a dependency snapshot derived from state, options, and the configured column/filter/sort surfaces.

pub fn tanstack_ungrouped_row_model_order_with_cache( &self, items_revision: u64, cache: &mut TanStackUngroupedRowModelOrderCache, ) -> Option<(Arc<TanStackRowModelOrderSnapshot>, bool)>

Returns the final ungrouped row-model ordering (rows + flatRows) with a persistent external memo cache.

This helper exists to support “rebuild each frame” callers: they can rebuild a fresh Table every frame while keeping a persistent memo cache (TanStack-style) outside the ephemeral instance.

Returns None when grouping is active, since grouped row models contain non-core rows (group headers) whose stable-key strategy is a separate concern.

pub fn column_can_sort(&self, column_id: &str) -> Option<bool>

TanStack-aligned: column.getCanSort().

pub fn column_can_multi_sort(&self, column_id: &str) -> Option<bool>

TanStack-aligned: column.getCanMultiSort().

pub fn column_auto_sort_dir_desc_tanstack( &self, column_id: &str, ) -> Option<bool>

TanStack-aligned: column.getAutoSortDir().

Returns true for desc and false for asc.

pub fn column_first_sort_dir_desc_tanstack( &self, column_id: &str, ) -> Option<bool>

TanStack-aligned: column.getFirstSortDir().

Returns true for desc and false for asc. Returns None when we cannot infer the direction (because the column has neither an explicit sortDescFirst override nor a stable sort_value_by surface for auto inference).

pub fn column_next_sorting_order_desc_tanstack( &self, column_id: &str, multi: bool, ) -> Option<Option<bool>>

TanStack-aligned: column.getNextSortingOrder(multi?).

Returns:

• Some(Some(true)) => 'desc'
• Some(Some(false)) => 'asc'
• Some(None) => false (remove)
• None => unknown column id

pub fn cleared_column_sorting(&self, column_id: &str) -> Option<Vec<SortSpec>>

TanStack-aligned: column.clearSorting().

pub fn column_is_sorted(&self, column_id: &str) -> Option<bool>

TanStack-aligned: column.getIsSorted() (boolean form).

pub fn column_sort_index(&self, column_id: &str) -> Option<i32>

TanStack-aligned: column.getSortIndex().

Returns -1 when the column is not currently sorted. Returns None when the column id does not exist.

pub fn sorting_updater_tanstack( &self, column_id: &str, multi: bool, auto_sort_dir_desc: bool, ) -> Option<Updater<Vec<SortSpec>>>

TanStack-aligned sorting state transition for column.toggleSorting(...).

This models the “direct toggle” policy (see sorting.rs::toggle_sorting_tanstack).

pub fn sorting_handler_updater_tanstack( &self, column_id: &str, event_multi: bool, auto_sort_dir_desc: bool, ) -> Option<Updater<Vec<SortSpec>>>

TanStack-aligned sorting state transition for column.getToggleSortingHandler().

This models the “handler” policy (including getCanSort gating), aligning with sorting.rs::toggle_sorting_handler_tanstack.

pub fn toggled_column_sorting_tanstack( &self, column_id: &str, multi: bool, auto_sort_dir_desc: bool, ) -> Option<Vec<SortSpec>>

Convenience: apply Self::sorting_updater_tanstack to the current sorting state.

pub fn toggled_column_sorting_handler_tanstack( &self, column_id: &str, event_multi: bool, auto_sort_dir_desc: bool, ) -> Option<Vec<SortSpec>>

Convenience: apply Self::sorting_handler_updater_tanstack to the current sorting state.

pub fn reset_column_filters(&self, default_state: bool) -> Vec<ColumnFilter>

TanStack-aligned: table.resetColumnFilters(defaultState?).

pub fn reset_global_filter(&self, default_state: bool) -> Option<Value>

TanStack-aligned: table.resetGlobalFilter(defaultState?).

pub fn column_can_filter(&self, column_id: &str) -> Option<bool>

pub fn column_filter_value(&self, column_id: &str) -> Option<&Value>

pub fn column_is_filtered(&self, column_id: &str) -> Option<bool>

pub fn column_filter_index(&self, column_id: &str) -> Option<i32>

TanStack-aligned: column.getFilterIndex().

Returns -1 when the column is not currently filtered. Returns None when the column id does not exist.

pub fn column_filters_updater_set_value( &self, column_id: &str, value: Value, ) -> Option<Updater<Vec<ColumnFilter>>>

TanStack-aligned: column.setFilterValue(value) as a state updater.

pub fn global_filter_updater_set_value( &self, value: Option<Value>, ) -> Updater<Option<Value>>

TanStack-aligned: table.setGlobalFilter(value) as a state updater.

pub fn column_can_global_filter(&self, column_id: &str) -> Option<bool>

TanStack-aligned: column.getCanGlobalFilter().

pub fn reset_grouping(&self, default_state: bool) -> Vec<Arc<str>>

TanStack-aligned: table.resetGrouping(defaultState?).

pub fn reset_column_visibility( &self, default_state: bool, ) -> HashMap<Arc<str>, bool>

TanStack-aligned: table.resetColumnVisibility(defaultState?).

pub fn reset_column_order(&self, default_state: bool) -> Vec<Arc<str>>

TanStack-aligned: table.resetColumnOrder(defaultState?).

pub fn row_is_pinned(&self, row_key: RowKey) -> Option<RowPinPosition>

pub fn row_pinned_index(&self, row_key: RowKey) -> Option<i32>

TanStack-aligned: row.getPinnedIndex().

Returns -1 when the row is not currently visible in its pinned region. Returns None when the row key does not exist.

pub fn row_can_pin(&self, row_key: RowKey) -> Option<bool>

pub fn row_pinning_updater( &self, row_key: RowKey, position: Option<RowPinPosition>, include_leaf_rows: bool, include_parent_rows: bool, ) -> Updater<RowPinningState>

pub fn row_pinning_updater_by_id( &self, row_id: &str, search_all: bool, position: Option<RowPinPosition>, include_leaf_rows: bool, include_parent_rows: bool, ) -> Option<Updater<RowPinningState>>

pub fn top_row_keys(&self) -> Vec<RowKey>

pub fn top_row_ids(&self) -> Vec<RowId>

pub fn bottom_row_keys(&self) -> Vec<RowKey>

pub fn bottom_row_ids(&self) -> Vec<RowId>

pub fn center_row_keys(&self) -> Vec<RowKey>

pub fn center_row_ids(&self) -> Vec<RowId>

pub fn ordered_columns(&self) -> Vec<&ColumnDef<TData>>

pub fn column_order(&self) -> &Vec<Arc<str>>

pub fn column_pinning(&self) -> &ColumnPinningState

pub fn column_can_order(&self, column_id: &str) -> Option<bool>

pub fn column_can_pin(&self, column_id: &str) -> Option<bool>

pub fn column_pin_position(&self, column_id: &str) -> Option<ColumnPinPosition>

pub fn column_pinned_index(&self, column_id: &str) -> Option<i32>

TanStack-aligned: column.getPinnedIndex().

Returns 0 for unpinned columns (matching TanStack). Returns -1 when the column is pinned via a group column but the group id is not present in the leaf-pinning state arrays.

pub fn column_pinning_updater( &self, column_id: &str, position: Option<ColumnPinPosition>, ) -> Option<Updater<ColumnPinningState>>

pub fn toggled_column_order_move( &self, column_id: &str, to_index: usize, ) -> Option<Vec<Arc<str>>>

pub fn toggled_column_pinning( &self, column_id: &str, position: Option<ColumnPinPosition>, ) -> Option<ColumnPinningState>

pub fn visible_columns(&self) -> Vec<&ColumnDef<TData>>

pub fn header_groups(&self) -> Vec<HeaderGroupSnapshot>

pub fn left_header_groups(&self) -> Vec<HeaderGroupSnapshot>

pub fn center_header_groups(&self) -> Vec<HeaderGroupSnapshot>

pub fn right_header_groups(&self) -> Vec<HeaderGroupSnapshot>

pub fn footer_groups(&self) -> Vec<HeaderGroupSnapshot>

pub fn left_footer_groups(&self) -> Vec<HeaderGroupSnapshot>

pub fn center_footer_groups(&self) -> Vec<HeaderGroupSnapshot>

pub fn right_footer_groups(&self) -> Vec<HeaderGroupSnapshot>

pub fn flat_headers(&self) -> Vec<HeaderSnapshot>

pub fn left_flat_headers(&self) -> Vec<HeaderSnapshot>

pub fn center_flat_headers(&self) -> Vec<HeaderSnapshot>

pub fn right_flat_headers(&self) -> Vec<HeaderSnapshot>

pub fn left_leaf_headers(&self) -> Vec<HeaderSnapshot>

pub fn center_leaf_headers(&self) -> Vec<HeaderSnapshot>

pub fn right_leaf_headers(&self) -> Vec<HeaderSnapshot>

pub fn leaf_headers(&self) -> Vec<HeaderSnapshot>

TanStack-style getLeafHeaders (postorder traversal from top headers).

pub fn row_cells(&self, row_key: RowKey) -> Option<RowCellsSnapshot>

pub fn core_model_snapshot(&self) -> CoreModelSnapshot

pub fn pinned_visible_columns( &self, ) -> (Vec<&ColumnDef<TData>>, Vec<&ColumnDef<TData>>, Vec<&ColumnDef<TData>>)

pub fn pinned_leaf_columns( &self, ) -> (Vec<&ColumnDef<TData>>, Vec<&ColumnDef<TData>>, Vec<&ColumnDef<TData>>)

TanStack-aligned: table.getLeft/Center/RightLeafColumns().

Note: this returns leaf columns split by pinning state and does not apply column visibility filtering. Use Self::pinned_visible_columns for visible-only splits.

pub fn left_leaf_columns(&self) -> Vec<&ColumnDef<TData>>

pub fn center_leaf_columns(&self) -> Vec<&ColumnDef<TData>>

pub fn right_leaf_columns(&self) -> Vec<&ColumnDef<TData>>

pub fn column_size(&self, id: &str) -> Option<f32>

pub fn column_sizing(&self) -> &HashMap<Arc<str>, f32>

pub fn column_sizing_info(&self) -> &ColumnSizingInfoState

pub fn column_can_resize(&self, id: &str) -> Option<bool>

pub fn is_column_resizing(&self, id: &str) -> Option<bool>

pub fn reset_column_size(&self, id: &str) -> Option<HashMap<Arc<str>, f32>>

TanStack-aligned: remove an override size entry (falls back to column defaults).

pub fn reset_column_sizing(&self, default_state: bool) -> HashMap<Arc<str>, f32>

TanStack-aligned: table.resetColumnSizing(defaultState?).

pub fn reset_header_size_info( &self, default_state: bool, ) -> ColumnSizingInfoState

TanStack-aligned: table.resetHeaderSizeInfo(defaultState?) (columnSizingInfo reset).

pub fn started_column_resize( &self, id: &str, pointer_x: f32, ) -> Option<ColumnSizingInfoState>

pub fn dragged_column_resize( &self, pointer_x: f32, ) -> (HashMap<Arc<str>, f32>, ColumnSizingInfoState)

pub fn ended_column_resize( &self, pointer_x: Option<f32>, ) -> (HashMap<Arc<str>, f32>, ColumnSizingInfoState)

pub fn total_size(&self) -> f32

pub fn pinned_total_sizes(&self) -> (f32, f32, f32)

pub fn left_total_size(&self) -> f32

pub fn center_total_size(&self) -> f32

pub fn right_total_size(&self) -> f32

pub fn column_start( &self, column_id: &str, region: ColumnSizingRegion, ) -> Option<f32>

TanStack-aligned: return the start offset (x) for a column within a sizing region.

Notes:

• For All, this is column.getStart() over TanStack’s _getVisibleLeafColumns(table).
• For Left/Center/Right, this corresponds to column.getStart(position) with fixture parity gating that only records values for columns that are pinned to that region (or are in the center region).
• When the column is not present in the visible list for the given region (e.g. hidden), TanStack’s getIndex returns -1, which results in slice(0, -1) behavior. We mirror that by summing all but the last column in that region for start, and summing the entire region for after.

pub fn column_after( &self, column_id: &str, region: ColumnSizingRegion, ) -> Option<f32>

TanStack-aligned: return the after offset (remaining width) for a column within a sizing region.

pub fn header_size(&self, header_id: &str) -> Option<f32>

TanStack-aligned: header.getSize() for header groups (including placeholder headers).

pub fn header_start(&self, header_id: &str) -> Option<f32>

TanStack-aligned: header.getStart() computed within its header group.

pub fn core_row_model(&self) -> &RowModel<'a, TData>

pub fn pre_filtered_row_model(&self) -> &RowModel<'a, TData>

pub fn filtered_row_model(&self) -> &RowModel<'a, TData>

pub fn row_filter_state_snapshot(&self) -> RowFilterStateSnapshot

pub fn pre_sorted_row_model(&self) -> &RowModel<'a, TData>

pub fn sorted_row_model(&self) -> &RowModel<'a, TData>

pub fn pre_pagination_row_model(&self) -> &RowModel<'a, TData>

pub fn pre_expanded_row_model(&self) -> &RowModel<'a, TData>

pub fn expanded_row_model(&self) -> &RowModel<'a, TData>

pub fn row_model(&self) -> &RowModel<'a, TData>

pub fn pre_selected_row_model(&self) -> &RowModel<'a, TData>

pub fn selected_row_model(&self) -> &RowModel<'a, TData>

pub fn filtered_selected_row_model(&self) -> &RowModel<'a, TData>

pub fn grouped_selected_row_model(&self) -> &RowModel<'a, TData>

pub fn page_selected_row_model(&self) -> &RowModel<'a, TData>

pub fn row_is_selected(&self, row_key: RowKey) -> bool

pub fn row_is_some_selected(&self, row_key: RowKey) -> bool

pub fn row_is_all_sub_rows_selected(&self, row_key: RowKey) -> bool

pub fn row_selection_updater( &self, row_key: RowKey, value: Option<bool>, select_children: bool, ) -> Updater<HashSet<RowKey>>

pub fn row_selection_updater_by_id( &self, row_id: &str, search_all: bool, value: Option<bool>, select_children: bool, ) -> Option<Updater<HashSet<RowKey>>>

pub fn toggled_row_selected_by_id( &self, row_id: &str, search_all: bool, value: Option<bool>, select_children: bool, ) -> Option<HashSet<RowKey>>

pub fn toggled_row_selected( &self, row_key: RowKey, value: Option<bool>, select_children: bool, ) -> HashSet<RowKey>

pub fn is_all_rows_selected(&self) -> bool

pub fn is_some_rows_selected(&self) -> bool

pub fn is_all_page_rows_selected(&self) -> bool

pub fn is_some_page_rows_selected(&self) -> bool

pub fn filtered_row_count(&self) -> usize

pub fn filtered_flat_row_count(&self) -> usize

pub fn filtered_selected_row_count(&self) -> usize

pub fn filtered_selected_flat_row_count(&self) -> usize

pub fn row_can_select(&self, row_key: RowKey) -> bool

TanStack-aligned: row.getCanSelect().

pub fn row_can_multi_select(&self, row_key: RowKey) -> bool

TanStack-aligned: row.getCanMultiSelect().

pub fn row_can_select_sub_rows(&self, row_key: RowKey) -> bool

TanStack-aligned: row.getCanSelectSubRows().

pub fn row_can_select_by_id( &self, row_id: &str, search_all: bool, ) -> Option<bool>

pub fn row_can_multi_select_by_id( &self, row_id: &str, search_all: bool, ) -> Option<bool>

pub fn row_can_select_sub_rows_by_id( &self, row_id: &str, search_all: bool, ) -> Option<bool>

pub fn toggled_all_rows_selected(&self, value: Option<bool>) -> HashSet<RowKey>

pub fn toggled_all_page_rows_selected( &self, value: Option<bool>, ) -> HashSet<RowKey>

pub fn faceted_row_model(&self, column_id: &str) -> Option<&RowModel<'a, TData>>

pub fn faceted_unique_values( &self, column_id: &str, ) -> Option<&HashMap<u64, usize>>

pub fn faceted_unique_value_labels( &self, column_id: &str, ) -> Option<&HashMap<u64, &'a str>>

pub fn faceted_min_max_u64(&self, column_id: &str) -> Option<(u64, u64)>

pub fn global_faceted_row_model(&self) -> &RowModel<'a, TData>

TanStack-aligned: table.getGlobalFacetedRowModel().

Notes:

• Matches upstream behavior by returning pre_filtered_row_model() when manualFiltering=true.
• When no override is provided, this defaults to filtered_row_model() (which already respects manualFiltering).

pub fn global_faceted_unique_values(&self) -> &HashMap<u64, usize>

TanStack-aligned: table.getGlobalFacetedUniqueValues().

Notes:

• Upstream does not gate this by manualFiltering; only the row model surface is gated.

pub fn global_faceted_min_max_u64(&self) -> Option<(u64, u64)>

TanStack-aligned: table.getGlobalFacetedMinMaxValues() (u64-only mapping).

Notes:

• Upstream does not gate this by manualFiltering; only the row model surface is gated.

impl<'a, TData> Table<'a, TData>

pub fn column_any(&self, column_id: &str) -> Option<&ColumnDef<TData>>

TanStack-aligned: table.getColumn(columnId).

Note: unlike Self::column, this searches the full column tree and can return group columns as well as leaf columns.

pub fn column_tree_snapshot(&self) -> Vec<ColumnNodeSnapshot>

TanStack-aligned: table.getAllColumns() snapshot surface.

pub fn column_node_snapshot( &self, column_id: &str, ) -> Option<ColumnNodeSnapshot>

TanStack-aligned: table.getColumn(columnId) structural snapshot.