@perspective-dev/viewer 4.2.0 → 4.4.0

package/src/rust/session/props.rs

@@ -0,0 +1,178 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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::js::plugin::ViewConfigRequirements;
+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::utils::*;
+
+#[derive(Clone, Debug, PartialEq, Default)]
+pub enum TableLoadState {
+    #[default]
+    Loaded,
+    Loading,
+}
+
+/// Value-semantic snapshot of the session state read by the root component.
+///
+/// This does not hold any async handles (`Table`, `View`, `Client`).  Those
+/// live inside `Session(Rc<SessionHandle>)` and are accessed directly when
+/// needed by async tasks.
+#[derive(Clone, Debug, PartialEq, Default)]
+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>,
+
+    /// `true` if a `Table` has been loaded into this session.
+    pub has_table: Option<TableLoadState>,
+
+    /// Non-`None` when the session is in an error state (e.g. table load
+    /// failure or client disconnection).
+    pub error: Option<TableErrorState>,
+
+    /// Optional title string set via `restore({ title: "..." })`.
+    pub title: Option<String>,
+
+    /// Cloned snapshot of `SessionMetadata` at the time of the last
+    /// `to_props()` call.  Components read column types, features,
+    /// expression info, etc. from this snapshot instead of borrowing
+    /// `Session`'s `RefCell` directly.
+    pub metadata: SessionMetadataRc,
+}
+
+impl SessionProps {
+    /// Returns `true` if the session is in any error state.
+    pub fn is_errored(&self) -> bool {
+        self.error.is_some()
+    }
+
+    /// Returns `true` if the error state represents a reconnectable
+    /// disconnection rather than a fatal failure.
+    pub fn is_reconnect(&self) -> bool {
+        self.error
+            .as_ref()
+            .map(|x| x.is_reconnect())
+            .unwrap_or_default()
+    }
+
+    /// Returns `true` if `name` appears in any active config slot (columns,
+    /// group-by, split-by, filter, or sort).
+    pub fn is_column_active(&self, name: &str) -> bool {
+        self.config.columns.iter().any(|maybe_col| {
+            maybe_col
+                .as_ref()
+                .map(|col| col == name)
+                .unwrap_or_default()
+        }) || self.config.group_by.iter().any(|col| col == name)
+            || self.config.split_by.iter().any(|col| col == name)
+            || self.config.filter.iter().any(|col| col.column() == name)
+            || self.config.sort.iter().any(|col| col.0 == name)
+    }
+
+    /// Returns `true` if the expression column `name` is referenced by any
+    /// part of the current view config.
+    pub fn is_column_expression_in_use(&self, name: &str) -> bool {
+        self.config.is_column_expression_in_use(name)
+    }
+
+    fn all_columns(&self) -> Vec<String> {
+        self.metadata
+            .get_table_columns()
+            .into_iter()
+            .flatten()
+            .cloned()
+            .collect()
+    }
+
+    /// Build a [`ViewConfigUpdate`] that applies a drag-drop of `column`
+    /// into the given `drop` target at `index`.
+    pub fn create_drag_drop_update(
+        &self,
+        column: String,
+        index: usize,
+        drop: DragTarget,
+        drag: DragEffect,
+        requirements: &ViewConfigRequirements,
+    ) -> ViewConfigUpdate {
+        let col_type = self
+            .metadata
+            .get_column_table_type(column.as_str())
+            .unwrap();
+
+        self.config.create_drag_drop_update(
+            column,
+            col_type,
+            index,
+            drop,
+            drag,
+            requirements,
+            self.metadata.get_features().unwrap(),
+        )
+    }
+
+    /// Populate `config_update` with default column settings (aggregates,
+    /// etc.) based on the current metadata and plugin requirements.
+    pub fn set_update_column_defaults(
+        &self,
+        config_update: &mut ViewConfigUpdate,
+        requirements: &ViewConfigRequirements,
+    ) {
+        config_update.set_update_column_defaults(
+            &self.metadata,
+            &self.all_columns().into_iter().map(Some).collect::<Vec<_>>(),
+            requirements,
+        )
+    }
+
+    /// Build a [`ViewConfigUpdate`] that replaces `old_expr_name` with
+    /// `new_expr` in every config slot where it appears.
+    pub fn create_replace_expression_update(
+        &self,
+        old_expr_name: &str,
+        new_expr: &Expression<'static>,
+    ) -> ViewConfigUpdate {
+        let old_expr_val = self
+            .metadata
+            .get_expression_by_alias(old_expr_name)
+            .unwrap();
+
+        let old_expr = Expression::new(Some(old_expr_name.into()), old_expr_val.into());
+        self.config
+            .create_replace_expression_update(&old_expr, new_expr)
+    }
+
+    /// Build a [`ViewConfigUpdate`] that renames `old_expr_name` to
+    /// `new_expr_name` (or clears the alias if `None`), keeping the
+    /// expression body unchanged.
+    pub fn create_rename_expression_update(
+        &self,
+        old_expr_name: String,
+        new_expr_name: Option<String>,
+    ) -> ViewConfigUpdate {
+        let old_expr_val = self
+            .metadata
+            .get_expression_by_alias(&old_expr_name)
+            .unwrap();
+        let old_expr = Expression::new(Some(old_expr_name.into()), old_expr_val.clone().into());
+        let new_expr = Expression::new(new_expr_name.map(|n| n.into()), old_expr_val.into());
+        self.config
+            .create_replace_expression_update(&old_expr, &new_expr)
+    }
+}

