@perspective-dev/viewer 5.3.1 → 5.5.0

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

@@ -16,9 +16,9 @@ use serde::{Deserialize, Serialize};
 use serde_json::Value;
 
 use super::{
-    CssKind, CustomNumberFormatConfig, DatetimeFormatType, KeyValueOpts,
-    NumberSeriesStyleDefaultConfig,
+    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
@@ -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,36 +178,113 @@ pub enum ControlSpec {
     },
 }
 
-#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
-pub struct EnumVariant {
-    pub value: String,
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub label: Option<String>,
+/// 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,
 }
 
-/// One stop of a [`ControlSpec::GradientStops`] value in its in-memory
-/// form: a `#rrggbb` color at `offset` ∈ `[0, 1]`.
+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 GradientStopSpec {
-    pub color: String,
-    pub offset: f64,
+pub struct FontToggle {
+    pub key: String,
+    #[serde(default)]
+    pub default: bool,
 }
 
-/// 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;
-    }
+/// 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>,
 
-    stops.sort_by(|a, b| {
-        a.offset
-            .partial_cmp(&b.offset)
-            .unwrap_or(std::cmp::Ordering::Equal)
-    });
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub max: Option<f64>,
 
-    stops
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub step: Option<f64>,
+}
+
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
+pub struct EnumVariant {
+    pub value: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub label: Option<String>,
 }
 
 /// Fit `stops` to a `discrete` field's fixed pair: an over-length value
@@ -207,9 +315,7 @@ impl ColumnConfigSchema {
         fn is_format(spec: &ControlSpec) -> bool {
             matches!(
                 spec,
-                ControlSpec::NumberFormat { .. }
-                    | ControlSpec::DatetimeFormat { .. }
-                    | ControlSpec::StringFormat
+                ControlSpec::NumberFormat { .. } | ControlSpec::DatetimeFormat { .. }
             )
         }
 
@@ -255,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, .. } => {
@@ -280,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 {
@@ -300,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, .. }
@@ -421,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();
@@ -439,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 {
@@ -561,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>,
 }

package/src/rust/config/mod.rs

@@ -15,7 +15,6 @@
 
 mod column_config_schema;
 mod columns_config;
-mod css_scale;
 mod datetime_column_style;
 mod export_method;
 mod kvpair;
@@ -23,21 +22,18 @@ mod number_series_style;
 mod number_string_format;
 mod options;
 mod plugin_static_config;
-mod string_column_style;
 pub mod view_config;
 mod viewer_config;
 mod workspace_config;
 
 pub use column_config_schema::*;
 pub use columns_config::*;
-pub use css_scale::*;
 pub use datetime_column_style::*;
 pub use export_method::*;
 pub use number_series_style::*;
 pub use number_string_format::*;
 pub use options::*;
 pub use plugin_static_config::*;
-pub use string_column_style::*;
 pub use view_config::*;
 pub use viewer_config::*;
 pub use workspace_config::*;