@perspective-dev/viewer 4.0.0

package/src/rust/session/drag_drop_update.rs

@@ -0,0 +1,179 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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 perspective_client::config::*;
+
+use crate::dragdrop::{DragEffect, DragTarget};
+use crate::js::plugin::ViewConfigRequirements;
+
+#[allow(clippy::too_many_arguments)]
+#[extend::ext]
+pub impl ViewConfig {
+    /// Create an update for this `ViewConfig` which applies a drag/drop action.
+    /// This method is designed to be called from `crate::session`.
+    fn create_drag_drop_update(
+        &self,
+        column: String,
+        col_type: ColumnType,
+        index: usize,
+        drop: DragTarget,
+        drag: DragEffect,
+        requirements: &ViewConfigRequirements,
+        features: &perspective_client::Features,
+    ) -> ViewConfigUpdate {
+        let mut config = self.clone();
+        let mut update = ViewConfigUpdate::default();
+        let is_to_swap = requirements.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))
+            .unwrap_or_default();
+
+        let is_from_swap = from_index
+            .map(|x| requirements.is_swap(x))
+            .unwrap_or_default();
+
+        let is_to_empty = config
+            .columns
+            .get(index)
+            .map(|x| x.is_none())
+            .unwrap_or_default();
+
+        let is_swap_to_after_last = index == config.columns.len() && from_index.is_some();
+        match drag {
+            DragEffect::Copy => (),
+            DragEffect::Move(DragTarget::Active) => {
+                let is_to_group_or_split =
+                    matches!(drop, DragTarget::GroupBy | DragTarget::SplitBy);
+
+                if ((!is_to_swap && is_from_swap)
+                    || (is_to_swap && !is_from_swap && is_to_empty)
+                    || is_to_group_or_split)
+                    && config.columns.len() > 1
+                    && !is_from_required
+                    && !is_swap_to_after_last
+                {
+                    // Is not a swap
+                    if !is_to_swap && !is_to_group_or_split {
+                        config.columns.iter_mut().for_each(|x| {
+                            if x.as_ref() == Some(&column) {
+                                *x = None;
+                            }
+                        });
+                    } else {
+                        config.columns.retain(|x| x.as_ref() != Some(&column));
+                    }
+
+                    update.columns = Some(config.columns.clone());
+                }
+            },
+            DragEffect::Move(DragTarget::GroupBy) => {
+                config.group_by.retain(|x| x != &column);
+                update.group_by = Some(config.group_by.clone());
+            },
+            DragEffect::Move(DragTarget::SplitBy) => {
+                config.split_by.retain(|x| x != &column);
+                update.split_by = Some(config.split_by.clone());
+            },
+            DragEffect::Move(DragTarget::Sort) => {
+                config.sort.retain(|x| x.0 != column);
+                update.sort = Some(config.sort.clone());
+            },
+            DragEffect::Move(DragTarget::Filter) => {
+                config.filter.retain(|x| x.column() != column);
+                update.filter = Some(config.filter.clone());
+            },
+        }
+
+        match drop {
+            DragTarget::Active => {
+                if !is_swap_to_after_last {
+                    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);
+
+                            if fill_to >= (config.columns.len() - 1) {
+                                fill_to + 1 - config.columns.len()
+                            } else {
+                                0
+                            }
+                        }));
+
+                        if let Some(prev) = config.columns.iter().position(|x| *x == column) {
+                            config.columns.swap(index, prev);
+                        } else {
+                            config.columns[index] = column;
+                        }
+                    } else {
+                        config.columns.retain(|x| x.as_ref() != Some(&column));
+                        config.columns.extend(std::iter::repeat_n(
+                            None,
+                            if index >= config.columns.len() {
+                                index - config.columns.len()
+                            } else {
+                                0
+                            },
+                        ));
+
+                        if is_to_empty {
+                            config.columns[index] = Some(column)
+                        } else {
+                            config.columns.insert(index, Some(column));
+                        }
+                    }
+
+                    update.columns = Some(config.columns);
+                }
+            },
+            DragTarget::GroupBy => {
+                config.group_by.retain(|x| x != &column);
+                let index = std::cmp::min(index, config.group_by.len());
+                config.group_by.insert(index, column);
+                update.group_by = Some(config.group_by);
+            },
+            DragTarget::SplitBy => {
+                config.split_by.retain(|x| x != &column);
+                let index = std::cmp::min(index, config.split_by.len());
+                config.split_by.insert(index, column);
+                update.split_by = Some(config.split_by);
+            },
+            DragTarget::Sort => {
+                let index = std::cmp::min(index, config.sort.len());
+                config.sort.insert(index, Sort(column, SortDir::Asc));
+                update.sort = Some(config.sort);
+            },
+            DragTarget::Filter => {
+                let index = std::cmp::min(index, config.filter.len());
+                config.filter.insert(
+                    index,
+                    Filter::new(
+                        &column,
+                        features.default_op(col_type).unwrap_or(""),
+                        FilterTerm::Scalar(Scalar::Null),
+                    ),
+                );
+                update.filter = Some(config.filter);
+            },
+        }
+
+        update
+    }
+}

