@perspective-dev/viewer 4.4.0 → 4.5.0

package/src/rust/config/column_config_schema.rs

@@ -0,0 +1,195 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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::HashSet;
+
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+use super::{KeyValueOpts, NumberSeriesStyleDefaultConfig};
+
+/// 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
+/// stored value (e.g. to hide dependent fields), so this is re-queried on
+/// every field update.
+///
+/// Each entry is a [`ControlSpec`]. Primitive variants carry their own
+/// `key` (JSON storage key) inline; the sidebar UI label is supplied by
+/// CSS via `--psp-label--<key>--content`. Composite variants render a
+/// self-contained Yew component that supplies its own labels and owns a
+/// fixed key namespace via [`ControlSpec::serialized_keys`].
+#[derive(Clone, Debug, Default, Deserialize, Serialize)]
+pub struct ColumnConfigSchema {
+    pub fields: Vec<ControlSpec>,
+}
+
+impl ColumnConfigSchema {
+    /// Union of every JSON key any control in this schema knows how to
+    /// read or write. Used to build the schema-filtered view of
+    /// `columns_config` passed to `plugin.restore()` — keys not in this
+    /// set are "ghost" state from a different plugin and stay invisible
+    /// to the active one.
+    pub fn active_keys(&self) -> HashSet<String> {
+        let mut out = HashSet::new();
+        for spec in &self.fields {
+            for k in spec.serialized_keys() {
+                out.insert(k.to_string());
+            }
+        }
+        out
+    }
+}
+
+/// Discriminated union of widget kinds the viewer can render. Composite
+/// variants wrap an existing rich Yew component and carry only the
+/// component's `*DefaultConfig`. Primitive variants render generic scalar
+/// widgets and carry their own `key` inline; the visible label is
+/// resolved at CSS time via `--psp-label--<key>--content`.
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(tag = "kind")]
+pub enum ControlSpec {
+    Enum {
+        key: String,
+        variants: Vec<EnumVariant>,
+        default: String,
+    },
+    Bool {
+        key: String,
+        default: bool,
+    },
+    Number {
+        key: String,
+        default: f64,
+
+        /// If `true`, always serialize this values even if it is the default.
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        include: Option<bool>,
+
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        min: Option<f64>,
+
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        max: Option<f64>,
+
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        step: Option<f64>,
+    },
+    String {
+        key: String,
+        default: String,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        placeholder: Option<String>,
+    },
+    Color {
+        key: String,
+        default: String,
+    },
+    /// Paired pos/neg color picker rendered as a single horizontal
+    /// gradient/range bar. Used to expose the existing
+    /// [`crate::components::form::color_range_selector::ColorRangeSelector`]
+    /// widget at primitive granularity. Owns two top-level keys
+    /// (`key_pos` + `key_neg`); the visible label is derived from
+    /// `key_pos`.
+    ColorRange {
+        key_pos: String,
+        key_neg: String,
+        default_pos: String,
+        default_neg: String,
+        /// When `true`, the bar renders as a continuous gradient
+        /// (e.g. for `gradient` color modes); when `false`, the bar
+        /// renders as a hard pos/neg split. Currently only changes the
+        /// visual; pos/neg semantics are unchanged.
+        #[serde(default)]
+        is_gradient: bool,
+    },
+
+    /// Residual format-only widget for datetime columns — owns
+    /// `date_format` only. Pair with primitive `Enum` and `Color` fields
+    /// for `datetime_color_mode` + `color` to fully decompose datetime
+    /// styling.
+    DatetimeFormat,
+    /// Residual format-only widget for string columns — owns `format`
+    /// only. Pair with primitive `Enum` and `Color` fields for
+    /// `string_color_mode` + `color` to fully decompose string styling.
+    StringFormat,
+    NumberSeriesStyle {
+        default: NumberSeriesStyleDefaultConfig,
+    },
+    Symbols {
+        default: KeyValueOpts,
+    },
+    NumberFormat,
+    AggregateDepth,
+}
+
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
+pub struct EnumVariant {
+    pub value: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub label: Option<String>,
+}
+
+impl ControlSpec {
+    /// Top-level JSON keys this control owns when its value is serialized
+    /// into a column's config map. For primitives this is just `[key]`;
+    /// for composites it's the set of fields the wrapped sub-struct
+    /// flattens. Used by [`ColumnConfigSchema::active_keys`] to filter the
+    /// `columns_config` blob passed to `plugin.restore()`.
+    pub fn serialized_keys(&self) -> Vec<&str> {
+        match self {
+            ControlSpec::DatetimeFormat => vec!["date_format"],
+            ControlSpec::StringFormat => vec!["format"],
+            ControlSpec::NumberSeriesStyle { .. } => vec!["chart_type", "stack"],
+            ControlSpec::Symbols { .. } => vec!["symbols"],
+            ControlSpec::NumberFormat => vec!["number_format"],
+            ControlSpec::AggregateDepth => vec!["aggregate_depth"],
+            ControlSpec::ColorRange {
+                key_pos, key_neg, ..
+            } => vec![key_pos.as_str(), key_neg.as_str()],
+            ControlSpec::Enum { key, .. }
+            | ControlSpec::Bool { key, .. }
+            | ControlSpec::Number { key, .. }
+            | ControlSpec::String { key, .. }
+            | ControlSpec::Color { key, .. } => vec![key.as_str()],
+        }
+    }
+}
+
+/// One UI-emitted change to a single schema field. The emitting widget
+/// declares which top-level keys the update is allowed to write
+/// (`keys` — equivalent to the field's [`ControlSpec::serialized_keys`])
+/// and a partial new sub-state (`value`).
+///
+/// Apply semantics: keys in `keys` are *cleared* from the column's config
+/// map, then keys present in `value` are *inserted*. Defaults are
+/// pre-stripped by the caller (typically via `skip_serializing_if`), so
+/// "no value set for key K" means the schema default applies and K is
+/// not serialized.
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct ColumnConfigFieldUpdate {
+    pub keys: Vec<String>,
+    pub value: serde_json::Map<String, Value>,
+}
+
+/// Filter a per-column config map to only the keys advertised by the
+/// active plugin's schema. Foreign keys (left over from a previous plugin)
+/// stay in the unfiltered presentation state but never reach `restore()`.
+pub fn filter_to_schema(
+    config: &serde_json::Map<String, Value>,
+    active_keys: &HashSet<String>,
+) -> serde_json::Map<String, Value> {
+    config
+        .iter()
+        .filter(|(k, _)| active_keys.contains(k.as_str()))
+        .map(|(k, v)| (k.clone(), v.clone()))
+        .collect()
+}

