@perspective-dev/viewer 4.4.1 → 4.5.1

package/src/rust/{tasks → queries}/column_locator.rs

@@ -10,32 +10,11 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
-use perspective_client::config::{ColumnType, ViewConfig};
+use perspective_client::config::ViewConfig;
 
-use super::HasSession;
-use super::plugin_column_styles::can_render_column_styles;
 use crate::presentation::{ColumnLocator, OpenColumnSettings};
 use crate::renderer::Renderer;
 use crate::session::SessionMetadata;
-use crate::tasks::{HasPresentation, HasRenderer, PluginColumnStyles};
-
-/// Returns the column name for a locator, generating a default for new
-/// expressions.
-pub fn locator_name_or_default(metadata: &SessionMetadata, locator: &ColumnLocator) -> String {
-    match locator {
-        ColumnLocator::Table(s) | ColumnLocator::Expression(s) => s.clone(),
-        ColumnLocator::NewExpression => metadata.make_new_column_name(None),
-    }
-}
-
-/// Returns the view type for a locator's column, if available.
-pub fn locator_view_type(
-    metadata: &SessionMetadata,
-    locator: &ColumnLocator,
-) -> Option<ColumnType> {
-    let name = locator.name().cloned().unwrap_or_default();
-    metadata.get_column_view_type(name.as_str())
-}
 
 /// Returns a [`ColumnLocator`] for a given column name, or [`None`] if no
 /// such column exists.
@@ -57,17 +36,20 @@ pub fn get_column_locator(
 
 /// Gets a [`ColumnLocator`] for the current UI's column settings state,
 /// or [`None`] if it is not currently active.
+///
+/// Table columns only have a useful sidebar (the Style tab)
+/// when they're in `view_config.columns`.
 pub fn get_current_column_locator(
     open_column_settings: &OpenColumnSettings,
     renderer: &Renderer,
     view_config: &ViewConfig,
-    metadata: &SessionMetadata,
+    _metadata: &SessionMetadata,
 ) -> Option<ColumnLocator> {
     open_column_settings
         .locator
         .clone()
         .filter(|locator| match locator {
-            ColumnLocator::Table(name) => {
+            ColumnLocator::Table(_name) => {
                 locator
                     .name()
                     .map(|name| {
@@ -76,58 +58,20 @@ pub fn get_current_column_locator(
                                 .as_ref()
                                 .map(|col| col == name)
                                 .unwrap_or_default()
-                        }) || view_config.group_by.iter().any(|col| col == name)
-                            || view_config.split_by.iter().any(|col| col == name)
-                            || view_config.filter.iter().any(|col| col.column() == name)
-                            || view_config.sort.iter().any(|col| &col.0 == name)
+
+                            //     }) || view_config.group_by.iter().any(|col|
+                            // col == name)         ||
+                            // view_config.split_by.iter().any(|col| col ==
+                            // name)         ||
+                            // view_config.filter.iter().any(|col| col.column()
+                            // == name)         ||
+                            // view_config.sort.iter().any(|col| &col.0 == name)
+                            // })
+                        })
                     })
                     .unwrap_or_default()
-                    && can_render_column_styles(renderer, view_config, metadata, name)
-                        .unwrap_or_default()
+                    && renderer.can_render_column_styles()
             },
             _ => true,
         })
 }
-
-/// Trait facade — delegates to standalone functions above.
-pub trait ColumnLocatorExt: HasSession {
-    fn locator_name_or_default(&self, locator: &ColumnLocator) -> String {
-        locator_name_or_default(&self.session().metadata(), locator)
-    }
-
-    fn is_locator_active(&self, locator: &ColumnLocator) -> bool {
-        locator
-            .name()
-            .map(|name| self.session().to_props().is_column_active(name))
-            .unwrap_or_default()
-    }
-
-    fn locator_view_type(&self, locator: &ColumnLocator) -> Option<ColumnType> {
-        locator_view_type(&self.session().metadata(), locator)
-    }
-
-    fn get_column_locator(&self, name: Option<String>) -> Option<ColumnLocator> {
-        get_column_locator(&self.session().metadata(), name)
-    }
-}
-
-impl<T: HasSession> ColumnLocatorExt for T {}
-
-/// Trait facade for `get_current_column_locator`.
-pub trait ColumnLocatorCurrentExt:
-    HasPresentation + HasRenderer + HasSession + PluginColumnStyles
-{
-    fn get_current_column_locator(&self) -> Option<ColumnLocator> {
-        get_current_column_locator(
-            &self.presentation().get_open_column_settings(),
-            self.renderer(),
-            &self.session().get_view_config(),
-            &self.session().metadata(),
-        )
-    }
-}
-
-impl<T: HasPresentation + HasRenderer + HasSession + PluginColumnStyles> ColumnLocatorCurrentExt
-    for T
-{
-}

