@perspective-dev/viewer 5.3.1 → 5.5.0

package/src/rust/components/viewer/panels.rs

@@ -33,7 +33,7 @@ use crate::renderer::Renderer;
 use crate::session::*;
 use crate::tasks::*;
 use crate::utils::{Completion, spawn_owned};
-use crate::workspace::PanelId;
+use crate::workspace::{Panel, PanelId};
 
 impl PerspectiveViewer {
     pub(super) fn on_layout_changed(&mut self, ctx: &Context<Self>) -> bool {
@@ -136,16 +136,11 @@ impl PerspectiveViewer {
         true
     }
 
-    pub(super) fn on_close_panel(
-        &mut self,
-        ctx: &Context<Self>,
-        id: String,
-        completion: Option<Completion>,
-    ) -> bool {
-        let id = PanelId::from(id);
-
-        let was_active = ctx.props().workspace.active_id().as_ref() == Some(&id);
-        let removed = ctx.props().workspace.remove_panel(&id);
+    /// Remove `id` from the workspace and return the detached [`Panel`] with
+    /// its engines still alive, or `None` for an unknown id.
+    fn detach_panel(&mut self, ctx: &Context<Self>, id: &PanelId) -> Option<Panel> {
+        let was_active = ctx.props().workspace.active_id().as_ref() == Some(id);
+        let removed = ctx.props().workspace.remove_panel(id)?;
         if was_active {
             if let Some(next) = ctx.props().workspace.panel_ids().first().cloned() {
                 ctx.props().workspace.set_active(next);
@@ -164,19 +159,55 @@ impl PerspectiveViewer {
             self.retarget_active(ctx, new_session, new_renderer);
         }
 
-        let eject = removed.map(eject_panel);
-        match (eject, completion) {
-            (Some(eject), Some(completion)) => completion.resolve_after(eject),
-            (Some(eject), None) => spawn_owned("close-panel", eject),
-            (None, Some(completion)) => completion.resolve_after(async { Ok(()) }),
-            (None, None) => {},
-        }
-
         apply_global_filters(&ctx.props().workspace);
         self._title_subscriptions = subscribe_panel_titles(ctx);
+        Some(removed)
+    }
+
+    pub(super) fn on_close_panel(
+        &mut self,
+        ctx: &Context<Self>,
+        id: String,
+        completion: Option<Completion>,
+    ) -> bool {
+        let id = PanelId::from(id);
+        let Some(removed) = self.detach_panel(ctx, &id) else {
+            if let Some(completion) = completion {
+                completion.resolve_after(async { Ok(()) });
+            }
+
+            return false;
+        };
+
+        ctx.props().workspace.stash_closing(removed);
+        if let Some(completion) = completion {
+            self.pending_closes.insert(id, completion);
+        }
+
         true
     }
 
+    pub(super) fn on_panel_closed(&mut self, ctx: &Context<Self>, id: String) -> bool {
+        let id = PanelId::from(id);
+        if let Some(panel) = ctx.props().workspace.take_closing(&id) {
+            let eject = eject_panel(panel);
+            match self.pending_closes.remove(&id) {
+                Some(completion) => completion.resolve_after(eject),
+                None => spawn_owned("close-panel", eject),
+            }
+
+            return false;
+        }
+
+        match self.detach_panel(ctx, &id) {
+            Some(panel) => {
+                spawn_owned("close-panel", eject_panel(panel));
+                true
+            },
+            None => false,
+        }
+    }
+
     pub(super) fn on_duplicate_panel(&mut self, ctx: &Context<Self>, id: String) -> bool {
         if let Some(panel) = ctx.props().workspace.panel(&PanelId::from(id)) {
             let elem = ctx.props().elem.clone();
@@ -204,6 +235,7 @@ impl PerspectiveViewer {
                     None,
                     update,
                     client,
+                    crate::session::MissingTable::Error,
                 )
                 .await?;
 
@@ -238,6 +270,7 @@ impl PerspectiveViewer {
                     None,
                     ViewerConfigInitial::new(table_name),
                     client,
+                    crate::session::MissingTable::Error,
                 )
                 .await?;
 
@@ -282,6 +315,7 @@ impl PerspectiveViewer {
                 None,
                 ViewerConfigInitial::new(table),
                 Some(client),
+                crate::session::MissingTable::Error,
             )
             .await?;
 

package/src/rust/components/viewer/render.rs

@@ -22,15 +22,15 @@ use yew::prelude::*;
 
 use super::PerspectiveViewer;
 use super::msg::PerspectiveViewerMsg::*;
+use super::msg::{Divider, PaneTarget};
 use crate::components::column_settings_sidebar::ColumnSettingsPanel;
-use crate::components::containers::split_panel::SplitPanel;
-use crate::components::font_loader::FontLoader;
 use crate::components::main_panel::MainPanel;
 use crate::components::panel_menu::PanelCommand;
 use crate::components::settings_panel::SettingsPanel;
-use crate::components::style::StyleProvider;
+use crate::components::style::StyleSurface;
 use crate::queries::*;
 use crate::session::TableLoadState;
+use crate::ui::{FontLoader, SplitPanel, StyleProvider};
 
 impl PerspectiveViewer {
     pub(super) fn render(&self, ctx: &Context<Self>) -> Html {
@@ -58,10 +58,6 @@ impl PerspectiveViewer {
             toggle: true,
         });
 
-        let on_column_settings_panel_resize = ctx
-            .link()
-            .callback(|(x, _)| ColumnSettingsPanelSizeUpdate(Some(x)));
-
         let on_close_settings = ctx
             .link()
             .callback(|()| ToggleSettingsInit(None, true, None));
@@ -99,6 +95,7 @@ impl PerspectiveViewer {
                     plugin_static_config={self.renderer_props.config.clone()}
                     {view_config}
                     plugin_config={self.renderer_props.plugin_config.clone()}
+                    columns_config={self.renderer_props.columns_config.clone()}
                     {drag_column}
                     metadata={metadata.clone()}
                     open_column_settings={self.presentation_props.open_column_settings.clone()}
@@ -135,9 +132,12 @@ impl PerspectiveViewer {
                     id="modal_panel"
                     class={classes!(is_pinned.then_some("pinned"))}
                     reverse=true
+                    deferred={is_pinned}
+                    size={self.settings_geometry.column_settings_width_override}
                     initial_size={self.settings_geometry.column_settings_width_override}
-                    on_reset={ctx.link().callback(|_| ColumnSettingsPanelSizeUpdate(None))}
-                    on_resize={on_column_settings_panel_resize}
+                    on_reset={ctx.link().callback(|_| DividerMove(Divider::ColumnSettings, PaneTarget::Natural))}
+                    on_resize={ctx.link().callback(|(x, _): (i32, i32)| DividerMove(Divider::ColumnSettings, PaneTarget::Width(x)))}
+                    on_resize_finished={ctx.link().callback(|_| DividerFinish(Divider::ColumnSettings))}
                 >
                     <ColumnSettingsPanel
                         {selected_column}
@@ -171,6 +171,7 @@ impl PerspectiveViewer {
                 {on_reset}
                 on_activate_panel={ctx.link().callback(|id| SetActivePanel(id, None))}
                 on_close_panel={ctx.link().callback(|id| ClosePanel(id, None))}
+                on_panel_closed={ctx.link().callback(PanelClosed)}
                 on_panel_command={ctx.link().batch_callback(|(id, cmd): (String, PanelCommand)| {
                     match cmd {
                         PanelCommand::New => vec![NewPanel(id)],
@@ -178,6 +179,7 @@ impl PerspectiveViewer {
                             vec![NewPanelFrom { client, table }]
                         },
                         PanelCommand::Duplicate => vec![DuplicatePanel(id)],
+                        PanelCommand::NewFromPanel(source) => vec![DuplicatePanel(source)],
                         PanelCommand::Reset => vec![ResetPanel(Some(id), false, None)],
                         PanelCommand::ToggleMaster => vec![ToggleMaster(id)],
                         PanelCommand::Close => vec![ClosePanel(id, None)],
@@ -233,8 +235,9 @@ impl PerspectiveViewer {
         };
 
         html! {
-            <StyleProvider root={ctx.props().elem.clone()}>
+            <StyleProvider root={ctx.props().elem.clone()} sheet={StyleSurface::Viewer.sheet()}>
                 <div id="component_container" class={is_single_panel}>
+                    <slot name="modal" />
                     <div id="layout_area">
                         <SplitPanel
                             id="app_panel"
@@ -243,9 +246,9 @@ impl PerspectiveViewer {
                             deferred=true
                             size={self.settings_geometry.pane_width_override}
                             initial_size={self.settings_geometry.pane_width_override}
-                            on_reset={ctx.link().callback(|_| SettingsPanelSizeUpdate(None))}
-                            on_resize={ctx.link().callback(|(x, _): (i32, i32)| SettingsDividerMove(x))}
-                            on_resize_finished={ctx.link().callback(|_| SettingsDividerFinish)}
+                            on_reset={ctx.link().callback(|_| DividerMove(Divider::Settings, PaneTarget::Natural))}
+                            on_resize={ctx.link().callback(|(x, _): (i32, i32)| DividerMove(Divider::Settings, PaneTarget::Width(x)))}
+                            on_resize_finished={ctx.link().callback(|_| DividerFinish(Divider::Settings))}
                         >
                             { settings_panel }
                             <div id="main_column_container">

package/src/rust/components/viewer/settings.rs

@@ -10,11 +10,6 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
-//! Settings-sidebar handlers: the open/close toggle (with its presize
-//! choreography), the deferred divider's latest-wins presize pump
-//! (`PRESIZE_EVERYWHERE_PLAN.md` P1/P2), and the column-settings drawer. The
-//! presize sweeps themselves live in [`crate::tasks`] (`presize_panels`).
-
 use futures::channel::oneshot::{Sender, channel};
 use perspective_js::utils::*;
 use wasm_bindgen::prelude::*;
@@ -22,12 +17,13 @@ use yew::prelude::*;
 
 use super::PerspectiveViewer;
 use super::msg::PerspectiveViewerMsg::*;
-use crate::components::font_loader::FontLoaderStatus;
+use super::msg::{Divider, PaneTarget};
 use crate::components::settings_panel::SelectedTab;
 use crate::config::*;
 use crate::presentation::{ColumnSettingsTab, ColumnSettingsTarget, OpenColumnSettings};
 use crate::queries::get_current_column_locator;
 use crate::tasks::*;
+use crate::ui::FontLoaderStatus;
 
 /// The settings sidebar's geometry state, folded into one field on
 /// [`PerspectiveViewer`]: the pane/drawer width overrides, the divider
@@ -44,11 +40,9 @@ pub(super) struct SettingsGeometry {
     /// High-water-mark auto width reported by the settings panel.
     pub auto_width: f64,
 
-    /// Latest-wins presize pump for the (deferred) settings divider: the
-    /// newest proposed pane width not yet presized, and whether a pump
-    /// iteration is in flight. See `SettingsDividerMove`.
-    pub divider_target: Option<i32>,
-    pub divider_pumping: bool,
+    pub settings_divider: DividerPump,
+
+    pub column_settings_divider: DividerPump,
 
     /// Open-state geometry deltas `(layout_area.w − mpc.w, main_column.h −
     /// mpc.h)`, cached at settings *close* time — used to presize panels to
@@ -85,6 +79,29 @@ pub(super) struct SettingsGeometry {
     pub column_settings_docked_width: Option<f64>,
 }
 
+#[derive(Default)]
+pub(super) struct DividerPump {
+    pub target: Option<PaneTarget>,
+    pub pumping: bool,
+    pub finish_pending: bool,
+}
+
+impl SettingsGeometry {
+    fn pump_mut(&mut self, divider: Divider) -> &mut DividerPump {
+        match divider {
+            Divider::Settings => &mut self.settings_divider,
+            Divider::ColumnSettings => &mut self.column_settings_divider,
+        }
+    }
+
+    fn is_divider_deferred(&self, divider: Divider) -> bool {
+        match divider {
+            Divider::Settings => true,
+            Divider::ColumnSettings => self.column_settings_pinned,
+        }
+    }
+}
+
 impl PerspectiveViewer {
     pub(super) fn on_toggle_settings_init(
         &mut self,
@@ -257,84 +274,143 @@ impl PerspectiveViewer {
         };
     }
 
-    pub(super) fn on_settings_panel_size_update(&mut self, x: Option<i32>) -> bool {
-        match x {
-            Some(x) => {
-                self.settings_geometry.pane_width_override = Some(x);
-                false
+    fn apply_pane_target(&mut self, divider: Divider, target: PaneTarget) -> bool {
+        let deferred = self.settings_geometry.is_divider_deferred(divider);
+        match (divider, target) {
+            (Divider::Settings, PaneTarget::Width(w)) => {
+                self.settings_geometry.pane_width_override = Some(w);
+                true
             },
-            None => {
+            (Divider::Settings, PaneTarget::Natural) => {
                 self.settings_geometry.pane_width_override = None;
                 self.settings_geometry.auto_width = 0.0;
                 self.on_settings_panel_dimensions_reset.emit(());
                 true
             },
+            (Divider::ColumnSettings, PaneTarget::Width(w)) => {
+                self.settings_geometry.column_settings_width_override = Some(w);
+                deferred
+            },
+            (Divider::ColumnSettings, PaneTarget::Natural) => {
+                self.settings_geometry.column_settings_width_override = None;
+                self.settings_geometry.column_settings_auto_width = 0.0;
+                true
+            },
         }
     }
 
-    pub(super) fn on_settings_divider_move(
+    pub(super) fn on_divider_move(
         &mut self,
         ctx: &Context<Self>,
-        pane_width: i32,
+        divider: Divider,
+        target: PaneTarget,
     ) -> bool {
+        if !self.settings_geometry.is_divider_deferred(divider) {
+            return self.apply_pane_target(divider, target);
+        }
+
         // Latest-wins: overwrite the pending target; start the pump if
         // idle. Intermediate targets that arrive while a presize is in
         // flight are dropped (mirrors `PresizeQueue`'s single queued
         // slot) — the pane tracks the pointer at content-render rate.
-        self.settings_geometry.divider_target = Some(pane_width);
-        if !self.settings_geometry.divider_pumping {
-            self.settings_geometry.divider_pumping = true;
-            ctx.link().send_message(SettingsDividerPump);
+        let pump = self.settings_geometry.pump_mut(divider);
+        pump.target = Some(target);
+        if !pump.pumping {
+            pump.pumping = true;
+            ctx.link().send_message(DividerPump(divider));
         }
 
         false
     }
 
-    pub(super) fn on_settings_divider_pump(&mut self, ctx: &Context<Self>) -> bool {
-        if let Some(pane_width) = self.settings_geometry.divider_target.take() {
-            let workspace = ctx.props().workspace.clone();
-            let elem = ctx.props().elem.clone();
-            let link = ctx.link().clone();
-            ApiFuture::spawn(async move {
-                let presents =
-                    presize_visible_panels_pane_width(&workspace, &elem, pane_width as f64).await;
-                link.send_message(SettingsDividerCommit(pane_width));
-                // Same task as the commit's re-render (whether Yew drained it
-                // synchronously inside `send_message` or deferred it to a
-                // microtask): the staged reveal and the pane-width geometry
-                // land in one paint.
-                presents.reveal();
-                Ok(())
-            });
-        } else {
-            self.settings_geometry.divider_pumping = false;
-        }
+    pub(super) fn on_divider_pump(&mut self, ctx: &Context<Self>, divider: Divider) -> bool {
+        let workspace = ctx.props().workspace.clone();
+        let pump = self.settings_geometry.pump_mut(divider);
+        let Some(target) = pump.target.take() else {
+            pump.pumping = false;
+            if std::mem::take(&mut pump.finish_pending) {
+                ApiFuture::spawn(async move {
+                    resize_visible_panels(&workspace).await;
+                    Ok(())
+                });
+            }
+
+            return false;
+        };
+
+        let elem = ctx.props().elem.clone();
+        let pane_width = match target {
+            PaneTarget::Width(w) => Some(w as f64),
+            PaneTarget::Natural => measure_pane_natural_width(&elem, divider.pane_selector()),
+        };
+
+        let link = ctx.link().clone();
+        ApiFuture::spawn(async move {
+            let presents = match pane_width {
+                Some(pane_width) => {
+                    presize_visible_panels_pane_width(
+                        &workspace,
+                        &elem,
+                        divider.pane_selector(),
+                        pane_width,
+                    )
+                    .await
+                },
+                None => StagedPresents::default(),
+            };
+
+            link.send_message(DividerCommit(divider, target));
+            presents.reveal();
+            Ok(())
+        });
 
         false
     }
 
-    pub(super) fn on_settings_divider_commit(
+    pub(super) fn on_divider_commit(
         &mut self,
         ctx: &Context<Self>,
-        pane_width: i32,
+        divider: Divider,
+        target: PaneTarget,
     ) -> bool {
         // Every visible panel has rendered at (approximately) its
         // target box — NOW move the geometry: the re-render below
-        // applies this width to the deferred `SplitPanel`'s controlled
+        // applies this target to the deferred `SplitPanel`'s controlled
         // `size`, in the same task as the presizes' inline clears.
-        self.settings_geometry.pane_width_override = Some(pane_width);
-        ctx.link().send_message(SettingsDividerPump);
+        self.apply_pane_target(divider, target);
+        if target == PaneTarget::Natural {
+            self.settings_geometry.pump_mut(divider).finish_pending = true;
+        }
+
+        ctx.link().send_message(DividerPump(divider));
         true
     }
 
-    pub(super) fn on_settings_divider_finish(&mut self, ctx: &Context<Self>) -> bool {
+    pub(super) fn on_divider_finish(&mut self, ctx: &Context<Self>, divider: Divider) -> bool {
+        if !self.settings_geometry.is_divider_deferred(divider) {
+            return false;
+        }
+
+        let pump = self.settings_geometry.pump_mut(divider);
+        if pump.pumping {
+            pump.finish_pending = true;
+        } else {
+            let workspace = ctx.props().workspace.clone();
+            ApiFuture::spawn(async move {
+                resize_visible_panels(&workspace).await;
+                Ok(())
+            });
+        }
+
+        false
+    }
+
+    fn resize_for_ratchet(&self, ctx: &Context<Self>) {
         let workspace = ctx.props().workspace.clone();
         ApiFuture::spawn(async move {
             resize_visible_panels(&workspace).await;
             Ok(())
         });
-
-        false
     }
 
     pub(super) fn on_settings_panel_tab_changed(&mut self, tab: SelectedTab) -> bool {
@@ -343,9 +419,10 @@ impl PerspectiveViewer {
         changed
     }
 
-    pub(super) fn on_settings_panel_auto_width(&mut self, w: f64) -> bool {
+    pub(super) fn on_settings_panel_auto_width(&mut self, ctx: &Context<Self>, w: f64) -> bool {
         if w > self.settings_geometry.auto_width {
             self.settings_geometry.auto_width = w;
+            self.resize_for_ratchet(ctx);
             true
         } else {
             false
@@ -397,19 +474,17 @@ impl PerspectiveViewer {
         true
     }
 
-    pub(super) fn on_column_settings_panel_size_update(&mut self, x: Option<i32>) -> bool {
-        self.settings_geometry.column_settings_width_override = x;
-        if x.is_none() {
-            self.settings_geometry.column_settings_auto_width = 0.0;
-            true
-        } else {
-            false
-        }
-    }
-
-    pub(super) fn on_column_settings_panel_auto_width(&mut self, w: f64) -> bool {
+    pub(super) fn on_column_settings_panel_auto_width(
+        &mut self,
+        ctx: &Context<Self>,
+        w: f64,
+    ) -> bool {
         if w > self.settings_geometry.column_settings_auto_width {
             self.settings_geometry.column_settings_auto_width = w;
+            if self.settings_geometry.column_settings_pinned {
+                self.resize_for_ratchet(ctx);
+            }
+
             true
         } else {
             false
@@ -561,12 +636,6 @@ impl PerspectiveViewer {
         true
     }
 
-    /// Toggling the debug tab re-renders the settings panel only — the
-    /// `DebugPanel` populates itself (`get_viewer_config` on mount +
-    /// change subscriptions), so no plugin dispatch is owed. The old
-    /// `just_render` here relied on the pre-amendment unconditional
-    /// `Unchanged → update` arm and repainted the plugin as a side effect
-    /// (`PLUGIN_DRAW_INVARIANT_PLAN.md` amendment, migration 2).
     pub(super) fn on_toggle_debug(&mut self, _ctx: &Context<Self>) -> bool {
         self.debug_open = !self.debug_open;
         true

package/src/rust/components/viewer/snapshots.rs

@@ -22,7 +22,7 @@ use yew::prelude::*;
 use super::PerspectiveViewer;
 use crate::presentation::{DragDropProps, PresentationProps};
 use crate::renderer::RendererProps;
-use crate::session::{SessionProps, TableLoadState, ViewStats};
+use crate::session::{SessionProps, TableLoadState};
 use crate::tasks::resize_visible_panels;
 
 impl PerspectiveViewer {
@@ -59,12 +59,12 @@ impl PerspectiveViewer {
 
     pub(super) fn on_update_session_stats(
         &mut self,
-        stats: Option<ViewStats>,
+        has_table_cells: bool,
         has_table: Option<TableLoadState>,
     ) -> bool {
-        let changed =
-            stats != self.session_props.stats || has_table != self.session_props.has_table;
-        self.session_props.stats = stats;
+        let changed = has_table_cells != self.session_props.has_table_cells
+            || has_table != self.session_props.has_table;
+        self.session_props.has_table_cells = has_table_cells;
         self.session_props.has_table = has_table;
         changed
     }
@@ -146,11 +146,6 @@ impl PerspectiveViewer {
         changed
     }
 
-    /// LEVEL-triggered spinner count: ASSIGN the absolute in-flight
-    /// config-run count from the session's RAII accounting — any missed or
-    /// reordered notification is corrected by the next one, unlike the
-    /// edge-counted increment/decrement pair this replaces (see
-    /// `UPDATE_COUNT_REGRESSION_PLAN.md`).
     pub(super) fn on_update_in_flight(&mut self, count: u32) -> bool {
         let changed = count != self.update_count;
         self.update_count = count;

package/src/rust/components/viewer/wiring.rs

@@ -280,28 +280,14 @@ pub(super) fn create_active_subscriptions(
 
         let sub1 = session.table_loaded.add_notify_listener(&cb);
         let sub2 = session.table_unloaded.add_notify_listener(&cb);
-        // Snapshot refresh on every RECONCILED commit (SKIP/REUSE/paused
-        // included), not just `View` construction.
         let sub3 = session.commit_reconciled.add_notify_listener(&cb);
         let sub4 = session.view_config_changed.add_notify_listener(&cb);
         let sub5 = session.title_changed.add_notify_listener(&cb);
-
-        // The `StatusIndicator` spinner count. LEVEL-triggered: the payload
-        // is the ABSOLUTE in-flight config-run count (RAII-settled by
-        // `ConfigRunToken`), which the handler ASSIGNS — replacing the
-        // edge-counted `view_config_changed`+1/`view_created`−1 pair, whose
-        // pairing the pipeline does not guarantee (stuck-spinner
-        // regression — see `UPDATE_COUNT_REGRESSION_PLAN.md`).
         let sub6 = session
             .run_state_changed
             .add_listener(ctx.link().callback(UpdateInFlight));
 
-        // Stats fetch resolution (populates session.column_stats) triggers
-        // a fresh `SessionProps` so `column_stats` reaches downstream
-        // components and the StyleTab re-queries the schema with the
-        // new value.
         let sub7 = session.column_stats_changed.add_notify_listener(&cb);
-
         vec![sub1, sub2, sub3, sub4, sub5, sub6, sub7]
     };
 
@@ -311,12 +297,6 @@ pub(super) fn create_active_subscriptions(
             move |_: JsPerspectiveViewerPlugin| UpdateRenderer(Box::new(renderer.to_props(None)))
         });
 
-        // Re-snapshot RendererProps when the plugin_config bucket
-        // changes (in-tab edit via `send_plugin_config`, JSON paste via
-        // `restore_and_render`, full clear via `reset_all` with
-        // `all=true`). Without this, `RendererProps.plugin_config`
-        // would stay frozen at its construct-time value and `PluginTab`
-        // would render stale.
         let cb_plugin_config = ctx.link().callback({
             let renderer = renderer.clone();
             move |_: serde_json::Map<String, serde_json::Value>| {
@@ -324,12 +304,21 @@ pub(super) fn create_active_subscriptions(
             }
         });
 
+        let cb_columns_config = ctx.link().callback({
+            let renderer = renderer.clone();
+            move |_: ColumnConfigMap| UpdateRenderer(Box::new(renderer.to_props(None)))
+        });
+
         let sub1 = renderer.plugin_changed.add_listener(cb_plugin);
         let sub2 = renderer
             .plugin_config_changed
             .add_listener(cb_plugin_config);
 
-        vec![sub1, sub2]
+        let sub3 = renderer
+            .columns_config_changed
+            .add_listener(cb_columns_config);
+
+        vec![sub1, sub2, sub3]
     };
 
     let mut subscriptions = Vec::new();
@@ -413,7 +402,7 @@ pub(super) fn inject_active_callbacks(
         let s = session.clone();
         let cb = ctx
             .link()
-            .callback(move |_: ()| UpdateSessionStats(s.get_table_stats(), s.has_table()));
+            .callback(move |_: ()| UpdateSessionStats(s.has_table_cells(), s.has_table()));
 
         *session.on_stats_changed.borrow_mut() = Some(cb);
     }