@perspective-dev/viewer 5.3.1 → 5.5.0

package/src/rust/renderer.rs

@@ -112,6 +112,11 @@ pub struct RendererData {
     /// plugin's bucket.
     pub plugin_config_changed: PubSub<serde_json::Map<String, serde_json::Value>>,
 
+    /// Fires after the active plugin's per-column bucket changes by any path
+    /// (edit, restore or reset), unlike `column_style_changed` which covers
+    /// edits only.
+    pub columns_config_changed: PubSub<ColumnConfigMap>,
+
     /// `true` while the active plugin's "rendering N of M" warning is
     /// dismissable.
     pub render_warning: Cell<bool>,
@@ -120,6 +125,10 @@ pub struct RendererData {
     /// [`Renderer::presize_with_box`] presize calls.
     presize_pending: Cell<u32>,
 
+    /// The `(width, height)` the plugin last painted at through a presize,
+    /// consumed by the post-commit reactive resize.
+    presized_box: Cell<Option<(f64, f64)>>,
+
     /// Debounce slot for geometry tasks (`resize` / presize), separate from
     /// the default slot data-update redraws coalesce on. Invariant: a
     /// geometry request must never resolve via a parked DATA task — a
@@ -160,14 +169,7 @@ pub struct RendererData {
 
     /// The effective theme stamped at the active plugin's last `--psp-*`
     /// CSS CAPTURE — its first paint ([`Renderer::draw_view`]) or last
-    /// [`Renderer::restyle_all`]. `None` = no capture has happened. The
-    /// state behind [`Renderer::needs_restyle`]: restyle necessity is a
-    /// comparison against what the plugin actually captured, never
-    /// inferred from which call site mutated a theme record (the
-    /// raycasting boot double render — see
-    /// `PLUGIN_DRAW_INVARIANT_PLAN.md`, captured-theme revision). Same
-    /// lifecycle as [`Self::has_drawn`]: cleared on plugin swap,
-    /// `dispose` and `delete`; written only inside locked dispatches.
+    /// [`Renderer::restyle_all`].
     captured_theme: RefCell<Option<Option<String>>>,
 
     /// The [`RenderContext`] of the currently-bound `View` (built at bind
@@ -266,8 +268,10 @@ impl Renderer {
             selection_changed: Default::default(),
             column_style_changed: Default::default(),
             plugin_config_changed: Default::default(),
+            columns_config_changed: Default::default(),
             render_warning: Cell::new(true),
             presize_pending: Cell::new(0),
+            presized_box: Cell::new(None),
             on_render_limits_changed: Default::default(),
             slot_name: Default::default(),
             theme: Default::default(),
@@ -315,14 +319,7 @@ impl Renderer {
 
     /// Whether the active plugin's captured `--psp-*` CSS is STALE — the
     /// effective theme differs from the one stamped at the plugin's last
-    /// CSS capture (first paint / last restyle). The state-keyed gate for
-    /// every theme-driven `restyle_all` (the `has_drawn` analog for
-    /// `restyle` — `PLUGIN_DRAW_INVARIANT_PLAN.md`, captured-theme
-    /// revision): a caller that just mutated a theme RECORD may not need a
-    /// restyle at all if the plugin's capture already reflects the new
-    /// value (e.g. the same restore also performed the first paint,
-    /// post-stamp). `false` when no capture exists yet — the owed first
-    /// paint captures fresh by construction ("stamp before draw").
+    /// CSS capture (first paint / last restyle).
     pub fn needs_restyle(&self) -> bool {
         match &*self.0.captured_theme.borrow() {
             Some(captured) => *captured != self.theme(),
@@ -336,17 +333,6 @@ impl Renderer {
     /// [`Self::delete`], which clears the entire light DOM). Removes the
     /// plugin (`slot=<id>`) and any panel-scoped aux element it mounted
     /// (e.g. the datagrid toolbar, `slot=statusbar-extra-<id>`).
-    ///
-    /// The teardown is DEFERRED through this renderer's draw lock: spawned
-    /// draws are uncancellable, so a synchronous `plugin.delete()` here could
-    /// land mid-`plugin.draw()`, which the serialized-call contract forbids
-    /// (see [`crate::js::plugin`]). Deferral is invisible — the caller
-    /// (`eject_panel`) has already removed the panel from the `Workspace`, so
-    /// the same commit unmounts its frame and the plugin element sits
-    /// unslotted (unrendered) until teardown lands; panel ids are never
-    /// reused, so it can't collide with a replacement panel's slot. Draws
-    /// still queued behind the lock no-op via the synchronous session reset
-    /// (`get_view()` → `None`).
     pub fn dispose(&self) -> ApiFuture<()> {
         self.0.has_drawn.set(false);
         self.0.captured_theme.borrow_mut().take();
@@ -488,6 +474,12 @@ impl Renderer {
         Ok(self.0.has_drawn.get())
     }
 
+    /// Take the box the plugin last painted at through a presize (see
+    /// `RendererData::presized_box`).
+    pub fn take_presized_box(&self) -> Option<(f64, f64)> {
+        self.0.presized_box.take()
+    }
+
     /// Mount the selected plugin element into the viewer's light DOM without
     /// drawing it (see [`activate::mount_plugin`] — idempotent). Pure query:
     /// a renderer with no selection is a no-op, deferring to the draw path's
@@ -695,6 +687,7 @@ impl Renderer {
     /// suitable for passing as a Yew prop.  Called by the root component
     /// whenever a renderer-related PubSub event fires.
     pub fn to_props(&self, render_limits: Option<RenderLimits>) -> RendererProps {
+        let render_limits = render_limits.filter(RenderLimits::is_capped);
         let has_plugin = self.active_plugin().is_some();
         if has_plugin {
             let config = self.metadata();
@@ -708,6 +701,7 @@ impl Renderer {
                 .into();
 
             let plugin_config = PtrEqRc::new(self.get_plugin_config());
+            let columns_config = PtrEqRc::new(self.all_columns_configs());
             RendererProps {
                 plugin_name,
                 config,
@@ -715,6 +709,7 @@ impl Renderer {
                 available_plugins,
                 is_chart,
                 plugin_config,
+                columns_config,
             }
         } else {
             RendererProps {
@@ -724,6 +719,7 @@ impl Renderer {
                 available_plugins: PtrEqRc::new(vec![]),
                 is_chart: false,
                 plugin_config: PtrEqRc::default(),
+                columns_config: PtrEqRc::default(),
             }
         }
     }

package/src/rust/session/props.rs

@@ -19,14 +19,18 @@ use crate::session::column_defaults_update::ViewConfigUpdateExt;
 use crate::session::drag_drop_update::ViewConfigExt as DragDropExt;
 use crate::session::metadata::SessionMetadataRc;
 use crate::session::replace_expression_update::ViewConfigExt as ReplaceExprExt;
-use crate::session::{ColumnStats, TableErrorState, ViewStats};
+use crate::session::{ColumnStats, TableErrorState};
 use crate::utils::*;
 
+/// The panel's table binding as the status indicator and chrome see it:
+/// bound, a `load()` in flight, or a named table awaiting its host (see
+/// `Session::pending_table`).
 #[derive(Clone, Debug, PartialEq, Default)]
 pub enum TableLoadState {
     #[default]
     Loaded,
     Loading,
+    Pending,
 }
 
 /// Value-semantic snapshot of the session state read by the root component.
@@ -39,8 +43,9 @@ pub struct SessionProps {
     /// The current `ViewConfig` driving the active `View`.
     pub config: PtrEqRc<ViewConfig>,
 
-    /// Row/column statistics for the status bar.
-    pub stats: Option<ViewStats>,
+    /// Whether the view stats carry table dimensions yet, the status
+    /// indicator's loaded/uninitialized split.
+    pub has_table_cells: bool,
 
     /// `true` if a `Table` has been loaded into this session.
     pub has_table: Option<TableLoadState>,

package/src/rust/session/view_subscription.rs

@@ -10,10 +10,11 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
-use std::cell::Cell;
+use std::cell::{Cell, RefCell};
 use std::rc::Rc;
 
 use perspective_client::config::*;
+use perspective_client::proto::ViewDimensionsResp;
 use perspective_client::{OnUpdateOptions, View};
 use wasm_bindgen::prelude::*;
 use yew::prelude::*;
@@ -41,6 +42,10 @@ struct ViewSubscriptionData {
     on_stats: Callback<ViewStats>,
     on_update: Option<Callback<()>>,
     is_deleted: Rc<Cell<bool>>,
+
+    /// The bound `View`'s latest known dimensions, written before
+    /// `on_update`/`on_stats` fire.
+    dimensions: Rc<RefCell<Option<ViewDimensionsResp>>>,
 }
 
 /// A subscription to `on_update()` events from a Perspective `View()`, managing
@@ -52,20 +57,21 @@ pub struct ViewSubscription {
 impl ViewSubscriptionData {
     /// Main handler when underlying `View()` calls `on_update()`.
     async fn on_view_update(self) -> ApiResult<JsValue> {
+        self.clone().update_view_stats().await?;
         if let Some(on_update) = &self.on_update {
             on_update.emit(());
         };
 
-        self.clone().update_view_stats().await?;
         Ok(JsValue::UNDEFINED)
     }
 
     async fn update_view_stats(self) -> ApiResult<JsValue> {
         let dimensions = self.view.dimensions().await?;
-        let num_rows = dimensions.num_table_rows as u32;
-        let num_cols = dimensions.num_table_columns as u32;
-        let virtual_rows = dimensions.num_view_rows as u32;
-        let virtual_cols = dimensions.num_view_columns as u32;
+        let num_rows = dimensions.num_table_rows;
+        let num_cols = dimensions.num_table_columns;
+        let virtual_rows = dimensions.num_view_rows;
+        let virtual_cols = dimensions.num_view_columns;
+        *self.dimensions.borrow_mut() = Some(dimensions);
         let stats = ViewStats {
             num_table_cells: Some((num_rows, num_cols)),
             num_view_cells: Some((virtual_rows, virtual_cols)),
@@ -119,6 +125,7 @@ impl ViewSubscription {
             callback_id: Rc::default(),
             on_update,
             is_deleted: Rc::default(),
+            dimensions: Rc::default(),
         };
 
         if data.on_update.is_some() {
@@ -160,6 +167,12 @@ impl ViewSubscription {
         &self.data.view
     }
 
+    /// The bound `View`'s latest known dimensions (`None` until the first
+    /// fetch resolves).
+    pub fn dimensions(&self) -> Option<ViewDimensionsResp> {
+        self.data.dimensions.borrow().clone()
+    }
+
     /// User-facing snapshot of the [`ViewConfig`] the bound `View` was
     /// constructed from (the persisted config at build time — global-filter
     /// overlay excluded). This is the [`ViewConfig`] consistent with the