@perspective-dev/viewer 4.4.1 → 4.5.0

package/src/rust/session/column_defaults_update.rs

@@ -16,27 +16,28 @@ use itertools::Itertools;
 use perspective_client::config::*;
 
 use super::metadata::*;
-use crate::js::plugin::*;
+use crate::config::PluginStaticConfig;
 
 #[extend::ext]
 pub impl ViewConfigUpdate {
     /// Appends additional columns to the `columns` field of this
     /// `ViewConfigUpdate` by picking appropriate new columns from the
-    /// `SessionMetadata`, give the necessary column requirements of the plugin
-    /// provided by a `ViewConfigRequirements`.  For example, an "X/Y Scatter"
-    /// chart needs a minimum of 2 numeric columns to be drawable.
+    /// `SessionMetadata`, given the necessary column requirements of the
+    /// plugin provided by a `PluginStaticConfig`. For example, an "X/Y
+    /// Scatter" chart needs a minimum of 2 numeric columns to be
+    /// drawable.
     fn set_update_column_defaults(
         &mut self,
         metadata: &SessionMetadata,
         columns: &[Option<String>],
-        requirements: &ViewConfigRequirements,
+        config_static: &PluginStaticConfig,
     ) {
         let rollup_features = metadata
             .get_features()
             .map(|x| x.get_group_rollup_modes())
             .unwrap_or_default();
 
-        let group_rollups = requirements.get_group_rollups(&rollup_features);
+        let group_rollups = config_static.get_group_rollups(&rollup_features);
         if !group_rollups.contains(
             self.group_rollup_mode
                 .as_ref()
@@ -49,15 +50,8 @@ pub impl ViewConfigUpdate {
             );
         }
 
-        if let (
-            None,
-            ViewConfigRequirements {
-                min: Some(min_cols),
-                names,
-                ..
-            },
-        ) = (&self.columns, &requirements)
-        {
+        if let (None, Some(min_cols)) = (&self.columns, config_static.min_config_columns) {
+            let names_len = config_static.config_column_names.len();
             // first try to take 2 numeric columns from existing config
             let numeric_config_columns = columns
                 .iter()
@@ -68,16 +62,16 @@ pub impl ViewConfigUpdate {
                         Some(ColumnType::Float | ColumnType::Integer)
                     )
                 })
-                .take(*min_cols)
+                .take(min_cols)
                 .cloned()
                 .map(Some)
                 .collect::<Vec<_>>();
 
-            if numeric_config_columns.len() == *min_cols {
+            if numeric_config_columns.len() == min_cols {
                 self.columns = Some(
                     numeric_config_columns
                         .into_iter()
-                        .pad_using(names.as_ref().map_or(0, |x| x.len()), |_| None)
+                        .pad_using(names_len, |_| None)
                         .collect::<Vec<_>>(),
                 );
             } else {
@@ -104,14 +98,14 @@ pub impl ViewConfigUpdate {
                             .cloned()
                             .map(Some),
                     )
-                    .take(*min_cols)
+                    .take(min_cols)
                     .collect::<Vec<_>>();
 
-                if config_columns.len() == *min_cols {
+                if config_columns.len() == min_cols {
                     self.columns = Some(
                         config_columns
                             .into_iter()
-                            .pad_using(names.as_ref().map_or(0, |x| x.len()), |_| None)
+                            .pad_using(names_len, |_| None)
                             .collect::<Vec<_>>(),
                     );
                 } else {
@@ -120,7 +114,7 @@ pub impl ViewConfigUpdate {
                             .get_table_columns()
                             .into_iter()
                             .flatten()
-                            .take(*min_cols)
+                            .take(min_cols)
                             .cloned()
                             .map(Some)
                             .collect::<Vec<_>>(),
@@ -132,16 +126,14 @@ pub impl ViewConfigUpdate {
             let initial_len = self.columns.as_ref().map(|x| x.len()).unwrap_or_default();
             if let Some(last_filled) = columns.iter().rposition(|x| x.is_some()) {
                 columns.truncate(last_filled + 1);
-                if let ViewConfigRequirements {
-                    names: Some(names), ..
-                } = &requirements
-                {
+                if !config_static.config_column_names.is_empty() {
+                    let names_len = config_static.config_column_names.len();
                     columns = columns
                         .into_iter()
                         .enumerate()
-                        .filter(|(idx, x)| *idx < names.len() || x.is_some())
+                        .filter(|(idx, x)| *idx < names_len || x.is_some())
                         .map(|(_, x)| x)
-                        .pad_using(names.len(), |_| None)
+                        .pad_using(names_len, |_| None)
                         .collect::<Vec<_>>();
                 } else {
                     columns = columns

package/src/rust/session/drag_drop_update.rs

@@ -12,7 +12,7 @@
 
 use perspective_client::config::*;
 
-use crate::js::plugin::ViewConfigRequirements;
+use crate::config::PluginStaticConfig;
 use crate::utils::{DragEffect, DragTarget};
 
 #[allow(clippy::too_many_arguments)]
@@ -27,23 +27,23 @@ pub impl ViewConfig {
         index: usize,
         drop: DragTarget,
         drag: DragEffect,
-        requirements: &ViewConfigRequirements,
+        config_static: &PluginStaticConfig,
         features: &perspective_client::Features,
     ) -> ViewConfigUpdate {
         let mut config = self.clone();
         let mut update = ViewConfigUpdate::default();
-        let is_to_swap = requirements.is_swap(index);
+        let is_to_swap = config_static.is_swap(index);
         let from_index = config
             .columns
             .iter()
             .position(|x| x.as_ref() == Some(&column));
 
         let is_from_required = from_index
-            .and_then(|x| requirements.min.map(|z| x < z))
+            .and_then(|x| config_static.min_config_columns.map(|z| x < z))
             .unwrap_or_default();
 
         let is_from_swap = from_index
-            .map(|x| requirements.is_swap(x))
+            .map(|x| config_static.is_swap(x))
             .unwrap_or_default();
 
         let is_to_empty = config
@@ -104,11 +104,11 @@ pub impl ViewConfig {
                     if is_to_swap || is_from_required {
                         let column = Some(column);
                         config.columns.extend(std::iter::repeat_n(None, {
-                            let fill_to = requirements
-                                .names
-                                .as_ref()
-                                .map(|x| std::cmp::max(x.len() - 1, index))
-                                .unwrap_or(index);
+                            let fill_to = if config_static.config_column_names.is_empty() {
+                                index
+                            } else {
+                                std::cmp::max(config_static.config_column_names.len() - 1, index)
+                            };
 
                             if fill_to >= (config.columns.len() - 1) {
                                 fill_to + 1 - config.columns.len()

package/src/rust/session/metadata.rs

@@ -17,6 +17,7 @@ use std::ops::{Deref, DerefMut};
 use perspective_client::config::*;
 use perspective_js::apierror;
 
+use crate::presentation::ColumnLocator;
 use crate::utils::PtrEqRc;
 use crate::*;
 
@@ -140,14 +141,14 @@ impl SessionMetadata {
     }
 
     pub fn get_expression_columns(&self) -> impl Iterator<Item = &'_ String> {
-        maybe!(Some(
+        try {
             self.as_ref()?
                 .expr_meta
                 .as_ref()?
                 .expressions
                 .expression_schema
                 .keys()
-        ))
+        }
         .into_iter()
         .flatten()
     }
@@ -173,30 +174,28 @@ impl SessionMetadata {
     /// # Arguments
     /// - `alias` An alias name for an expression column in this `Session`.
     pub fn get_edit_by_alias(&self, alias: &str) -> Option<String> {
-        maybe!(
+        try {
             self.as_ref()?
                 .expr_meta
                 .as_ref()?
                 .edited
                 .get(alias)
-                .cloned()
-        )
+                .cloned()?
+        }
     }
 
     pub fn set_edit_by_alias(&mut self, alias: &str, edit: String) {
-        drop(maybe!(
+        let _: Option<_> = try {
             self.as_mut()?
                 .expr_meta
                 .as_mut()?
                 .edited
                 .insert(alias.to_owned(), edit)
-        ))
+        };
     }
 
     pub fn clear_edit_by_alias(&mut self, alias: &str) {
-        drop(maybe!(
-            self.as_mut()?.expr_meta.as_mut()?.edited.remove(alias)
-        ))
+        let _: Option<_> = try { self.as_mut()?.expr_meta.as_mut()?.edited.remove(alias) };
     }
 
     pub fn get_table_columns(&self) -> Option<&'_ Vec<String>> {
@@ -204,14 +203,14 @@ impl SessionMetadata {
     }
 
     pub fn is_column_expression(&self, name: &str) -> bool {
-        let is_expr = maybe!(Some(
+        let is_expr: Option<bool> = try {
             self.as_ref()?
                 .expr_meta
                 .as_ref()?
                 .expressions
                 .expression_schema
                 .contains_key(name)
-        ));
+        };
 
         is_expr.unwrap_or_default()
     }
@@ -242,7 +241,7 @@ impl SessionMetadata {
     /// - `name` The column name (or expresison alias) to retrieve a principal
     ///   type.
     pub fn get_column_table_type(&self, name: &str) -> Option<ColumnType> {
-        maybe!({
+        try {
             let meta = self.as_ref()?;
             meta.table_schema.get(name).cloned().or_else(|| {
                 meta.expr_meta
@@ -251,8 +250,8 @@ impl SessionMetadata {
                     .expression_schema
                     .get(name)
                     .cloned()
-            })
-        })
+            })?
+        }
     }
 
     /// Returns the type of a column name relative to the `View`, including
@@ -265,7 +264,23 @@ impl SessionMetadata {
     /// - `name` The column name (or expresison alias) to retrieve a `View`
     ///   type.
     pub fn get_column_view_type(&self, name: &str) -> Option<ColumnType> {
-        maybe!(self.as_ref()?.view_schema.as_ref()?.get(name)).cloned()
+        let r: Option<&ColumnType> = try { self.as_ref()?.view_schema.as_ref()?.get(name)? };
+        r.cloned()
+    }
+
+    /// Returns the column name for a locator, generating a default for new
+    /// expressions.
+    pub fn locator_name_or_default(&self, locator: &ColumnLocator) -> String {
+        match locator {
+            ColumnLocator::Table(s) | ColumnLocator::Expression(s) => s.clone(),
+            ColumnLocator::NewExpression => self.make_new_column_name(None),
+        }
+    }
+
+    /// Returns the view type for a locator's column, if available.
+    pub fn locator_view_type(&self, locator: &ColumnLocator) -> Option<ColumnType> {
+        let name = locator.name().cloned().unwrap_or_default();
+        self.get_column_view_type(name.as_str())
     }
 
     pub fn get_column_aggregates<'a>(

package/src/rust/session/props.rs

@@ -10,14 +10,16 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
+use std::collections::HashMap;
+
 use perspective_client::config::*;
 
-use crate::js::plugin::ViewConfigRequirements;
+use crate::config::PluginStaticConfig;
 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::{TableErrorState, ViewStats};
+use crate::session::{ColumnStats, TableErrorState, ViewStats};
 use crate::utils::*;
 
 #[derive(Clone, Debug, PartialEq, Default)]
@@ -55,6 +57,13 @@ pub struct SessionProps {
     /// expression info, etc. from this snapshot instead of borrowing
     /// `Session`'s `RefCell` directly.
     pub metadata: SessionMetadataRc,
+
+    /// Snapshot of the per-column stats cache (currently `abs_max`
+    /// only), populated lazily by the `fetch_column_abs_max` task.
+    /// Cleared whenever `view_config` changes; rebuilt on each
+    /// `to_props()` call when the root component re-renders in
+    /// response to `column_stats_changed`.
+    pub column_stats: PtrEqRc<HashMap<String, ColumnStats>>,
 }
 
 impl SessionProps {
@@ -109,7 +118,7 @@ impl SessionProps {
         index: usize,
         drop: DragTarget,
         drag: DragEffect,
-        requirements: &ViewConfigRequirements,
+        config_static: &PluginStaticConfig,
     ) -> ViewConfigUpdate {
         let col_type = self
             .metadata
@@ -122,7 +131,7 @@ impl SessionProps {
             index,
             drop,
             drag,
-            requirements,
+            config_static,
             self.metadata.get_features().unwrap(),
         )
     }
@@ -132,12 +141,12 @@ impl SessionProps {
     pub fn set_update_column_defaults(
         &self,
         config_update: &mut ViewConfigUpdate,
-        requirements: &ViewConfigRequirements,
+        config_static: &PluginStaticConfig,
     ) {
         config_update.set_update_column_defaults(
             &self.metadata,
             &self.all_columns().into_iter().map(Some).collect::<Vec<_>>(),
-            requirements,
+            config_static,
         )
     }
 

package/src/rust/session/view_subscription.rs

@@ -153,6 +153,16 @@ impl ViewSubscription {
         &self.data.view
     }
 
+    /// Snapshot of the [`ViewConfig`] the bound `View` was constructed
+    /// from (or its operationally-equivalent successor on the
+    /// [`ValidSession::create_view`] fast path). This is the
+    /// [`ViewConfig`] consistent with the data the active plugin is
+    /// currently rendering — not the live session config, which may
+    /// have been mutated synchronously ahead of the next queued draw.
+    pub fn get_view_config(&self) -> Rc<ViewConfig> {
+        self.data.config.clone()
+    }
+
     /// Delete this `View`. Neglecting to call this method before a
     /// `ViewSubscription` is dropped will result in a log warning, but the
     /// `View` will not leak.