@perspective-dev/viewer 5.5.0 → 5.6.0

package/src/rust/config/column_config_schema.rs

@@ -61,6 +61,14 @@ impl ColumnConfigSchema {
     }
 }
 
+/// A per-column statistic a [`ControlSpec::Number`] may take its default from.
+#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub enum NumberStat {
+    /// The largest absolute value in the column.
+    AbsMax,
+}
+
 /// Discriminated union of widget kinds the viewer can render. Composite
 /// variants wrap an existing rich Yew component and carry only the
 /// component's `*DefaultConfig`. Primitive variants render generic scalar
@@ -126,6 +134,11 @@ pub enum ControlSpec {
 
         #[serde(default, skip_serializing_if = "Option::is_none")]
         step: Option<f64>,
+
+        /// The column statistic the HOST substitutes for `default`, once it has
+        /// fetched it.
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        default_stat: Option<NumberStat>,
     },
     String {
         key: String,
@@ -311,6 +324,31 @@ impl ColumnConfigSchema {
         self.canonicalize_defaults().group_format_controls()
     }
 
+    /// Replace the `default` of every [`ControlSpec::Number`] that declares a
+    /// `default_stat` with that statistic, where the host has it.
+    pub fn resolve_stat_defaults(mut self, abs_max: Option<f64>) -> Self {
+        fn walk(fields: &mut [ControlSpec], abs_max: Option<f64>) {
+            for spec in fields {
+                match spec {
+                    ControlSpec::Group { fields, .. } => walk(fields, abs_max),
+                    ControlSpec::Number {
+                        default,
+                        default_stat: Some(NumberStat::AbsMax),
+                        ..
+                    } => {
+                        if let Some(abs_max) = abs_max {
+                            *default = abs_max;
+                        }
+                    },
+                    _ => {},
+                }
+            }
+        }
+
+        walk(&mut self.fields, abs_max);
+        self
+    }
+
     pub fn group_format_controls(mut self) -> Self {
         fn is_format(spec: &ControlSpec) -> bool {
             matches!(
@@ -485,380 +523,3 @@ 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 enum_variants_see_through_groups() {
-        let mode = ControlSpec::Enum {
-            key: "fg_mode".to_owned(),
-            default: "color".to_owned(),
-            variants: vec![
-                EnumVariant {
-                    value: "disabled".to_owned(),
-                    label: None,
-                },
-                EnumVariant {
-                    value: "color".to_owned(),
-                    label: None,
-                },
-            ],
-        };
-
-        let grouped = ColumnConfigSchema {
-            fields: vec![group("color", vec![mode, flag("flag")])],
-        };
-
-        let values: Vec<&str> = grouped
-            .enum_variants_of("fg_mode")
-            .unwrap()
-            .iter()
-            .map(|v| v.value.as_str())
-            .collect();
-
-        assert_eq!(values, vec!["disabled", "color"]);
-        assert!(grouped.enum_variants_of("flag").is_none());
-        assert!(grouped.enum_variants_of("missing").is_none());
-    }
-
-    #[test]
-    fn format_controls_group_and_merge() {
-        let schema = ColumnConfigSchema {
-            fields: vec![
-                ControlSpec::NumberFormat { default: None },
-                flag("flag"),
-                ControlSpec::DatetimeFormat { default: None },
-            ],
-        }
-        .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::DatetimeFormat { .. }));
-        assert!(matches!(&schema.fields[1], ControlSpec::Bool { .. }));
-
-        assert_eq!(
-            schema.active_keys(),
-            HashSet::from([
-                "number_format".to_owned(),
-                "date_format".to_owned(),
-                "flag".to_owned()
-            ])
-        );
-    }
-
-    #[test]
-    fn font_owns_its_size_and_toggle_keys() {
-        let spec = ControlSpec::Font {
-            key: "font_family".to_owned(),
-            default: "inherit".to_owned(),
-            size: Some(FontSize {
-                key: "font_size".to_owned(),
-                default: 12.0,
-                min: None,
-                max: None,
-                step: None,
-            }),
-            bold: Some(FontToggle {
-                key: "bold".to_owned(),
-                default: false,
-            }),
-            italic: None,
-        };
-
-        assert_eq!(spec.serialized_keys(), vec![
-            "font_family",
-            "font_size",
-            "bold"
-        ]);
-    }
-
-    #[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 alignment_tokens_round_trip() {
-        for align in Alignment::ALL {
-            assert_eq!(Alignment::parse(align.as_str()), Some(align));
-            assert_eq!(serde_json::to_value(align).unwrap(), json!(align.as_str()));
-        }
-
-        for bad in ["middle", "left-top", "top-center", "middle-left", ""] {
-            assert_eq!(Alignment::parse(bad), None, "{bad}");
-        }
-
-        assert_eq!(Alignment::ALL.iter().filter(|x| x.is_corner()).count(), 4);
-        assert_eq!(Alignment::TopLeft.humanized(), "Top Left");
-        assert_eq!(Alignment::Center.humanized(), "Center");
-    }
-
-    #[test]
-    fn alignment_deserializes_with_optional_default_and_corners() {
-        let schema: ColumnConfigSchema = serde_json::from_value(json!({
-            "fields": [
-                { "kind": "Alignment", "key": "align" },
-                { "kind": "Alignment", "key": "legend_anchor", "default": "top-right", "corners": true }
-            ]
-        }))
-        .unwrap();
-
-        assert!(matches!(&schema.fields[0], ControlSpec::Alignment {
-            default: None,
-            corners: false,
-            ..
-        }));
-        assert!(matches!(&schema.fields[1], ControlSpec::Alignment {
-            default: Some(Alignment::TopRight),
-            corners: true,
-            ..
-        }));
-        assert_eq!(
-            schema.active_keys(),
-            HashSet::from(["align".to_owned(), "legend_anchor".to_owned()])
-        );
-        assert!(
-            serde_json::from_value::<ColumnConfigSchema>(json!({
-                "fields": [{ "kind": "Alignment", "key": "x", "default": "middle" }]
-            }))
-            .is_err()
-        );
-    }
-
-    #[test]
-    fn canonicalize_defaults_drops_non_corner_default_of_corners_field() {
-        let schema = ColumnConfigSchema {
-            fields: vec![
-                ControlSpec::Alignment {
-                    key: "bad".to_owned(),
-                    default: Some(Alignment::Top),
-                    corners: true,
-                },
-                ControlSpec::Alignment {
-                    key: "ok".to_owned(),
-                    default: Some(Alignment::Top),
-                    corners: false,
-                },
-                ControlSpec::Alignment {
-                    key: "unset".to_owned(),
-                    default: None,
-                    corners: true,
-                },
-            ],
-        }
-        .canonicalize_defaults();
-
-        assert_eq!(
-            schema.active_keys(),
-            HashSet::from(["ok".to_owned(), "unset".to_owned()])
-        );
-    }
-
-    #[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/export_method.rs

@@ -69,6 +69,24 @@ pub enum ExportMethod {
     #[serde(rename = "arrow-all")]
     ArrowAll,
 
+    #[serde(rename = "arrow-lz4")]
+    ArrowLz4,
+
+    #[serde(rename = "arrow-lz4-selected")]
+    ArrowLz4Selected,
+
+    #[serde(rename = "arrow-lz4-all")]
+    ArrowLz4All,
+
+    #[serde(rename = "arrow-zstd")]
+    ArrowZstd,
+
+    #[serde(rename = "arrow-zstd-selected")]
+    ArrowZstdSelected,
+
+    #[serde(rename = "arrow-zstd-all")]
+    ArrowZstdAll,
+
     #[serde(rename = "json-config")]
     JsonConfig,
 }
@@ -94,6 +112,12 @@ impl ExportMethod {
             Self::CsvSelected => ".selected.csv",
             Self::JsonSelected => ".selected.json",
             Self::ArrowSelected => ".selected.arrow",
+            Self::ArrowLz4 => ".lz4.arrow",
+            Self::ArrowLz4Selected => ".selected.lz4.arrow",
+            Self::ArrowLz4All => ".all.lz4.arrow",
+            Self::ArrowZstd => ".zstd.arrow",
+            Self::ArrowZstdSelected => ".selected.zstd.arrow",
+            Self::ArrowZstdAll => ".all.zstd.arrow",
             Self::Ndjson => ".ndjson",
             Self::NdjsonAll => ".all.ndjson",
             Self::NdjsonSelected => ".selected.ndjson",

package/src/rust/config/number_string_format.rs

@@ -422,97 +422,3 @@ impl CustomNumberFormatConfig {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn sig(min: f64, max: f64) -> CustomNumberFormatConfig {
-        CustomNumberFormatConfig {
-            minimum_significant_digits: Some(min),
-            maximum_significant_digits: Some(max),
-            ..Default::default()
-        }
-    }
-
-    #[test]
-    fn resolve_overlays_partial_default_on_builtin() {
-        let spec = CustomNumberFormatConfig {
-            _notation: Some(Notation::Compact(CompactDisplay::Short)),
-            minimum_fraction_digits: Some(0.),
-            maximum_fraction_digits: Some(1.),
-            ..Default::default()
-        };
-
-        let defaults = NumberFormatDefaults::resolve(Some(&spec), true);
-        assert_eq!(defaults.notation, Notation::Compact(CompactDisplay::Short));
-        assert_eq!(defaults.fraction, (0., 1.));
-        assert_eq!(defaults.style, NumberFormatStyle::Decimal);
-        assert_eq!(defaults.significant, (1., 21.));
-        assert_eq!(
-            NumberFormatDefaults::resolve(None, true),
-            NumberFormatDefaults::builtin(true)
-        );
-    }
-
-    #[test]
-    fn filter_preserves_max_significant_digits() {
-        let filtered = sig(1., 5.).filter_default(&NumberFormatDefaults::builtin(true));
-        assert_eq!(filtered.minimum_significant_digits, Some(1.));
-        assert_eq!(filtered.maximum_significant_digits, Some(5.));
-
-        let filtered = sig(3., 21.).filter_default(&NumberFormatDefaults::builtin(true));
-        assert_eq!(filtered.minimum_significant_digits, Some(3.));
-        assert_eq!(filtered.maximum_significant_digits, Some(21.));
-    }
-
-    #[test]
-    fn filter_elides_values_equal_to_resolved_defaults() {
-        let defaults = NumberFormatDefaults {
-            fraction: (0., 1.),
-            notation: Notation::Compact(CompactDisplay::Short),
-            ..NumberFormatDefaults::builtin(true)
-        };
-
-        let config = CustomNumberFormatConfig {
-            _notation: Some(Notation::Compact(CompactDisplay::Short)),
-            minimum_fraction_digits: Some(0.),
-            maximum_fraction_digits: Some(1.),
-            ..Default::default()
-        };
-
-        assert_eq!(
-            config.filter_default(&defaults),
-            CustomNumberFormatConfig::default()
-        );
-    }
-
-    #[test]
-    fn filter_serializes_builtin_values_under_override() {
-        let defaults = NumberFormatDefaults {
-            notation: Notation::Compact(CompactDisplay::Short),
-            ..NumberFormatDefaults::builtin(true)
-        };
-
-        let config = CustomNumberFormatConfig {
-            _notation: Some(Notation::Standard),
-            ..Default::default()
-        };
-
-        let filtered = config.filter_default(&defaults);
-        assert_eq!(filtered._notation, Some(Notation::Standard));
-    }
-
-    #[test]
-    fn filter_bakes_fraction_digits_for_percent_style() {
-        let config = CustomNumberFormatConfig {
-            _style: Some(NumberFormatStyle::Percent),
-            ..Default::default()
-        };
-
-        let filtered = config.filter_default(&NumberFormatDefaults::builtin(true));
-        assert_eq!(filtered._style, Some(NumberFormatStyle::Percent));
-        assert_eq!(filtered.minimum_fraction_digits, Some(2.));
-        assert_eq!(filtered.maximum_fraction_digits, Some(2.));
-    }
-}

package/src/rust/config/options.rs

@@ -35,13 +35,9 @@ pub struct RestoreOptions {
     #[ts(optional)]
     pub panel: Option<String>,
 
-    /// When `true`, a failed restore only REJECTS the returned `Promise` —
-    /// the error is not committed to the viewer's visible error state, and
-    /// the session remains usable for subsequent calls. For programmatic
-    /// callers (e.g. the LLM agent's `set_view_config` tool) for whom a
-    /// failed config patch is feedback rather than a user-facing fault.
-    /// The config may be partially applied on failure; restore a
-    /// known-good config to recover exactly.
+    /// When `true`, a config that was applied and then failed to render only
+    /// rejects the returned `Promise`, without raising the panel's visible
+    /// error state.
     #[ts(optional)]
     pub suppress_errors: Option<bool>,
 

package/src/rust/config/plugin_static_config.rs

@@ -215,45 +215,3 @@ impl PluginStaticConfig {
             .unwrap_or_default()
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn plugin(names: &[&str]) -> PluginStaticConfig {
-        PluginStaticConfig {
-            config_column_names: names.iter().map(|x| (*x).to_owned()).collect(),
-            ..Default::default()
-        }
-    }
-
-    /// The tail rule has ONE definition: `is_swap` and the role a
-    /// trailing column repeats must never disagree about where the
-    /// positional slots end.
-    #[test]
-    fn positional_slots_and_tail_agree() {
-        // `Y Line` — the only named slot IS the tail, so every column
-        // is another Y series and none of them swap.
-        let y_line = plugin(&["Y Axis"]);
-        assert_eq!(y_line.positional_columns(), 0);
-        assert_eq!(y_line.tail_column_role(), Some("Y Axis"));
-        assert!(!y_line.is_swap(0));
-
-        // `X/Y Line` — two pinned axes, then tooltips.
-        let xy_line = plugin(&["X Axis", "Y Axis", "Tooltip"]);
-        assert_eq!(xy_line.positional_columns(), 2);
-        assert_eq!(xy_line.tail_column_role(), Some("Tooltip"));
-        assert!(xy_line.is_swap(0));
-        assert!(xy_line.is_swap(1));
-        assert!(!xy_line.is_swap(2));
-
-        for index in 0..4 {
-            assert_eq!(xy_line.is_swap(index), index < xy_line.positional_columns());
-        }
-
-        let unnamed = plugin(&[]);
-        assert_eq!(unnamed.positional_columns(), 0);
-        assert_eq!(unnamed.tail_column_role(), None);
-        assert!(!unnamed.is_swap(0));
-    }
-}