package/src/rust/config/columns_config.rs

@@ -10,105 +10,12 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
-use std::collections::HashMap;
+//! Auxiliary types used by `ColumnConfigSchema`'s composite control
+//! variants. Per-column persisted state itself is opaque
+//! `serde_json::Map<String, serde_json::Value>`; see
+//! [`crate::presentation::ColumnConfigMap`].
 
 use serde::{Deserialize, Serialize};
-use ts_rs::TS;
-
-use super::{
-    CustomNumberFormatConfig, DatetimeColumnStyleConfig, DatetimeColumnStyleDefaultConfig,
-    NumberColumnStyleConfig, NumberColumnStyleDefaultConfig, StringColumnStyleConfig,
-    StringColumnStyleDefaultConfig,
-};
-
-fn is_zero(x: &u32) -> bool {
-    x == &0
-}
-
-/// The value de/serialized and stored in the viewer config.
-/// Also passed to the plugin via `plugin.save()`.
-#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize, TS)]
-pub struct ColumnConfigValues {
-    #[serde(default)]
-    #[serde(skip_serializing_if = "HashMap::is_empty")]
-    pub symbols: HashMap<String, String>,
-
-    #[serde(flatten)]
-    pub datagrid_number_style: NumberColumnStyleConfig,
-
-    #[serde(flatten)]
-    pub datagrid_string_style: StringColumnStyleConfig,
-
-    #[serde(flatten)]
-    pub datagrid_datetime_style: DatetimeColumnStyleConfig,
-
-    #[serde(default)]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub number_format: Option<CustomNumberFormatConfig>,
-
-    #[serde(default)]
-    #[serde(skip_serializing_if = "is_zero")]
-    pub aggregate_depth: u32,
-}
-
-#[derive(Debug)]
-pub enum ColumnConfigValueUpdate {
-    DatagridNumberStyle(Option<NumberColumnStyleConfig>),
-    DatagridStringStyle(Option<StringColumnStyleConfig>),
-    DatagridDatetimeStyle(Option<DatetimeColumnStyleConfig>),
-    Symbols(Option<HashMap<String, String>>),
-    CustomNumberStringFormat(Option<CustomNumberFormatConfig>),
-    AggregateDepth(u32),
-}
-
-impl ColumnConfigValues {
-    pub fn update(self, update: ColumnConfigValueUpdate) -> Self {
-        match update {
-            ColumnConfigValueUpdate::DatagridNumberStyle(update) => Self {
-                datagrid_number_style: update.unwrap_or_default(),
-                ..self
-            },
-            ColumnConfigValueUpdate::DatagridStringStyle(update) => Self {
-                datagrid_string_style: update.unwrap_or_default(),
-                ..self
-            },
-            ColumnConfigValueUpdate::DatagridDatetimeStyle(update) => Self {
-                datagrid_datetime_style: update.unwrap_or_default(),
-                ..self
-            },
-            ColumnConfigValueUpdate::Symbols(update) => Self {
-                symbols: update.unwrap_or_default(),
-                ..self
-            },
-            ColumnConfigValueUpdate::CustomNumberStringFormat(update) => Self {
-                number_format: update.filter(|x| x != &CustomNumberFormatConfig::default()),
-                ..self
-            },
-            ColumnConfigValueUpdate::AggregateDepth(aggregate_depth) => Self {
-                aggregate_depth,
-                ..self
-            },
-        }
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self == &Self::default()
-    }
-}
-
-/// The controls returned by plugin.column_style_controls.
-///
-/// This is a way to fill out default values for the given controls.
-/// If a control is not given, it will not be rendered. I would like to
-/// eventually show these as inactive values.
-#[derive(Serialize, Deserialize, PartialEq, Debug, Default)]
-pub struct ColumnStyleOpts {
-    pub datagrid_number_style: Option<NumberColumnStyleDefaultConfig>,
-    pub datagrid_string_style: Option<StringColumnStyleDefaultConfig>,
-    pub datagrid_datetime_style: Option<DatetimeColumnStyleDefaultConfig>,
-    pub symbols: Option<KeyValueOpts>,
-    pub number_string_format: Option<bool>,
-}
 
 #[derive(Serialize, Deserialize, Debug, PartialEq, Clone, Copy)]
 #[serde(rename_all = "snake_case")]

