@perspective-dev/viewer 5.3.0 → 5.4.0

package/src/rust/presentation.rs

@@ -11,7 +11,6 @@
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
 mod column_locator;
-pub mod drag_helpers;
 mod props;
 mod sheets;
 
@@ -28,13 +27,14 @@ use yew::html::ImplicitClone;
 use yew::prelude::*;
 
 pub use self::column_locator::{
-    ColumnLocator, ColumnSettingsTab, ColumnSettingsTarget, ColumnTab, OpenColumnSettings,
+    ColumnLocator, ColumnSettingsTab, ColumnSettingsTarget, OpenColumnSettings,
 };
-use self::drag_helpers::DragTargetState;
-pub use self::drag_helpers::{DragDropContainer, DragEndCallback};
 pub use self::props::{DragDropProps, PresentationProps};
-use crate::config::{CssKind, NamedValue, assign_palette_names};
-use crate::utils::*;
+pub use crate::ui::{DragDropContainer, DragEndCallback};
+use crate::ui::{
+    DragTargetState, PointerDownCallback, clear_document_selection, closest_draggable,
+};
+use crate::utils::{CssKind, NamedValue, assign_palette_names, *};
 
 #[derive(Clone, Debug)]
 struct DragFrom {
@@ -73,14 +73,7 @@ pub struct PresentationHandle {
     pub agent: crate::agent::AgentSlot,
 
     /// The available themes as detected in the browser environment or set
-    /// explicitly when CORS prevents detection — a MEMO of a document
-    /// external, not component state. `None` until first parsed (detection
-    /// is expensive and must wait for `document.styleSheets`). Sync-readable
-    /// (a `RefCell`, never borrowed across an await) so synchronous paths
-    /// ("stamp with commit" — panel creation, theme mutation sites) can
-    /// derive the registry default without awaiting registry init; derived
-    /// values (e.g. the default theme = first registered) are computed from
-    /// it on demand, never mirrored.
+    /// explicitly when CORS prevents detection.
     themes: RefCell<Option<Vec<String>>>,
 
     /// Single-flight guard for the stylesheet parse that populates
@@ -91,12 +84,6 @@ pub struct PresentationHandle {
 
     /// Whether the host's theme was ever EXPLICITLY chosen — authored as a
     /// `theme` attribute, or set by name through [`Self::set_theme_name`].
-    ///
-    /// `false` means the host merely displays the registry default, which
-    /// [`Self::reset_themes`] is free to move; `true` pins the selection
-    /// until it leaves the registry. The `theme` attribute alone cannot
-    /// carry this, because `init` stamps it unconditionally so the document
-    /// cascade has a theme to match.
     theme_selected: Cell<bool>,
 
     palette: RefCell<BTreeMap<String, String>>,
@@ -104,6 +91,8 @@ pub struct PresentationHandle {
     open_column_settings: RefCell<OpenColumnSettings>,
     is_workspace: RefCell<Option<bool>>,
 
+    collapsed_control_groups: RefCell<HashSet<String>>,
+
     /// Drag/drop in-progress state. Empty (`NoDrag`) when no user drag is
     /// active. Mutated by `notify_drag_*` / `notify_drop`; read by component
     /// CSS-class derivations (`is_dragover`, `get_drag_column`).
@@ -124,32 +113,22 @@ pub struct PresentationHandle {
     /// dragged element from the shadow tree.
     host_dragend: RefCell<Option<DragEndCallback>>,
 
+    /// Host-level `pointerdown` listener that clears a stale page selection
+    /// before it can turn a row drag into a browser selection drag.
+    host_pointerdown: RefCell<Option<PointerDownCallback>>,
+
     source_dragend: RefCell<Option<(web_sys::EventTarget, DragEndCallback)>>,
 
     /// IntersectionObserver-based fallback for the drag image, kept alive for
     /// the duration of the drag.
     drag_target: RefCell<Option<DragTargetState>>,
 
-    /// `(open, announce)` — `announce` says this toggle is the SOLE carrier
-    /// of the config change (a user gesture: toolbar, `toggleConfig`), so
-    /// the element must emit `toggle-settings` + a config-update for it. An
-    /// API restore's toggle is announced by its own view-config commit
-    /// dispatch instead — announcing here too would double-emit, the first
-    /// carrying the intermediate config (settings flipped, view fields not
-    /// yet committed).
     pub settings_open_changed: PubSub<(bool, bool)>,
-
-    /// Injected callback from the root component, replacing the former
-    /// `is_workspace_changed: PubSub` field.
     pub on_is_workspace_changed: RefCell<Option<Callback<bool>>>,
     pub settings_before_open_changed: PubSub<bool>,
     pub column_settings_open_changed: PubSub<(bool, Option<String>)>,
     pub theme_config_updated: PubSub<(PtrEqRc<Vec<String>>, Option<usize>)>,
     pub on_eject: PubSub<()>,
-
-    /// Fires for status-bar / main-panel pointer events that target the
-    /// statusbar element. `wire_element_events` formats the `PointerEvent`'s
-    /// `type_()` into a `perspective-statusbar-{type}` `CustomEvent` name.
     pub statusbar_pointer_event: PubSub<PointerEvent>,
 }
 
@@ -191,6 +170,7 @@ impl Presentation {
             on_is_workspace_changed: Default::default(),
             is_settings_open: Default::default(),
             open_column_settings: Default::default(),
+            collapsed_control_groups: Default::default(),
             theme_config_updated: PubSub::default(),
             on_eject: PubSub::default(),
             statusbar_pointer_event: PubSub::default(),
@@ -199,10 +179,12 @@ impl Presentation {
             on_dragstart: Default::default(),
             on_dragend: Default::default(),
             host_dragend: Default::default(),
+            host_pointerdown: Default::default(),
             source_dragend: Default::default(),
             drag_target: Default::default(),
         }));
 
+        theme.register_host_pointerdown();
         ApiFuture::spawn(theme.clone().init());
         theme
     }
@@ -357,6 +339,20 @@ impl Presentation {
         self.open_column_settings.borrow().deref().clone()
     }
 
+    pub fn is_control_group_collapsed(&self, key: &str) -> bool {
+        self.collapsed_control_groups.borrow().contains(key)
+    }
+
+    pub fn set_control_group_collapsed(&self, key: &str, collapsed: bool) {
+        if collapsed {
+            self.collapsed_control_groups
+                .borrow_mut()
+                .insert(key.to_owned());
+        } else {
+            self.collapsed_control_groups.borrow_mut().remove(key);
+        }
+    }
+
     async fn init(self) -> ApiResult<()> {
         self.set_theme_attribute(self.get_selected_theme_name().await.as_deref())
     }
@@ -560,18 +556,53 @@ impl Presentation {
         }
     }
 
-    pub fn set_drag_image(&self, event: &DragEvent) -> ApiResult<()> {
+    /// Claim a `dragstart` for the column drag machinery, returning `false`
+    /// (cancelling the native drag) when it did not originate on a
+    /// `draggable="true"` row or installation failed.
+    pub fn set_drag_image(&self, event: &DragEvent) -> bool {
+        match self.try_set_drag_image(event) {
+            Ok(true) => true,
+            Ok(false) => {
+                event.prevent_default();
+                if let Err(e) = clear_document_selection() {
+                    web_sys::console::warn_1(&e.into());
+                }
+
+                false
+            },
+            Err(e) => {
+                event.prevent_default();
+                web_sys::console::warn_1(&e.into());
+                false
+            },
+        }
+    }
+
+    fn try_set_drag_image(&self, event: &DragEvent) -> ApiResult<bool> {
         event.stop_propagation();
+        let Some(original) = closest_draggable(event) else {
+            return Ok(false);
+        };
+
+        let is_row_drag = event
+            .target()
+            .and_then(|target| target.dyn_into::<Node>().ok())
+            .map(|target| original.is_same_node(Some(&target)))
+            .unwrap_or(false);
+
+        if !is_row_drag {
+            return Ok(false);
+        }
+
         self.register_source_dragend(event)?;
         if let Some(dt) = event.data_transfer() {
             dt.set_drop_effect("move");
         }
 
-        let original: HtmlElement = event.target().into_apierror()?.unchecked_into();
         let elem: HtmlElement = original
             .children()
             .get_with_index(0)
-            .unwrap()
+            .into_apierror()?
             .clone_node_with_deep(true)?
             .unchecked_into();
 
@@ -595,7 +626,7 @@ impl Presentation {
             Ok(())
         });
 
-        Ok(())
+        Ok(true)
     }
 
     /// Is the drag/drop state currently in `action`?
@@ -678,6 +709,22 @@ impl Presentation {
         Ok(())
     }
 
+    fn register_host_pointerdown(&self) {
+        let closure = Closure::wrap(Box::new(move |event: PointerEvent| {
+            if closest_draggable(&event).is_some()
+                && let Err(e) = clear_document_selection()
+            {
+                web_sys::console::warn_1(&e.into());
+            }
+        }) as Box<dyn FnMut(PointerEvent)>);
+
+        self.viewer_elem
+            .add_event_listener_with_callback("pointerdown", closure.as_ref().unchecked_ref())
+            .unwrap();
+
+        *self.host_pointerdown.borrow_mut() = Some(closure);
+    }
+
     fn register_host_dragend(&self) {
         if let Some(prev) = self.host_dragend.borrow_mut().take() {
             let _ = self

package/src/rust/queries/hosted_tables.rs

@@ -0,0 +1,38 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+// ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+// ┃ This file is part of the Perspective library, distributed under the terms ┃
+// ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+use crate::workspace::Workspace;
+
+/// Every hosted `Table` name per loaded `Client`, as `(client name, sorted
+/// table names)` in registration order.
+pub async fn fetch_hosted_tables(workspace: &Workspace) -> Vec<(String, Vec<String>)> {
+    let clients = workspace.clients();
+    let mut tables = Vec::with_capacity(clients.len());
+    for client in clients {
+        let mut names = match client.get_hosted_table_names().await {
+            Ok(names) => names,
+            Err(err) => {
+                tracing::warn!(
+                    "Failed to list tables for `Client` \"{}\": {err}",
+                    client.get_name()
+                );
+
+                vec![]
+            },
+        };
+
+        names.sort_unstable();
+        tables.push((client.get_name().to_owned(), names));
+    }
+
+    tables
+}

package/src/rust/queries/mod.rs

@@ -28,6 +28,7 @@ pub mod export_app;
 mod exports;
 mod fetch_column_stats;
 mod get_viewer_config;
+mod hosted_tables;
 mod is_invalid_drop;
 mod palette_set;
 mod plugin_column_styles;
@@ -40,6 +41,7 @@ pub use self::export_app::*;
 pub use self::exports::*;
 pub use self::fetch_column_stats::*;
 pub use self::get_viewer_config::*;
+pub use self::hosted_tables::*;
 pub use self::is_invalid_drop::*;
 pub use self::palette_set::*;
 pub use self::plugin_column_styles::*;

package/src/rust/queries/palette_set.rs

@@ -12,8 +12,8 @@
 
 use std::collections::BTreeMap;
 
-use crate::config::{CssKind, CssLiteralUse, NamedValue, assign_palette_names};
 use crate::presentation::Presentation;
+use crate::utils::{CssKind, CssLiteralUse, NamedValue, assign_palette_names};
 use crate::workspace::{PanelId, Workspace};
 
 /// Every CSS literal in use across the workspace, as `(panel id, use)`,

package/src/rust/queries/plugin_column_styles.rs

@@ -42,7 +42,7 @@ pub fn get_plugin_config_schema(
         wasm_bindgen::JsValue::from_serde_ext(view_config).unwrap_or(wasm_bindgen::JsValue::NULL);
     let raw = plugin._plugin_config_schema(&view_config_js)?;
     serde_wasm_bindgen::from_value::<ColumnConfigSchema>(raw)
-        .map(|schema| schema.canonicalize_defaults())
+        .map(|schema| schema.canonicalize())
         .map_err(|e| e.into())
 }
 
@@ -100,6 +100,6 @@ pub fn get_column_config_schema(
     )?;
 
     serde_wasm_bindgen::from_value::<ColumnConfigSchema>(raw)
-        .map(|schema| schema.canonicalize_defaults())
+        .map(|schema| schema.canonicalize())
         .map_err(|e| e.into())
 }

package/src/rust/renderer/activate.rs

@@ -51,9 +51,7 @@ pub fn mount_plugin(
 }
 
 /// Given an async `task` which draws `plugin`, [`mount_plugin`] it, then run
-/// `task`. Requires the [`RenderGuard`] lock witness — plugin dispatch
-/// outside a locked run does not compile (invariants I3/I6 of the merge;
-/// see `SESSION_CONFIG_COHERENCE_PLAN.md`).
+/// `task`.
 pub async fn activate_plugin<T>(
     _guard: &RenderGuard,
     viewer: &HtmlElement,

package/src/rust/renderer/dispatch.rs

@@ -19,6 +19,7 @@ use std::future::Future;
 use std::rc::Rc;
 
 use perspective_client::View;
+use perspective_client::proto::ViewDimensionsResp;
 use perspective_js::utils::{ApiResult, ResultTApiErrorExt};
 use wasm_bindgen::prelude::*;
 use web_sys::*;
@@ -44,25 +45,27 @@ impl Renderer {
         let _ = el.class_list().toggle_with_force("multi", !is_solo);
     }
 
-    /// Stamp this panel's effective `theme` attribute.
     pub fn stamp_theme(&self, plugin: Option<&JsPerspectiveViewerPlugin>) {
+        let theme = self.theme();
         let active_plugin = self.active_plugin();
         if let Some(plugin) = plugin.or(active_plugin.as_ref()) {
-            let theme_elem = plugin.unchecked_ref::<HtmlElement>();
-            match self.theme() {
-                Some(theme)
-                    if theme_elem.get_attribute("theme").as_deref() != Some(theme.as_str()) =>
-                {
-                    let _ = theme_elem.set_attribute("theme", &theme);
-                },
-                Some(_) => {},
-                None => {
-                    let _ = theme_elem.remove_attribute("theme");
-                },
-            }
+            stamp_theme_attr(plugin.unchecked_ref::<Element>(), theme.as_deref());
+        }
+
+        if let Some(tab) = self.tab_host() {
+            stamp_theme_attr(&tab, theme.as_deref());
         }
     }
 
+    fn tab_host(&self) -> Option<Element> {
+        let slot = format!("tab-{}", self.slot_name()?);
+        let viewer = self.plugin_data.borrow().viewer_elem.clone();
+        let children = viewer.children();
+        (0..children.length())
+            .filter_map(|i| children.item(i))
+            .find(|el| el.get_attribute("slot").as_deref() == Some(slot.as_str()))
+    }
+
     /// Restyle the active plugin and re-draw.
     pub async fn restyle_all(&self) -> ApiResult<JsValue> {
         self.render_task(|guard| async move {
@@ -78,8 +81,14 @@ impl Renderer {
             self.stamp_active(&plugin);
             plugin.restyle();
             *self.0.captured_theme.borrow_mut() = Some(stamped_theme);
-            let mut limits =
-                get_row_and_col_limits(&ctx.view, &meta, self.is_render_warning_enabled()).await?;
+            let dimensions = ctx.view.dimensions().await?;
+            let mut limits = get_row_and_col_limits(
+                &dimensions,
+                &ctx.view,
+                &meta,
+                self.is_render_warning_enabled(),
+            )
+            .await?;
 
             limits.is_update = true;
             plugin
@@ -165,10 +174,8 @@ impl Renderer {
         width: f64,
         height: f64,
     ) -> ApiResult<Option<js_sys::Function>> {
-        self.0.presize_pending.set(self.0.presize_pending.get() + 1);
-        let result = self.presize_inner(None, width, height).await;
-        self.0.presize_pending.set(self.0.presize_pending.get() - 1);
-        result
+        let _pending = PresizePendingGuard::increment(self);
+        self.presize_inner(None, width, height).await
     }
 
     /// Pre-size AND pre-position the plugin to its target layout bo.
@@ -179,10 +186,8 @@ impl Renderer {
         width: f64,
         height: f64,
     ) -> ApiResult<Option<js_sys::Function>> {
-        self.0.presize_pending.set(self.0.presize_pending.get() + 1);
-        let result = self.presize_inner(Some((dx, dy)), width, height).await;
-        self.0.presize_pending.set(self.0.presize_pending.get() - 1);
-        result
+        let _pending = PresizePendingGuard::increment(self);
+        self.presize_inner(Some((dx, dy)), width, height).await
     }
 
     async fn presize_inner(
@@ -219,6 +224,7 @@ impl Renderer {
                         };
 
                         self.stamp_active(&jsplugin);
+                        self.0.presized_box.set(None);
                         jsplugin.resize().await?;
                         Ok(None)
                     },
@@ -245,7 +251,33 @@ impl Renderer {
         self.stamp_active(&plugin);
         self.clear_presize()?;
         if plugin.capabilities().presize {
-            return plugin.presize(width, height).await;
+            let Some(present) = plugin.presize(width, height).await? else {
+                return Ok(None);
+            };
+
+            self.0.presized_box.set(Some((width, height)));
+            let inline = js_sys::Reflect::get(&present, &"inline".into())
+                .ok()
+                .and_then(|v| v.as_bool())
+                .unwrap_or(false);
+
+            if inline {
+                self.0.presized_box.set(None);
+            }
+
+            let renderer = self.clone();
+            let wrapped = Closure::once_into_js(move || {
+                let filled = present
+                    .call0(&JsValue::NULL)
+                    .map(|v| v.as_bool() != Some(false))
+                    .unwrap_or(false);
+
+                if !filled {
+                    renderer.0.presized_box.set(None);
+                }
+            });
+
+            return Ok(Some(wrapped.unchecked_into::<js_sys::Function>()));
         }
 
         let main_panel: &web_sys::HtmlElement = plugin.unchecked_ref();
@@ -282,6 +314,7 @@ impl Renderer {
             }
 
             result?;
+            self.0.presized_box.set(Some((width, height)));
         }
 
         Ok(None)
@@ -311,14 +344,16 @@ impl Renderer {
     pub async fn draw_fresh(&self, guard: &RenderGuard, view: FreshView) -> ApiResult<()> {
         let timer = self.render_timer();
         timer
-            .capture_time(self.draw_view(guard, view.view(), false))
+            .capture_time(self.draw_view(guard, view.view(), false, None))
             .await
     }
 
     /// Repaint the ALREADY-BOUND `view` on the active plugin.
     pub async fn update_bound(&self, guard: &RenderGuard, view: &View) -> ApiResult<()> {
         let timer = self.render_timer();
-        timer.capture_time(self.draw_view(guard, view, true)).await
+        timer
+            .capture_time(self.draw_view(guard, view, true, None))
+            .await
     }
 
     /// Mint the [`FreshView`] full-draw witness for a plugin that has never
@@ -367,26 +402,33 @@ impl Renderer {
     /// Redraw an already-bound view, debounced.
     pub async fn update_lazy(
         &self,
-        view: impl Future<Output = ApiResult<Option<View>>>,
+        view: impl Future<Output = ApiResult<Option<(View, Option<ViewDimensionsResp>)>>>,
     ) -> ApiResult<()> {
         let timer = self.render_timer();
         self.draw_lock()
             .debounce_with(|guard| async move {
                 set_timeout(timer.get_throttle()).await?;
                 if self.0.presize_pending.get() > 0 {
+                    // Record the drop like the hidden-panel path
+                    // (`wire_panel_render_sub`) does — a silently
+                    // discarded update otherwise leaves the plugin's
+                    // retained frame stale until the NEXT data tick,
+                    // or forever if none comes. `draw_view` /
+                    // `activation_render` consume the marker.
                     tracing::debug!("Update skipped, presize pending");
+                    self.set_data_stale();
                     return Ok(());
                 }
 
                 self.mount_active_plugin()?;
-                if let Some(view) = view.await? {
+                if let Some((view, dimensions)) = view.await? {
                     let _pin = self
                         .cached_context()
                         .map(|ctx| self.pin_context(&guard, ctx));
 
                     let timer = self.render_timer();
                     timer
-                        .capture_time(self.draw_view(&guard, &view, true))
+                        .capture_time(self.draw_view(&guard, &view, true, dimensions))
                         .await
                 } else {
                     tracing::debug!("Render skipped, no `View` attached");
@@ -396,11 +438,14 @@ impl Renderer {
             .await
     }
 
+    /// `dimensions` is the caller's already-fetched view dimensions, or
+    /// `None` to fetch here.
     async fn draw_view(
         &self,
         _guard: &RenderGuard,
         view: &perspective_client::View,
         is_update: bool,
+        dimensions: Option<ViewDimensionsResp>,
     ) -> ApiResult<()> {
         debug_assert!(
             !is_update || self.cached_context().is_none() || self.render_context().is_some(),
@@ -417,8 +462,14 @@ impl Renderer {
         };
 
         let meta = self.metadata();
+        let dimensions = match dimensions {
+            Some(dimensions) => dimensions,
+            None => view.dimensions().await?,
+        };
+
         let mut limits =
-            get_row_and_col_limits(view, &meta, self.is_render_warning_enabled()).await?;
+            get_row_and_col_limits(&dimensions, view, &meta, self.is_render_warning_enabled())
+                .await?;
 
         limits.is_update = is_update;
         if let Some(cb) = self.0.on_render_limits_changed.borrow().as_ref() {
@@ -437,6 +488,7 @@ impl Renderer {
         }
 
         self.0.data_stale.set(false);
+        self.0.presized_box.set(None);
         let result = if is_update {
             let task = plugin.update(view.clone().into(), limits.max_cols, limits.max_rows, false);
             activate_plugin(_guard, &viewer_elem, &plugin, slot.as_deref(), task).await
@@ -473,3 +525,38 @@ impl Renderer {
         self.draw_lock.clone()
     }
 }
+
+/// RAII increment of [`RendererData::presize_pending`], the counter that
+/// gates [`Renderer::update_lazy`] dispatches. Decrementing on `Drop`
+/// (not on the happy path) makes the release unconditional — a presize
+/// future cancelled mid-await can never strand the counter above zero,
+/// which would silently discard every subsequent debounced update for
+/// the panel's lifetime.
+struct PresizePendingGuard(Renderer);
+
+impl PresizePendingGuard {
+    fn increment(renderer: &Renderer) -> Self {
+        let cell = &renderer.0.presize_pending;
+        cell.set(cell.get() + 1);
+        Self(renderer.clone())
+    }
+}
+
+impl Drop for PresizePendingGuard {
+    fn drop(&mut self) {
+        let cell = &self.0.0.presize_pending;
+        cell.set(cell.get() - 1);
+    }
+}
+
+fn stamp_theme_attr(el: &Element, theme: Option<&str>) {
+    match theme {
+        Some(theme) if el.get_attribute("theme").as_deref() != Some(theme) => {
+            let _ = el.set_attribute("theme", theme);
+        },
+        Some(_) => {},
+        None => {
+            let _ = el.remove_attribute("theme");
+        },
+    }
+}

package/src/rust/renderer/limits.rs

@@ -10,6 +10,7 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
+use perspective_client::proto::ViewDimensionsResp;
 use perspective_js::utils::ApiError;
 
 use crate::config::PluginStaticConfig;
@@ -31,16 +32,34 @@ pub struct RenderLimits {
     pub max_rows: Option<usize>,
 }
 
-/// Compute the row/column caps for `view` against the plugin's static
-/// limits. `render_warning` is the renderer-state flag controlling
-/// whether the warning is currently armed; when `false`, an oversized
-/// view renders uncapped (the user has dismissed the warning).
+impl RenderLimits {
+    /// The column cap is in effect (fewer columns render than the view has).
+    pub fn is_col_capped(&self) -> bool {
+        self.max_cols.is_some_and(|x| x < self.num_cols)
+    }
+
+    /// The row cap is in effect (fewer rows render than the view has).
+    pub fn is_row_capped(&self) -> bool {
+        self.max_rows.is_some_and(|x| x < self.num_rows)
+    }
+
+    /// Either cap is in effect — exactly when the render warning shows.
+    pub fn is_capped(&self) -> bool {
+        self.is_col_capped() || self.is_row_capped()
+    }
+}
+
+/// Compute the row/column caps for `view` from its already-fetched
+/// `dimensions` against the plugin's static limits. `render_warning` is the
+/// renderer-state flag controlling whether the warning is currently armed;
+/// when `false`, an oversized view renders uncapped (the user has dismissed
+/// the warning).
 pub async fn get_row_and_col_limits(
+    dimensions: &ViewDimensionsResp,
     view: &perspective_client::View,
     config: &PluginStaticConfig,
     render_warning: bool,
 ) -> Result<RenderLimits, ApiError> {
-    let dimensions = view.dimensions().await?;
     let num_cols = dimensions.num_view_columns as usize;
     let num_rows = dimensions.num_view_rows as usize;
     match (config.max_columns, render_warning) {