package/src/rust/session/metadata.rs

@@ -0,0 +1,308 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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 std::collections::{HashMap, HashSet};
+use std::iter::IntoIterator;
+use std::ops::{Deref, DerefMut};
+
+use perspective_client::config::*;
+use perspective_js::apierror;
+
+use crate::components::viewer::ColumnLocator;
+use crate::*;
+
+struct SessionViewExpressionMetadata {
+    edited: HashMap<String, String>,
+    expressions: perspective_client::ExprValidationResult,
+}
+
+/// Metadata state reflects data we could fetch from a `View`, but would like to
+/// do so without `async`.  It must be recreated by any `async` method which
+/// changes the `View` and may temporarily be out-of-sync with the
+/// `View`/`ViewConfig`.
+#[derive(Default)]
+pub struct SessionMetadata(Option<SessionMetadataState>);
+
+impl Deref for SessionMetadata {
+    type Target = Option<SessionMetadataState>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for SessionMetadata {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+/// TODO the multiple `Option` types could probably be merged since they are
+/// populated within an async lock
+#[derive(Default)]
+pub struct SessionMetadataState {
+    features: perspective_client::Features,
+    column_names: Vec<String>,
+    table_schema: HashMap<String, ColumnType>,
+    edit_port: f64,
+    view_schema: Option<HashMap<String, ColumnType>>,
+    expr_meta: Option<SessionViewExpressionMetadata>,
+}
+
+impl SessionMetadata {
+    /// Creates a new `SessionMetadata` from a `JsPerspectiveTable`.
+    pub(super) async fn from_table(table: &perspective_client::Table) -> ApiResult<Self> {
+        let features = table.get_features().await?.clone();
+        let column_names = table.columns().await?;
+        let table_schema = table.schema().await?;
+        let edit_port = table.make_port().await? as f64;
+        Ok(Self(Some(SessionMetadataState {
+            features,
+            column_names,
+            table_schema,
+            edit_port,
+            ..SessionMetadataState::default()
+        })))
+    }
+
+    pub(super) fn update_view_schema(
+        &mut self,
+        view_schema: &HashMap<String, ColumnType>,
+    ) -> ApiResult<()> {
+        self.as_mut().unwrap().view_schema = Some(view_schema.clone());
+        Ok(())
+    }
+
+    pub(super) fn update_expressions(
+        &mut self,
+        valid_recs: &perspective_client::ExprValidationResult,
+    ) -> ApiResult<HashSet<String>> {
+        if !valid_recs.errors.is_empty() {
+            return Err(apierror!(InvalidViewerConfigExpressionsError(
+                valid_recs.clone().into(),
+            )));
+        }
+
+        let mut edited = self
+            .as_mut()
+            .unwrap()
+            .expr_meta
+            .take()
+            .map(|x| x.edited)
+            .unwrap_or_default();
+
+        edited.retain(|k, _| valid_recs.expression_alias.contains_key(k));
+        self.as_mut().unwrap().expr_meta = Some(SessionViewExpressionMetadata {
+            expressions: valid_recs.clone(),
+            edited,
+        });
+
+        Ok(valid_recs.expression_schema.keys().cloned().collect())
+    }
+
+    /// Get the `Table`'s supported features.
+    pub fn get_features(&self) -> Option<&'_ perspective_client::Features> {
+        Some(&self.as_ref()?.features)
+    }
+
+    /// Returns the unique column names in this session that are expression
+    /// columns.
+    pub fn get_expression_columns(&self) -> impl Iterator<Item = &'_ String> {
+        maybe!(Some(
+            self.as_ref()?
+                .expr_meta
+                .as_ref()?
+                .expressions
+                .expression_schema
+                .keys()
+        ))
+        .into_iter()
+        .flatten()
+    }
+
+    /// Returns the full original expression `String` for an expression alias.
+    /// TODO should expressions be `Rc`?
+    ///
+    /// # Arguments
+    /// - `alias` An alias name for an expression column in this `Session`.
+    pub fn get_expression_by_alias(&self, alias: &str) -> Option<String> {
+        self.as_ref()?
+            .expr_meta
+            .as_ref()?
+            .expressions
+            .expression_alias
+            .get(alias)
+            .cloned()
+    }
+
+    /// Returns the edited expression `String` (e.g. the not-yet-saved, edited
+    /// expression state of a column, if any) for an expression alias.
+    ///
+    /// # Arguments
+    /// - `alias` An alias name for an expression column in this `Session`.
+    pub fn get_edit_by_alias(&self, alias: &str) -> Option<String> {
+        maybe!(
+            self.as_ref()?
+                .expr_meta
+                .as_ref()?
+                .edited
+                .get(alias)
+                .cloned()
+        )
+    }
+
+    pub fn set_edit_by_alias(&mut self, alias: &str, edit: String) {
+        drop(maybe!(
+            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)
+        ))
+    }
+
+    pub fn get_table_columns(&self) -> Option<&'_ Vec<String>> {
+        self.as_ref().map(|meta| &meta.column_names)
+    }
+
+    pub fn is_column_expression(&self, name: &str) -> bool {
+        let is_expr = maybe!(Some(
+            self.as_ref()?
+                .expr_meta
+                .as_ref()?
+                .expressions
+                .expression_schema
+                .contains_key(name)
+        ));
+
+        is_expr.unwrap_or_default()
+    }
+
+    /// This function will find a currently existing column. If you want to
+    /// create a new expression column, use ColumnLocator::Expr(None)
+    pub fn get_column_locator(&self, name: Option<String>) -> Option<ColumnLocator> {
+        name.and_then(|name| {
+            self.as_ref().and_then(|meta| {
+                if self.is_column_expression(&name) {
+                    Some(ColumnLocator::Expression(name))
+                } else {
+                    meta.column_names
+                        .iter()
+                        .find_map(|n| (n == &name).then_some(ColumnLocator::Table(name.clone())))
+                }
+            })
+        })
+    }
+
+    /// Creates a new column name by appending a numeral corresponding to the
+    /// number of columns with that name.
+    pub fn make_new_column_name(&self, col: Option<&str>) -> String {
+        let mut i = 0;
+        loop {
+            i += 1;
+            let name = format!("{} {i}", col.unwrap_or("New Column"));
+            if self.get_column_table_type(&name).is_none() {
+                return name;
+            }
+        }
+    }
+
+    pub fn get_edit_port(&self) -> Option<f64> {
+        self.as_ref().map(|meta| meta.edit_port)
+    }
+
+    /// Returns the type of a column name relative to the `Table`.  Despite the
+    /// name, `get_column_table_type()` also returns the `Table` type for
+    /// Expressions, which despite living on the `View` still have a `table`
+    /// type associated with them pre-aggregation.
+    ///
+    /// # Arguments
+    /// - `name` The column name (or expresison alias) to retrieve a principal
+    ///   type.
+    pub fn get_column_table_type(&self, name: &str) -> Option<ColumnType> {
+        maybe!({
+            let meta = self.as_ref()?;
+            meta.table_schema.get(name).cloned().or_else(|| {
+                meta.expr_meta
+                    .as_ref()?
+                    .expressions
+                    .expression_schema
+                    .get(name)
+                    .cloned()
+            })
+        })
+    }
+
+    /// Returns the type of a column name relative to the `View`, including
+    /// expression columns which were part of the `ViewConfig`.  Types
+    /// returned from the `View` incorporate the type transform applied by
+    /// their aggregate if applicable, so may differ from the type returned
+    /// by `get_column_table_type()`.
+    ///
+    /// # Arguments
+    /// - `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()
+    }
+
+    pub fn get_column_aggregates<'a>(
+        &'a self,
+        name: &str,
+    ) -> Option<Box<dyn Iterator<Item = Aggregate> + 'a>> {
+        let coltype = self.get_column_table_type(name)?;
+        let f = self.get_features()?.aggregates.get(&(coltype as u32))?;
+
+        let aggregates = f
+            .aggregates
+            .iter()
+            .flat_map(move |x| {
+                if x.args.is_empty() {
+                    Some(vec![Aggregate::SingleAggregate(x.name.to_string())])
+                } else {
+                    // todo: handle multi args
+                    let dtype = x.args.first().unwrap();
+                    Some(
+                        self.get_expression_columns()
+                            .cloned()
+                            .chain(self.get_table_columns()?.clone().into_iter())
+                            .map(move |name| {
+                                self.get_column_table_type(&name)
+                                    .map(|coltype| (name, coltype))
+                            })
+                            .collect::<Option<Vec<_>>>()?
+                            .into_iter()
+                            .filter(move |(_, coltype)| {
+                                *coltype as i32 == *dtype
+                                    || (coltype == &ColumnType::Integer
+                                        && *dtype == ColumnType::Float as i32)
+                                    || (coltype == &ColumnType::Float
+                                        && *dtype == ColumnType::Integer as i32)
+                            })
+                            .map(|(name, _)| {
+                                Aggregate::MultiAggregate(x.name.to_string(), vec![name])
+                            })
+                            .collect(),
+                    )
+                }
+            })
+            .flatten();
+
+        Some(Box::new(aggregates))
+    }
+}

