@perspective-dev/viewer 5.4.0 → 5.5.1

package/src/rust/lib.rs

@@ -93,25 +93,29 @@ export type * from "../../src/ts/ts-rs/WorkspaceConfigUpdate.d.ts";
 export type * from "../../src/ts/ts-rs/ExportMethod.d.ts";
 export type * from "../../src/ts/ts-rs/PanelOptions.d.ts";
 export type * from "../../src/ts/ts-rs/RestoreOptions.d.ts";
+export type * from "../../src/ts/ts-rs/RestoreWorkspaceOptions.d.ts";
+export type * from "../../src/ts/ts-rs/AddPanelOptions.d.ts";
 export type * from "../../src/ts/ts-rs/SaveWorkspaceOptions.d.ts";
 export type * from "../../src/ts/ts-rs/ClientOptions.d.ts";
 export type * from "../../src/ts/ts-rs/ExportOptions.d.ts";
 export type * from "../../src/ts/ts-rs/GetTableOptions.d.ts";
 export type * from "../../src/ts/ts-rs/GetClientOptions.d.ts";
+export type * from "../../src/ts/ts-rs/GetViewOptions.d.ts";
+export type * from "../../src/ts/ts-rs/GetViewMode.d.ts";
 export type * from "../../src/ts/ts-rs/CustomNumberFormatConfig.d.ts";
 export type * from "../../src/ts/ts-rs/NumberFormatStyle.d.ts";
 export type * from "../../src/ts/ts-rs/Notation.d.ts";
 export type * from "../../src/ts/ts-rs/DatetimeFormatType.d.ts";
-export type * from "../../src/ts/ts-rs/StringColorMode.d.ts";
-export type * from "../../src/ts/ts-rs/DatetimeColorMode.d.ts";
-export type * from "../../src/ts/ts-rs/FormatMode.d.ts";
 
 import type {GetTableOptions} from "../../src/ts/ts-rs/GetTableOptions.d.ts";
 import type {PanelOptions} from "../../src/ts/ts-rs/PanelOptions.d.ts";
 import type {RestoreOptions} from "../../src/ts/ts-rs/RestoreOptions.d.ts";
+import type {RestoreWorkspaceOptions} from "../../src/ts/ts-rs/RestoreWorkspaceOptions.d.ts";
+import type {AddPanelOptions} from "../../src/ts/ts-rs/AddPanelOptions.d.ts";
 import type {SaveWorkspaceOptions} from "../../src/ts/ts-rs/SaveWorkspaceOptions.d.ts";
 import type {ExportOptions} from "../../src/ts/ts-rs/ExportOptions.d.ts";
 import type {GetClientOptions} from "../../src/ts/ts-rs/GetClientOptions.d.ts";
+import type {GetViewOptions} from "../../src/ts/ts-rs/GetViewOptions.d.ts";
 import type {ClientOptions} from "../../src/ts/ts-rs/ClientOptions.d.ts";
 import type {ViewerConfig} from "../../src/ts/ts-rs/ViewerConfig.d.ts";
 import type {ViewerConfigUpdate} from "../../src/ts/ts-rs/ViewerConfigUpdate.d.ts";

package/src/rust/queries/plugin_column_styles.rs

@@ -29,18 +29,19 @@ struct ColumnStats {
     abs_max: Option<f64>,
 }
 
-/// Queries the active plugin for its plugin-scoped
-/// [`ColumnConfigSchema`]. Mirrors [`get_column_config_schema`] but
-/// drops the column-specific args — the schema describes the shape
-/// of the plugin's own config bucket on the renderer.
+/// Queries the active plugin for its plugin-scoped [`ColumnConfigSchema`] as
+/// it applies to `current_value`.
 pub fn get_plugin_config_schema(
     renderer: &Renderer,
     view_config: &ViewConfig,
+    current_value: Option<&serde_json::Map<String, serde_json::Value>>,
 ) -> ApiResult<ColumnConfigSchema> {
     let plugin = renderer.ensure_plugin_selected()?;
     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)?;
+    let current_js = wasm_bindgen::JsValue::from_serde_ext(&current_value)
+        .unwrap_or(wasm_bindgen::JsValue::NULL);
+    let raw = plugin._plugin_config_schema(&view_config_js, &current_js)?;
     serde_wasm_bindgen::from_value::<ColumnConfigSchema>(raw)
         .map(|schema| schema.canonicalize())
         .map_err(|e| e.into())

