@perspective-dev/viewer 5.1.0 → 5.3.0

package/src/rust/queries/get_viewer_config.rs

@@ -54,7 +54,8 @@ pub async fn get_viewer_config(
     let table = session
         .get_table()
         .map(|x| x.get_name().to_owned())
-        .or_else(|| session.pending_table());
+        .or_else(|| session.pending_table())
+        .ok_or_else(|| ApiError::from("Panel has no `table`"))?;
     let columns_config = renderer.all_columns_configs();
     Ok(ViewerConfig {
         settings,

package/src/rust/queries/mod.rs

@@ -29,6 +29,7 @@ mod exports;
 mod fetch_column_stats;
 mod get_viewer_config;
 mod is_invalid_drop;
+mod palette_set;
 mod plugin_column_styles;
 mod validate_expression;
 
@@ -40,5 +41,6 @@ pub use self::exports::*;
 pub use self::fetch_column_stats::*;
 pub use self::get_viewer_config::*;
 pub use self::is_invalid_drop::*;
+pub use self::palette_set::*;
 pub use self::plugin_column_styles::*;
 pub use self::validate_expression::*;

package/src/rust/queries/palette_set.rs

@@ -0,0 +1,82 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+// ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+// ┃ This file is part of the Perspective library, distributed under the terms ┃
+// ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+use std::collections::BTreeMap;
+
+use crate::config::{CssKind, CssLiteralUse, NamedValue, assign_palette_names};
+use crate::presentation::Presentation;
+use crate::workspace::{PanelId, Workspace};
+
+/// Every CSS literal in use across the workspace, as `(panel id, use)`,
+/// in a deterministic order.
+pub fn styles_in_use(workspace: &Workspace) -> Vec<(PanelId, CssLiteralUse)> {
+    let mut ids = workspace.panel_ids();
+    ids.sort_by(|a, b| a.as_str().cmp(b.as_str()));
+    let mut out = vec![];
+    for id in ids {
+        let Some(panel) = workspace.panel(&id) else {
+            continue;
+        };
+
+        let uses = {
+            let view_config = panel.session.get_view_config();
+            panel
+                .renderer
+                .css_literals_in_use(&view_config, &panel.session)
+        };
+
+        out.extend(uses.into_iter().map(|x| (id.clone(), x)));
+    }
+
+    out
+}
+
+/// The workspace palette set: the restored palette ∪ every literal in
+/// use, named stably (see [`crate::config::assign_palette_names`]).
+pub fn palette_set(workspace: &Workspace, presentation: &Presentation) -> BTreeMap<String, String> {
+    let host: Vec<NamedValue> = CssKind::ALL
+        .into_iter()
+        .flat_map(|kind| presentation.host_named_values(kind))
+        .collect();
+
+    let in_use: Vec<(CssKind, String)> = styles_in_use(workspace)
+        .into_iter()
+        .map(|(_, x)| (x.kind, x.literal))
+        .collect();
+
+    assign_palette_names(&presentation.palette(), &host, &in_use, &|name| {
+        presentation.resolve_css_var(name).is_some()
+    })
+}
+
+/// The named values of `kind` a picker offers: the palette set's
+/// entries, then any theme/page-authored host entries not already in
+/// the set by name.
+pub fn named_values(
+    workspace: &Workspace,
+    presentation: &Presentation,
+    kind: CssKind,
+) -> Vec<NamedValue> {
+    let mut out: Vec<NamedValue> = palette_set(workspace, presentation)
+        .into_iter()
+        .filter(|(name, _)| name.starts_with(kind.var_prefix()))
+        .map(|(name, value)| NamedValue { name, value })
+        .collect();
+
+    for entry in presentation.host_named_values(kind) {
+        if !out.iter().any(|x| x.name == entry.name) {
+            out.push(entry);
+        }
+    }
+
+    out
+}

package/src/rust/queries/plugin_column_styles.rs

@@ -41,7 +41,9 @@ pub fn get_plugin_config_schema(
     let view_config_js =
         wasm_bindgen::JsValue::from_serde_ext(view_config).unwrap_or(wasm_bindgen::JsValue::NULL);
     let raw = plugin._plugin_config_schema(&view_config_js)?;
-    serde_wasm_bindgen::from_value(raw).map_err(|e| e.into())
+    serde_wasm_bindgen::from_value::<ColumnConfigSchema>(raw)
+        .map(|schema| schema.canonicalize_defaults())
+        .map_err(|e| e.into())
 }
 
 /// Queries the active plugin for the per-column [`ColumnConfigSchema`].
@@ -97,5 +99,7 @@ pub fn get_column_config_schema(
         &stats_js,
     )?;
 
-    serde_wasm_bindgen::from_value(raw).map_err(|e| e.into())
+    serde_wasm_bindgen::from_value::<ColumnConfigSchema>(raw)
+        .map(|schema| schema.canonicalize_defaults())
+        .map_err(|e| e.into())
 }

package/src/rust/renderer/dispatch.rs

@@ -49,7 +49,7 @@ impl Renderer {
         let active_plugin = self.active_plugin();
         if let Some(plugin) = plugin.or(active_plugin.as_ref()) {
             let theme_elem = plugin.unchecked_ref::<HtmlElement>();
-            match self.effective_theme() {
+            match self.theme() {
                 Some(theme)
                     if theme_elem.get_attribute("theme").as_deref() != Some(theme.as_str()) =>
                 {
@@ -73,7 +73,7 @@ impl Renderer {
             let _pin = self.pin_context(&guard, ctx.clone());
             let plugin = self.ensure_plugin_selected()?;
             let meta = self.metadata();
-            let stamped_theme = self.effective_theme();
+            let stamped_theme = self.theme();
             self.stamp_theme(Some(&plugin));
             self.stamp_active(&plugin);
             plugin.restyle();
@@ -134,7 +134,19 @@ impl Renderer {
 
     pub async fn resize(&self) -> ApiResult<()> {
         self.0.geometry_cmd.set(Some(GeometryCmd::Measure));
-        self.geometry_task().await.map(|_| ())
+
+        // This caller queued a `Measure`, but the parked run it resolves
+        // through executes the LATEST `geometry_cmd` — which a concurrent
+        // presize sweep may have swapped to a `Presize` whose sweep
+        // coalesced (and so received `None`). Any present closure returned
+        // here is therefore held by no one else: invoke it, or the
+        // transport's present-hold leaks and the plot freezes on its
+        // last-blitted frame.
+        if let Some(present) = self.geometry_task().await? {
+            present.call0(&JsValue::NULL)?;
+        }
+
+        Ok(())
     }
 
     /// Public one-shot resize to explicit dimensions (`viewer.resize({
@@ -416,7 +428,7 @@ impl Renderer {
         let viewer_elem = self.0.borrow().viewer_elem.clone();
         let slot = self.slot_name();
         let first_paint = !self.0.has_drawn.get();
-        let stamped_theme = self.effective_theme();
+        let stamped_theme = self.theme();
         self.stamp_active(&plugin);
         self.stamp_theme(Some(&plugin));
         if self.needs_restyle() {

package/src/rust/renderer/plugin_config.rs

@@ -18,7 +18,7 @@ use std::collections::HashMap;
 
 use futures::future::join_all;
 use perspective_client::config::ViewConfig;
-use perspective_js::utils::{ApiResult, JsValueSerdeExt};
+use perspective_js::utils::{ApiError, ApiResult, JsValueSerdeExt};
 use serde_json::Value;
 use wasm_bindgen::prelude::*;
 
@@ -63,6 +63,50 @@ impl Renderer {
             .unwrap_or_default()
     }
 
+    fn resolve_css_refs_in(&self, column: &str, entry: &mut serde_json::Map<String, Value>) {
+        let host = self.borrow().viewer_elem.clone();
+        let lookup = |name: &str| crate::utils::read_custom_property(&host, name);
+        for (key, name) in resolve_css_refs(entry, &lookup) {
+            tracing::warn!(
+                "Dropping `columns_config[\"{column}\"].{key}`: `var({name})` is undefined or not \
+                 a valid value of its kind"
+            );
+        }
+    }
+
+    /// Every CSS literal stored in the active plugin's per-column bucket
+    /// with its schema kind, sorted by `(column, key)`.
+    pub fn css_literals_in_use(
+        &self,
+        view_config: &ViewConfig,
+        session: &Session,
+    ) -> Vec<CssLiteralUse> {
+        let mut out = vec![];
+        for (column, entry) in self.all_columns_configs() {
+            let Ok(schema) =
+                self.query_column_config_schema(view_config, session, &column, Some(&entry))
+            else {
+                continue;
+            };
+
+            for (key, value) in &entry {
+                if let (Some(kind), Some(literal)) = (schema.css_kind_of(key), value.as_str())
+                    && parse_var_ref(literal).is_none()
+                {
+                    out.push(CssLiteralUse {
+                        column: column.clone(),
+                        key: key.clone(),
+                        kind,
+                        literal: literal.to_owned(),
+                    });
+                }
+            }
+        }
+
+        out.sort_by(|a, b| (&a.column, &a.key).cmp(&(&b.column, &b.key)));
+        out
+    }
+
     /// Restore-prep snapshot: like [`Self::all_columns_configs`], but
     /// for each column also materializes any `ControlSpec::Number`
     /// fields the schema declares with `include: true` that aren't
@@ -173,15 +217,15 @@ impl Renderer {
             .cloned()
     }
 
-    /// Wholesale update the active plugin's per-column config map
+    /// Wholesale update the active plugin's per-column config map.
     pub fn update_columns_configs(
         &self,
         view_config: &ViewConfig,
         session: &Session,
         update: ColumnConfigUpdate,
-    ) -> bool {
+    ) -> ApiResult<bool> {
         let Some(n) = self.active_plugin_name() else {
-            return false;
+            return Ok(false);
         };
 
         match update {
@@ -190,24 +234,31 @@ impl Renderer {
                 let bucket = st.plugin_states.entry(n).or_default();
                 let was_nonempty = !bucket.columns.is_empty();
                 bucket.columns.clear();
-                was_nonempty
+                Ok(was_nonempty)
             },
-            OptionalUpdate::Missing => false,
+            OptionalUpdate::Missing => Ok(false),
             OptionalUpdate::Update(map) => {
-                let stripped: Vec<(String, serde_json::Map<String, serde_json::Value>)> = map
-                    .into_iter()
-                    .map(|(col, mut cfg)| {
-                        if let Ok(schema) =
-                            self.query_column_config_schema(view_config, session, &col, Some(&cfg))
-                        {
-                            let active = schema.active_keys();
-                            cfg.retain(|k, _| active.contains(k));
-                            strip_default_values(&schema, &mut cfg);
+                let mut stripped: Vec<(String, serde_json::Map<String, serde_json::Value>)> =
+                    Vec::with_capacity(map.len());
+                for (col, mut cfg) in map {
+                    if let Ok(schema) =
+                        self.query_column_config_schema(view_config, session, &col, Some(&cfg))
+                    {
+                        let active = schema.active_keys();
+                        cfg.retain(|k, _| active.contains(k));
+                        let errors = normalize_css_values(&schema, &mut cfg);
+                        if let Some((key, error)) = errors.first() {
+                            return Err(ApiError::from(JsValue::from_str(&format!(
+                                "Invalid `columns_config[\"{col}\"].{key}`: {error}"
+                            ))));
                         }
 
-                        (col, cfg)
-                    })
-                    .collect();
+                        self.resolve_css_refs_in(&col, &mut cfg);
+                        strip_default_values(&schema, &mut cfg);
+                    }
+
+                    stripped.push((col, cfg));
+                }
 
                 let mut st = self.borrow_mut();
                 let bucket = st.plugin_states.entry(n).or_default();
@@ -226,7 +277,7 @@ impl Renderer {
                     }
                 }
 
-                changed
+                Ok(changed)
             },
         }
     }
@@ -253,22 +304,45 @@ impl Renderer {
             &column_name,
             current_value.as_ref(),
         ) {
+            for (key, error) in normalize_css_values(&schema, &mut update.value) {
+                tracing::error!("Dropping `{column_name}`.`{key}`: {error}");
+            }
+
+            self.resolve_css_refs_in(&column_name, &mut update.value);
             strip_default_values(&schema, &mut update.value);
         }
 
+        let next = {
+            let mut st = self.borrow_mut();
+            let bucket = st.plugin_states.entry(n.clone()).or_default();
+            let entry = bucket.columns.entry(column_name.clone()).or_default();
+            for k in &update.keys {
+                entry.remove(k);
+            }
+            for (k, v) in update.value {
+                if update.keys.contains(&k) {
+                    entry.insert(k, v);
+                }
+            }
+
+            entry.clone()
+        };
+
+        let active = self
+            .query_column_config_schema(view_config, session, &column_name, Some(&next))
+            .ok()
+            .map(|schema| schema.active_keys());
+
         let mut st = self.borrow_mut();
         let bucket = st.plugin_states.entry(n).or_default();
-        let entry = bucket.columns.entry(column_name.clone()).or_default();
-        for k in &update.keys {
-            entry.remove(k);
-        }
-        for (k, v) in update.value {
-            if update.keys.contains(&k) {
-                entry.insert(k, v);
+        if let Some(entry) = bucket.columns.get_mut(&column_name) {
+            if let Some(active) = &active {
+                entry.retain(|k, _| active.contains(k));
+            }
+
+            if entry.is_empty() {
+                bucket.columns.remove(&column_name);
             }
-        }
-        if entry.is_empty() {
-            bucket.columns.remove(&column_name);
         }
     }
 
@@ -305,7 +379,9 @@ impl Renderer {
         let plugin = self.ensure_plugin_selected()?;
         let view_config_js = JsValue::from_serde_ext(view_config).unwrap_or(JsValue::NULL);
         let raw = plugin._plugin_config_schema(&view_config_js)?;
-        serde_wasm_bindgen::from_value(raw).map_err(|e| e.into())
+        serde_wasm_bindgen::from_value::<ColumnConfigSchema>(raw)
+            .map(|schema| schema.canonicalize_defaults())
+            .map_err(|e| e.into())
     }
 
     /// Per-column counterpart of [`query_plugin_config_schema`]. Used by
@@ -352,7 +428,9 @@ impl Renderer {
             &stats_js,
         )?;
 
-        serde_wasm_bindgen::from_value(raw).map_err(|e| e.into())
+        serde_wasm_bindgen::from_value::<ColumnConfigSchema>(raw)
+            .map(|schema| schema.canonicalize_defaults())
+            .map_err(|e| e.into())
     }
 
     /// Wholesale update the active plugin's plugin-level config map.
@@ -365,9 +443,9 @@ impl Renderer {
         &self,
         view_config: &ViewConfig,
         update: PluginConfigUpdate,
-    ) -> bool {
+    ) -> ApiResult<bool> {
         let Some(n) = self.active_plugin_name() else {
-            return false;
+            return Ok(false);
         };
 
         let schema = self.query_plugin_config_schema(view_config).ok();
@@ -377,14 +455,21 @@ impl Renderer {
             OptionalUpdate::SetDefault => {
                 let changed = !bucket.plugin.is_empty();
                 bucket.plugin.clear();
-                changed
+                Ok(changed)
             },
-            OptionalUpdate::Missing => false,
+            OptionalUpdate::Missing => Ok(false),
             OptionalUpdate::Update(mut map) => {
                 let mut changed = false;
                 if let Some(s) = &schema {
                     let active = s.active_keys();
                     map.retain(|k, _| active.contains(k));
+                    let errors = normalize_css_values(s, &mut map);
+                    if let Some((key, error)) = errors.first() {
+                        return Err(ApiError::from(JsValue::from_str(&format!(
+                            "Invalid `plugin_config.{key}`: {error}"
+                        ))));
+                    }
+
                     map.retain(|key, value| {
                         let is_default = s
                             .fields
@@ -408,7 +493,7 @@ impl Renderer {
                     }
                 }
 
-                changed
+                Ok(changed)
             },
         }
     }
@@ -424,6 +509,10 @@ impl Renderer {
         };
 
         if let Ok(schema) = self.query_plugin_config_schema(view_config) {
+            for (key, error) in normalize_css_values(&schema, &mut update.value) {
+                tracing::error!("Dropping `plugin_config`.`{key}`: {error}");
+            }
+
             strip_default_values(&schema, &mut update.value);
         }
 
@@ -446,6 +535,34 @@ impl Renderer {
     }
 }
 
+fn normalize_css_values(
+    schema: &ColumnConfigSchema,
+    map: &mut serde_json::Map<String, serde_json::Value>,
+) -> Vec<(String, String)> {
+    let mut errors = vec![];
+    for (key, value) in map.iter_mut() {
+        let Some(kind) = schema.css_kind_of(key) else {
+            continue;
+        };
+
+        let canonical = match value.as_str() {
+            Some(src) => kind.canonicalize(src),
+            None => Err(format!("expected a CSS string, got `{value}`")),
+        };
+
+        match canonical {
+            Ok(canonical) => *value = Value::String(canonical),
+            Err(error) => errors.push((key.clone(), error)),
+        }
+    }
+
+    for (key, _) in &errors {
+        map.remove(key);
+    }
+
+    errors
+}
+
 fn strip_default_values(
     schema: &ColumnConfigSchema,
     map: &mut serde_json::Map<String, serde_json::Value>,
@@ -479,17 +596,162 @@ fn matches_declared_default(spec: &ControlSpec, key: &str, value: &Value) -> boo
         } if k == key => value.as_str() == Some(default.as_str()),
         ControlSpec::Color {
             key: k, default, ..
-        } if k == key => value.as_str() == Some(default.as_str()),
-        ControlSpec::ColorRange {
-            key_pos,
-            default_pos,
-            ..
-        } if key_pos == key => value.as_str() == Some(default_pos.as_str()),
-        ControlSpec::ColorRange {
-            key_neg,
-            default_neg,
-            ..
-        } if key_neg == key => value.as_str() == Some(default_neg.as_str()),
+        } if k == key => css_matches(CssKind::Color, value, default),
+        ControlSpec::Palette {
+            key: k, default, ..
+        } if k == key => css_matches(CssKind::Palette, value, default),
+        ControlSpec::GradientStops {
+            key: k, default, ..
+        } if k == key => css_matches(CssKind::Gradient, value, default),
         _ => false,
     }
 }
+
+fn css_matches(kind: CssKind, value: &Value, default: &str) -> bool {
+    value
+        .as_str()
+        .and_then(|src| kind.canonicalize(src).ok())
+        .is_some_and(|canonical| canonical == default)
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_json::json;
+
+    use super::*;
+
+    #[test]
+    fn palette_default_matches_canonically() {
+        let spec = ControlSpec::Palette {
+            key: "palette".to_owned(),
+            default: "linear-gradient(to right, #0366d6, #ff7f0e)".to_owned(),
+            max: None,
+        };
+
+        assert!(matches_declared_default(
+            &spec,
+            "palette",
+            &json!("linear-gradient(to right, #0366d6, #ff7f0e)")
+        ));
+
+        assert!(matches_declared_default(
+            &spec,
+            "palette",
+            &json!("linear-gradient(90deg, RGB(3,102,214), #FF7F0E)")
+        ));
+
+        assert!(!matches_declared_default(
+            &spec,
+            "palette",
+            &json!("linear-gradient(to right, #ff7f0e, #0366d6)")
+        ));
+
+        assert!(!matches_declared_default(
+            &spec,
+            "palette",
+            &json!("var(--psp-user--palette-1)")
+        ));
+
+        assert!(!matches_declared_default(
+            &spec,
+            "palette",
+            &json!(["#0366d6"])
+        ));
+        assert!(!matches_declared_default(
+            &spec,
+            "other",
+            &json!("linear-gradient(to right, #0366d6, #ff7f0e)")
+        ));
+    }
+
+    #[test]
+    fn gradient_default_matches_canonical_values() {
+        let spec = ControlSpec::GradientStops {
+            key: "gradient".to_owned(),
+            default: "linear-gradient(to right, #0366d6 0%, #ff7f0e 33.3%)".to_owned(),
+            discrete: false,
+        };
+
+        assert!(matches_declared_default(
+            &spec,
+            "gradient",
+            &json!("linear-gradient(#0366d6, #ff7f0e 33.3%)")
+        ));
+
+        assert!(!matches_declared_default(
+            &spec,
+            "gradient",
+            &json!("linear-gradient(to right, #0366d6 0%, #ff7f0e 33.4%)")
+        ));
+
+        let color = ControlSpec::Color {
+            key: "color".to_owned(),
+            default: "#ff7f0e".to_owned(),
+        };
+
+        assert!(matches_declared_default(&color, "color", &json!("#FF7F0E")));
+        assert!(matches_declared_default(
+            &color,
+            "color",
+            &json!("rgb(255, 127, 14)")
+        ));
+        assert!(!matches_declared_default(
+            &color,
+            "color",
+            &json!("var(--psp-user--color-1)")
+        ));
+    }
+
+    #[test]
+    fn normalize_css_values_canonicalizes_and_reports() {
+        let schema = ColumnConfigSchema {
+            fields: vec![
+                ControlSpec::Color {
+                    key: "color".to_owned(),
+                    default: "#000000".to_owned(),
+                },
+                ControlSpec::Palette {
+                    key: "palette".to_owned(),
+                    default: "linear-gradient(to right, #000000)".to_owned(),
+                    max: None,
+                },
+                ControlSpec::GradientStops {
+                    key: "gradient".to_owned(),
+                    default: "linear-gradient(to right, #000000 0%, #ffffff 100%)".to_owned(),
+                    discrete: false,
+                },
+                ControlSpec::Bool {
+                    key: "flag".to_owned(),
+                    default: false,
+                },
+            ],
+        };
+
+        let mut map = json!({
+            "color": "RGB(255,0,0)",
+            "palette": "var(--psp-user--palette-warm)",
+            "gradient": [{ "color": "#000000", "offset": 0 }],
+            "flag": true,
+            "foreign": "linear-gradient(red, blue)",
+        })
+        .as_object()
+        .unwrap()
+        .clone();
+
+        let errors = normalize_css_values(&schema, &mut map);
+        assert_eq!(errors.len(), 1);
+        assert_eq!(errors[0].0, "gradient");
+        assert_eq!(
+            map,
+            json!({
+                "color": "#ff0000",
+                "palette": "var(--psp-user--palette-warm)",
+                "flag": true,
+                "foreign": "linear-gradient(red, blue)",
+            })
+            .as_object()
+            .unwrap()
+            .clone()
+        );
+    }
+}