@perspective-dev/viewer 4.4.1 → 4.5.0

package/src/rust/{engines.rs → queries/validate_expression.rs}

@@ -10,19 +10,30 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
-//! Engine-handle types for the four major state singletons.
-//!
-//! These are the async-machinery halves of the engine/value split described in
-//! the props modules.  They own JS object handles, draw locks, async
-//! subscriptions, and PubSub channels — i.e. anything that cannot be cheaply
-//! cloned into a plain `PartialEq` prop.
-//!
-//! **Current status (Step 3 of the migration):** Each `*Engine` type is a thin
-//! type alias for the existing `Rc<*Handle>` wrapper.  They will be replaced
-//! with true struct types in later migration steps once the component tree has
-//! been updated to consume value-semantic props instead of the old handles.
+use std::collections::HashMap;
 
-pub use crate::dragdrop::DragDrop as DragDropEngine;
-pub use crate::presentation::Presentation as PresentationEngine;
-pub use crate::renderer::Renderer as RendererEngine;
-pub use crate::session::Session as SessionEngine;
+use perspective_client::ExprValidationError;
+use perspective_client::config::ExpressionsDeserde;
+use perspective_js::utils::ApiError;
+
+use crate::session::Session;
+
+/// Validate an expression string against the active table; returns the
+/// per-expression error map entry (if any).
+pub async fn validate_expr(
+    session: &Session,
+    expr: &str,
+) -> Result<Option<ExprValidationError>, ApiError> {
+    let table = session
+        .get_table()
+        .ok_or_else(|| ApiError::from("No table set"))?;
+    let errors = table
+        .validate_expressions(
+            ExpressionsDeserde::Map(HashMap::from_iter([("_".to_string(), expr.to_string())]))
+                .into(),
+        )
+        .await?
+        .errors;
+
+    Ok(errors.get("_").cloned())
+}

package/src/rust/renderer/activate.rs