package/src/rust/config/datetime_column_style.rs

@@ -92,8 +92,3 @@ impl Default for DatetimeColumnStyleConfig {
         }
     }
 }
-
-#[derive(Clone, Default, Deserialize, Eq, PartialEq, Serialize, Debug)]
-pub struct DatetimeColumnStyleDefaultConfig {
-    pub color: String,
-}

package/src/rust/config/mod.rs

@@ -13,19 +13,25 @@
 //! A collection of (de-)serializable structs which capture the application
 //! state, suitable for persistence, history, etc. features.
 
+mod column_config_schema;
 mod columns_config;
 mod datetime_column_style;
+mod export_method;
 mod kvpair;
-mod number_column_style;
+mod number_series_style;
 mod number_string_format;
+mod plugin_static_config;
 mod string_column_style;
 pub mod view_config;
 mod viewer_config;
 
+pub use column_config_schema::*;
 pub use columns_config::*;
 pub use datetime_column_style::*;
-pub use number_column_style::*;
+pub use export_method::*;
+pub use number_series_style::*;
 pub use number_string_format::*;
+pub use plugin_static_config::*;
 pub use string_column_style::*;
 pub use view_config::*;
 pub use viewer_config::*;

package/src/rust/config/number_series_style.rs

@@ -0,0 +1,79 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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 serde::{Deserialize, Serialize};
+use strum::{Display, EnumIter};
+use ts_rs::TS;
+
+/// Render glyph for a numeric aggregate in the Y Bar plugin. Serialized as
+/// a lowercase string to match the plugin's runtime lookup (which does a
+/// case-insensitive `chart_type` match against the same literal set).
+#[derive(
+    Clone, Copy, Debug, Default, Deserialize, Display, EnumIter, Eq, PartialEq, Serialize, TS,
+)]
+pub enum ChartType {
+    #[default]
+    #[serde(rename = "bar")]
+    Bar,
+
+    #[serde(rename = "line")]
+    Line,
+
+    #[serde(rename = "scatter")]
+    Scatter,
+
+    #[serde(rename = "area")]
+    Area,
+}
+
+impl ChartType {
+    pub fn is_default(&self) -> bool {
+        *self == Self::Bar
+    }
+
+    /// Glyphs for which `stack` is a meaningful option. Line/Scatter never
+    /// stack; Bar/Area stack by default but can be opted out per column.
+    pub fn supports_stack(&self) -> bool {
+        matches!(self, Self::Bar | Self::Area)
+    }
+}
+
+/// Per-column render-style config for numeric aggregates in series charts
+/// (currently Y Bar). Stored flat in the column's
+/// `serde_json::Map<String, serde_json::Value>`, so the JSON shape at the
+/// viewer boundary is `{ "chart_type": "line", "stack": false }`.
+///
+/// Default `Bar` + `None` stack serializes as an empty object so plugins
+/// that never touch these fields don't pay any JSON overhead.
+#[derive(Serialize, Deserialize, Clone, Default, Debug, PartialEq, TS)]
+pub struct NumberSeriesStyleConfig {
+    #[serde(default)]
+    #[serde(skip_serializing_if = "ChartType::is_default")]
+    pub chart_type: ChartType,
+
+    /// Stack override. `None` means "use the glyph default"
+    /// (Bar/Area stack, Line/Scatter don't). `Some(false)` on a Bar/Area
+    /// forces non-stacking.
+    #[serde(default)]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub stack: Option<bool>,
+}
+
+/// Defaults-only shape carried by `ControlSpec::NumberSeriesStyle`. The
+/// presence of this control in a plugin's `column_config_schema` is the
+/// signal for the sidebar to render the chart-type picker.
+#[derive(Serialize, Deserialize, Clone, Default, Debug, PartialEq)]
+pub struct NumberSeriesStyleDefaultConfig {
+    pub chart_type: ChartType,
+    #[serde(default)]
+    pub stack: Option<bool>,
+}

