@perspective-dev/viewer 5.2.0 → 5.3.1

package/src/rust/components/plugin_tab.rs

@@ -20,9 +20,11 @@ use perspective_client::config::ViewConfig;
 use yew::prelude::*;
 
 use crate::components::column_settings_sidebar::style_tab::primitive_field::{
-    BoolField, ColorField, ColorRangeField, EnumField, NumberFieldPrimitive,
+    BoolField, ColorField, EnumField, NumberFieldPrimitive,
 };
+use crate::components::containers::control_group::ControlGroup;
 use crate::config::ControlSpec;
+use crate::presentation::Presentation;
 use crate::queries::get_plugin_config_schema;
 use crate::renderer::Renderer;
 use crate::session::Session;
@@ -47,6 +49,7 @@ pub struct PluginTabProps {
     pub plugin_config: PtrEqRc<serde_json::Map<String, serde_json::Value>>,
 
     // State
+    pub presentation: Presentation,
     pub renderer: Renderer,
     pub session: Session,
 }
@@ -95,122 +98,133 @@ pub fn PluginTab(props: &PluginTabProps) -> Html {
         })
     };
 
-    let raw_config = &*props.plugin_config;
-    let components = schema
-        .iter()
-        .cloned()
-        .filter_map(|spec| {
-            let component = match spec {
-                ControlSpec::Enum {
-                    key,
-                    variants,
-                    default,
-                } => {
-                    let current = raw_config
-                        .get(&key)
-                        .and_then(|v| v.as_str().map(|s| s.to_string()));
-                    html! {
-                        <EnumField
-                            field_key={key}
-                            {variants}
-                            {default}
-                            {current}
-                            on_change={on_change.clone()}
-                        />
-                    }
-                },
-                ControlSpec::Bool { key, default } => {
-                    let current = raw_config.get(&key).and_then(|v| v.as_bool());
-                    html! {
-                        <BoolField
-                            field_key={key}
-                            {default}
-                            {current}
-                            on_change={on_change.clone()}
-                        />
-                    }
-                },
-                ControlSpec::Color { key, default } => {
-                    let current = raw_config
-                        .get(&key)
-                        .and_then(|v| v.as_str().map(|s| s.to_string()));
-                    html! {
-                        <ColorField
-                            field_key={key}
-                            {default}
-                            {current}
-                            on_change={on_change.clone()}
-                        />
-                    }
-                },
-                ControlSpec::ColorRange {
-                    key_pos,
-                    key_neg,
-                    default_pos,
-                    default_neg,
-                    is_gradient,
-                } => {
-                    let current_pos = raw_config
-                        .get(&key_pos)
-                        .and_then(|v| v.as_str().map(|s| s.to_string()));
-                    let current_neg = raw_config
-                        .get(&key_neg)
-                        .and_then(|v| v.as_str().map(|s| s.to_string()));
-                    html! {
-                        <ColorRangeField
-                            field_key_pos={key_pos}
-                            field_key_neg={key_neg}
-                            {default_pos}
-                            {default_neg}
-                            {current_pos}
-                            {current_neg}
-                            {is_gradient}
-                            on_change={on_change.clone()}
-                        />
-                    }
-                },
-                ControlSpec::Number {
-                    key,
-                    default,
-                    min,
-                    max,
-                    step,
-                    include,
-                } => {
-                    let current = raw_config.get(&key).and_then(|v| v.as_f64());
-                    html! {
-                        <NumberFieldPrimitive
-                            field_key={key}
-                            {default}
-                            {current}
-                            {min}
-                            {max}
-                            {step}
-                            {include}
-                            on_change={on_change.clone()}
-                        />
-                    }
-                },
-                // Column-scoped variants don't apply to
-                // plugin-level config; drop silently.
-                ControlSpec::AggregateDepth
-                | ControlSpec::NumberSeriesStyle { .. }
-                | ControlSpec::DatetimeFormat
-                | ControlSpec::StringFormat
-                | ControlSpec::Symbols { .. }
-                | ControlSpec::NumberFormat
-                | ControlSpec::String { .. } => {
-                    return None;
-                },
-            };
-
-            Some(html! { <fieldset class="style-control">{ component }</fieldset> })
+    let on_group_toggle = {
+        let presentation = props.presentation.clone();
+        yew::Callback::from(move |(key, open): (String, bool)| {
+            presentation.set_control_group_collapsed(&key, !open);
         })
-        .collect_vec();
+    };
 
+    let raw_config = &*props.plugin_config;
+    let components = render_specs(
+        &schema,
+        raw_config,
+        &on_change,
+        &props.presentation,
+        &on_group_toggle,
+    );
     html! {
         <div id="plugin-tab" class="sidebar_column scrollable">
             <div id="plugin-config-container" class="tab-section">{ components }</div>
         </div>
     }
 }
+
+fn render_specs(
+    specs: &[ControlSpec],
+    raw_config: &serde_json::Map<String, serde_json::Value>,
+    on_change: &Callback<crate::config::ColumnConfigFieldUpdate>,
+    presentation: &Presentation,
+    on_group_toggle: &Callback<(String, bool)>,
+) -> Vec<Html> {
+    specs
+        .iter()
+        .filter_map(|spec| match spec {
+            ControlSpec::Group { key, fields } => {
+                let children =
+                    render_specs(fields, raw_config, on_change, presentation, on_group_toggle);
+
+                (!children.is_empty()).then(|| {
+                    html! {
+                        <ControlGroup
+                            key={format!("group::{key}")}
+                            group_key={key.clone()}
+                            open={!presentation.is_control_group_collapsed(key)}
+                            on_toggle={on_group_toggle.clone()}
+                        >
+                            { children }
+                        </ControlGroup>
+                    }
+                })
+            },
+            leaf => {
+                let key = leaf.serialized_keys().join("+");
+                let component = render_leaf(leaf, raw_config, on_change)?;
+                Some(html! { <fieldset class="style-control" {key}>{ component }</fieldset> })
+            },
+        })
+        .collect_vec()
+}
+
+fn render_leaf(
+    spec: &ControlSpec,
+    raw_config: &serde_json::Map<String, serde_json::Value>,
+    on_change: &Callback<crate::config::ColumnConfigFieldUpdate>,
+) -> Option<Html> {
+    match spec.clone() {
+        ControlSpec::Enum {
+            key,
+            variants,
+            default,
+        } => {
+            let current = raw_config
+                .get(&key)
+                .and_then(|v| v.as_str().map(|s| s.to_string()));
+            Some(html! {
+                <EnumField
+                    field_key={key}
+                    {variants}
+                    {default}
+                    {current}
+                    on_change={on_change.clone()}
+                />
+            })
+        },
+        ControlSpec::Bool { key, default } => {
+            let current = raw_config.get(&key).and_then(|v| v.as_bool());
+            Some(html! {
+                <BoolField field_key={key} {default} {current} on_change={on_change.clone()} />
+            })
+        },
+        ControlSpec::Color { key, default } => {
+            let current = raw_config
+                .get(&key)
+                .and_then(|v| v.as_str().map(|s| s.to_string()));
+            Some(html! {
+                <ColorField field_key={key} {default} {current} on_change={on_change.clone()} />
+            })
+        },
+        ControlSpec::Number {
+            key,
+            default,
+            min,
+            max,
+            step,
+            include,
+        } => {
+            let current = raw_config.get(&key).and_then(|v| v.as_f64());
+            Some(html! {
+                <NumberFieldPrimitive
+                    field_key={key}
+                    {default}
+                    {current}
+                    {min}
+                    {max}
+                    {step}
+                    {include}
+                    on_change={on_change.clone()}
+                />
+            })
+        },
+        ControlSpec::Group { .. }
+        | ControlSpec::AggregateDepth
+        | ControlSpec::NumberSeriesStyle { .. }
+        | ControlSpec::DatetimeFormat { .. }
+        | ControlSpec::StringFormat
+        | ControlSpec::Symbols { .. }
+        | ControlSpec::NumberFormat { .. }
+        | ControlSpec::String { .. }
+        | ControlSpec::Palette { .. }
+        | ControlSpec::GradientStops { .. } => None,
+    }
+}

package/src/rust/components/settings_panel.rs

@@ -22,7 +22,8 @@ use super::plugin_tab::PluginTab;
 use crate::components::containers::sidebar_close_button::SidebarCloseButton;
 use crate::components::form::debug::DebugPanel;
 use crate::config::{PluginStaticConfig, PluginUpdate};
-use crate::presentation::{ColumnLocator, OpenColumnSettings, Presentation};
+use crate::presentation::{ColumnLocator, ColumnSettingsTarget, OpenColumnSettings, Presentation};
+use crate::queries::classify_column;
 use crate::renderer::*;
 use crate::session::column_defaults_update::*;
 use crate::session::*;
@@ -34,7 +35,7 @@ use crate::workspace::Workspace;
 pub struct SettingsPanelProps {
     pub on_close: Callback<()>,
     pub on_resize: Rc<PubSub<()>>,
-    pub on_select_column: Callback<Option<ColumnLocator>>,
+    pub on_select_column: Callback<Option<ColumnSettingsTarget>>,
     pub on_debug: Callback<()>,
     pub is_debug: bool,
 
@@ -145,25 +146,28 @@ pub fn SettingsPanel(props: &SettingsPanelProps) -> Html {
     } = &props;
 
     let selected_column = {
-        let locator = props.open_column_settings.locator.clone();
         let config = &props.view_config;
-        locator.filter(|locator| match locator {
-            ColumnLocator::Table(_name) => {
-                locator
-                    .name()
-                    .map(|n| {
-                        config.columns.iter().any(|maybe_col| {
-                            maybe_col.as_ref().map(|col| col == n).unwrap_or_default()
-                        }) || config.group_by.iter().any(|col| col == n)
-                            || config.split_by.iter().any(|col| col == n)
-                            || config.filter.iter().any(|col| col.column() == n)
-                            || config.sort.iter().any(|col| &col.0 == n)
-                    })
-                    .unwrap_or_default()
-                    && props.renderer.can_render_column_styles()
-            },
-            _ => true,
-        })
+        props
+            .open_column_settings
+            .target
+            .as_ref()
+            .and_then(|target| match target {
+                ColumnSettingsTarget::NewExpression => Some(ColumnLocator::NewExpression),
+                ColumnSettingsTarget::Column(n) => {
+                    let locator = classify_column(n, config, &props.metadata)?;
+                    if !matches!(locator, ColumnLocator::Table(_)) {
+                        return Some(locator);
+                    }
+
+                    let used = config.columns.iter().any(|maybe_col| {
+                        maybe_col.as_ref().map(|col| col == n).unwrap_or_default()
+                    }) || config.group_by.iter().any(|col| col == n)
+                        || config.split_by.iter().any(|col| col == n)
+                        || config.filter.iter().any(|col| col.column() == n)
+                        || config.sort.iter().any(|col| &col.0 == n);
+                    (used && props.renderer.can_render_column_styles()).then_some(locator)
+                },
+            })
     };
 
     let plugin_name = props.plugin_name.clone();
@@ -217,6 +221,7 @@ pub fn SettingsPanel(props: &SettingsPanelProps) -> Html {
 
             update.set_update_column_defaults(
                 &session_metadata,
+                &view_config,
                 &view_config.columns,
                 plugin_config,
             );
@@ -365,6 +370,7 @@ pub fn SettingsPanel(props: &SettingsPanelProps) -> Html {
                 <PluginTab
                     view_config={props.view_config.clone()}
                     plugin_config={props.plugin_config.clone()}
+                    presentation={presentation.clone()}
                     renderer={renderer.clone()}
                     session={session.clone()}
                 // initial_width={width}

package/src/rust/components/status_bar.rs

@@ -429,7 +429,6 @@ fn ThemeSelector(props: &ThemeSelectorProps) -> Html {
                             <span class="icon" />
                             <Select<String>
                                 id="theme_selector"
-                                class="invert"
                                 {values}
                                 selected={selected.to_owned()}
                                 on_select={props.on_change.clone()}

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

@@ -37,7 +37,7 @@ impl CustomNumberFormat {
                     min=1.
                     max=21.
                     step=1.
-                    default=1.
+                    default={ctx.props().defaults.minimum_integer_digits}
                     current_value={self.config.minimum_integer_digits}
                     on_change={ctx.link().callback(CustomNumberFormatMsg::MinimumIntegerDigits)}
                 />
@@ -84,14 +84,23 @@ impl CustomNumberFormat {
     }
 
     fn float_section(&self, ctx: &yew::prelude::Context<Self>) -> yew::prelude::Html {
+        let defaults = &ctx.props().defaults;
         let fractional_value = Some((
-            self.config.minimum_fraction_digits.unwrap_or(2.),
-            self.config.maximum_fraction_digits.unwrap_or(2.),
+            self.config
+                .minimum_fraction_digits
+                .unwrap_or(defaults.fraction.0),
+            self.config
+                .maximum_fraction_digits
+                .unwrap_or(defaults.fraction.1),
         ));
 
         let significant_value = Some((
-            self.config.minimum_significant_digits.unwrap_or(1.),
-            self.config.maximum_significant_digits.unwrap_or(21.),
+            self.config
+                .minimum_significant_digits
+                .unwrap_or(defaults.significant.0),
+            self.config
+                .maximum_significant_digits
+                .unwrap_or(defaults.significant.1),
         ));
 
         html! {
@@ -102,7 +111,7 @@ impl CustomNumberFormat {
                         min=0.
                         max=20.
                         step=1.
-                        default={(2., 2.)}
+                        default={defaults.fraction}
                         current_value={fractional_value}
                         on_change={ctx.link().callback(CustomNumberFormatMsg::FracChange)}
                     />
@@ -113,7 +122,7 @@ impl CustomNumberFormat {
                         min=1.
                         max=21.
                         step=1.
-                        default={(1., 21.)}
+                        default={defaults.significant}
                         current_value={significant_value}
                         on_change={ctx.link().callback(CustomNumberFormatMsg::SigChange)}
                     />
@@ -121,17 +130,20 @@ impl CustomNumberFormat {
                 { self.rounding_increment(ctx) }
                 <SelectEnumField<RoundingPriority>
                     label="rounding-priority"
-                    current_value={self.config.rounding_priority}
+                    current_value={self.config.rounding_priority.unwrap_or(defaults.rounding_priority)}
+                    default_value={defaults.rounding_priority}
                     on_change={ctx.link().callback(CustomNumberFormatMsg::RoundingPriority)}
                 />
                 <SelectEnumField<RoundingMode>
                     label="rounding-mode"
-                    current_value={self.config.rounding_mode}
+                    current_value={self.config.rounding_mode.unwrap_or(defaults.rounding_mode)}
+                    default_value={defaults.rounding_mode}
                     on_change={ctx.link().callback(CustomNumberFormatMsg::RoundingMode)}
                 />
                 <SelectEnumField<TrailingZeroDisplay>
                     label="trailing-zero-display"
-                    current_value={self.config.trailing_zero_display}
+                    current_value={self.config.trailing_zero_display.unwrap_or(defaults.trailing_zero_display)}
+                    default_value={defaults.trailing_zero_display}
                     on_change={ctx.link().callback(CustomNumberFormatMsg::TrailingZero)}
                 />
             </>

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

@@ -32,23 +32,27 @@ impl CustomNumberFormat {
             None
         };
 
+        let defaults = &ctx.props().defaults;
         html! {
             <>
                 <SelectEnumField<NotationName>
                     label="notation"
                     on_change={ctx.link().callback(CustomNumberFormatMsg::NotationChanged)}
                     current_value={self.notation.unwrap_or_default()}
+                    default_value={NotationName::from(&defaults.notation)}
                 />
                 { compact_display_checkbox }
                 <SelectEnumField<UseGrouping>
                     label="use-grouping"
                     on_change={ctx.link().callback(CustomNumberFormatMsg::UseGrouping)}
-                    current_value={self.config.use_grouping.unwrap_or_default()}
+                    current_value={self.config.use_grouping.unwrap_or(defaults.use_grouping)}
+                    default_value={defaults.use_grouping}
                 />
                 <SelectEnumField<SignDisplay>
                     label="sign-display"
                     on_change={ctx.link().callback(CustomNumberFormatMsg::SignDisplay)}
-                    current_value={self.config.sign_display.unwrap_or_default()}
+                    current_value={self.config.sign_display.unwrap_or(defaults.sign_display)}
+                    default_value={defaults.sign_display}
                 />
             </>
         }

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

@@ -60,6 +60,7 @@ impl CustomNumberFormat {
                 <SelectEnumField<NumberStyle>
                     label="style"
                     current_value={self.style}
+                    default_value={NumberStyle::from(&ctx.props().defaults.style)}
                     on_change={ctx.link().callback(CustomNumberFormatMsg::StyleChanged)}
                 />
                 { section }

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

@@ -12,6 +12,8 @@
 
 use strum::{Display, EnumIter};
 
+use crate::config::{Notation, NumberFormatStyle};
+
 #[derive(Clone, PartialEq, Debug, Copy, Default, EnumIter, Display)]
 pub enum NumberStyle {
     #[default]
@@ -21,6 +23,17 @@ pub enum NumberStyle {
     Unit,
 }
 
+impl From<&NumberFormatStyle> for NumberStyle {
+    fn from(style: &NumberFormatStyle) -> Self {
+        match style {
+            NumberFormatStyle::Decimal => Self::Decimal,
+            NumberFormatStyle::Currency(_) => Self::Currency,
+            NumberFormatStyle::Percent => Self::Percent,
+            NumberFormatStyle::Unit(_) => Self::Unit,
+        }
+    }
+}
+
 #[derive(Clone, PartialEq, Debug, Copy, Default, Display, EnumIter)]
 pub enum NotationName {
     #[default]
@@ -29,3 +42,14 @@ pub enum NotationName {
     Engineering,
     Compact,
 }
+
+impl From<&Notation> for NotationName {
+    fn from(notation: &Notation) -> Self {
+        match notation {
+            Notation::Standard => Self::Standard,
+            Notation::Scientific => Self::Scientific,
+            Notation::Engineering => Self::Engineering,
+            Notation::Compact(_) => Self::Compact,
+        }
+    }
+}

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,
         }
     }
 }