package/src/rust/queries/column_values.rs

@@ -0,0 +1,59 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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::ViewConfigUpdate;
+use perspective_client::{ViewWindow, clone};
+use perspective_js::utils::{ApiError, ApiFuture};
+
+use crate::session::Session;
+
+/// Get all unique column values for a given column name.
+///
+/// Use the `.to_csv()` method, as I suspected copying this large string
+/// once was more efficient than copying many smaller strings, and
+/// string copying shows up frequently when doing performance analysis.
+///
+/// TODO Does not work with expressions yet.
+pub async fn get_column_values(session: &Session, column: String) -> Result<Vec<String>, ApiError> {
+    let expressions = Some(session.get_view_config().expressions.clone());
+    let config = ViewConfigUpdate {
+        group_by: Some(vec![column]),
+        columns: Some(vec![]),
+        expressions,
+        ..ViewConfigUpdate::default()
+    };
+
+    let table = session
+        .get_table()
+        .ok_or_else(|| ApiError::from("No table set"))?;
+    let view = table.view(Some(config.clone())).await?;
+    let csv = view.to_csv(ViewWindow::default()).await?;
+
+    clone!(view);
+    ApiFuture::spawn(async move {
+        view.delete().await?;
+        Ok(())
+    });
+
+    let res = csv
+        .lines()
+        .map(|val| {
+            if val.starts_with('\"') && val.ends_with('\"') {
+                (val[1..val.len() - 1]).to_owned()
+            } else {
+                val.to_owned()
+            }
+        })
+        .skip(2)
+        .collect::<Vec<String>>();
+    Ok(res)
+}

package/src/rust/{tasks → queries}/columns_iter_set.rs

@@ -16,11 +16,10 @@ use itertools::Itertools;
 use perspective_client::config::*;
 
 use super::is_invalid_columns_column;
-use crate::dragdrop::*;
+use crate::presentation::Presentation;
 use crate::renderer::*;
 use crate::session::SessionMetadata;
 use crate::utils::DragTarget;
-use crate::*;
 
 /// The possible states of a column (row) in the active columns list, including
 /// the `Option<String>` label type.
@@ -76,10 +75,10 @@ impl<'a> ColumnsIteratorSet<'a> {
         config: &'a ViewConfig,
         metadata: &'a SessionMetadata,
         renderer: &'a Renderer,
-        dragdrop: &DragDrop,
+        presentation: &Presentation,
     ) -> ColumnsIteratorSet<'a> {