@@ -36,6 +36,7 @@ pub async fn activate_plugin<T>(
     if html_plugin.parent_node().is_none() {
         html_plugin.style().set_property("opacity", "0")?;
         viewer.append_child(html_plugin)?;
+        plugin.restyle();
     }
 
     let result = task.await;

package/src/rust/renderer/limits.rs

@@ -12,7 +12,7 @@
 
 use perspective_js::utils::ApiError;
 
-use crate::js::plugin::*;
+use crate::config::PluginStaticConfig;
 
 /// The row/column limits computed for the current view and plugin
 /// configuration.
@@ -31,14 +31,19 @@ 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).
 pub async fn get_row_and_col_limits(
     view: &perspective_client::View,
-    plugin_metadata: &ViewConfigRequirements,
+    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 (plugin_metadata.max_columns, plugin_metadata.render_warning) {
+    match (config.max_columns, render_warning) {
         (Some(_), false) => Ok(RenderLimits {
             is_update: false,
             num_cols,
@@ -60,7 +65,7 @@ pub async fn get_row_and_col_limits(
                 }
             });
 
-            let max_rows = plugin_metadata.max_cells.map(|max_cells| {
+            let max_rows = config.max_cells.map(|max_cells| {
                 match max_cols {
                     Some(max_cols) => max_cells as f64 / max_cols as f64,
                     None => max_cells as f64 / num_cols as f64,

package/src/rust/renderer/plugin_store.rs

@@ -11,19 +11,23 @@
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
 use std::collections::HashMap;
+use std::rc::Rc;
 
 use super::registry::*;
+use crate::config::PluginStaticConfig;
 use crate::js::plugin::*;
 
 #[derive(Default)]
 pub struct PluginStore {
     plugins: Option<Vec<JsPerspectiveViewerPlugin>>,
+    plugin_configs: Option<Vec<Rc<PluginStaticConfig>>>,
     plugin_records: Option<HashMap<String, Vec<String>>>,
 }
 
 impl PluginStore {
     fn init_lazy(&mut self) {
         self.plugins = Some(PLUGIN_REGISTRY.create_plugins());
+        self.plugin_configs = Some(PLUGIN_REGISTRY.plugin_configs());
         self.plugin_records = Some(PLUGIN_REGISTRY.available_plugin_names_by_category());
     }
 
@@ -35,6 +39,14 @@ impl PluginStore {
         self.plugins.as_ref().unwrap()
     }
 
+    pub fn plugin_configs(&mut self) -> &Vec<Rc<PluginStaticConfig>> {
+        if self.plugins.is_none() {
+            self.init_lazy();
+        }
+
+        self.plugin_configs.as_ref().unwrap()
+    }
+
     pub fn plugin_records(&mut self) -> &HashMap<String, Vec<String>> {
         if self.plugins.is_none() {
             self.init_lazy();

package/src/rust/renderer/props.rs

@@ -10,7 +10,9 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
-use crate::js::plugin::ViewConfigRequirements;
+use std::rc::Rc;
+
+use crate::config::PluginStaticConfig;
 use crate::renderer::limits::RenderLimits;
 use crate::utils::PtrEqRc;
 
@@ -23,12 +25,35 @@ pub struct RendererProps {
     /// Name of the currently active plugin (e.g. `"Datagrid"`).
     pub plugin_name: Option<String>,
 
-    /// Column count / config requirements reported by the active plugin.
-    pub requirements: ViewConfigRequirements,
+    /// Cached static config of the active plugin (column requirements,
+    /// rollup modes, render caps, etc.). Shared with the renderer's
+    /// internal `metadata` — `Rc::ptr_eq` works.
+    pub config: Rc<PluginStaticConfig>,
 
     /// Most recently emitted render limits, if any.
     pub render_limits: Option<RenderLimits>,
 
     /// Names of all registered plugins, in registration order.
     pub available_plugins: PtrEqRc<Vec<String>>,
+
+    /// `true` when the active plugin is anything other than the
+    /// `Datagrid`. Changes only when the active plugin swaps, so reading
+    /// from this prop avoids a per-render `Renderer::is_chart()` call.
+    pub is_chart: bool,
+
+    /// Snapshot of the active plugin's `plugin_config` bucket. Re-read
+    /// by `Renderer::to_props` on `plugin_config_changed` /
+    /// `plugin_changed` (the active bucket changes on plugin switch).
+    /// Consumed by `PluginTab` so the tab is a pure function of its
+    /// props — no direct `Renderer::get_plugin_config()` reads against
+    /// the interior-mutable handle, no manual PubSub subscription, no
+    /// race window between `plugins_idx` swap and the schema query.
+    pub plugin_config: PtrEqRc<serde_json::Map<String, serde_json::Value>>,
+}
+
+impl RendererProps {
+    /// Whether the active plugin opts into per-column style controls.
+    pub fn can_render_column_styles(&self) -> bool {
+        self.config.can_render_column_styles
+    }
 }

package/src/rust/renderer/registry.rs

@@ -21,6 +21,7 @@ use wasm_bindgen::JsCast;
 use wasm_bindgen::prelude::*;
 use web_sys::*;
 
+use crate::config::{ColumnSelectMode, PluginStaticConfig};
 use crate::js::plugin::*;
 
 thread_local! {
@@ -28,10 +29,8 @@ thread_local! {
 }
 
 pub struct PluginRecord {
-    name: String,
-    category: String,
     tag_name: String,
-    priority: i32,
+    config: Rc<PluginStaticConfig>,
 }
 
 /// A global registry of all plugins that have been registered.
@@ -59,13 +58,27 @@ pub impl LocalKey<Rc<RefCell<Vec<PluginRecord>>>> {
         .unwrap()
     }
 
+    /// Returns the cached `PluginStaticConfig`s for every registered
+    /// plugin, in registration order. The renderer reads these at
+    /// activation time instead of calling back into JS for each field.
+    fn plugin_configs(&'static self) -> Vec<Rc<PluginStaticConfig>> {
+        register_default();
+        self.with(|plugins| {
+            plugins
+                .borrow()
+                .iter()
+                .map(|plugin| plugin.config.clone())
+                .collect()
+        })
+    }
+
     fn default_plugin_name(&'static self) -> String {
         register_default();
         self.with(|plugins| {
             plugins
                 .borrow()
                 .iter()
-                .map(|plugin| plugin.name.to_owned())
+                .map(|plugin| plugin.config.name.clone())
                 .next()
                 .unwrap()
         })
@@ -77,9 +90,15 @@ pub impl LocalKey<Rc<RefCell<Vec<PluginRecord>>>> {
             plugins.borrow().iter().fold(
                 HashMap::<String, Vec<String>>::default(),
                 |mut acc, plugin| {
-                    acc.entry(plugin.category.to_owned())
+                    let category = plugin
+                        .config
+                        .category
+                        .clone()
+                        .unwrap_or_else(|| "Custom".to_owned());
+
+                    acc.entry(category)
                         .or_default()
-                        .push(plugin.name.to_owned());
+                        .push(plugin.config.name.clone());
                     acc
                 },
             )
@@ -94,13 +113,10 @@ pub impl LocalKey<Rc<RefCell<Vec<PluginRecord>>>> {
 
         self.with(|plugin| {
             let plugin_inst = create_plugin(tag_name);
+            let config = Rc::new(plugin_inst.read_static_config());
             let record = PluginRecord {
                 tag_name: tag_name.to_owned(),
-                name: plugin_inst.name(),
-                category: plugin_inst
-                    .category()
-                    .unwrap_or_else(|| "Custom".to_owned()),
-                priority: plugin_inst.priority().unwrap_or_default(),
+                config,
             };
 
             let mut plugins = plugin.borrow_mut();
@@ -111,7 +127,12 @@ pub impl LocalKey<Rc<RefCell<Vec<PluginRecord>>>> {
             }
 
             plugins.push(record);
-            plugins.sort_by(|a, b| Ord::cmp(&b.priority, &a.priority));
+            plugins.sort_by(|a, b| {
+                Ord::cmp(
+                    &b.config.priority.unwrap_or(0),
+                    &a.config.priority.unwrap_or(0),
+                )
+            });
         });
     }
 
@@ -125,10 +146,14 @@ fn register_default() {
     PLUGIN_REGISTRY.with(|plugins| {
         if plugins.borrow().is_empty() {
             plugins.borrow_mut().push(PluginRecord {
-                name: "Debug".to_owned(),
-                category: "Custom".to_owned(),
                 tag_name: "perspective-viewer-plugin".to_owned(),
-                priority: -1,
+                config: Rc::new(PluginStaticConfig {
+                    name: "Debug".to_owned(),
+                    category: Some("Custom".to_owned()),
+                    select_mode: ColumnSelectMode::Select,
+                    priority: Some(-1),
+                    ..PluginStaticConfig::default()
+                }),
             })
         }
     })