package/src/rust/config/plugin_static_config.rs

@@ -0,0 +1,144 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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 perspective_client::config::GroupRollupMode;
+use serde::Deserialize;
+use ts_rs::TS;
+
+#[derive(Clone, Copy, Debug, Default, Deserialize, Eq, PartialEq, TS)]
+#[serde(rename_all = "camelCase")]
+pub enum ColumnSelectMode {
+    #[default]
+    Toggle,
+    Select,
+}
+
+impl ColumnSelectMode {
+    pub fn css(&self) -> yew::Classes {
+        match self {
+            Self::Toggle => yew::classes!("toggle-mode", "is_column_active"),
+            Self::Select => yew::classes!("select-mode", "is_column_active"),
+        }
+    }
+}
+
+/// Static, immutable configuration for a plugin.
+///
+/// Returned once per plugin from `get_static_config()` at registration
+/// time and cached in [`crate::renderer::PluginRecord`]. Consumers
+/// (renderer, session, queries, components) read these fields off the
+/// renderer's active-plugin metadata rather than calling back into JS.
+///
+/// `<perspective-viewer>` reads this exactly once per plugin (at
+/// `registerPlugin` time) and caches it for the lifetime of the
+/// application. The result must be stable; do not mutate any field
+/// after registration.
+#[derive(Clone, Debug, Default, Deserialize, PartialEq, TS)]
+pub struct PluginStaticConfig {
+    /// The unique key for this plugin. Used as the `plugin` field in a
+    /// `ViewerConfig` and as the display name key in the
+    /// `<perspective-viewer>` UI.
+    pub name: String,
+
+    /// Category in the plugin picker menu.
+    #[serde(default)]
+    #[ts(as = "Option<_>")]
+    #[ts(optional)]
+    pub category: Option<String>,
+
+    /// Soft limit on the number of columns the plugin will render.
+    /// Triggers the "Rendering N of M" warning when the view exceeds
+    /// this value (until dismissed).
+    #[serde(default)]
+    #[ts(as = "Option<_>")]
+    #[ts(optional)]
+    pub max_columns: Option<usize>,
+
+    /// Soft limit on the number of cells (rows × columns) the plugin
+    /// will render. Triggers the "Rendering N of M" warning when the view
+    /// exceeds this value (until dismissed).
+    #[serde(default)]
+    #[ts(as = "Option<_>")]
+    #[ts(optional)]
+    pub max_cells: Option<usize>,
+
+    /// Column add/remove behavior. `"select"` exclusively selects the
+    /// added column, removing other columns. `"toggle"` toggles the
+    /// column on or off based on its current state, leaving other
+    /// columns alone.
+    #[serde(default)]
+    #[ts(as = "Option<_>")]
+    #[ts(optional)]
+    pub select_mode: ColumnSelectMode,
+
+    /// Minimum number of columns the plugin requires to render. Mostly
+    /// affects drag/drop and column-remove button behavior. `undefined`
+    /// is treated identically to `1`.
+    #[serde(default)]
+    #[ts(as = "Option<_>")]
+    #[ts(optional)]
+    pub min_config_columns: Option<usize>,
+
+    /// Named column slots. Named columns have replace/swap behavior in
+    /// drag/drop rather than insert. The length must be at least
+    /// `min_config_columns`.
+    #[serde(default)]
+    #[ts(as = "Option<_>")]
+    #[ts(optional)]
+    pub config_column_names: Vec<String>,
+
+    /// Group-rollup modes the plugin accepts, in preference order.
+    /// The first entry that matches a feature flag becomes the default.
+    #[serde(default)]
+    #[ts(as = "Option<_>")]
+    #[ts(optional)]
+    pub group_rollup_modes: Option<Vec<GroupRollupMode>>,
+
+    /// Plugin load priority. Higher numbers win; ties resolve in
+    /// registration order. The highest-priority plugin is loaded by
+    /// default unless `restore({ plugin })` overrides it.
+    #[serde(default)]
+    #[ts(as = "Option<_>")]
+    #[ts(optional)]
+    pub priority: Option<i32>,
+
+    /// Whether this plugin opts into per-column style controls in the
+    /// settings sidebar. When `true`, the StyleTab is shown for active
+    /// columns and the plugin's `column_config_schema` is queried for
+    /// the per-column field set. When `false` or omitted, no StyleTab
+    /// is shown.
+    #[serde(default)]
+    #[ts(as = "Option<_>")]
+    #[ts(optional)]
+    pub can_render_column_styles: bool,
+}
+
+impl PluginStaticConfig {
+    /// `true` if dropping a column at `index` should swap with the
+    /// column already there rather than insert. Only the named slots
+    /// (`config_column_names[..len()-1]`) participate in swap behaviour;
+    /// the trailing unnamed tail inserts.
+    pub fn is_swap(&self, index: usize) -> bool {
+        !self.config_column_names.is_empty() && index < self.config_column_names.len() - 1
+    }
+
+    pub fn get_group_rollups(&self, rollup_features: &[GroupRollupMode]) -> Vec<GroupRollupMode> {
+        self.group_rollup_modes
+            .clone()
+            .map(|x| {
+                x.into_iter()
+                    .filter(|y| rollup_features.is_empty() || rollup_features.contains(y))
+                    .collect()
+            })
+            .unwrap_or_default()
+    }
+}

