@perspective-dev/viewer 4.5.1 → 5.0.0

package/src/rust/session/column_defaults_update.rs

@@ -20,16 +20,19 @@ 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`, 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(
+    /// Coerce this update's `group_rollup_mode` to one the plugin accepts
+    /// (`PluginStaticConfig::group_rollup_modes`, feature-filtered). An
+    /// absent mode counts as `Rollup` for the acceptance check, so a plugin
+    /// that only renders `flat` (Treemap / Sunburst) gets it stamped even
+    /// when the update never mentions rollup at all.
+    ///
+    /// Split out of [`Self::set_update_column_defaults`] so same-plugin
+    /// restores can enforce the mode WITHOUT the column-defaulting below —
+    /// that path must not touch `columns` (it would drop non-numeric color
+    /// slots from a partial restore).
+    fn set_update_rollup_defaults(
         &mut self,
         metadata: &SessionMetadata,
-        columns: &[Option<String>],
         config_static: &PluginStaticConfig,
     ) {
         let rollup_features = metadata
@@ -49,6 +52,21 @@ pub impl ViewConfigUpdate {
                 self.group_rollup_mode
             );
         }
+    }
+
+    /// Appends additional columns to the `columns` field of this
+    /// `ViewConfigUpdate` by picking appropriate new columns from the
+    /// `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>],
+        config_static: &PluginStaticConfig,
+    ) {
+        self.set_update_rollup_defaults(metadata, config_static);
 
         if let (None, Some(min_cols)) = (&self.columns, config_static.min_config_columns) {
             let names_len = config_static.config_column_names.len();

package/src/rust/session/metadata.rs

@@ -95,6 +95,16 @@ impl SessionMetadata {
         Ok(())
     }
 
+    /// Whether `view_schema` has been populated by a prior successful
+    /// `create_view`. Used by `Session::create_view` to force a full
+    /// build on first run even when `is_clean` happens to be true, so
+    /// that downstream consumers (`query_column_config_schema`,
+    /// strip-on-write in `update_columns_configs`) always see a real
+    /// view schema rather than `None`.
+    pub fn has_view_schema(&self) -> bool {
+        self.as_ref().and_then(|s| s.view_schema.as_ref()).is_some()
+    }
+
     pub(super) fn update_expressions(
         &mut self,
         valid_recs: &perspective_client::ExprValidationResult,
@@ -302,7 +312,7 @@ impl SessionMetadata {
                     Some(
                         self.get_expression_columns()
                             .cloned()
-                            .chain(self.get_table_columns()?.clone().into_iter())
+                            .chain(self.get_table_columns()?.clone())
                             .map(move |name| {
                                 self.get_column_table_type(&name)
                                     .map(|coltype| (name, coltype))

package/src/rust/session/view_subscription.rs

@@ -36,6 +36,7 @@ pub struct ViewStats {
 struct ViewSubscriptionData {
     view: View,
     config: Rc<ViewConfig>,
+    build_config: Rc<ViewConfig>,
     callback_id: Rc<Cell<u32>>,
     on_stats: Callback<ViewStats>,
     on_update: Option<Callback<()>>,
@@ -59,8 +60,6 @@ impl ViewSubscriptionData {
         Ok(JsValue::UNDEFINED)
     }
 
-    /// TODO Use serde to serialize the full view config, instead of calculating
-    /// `is_aggregated` here.
     async fn update_view_stats(self) -> ApiResult<JsValue> {
         let dimensions = self.view.dimensions().await?;
         let num_rows = dimensions.num_table_rows as u32;
@@ -80,13 +79,16 @@ impl ViewSubscriptionData {
     }
 
     async fn internal_delete(&self) -> ApiResult<()> {
+        if self.is_deleted.replace(true) {
+            return Ok(());
+        }
+
         let view = &self.view;
         if self.on_update.is_some() {
             view.remove_update(self.callback_id.get()).await?;
         }
 
         view.delete().await?;
-        self.is_deleted.set(true);
         Ok(())
     }
 }
@@ -104,13 +106,15 @@ impl ViewSubscription {
     ///   `View.on_update()`.
     pub async fn new(
         view: perspective_client::View,
-        config: ViewConfig,
+        config: Rc<ViewConfig>,
+        build_config: Rc<ViewConfig>,
         on_stats: Callback<ViewStats>,
         on_update: Option<Callback<()>>,
     ) -> Result<Self, ApiError> {
         let data = ViewSubscriptionData {
             view,
-            config: config.into(),
+            config,
+            build_config,
             on_stats,
             callback_id: Rc::default(),
             on_update,
@@ -142,10 +146,13 @@ impl ViewSubscription {
     }
 
     /// It is possible to re-use a `ViewSubscription` without a costly
-    /// resubscribe under certain conditions, which still need an updated
-    /// `ViewConfig`.
-    pub fn update_view_config(&mut self, config: Rc<ViewConfig>) {
-        self.data.config = config
+    /// resubscribe when the new config is engine-equivalent to the one the
+    /// bound `View` was built from (placeholder-only differences); the
+    /// snapshots still need updating so reads stay consistent with the run
+    /// that adopted them.
+    pub fn set_configs(&mut self, config: Rc<ViewConfig>, build_config: Rc<ViewConfig>) {
+        self.data.config = config;
+        self.data.build_config = build_config;
     }
 
     /// Getter for the underlying `View()`.
@@ -153,16 +160,24 @@ 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.
+    /// User-facing snapshot of the [`ViewConfig`] the bound `View` was
+    /// constructed from (the persisted config at build time — global-filter
+    /// overlay excluded). 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 run.
     pub fn get_view_config(&self) -> Rc<ViewConfig> {
         self.data.config.clone()
     }
 
+    /// The EFFECTIVE [`ViewConfig`] the bound `View` was built from
+    /// (persisted config + global-filter overlay at build time). This is
+    /// the value `Session::bind_view` compares a run's snapshot against to
+    /// decide SKIP / REUSE / REBUILD.
+    pub fn build_config(&self) -> Rc<ViewConfig> {
+        self.data.build_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.