@perspective-dev/viewer 4.5.2 → 5.1.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/drag_drop_update.rs

@@ -96,9 +96,27 @@ pub impl ViewConfig {
                 config.filter.retain(|x| x.column() != column);
                 update.filter = Some(config.filter.clone());
             },
+            DragEffect::Move(
+                DragTarget::WindowSource
+                | DragTarget::WindowOrderBy
+                | DragTarget::WindowPartitionBy,
+            ) => {
+                // Staged origins (window-editor pills) have nothing to remove
+                // HERE - the editor's draft is not part of the view config
+                // this update mutates. The open `WindowEditor` observes the
+                // same `drop_received` event and clears the origin slot in
+                // its draft, completing the move.
+            },
         }
 
         match drop {
+            DragTarget::WindowSource
+            | DragTarget::WindowOrderBy
+            | DragTarget::WindowPartitionBy => {
+                // Unreachable: staged drops never build config updates
+                // (`DragTarget::is_staged` is excluded by every committing
+                // `drop_received` subscriber).
+            },
             DragTarget::Active => {
                 if !is_swap_to_after_last {
                     if is_to_swap || is_from_required {

package/src/rust/session/metadata.rs

@@ -69,6 +69,7 @@ pub struct SessionMetadataState {
     edit_port: f64,
     view_schema: Option<HashMap<String, ColumnType>>,
     expr_meta: Option<SessionViewExpressionMetadata>,
+    window_schema: HashMap<String, ColumnType>,
 }
 
 impl SessionMetadata {
@@ -95,6 +96,43 @@ impl SessionMetadata {
         Ok(())
     }
 
+    /// Records the pre-aggregation types of the config's window columns, so
+    /// `get_column_table_type` resolves them like any other derived column.
+    /// Types mirror the engine's `t_window_engine::resolve_dtype` rules from
+    /// the window's op and its source's table type - independent of any
+    /// aggregation the view may also apply.
+    pub(super) fn update_windows(
+        &mut self,
+        windows: &perspective_client::config::Windows,
+    ) -> ApiResult<()> {
+        use perspective_client::config::WindowAggregate;
+        let window_schema = windows
+            .iter()
+            .filter_map(|(name, w)| {
+                let source = self.get_column_table_type(&w.column)?;
+                let dtype = match w.aggregate {
+                    WindowAggregate::Sum
+                    | WindowAggregate::Avg
+                    | WindowAggregate::Stddev
+                    | WindowAggregate::Var
+                    | WindowAggregate::Rate
+                    | WindowAggregate::Ema
+                    | WindowAggregate::Diff => ColumnType::Float,
+                    WindowAggregate::Count => ColumnType::Integer,
+                    WindowAggregate::Min
+                    | WindowAggregate::Max
+                    | WindowAggregate::First
+                    | WindowAggregate::Last
+                    | WindowAggregate::Lag
+                    | WindowAggregate::Lead => source,
+                };
+                Some((name.clone(), dtype))
+            })
+            .collect();
+        self.as_mut().unwrap().window_schema = window_schema;
+        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
@@ -212,6 +250,19 @@ impl SessionMetadata {
         self.as_ref().map(|meta| &meta.column_names)
     }
 
+    pub fn is_column_window(&self, name: &str) -> bool {
+        self.as_ref()
+            .map(|meta| meta.window_schema.contains_key(name))
+            .unwrap_or_default()
+    }
+
+    pub fn get_window_columns(&self) -> impl Iterator<Item = &'_ String> {
+        self.as_ref()
+            .map(|meta| meta.window_schema.keys())
+            .into_iter()
+            .flatten()
+    }
+
     pub fn is_column_expression(&self, name: &str) -> bool {
         let is_expr: Option<bool> = try {
             self.as_ref()?
@@ -253,14 +304,18 @@ impl SessionMetadata {
     pub fn get_column_table_type(&self, name: &str) -> Option<ColumnType> {
         try {
             let meta = self.as_ref()?;
-            meta.table_schema.get(name).cloned().or_else(|| {
-                meta.expr_meta
-                    .as_ref()?
-                    .expressions
-                    .expression_schema
-                    .get(name)
-                    .cloned()
-            })?
+            meta.table_schema
+                .get(name)
+                .cloned()
+                .or_else(|| {
+                    meta.expr_meta
+                        .as_ref()?
+                        .expressions
+                        .expression_schema
+                        .get(name)
+                        .cloned()
+                })
+                .or_else(|| meta.window_schema.get(name).cloned())?
         }
     }
 
@@ -282,7 +337,9 @@ impl SessionMetadata {
     /// expressions.
     pub fn locator_name_or_default(&self, locator: &ColumnLocator) -> String {
         match locator {
-            ColumnLocator::Table(s) | ColumnLocator::Expression(s) => s.clone(),
+            ColumnLocator::Table(s) | ColumnLocator::Expression(s) | ColumnLocator::Window(s) => {
+                s.clone()
+            },
             ColumnLocator::NewExpression => self.make_new_column_name(None),
         }
     }

package/src/rust/session/replace_expression_update.rs

@@ -126,6 +126,7 @@ pub impl ViewConfig {
             filter_op: None,
             group_by_depth: None,
             group_rollup_mode: None,
+            windows: None,
         }
     }
 }

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.