-        let is_dragover_column = dragdrop.is_dragover(DragTarget::Active);
-        let named_columns = renderer.metadata().names.clone().unwrap_or_default();
+        let is_dragover_column = presentation.is_dragover(DragTarget::Active);
+        let named_columns = renderer.metadata().config_column_names.clone();
         ColumnsIteratorSet {
             config,
             renderer,
@@ -92,12 +91,7 @@ impl<'a> ColumnsIteratorSet<'a> {
     /// Generate an iterator for active columns, which are represented as
     /// `Option` for dragover and missing columns.
     pub fn active(&'a self) -> impl Iterator<Item = ActiveColumnState> + 'a {
-        let min_cols = self
-            .renderer
-            .metadata()
-            .names
-            .as_ref()
-            .map_or(0, |x| x.len());
+        let min_cols = self.renderer.metadata().config_column_names.len();
 
         let last_col = self.config.columns.last().and_then(|x| x.as_ref());
         let has_blank_tail = last_col.is_none()
@@ -122,7 +116,7 @@ impl<'a> ColumnsIteratorSet<'a> {
                     .position(|x| x.as_ref() == Some(from_column));
 
                 let is_from_required = from_index
-                    .and_then(|x| self.renderer.metadata().min.map(|y| x < y))
+                    .and_then(|x| self.renderer.metadata().min_config_columns.map(|y| x < y))
                     .unwrap_or_default();
 
                 let is_from_swap = from_index
@@ -131,7 +125,7 @@ impl<'a> ColumnsIteratorSet<'a> {
 
                 let is_swap_invalid = is_invalid_columns_column(
                     self.config,
-                    self.renderer.metadata().min,
+                    self.renderer.metadata().min_config_columns,
                     from_column,
                     *to_index,
                 );
@@ -254,12 +248,11 @@ impl<'a> ColumnsIteratorSet<'a> {
         &'a self,
         values: impl Iterator<Item = &'a String>,
     ) -> impl Iterator<Item = OrderedColumn<'a>> {
-        let is_drag_active = maybe! {
+        let is_drag_active: Option<bool> = try {
             let dragover_col = self.is_dragover_column.as_ref();
             let cols = &self.config.columns;
             let (_, drag_name) = dragover_col?;
-            let is_drag_active = cols.iter().flatten().any(|x| x == drag_name);
-            Some(is_drag_active)
+            cols.iter().flatten().any(|x| x == drag_name)
         };
 
         let col_set = self.config.columns.iter().collect::<HashSet<_>>();
@@ -282,11 +275,11 @@ impl<'a> ColumnsIteratorSet<'a> {
         let dragover_col = self.is_dragover_column.as_ref();
         let cols = &self.config.columns;
         let is_active = col_set.contains(&Some(name.to_string())); // cols.iter().flatten().any(|x| x == name);
-        let is_swap_over = maybe! {
+        let is_swap_over: Option<bool> = try {
             let (drop_index, _) = dragover_col?;
             let is_swap = self.renderer.metadata().is_swap(*drop_index);
             let is_over = cols.get(*drop_index)?.as_ref()? == name;
-            Some(is_swap && is_over && !is_drag_active?)
+            is_swap && is_over && !is_drag_active?
         };
 
         if !is_active || is_swap_over.unwrap_or_default() {

package/src/rust/queries/exports.rs

@@ -0,0 +1,96 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+//! Pure read-only `View` → bytes/string derivations.  `flat = true` means
+//! "ignore the active view config and re-fetch the un-pivoted table view";
+//! `flat = false` means "use the session's bound view".
+
+use perspective_client::{View, ViewWindow};
+use perspective_js::utils::{ApiError, ApiResult};
+use wasm_bindgen::JsCast;
+
+use crate::session::Session;
+
+async fn flat_view(session: &Session, flat: bool) -> ApiResult<View> {
+    if flat {
+        let table = session
+            .get_table()
+            .ok_or_else(|| ApiError::from("No table set"))?;
+        Ok(table.view(None).await?)
+    } else {
+        session
+            .get_view()
+            .ok_or_else(|| ApiError::from("No view created"))
+    }
+}
+
+pub async fn arrow_as_vec(
+    session: &Session,
+    flat: bool,
+    window: Option<ViewWindow>,
+) -> Result<Vec<u8>, ApiError> {
+    Ok(flat_view(session, flat)
+        .await?
+        .to_arrow(window.unwrap_or_default())
+        .await?
+        .into())
+}
+
+pub async fn arrow_as_jsvalue(
+    session: &Session,
+    flat: bool,
+    window: Option<ViewWindow>,
+) -> Result<js_sys::ArrayBuffer, ApiError> {
+    let arrow = flat_view(session, flat)
+        .await?
+        .to_arrow(window.unwrap_or_default())
+        .await?;
+    Ok(js_sys::Uint8Array::from(&arrow[..])
+        .buffer()
+        .unchecked_into())
+}
+
+pub async fn ndjson_as_jsvalue(
+    session: &Session,
+    flat: bool,
+    window: Option<ViewWindow>,
+) -> Result<js_sys::JsString, ApiError> {
+    let json: String = flat_view(session, flat)
+        .await?
+        .to_ndjson(window.unwrap_or_default())
+        .await?;
+
+    Ok(json.into())
+}
+
+pub async fn json_as_jsvalue(
+    session: &Session,
+    flat: bool,
+    window: Option<ViewWindow>,
+) -> Result<js_sys::Object, ApiError> {
+    let json: String = flat_view(session, flat)
+        .await?
+        .to_columns_string(window.unwrap_or_default())
+        .await?;
+
+    Ok(js_sys::JSON::parse(&json)?.unchecked_into())
+}
+
+pub async fn csv_as_jsvalue(
+    session: &Session,
+    flat: bool,
+    window: Option<ViewWindow>,
+) -> Result<js_sys::JsString, ApiError> {
+    let window = window.unwrap_or_default();
+    let csv = flat_view(session, flat).await?.to_csv(window).await;
+    Ok(csv.map(js_sys::JsString::from)?)
+}

package/src/rust/queries/fetch_column_stats.rs

@@ -0,0 +1,94 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+//! Async dispatch task for per-column numeric stats.
+//!
+//! `resolve_abs_max` is the cache-or-fetch core: hit the
+//! [`Session`] stats cache first, fall back to `View::get_min_max`
+//! for numeric columns on miss, write-through on success.
+//!
+//! `fetch_column_abs_max` is the fire-and-forget pre-warm wrapper used
+//! by the StyleTab on column-settings panel open so the gradient
+//! defaults are ready before the user can trigger any UI update.
+
+use perspective_client::View;
+use perspective_client::config::{ColumnType, Scalar};
+use perspective_js::utils::ApiFuture;
+
+use crate::session::{Session, SessionMetadata};
+
+fn scalar_to_f64(s: &Scalar) -> Option<f64> {
+    match s {
+        Scalar::Float(x) => Some(*x),
+        _ => None,
+    }
+}
+
+/// Extract `abs_max = max(|min|, |max|)` from a `(Scalar, Scalar)`
+/// `View::get_min_max` result. Returns `None` for non-numeric scalars.
+pub fn min_max_to_abs_max(min: &Scalar, max: &Scalar) -> Option<f64> {
+    let min = scalar_to_f64(min)?;
+    let max = scalar_to_f64(max)?;
+    Some(min.abs().max(max.abs()))
+}
+
+/// `true` if the column's view type is `Integer` or `Float`. Used to
+/// skip the `View::get_min_max` round trip for non-numeric columns
+/// (which would either error or return non-`Float` scalars).
+pub fn is_numeric_column(metadata: &SessionMetadata, col_name: &str) -> bool {
+    matches!(
+        metadata.get_column_view_type(col_name),
+        Some(ColumnType::Integer | ColumnType::Float)
+    )
+}
+
+/// Resolve the cached `abs_max` for `col_name`; on miss, await
+/// `View::get_min_max` for numeric columns, populate the cache, and
+/// return the value. Non-numeric columns and missing views return
+/// `None` without a fetch.
+pub async fn resolve_abs_max(
+    session: &Session,
+    metadata: &SessionMetadata,
+    view: Option<&View>,
+    col_name: &str,
+) -> Option<f64> {
+    if let Some(stats) = session.get_column_stats(col_name)
+        && let Some(v) = stats.abs_max
+    {
+        return Some(v);
+    }
+    if !is_numeric_column(metadata, col_name) {
+        return None;
+    }
+
+    let view = view?;
+    let (min, max) = view.get_min_max(col_name.to_string()).await.ok()?;
+    let v = min_max_to_abs_max(&min, &max)?;
+    session.set_column_abs_max(col_name.to_string(), v);
+    Some(v)
+}
+
+/// Fire-and-forget pre-warm of the stats cache. Spawns
+/// [`resolve_abs_max`] on the active session's view; the result is
+/// discarded — the side effect of populating
+/// [`Session::set_column_abs_max`] is the goal. Used by the
+/// `StyleTab`'s `use_effect_with` to warm gradient defaults before
+/// the user can trigger a `plugin.restore`.
+pub fn fetch_column_abs_max(session: &Session, column_name: String) {
+    let session = session.clone();
+    ApiFuture::spawn(async move {
+        let metadata = session.metadata().clone();
+        let view = session.get_view();
+        resolve_abs_max(&session, &metadata, view.as_ref(), &column_name).await;
+        Ok::<_, perspective_js::utils::ApiError>(())
+    });
+}

package/src/rust/queries/get_viewer_config.rs

@@ -0,0 +1,54 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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 crate::config::*;
+use crate::presentation::Presentation;
+use crate::renderer::Renderer;
+use crate::session::Session;
+use crate::*;
+
+/// Compose the current [`ViewerConfig`] from across the engine handles.
+///
+/// The `view_config` field is read from the snapshot the currently-bound
+/// `View` was constructed from, so it is consistent with what the active
+/// plugin is rendering. Falls back to the live session config if no
+/// `View` exists yet.
+pub async fn get_viewer_config(
+    session: &Session,
+    renderer: &Renderer,
+    presentation: &Presentation,
+) -> ApiResult<ViewerConfig> {
+    let version = config::API_VERSION.to_string();
+    let view_config = if let Some(rendered) = session.get_rendered_view_config() {
+        (*rendered).clone()
+    } else {
+        session.get_view_config().clone()
+    };
+    let settings = presentation.is_settings_open();
+    let plugin = renderer.metadata().name.clone();
+    let plugin_config = renderer.get_plugin_config();
+    let theme = presentation.get_selected_theme_name().await;
+    let title = session.get_title();
+    let table = session.get_table().map(|x| x.get_name().to_owned());
+    let columns_config = renderer.all_columns_configs();
+    Ok(ViewerConfig {
+        version,
+        plugin,
+        title,
+        plugin_config,
+        columns_config,
+        settings,
+        table,
+        view_config,
+        theme,
+    })
+}

package/src/rust/queries/mod.rs

@@ -0,0 +1,44 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+//! Read-only async utilities across the engine handles.
+//!
+//! Each function in this module reads from one or more of [`Session`],
+//! [`Renderer`], [`Presentation`] and produces a derived value without
+//! mutating engine state.  Compare [`crate::tasks`], which holds the
+//! state-mutating async business logic dispatched from user actions.
+//!
+//! [`Session`]: crate::session::Session
+//! [`Renderer`]: crate::renderer::Renderer
+//! [`Presentation`]: crate::presentation::Presentation
+
+mod column_locator;
+mod column_values;
+mod columns_iter_set;
+pub mod export_app;
+mod exports;
+mod fetch_column_stats;
+mod get_viewer_config;
+mod is_invalid_drop;
+mod plugin_column_styles;
+mod validate_expression;
+
+pub use self::column_locator::*;
+pub use self::column_values::*;
+pub use self::columns_iter_set::*;
+pub use self::export_app::*;
+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::plugin_column_styles::*;
+pub use self::validate_expression::*;

package/src/rust/queries/plugin_column_styles.rs

@@ -0,0 +1,101 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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 itertools::Itertools;
+use perspective_client::config::ViewConfig;
+use perspective_js::utils::{ApiResult, JsValueSerdeExt};
+use serde::Serialize;
+
+use crate::config::ColumnConfigSchema;
+use crate::renderer::Renderer;
+use crate::session::SessionMetadata;
+
+/// Stats payload passed to `plugin.column_config_schema` as the
+/// `column_stats` arg. The caller (e.g. the StyleTab) owns the value —
+/// typically populated by `fetch_column_abs_max` resolving into a
+/// component-local `use_state`. Missing when no fetch has resolved yet.
+#[derive(Default, Serialize)]
+struct ColumnStats {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    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.
+pub fn get_plugin_config_schema(
+    renderer: &Renderer,
+    view_config: &ViewConfig,
+) -> ApiResult<ColumnConfigSchema> {
+    let plugin = renderer.get_active_plugin()?;
+    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())
+}
+
+/// Queries the active plugin for the per-column [`ColumnConfigSchema`].
+///
+/// `current_value` is the column's existing flat JSON config (if any);
+/// plugins use it to dynamically gate fields based on prior state.
+/// `abs_max` is the caller-owned numeric stat (typically a Yew
+/// `use_state` populated by an in-flight `fetch_column_abs_max` task);
+/// `None` means the fetch has not yet resolved and gradient defaults
+/// fall back to 0.
+pub fn get_column_config_schema(
+    renderer: &Renderer,
+    view_config: &ViewConfig,
+    metadata: &SessionMetadata,
+    column_name: &str,
+    current_value: Option<&serde_json::Map<String, serde_json::Value>>,
+    abs_max: Option<f64>,
+) -> ApiResult<ColumnConfigSchema> {
+    let plugin = renderer.get_active_plugin()?;
+    let plugin_config = renderer.metadata();
+    let names = &plugin_config.config_column_names;
+    let group = view_config
+        .columns
+        .iter()
+        .find_position(|maybe_s| maybe_s.as_deref() == Some(column_name))
+        .and_then(|(idx, _)| names.get(idx))
+        .map(|s| s.as_str());
+
+    let view_type = if let Some(x) = metadata.get_column_view_type(column_name) {
+        x
+    } else {
+        return Ok(ColumnConfigSchema { fields: vec![] });
+    };
+
+    // Route through serde_json so maps serialize as plain JS objects
+    // rather than `Map` instances — plugin code accesses these with
+    // property syntax, not `.get()`.
+    let current_js = wasm_bindgen::JsValue::from_serde_ext(&current_value)
+        .unwrap_or(wasm_bindgen::JsValue::NULL);
+    let view_config_js =
+        wasm_bindgen::JsValue::from_serde_ext(view_config).unwrap_or(wasm_bindgen::JsValue::NULL);
+
+    let stats = ColumnStats { abs_max };
+    let stats_js =
+        wasm_bindgen::JsValue::from_serde_ext(&stats).unwrap_or(wasm_bindgen::JsValue::NULL);
+
+    let raw = plugin._column_config_schema(
+        &view_type.to_string(),
+        group,
+        column_name,
+        &current_js,
+        &view_config_js,
+        &stats_js,
+    )?;
+
+    serde_wasm_bindgen::from_value(raw).map_err(|e| e.into())
+}