@perspective-dev/viewer 5.3.0 → 5.4.0

package/src/rust/components/viewer/wiring.rs

@@ -280,28 +280,14 @@ pub(super) fn create_active_subscriptions(
 
         let sub1 = session.table_loaded.add_notify_listener(&cb);
         let sub2 = session.table_unloaded.add_notify_listener(&cb);
-        // Snapshot refresh on every RECONCILED commit (SKIP/REUSE/paused
-        // included), not just `View` construction.
         let sub3 = session.commit_reconciled.add_notify_listener(&cb);
         let sub4 = session.view_config_changed.add_notify_listener(&cb);
         let sub5 = session.title_changed.add_notify_listener(&cb);
-
-        // The `StatusIndicator` spinner count. LEVEL-triggered: the payload
-        // is the ABSOLUTE in-flight config-run count (RAII-settled by
-        // `ConfigRunToken`), which the handler ASSIGNS — replacing the
-        // edge-counted `view_config_changed`+1/`view_created`−1 pair, whose
-        // pairing the pipeline does not guarantee (stuck-spinner
-        // regression — see `UPDATE_COUNT_REGRESSION_PLAN.md`).
         let sub6 = session
             .run_state_changed
             .add_listener(ctx.link().callback(UpdateInFlight));
 
-        // Stats fetch resolution (populates session.column_stats) triggers
-        // a fresh `SessionProps` so `column_stats` reaches downstream
-        // components and the StyleTab re-queries the schema with the
-        // new value.
         let sub7 = session.column_stats_changed.add_notify_listener(&cb);
-
         vec![sub1, sub2, sub3, sub4, sub5, sub6, sub7]
     };
 
@@ -311,12 +297,6 @@ pub(super) fn create_active_subscriptions(
             move |_: JsPerspectiveViewerPlugin| UpdateRenderer(Box::new(renderer.to_props(None)))
         });
 