package/src/rust/session/replace_expression_update.rs

@@ -0,0 +1,131 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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 std::collections::HashMap;
+
+use perspective_client::config::*;
+
+#[extend::ext]
+pub impl ViewConfig {
+    /// Create an update for this `ViewConfig` that replaces an expression
+    /// column with a new one, e.g. when a user edits an expression.  This may
+    /// changed either the expression alias, the expression itself, or both; as
+    /// well as any other fields that reference the expression column by alias.
+    ///
+    /// This method is designed to be called from `crate::session` which can
+    /// fill in `old_expression` and `new_alias`.
+    fn create_replace_expression_update(
+        &self,
+        old_expr: &Expression,
+        new_expr: &Expression,
+    ) -> ViewConfigUpdate {
+        let expression = new_expr;
+        let Self {
+            columns,
+            expressions,
+            group_by,
+            split_by,
+            sort,
+            filter,
+            aggregates,
+            filter_op: _,
+            group_by_depth: _,
+        } = self.clone();
+
+        let expressions = expressions
+            .iter()
+            .map(|(serde_name, serde_expr)| {
+                if &old_expr.name == serde_name {
+                    expression.to_owned()
+                } else {
+                    Expression::new(Some(serde_name.into()), serde_expr.into())
+                }
+            })
+            .collect::<Expressions>();
+
+        let aggregates = aggregates
+            .into_iter()
+            .map(|x| {
+                if x.0 == old_expr.name {
+                    (expression.name.as_ref().to_owned(), x.1)
+                } else {
+                    x
+                }
+            })
+            .collect::<HashMap<_, _>>();
+
+        let columns = columns
+            .into_iter()
+            .map(|x| match x {
+                Some(x) if x == old_expr.name => Some(new_expr.name.as_ref().to_owned()),
+                x => x,
+            })
+            .collect::<Vec<_>>();
+
+        let group_by = group_by
+            .into_iter()
+            .map(|x| {
+                if x == old_expr.name {
+                    new_expr.name.as_ref().to_owned()
+                } else {
+                    x
+                }
+            })
+            .collect::<Vec<_>>();
+
+        let split_by = split_by
+            .into_iter()
+            .map(|x| {
+                if x == old_expr.name {
+                    new_expr.name.as_ref().to_owned()
+                } else {
+                    x
+                }
+            })
+            .collect::<Vec<_>>();
+
+        let sort = sort
+            .into_iter()
+            .map(|x| {
+                if x.0 == old_expr.name {
+                    Sort(new_expr.name.as_ref().to_owned(), x.1)
+                } else {
+                    x
+                }
+            })
+            .collect::<Vec<_>>();
+
+        // TODO expression editing can change type, which may invalidate filters
+        let filter = filter
+            .into_iter()
+            .map(|x| {
+                if x.column() == old_expr.name {
+                    Filter::new(new_expr.name.as_ref(), x.op(), x.term().clone())
+                } else {
+                    x
+                }
+            })
+            .collect::<Vec<_>>();
+
+        ViewConfigUpdate {
+            columns: Some(columns),
+            aggregates: Some(aggregates),
+            expressions: Some(expressions),
+            group_by: Some(group_by),
+            split_by: Some(split_by),
+            sort: Some(sort),
+            filter: Some(filter),
+            filter_op: None,
+            group_by_depth: None,
+        }
+    }
+}