@perspective-dev/viewer 5.4.0 → 5.5.0

package/src/rust/components/main_panel.rs

@@ -250,6 +250,9 @@ pub struct MainPanel {
     /// `Workspace::staged_changed` → [`MainPanelMsg::StagedChanged`] on THIS
     /// component's scope (see the message doc for why not the root's).
     _staged_sub: crate::utils::Subscription,
+
+    /// `Workspace::layout_staged` → [`MainPanelMsg::LayoutStaged`].
+    _layout_staged_sub: crate::utils::Subscription,
 }
 
 impl Component for MainPanel {
@@ -351,6 +354,15 @@ impl Component for MainPanel {
                 .add_listener(move |()| cb.emit(()))
         };
 
+        let layout_staged_sub = {
+            use crate::utils::AddListener;
+            let cb = ctx.link().callback(|_: ()| MainPanelMsg::LayoutStaged);
+            ctx.props()
+                .workspace
+                .layout_staged()
+                .add_listener(move |()| cb.emit(()))
+        };
+
         Self {
             main_panel_ref: NodeRef::default(),
             layout_ref: NodeRef::default(),
@@ -368,6 +380,7 @@ impl Component for MainPanel {
             theme_backgrounds: HashMap::new(),
             stamped_frame_themes: None,
             _staged_sub: staged_sub,
+            _layout_staged_sub: layout_staged_sub,
         }
     }
 
@@ -375,6 +388,7 @@ impl Component for MainPanel {
         match msg {
             MainPanelMsg::PointerEvent(event) => self.on_pointer_event(ctx, event),
             MainPanelMsg::StagedChanged => true,
+            MainPanelMsg::LayoutStaged => true,
             MainPanelMsg::LayoutUpdated => self.on_layout_updated(ctx),
             MainPanelMsg::TabSelected(name) => self.on_tab_selected(ctx, name),
             MainPanelMsg::ContextMenu(id, x, y) => self.on_context_menu(ctx, id, x, y),

package/src/rust/components/mod.rs

@@ -43,7 +43,6 @@ pub mod rows_counter;
 pub mod settings_panel;
 pub mod status_bar;
 pub mod status_indicator;
-pub mod string_column_style;
 pub mod style;
 pub mod style_controls;
 pub mod type_icon;

package/src/rust/components/plugin_tab.rs

@@ -19,10 +19,12 @@ use itertools::Itertools;
 use perspective_client::config::ViewConfig;
 use yew::prelude::*;
 
+use crate::components::column_settings_sidebar::style_tab::alignment_field::AlignmentField;
+use crate::components::column_settings_sidebar::style_tab::font_field::FontField;
 use crate::components::column_settings_sidebar::style_tab::primitive_field::{
     BoolField, ColorField, EnumField, NumberFieldPrimitive,
 };
-use crate::config::ControlSpec;
+use crate::config::{Alignment, ControlSpec, FontToggle};
 use crate::presentation::Presentation;
 use crate::queries::get_plugin_config_schema;
 use crate::renderer::Renderer;
@@ -72,9 +74,10 @@ pub fn PluginTab(props: &PluginTabProps) -> Html {
     let schema = {
         let renderer = props.renderer.clone();
         let view_config = props.view_config.clone();
+        let plugin_config = props.plugin_config.clone();
         use_memo(
             (props.plugin_config.clone(), props.view_config.clone()),
-            move |_| match get_plugin_config_schema(&renderer, &view_config) {
+            move |_| match get_plugin_config_schema(&renderer, &view_config, Some(&plugin_config)) {
                 Ok(schema) => schema.fields,
                 Err(error) => {
                     tracing::error!("{}", error);
@@ -180,6 +183,58 @@ fn render_leaf(
                 />
             })
         },
+        ControlSpec::Font {
+            key,
+            default,
+            size,
+            bold,
+            italic,
+        } => {
+            let current = raw_config
+                .get(&key)
+                .and_then(|v| v.as_str().map(|s| s.to_string()));
+            let toggle = |t: &FontToggle| raw_config.get(&t.key).and_then(|v| v.as_bool());
+            let size_current = size
+                .as_ref()
+                .and_then(|s| raw_config.get(&s.key))
+                .and_then(|v| v.as_f64());
+            let bold_current = bold.as_ref().and_then(toggle);
+            let italic_current = italic.as_ref().and_then(toggle);
+            Some(html! {
+                <FontField
+                    field_key={key}
+                    {default}
+                    {current}
+                    {size}
+                    {size_current}
+                    {bold}
+                    {bold_current}
+                    {italic}
+                    {italic_current}
+                    on_change={on_change.clone()}
+                />
+            })
+        },
+        ControlSpec::Alignment {
+            key,
+            default,
+            corners,
+        } => {
+            let current = raw_config
+                .get(&key)
+                .and_then(|v| v.as_str())
+                .and_then(Alignment::parse);
+
+            Some(html! {
+                <AlignmentField
+                    field_key={key}
+                    {default}
+                    {corners}
+                    {current}
+                    on_change={on_change.clone()}
+                />
+            })
+        },
         ControlSpec::Bool { key, default } => {
             let current = raw_config.get(&key).and_then(|v| v.as_bool());
             Some(html! {
@@ -220,7 +275,6 @@ fn render_leaf(
         | ControlSpec::AggregateDepth
         | ControlSpec::NumberSeriesStyle { .. }
         | ControlSpec::DatetimeFormat { .. }
-        | ControlSpec::StringFormat
         | ControlSpec::Symbols { .. }
         | ControlSpec::NumberFormat { .. }
         | ControlSpec::String { .. }

package/src/rust/components/settings_panel.rs

@@ -60,6 +60,10 @@ pub struct SettingsPanelProps {
     /// prop-driven instead of reading `Renderer` directly.
     pub plugin_config: PtrEqRc<serde_json::Map<String, serde_json::Value>>,
 
+    /// Snapshot of the active plugin's `columns_config` bucket, threaded
+    /// from `RendererProps` into `ColumnSelector`.
+    pub columns_config: PtrEqRc<ColumnConfigMap>,
+
     /// Column currently being dragged (if any) — threaded to show drag
     /// highlights without per-component `DragDrop` PubSub subscriptions.
     pub drag_column: Option<String>,
@@ -114,6 +118,7 @@ impl PartialEq for SettingsPanelProps {
             && self.plugin_static_config == rhs.plugin_static_config
             && self.view_config == rhs.view_config
             && self.plugin_config == rhs.plugin_config
+            && self.columns_config == rhs.columns_config
             && self.drag_column == rhs.drag_column
             && self.metadata == rhs.metadata
             && self.open_column_settings == rhs.open_column_settings
@@ -356,6 +361,7 @@ pub fn SettingsPanel(props: &SettingsPanelProps) -> Html {
                     named_column_count={props.named_column_count}
                     plugin_static_config={props.plugin_static_config.clone()}
                     view_config={props.view_config.clone()}
+                    columns_config={props.columns_config.clone()}
                     drag_column={props.drag_column.clone()}
                     metadata={props.metadata.clone()}
                     selected_theme={props.selected_theme.clone()}

package/src/rust/components/status_indicator.rs

@@ -51,6 +51,8 @@ pub fn StatusIndicator(props: &StatusIndicatorProps) -> Html {
         && matches!(props.session_props.has_table, Some(TableLoadState::Loading))
     {
         StatusIconState::Loading
+    } else if matches!(props.session_props.has_table, Some(TableLoadState::Pending)) {
+        StatusIconState::Pending
     } else if props.update_count > 0 {
         StatusIconState::Updating
     } else if has_table_cells {
@@ -65,6 +67,7 @@ pub fn StatusIndicator(props: &StatusIndicatorProps) -> Html {
         StatusIconState::Normal => "connected",
         StatusIconState::Updating => "updating",
         StatusIconState::Loading => "loading",
+        StatusIconState::Pending => "pending",
         StatusIconState::Uninitialized => "uninitialized",
     };
 
@@ -107,6 +110,7 @@ pub fn StatusIndicator(props: &StatusIndicatorProps) -> Html {
 #[derive(Clone, Debug, PartialEq)]
 enum StatusIconState {
     Loading,
+    Pending,
     Updating,
     Errored(String, String, &'static str, bool),
     Normal,

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

@@ -235,6 +235,7 @@ impl PerspectiveViewer {
                     None,
                     update,
                     client,
+                    crate::session::MissingTable::Error,
                 )
                 .await?;
 
@@ -269,6 +270,7 @@ impl PerspectiveViewer {
                     None,
                     ViewerConfigInitial::new(table_name),
                     client,
+                    crate::session::MissingTable::Error,
                 )
                 .await?;
 
@@ -313,6 +315,7 @@ impl PerspectiveViewer {
                 None,
                 ViewerConfigInitial::new(table),
                 Some(client),
+                crate::session::MissingTable::Error,
             )
             .await?;
 

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

@@ -95,6 +95,7 @@ impl PerspectiveViewer {
                     plugin_static_config={self.renderer_props.config.clone()}
                     {view_config}
                     plugin_config={self.renderer_props.plugin_config.clone()}
+                    columns_config={self.renderer_props.columns_config.clone()}
                     {drag_column}
                     metadata={metadata.clone()}
                     open_column_settings={self.presentation_props.open_column_settings.clone()}

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

@@ -304,12 +304,21 @@ pub(super) fn create_active_subscriptions(
             }
         });
 
+        let cb_columns_config = ctx.link().callback({
+            let renderer = renderer.clone();
+            move |_: ColumnConfigMap| UpdateRenderer(Box::new(renderer.to_props(None)))
+        });
+
         let sub1 = renderer.plugin_changed.add_listener(cb_plugin);
         let sub2 = renderer
             .plugin_config_changed
             .add_listener(cb_plugin_config);
 
-        vec![sub1, sub2]
+        let sub3 = renderer
+            .columns_config_changed
+            .add_listener(cb_columns_config);
+
+        vec![sub1, sub2, sub3]
     };
 
     let mut subscriptions = Vec::new();

package/src/rust/config/column_config_schema.rs

@@ -74,6 +74,38 @@ pub enum ControlSpec {
         variants: Vec<EnumVariant>,
         default: String,
     },
+
+    /// A CSS `font-family` picked from the generic keywords plus the families
+    /// the host can enumerate, with optional size, bold and italic inputs
+    /// each bound to its own key.
+    Font {
+        key: String,
+        default: String,
+
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        size: Option<FontSize>,
+
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        bold: Option<FontToggle>,
+
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        italic: Option<FontToggle>,
+    },
+    /// A 3×3 anchor picker whose value is one of the nine [`Alignment`]
+    /// tokens.
+    Alignment {
+        key: String,
+
+        /// The cell shown as the unmodified value and elided from serialized
+        /// configs, or `None` when an unset key stands for something no cell
+        /// can show.
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        default: Option<Alignment>,
+
+        /// Only the four corner cells are selectable.
+        #[serde(default, skip_serializing_if = "std::ops::Not::not")]
+        corners: bool,
+    },
     Bool {
         key: String,
         default: bool,
@@ -125,7 +157,6 @@ pub enum ControlSpec {
         #[serde(default, skip_serializing_if = "Option::is_none")]
         default: Option<DatetimeFormatType>,
     },
-    StringFormat,
     NumberSeriesStyle {
         default: NumberSeriesStyleDefaultConfig,
     },
@@ -147,6 +178,108 @@ pub enum ControlSpec {
     },
 }
 
+/// One cell of a 3×3 anchor grid: a corner `top-left`/`top-right`/
+/// `bottom-left`/`bottom-right`, an edge `top`/`left`/`right`/`bottom`, or
+/// `center`.
+#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, PartialEq, Serialize)]
+#[serde(rename_all = "kebab-case")]
+pub enum Alignment {
+    TopLeft,
+    Top,
+    TopRight,
+    Left,
+    Center,
+    Right,
+    BottomLeft,
+    Bottom,
+    BottomRight,
+}
+
+impl Alignment {
+    /// Every cell in row-major order.
+    pub const ALL: [Alignment; 9] = [
+        Alignment::TopLeft,
+        Alignment::Top,
+        Alignment::TopRight,
+        Alignment::Left,
+        Alignment::Center,
+        Alignment::Right,
+        Alignment::BottomLeft,
+        Alignment::Bottom,
+        Alignment::BottomRight,
+    ];
+    pub const CORNERS: [Alignment; 4] = [
+        Alignment::TopLeft,
+        Alignment::TopRight,
+        Alignment::BottomLeft,
+        Alignment::BottomRight,
+    ];
+
+    pub fn is_corner(self) -> bool {
+        Self::CORNERS.contains(&self)
+    }
+
+    /// The serialized token.
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Alignment::TopLeft => "top-left",
+            Alignment::Top => "top",
+            Alignment::TopRight => "top-right",
+            Alignment::Left => "left",
+            Alignment::Center => "center",
+            Alignment::Right => "right",
+            Alignment::BottomLeft => "bottom-left",
+            Alignment::Bottom => "bottom",
+            Alignment::BottomRight => "bottom-right",
+        }
+    }
+
+    pub fn parse(src: &str) -> Option<Self> {
+        Self::ALL.into_iter().find(|x| x.as_str() == src)
+    }
+
+    /// `Top Left`-style text for accessible names.
+    pub fn humanized(self) -> String {
+        self.as_str()
+            .split('-')
+            .map(|word| {
+                let mut chars = word.chars();
+                match chars.next() {
+                    Some(first) => first.to_uppercase().chain(chars).collect::<String>(),
+                    None => String::new(),
+                }
+            })
+            .collect::<Vec<_>>()
+            .join(" ")
+    }
+}
+
+/// One boolean style toggle of a [`ControlSpec::Font`] control: the
+/// config key it writes and the value that counts as "not set".
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
+pub struct FontToggle {
+    pub key: String,
+    #[serde(default)]
+    pub default: bool,
+}
+
+/// The size input of a [`ControlSpec::Font`] control: a number (CSS px)
+/// under its own key, elided from serialized configs at `default`.
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
+pub struct FontSize {
+    pub key: String,
+    pub default: f64,
+
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub min: Option<f64>,
+
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub max: Option<f64>,
+
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub step: Option<f64>,
+}
+
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
 pub struct EnumVariant {
     pub value: String,
@@ -182,9 +315,7 @@ impl ColumnConfigSchema {
         fn is_format(spec: &ControlSpec) -> bool {
             matches!(
                 spec,
-                ControlSpec::NumberFormat { .. }
-                    | ControlSpec::DatetimeFormat { .. }
-                    | ControlSpec::StringFormat
+                ControlSpec::NumberFormat { .. } | ControlSpec::DatetimeFormat { .. }
             )
         }
 
@@ -230,6 +361,18 @@ impl ColumnConfigSchema {
                         canonicalize_specs(fields);
                         return !fields.is_empty();
                     },
+                    ControlSpec::Alignment {
+                        key,
+                        default: Some(default),
+                        corners: true,
+                    } if !default.is_corner() => {
+                        tracing::error!(
+                            "Dropping `{key}` — default `{}` is not a corner",
+                            default.as_str()
+                        );
+
+                        return false;
+                    },
                     ControlSpec::Color { key, default } => (CssKind::Color, key, default),
                     ControlSpec::Palette { key, default, .. } => (CssKind::Palette, key, default),
                     ControlSpec::GradientStops { key, default, .. } => {
@@ -255,6 +398,16 @@ impl ColumnConfigSchema {
         self
     }
 
+    /// The variants of the [`ControlSpec::Enum`] owning `key`, if any.
+    pub fn enum_variants_of(&self, key: &str) -> Option<&[EnumVariant]> {
+        self.leaf_fields().into_iter().find_map(|spec| match spec {
+            ControlSpec::Enum {
+                key: k, variants, ..
+            } if k == key => Some(variants.as_slice()),
+            _ => None,
+        })
+    }
+
     /// The CSS kind of the control owning `key`, if it is CSS-valued.
     pub fn css_kind_of(&self, key: &str) -> Option<CssKind> {
         self.leaf_fields().into_iter().find_map(|spec| match spec {
@@ -275,12 +428,27 @@ impl ControlSpec {
     pub fn serialized_keys(&self) -> Vec<&str> {
         match self {
             ControlSpec::DatetimeFormat { .. } => vec!["date_format"],
-            ControlSpec::StringFormat => vec!["format"],
+            ControlSpec::Font {
+                key,
+                size,
+                bold,
+                italic,
+                ..
+            } => [
+                Some(key.as_str()),
+                size.as_ref().map(|s| s.key.as_str()),
+                bold.as_ref().map(|t| t.key.as_str()),
+                italic.as_ref().map(|t| t.key.as_str()),
+            ]
+            .into_iter()
+            .flatten()
+            .collect(),
             ControlSpec::NumberSeriesStyle { .. } => vec!["chart_type", "stack"],
             ControlSpec::Symbols { .. } => vec!["symbols"],
             ControlSpec::NumberFormat { .. } => vec!["number_format"],
             ControlSpec::AggregateDepth => vec!["aggregate_depth"],
             ControlSpec::Enum { key, .. }
+            | ControlSpec::Alignment { key, .. }
             | ControlSpec::Bool { key, .. }
             | ControlSpec::Number { key, .. }
             | ControlSpec::String { key, .. }
@@ -396,13 +564,46 @@ mod tests {
         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::StringFormat,
+                ControlSpec::DatetimeFormat { default: None },
             ],
         }
         .group_format_controls();
@@ -414,19 +615,45 @@ mod tests {
 
         assert_eq!(key, "format");
         assert!(matches!(fields[0], ControlSpec::NumberFormat { .. }));
-        assert!(matches!(fields[1], ControlSpec::StringFormat));
+        assert!(matches!(fields[1], ControlSpec::DatetimeFormat { .. }));
         assert!(matches!(&schema.fields[1], ControlSpec::Bool { .. }));
 
         assert_eq!(
             schema.active_keys(),
             HashSet::from([
                 "number_format".to_owned(),
-                "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 {
@@ -536,6 +763,83 @@ mod tests {
         );
     }
 
+    #[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 {

package/src/rust/config/datetime_column_style.rs

@@ -10,13 +10,11 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
-mod color_mode;
 mod custom;
 mod custom_format;
 mod simple;
 mod simple_format;
 
-pub use color_mode::*;
 pub use custom::*;
 pub use custom_format::*;
 use serde::{Deserialize, Serialize};
@@ -65,13 +63,4 @@ pub struct DatetimeColumnStyleConfig {
     #[serde(skip_serializing_if = "Option::is_none")]
     #[ts(optional, as = "Option<_>")]
     pub date_format: Option<DatetimeFormatType>,
-
-    #[serde(default)]
-    #[serde(skip_serializing_if = "DatetimeColorMode::is_none")]
-    pub datetime_color_mode: DatetimeColorMode,
-
-    #[serde(default)]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    #[ts(skip)]
-    pub color: Option<String>,
 }