-        // Re-snapshot RendererProps when the plugin_config bucket
-        // changes (in-tab edit via `send_plugin_config`, JSON paste via
-        // `restore_and_render`, full clear via `reset_all` with
-        // `all=true`). Without this, `RendererProps.plugin_config`
-        // would stay frozen at its construct-time value and `PluginTab`
-        // would render stale.
         let cb_plugin_config = ctx.link().callback({
             let renderer = renderer.clone();
             move |_: serde_json::Map<String, serde_json::Value>| {
@@ -413,7 +393,7 @@ pub(super) fn inject_active_callbacks(
         let s = session.clone();
         let cb = ctx
             .link()
-            .callback(move |_: ()| UpdateSessionStats(s.get_table_stats(), s.has_table()));
+            .callback(move |_: ()| UpdateSessionStats(s.has_table_cells(), s.has_table()));
 
         *session.on_stats_changed.borrow_mut() = Some(cb);
     }

package/src/rust/components/viewer.rs

@@ -27,6 +27,7 @@ mod settings;
 mod snapshots;
 mod wiring;
 
+use std::collections::HashMap;
 use std::rc::Rc;
 
 use futures::channel::oneshot::Sender;
@@ -40,13 +41,13 @@ pub use self::msg::PerspectiveViewerMsg;
 use self::msg::PerspectiveViewerMsg::*;
 use self::settings::SettingsGeometry;
 use self::wiring::*;
-use super::font_loader::{FontLoaderProps, FontLoaderStatus};
 use crate::presentation::{Presentation, PresentationProps};
 use crate::renderer::{RendererProps, *};
 use crate::session::{SessionProps, *};
 use crate::tasks::*;
+use crate::ui::{FontLoaderProps, FontLoaderStatus};
 use crate::utils::*;
-use crate::workspace::Workspace;
+use crate::workspace::{PanelId, Workspace};
 
 #[derive(Clone, Properties)]
 pub struct PerspectiveViewerProps {
@@ -99,6 +100,10 @@ pub struct PerspectiveViewer {
     on_settings_panel_dimensions_reset: Rc<PubSub<()>>,
     settings_open: bool,
 
+    /// `removePanel()` completions awaiting their panel's `PanelClosed`
+    /// (the deferred eject — see `ClosePanel`).
+    pending_closes: HashMap<PanelId, Completion>,
+
     /// Render snapshot of the `Workspace`-owned global filter set (see
     /// `Workspace::global_filters`); refreshed by `UpdateGlobalFilters` via
     /// the `filters_changed` subscription. The status-bar chips render from
@@ -210,6 +215,7 @@ impl Component for PerspectiveViewer {
             on_resize: Default::default(),
             on_settings_panel_dimensions_reset: Default::default(),
             settings_open: false,
+            pending_closes: HashMap::new(),
             global_filters: Vec::new(),
             settings_geometry: Default::default(),
             session_props,
@@ -305,6 +311,7 @@ impl Component for PerspectiveViewer {
             LayoutChanged => self.on_layout_changed(ctx),
             SetActivePanel(id, completion) => self.on_set_active_panel(ctx, id, completion),
             ClosePanel(id, completion) => self.on_close_panel(ctx, id, completion),
+            PanelClosed(id) => self.on_panel_closed(ctx, id),
             CommitWorkspaceRestore(id) => self.on_commit_workspace_restore(ctx, id),
             DuplicatePanel(id) => self.on_duplicate_panel(ctx, id),
             NewPanel(id) => self.on_new_panel(ctx, id),
@@ -325,20 +332,18 @@ impl Component for PerspectiveViewer {
             ToggleSettingsComplete(update, resolve) => {
                 self.on_toggle_settings_complete(ctx, update, resolve)
             },
-            SettingsPanelSizeUpdate(x) => self.on_settings_panel_size_update(x),
-            SettingsDividerMove(w) => self.on_settings_divider_move(ctx, w),
-            SettingsDividerPump => self.on_settings_divider_pump(ctx),
-            SettingsDividerCommit(w) => self.on_settings_divider_commit(ctx, w),
-            SettingsDividerFinish => self.on_settings_divider_finish(ctx),
+            DividerMove(divider, target) => self.on_divider_move(ctx, divider, target),
+            DividerPump(divider) => self.on_divider_pump(ctx, divider),
+            DividerCommit(divider, target) => self.on_divider_commit(ctx, divider, target),
+            DividerFinish(divider) => self.on_divider_finish(ctx, divider),
             SettingsPanelTabChanged(tab) => self.on_settings_panel_tab_changed(tab),
-            SettingsPanelAutoWidth(w) => self.on_settings_panel_auto_width(w),
+            SettingsPanelAutoWidth(w) => self.on_settings_panel_auto_width(ctx, w),
             OpenColumnSettings {
                 target,
                 sender,
                 toggle,
             } => self.on_open_column_settings(ctx, target, sender, toggle),
-            ColumnSettingsPanelSizeUpdate(x) => self.on_column_settings_panel_size_update(x),
-            ColumnSettingsPanelAutoWidth(w) => self.on_column_settings_panel_auto_width(w),
+            ColumnSettingsPanelAutoWidth(w) => self.on_column_settings_panel_auto_width(ctx, w),
             ToggleColumnSettingsPin => self.on_toggle_column_settings_pin(ctx),
             ToggleColumnSettingsPinComplete(resolve) => {
                 self.on_toggle_column_settings_pin_complete(resolve)

package/src/rust/components/window_editor.rs

@@ -20,12 +20,10 @@ use yew::prelude::*;
 
 use crate::components::column_dropdown::{ColumnDropDownElement, ColumnDropDownPortal};
 use crate::components::column_selector::{ColumnSelectorColumnRow, InPlaceColumn, PivotColumn};
-use crate::components::containers::dragdrop_list::{
-    DragContext, DragDropList, DragDropListItemProps,
-};
-use crate::components::containers::select::{Select, SelectItem};
+use crate::components::dragdrop_list::{DragContext, DragDropList, DragDropListItemProps};
 use crate::presentation::Presentation;
 use crate::session::{Session, SessionMetadataRc};
+use crate::ui::{IntlLabel, Select, SelectItem};
 use crate::utils::{AddListener, DragEffect, DragTarget, Subscription};
 
 /// The declared capabilities of one window aggregate, for a `source` column
@@ -479,8 +477,9 @@ impl Component for WindowSlotColumn {
             let presentation = ctx.props().presentation.clone();
             let action = ctx.props().action;
             move |event: DragEvent| {
-                presentation.set_drag_image(&event).unwrap();
-                presentation.notify_drag_start(column.clone(), DragEffect::Move(action))
+                if presentation.set_drag_image(&event) {
+                    presentation.notify_drag_start(column.clone(), DragEffect::Move(action))
+                }
             }
         });
 
@@ -909,7 +908,7 @@ impl Component for WindowEditor {
                 <div id="window-editor-slots">{ source_list }{ order_list }{ partition_list }</div>
                 <div id="window-editor-container">
                     if show_frame {
-                        <div class="column-style-label"><label id="window-frame-label" /></div>
+                        <div class="column-style-label"><IntlLabel name="window-frame" /></div>
                         <div class="row">
                             <Select<String>
                                 id="window-frame-type"
@@ -943,7 +942,7 @@ impl Component for WindowEditor {
                     }
                     if show_offset {
                         <div class="column-style-label">
-                            <label id="window-offset-label" class="indent" />
+                            <IntlLabel name="window-offset" class="indent" />
                         </div>
                         <div class="row">
                             <input
@@ -957,7 +956,7 @@ impl Component for WindowEditor {
                     }
                     if show_alpha {
                         <div class="column-style-label">
-                            <label id="window-alpha-label" class="indent" />
+                            <IntlLabel name="window-alpha" class="indent" />
                         </div>
                         <div class="row">
                             <input

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::{
+    CustomNumberFormatConfig, DatetimeFormatType, KeyValueOpts, NumberSeriesStyleDefaultConfig,
+};
+use crate::utils::{CssKind, GradientStopSpec, canonicalize_gradient_stops};
 
 /// 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)]
@@ -120,31 +154,6 @@ 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> {
@@ -165,37 +174,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 +274,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 +287,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 +317,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"
+        ));
+    }
+}