package/src/rust/config/string_column_style.rs

@@ -133,8 +133,3 @@ pub struct StringColumnStyleConfig {
     #[serde(default)]
     pub color: Option<String>,
 }
-
-#[derive(Debug, Clone, Default, Deserialize, Eq, PartialEq, Serialize)]
-pub struct StringColumnStyleDefaultConfig {
-    pub color: String,
-}

package/src/rust/config/viewer_config.rs

@@ -10,7 +10,6 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
-use std::collections::HashMap;
 use std::ops::Deref;
 use std::sync::LazyLock;
 
@@ -21,18 +20,17 @@ use serde_json::Value;
 use ts_rs::TS;
 use wasm_bindgen::prelude::*;
 
-use super::ColumnConfigValues;
-use crate::presentation::ColumnConfigMap;
+use crate::renderer::ColumnConfigMap;
 
 /// The state of an entire `custom_elements::PerspectiveViewerElement` component
 /// and its `Plugin`.
-#[derive(Debug, Default, Serialize, PartialEq)]
+#[derive(Debug, Default, Serialize, PartialEq, TS)]
 #[serde(deny_unknown_fields)]
-pub struct ViewerConfig<V = String> {
+pub struct ViewerConfig<V: TS = String> {
     pub version: V,
     pub columns_config: ColumnConfigMap,
     pub plugin: String,
-    pub plugin_config: Value,
+    pub plugin_config: serde_json::Map<String, Value>,
     pub settings: bool,
     pub table: Option<String>,
     pub theme: Option<String>,
@@ -106,7 +104,7 @@ pub struct ViewerConfigUpdate {
     #[serde(default)]
     #[ts(as = "Option<_>")]
     #[ts(optional)]
-    pub plugin_config: Option<PluginConfig>,
+    pub plugin_config: PluginConfigUpdate,
 
     #[serde(default)]
     #[ts(as = "Option<_>")]
@@ -162,7 +160,8 @@ pub type ThemeUpdate = OptionalUpdate<String>;
 pub type TitleUpdate = OptionalUpdate<String>;
 pub type TableUpdate = OptionalUpdate<String>;
 pub type VersionUpdate = OptionalUpdate<String>;
-pub type ColumnConfigUpdate = OptionalUpdate<HashMap<String, ColumnConfigValues>>;
+pub type ColumnConfigUpdate = OptionalUpdate<ColumnConfigMap>;
+pub type PluginConfigUpdate = OptionalUpdate<serde_json::Map<String, Value>>;
 
 /// Handles `{}` when included as a field with `#[serde(default)]`.
 impl<T: Clone> Default for OptionalUpdate<T> {