@perspective-dev/viewer 5.2.0 → 5.3.1

package/src/rust/config/datetime_column_style.rs

@@ -41,10 +41,6 @@ impl Default for DatetimeFormatType {
 }
 
 impl DatetimeFormatType {
-    fn is_simple(&self) -> bool {
-        self == &Self::Simple(SimpleDatetimeStyleConfig::default())
-    }
-
     pub fn time_zone(&self) -> &Option<String> {
         match self {
             DatetimeFormatType::Custom(x) => &x.time_zone,
@@ -62,12 +58,13 @@ impl DatetimeFormatType {
 
 /// A model for the JSON serialized style configuration for a column of type
 /// `datetime`.
-#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize, TS)]
+#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq, Serialize, TS)]
 // #[derive(WasmDescribe!, FromWasmAbi!)]
 pub struct DatetimeColumnStyleConfig {
     #[serde(default)]
-    #[serde(skip_serializing_if = "DatetimeFormatType::is_simple")]
-    pub date_format: DatetimeFormatType,
+    #[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")]
@@ -78,17 +75,3 @@ pub struct DatetimeColumnStyleConfig {
     #[ts(skip)]
     pub color: Option<String>,
 }
-
-impl Default for DatetimeColumnStyleConfig {
-    fn default() -> Self {
-        Self {
-            date_format: DatetimeFormatType::Simple(SimpleDatetimeStyleConfig {
-                time_zone: Default::default(),
-                date_style: SimpleDatetimeFormat::Short,
-                time_style: SimpleDatetimeFormat::Medium,
-            }),
-            datetime_color_mode: Default::default(),
-            color: Default::default(),
-        }
-    }
-}

package/src/rust/config/mod.rs

@@ -15,6 +15,7 @@
 
 mod column_config_schema;
 mod columns_config;
+mod css_scale;
 mod datetime_column_style;
 mod export_method;
 mod kvpair;
@@ -29,6 +30,7 @@ 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::*;

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/config/options.rs

@@ -87,3 +87,13 @@ pub struct GetClientOptions {
     #[ts(optional)]
     pub panel: Option<String>,
 }
+
+/// Options for the `saveWorkspace()` method.
+#[derive(Deserialize, Default, TS)]
+pub struct SaveWorkspaceOptions {
+    /// When `true`, the emitted `palette` is the full set the element
+    /// holds rather than only the values the panels reference.
+    #[serde(default)]
+    #[ts(optional)]
+    pub full_palette: Option<bool>,
+}

package/src/rust/config/viewer_config.rs

@@ -24,7 +24,7 @@ use crate::renderer::ColumnConfigMap;
 
 /// The state of an entire `custom_elements::PerspectiveViewerElement` component
 /// and its `Plugin`: the element-level `settings` flag plus the per-panel
-/// [`PanelViewerConfig`]. The split exists so the whole-element config format
+/// [`PanelViewerConfig`]. The split exists so the workspace config format
 /// can serialize panel entries *without* a `settings` key (it is element-level
 /// state there, carried by the top-level `active` field instead), while the
 /// single-panel format flattens back to the legacy shape.
@@ -39,7 +39,7 @@ pub struct ViewerConfig<V: TS = String> {
 
 /// The per-panel state of a [`ViewerConfig`] — everything except the
 /// element-level `settings` flag. This is the `panels` entry type of the
-/// whole-element config format.
+/// workspace config format.
 #[derive(Debug, Default, Serialize, PartialEq, TS)]
 pub struct PanelViewerConfig<V: TS = String> {
     /// The `@perspective-dev/viewer` version that wrote this config,
@@ -315,15 +315,53 @@ impl From<ViewerConfigInitial> for ViewerConfigUpdate {
     }
 }
 
-// There is deliberately NO `TryFrom<ViewerConfigUpdate>` here. Requiring a
-// `table` is a property of the CREATION ENTRY POINTS — `addPanel`'s
-// argument type, `WorkspaceConfigUpdate::panels`, and the agent's
-// `add_panel` decode — each of which already has a `ViewerConfigInitial`
-// in hand. An update→initial conversion exists only to let a route holding
-// a PATCH pretend it is creating from scratch, which is how `restore`'s
-// upsert acquired the gate and started rejecting the table-less
-// restore-then-`load` contract. Its absence is what keeps that from
-// recurring: `create_panel` takes an update, so no caller needs one.
+/// The rejection every panel-creating route without a `table` resolves to.
+pub const CREATE_REQUIRES_TABLE: &str = "Cannot create a panel without a `table` — `load()` a \
+                                         `Client` and include `table` in the config, or use \
+                                         `addPanel()`";
+
+fn down<T: Clone>(value: OptionalUpdate<T>) -> Option<T> {
+    match value {
+        OptionalUpdate::Update(value) => Some(value),
+        OptionalUpdate::Missing | OptionalUpdate::SetDefault => None,
+    }
+}
+
+impl TryFrom<ViewerConfigUpdate> for ViewerConfigInitial {
+    type Error = ApiError;
+
+    fn try_from(value: ViewerConfigUpdate) -> Result<Self, Self::Error> {
+        // Exhaustive (no `..`) on purpose — the same drift alarm as the
+        // `From<ViewerConfigInitial>` impl above. `settings` is element-level
+        // state, stripped by `restore()` before resolution; discarded here.
+        let ViewerConfigUpdate {
+            version,
+            plugin,
+            title,
+            table,
+            theme,
+            settings: _settings,
+            plugin_config,
+            columns_config,
+            view_config,
+        } = value;
+
+        let OptionalUpdate::Update(table) = table else {
+            return Err(ApiError::new(CREATE_REQUIRES_TABLE));
+        };
+
+        Ok(Self {
+            table,
+            version: down(version),
+            plugin: down(plugin),
+            title: down(title),
+            theme: down(theme),
+            plugin_config: down(plugin_config),
+            columns_config: down(columns_config),
+            view_config,
+        })
+    }
+}
 
 impl std::fmt::Display for ViewerConfigUpdate {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -360,50 +398,6 @@ pub type VersionUpdate = OptionalUpdate<String>;
 pub type ColumnConfigUpdate = OptionalUpdate<ColumnConfigMap>;
 pub type PluginConfigUpdate = OptionalUpdate<serde_json::Map<String, Value>>;
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn initial_requires_a_table() {
-        let json = serde_json::json!({ "group_by": ["State"] });
-        let err = serde_json::from_value::<ViewerConfigInitial>(json).unwrap_err();
-        assert!(format!("{err}").contains("table"));
-    }
-
-    /// The creation → patch direction is the only one that exists (see the
-    /// note above the `From` impl); a `table` becomes a concrete update and
-    /// the element-level `settings` is not carried.
-    #[test]
-    fn initial_widens_to_an_update() {
-        let json = serde_json::json!({
-            "table": "superstore",
-            "plugin": "Datagrid",
-            "group_by": ["State"],
-        });
-
-        let initial: ViewerConfigInitial = serde_json::from_value(json).unwrap();
-        let update = ViewerConfigUpdate::from(initial);
-        assert!(matches!(&update.table, OptionalUpdate::Update(x) if x == "superstore"));
-        assert!(matches!(&update.settings, OptionalUpdate::Missing));
-        assert!(matches!(&update.plugin, OptionalUpdate::Update(x) if x == "Datagrid"));
-        assert_eq!(
-            update.view_config.group_by.as_deref(),
-            Some(&["State".to_owned()][..])
-        );
-    }
-
-    /// A table-less patch is a legitimate creation input now that
-    /// `create_panel` takes an update — the deferred panel a `load()`
-    /// binds. Nothing in this module may reject it.
-    #[test]
-    fn a_table_less_update_is_representable() {
-        let json = serde_json::json!({ "group_by": ["State"] });
-        let update: ViewerConfigUpdate = serde_json::from_value(json).unwrap();
-        assert!(matches!(&update.table, OptionalUpdate::Missing));
-    }
-}
-
 /// Handles `{}` when included as a field with `#[serde(default)]`.
 impl<T: Clone> Default for OptionalUpdate<T> {
     fn default() -> Self {

package/src/rust/config/workspace_config.rs

@@ -14,9 +14,9 @@ use std::collections::BTreeMap;
 
 use perspective_client::config::Filter;
 
-use crate::config::{PanelViewerConfig, ViewerConfigInitial};
+use crate::config::{CssKind, PanelViewerConfig, ViewerConfigInitial};
 
-/// The whole-element config format (`{version, active?, layout, panels}`) —
+/// The workspace config format (`{version, active?, layout, panels}`) —
 /// the multi-panel counterpart of the single-panel [`ViewerConfig`] — as
 /// emitted by [`PerspectiveViewerElement::save`].
 ///
@@ -56,9 +56,17 @@ pub struct WorkspaceConfig {
     #[ts(as = "Option<_>")]
     #[ts(optional)]
     pub masters: Vec<String>,
+
+    /// Named color-scale definitions shared by every panel: CSS custom
+    /// property name (`--psp-user--<kind>-<name>`) → canonical CSS
+    /// value.
+    #[serde(skip_serializing_if = "BTreeMap::is_empty")]
+    #[ts(as = "Option<_>")]
+    #[ts(optional)]
+    pub palette: BTreeMap<String, String>,
 }
 
-/// The parse target of a whole-element config in
+/// The parse target of a workspace config in
 /// [`PerspectiveViewerElement::restoreWorkspace`]. Mirrors
 /// [`WorkspaceConfig`], but `panels` entries are [`ViewerConfigInitial`]s —
 /// every entry creates a NEW panel, so `table` is required by type (a
@@ -79,15 +87,134 @@ pub struct WorkspaceConfigUpdate {
     /// The element-level global (master/detail cross-) filters to re-apply as
     /// a transient overlay on every DETAIL panel. Restored as one
     /// unattributed bucket: the next selection on any master replaces it.
+    /// `Option` so an explicit `undefined` property deserializes as
+    /// `None` like an absent key (also `masters` / `palette` below).
     #[serde(default)]
     #[ts(as = "Option<_>")]
     #[ts(optional)]
-    pub global_filters: Vec<Filter>,
+    pub global_filters: Option<Vec<Filter>>,
 
     /// The master (filter-source) panels, by saved `panels` key. An id not in
     /// `panels` warns and is dropped.
     #[serde(default)]
     #[ts(as = "Option<_>")]
     #[ts(optional)]
-    pub masters: Vec<String>,
+    pub masters: Option<Vec<String>>,
+
+    /// Named color-scale definitions to apply to the host (see
+    /// [`WorkspaceConfig::palette`]), replacing any previously restored
+    /// palette.
+    #[serde(default)]
+    #[ts(as = "Option<_>")]
+    #[ts(optional)]
+    pub palette: Option<BTreeMap<String, String>>,
+}
+
+/// Validate a restored palette map: each key's `--psp-user--<kind>-`
+/// prefix selects the reader that canonicalizes its value.
+pub fn validate_palette(
+    palette: BTreeMap<String, String>,
+) -> Result<BTreeMap<String, String>, String> {
+    palette
+        .into_iter()
+        .map(|(name, value)| {
+            let kind = CssKind::of_var(&name).ok_or_else(|| {
+                format!(
+                    "`palette` key `{name}` must start with `--psp-user--gradient-`, \
+                     `--psp-user--palette-` or `--psp-user--color-`"
+                )
+            })?;
+
+            let canonical = kind
+                .canonicalize(&value)
+                .map_err(|error| format!("`palette[\"{name}\"]`: {error}"))?;
+
+            Ok((name, canonical))
+        })
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_json::json;
+
+    use super::*;
+
+    #[test]
+    fn palette_serializes_only_when_present() {
+        let config = WorkspaceConfig {
+            version: "x".to_owned(),
+            active: None,
+            layout: None,
+            panels: BTreeMap::new(),
+            global_filters: vec![],
+            masters: vec![],
+            palette: BTreeMap::new(),
+        };
+
+        assert_eq!(
+            serde_json::to_value(&config).unwrap(),
+            json!({ "version": "x", "layout": null, "panels": {} })
+        );
+
+        let mut palette = BTreeMap::new();
+        palette.insert("--psp-user--color-hot".to_owned(), "#ff0000".to_owned());
+
+        let config = WorkspaceConfig { palette, ..config };
+        assert_eq!(
+            serde_json::to_value(&config).unwrap(),
+            json!({
+                "version": "x",
+                "layout": null,
+                "panels": {},
+                "palette": { "--psp-user--color-hot": "#ff0000" },
+            })
+        );
+    }
+
+    #[test]
+    fn update_palette_defaults_empty_and_validates_by_prefix() {
+        let update: WorkspaceConfigUpdate =
+            serde_json::from_value(json!({ "panels": {} })).unwrap();
+        assert!(update.palette.is_none());
+
+        let update: WorkspaceConfigUpdate = serde_json::from_value(json!({
+            "panels": {},
+            "palette": {
+                "--psp-user--gradient-1": "linear-gradient(#000, #fff)",
+                "--psp-user--palette-warm": "linear-gradient(90deg, RGB(255,0,0), #ff0)",
+                "--psp-user--color-hot": "#F00",
+            },
+        }))
+        .unwrap();
+
+        let valid = validate_palette(update.palette.unwrap()).unwrap();
+        assert_eq!(
+            valid.get("--psp-user--gradient-1").unwrap(),
+            "linear-gradient(to right, #000000 0%, #ffffff 100%)"
+        );
+        assert_eq!(
+            valid.get("--psp-user--palette-warm").unwrap(),
+            "linear-gradient(to right, #ff0000, #ffff00)"
+        );
+        assert_eq!(valid.get("--psp-user--color-hot").unwrap(), "#ff0000");
+
+        let bad = |name: &str, value: &str| {
+            let mut map = BTreeMap::new();
+            map.insert(name.to_owned(), value.to_owned());
+            validate_palette(map).unwrap_err()
+        };
+
+        assert!(bad("--psp-user--other-1", "#ff0000").contains("--psp-user--other-1"));
+        assert!(bad("--psp-charts--gradient", "#ff0000").contains("must start with"));
+        assert!(
+            bad(
+                "--psp-user--palette-1",
+                "linear-gradient(#000 0%, #fff 100%)"
+            )
+            .contains("--psp-user--palette-1")
+        );
+        assert!(bad("--psp-user--gradient-1", "#ff0000").contains("linear-gradient"));
+        assert!(bad("--psp-user--color-1", "red").contains("red"));
+    }
 }