@perspective-dev/viewer 5.3.0 → 5.3.1

package/src/rust/config/number_string_format.rs

@@ -255,13 +255,106 @@ pub struct CustomNumberFormatConfig {
     pub sign_display: Option<SignDisplay>,
 }
 
+/// The active plugin's `NumberFormat` default overlaid on the built-in
+/// `number_format` values.
+#[derive(Clone, Debug, PartialEq)]
+pub struct NumberFormatDefaults {
+    pub is_float: bool,
+    pub style: NumberFormatStyle,
+    pub notation: Notation,
+    pub minimum_integer_digits: f64,
+    pub fraction: (f64, f64),
+    pub significant: (f64, f64),
+    pub rounding_priority: RoundingPriority,
+    pub rounding_mode: RoundingMode,
+    pub trailing_zero_display: TrailingZeroDisplay,
+    pub use_grouping: UseGrouping,
+    pub sign_display: SignDisplay,
+}
+
+impl NumberFormatDefaults {
+    pub fn builtin(is_float: bool) -> Self {
+        Self {
+            is_float,
+            style: NumberFormatStyle::default(),
+            notation: Notation::default(),
+            minimum_integer_digits: 1.,
+            fraction: if is_float { (2., 2.) } else { (0., 0.) },
+            significant: (1., 21.),
+            rounding_priority: RoundingPriority::default(),
+            rounding_mode: RoundingMode::default(),
+            trailing_zero_display: TrailingZeroDisplay::default(),
+            use_grouping: UseGrouping::default(),
+            sign_display: SignDisplay::default(),
+        }
+    }
+
+    /// Overlay a plugin-declared partial default onto [`Self::builtin`].
+    pub fn resolve(spec_default: Option<&CustomNumberFormatConfig>, is_float: bool) -> Self {
+        let mut out = Self::builtin(is_float);
+        let Some(d) = spec_default else {
+            return out;
+        };
+
+        if let Some(style) = &d._style {
+            out.style = style.clone();
+        }
+
+        if let Some(notation) = &d._notation {
+            out.notation = notation.clone();
+        }
+
+        if let Some(v) = d.minimum_integer_digits {
+            out.minimum_integer_digits = v;
+        }
+
+        if let Some(v) = d.minimum_fraction_digits {
+            out.fraction.0 = v;
+        }
+
+        if let Some(v) = d.maximum_fraction_digits {
+            out.fraction.1 = v;
+        }
+
+        if let Some(v) = d.minimum_significant_digits {
+            out.significant.0 = v;
+        }
+
+        if let Some(v) = d.maximum_significant_digits {
+            out.significant.1 = v;
+        }
+
+        if let Some(v) = d.rounding_priority {
+            out.rounding_priority = v;
+        }
+
+        if let Some(v) = d.rounding_mode {
+            out.rounding_mode = v;
+        }
+
+        if let Some(v) = d.trailing_zero_display {
+            out.trailing_zero_display = v;
+        }
+
+        if let Some(v) = d.use_grouping {
+            out.use_grouping = v;
+        }
+
+        if let Some(v) = d.sign_display {
+            out.sign_display = v;
+        }
+
+        out
+    }
+}
+
 impl CustomNumberFormatConfig {
-    pub fn filter_default(self, is_float: bool) -> Self {
-        let (frac_min, frac_max) = if is_float { (2., 2.) } else { (0., 0.) };
+    pub fn filter_default(self, defaults: &NumberFormatDefaults) -> Self {
+        let (frac_min, frac_max) = defaults.fraction;
         let rounding_increment = self.rounding_increment;
         let use_grouping = self
             .use_grouping
-            .filter(|val| *val != UseGrouping::default());
+            .filter(|val| *val != defaults.use_grouping);
 
         let mut minimum_fraction_digits =
             self.minimum_fraction_digits.filter(|val| *val != frac_min);
@@ -269,7 +362,7 @@ impl CustomNumberFormatConfig {
         let mut maximum_fraction_digits =
             self.maximum_fraction_digits.filter(|val| *val != frac_max);
 
-        let mut show_frac = is_float
+        let mut show_frac = defaults.is_float
             && (minimum_fraction_digits.is_some()
                 || maximum_fraction_digits.is_some()
                 || use_grouping.is_some()
@@ -277,7 +370,7 @@ impl CustomNumberFormatConfig {
                     self._style,
                     Some(NumberFormatStyle::Percent | NumberFormatStyle::Unit(_))
                 ))
-            || !is_float && matches!(self._style, Some(NumberFormatStyle::Currency(_)));
+            || !defaults.is_float && matches!(self._style, Some(NumberFormatStyle::Currency(_)));
 
         // Rounding increment does not work unless `minimum_fraction_digits`
         // and `maximum_fraction_digits` are set to 0.
@@ -287,39 +380,139 @@ impl CustomNumberFormatConfig {
             maximum_fraction_digits = Some(0.);
         }
 
-        let minimum_significant_digits = self.minimum_significant_digits.filter(|val| *val != 1.);
-        let maximum_significant_digits = self.maximum_significant_digits.filter(|val| *val != 21.);
+        let minimum_significant_digits = self
+            .minimum_significant_digits
+            .filter(|val| *val != defaults.significant.0);
+
+        let maximum_significant_digits = self
+            .maximum_significant_digits
+            .filter(|val| *val != defaults.significant.1);
+
         let show_sig = minimum_significant_digits.is_some() || maximum_significant_digits.is_some();
         Self {
-            _style: self
-                ._style
-                .filter(|style| !matches!(style, NumberFormatStyle::Decimal)),
-            minimum_integer_digits: self.minimum_integer_digits.filter(|val| *val != 1.),
+            _style: self._style.filter(|style| *style != defaults.style),
+            minimum_integer_digits: self
+                .minimum_integer_digits
+                .filter(|val| *val != defaults.minimum_integer_digits),
             minimum_fraction_digits: show_frac
                 .then_some(minimum_fraction_digits.unwrap_or(frac_min)),
             maximum_fraction_digits: show_frac
                 .then_some(maximum_fraction_digits.unwrap_or(frac_max)),
             minimum_significant_digits: show_sig
-                .then_some(minimum_significant_digits.unwrap_or(1.)),
+                .then_some(minimum_significant_digits.unwrap_or(defaults.significant.0)),
             maximum_significant_digits: show_sig
-                .then_some(minimum_significant_digits.unwrap_or(21.)),
+                .then_some(maximum_significant_digits.unwrap_or(defaults.significant.1)),
             rounding_priority: self
                 .rounding_priority
-                .filter(|val| *val != RoundingPriority::default()),
+                .filter(|val| *val != defaults.rounding_priority),
             rounding_increment,
             rounding_mode: self
                 .rounding_mode
-                .filter(|val| *val != RoundingMode::default()),
+                .filter(|val| *val != defaults.rounding_mode),
             trailing_zero_display: self
                 .trailing_zero_display
-                .filter(|val| *val != TrailingZeroDisplay::default()),
+                .filter(|val| *val != defaults.trailing_zero_display),
             _notation: self
                 ._notation
-                .filter(|notation| !matches!(notation, Notation::Standard)),
+                .filter(|notation| *notation != defaults.notation),
             use_grouping,
             sign_display: self
                 .sign_display
-                .filter(|val| *val != SignDisplay::default()),
+                .filter(|val| *val != defaults.sign_display),
+        }
+    }
+}
+
+#[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/presentation.rs

@@ -104,6 +104,8 @@ pub struct PresentationHandle {
     open_column_settings: RefCell<OpenColumnSettings>,
     is_workspace: RefCell<Option<bool>>,
 
+    collapsed_control_groups: RefCell<HashSet<String>>,
+
     /// Drag/drop in-progress state. Empty (`NoDrag`) when no user drag is
     /// active. Mutated by `notify_drag_*` / `notify_drop`; read by component
     /// CSS-class derivations (`is_dragover`, `get_drag_column`).
@@ -191,6 +193,7 @@ impl Presentation {
             on_is_workspace_changed: Default::default(),
             is_settings_open: Default::default(),
             open_column_settings: Default::default(),
+            collapsed_control_groups: Default::default(),
             theme_config_updated: PubSub::default(),
             on_eject: PubSub::default(),
             statusbar_pointer_event: PubSub::default(),
@@ -357,6 +360,20 @@ impl Presentation {
         self.open_column_settings.borrow().deref().clone()
     }
 
+    pub fn is_control_group_collapsed(&self, key: &str) -> bool {
+        self.collapsed_control_groups.borrow().contains(key)
+    }
+
+    pub fn set_control_group_collapsed(&self, key: &str, collapsed: bool) {
+        if collapsed {
+            self.collapsed_control_groups
+                .borrow_mut()
+                .insert(key.to_owned());
+        } else {
+            self.collapsed_control_groups.borrow_mut().remove(key);
+        }
+    }
+
     async fn init(self) -> ApiResult<()> {
         self.set_theme_attribute(self.get_selected_theme_name().await.as_deref())
     }

package/src/rust/queries/plugin_column_styles.rs

@@ -42,7 +42,7 @@ pub fn get_plugin_config_schema(
         wasm_bindgen::JsValue::from_serde_ext(view_config).unwrap_or(wasm_bindgen::JsValue::NULL);
     let raw = plugin._plugin_config_schema(&view_config_js)?;
     serde_wasm_bindgen::from_value::<ColumnConfigSchema>(raw)
-        .map(|schema| schema.canonicalize_defaults())
+        .map(|schema| schema.canonicalize())
         .map_err(|e| e.into())
 }
 
@@ -100,6 +100,6 @@ pub fn get_column_config_schema(
     )?;
 
     serde_wasm_bindgen::from_value::<ColumnConfigSchema>(raw)
-        .map(|schema| schema.canonicalize_defaults())
+        .map(|schema| schema.canonicalize())
         .map_err(|e| e.into())
 }

package/src/rust/renderer/dispatch.rs

@@ -165,10 +165,8 @@ impl Renderer {
         width: f64,
         height: f64,
     ) -> ApiResult<Option<js_sys::Function>> {
-        self.0.presize_pending.set(self.0.presize_pending.get() + 1);
-        let result = self.presize_inner(None, width, height).await;
-        self.0.presize_pending.set(self.0.presize_pending.get() - 1);
-        result
+        let _pending = PresizePendingGuard::increment(self);
+        self.presize_inner(None, width, height).await
     }
 
     /// Pre-size AND pre-position the plugin to its target layout bo.
@@ -179,10 +177,8 @@ impl Renderer {
         width: f64,
         height: f64,
     ) -> ApiResult<Option<js_sys::Function>> {
-        self.0.presize_pending.set(self.0.presize_pending.get() + 1);
-        let result = self.presize_inner(Some((dx, dy)), width, height).await;
-        self.0.presize_pending.set(self.0.presize_pending.get() - 1);
-        result
+        let _pending = PresizePendingGuard::increment(self);
+        self.presize_inner(Some((dx, dy)), width, height).await
     }
 
     async fn presize_inner(
@@ -374,7 +370,14 @@ impl Renderer {
             .debounce_with(|guard| async move {
                 set_timeout(timer.get_throttle()).await?;
                 if self.0.presize_pending.get() > 0 {
+                    // Record the drop like the hidden-panel path
+                    // (`wire_panel_render_sub`) does — a silently
+                    // discarded update otherwise leaves the plugin's
+                    // retained frame stale until the NEXT data tick,
+                    // or forever if none comes. `draw_view` /
+                    // `activation_render` consume the marker.
                     tracing::debug!("Update skipped, presize pending");
+                    self.set_data_stale();
                     return Ok(());
                 }
 
@@ -473,3 +476,26 @@ impl Renderer {
         self.draw_lock.clone()
     }
 }
+
+/// RAII increment of [`RendererData::presize_pending`], the counter that
+/// gates [`Renderer::update_lazy`] dispatches. Decrementing on `Drop`
+/// (not on the happy path) makes the release unconditional — a presize
+/// future cancelled mid-await can never strand the counter above zero,
+/// which would silently discard every subsequent debounced update for
+/// the panel's lifetime.
+struct PresizePendingGuard(Renderer);
+
+impl PresizePendingGuard {
+    fn increment(renderer: &Renderer) -> Self {
+        let cell = &renderer.0.presize_pending;
+        cell.set(cell.get() + 1);
+        Self(renderer.clone())
+    }
+}
+
+impl Drop for PresizePendingGuard {
+    fn drop(&mut self) {
+        let cell = &self.0.0.presize_pending;
+        cell.set(cell.get() - 1);
+    }
+}

package/src/rust/renderer/plugin_config.rs

@@ -133,7 +133,7 @@ impl Renderer {
             else {
                 continue;
             };
-            let needs_warm = schema.fields.iter().any(|f| {
+            let needs_warm = schema.leaf_fields().into_iter().any(|f| {
                 matches!(
                     f,
                     ControlSpec::Number {
@@ -164,7 +164,7 @@ impl Renderer {
                 continue;
             };
 
-            for field in &schema.fields {
+            for field in schema.leaf_fields() {
                 let ControlSpec::Number {
                     key,
                     default,
@@ -380,7 +380,7 @@ impl Renderer {
         let view_config_js = JsValue::from_serde_ext(view_config).unwrap_or(JsValue::NULL);
         let raw = plugin._plugin_config_schema(&view_config_js)?;
         serde_wasm_bindgen::from_value::<ColumnConfigSchema>(raw)
-            .map(|schema| schema.canonicalize_defaults())
+            .map(|schema| schema.canonicalize())
             .map_err(|e| e.into())
     }
 
@@ -429,7 +429,7 @@ impl Renderer {
         )?;
 
         serde_wasm_bindgen::from_value::<ColumnConfigSchema>(raw)
-            .map(|schema| schema.canonicalize_defaults())
+            .map(|schema| schema.canonicalize())
             .map_err(|e| e.into())
     }
 
@@ -470,9 +470,9 @@ impl Renderer {
                         ))));
                     }
 
+                    let leaves = s.leaf_fields();
                     map.retain(|key, value| {
-                        let is_default = s
-                            .fields
+                        let is_default = leaves
                             .iter()
                             .any(|spec| matches_declared_default(spec, key, value));
                         if is_default {
@@ -567,9 +567,9 @@ fn strip_default_values(
     schema: &ColumnConfigSchema,
     map: &mut serde_json::Map<String, serde_json::Value>,
 ) {
+    let leaves = schema.leaf_fields();
     map.retain(|key, value| {
-        !schema
-            .fields
+        !leaves
             .iter()
             .any(|spec| matches_declared_default(spec, key, value))
     });
@@ -702,6 +702,53 @@ mod tests {
         ));
     }
 
+    #[test]
+    fn strip_default_values_sees_through_groups() {
+        let leaves = vec![
+            ControlSpec::Bool {
+                key: "flag".to_owned(),
+                default: false,
+            },
+            ControlSpec::Number {
+                key: "size".to_owned(),
+                default: 3.0,
+                include: None,
+                min: None,
+                max: None,
+                step: None,
+            },
+        ];
+
+        let flat = ColumnConfigSchema {
+            fields: leaves.clone(),
+        };
+
+        let grouped = ColumnConfigSchema {
+            fields: vec![ControlSpec::Group {
+                key: "section".to_owned(),
+                fields: leaves,
+            }],
+        };
+
+        let src = json!({ "flag": false, "size": 4.0, "foreign": 1 })
+            .as_object()
+            .unwrap()
+            .clone();
+
+        let mut a = src.clone();
+        let mut b = src;
+        strip_default_values(&flat, &mut a);
+        strip_default_values(&grouped, &mut b);
+        assert_eq!(a, b);
+        assert_eq!(
+            a,
+            json!({ "size": 4.0, "foreign": 1 })
+                .as_object()
+                .unwrap()
+                .clone()
+        );
+    }
+
     #[test]
     fn normalize_css_values_canonicalizes_and_reports() {
         let schema = ColumnConfigSchema {