package/src/rust/session/replace_expression_update.rs

@@ -125,6 +125,7 @@ pub impl ViewConfig {
             filter: Some(filter),
             filter_op: None,
             group_by_depth: None,
+            group_rollup_mode: None,
         }
     }
 }

package/src/rust/session.rs

@@ -10,10 +10,11 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
-mod column_defaults_update;
-mod drag_drop_update;
+pub(crate) mod column_defaults_update;
+pub(crate) mod drag_drop_update;
 mod metadata;
-mod replace_expression_update;
+mod props;
+pub(crate) mod replace_expression_update;
 mod view_subscription;
 
 use std::cell::{Ref, RefCell};
@@ -30,9 +31,9 @@ use wasm_bindgen::prelude::*;
 use yew::html::ImplicitClone;
 use yew::prelude::*;
 
-pub use self::metadata::MetadataRef;
 use self::metadata::*;
-use self::replace_expression_update::*;
+pub use self::metadata::{MetadataRef, SessionMetadata, SessionMetadataRc};
+pub use self::props::{SessionProps, TableLoadState};
 pub use self::view_subscription::ViewStats;
 use self::view_subscription::*;
 use crate::js::plugin::*;
@@ -44,12 +45,19 @@ pub struct SessionHandle {
     session_data: RefCell<SessionData>,
     pub table_updated: PubSub<()>,
     pub table_loaded: PubSub<()>,
-    pub table_errored: PubSub<ApiError>,
     pub table_unloaded: PubSub<bool>,
     pub view_created: PubSub<()>,
     pub view_config_changed: PubSub<()>,
-    pub stats_changed: PubSub<Option<ViewStats>>,
     pub title_changed: PubSub<Option<String>>,
+
+    /// Injected callback from the root component, replacing the former
+    /// `stats_changed: PubSub` field.  Fires when view stats are updated.
+    pub on_stats_changed: RefCell<Option<Callback<()>>>,
+
+    /// Injected callback from the root component, replacing the former
+    /// `table_errored: PubSub` field.  Fires when an error is set on the
+    /// session (table load failure, client disconnect, invalid config, etc.).
+    pub on_table_errored: RefCell<Option<Callback<()>>>,
 }
 
 impl Deref for SessionHandle {
@@ -70,6 +78,7 @@ pub struct SessionData {
     config: ViewConfig,
     view_sub: Option<ViewSubscription>,
     stats: Option<ViewStats>,
+    is_loading: bool,
     is_clean: bool,
     is_paused: bool,
     error: Option<TableErrorState>,
@@ -79,6 +88,45 @@ pub struct SessionData {
 #[derive(Clone)]
 pub struct TableErrorState(ApiError, Option<ReconnectCallback>);
 
+impl PartialEq for TableErrorState {
+    fn eq(&self, other: &Self) -> bool {
+        self.0.to_string() == other.0.to_string()
+    }
+}
+
+impl std::fmt::Debug for TableErrorState {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_tuple("TableErrorState")
+            .field(&self.0.to_string())
+            .finish()
+    }
+}
+
+impl TableErrorState {
+    pub fn message(&self) -> String {
+        self.0.message()
+    }
+
+    pub fn stacktrace(&self) -> String {
+        self.0.stacktrace()
+    }
+
+    pub fn kind(&self) -> &'static str {
+        self.0.kind()
+    }
+
+    pub fn is_reconnect(&self) -> bool {
+        self.1.is_some()
+    }
+}
+
+#[derive(Debug, Default)]
+pub enum TableIntermediateState {
+    #[default]
+    Ejected,
+    Reloaded,
+}
+
 /// Options for [`Session::reset`]
 #[derive(Default)]
 pub struct ResetOptions {
@@ -86,7 +134,7 @@ pub struct ResetOptions {
     pub expressions: bool,
 
     /// Reset the [`Table`]
-    pub table: bool,
+    pub table: Option<TableIntermediateState>,
 
     /// Reset the [`ViewConfig`]
     pub config: bool,
@@ -125,15 +173,15 @@ impl Session {
         Self(Rc::default())
     }
 
-    pub fn metadata(&self) -> MetadataRef<'_> {
+    pub(crate) fn metadata(&self) -> MetadataRef<'_> {
         std::cell::Ref::map(self.borrow(), |x| &x.metadata)
     }
 
-    pub fn metadata_mut(&self) -> MetadataMutRef<'_> {
+    pub(crate) fn metadata_mut(&self) -> MetadataMutRef<'_> {
         std::cell::RefMut::map(self.borrow_mut(), |x| &mut x.metadata)
     }
 
-    pub fn get_title(&self) -> Option<String> {
+    pub(crate) fn get_title(&self) -> Option<String> {
         self.borrow().title.clone()
     }
 
@@ -160,16 +208,27 @@ impl Session {
             self.borrow_mut().config.reset(options.expressions);
         }
 
-        if options.table {
-            self.borrow_mut().table = None;
-            self.borrow_mut().metadata = SessionMetadata::default();
-        }
+        match options.table {
+            Some(TableIntermediateState::Ejected) => {
+                self.borrow_mut().is_loading = false;
+                self.borrow_mut().table = None;
+                self.borrow_mut().metadata = SessionMetadata::default();
+            },
+            Some(TableIntermediateState::Reloaded) => {
+                self.borrow_mut().is_loading = true;
+                self.borrow_mut().table = None;
+                self.borrow_mut().metadata = SessionMetadata::default();
+            },
+            _ => {
+                self.borrow_mut().is_loading = false;
+            },
+        };
 
         let table_unloaded = self.table_unloaded.callback();
         self.borrow_mut().is_clean = false;
         async move {
             let res = view.delete().await;
-            if options.table {
+            if options.table.is_some() {
                 table_unloaded.emit(true)
             }
 
@@ -177,8 +236,15 @@ impl Session {
         }
     }
 
-    pub fn has_table(&self) -> bool {
-        self.borrow().table.is_some()
+    pub(crate) fn has_table(&self) -> Option<TableLoadState> {
+        let data = self.borrow();
+        if data.table.is_some() {
+            Some(TableLoadState::Loaded)
+        } else if data.is_loading {
+            Some(TableLoadState::Loading)
+        } else {
+            None
+        }
     }
 
     pub fn get_table(&self) -> Option<perspective_client::Table> {
@@ -222,11 +288,13 @@ impl Session {
         match SessionMetadata::from_table(&table).await {
             Ok(metadata) => {
                 let client = table.get_client();
-                let set_error = self.table_errored.as_boxfn();
+                let on_error = self.on_table_errored.borrow().clone();
                 let session = self.clone();
                 let poll_loop = LocalPollLoop::new(move |(message, reconnect): (ApiError, _)| {
-                    set_error(message.clone());
                     session.borrow_mut().error = Some(TableErrorState(message, reconnect));
+                    if let Some(cb) = &on_error {
+                        cb.emit(());
+                    }
                     if let Some(sub) = session.borrow_mut().view_sub.take() {
                         sub.dismiss();
                     }
@@ -247,6 +315,7 @@ impl Session {
                 let sub = self.borrow_mut().view_sub.take();
                 self.borrow_mut().metadata = metadata;
                 self.borrow_mut().table = Some(table);
+                self.borrow_mut().is_loading = false;
                 self.borrow_mut().is_clean = false;
                 sub.delete().await?;
                 self.table_loaded.emit(());
@@ -286,7 +355,10 @@ impl Session {
             })),
         ));
 
-        self.table_errored.emit(err.clone());
+        if let Some(cb) = self.on_table_errored.borrow().as_ref() {
+            cb.emit(());
+        }
+
         let sub = self.borrow_mut().view_sub.take();
         if reset_table {
             self.borrow_mut().metadata = SessionMetadata::default();
@@ -324,31 +396,19 @@ impl Session {
         Some(perspective_js::Table::from(self.borrow().table.clone()?).into())
     }
 
-    pub fn js_get_view(&self) -> Option<JsValue> {
-        let view = self.borrow().view_sub.as_ref()?.get_view().clone();
-        Some(perspective_js::View::from(view).into())
-    }
-
-    pub fn is_errored(&self) -> bool {
+    pub(crate) fn is_errored(&self) -> bool {
         self.borrow().error.is_some()
     }
 
-    pub fn get_error(&self) -> Option<ApiError> {
+    pub(crate) fn get_error(&self) -> Option<ApiError> {
         self.borrow().error.as_ref().map(|x| x.0.clone())
     }
 
-    pub fn is_reconnect(&self) -> bool {
-        self.borrow()
-            .error
-            .as_ref()
-            .map(|x| x.1.is_some())
-            .unwrap_or_default()
-    }
-
     pub async fn reconnect(&self) -> ApiResult<()> {
         let err = self.borrow().error.clone();
         if let Some(TableErrorState(_, Some(reconnect))) = err {
             reconnect().await?;
+            self.borrow_mut().is_loading = false;
             self.borrow_mut().error = None;
             self.borrow_mut().is_clean = false;
             self.borrow_mut().view_sub = None;
@@ -358,82 +418,6 @@ impl Session {
         Ok(())
     }
 
-    pub fn is_column_expression_in_use(&self, name: &str) -> bool {
-        self.borrow().config.is_column_expression_in_use(name)
-    }
-
-    /// Is this column currently being used or not
-    pub fn is_column_active(&self, name: &str) -> bool {
-        let config = Ref::map(self.borrow(), |x| &x.config);
-        config.columns.iter().any(|maybe_col| {
-            maybe_col
-                .as_ref()
-                .map(|col| col == name)
-                .unwrap_or_default()
-        }) || config.group_by.iter().any(|col| col == name)
-            || config.split_by.iter().any(|col| col == name)
-            || config.filter.iter().any(|col| col.column() == name)
-            || config.sort.iter().any(|col| col.0 == name)
-    }
-
-    pub fn create_drag_drop_update(
-        &self,
-        column: String,
-        index: usize,
-        drop: DragTarget,
-        drag: DragEffect,
-        requirements: &ViewConfigRequirements,
-    ) -> ViewConfigUpdate {
-        use self::drag_drop_update::*;
-        let col_type = self
-            .metadata()
-            .get_column_table_type(column.as_str())
-            .unwrap();
-
-        self.get_view_config().create_drag_drop_update(
-            column,
-            col_type,
-            index,
-            drop,
-            drag,
-            requirements,
-            self.metadata().get_features().unwrap(),
-        )
-    }
-
-    /// An async task which replaces a `column` aliased expression with another.
-    pub async fn create_replace_expression_update(
-        &self,
-        old_expr_name: &str,
-        new_expr: &Expression<'static>,
-    ) -> ViewConfigUpdate {
-        let old_expr_val = self
-            .metadata()
-            .get_expression_by_alias(old_expr_name)
-            .unwrap();
-
-        let old_expr = Expression::new(Some(old_expr_name.into()), old_expr_val.into());
-
-        use self::replace_expression_update::*;
-        self.get_view_config()
-            .create_replace_expression_update(&old_expr, new_expr)
-    }
-
-    pub async fn create_rename_expression_update(
-        &self,
-        old_expr_name: String,
-        new_expr_name: Option<String>,
-    ) -> ViewConfigUpdate {
-        let old_expr_val = self
-            .metadata()
-            .get_expression_by_alias(&old_expr_name)
-            .expect_throw(&format!("Unable to get expr with name {old_expr_name}"));
-        let old_expr = Expression::new(Some(old_expr_name.into()), old_expr_val.clone().into());
-        let new_expr = Expression::new(new_expr_name.map(|n| n.into()), old_expr_val.into());
-        self.get_view_config()
-            .create_replace_expression_update(&old_expr, &new_expr)
-    }
-
     /// Validate an expression string and marshall the results.
     pub async fn validate_expr(
         &self,
@@ -527,7 +511,7 @@ impl Session {
             .map(|sub| sub.get_view().clone())
     }
 
-    pub fn get_table_stats(&self) -> Option<ViewStats> {
+    pub(crate) fn get_table_stats(&self) -> Option<ViewStats> {
         self.borrow().stats.clone()
     }
 
@@ -585,7 +569,7 @@ impl Session {
         use self::column_defaults_update::*;
         config_update.set_update_column_defaults(
             &self.metadata(),
-            &self.all_columns().into_iter().map(Some).collect::<Vec<_>>(),
+            &self.get_view_config().columns,
             requirements,
         )
     }
@@ -600,7 +584,7 @@ impl Session {
             return Err(ApiError::new(x.0.clone()));
         }
 
-        if self.borrow_mut().config.apply_update(config_update) {
+        if self.borrow_mut().config.apply_update(config_update) && self.0.borrow().is_clean {
             self.0.borrow_mut().is_clean = false;
             self.view_config_changed.emit(());
         }
@@ -673,8 +657,10 @@ impl Session {
     }
 
     fn update_stats(&self, stats: ViewStats) {
-        self.borrow_mut().stats = Some(stats.clone());
-        self.stats_changed.emit(Some(stats));
+        self.borrow_mut().stats = Some(stats);
+        if let Some(cb) = self.on_stats_changed.borrow().as_ref() {
+            cb.emit(());
+        }
     }
 
     fn all_columns(&self) -> Vec<String> {
@@ -781,6 +767,27 @@ impl Session {
         std::mem::swap(&mut is_clean, &mut self.0.borrow_mut().is_clean);
         is_clean
     }
+
+    /// Snapshot the current session state as a [`SessionProps`] value suitable
+    /// for passing as a Yew prop.  Called by the root component whenever a
+    /// session-related PubSub event fires.
+    pub fn to_props(&self) -> SessionProps {
+        let data = self.borrow();
+        SessionProps {
+            config: PtrEqRc::new(data.config.clone()),
+            stats: data.stats.clone(),
+            has_table: if data.table.is_some() {
+                Some(TableLoadState::Loaded)
+            } else if data.is_loading {
+                Some(TableLoadState::Loading)
+            } else {
+                None
+            },
+            error: data.error.clone(),
+            title: data.title.clone(),
+            metadata: PtrEqRc::new(data.metadata.clone()),
+        }
+    }
 }
 
 /// A newtype wrapper which only provides `create_view()`