@perspective-dev/viewer 5.3.0 → 5.4.0

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

@@ -26,7 +26,7 @@ use crate::presentation::{
     ColumnSettingsTab, ColumnSettingsTarget, DragDropProps, PresentationProps,
 };
 use crate::renderer::RendererProps;
-use crate::session::{SessionProps, TableLoadState, ViewStats};
+use crate::session::{SessionProps, TableLoadState};
 use crate::utils::Completion;
 
 /// The filter-bearing payload of a master panel's selection or click event
@@ -45,9 +45,31 @@ pub struct MasterSelection {
     pub cell_fallback: Option<Filter>,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Divider {
+    Settings,
+    ColumnSettings,
+}
+
+impl Divider {
+    /// The shadow-DOM selector of the divider's resizable pane (pane 0 of
+    /// its `SplitPanel`; the flex-fill pane renders bare).
+    pub fn pane_selector(self) -> &'static str {
+        match self {
+            Self::Settings => "#app_panel > .split-panel-child",
+            Self::ColumnSettings => "#modal_panel > .split-panel-child",
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum PaneTarget {
+    Width(i32),
+    Natural,
+}
+
 #[derive(Debug)]
 pub enum PerspectiveViewerMsg {
-    ColumnSettingsPanelSizeUpdate(Option<i32>),
     ColumnSettingsPanelAutoWidth(f64),
     ToggleColumnSettingsPin,
     ToggleColumnSettingsPinComplete(Sender<()>),
@@ -84,12 +106,18 @@ pub enum PerspectiveViewerMsg {
     /// nudge runs complete (invariant I6).
     SetActivePanel(String, Option<Completion>),
 
-    /// The named panel's frame was closed (removed from the layout); remove it
-    /// from the workspace and dispose its engines. The `Completion` resolves
-    /// `removePanel()` after the eject's teardown run completes (invariant
-    /// I6) — carrying any teardown error, which was previously dropped.
+    /// Close the named panel: remove it from the workspace now but keep its
+    /// engines parked until [`Self::PanelClosed`] reports the layout commit
+    /// that reclaims its cell. The `Completion` resolves `removePanel()`
+    /// after the eject's teardown run completes (invariant I6) — carrying
+    /// any teardown error.
     ClosePanel(String, Option<Completion>),
 
+    /// `MainPanel` saw the named panel leave the `regular-layout` tree, so
+    /// dispose its parked panel, or close outright one the workspace still
+    /// holds.
+    PanelClosed(String),
+
     /// `restoreWorkspace` finished replacing the panel set in the
     /// `Workspace` (new models inserted, old panels ejected, layout staged):
     /// activate the named panel, re-subscribe the per-panel wiring, and
@@ -130,26 +158,10 @@ pub enum PerspectiveViewerMsg {
     /// Some panel's title changed (any panel, via `_title_subscriptions`);
     /// re-render so the tab titles refresh.
     TitlesChanged,
-    SettingsPanelSizeUpdate(Option<i32>),
-
-    /// The settings-pane divider proposed a new pane width (per pointermove,
-    /// from the *deferred* `SplitPanel` — it has NOT been applied). Feeds the
-    /// latest-wins presize pump (`PRESIZE_EVERYWHERE_PLAN.md` P1): geometry
-    /// commits only after every visible panel has rendered at its target.
-    SettingsDividerMove(i32),
-
-    /// Run one pump iteration: presize all visible panels at the newest
-    /// proposed pane width, then commit it.
-    SettingsDividerPump,
-
-    /// Presize for this pane width completed — commit it (the deferred
-    /// `SplitPanel`'s controlled `size`), then pump again if a newer target
-    /// arrived meanwhile.
-    SettingsDividerCommit(i32),
-
-    /// Divider drag ended: reactively finalize every visible panel at its
-    /// exact settled cell (debounced no-op when the presizes were exact).
-    SettingsDividerFinish,
+    DividerMove(Divider, PaneTarget),
+    DividerPump(Divider),
+    DividerCommit(Divider, PaneTarget),
+    DividerFinish(Divider),
     SettingsPanelTabChanged(SelectedTab),
     SettingsPanelAutoWidth(f64),
     ToggleDebug,
@@ -203,10 +215,11 @@ pub enum PerspectiveViewerMsg {
     UpdateColumnSettingsCommit(Sender<()>),
     UpdateDragDrop(Box<DragDropProps>),
 
-    /// Update only stats-related fields of `session_props` without touching
-    /// `config`.  This prevents `stats_changed` events (e.g. from `reset()`)
-    /// from propagating a freshly-cleared config to the column selector.
-    UpdateSessionStats(Option<ViewStats>, Option<TableLoadState>),
+    /// Update only the stats-derived fields of `session_props`
+    /// (`has_table_cells`, `has_table`) without touching `config`.  This
+    /// prevents `stats_changed` events (e.g. from `reset()`) from propagating
+    /// a freshly-cleared config to the column selector.
+    UpdateSessionStats(bool, Option<TableLoadState>),
 
     /// Refresh the root's render snapshot of the `Workspace`-owned global
     /// filter set (dispatched by its `filters_changed` PubSub).

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();

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));
@@ -135,9 +131,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 +170,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 +178,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 +234,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 +245,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;