package/src/rust/renderer/plugin_config.rs

@@ -247,10 +247,16 @@ impl Renderer {
                     {
                         let active = schema.active_keys();
                         cfg.retain(|k, _| active.contains(k));
-                        let errors = normalize_css_values(&schema, &mut cfg);
+                        let errors = normalize_values(&schema, &mut cfg);
                         if let Some((key, error)) = errors.first() {
+                            let ty = session
+                                .metadata()
+                                .get_column_view_type(&col)
+                                .map(|t| format!(" for a {t} column"))
+                                .unwrap_or_default();
+
                             return Err(ApiError::from(JsValue::from_str(&format!(
-                                "Invalid `columns_config[\"{col}\"].{key}`: {error}"
+                                "Invalid `columns_config[\"{col}\"].{key}`{ty}: {error}"
                             ))));
                         }
 
@@ -305,7 +311,7 @@ impl Renderer {
             &column_name,
             current_value.as_ref(),
         ) {
-            for (key, error) in normalize_css_values(&schema, &mut update.value) {
+            for (key, error) in normalize_values(&schema, &mut update.value) {
                 tracing::error!("Dropping `{column_name}`.`{key}`: {error}");
             }
 
@@ -329,16 +335,25 @@ impl Renderer {
             entry.clone()
         };
 
-        let active = self
+        // The schema AFTER the update decides which keys survive and, for a
+        // key whose control kind follows another key (`fg_color` reads as a
+        // color, gradient or palette depending on `fg_mode`), whether the
+        // value still parses under its new kind. A value that no longer
+        // does is dropped here, so `save()` never emits a config that
+        // `restore()` would reject.
+        let after = self
             .query_column_config_schema(view_config, session, &column_name, Some(&next))
-            .ok()
-            .map(|schema| schema.active_keys());
+            .ok();
 
         let mut st = self.borrow_mut();
         let bucket = st.plugin_states.entry(n).or_default();
         if let Some(entry) = bucket.columns.get_mut(&column_name) {
-            if let Some(active) = &active {
+            if let Some(schema) = &after {
+                let active = schema.active_keys();
                 entry.retain(|k, _| active.contains(k));
+                for (key, error) in normalize_values(schema, entry) {
+                    tracing::warn!("Dropping `{column_name}`.`{key}` after a mode change: {error}");
+                }
             }
 
             if entry.is_empty() {
@@ -371,15 +386,18 @@ impl Renderer {
         }
     }
 
-    /// Synchronously query the active plugin's
-    /// [`ColumnConfigSchema`] used to gate plugin-config strip logic.
+    /// Synchronously query the active plugin's [`ColumnConfigSchema`] as it
+    /// applies to `current_value`, the plugin-config state the schema should
+    /// describe.
     fn query_plugin_config_schema(
         &self,
         view_config: &ViewConfig,
+        current_value: Option<&serde_json::Map<String, serde_json::Value>>,
     ) -> ApiResult<ColumnConfigSchema> {
         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)?;
+        let current_js = JsValue::from_serde_ext(&current_value).unwrap_or(JsValue::NULL);
+        let raw = plugin._plugin_config_schema(&view_config_js, &current_js)?;
         serde_wasm_bindgen::from_value::<ColumnConfigSchema>(raw)
             .map(|schema| schema.canonicalize())
             .map_err(|e| e.into())
@@ -434,12 +452,9 @@ impl Renderer {
             .map_err(|e| e.into())
     }
 
-    /// Wholesale update the active plugin's plugin-level config map.
-    /// Entries whose value equals the schema-declared default are
-    /// treated as "reset this key" — the corresponding bucket entry
-    /// is cleared rather than the default being stored literally.
-    /// Keys absent from the incoming map are left alone (merge
-    /// semantics for the non-default subset).
+    /// Merge an update into the active plugin's plugin-level config map,
+    /// clearing entries equal to the schema default and dropping keys the
+    /// resulting schema no longer advertises.
     pub fn update_plugin_config(
         &self,
         view_config: &ViewConfig,
@@ -449,28 +464,42 @@ impl Renderer {
             return Ok(false);
         };
 
-        let schema = self.query_plugin_config_schema(view_config).ok();
-        let mut st = self.borrow_mut();
-        let bucket = st.plugin_states.entry(n).or_default();
         match update {
             OptionalUpdate::SetDefault => {
+                let mut st = self.borrow_mut();
+                let bucket = st.plugin_states.entry(n).or_default();
                 let changed = !bucket.plugin.is_empty();
                 bucket.plugin.clear();
                 Ok(changed)
             },
             OptionalUpdate::Missing => Ok(false),
             OptionalUpdate::Update(mut map) => {
-                let mut changed = false;
+                let mut merged = self.get_plugin_config();
+                for (k, v) in &map {
+                    merged.insert(k.clone(), v.clone());
+                }
+
+                let schema = self
+                    .query_plugin_config_schema(view_config, Some(&merged))
+                    .ok();
+
+                let mut active = None;
                 if let Some(s) = &schema {
-                    let active = s.active_keys();
-                    map.retain(|k, _| active.contains(k));
-                    let errors = normalize_css_values(s, &mut map);
+                    let keys = s.active_keys();
+                    map.retain(|k, _| keys.contains(k));
+                    active = Some(keys);
+                    let errors = normalize_values(s, &mut map);
                     if let Some((key, error)) = errors.first() {
                         return Err(ApiError::from(JsValue::from_str(&format!(
                             "Invalid `plugin_config.{key}`: {error}"
                         ))));
                     }
+                }
 
+                let mut st = self.borrow_mut();
+                let bucket = st.plugin_states.entry(n).or_default();
+                let mut changed = false;
+                if let Some(s) = &schema {
                     let leaves = s.leaf_fields();
                     map.retain(|key, value| {
                         let is_default = leaves
@@ -494,12 +523,19 @@ impl Renderer {
                     }
                 }
 
+                if let Some(active) = active {
+                    let before = bucket.plugin.len();
+                    bucket.plugin.retain(|k, _| active.contains(k));
+                    changed |= bucket.plugin.len() != before;
+                }
+
                 Ok(changed)
             },
         }
     }
 
-    /// Apply a single schema-field update from the plugin-settings UI
+    /// Apply a single schema-field update from the plugin-settings UI,
+    /// dropping keys the resulting schema no longer advertises.
     pub fn update_plugin_config_field(
         &self,
         view_config: &ViewConfig,
@@ -509,12 +545,28 @@ impl Renderer {
             return false;
         };
 
-        if let Ok(schema) = self.query_plugin_config_schema(view_config) {
-            for (key, error) in normalize_css_values(&schema, &mut update.value) {
+        let mut next = self.get_plugin_config();
+        for k in &update.keys {
+            match update.value.get(k) {
+                Some(v) => {
+                    next.insert(k.clone(), v.clone());
+                },
+                None => {
+                    next.remove(k);
+                },
+            }
+        }
+
+        let schema = self
+            .query_plugin_config_schema(view_config, Some(&next))
+            .ok();
+
+        if let Some(schema) = &schema {
+            for (key, error) in normalize_values(schema, &mut update.value) {
                 tracing::error!("Dropping `plugin_config`.`{key}`: {error}");
             }
 
-            strip_default_values(&schema, &mut update.value);
+            strip_default_values(schema, &mut update.value);
         }
 
         let mut st = self.borrow_mut();
@@ -532,28 +584,48 @@ impl Renderer {
             }
         }
 
+        if let Some(schema) = &schema {
+            let active = schema.active_keys();
+            let before = bucket.plugin.len();
+            bucket.plugin.retain(|k, _| active.contains(k));
+            changed |= bucket.plugin.len() != before;
+        }
+
         changed
     }
 }
 
-fn normalize_css_values(
+/// Canonicalize every CSS-valued key of `map` and check every `Enum`-valued
+/// key against its variants, removing and reporting the keys that fail.
+/// The schema is the one queried for `map`'s own values, so an `Enum`'s
+/// variants are exactly the values the column's type accepts.
+fn normalize_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}`")),
-        };
+        if let Some(kind) = schema.css_kind_of(key) {
+            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)),
+            match canonical {
+                Ok(canonical) => *value = Value::String(canonical),
+                Err(error) => errors.push((key.clone(), error)),
+            }
+        } else if let Some(variants) = schema.enum_variants_of(key) {
+            let accepted = variants.iter().any(|v| value.as_str() == Some(&v.value));
+            if !accepted {
+                let expected = variants
+                    .iter()
+                    .map(|v| format!("`{}`", v.value))
+                    .collect::<Vec<_>>()
+                    .join(", ");
+
+                errors.push((key.clone(), format!("{value} is not one of {expected}")));
+            }
         }
     }
 
@@ -580,6 +652,21 @@ fn matches_declared_default(spec: &ControlSpec, key: &str, value: &Value) -> boo
     match spec {
         ControlSpec::Enum {
             key: k, default, ..
+        }
+        | ControlSpec::Font {
+            key: k, default, ..
+        } if k == key => value.as_str() == Some(default.as_str()),
+        ControlSpec::Font {
+            size: Some(size), ..
+        } if size.key == key => value.as_f64() == Some(size.default),
+        ControlSpec::Font { bold, italic, .. } => [bold, italic]
+            .into_iter()
+            .flatten()
+            .any(|toggle| toggle.key == key && value.as_bool() == Some(toggle.default)),
+        ControlSpec::Alignment {
+            key: k,
+            default: Some(default),
+            ..
         } if k == key => value.as_str() == Some(default.as_str()),
         ControlSpec::Bool {
             key: k, default, ..
@@ -703,6 +790,35 @@ mod tests {
         ));
     }
 
+    #[test]
+    fn alignment_strips_only_a_declared_default() {
+        let schema = ColumnConfigSchema {
+            fields: vec![
+                ControlSpec::Alignment {
+                    key: "align".to_owned(),
+                    default: None,
+                    corners: false,
+                },
+                ControlSpec::Alignment {
+                    key: "legend_anchor".to_owned(),
+                    default: Some(Alignment::TopRight),
+                    corners: true,
+                },
+            ],
+        };
+
+        let mut map = json!({ "align": "center", "legend_anchor": "top-right" })
+            .as_object()
+            .unwrap()
+            .clone();
+
+        strip_default_values(&schema, &mut map);
+        assert_eq!(
+            map,
+            json!({ "align": "center" }).as_object().unwrap().clone()
+        );
+    }
+
     #[test]
     fn strip_default_values_sees_through_groups() {
         let leaves = vec![
@@ -751,7 +867,50 @@ mod tests {
     }
 
     #[test]
-    fn normalize_css_values_canonicalizes_and_reports() {
+    fn normalize_values_rejects_enum_values_outside_the_variants() {
+        let schema = ColumnConfigSchema {
+            fields: vec![ControlSpec::Group {
+                key: "color".to_owned(),
+                fields: vec![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 mut map = json!({ "fg_mode": "color", "other": "series" })
+            .as_object()
+            .unwrap()
+            .clone();
+
+        assert!(normalize_values(&schema, &mut map).is_empty());
+        assert_eq!(map.len(), 2);
+
+        let mut map = json!({ "fg_mode": "series" }).as_object().unwrap().clone();
+        let errors = normalize_values(&schema, &mut map);
+        assert_eq!(errors.len(), 1);
+        assert_eq!(errors[0].0, "fg_mode");
+        assert_eq!(errors[0].1, "\"series\" is not one of `disabled`, `color`");
+        assert!(map.is_empty());
+
+        let mut map = json!({ "fg_mode": 3 }).as_object().unwrap().clone();
+        let errors = normalize_values(&schema, &mut map);
+        assert_eq!(errors.len(), 1);
+        assert!(map.is_empty());
+    }
+
+    #[test]
+    fn normalize_values_canonicalizes_and_reports() {
         let schema = ColumnConfigSchema {
             fields: vec![
                 ControlSpec::Color {
@@ -786,7 +945,7 @@ mod tests {
         .unwrap()
         .clone();
 
-        let errors = normalize_css_values(&schema, &mut map);
+        let errors = normalize_values(&schema, &mut map);
         assert_eq!(errors.len(), 1);
         assert_eq!(errors[0].0, "gradient");
         assert_eq!(

package/src/rust/renderer/plugin_store.rs

@@ -26,7 +26,8 @@ pub struct PluginStore {
 
 impl PluginStore {
     fn init_lazy(&mut self) {
-        self.plugins = Some(PLUGIN_REGISTRY.create_plugins());
+        let plugins = PLUGIN_REGISTRY.create_plugins();
+        self.plugins = Some(plugins);
         self.plugin_configs = Some(PLUGIN_REGISTRY.plugin_configs());
         self.plugin_records = Some(PLUGIN_REGISTRY.available_plugin_names_by_category());
     }

package/src/rust/renderer/props.rs

@@ -14,6 +14,7 @@ use std::rc::Rc;
 
 use crate::config::PluginStaticConfig;
 use crate::renderer::limits::RenderLimits;
+use crate::renderer::plugin_config::ColumnConfigMap;
 use crate::utils::PtrEqRc;
 
 /// Value-semantic snapshot of the renderer state read by components.
@@ -50,6 +51,10 @@ pub struct RendererProps {
     /// the interior-mutable handle, no manual PubSub subscription, no
     /// race window between `plugins_idx` swap and the schema query.
     pub plugin_config: PtrEqRc<serde_json::Map<String, serde_json::Value>>,
+
+    /// Snapshot of the active plugin's `columns_config` bucket, re-read by
+    /// `Renderer::to_props` on `columns_config_changed` and `plugin_changed`.
+    pub columns_config: PtrEqRc<ColumnConfigMap>,
 }
 
 impl RendererProps {

package/src/rust/renderer.rs

@@ -112,6 +112,11 @@ pub struct RendererData {
     /// plugin's bucket.
     pub plugin_config_changed: PubSub<serde_json::Map<String, serde_json::Value>>,
 
+    /// Fires after the active plugin's per-column bucket changes by any path
+    /// (edit, restore or reset), unlike `column_style_changed` which covers
+    /// edits only.
+    pub columns_config_changed: PubSub<ColumnConfigMap>,
+
     /// `true` while the active plugin's "rendering N of M" warning is
     /// dismissable.
     pub render_warning: Cell<bool>,
@@ -263,6 +268,7 @@ impl Renderer {
             selection_changed: Default::default(),
             column_style_changed: Default::default(),
             plugin_config_changed: Default::default(),
+            columns_config_changed: Default::default(),
             render_warning: Cell::new(true),
             presize_pending: Cell::new(0),
             presized_box: Cell::new(None),
@@ -695,6 +701,7 @@ impl Renderer {
                 .into();
 
             let plugin_config = PtrEqRc::new(self.get_plugin_config());
+            let columns_config = PtrEqRc::new(self.all_columns_configs());
             RendererProps {
                 plugin_name,
                 config,
@@ -702,6 +709,7 @@ impl Renderer {
                 available_plugins,
                 is_chart,
                 plugin_config,
+                columns_config,
             }
         } else {
             RendererProps {
@@ -711,6 +719,7 @@ impl Renderer {
                 available_plugins: PtrEqRc::new(vec![]),
                 is_chart: false,
                 plugin_config: PtrEqRc::default(),
+                columns_config: PtrEqRc::default(),
             }
         }
     }

package/src/rust/session/metadata.rs

@@ -92,7 +92,7 @@ impl SessionMetadata {
         &mut self,
         view_schema: &HashMap<String, ColumnType>,
     ) -> ApiResult<()> {
-        self.as_mut().unwrap().view_schema = Some(view_schema.clone());
+        self.as_mut().ok_or("No `Table` set")?.view_schema = Some(view_schema.clone());
         Ok(())
     }
 
@@ -115,7 +115,7 @@ impl SessionMetadata {
                 Some((name.clone(), dtype))
             })
             .collect();
-        self.as_mut().unwrap().window_schema = window_schema;
+        self.as_mut().ok_or("No `Table` set")?.window_schema = window_schema;
         Ok(())
     }
 
@@ -151,16 +151,11 @@ impl SessionMetadata {
             )));
         }
 
-        let mut edited = self
-            .as_mut()
-            .unwrap()
-            .expr_meta
-            .take()
-            .map(|x| x.edited)
-            .unwrap_or_default();
+        let state = self.as_mut().ok_or("No `Table` set")?;
+        let mut edited = state.expr_meta.take().map(|x| x.edited).unwrap_or_default();
 
         edited.retain(|k, _| valid_recs.expression_alias.contains_key(k));
-        self.as_mut().unwrap().expr_meta = Some(SessionViewExpressionMetadata {
+        state.expr_meta = Some(SessionViewExpressionMetadata {
             expressions: valid_recs.clone(),
             edited,
         });

package/src/rust/session/props.rs

@@ -22,11 +22,15 @@ use crate::session::replace_expression_update::ViewConfigExt as ReplaceExprExt;
 use crate::session::{ColumnStats, TableErrorState};
 use crate::utils::*;
 
+/// The panel's table binding as the status indicator and chrome see it:
+/// bound, a `load()` in flight, or a named table awaiting its host (see
+/// `Session::pending_table`).
 #[derive(Clone, Debug, PartialEq, Default)]
 pub enum TableLoadState {
     #[default]
     Loaded,
     Loading,
+    Pending,
 }
 
 /// Value-semantic snapshot of the session state read by the root component.