@perspective-dev/viewer 5.3.0 → 5.3.1

package/src/rust/components/style_controls/number_string_format.rs

@@ -15,6 +15,8 @@ mod misc_section;
 mod style_section;
 mod types;
 
+use std::rc::Rc;
+
 use perspective_client::config::ColumnType;
 pub use types::*;
 use yew::{Callback, Component, Properties, html};
@@ -27,6 +29,10 @@ pub struct CustomNumberFormatProps {
     pub on_change: Callback<ColumnConfigFieldUpdate>,
     pub view_type: ColumnType,
     pub column_name: String,
+
+    /// Resolved default values for this column under the active plugin.
+    pub defaults: Rc<NumberFormatDefaults>,
+
     #[prop_or_default]
     pub keys: Vec<String>,
 }
@@ -147,25 +153,39 @@ impl Component for CustomNumberFormat {
                 self.config.minimum_integer_digits = val;
             },
             CustomNumberFormatMsg::FracChange(val) => {
+                let defaults = &ctx.props().defaults;
                 self.config.rounding_increment = None;
                 self.config.maximum_fraction_digits = val.map(|(_, val)| {
-                    let min = self.config.minimum_fraction_digits.unwrap_or(2.);
+                    let min = self
+                        .config
+                        .minimum_fraction_digits
+                        .unwrap_or(defaults.fraction.0);
                     val.max(min)
                 });
 
                 self.config.minimum_fraction_digits = val.map(|(val, _)| {
-                    let max = self.config.maximum_fraction_digits.unwrap_or(2.);
+                    let max = self
+                        .config
+                        .maximum_fraction_digits
+                        .unwrap_or(defaults.fraction.1);
                     val.min(max)
                 });
             },
             CustomNumberFormatMsg::SigChange(val) => {
+                let defaults = &ctx.props().defaults;
                 self.config.maximum_significant_digits = val.map(|(_, val)| {
-                    let min = self.config.minimum_significant_digits.unwrap_or(1.);
+                    let min = self
+                        .config
+                        .minimum_significant_digits
+                        .unwrap_or(defaults.significant.0);
                     val.max(min)
                 });
 
                 self.config.minimum_significant_digits = val.map(|(val, _)| {
-                    let max = self.config.maximum_significant_digits.unwrap_or(21.);
+                    let max = self
+                        .config
+                        .maximum_significant_digits
+                        .unwrap_or(defaults.significant.1);
                     val.min(max)
                 });
             },
@@ -191,8 +211,7 @@ impl Component for CustomNumberFormat {
             },
         };
 
