@perspective-dev/viewer 5.1.0 → 5.3.0

package/src/rust/components/window_editor.rs

@@ -13,9 +13,7 @@
 use std::collections::HashSet;
 use std::rc::Rc;
 
-use perspective_client::config::{
-    ColumnType, WindowAggregate, WindowFrame, WindowSort, WindowSortDir, WindowSpec,
-};
+use perspective_client::config::{ColumnType, WindowFrame, WindowSort, WindowSortDir, WindowSpec};
 use wasm_bindgen::JsCast;
 use web_sys::{DragEvent, HtmlInputElement, MouseEvent};
 use yew::prelude::*;
@@ -30,63 +28,33 @@ use crate::presentation::Presentation;
 use crate::session::{Session, SessionMetadataRc};
 use crate::utils::{AddListener, DragEffect, DragTarget, Subscription};
 
-fn op_label(op: WindowAggregate) -> &'static str {
-    match op {
-        WindowAggregate::Sum => "sum",
-        WindowAggregate::Avg => "avg",
-        WindowAggregate::Count => "count",
-        WindowAggregate::Min => "min",
-        WindowAggregate::Max => "max",
-        WindowAggregate::Stddev => "stddev",
-        WindowAggregate::Var => "var",
-        WindowAggregate::First => "first",
-        WindowAggregate::Last => "last",
-        WindowAggregate::Lag => "lag",
-        WindowAggregate::Lead => "lead",
-        WindowAggregate::Diff => "diff",
-        WindowAggregate::Rate => "rate",
-        WindowAggregate::Ema => "ema",
-    }
-}
-
-fn op_from_label(label: &str) -> Option<WindowAggregate> {
-    Some(match label {
-        "sum" => WindowAggregate::Sum,
-        "avg" => WindowAggregate::Avg,
-        "count" => WindowAggregate::Count,
-        "min" => WindowAggregate::Min,
-        "max" => WindowAggregate::Max,
-        "stddev" => WindowAggregate::Stddev,
-        "var" => WindowAggregate::Var,
-        "first" => WindowAggregate::First,
-        "last" => WindowAggregate::Last,
-        "lag" => WindowAggregate::Lag,
-        "lead" => WindowAggregate::Lead,
-        "diff" => WindowAggregate::Diff,
-        "rate" => WindowAggregate::Rate,
-        "ema" => WindowAggregate::Ema,
-        _ => return None,
-    })
+/// The declared capabilities of one window aggregate, for a `source` column
+/// type. Which controls an aggregate needs is the data model's to state - the
+/// editor cannot infer it from a name it has never seen.
+fn op_spec(
+    metadata: &SessionMetadataRc,
+    source: &str,
+    op: &str,
+) -> Option<perspective_client::proto::WindowAggregateArgs> {
+    let ty = metadata.get_column_table_type(source)?;
+    metadata.get_window_aggregate(ty, op)
 }
 
-fn is_aggregating(op: WindowAggregate) -> bool {
-    matches!(
-        op,
-        WindowAggregate::Sum
-            | WindowAggregate::Avg
-            | WindowAggregate::Count
-            | WindowAggregate::Min
-            | WindowAggregate::Max
-            | WindowAggregate::Stddev
-            | WindowAggregate::Var
-    )
+/// The editor's frame-type labels, as the `frames` a declaration lists.
+fn frame_label(frame: &str) -> &'static str {
+    match frame {
+        "rows" => "Rows",
+        "range" => "Range",
+        _ => "Cumulative",
+    }
 }
 
-fn is_positional(op: WindowAggregate) -> bool {
-    matches!(
-        op,
-        WindowAggregate::Lag | WindowAggregate::Lead | WindowAggregate::Diff
-    )
+fn frame_name(label: &str) -> &'static str {
+    match label {
+        "Rows" => "rows",
+        "Range" => "range",
+        _ => "cumulative",
+    }
 }
 
 fn is_orderable_for_range(ty: ColumnType) -> bool {
@@ -182,7 +150,7 @@ impl WindowDraft {
         };
 
         Self {
-            op: op_label(spec.aggregate).to_string(),
+            op: spec.aggregate.clone(),
             source: spec.column.clone(),
             order_by: spec
                 .order_by
@@ -212,7 +180,7 @@ impl WindowDraft {
     }
 
     fn validate(&self, metadata: &SessionMetadataRc) -> Result<WindowSpec, String> {
-        let op = op_from_label(&self.op).ok_or("Unknown op")?;
+        let op = self.op.clone();
 
         // Every slot takes true `Table` columns ONLY - expression aliases
         // and other window columns would create dependency cycles (and
@@ -245,18 +213,13 @@ impl WindowDraft {
 
         // Backstop for API-authored specs opened in the editor - the op
         // menu only offers the feature-declared set, so this is
-        // unreachable from the UI.
-        let available = metadata
-            .get_features()
-            .map(|x| x.get_window_aggregates(source_ty))
-            .unwrap_or_default();
-
-        if !available.contains(&op) {
-            return Err(format!(
-                "\"{}\" is not a supported window aggregate for this column",
-                op_label(op)
-            ));
-        }
+        // unreachable from the UI. The declaration also supplies the
+        // controls this op takes, below.
+        let declared = metadata
+            .get_window_aggregate(source_ty, &op)
+            .ok_or_else(|| {
+                format!("\"{op}\" is not a supported window aggregate for this column")
+            })?;
 
         // An EMPTY order slot is valid when the backend has a natural row
         // order to fall back on (primary key order in the engine, `rowid`
@@ -300,11 +263,15 @@ impl WindowDraft {
 
         // The numeric fields are typed and input-clamped to their domains,
         // so no parse or range errors are reachable here.
-        let frame = if is_aggregating(op) || op == WindowAggregate::Rate {
+        let frame = if declared.frames.is_empty() {
+            None
+        } else {
+            let chosen = frame_name(&self.frame_type);
+            if !declared.frames.iter().any(|x| x == chosen) {
+                return Err(format!("\"{op}\" does not support a {chosen} frame"));
+            }
+
             match self.frame_type.as_str() {
-                "Rows" | "Cumulative" if op == WindowAggregate::Rate => {
-                    return Err("\"rate\" requires a range frame".to_string());
-                },
                 "Rows" => Some(WindowFrame::Rows(self.frame_rows)),
                 "Range" => {
                     // The natural-order fallback has no units, so `range`
@@ -323,15 +290,13 @@ impl WindowDraft {
                 },
                 _ => None,
             }
-        } else {
-            None
         };
 
         // Emit `None` at the engine default so a spec saved without an
         // explicit `offset` round-trips unchanged (the name-stripped
         // change-detection baseline compares specs structurally).
-        let offset = (is_positional(op) && self.offset != 1).then_some(self.offset);
-        let alpha = (op == WindowAggregate::Ema).then_some(self.alpha);
+        let offset = (declared.offset && self.offset != 1).then_some(self.offset);
+        let alpha = declared.alpha.then_some(self.alpha);
 
         let mut partition_by = self.partition_by.clone();
         partition_by.retain(|col| !col.is_empty());
@@ -676,12 +641,10 @@ impl Component for WindowEditor {
                             })
                             .unwrap_or_default();
 
-                        if !op_from_label(&self.draft.op)
-                            .map(|op| available.contains(&op))
-                            .unwrap_or_default()
+                        if !available.iter().any(|x| x.name == self.draft.op)
                             && let Some(first) = available.first()
                         {
-                            self.draft.op = op_label(*first).to_string();
+                            self.draft.op = first.name.clone();
                         }
                     },
                     DragTarget::WindowOrderBy => self.draft.order_by = column,
@@ -698,11 +661,19 @@ impl Component for WindowEditor {
             WindowEditorMsg::SetOp(op) => {
                 self.draft.op = op;
 
-                // Keep the frame coherent as the op class changes (`rate`
-                // requires a Range frame; the frame-type dropdown omits the
-                // rest).
-                if op_from_label(&self.draft.op) == Some(WindowAggregate::Rate) {
-                    self.draft.frame_type = "Range".to_string();
+                // Keep the frame coherent as the op changes - an op that
+                // does not accept the current frame kind coerces to its
+                // first declared one (the dropdown omits the rest).
+                if let Some(declared) =
+                    op_spec(&ctx.props().metadata, &self.draft.source, &self.draft.op)
+                    && !declared.frames.is_empty()
+                    && !declared
+                        .frames
+                        .iter()
+                        .any(|x| x == frame_name(&self.draft.frame_type))
+                    && let Some(first) = declared.frames.first()
+                {
+                    self.draft.frame_type = frame_label(first).to_string();
                 }
             },
             WindowEditorMsg::ClearSource => self.draft.source = String::default(),
@@ -745,7 +716,7 @@ impl Component for WindowEditor {
     }
 
     fn view(&self, ctx: &Context<Self>) -> Html {
-        let op = op_from_label(&self.draft.op);
+        let declared = op_spec(&ctx.props().metadata, &self.draft.source, &self.draft.op);
 
         // The op selector renders the FEATURE-DECLARED window aggregates
         // for the source column's type, in the server's declared order -
@@ -763,7 +734,7 @@ impl Component for WindowEditor {
                 })
                 .unwrap_or_default()
                 .into_iter()
-                .map(|x| SelectItem::Option(op_label(x).to_string()))
+                .map(|x| SelectItem::Option(x.name.clone()))
                 .collect(),
         );
 
@@ -782,17 +753,16 @@ impl Component for WindowEditor {
         };
 
         // Frame type as a dropdown; like the op selector, invalid choices
-        // are omitted rather than disabled (`rate` requires a Range frame,
-        // and `SetOp` already coerces the draft there).
+        // are omitted rather than disabled - the declared `frames` are the
+        // menu, and `SetOp` already coerces the draft into them.
         let frame_types: Rc<Vec<SelectItem<String>>> = Rc::new(
-            if op == Some(WindowAggregate::Rate) {
-                vec!["Range"]
-            } else {
-                vec!["Rows", "Range", "Cumulative"]
-            }
-            .into_iter()
-            .map(|x| SelectItem::Option(x.to_string()))
-            .collect(),
+            declared
+                .as_ref()
+                .map(|x| x.frames.clone())
+                .unwrap_or_default()
+                .iter()
+                .map(|x| SelectItem::Option(frame_label(x).to_string()))
+                .collect(),
         );
 
         // Slots take true `Table` columns ONLY - expression aliases and
@@ -927,10 +897,12 @@ impl Component for WindowEditor {
             </DragDropList<WindowEditor, PivotColumn, WindowPartitionByContext>>
         };
 
-        let show_frame =
-            op.map(is_aggregating).unwrap_or_default() || op == Some(WindowAggregate::Rate);
-        let show_offset = op.map(is_positional).unwrap_or_default();
-        let show_alpha = op == Some(WindowAggregate::Ema);
+        let show_frame = declared
+            .as_ref()
+            .map(|x| !x.frames.is_empty())
+            .unwrap_or_default();
+        let show_offset = declared.as_ref().map(|x| x.offset).unwrap_or_default();
+        let show_alpha = declared.as_ref().map(|x| x.alpha).unwrap_or_default();
 
         html! {
             <>

package/src/rust/config/column_config_schema.rs

@@ -15,18 +15,12 @@ use std::collections::HashSet;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 
-use super::{KeyValueOpts, NumberSeriesStyleDefaultConfig};
+use super::{CssKind, KeyValueOpts, NumberSeriesStyleDefaultConfig};
 
 /// The full schema for one column at one point in time. Plugins may return
 /// different schemas for the same column based on the column's current
 /// stored value (e.g. to hide dependent fields), so this is re-queried on
 /// every field update.
-///
-/// Each entry is a [`ControlSpec`]. Primitive variants carry their own
-/// `key` (JSON storage key) inline; the sidebar UI label is supplied by
-/// CSS via `--psp-label--<key>--content`. Composite variants render a
-/// self-contained Yew component that supplies its own labels and owns a
-/// fixed key namespace via [`ControlSpec::serialized_keys`].
 #[derive(Clone, Debug, Default, Deserialize, Serialize)]
 pub struct ColumnConfigSchema {
     pub fields: Vec<ControlSpec>,
@@ -93,33 +87,21 @@ pub enum ControlSpec {
         key: String,
         default: String,
     },
-    /// Paired pos/neg color picker rendered as a single horizontal
-    /// gradient/range bar. Used to expose the existing
-    /// [`crate::components::form::color_range_selector::ColorRangeSelector`]
-    /// widget at primitive granularity. Owns two top-level keys
-    /// (`key_pos` + `key_neg`); the visible label is derived from
-    /// `key_pos`.
-    ColorRange {
-        key_pos: String,
-        key_neg: String,
-        default_pos: String,
-        default_neg: String,
-        /// When `true`, the bar renders as a continuous gradient
-        /// (e.g. for `gradient` color modes); when `false`, the bar
-        /// renders as a hard pos/neg split. Currently only changes the
-        /// visual; pos/neg semantics are unchanged.
-        #[serde(default)]
-        is_gradient: bool,
+    Palette {
+        key: String,
+        default: String,
+
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        max: Option<usize>,
     },
+    GradientStops {
+        key: String,
+        default: String,
 
-    /// Residual format-only widget for datetime columns — owns
-    /// `date_format` only. Pair with primitive `Enum` and `Color` fields
-    /// for `datetime_color_mode` + `color` to fully decompose datetime
-    /// styling.
+        #[serde(default, skip_serializing_if = "std::ops::Not::not")]
+        discrete: bool,
+    },
     DatetimeFormat,
-    /// Residual format-only widget for string columns — owns `format`
-    /// only. Pair with primitive `Enum` and `Color` fields for
-    /// `string_color_mode` + `color` to fully decompose string styling.
     StringFormat,
     NumberSeriesStyle {
         default: NumberSeriesStyleDefaultConfig,
@@ -138,6 +120,90 @@ pub struct EnumVariant {
     pub label: Option<String>,
 }
 
+/// One stop of a [`ControlSpec::GradientStops`] value in its in-memory
+/// form: a `#rrggbb` color at `offset` ∈ `[0, 1]`.
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
+pub struct GradientStopSpec {
+    pub color: String,
+    pub offset: f64,
+}
+
+/// The [`ControlSpec::GradientStops`] canonical stop order: offsets
+/// clamped to `[0, 1]` and rounded to 3 decimals, stops sorted stably
+/// by offset.
+pub fn canonicalize_gradient_stops(mut stops: Vec<GradientStopSpec>) -> Vec<GradientStopSpec> {
+    for stop in &mut stops {
+        stop.offset = (stop.offset.clamp(0.0, 1.0) * 1000.0).round() / 1000.0;
+    }
+
+    stops.sort_by(|a, b| {
+        a.offset
+            .partial_cmp(&b.offset)
+            .unwrap_or(std::cmp::Ordering::Equal)
+    });
+
+    stops
+}
+
+/// Fit `stops` to a `discrete` field's fixed pair: an over-length value
+/// keeps only its two end colors, pinned to `0`/`1`.
+pub fn discrete_pair(stops: Vec<GradientStopSpec>) -> Vec<GradientStopSpec> {
+    let stops = canonicalize_gradient_stops(stops);
+    match (stops.first(), stops.last()) {
+        (Some(first), Some(last)) if stops.len() > 2 => vec![
+            GradientStopSpec {
+                color: first.color.clone(),
+                offset: 0.0,
+            },
+            GradientStopSpec {
+                color: last.color.clone(),
+                offset: 1.0,
+            },
+        ],
+        _ => stops,
+    }
+}
+
+impl ColumnConfigSchema {
+    /// Canonicalize every CSS-valued default at schema ingest, dropping
+    /// (and logging) fields whose default fails its kind's reader.
+    pub fn canonicalize_defaults(mut self) -> Self {
+        self.fields.retain_mut(|spec| {
+            let (kind, key, default) = match spec {
+                ControlSpec::Color { key, default } => (CssKind::Color, key, default),
+                ControlSpec::Palette { key, default, .. } => (CssKind::Palette, key, default),
+                ControlSpec::GradientStops { key, default, .. } => {
+                    (CssKind::Gradient, key, default)
+                },
+                _ => return true,
+            };
+
+            match kind.canonicalize(default) {
+                Ok(canonical) => {
+                    *default = canonical;
+                    true
+                },
+                Err(error) => {
+                    tracing::error!("Dropping `{key}` — invalid schema default: {error}");
+                    false
+                },
+            }
+        });
+
+        self
+    }
+
+    /// The CSS kind of the control owning `key`, if it is CSS-valued.
+    pub fn css_kind_of(&self, key: &str) -> Option<CssKind> {
+        self.fields.iter().find_map(|spec| match spec {
+            ControlSpec::Color { key: k, .. } if k == key => Some(CssKind::Color),
+            ControlSpec::Palette { key: k, .. } if k == key => Some(CssKind::Palette),
+            ControlSpec::GradientStops { key: k, .. } if k == key => Some(CssKind::Gradient),
+            _ => None,
+        })
+    }
+}
+
 impl ControlSpec {
     /// Top-level JSON keys this control owns when its value is serialized
     /// into a column's config map. For primitives this is just `[key]`;
@@ -152,14 +218,13 @@ impl ControlSpec {
             ControlSpec::Symbols { .. } => vec!["symbols"],
             ControlSpec::NumberFormat => vec!["number_format"],
             ControlSpec::AggregateDepth => vec!["aggregate_depth"],
-            ControlSpec::ColorRange {
-                key_pos, key_neg, ..
-            } => vec![key_pos.as_str(), key_neg.as_str()],
             ControlSpec::Enum { key, .. }
             | ControlSpec::Bool { key, .. }
             | ControlSpec::Number { key, .. }
             | ControlSpec::String { key, .. }
-            | ControlSpec::Color { key, .. } => vec![key.as_str()],
+            | ControlSpec::Color { key, .. }
+            | ControlSpec::Palette { key, .. }
+            | ControlSpec::GradientStops { key, .. } => vec![key.as_str()],
         }
     }
 }
@@ -168,12 +233,6 @@ impl ControlSpec {
 /// declares which top-level keys the update is allowed to write
 /// (`keys` — equivalent to the field's [`ControlSpec::serialized_keys`])
 /// and a partial new sub-state (`value`).
-///
-/// Apply semantics: keys in `keys` are *cleared* from the column's config
-/// map, then keys present in `value` are *inserted*. Defaults are
-/// pre-stripped by the caller (typically via `skip_serializing_if`), so
-/// "no value set for key K" means the schema default applies and K is
-/// not serialized.
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct ColumnConfigFieldUpdate {
     pub keys: Vec<String>,