-        let is_float = ctx.props().view_type == ColumnType::Float;
-        let filtered_config = self.config.clone().filter_default(is_float);
+        let filtered_config = self.config.clone().filter_default(&ctx.props().defaults);
         let mut value = serde_json::Map::new();
         if filtered_config != CustomNumberFormatConfig::default() {
             value.insert(
@@ -216,20 +235,24 @@ impl Component for CustomNumberFormat {
 
 impl CustomNumberFormat {
     fn initialize(ctx: &yew::prelude::Context<Self>) -> Self {
-        let config = ctx.props().restored_config.clone();
+        let defaults = &ctx.props().defaults;
+        let mut config = ctx.props().restored_config.clone();
+        if config._style.is_none() && defaults.style != NumberFormatStyle::Decimal {
+            config._style = Some(defaults.style.clone());
+        }
+
+        if config._notation.is_none() && defaults.notation != Notation::Standard {
+            config._notation = Some(defaults.notation.clone());
+        }
+
         Self {
             style: config
                 ._style
                 .as_ref()
-                .map(|style| match style {
-                    NumberFormatStyle::Decimal => NumberStyle::Decimal,
-                    NumberFormatStyle::Currency(_) => NumberStyle::Currency,
-                    NumberFormatStyle::Percent => NumberStyle::Percent,
-                    NumberFormatStyle::Unit(_) => NumberStyle::Unit,
-                })
+                .map(NumberStyle::from)
                 .unwrap_or_default(),
+            notation: config._notation.as_ref().map(NotationName::from),
             config,
-            notation: None,
         }
     }
 }

package/src/rust/config/column_config_schema.rs

@@ -15,7 +15,10 @@ use std::collections::HashSet;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 
-use super::{CssKind, KeyValueOpts, NumberSeriesStyleDefaultConfig};
+use super::{
+    CssKind, CustomNumberFormatConfig, DatetimeFormatType, 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
@@ -41,6 +44,21 @@ impl ColumnConfigSchema {
         }
         out
     }
+
+    pub fn leaf_fields(&self) -> Vec<&ControlSpec> {
+        fn collect<'a>(fields: &'a [ControlSpec], out: &mut Vec<&'a ControlSpec>) {
+            for spec in fields {
+                match spec {
+                    ControlSpec::Group { fields, .. } => collect(fields, out),
+                    leaf => out.push(leaf),
+                }
+            }
+        }
+
+        let mut out = vec![];
+        collect(&self.fields, &mut out);
+        out
+    }
 }
 
 /// Discriminated union of widget kinds the viewer can render. Composite
@@ -101,7 +119,12 @@ pub enum ControlSpec {
         #[serde(default, skip_serializing_if = "std::ops::Not::not")]
         discrete: bool,
     },
-    DatetimeFormat,
+    DatetimeFormat {
+        /// Plugin-declared default `date_format`, shown by the editor in
+        /// unedited fields and elided from serialized configs.
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        default: Option<DatetimeFormatType>,
+    },
     StringFormat,
     NumberSeriesStyle {
         default: NumberSeriesStyleDefaultConfig,
@@ -109,8 +132,19 @@ pub enum ControlSpec {
     Symbols {
         default: KeyValueOpts,
     },
-    NumberFormat,
+    NumberFormat {
+        /// Plugin-declared default format, keyed like `number_format`
+        /// itself.
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        default: Option<CustomNumberFormatConfig>,
+    },
     AggregateDepth,
+
+    Group {
+        key: String,
+        #[serde(default)]
+        fields: Vec<ControlSpec>,
+    },
 }
 
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
@@ -165,37 +199,90 @@ pub fn discrete_pair(stops: Vec<GradientStopSpec>) -> Vec<GradientStopSpec> {
 }
 
 impl ColumnConfigSchema {
+    pub fn canonicalize(self) -> Self {
+        self.canonicalize_defaults().group_format_controls()
+    }
+
+    pub fn group_format_controls(mut self) -> Self {
+        fn is_format(spec: &ControlSpec) -> bool {
+            matches!(
+                spec,
+                ControlSpec::NumberFormat { .. }
+                    | ControlSpec::DatetimeFormat { .. }
+                    | ControlSpec::StringFormat
+            )
+        }
+
+        fn walk(fields: &mut Vec<ControlSpec>) {
+            for spec in fields.iter_mut() {
+                if let ControlSpec::Group { key, fields } = spec
+                    && key != "format"
+                {
+                    walk(fields);
+                }
+            }
+
+            let first = fields.iter().position(is_format);
+            if let Some(first) = first {
+                let mut formats = vec![];
+                let mut i = first;
+                while i < fields.len() {
+                    if is_format(&fields[i]) {
+                        formats.push(fields.remove(i));
+                    } else {
+                        i += 1;
+                    }
+                }
+
+                fields.insert(first, ControlSpec::Group {
+                    key: "format".to_owned(),
+                    fields: formats,
+                });
+            }
+        }
+
+        walk(&mut self.fields);
+        self
+    }
+
     /// 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
-                },
-            }
-        });
+        fn canonicalize_specs(fields: &mut Vec<ControlSpec>) {
+            fields.retain_mut(|spec| {
+                let (kind, key, default) = match spec {
+                    ControlSpec::Group { fields, .. } => {
+                        canonicalize_specs(fields);
+                        return !fields.is_empty();
+                    },
+                    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
+                    },
+                }
+            });
+        }
+
+        canonicalize_specs(&mut self.fields);
         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 {
+        self.leaf_fields().into_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),
@@ -212,11 +299,11 @@ impl ControlSpec {
     /// `columns_config` blob passed to `plugin.restore()`.
     pub fn serialized_keys(&self) -> Vec<&str> {
         match self {
-            ControlSpec::DatetimeFormat => vec!["date_format"],
+            ControlSpec::DatetimeFormat { .. } => vec!["date_format"],
             ControlSpec::StringFormat => vec!["format"],
             ControlSpec::NumberSeriesStyle { .. } => vec!["chart_type", "stack"],
             ControlSpec::Symbols { .. } => vec!["symbols"],
-            ControlSpec::NumberFormat => vec!["number_format"],
+            ControlSpec::NumberFormat { .. } => vec!["number_format"],
             ControlSpec::AggregateDepth => vec!["aggregate_depth"],
             ControlSpec::Enum { key, .. }
             | ControlSpec::Bool { key, .. }
@@ -225,6 +312,9 @@ impl ControlSpec {
             | ControlSpec::Color { key, .. }
             | ControlSpec::Palette { key, .. }
             | ControlSpec::GradientStops { key, .. } => vec![key.as_str()],
+            ControlSpec::Group { fields, .. } => {
+                fields.iter().flat_map(|f| f.serialized_keys()).collect()
+            },
         }
     }
 }
@@ -252,3 +342,244 @@ pub fn filter_to_schema(
         .map(|(k, v)| (k.clone(), v.clone()))
         .collect()
 }
+
+#[cfg(test)]
+mod tests {
+    use serde_json::json;
+
+    use super::*;
+
+    fn color(key: &str, default: &str) -> ControlSpec {
+        ControlSpec::Color {
+            key: key.to_owned(),
+            default: default.to_owned(),
+        }
+    }
+
+    fn flag(key: &str) -> ControlSpec {
+        ControlSpec::Bool {
+            key: key.to_owned(),
+            default: false,
+        }
+    }
+
+    fn group(key: &str, fields: Vec<ControlSpec>) -> ControlSpec {
+        ControlSpec::Group {
+            key: key.to_owned(),
+            fields,
+        }
+    }
+
+    #[test]
+    fn group_deserializes_recursively() {
+        let schema: ColumnConfigSchema = serde_json::from_value(json!({
+            "fields": [{
+                "kind": "Group",
+                "key": "legend",
+                "fields": [
+                    { "kind": "Bool", "key": "legend_on", "default": false },
+                    {
+                        "kind": "Group",
+                        "key": "inner",
+                        "fields": [{ "kind": "Color", "key": "color", "default": "#ff0000" }]
+                    }
+                ]
+            }]
+        }))
+        .unwrap();
+
+        let keys = schema.active_keys();
+        assert_eq!(
+            keys,
+            HashSet::from(["legend_on".to_owned(), "color".to_owned()])
+        );
+
+        let leaves = schema.leaf_fields();
+        assert_eq!(leaves.len(), 2);
+        assert!(
+            leaves
+                .iter()
+                .all(|s| !matches!(s, ControlSpec::Group { .. }))
+        );
+    }
+
+    #[test]
+    fn grouped_schema_is_equivalent_to_flat() {
+        let flat = ColumnConfigSchema {
+            fields: vec![flag("stack"), color("color", "#0366d6")],
+        };
+
+        let grouped = ColumnConfigSchema {
+            fields: vec![group("series", vec![
+                flag("stack"),
+                color("color", "#0366d6"),
+            ])],
+        };
+
+        assert_eq!(flat.active_keys(), grouped.active_keys());
+        assert_eq!(flat.css_kind_of("color"), grouped.css_kind_of("color"));
+        assert_eq!(flat.css_kind_of("stack"), grouped.css_kind_of("stack"));
+    }
+
+    #[test]
+    fn format_controls_group_and_merge() {
+        let schema = ColumnConfigSchema {
+            fields: vec![
+                ControlSpec::NumberFormat { default: None },
+                flag("flag"),
+                ControlSpec::StringFormat,
+            ],
+        }
+        .group_format_controls();
+
+        assert_eq!(schema.fields.len(), 2);
+        let ControlSpec::Group { key, fields } = &schema.fields[0] else {
+            panic!("expected format group first");
+        };
+
+        assert_eq!(key, "format");
+        assert!(matches!(fields[0], ControlSpec::NumberFormat { .. }));
+        assert!(matches!(fields[1], ControlSpec::StringFormat));
+        assert!(matches!(&schema.fields[1], ControlSpec::Bool { .. }));
+
+        assert_eq!(
+            schema.active_keys(),
+            HashSet::from([
+                "number_format".to_owned(),
+                "format".to_owned(),
+                "flag".to_owned()
+            ])
+        );
+    }
+
+    #[test]
+    fn format_grouping_recurses_but_never_double_wraps() {
+        let schema = ColumnConfigSchema {
+            fields: vec![
+                group("format", vec![ControlSpec::NumberFormat { default: None }]),
+                group("styling", vec![flag("x"), ControlSpec::DatetimeFormat {
+                    default: None,
+                }]),
+            ],
+        }
+        .group_format_controls();
+
+        let ControlSpec::Group { key, fields } = &schema.fields[0] else {
+            panic!("expected group");
+        };
+
+        assert_eq!(key, "format");
+        assert!(matches!(fields[0], ControlSpec::NumberFormat { .. }));
+
+        let ControlSpec::Group { fields, .. } = &schema.fields[1] else {
+            panic!("expected group");
+        };
+
+        assert!(matches!(
+            &fields[1],
+            ControlSpec::Group { key, fields }
+                if key == "format" && matches!(fields[0], ControlSpec::DatetimeFormat { .. })
+        ));
+    }
+
+    #[test]
+    fn format_controls_deserialize_without_default_payload() {
+        let schema: ColumnConfigSchema = serde_json::from_value(json!({
+            "fields": [{ "kind": "NumberFormat" }, { "kind": "DatetimeFormat" }]
+        }))
+        .unwrap();
+
+        assert!(matches!(&schema.fields[0], ControlSpec::NumberFormat {
+            default: None
+        }));
+        assert!(matches!(&schema.fields[1], ControlSpec::DatetimeFormat {
+            default: None
+        }));
+    }
+
+    #[test]
+    fn number_format_default_payload_deserializes_flattened_families() {
+        let schema: ColumnConfigSchema = serde_json::from_value(json!({
+            "fields": [{
+                "kind": "NumberFormat",
+                "default": {
+                    "notation": "compact",
+                    "compactDisplay": "short",
+                    "minimumFractionDigits": 0,
+                    "maximumFractionDigits": 1
+                }
+            }]
+        }))
+        .unwrap();
+
+        let ControlSpec::NumberFormat {
+            default: Some(default),
+        } = &schema.fields[0]
+        else {
+            panic!("expected NumberFormat with default");
+        };
+
+        assert_eq!(
+            default._notation,
+            Some(crate::config::Notation::Compact(
+                crate::config::CompactDisplay::Short
+            ))
+        );
+        assert_eq!(default._style, None);
+        assert_eq!(default.minimum_fraction_digits, Some(0.));
+        assert_eq!(default.maximum_fraction_digits, Some(1.));
+        assert_eq!(
+            schema.active_keys(),
+            HashSet::from(["number_format".to_owned()])
+        );
+    }
+
+    #[test]
+    fn datetime_format_default_payload_deserializes_simple_arm() {
+        let schema: ColumnConfigSchema = serde_json::from_value(json!({
+            "fields": [{
+                "kind": "DatetimeFormat",
+                "default": { "dateStyle": "medium", "timeStyle": "disabled" }
+            }]
+        }))
+        .unwrap();
+
+        let ControlSpec::DatetimeFormat {
+            default: Some(DatetimeFormatType::Simple(simple)),
+        } = &schema.fields[0]
+        else {
+            panic!("expected DatetimeFormat with Simple default");
+        };
+
+        assert_eq!(
+            simple.date_style,
+            crate::config::SimpleDatetimeFormat::Medium
+        );
+        assert_eq!(
+            simple.time_style,
+            crate::config::SimpleDatetimeFormat::Disabled
+        );
+    }
+
+    #[test]
+    fn canonicalize_defaults_recurses_and_drops_empty_groups() {
+        let schema = ColumnConfigSchema {
+            fields: vec![
+                group("ok", vec![color("good", "RGB(255,0,0)"), flag("flag")]),
+                group("doomed", vec![color("bad", "not-a-color")]),
+            ],
+        }
+        .canonicalize_defaults();
+
+        assert_eq!(schema.fields.len(), 1);
+        let ControlSpec::Group { key, fields } = &schema.fields[0] else {
+            panic!("expected group");
+        };
+
+        assert_eq!(key, "ok");
+        assert!(matches!(
+            &fields[0],
+            ControlSpec::Color { default, .. } if default == "#ff0000"
+        ));
+    }
+}

package/src/rust/config/datetime_column_style.rs

@@ -41,10 +41,6 @@ impl Default for DatetimeFormatType {
 }
 
 impl DatetimeFormatType {
-    fn is_simple(&self) -> bool {
-        self == &Self::Simple(SimpleDatetimeStyleConfig::default())
-    }
-
     pub fn time_zone(&self) -> &Option<String> {
         match self {
             DatetimeFormatType::Custom(x) => &x.time_zone,
@@ -62,12 +58,13 @@ impl DatetimeFormatType {
 
 /// A model for the JSON serialized style configuration for a column of type
 /// `datetime`.
-#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize, TS)]
+#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq, Serialize, TS)]
 // #[derive(WasmDescribe!, FromWasmAbi!)]
 pub struct DatetimeColumnStyleConfig {
     #[serde(default)]
-    #[serde(skip_serializing_if = "DatetimeFormatType::is_simple")]
-    pub date_format: DatetimeFormatType,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[ts(optional, as = "Option<_>")]
+    pub date_format: Option<DatetimeFormatType>,
 
     #[serde(default)]
     #[serde(skip_serializing_if = "DatetimeColorMode::is_none")]
@@ -78,17 +75,3 @@ pub struct DatetimeColumnStyleConfig {
     #[ts(skip)]
     pub color: Option<String>,
 }
-
-impl Default for DatetimeColumnStyleConfig {
-    fn default() -> Self {
-        Self {
-            date_format: DatetimeFormatType::Simple(SimpleDatetimeStyleConfig {
-                time_zone: Default::default(),
-                date_style: SimpleDatetimeFormat::Short,
-                time_style: SimpleDatetimeFormat::Medium,
-            }),
-            datetime_color_mode: Default::default(),
-            color: Default::default(),
-        }
-    }
-}