@perspective-dev/viewer 4.3.0 → 4.4.0

package/src/rust/tasks/column_locator.rs

@@ -0,0 +1,133 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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::{ColumnType, 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.
+pub fn get_column_locator(
+    metadata: &SessionMetadata,
+    name: Option<String>,
+) -> Option<ColumnLocator> {
+    name.and_then(|name| {
+        if metadata.is_column_expression(&name) {
+            Some(ColumnLocator::Expression(name))
+        } else {
+            metadata.get_table_columns().and_then(|x| {
+                x.iter()
+                    .find_map(|n| (n == &name).then_some(ColumnLocator::Table(name.clone())))
+            })
+        }
+    })
+}
+
+/// Gets a [`ColumnLocator`] for the current UI's column settings state,
+/// or [`None`] if it is not currently active.
+pub fn get_current_column_locator(
+    open_column_settings: &OpenColumnSettings,
+    renderer: &Renderer,
+    view_config: &ViewConfig,
+    metadata: &SessionMetadata,
+) -> Option<ColumnLocator> {
+    open_column_settings
+        .locator
+        .clone()
+        .filter(|locator| match locator {
+            ColumnLocator::Table(name) => {
+                locator
+                    .name()
+                    .map(|name| {
+                        view_config.columns.iter().any(|maybe_col| {
+                            maybe_col
+                                .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)
+                    })
+                    .unwrap_or_default()
+                    && can_render_column_styles(renderer, view_config, metadata, name)
+                        .unwrap_or_default()
+            },
+            _ => 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/{model → tasks}/columns_iter_set.rs

@@ -15,10 +15,10 @@ use std::collections::HashSet;
 use itertools::Itertools;
 use perspective_client::config::*;
 
-use super::{HasRenderer, HasSession, IsInvalidDrop};
+use super::is_invalid_columns_column;
 use crate::dragdrop::*;
 use crate::renderer::*;
-use crate::session::*;
+use crate::session::SessionMetadata;
 use crate::utils::DragTarget;
 use crate::*;
 
@@ -65,28 +65,16 @@ type Label = Option<String>;
 /// iterator returning functions `active()`, `inactive()` and `expression()`.
 pub struct ColumnsIteratorSet<'a> {
     config: &'a ViewConfig,
-    session: &'a Session,
     renderer: &'a Renderer,
-    metadata: MetadataRef<'a>,
+    metadata: &'a SessionMetadata,
     is_dragover_column: Option<(usize, String)>,
     named_columns: Vec<String>,
 }
 
-impl HasRenderer for ColumnsIteratorSet<'_> {
-    fn renderer(&self) -> &'_ Renderer {
-        self.renderer
-    }
-}
-impl HasSession for ColumnsIteratorSet<'_> {
-    fn session(&self) -> &'_ Session {
-        self.session
-    }
-}
-
 impl<'a> ColumnsIteratorSet<'a> {
     pub fn new(
         config: &'a ViewConfig,
-        session: &'a Session,
+        metadata: &'a SessionMetadata,
         renderer: &'a Renderer,
         dragdrop: &DragDrop,
     ) -> ColumnsIteratorSet<'a> {
@@ -94,9 +82,8 @@ impl<'a> ColumnsIteratorSet<'a> {
         let named_columns = renderer.metadata().names.clone().unwrap_or_default();
         ColumnsIteratorSet {
             config,
-            session,
             renderer,
-            metadata: session.metadata(),
+            metadata,
             is_dragover_column,
             named_columns,
         }
@@ -117,10 +104,9 @@ impl<'a> ColumnsIteratorSet<'a> {
             || self.config.columns.len() < self.named_columns.len()
             || self.config.columns.iter().filter(|x| x.is_some()).count()
                 == self
-                    .session
-                    .metadata()
+                    .metadata
                     .get_table_columns()
-                    .map(|x| x.len())
+                    .map(|x: &Vec<String>| x.len())
                     .unwrap_or_default()
                     + self.config.expressions.len();
 
@@ -143,7 +129,12 @@ impl<'a> ColumnsIteratorSet<'a> {
                     .map(|x| self.renderer.metadata().is_swap(x))
                     .unwrap_or_default();
 
-                let is_swap_invalid = self.is_invalid_columns_column(from_column, *to_index);
+                let is_swap_invalid = is_invalid_columns_column(
+                    self.config,
+                    self.renderer.metadata().min,
+                    from_column,
+                    *to_index,
+                );
                 let is_dragover_after_last = *to_index == self.config.columns.len();
                 if is_swap_invalid {
                     let all_columns = self.config.columns.iter().map(|x| x.into());
@@ -299,7 +290,7 @@ impl<'a> ColumnsIteratorSet<'a> {
         };
 
         if !is_active || is_swap_over.unwrap_or_default() {
-            let col_type = self.session.metadata().get_column_table_type(name)?;
+            let col_type = self.metadata.get_column_table_type(name)?;
             let is_visible = dragover_col.is_none_or(|(_, x)| x != name);
             Some(OrderedColumn {
                 is_visible,

package/src/rust/{model → tasks}/edit_expression.rs

@@ -19,13 +19,31 @@ use crate::renderer::Renderer;
 use crate::session::Session;
 use crate::*;
 
-#[derive(PartialEq, PerspectiveProperties!)]
+#[derive(Clone, PartialEq)]
 pub struct ExpressionUpdater {
     presentation: Presentation,
     renderer: Renderer,
     session: Session,
 }
 
+impl HasPresentation for ExpressionUpdater {
+    fn presentation(&self) -> &Presentation {
+        &self.presentation
+    }
+}
+
+impl HasRenderer for ExpressionUpdater {
+    fn renderer(&self) -> &Renderer {
+        &self.renderer
+    }
+}
+
+impl HasSession for ExpressionUpdater {
+    fn session(&self) -> &Session {
+        &self.session
+    }
+}
+
 pub trait EditExpression: HasPresentation + HasRenderer + HasSession + UpdateAndRender {
     fn get_expression_updater(&self) -> ExpressionUpdater {
         ExpressionUpdater {
@@ -41,37 +59,43 @@ pub trait EditExpression: HasPresentation + HasRenderer + HasSession + UpdateAnd
         ApiFuture::spawn(async move {
             let update = this
                 .session
-                .create_replace_expression_update(&old_name, &new_expr)
-                .await;
+                .to_props()
+                .create_replace_expression_update(&old_name, &new_expr);
 
+            this.update_and_render(update)?.await?;
             this.presentation
                 .set_open_column_settings(Some(OpenColumnSettings {
                     locator: Some(ColumnLocator::Expression(new_expr.name.to_string())),
                     tab: Some(ColumnSettingsTab::Attributes),
                 }));
 
-            this.update_and_render(update)?.await?;
             Ok(())
         });
     }
 
     /// Saves a new expression. Spawns a future.
     fn save_expr(&self, expr: Expression) -> ApiResult<()> {
+        let presentation = self.presentation().clone();
+        let expr_name: String = expr.name.clone().into();
         let task = {
             let mut serde_exprs = self.session().get_view_config().expressions.clone();
             serde_exprs.insert(&expr);
-            self.presentation()
-                .set_open_column_settings(Some(OpenColumnSettings {
-                    locator: Some(ColumnLocator::Expression(expr.name.clone().into())),
-                    tab: Some(ColumnSettingsTab::Attributes),
-                }));
             self.update_and_render(ViewConfigUpdate {
                 expressions: Some(serde_exprs),
                 ..Default::default()
             })
         }?;
 
-        ApiFuture::spawn(task);
+        ApiFuture::spawn(async move {
+            task.await?;
+            presentation.set_open_column_settings(Some(OpenColumnSettings {
+                locator: Some(ColumnLocator::Expression(expr_name)),
+                tab: Some(ColumnSettingsTab::Attributes),
+            }));
+
+            Ok(())
+        });
+
         Ok(())
     }
 

package/src/rust/{model → tasks}/eject.rs

@@ -16,7 +16,7 @@ use yew::Component;
 use super::{HasRenderer, HasSession};
 use crate::ApiFuture;
 use crate::root::Root;
-use crate::session::ResetOptions;
+use crate::session::{ResetOptions, TableIntermediateState};
 
 pub trait DeleteAll: HasSession + HasRenderer {
     fn delete_all<T: Component>(&self, root: &Root<T>) -> ApiFuture<()> {
@@ -29,7 +29,7 @@ pub trait DeleteAll: HasSession + HasRenderer {
                 .reset(ResetOptions {
                     config: true,
                     expressions: true,
-                    table: true,
+                    table: Some(TableIntermediateState::Ejected),
                     ..ResetOptions::default()
                 })
                 .await?;

package/src/rust/{model → tasks}/get_viewer_config.rs

@@ -10,9 +10,6 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
-use perspective_client::config::ViewConfig;
-
-use super::columns_iter_set::*;
 use super::structural::*;
 use crate::config::*;
 use crate::*;
@@ -51,11 +48,3 @@ pub trait GetViewerConfigModel: HasSession + HasRenderer + HasPresentation {
 }
 
 impl<T: HasRenderer + HasSession + HasPresentation> GetViewerConfigModel for T {}
-
-pub trait ColumnIteratorModel: HasSession + HasRenderer + HasDragDrop {
-    fn column_selector_iter_set<'a>(&'a self, config: &'a ViewConfig) -> ColumnsIteratorSet<'a> {
-        ColumnsIteratorSet::new(config, self.session(), self.renderer(), self.dragdrop())
-    }
-}
-
-impl<T: HasSession + HasRenderer + HasDragDrop> ColumnIteratorModel for T {}

package/src/rust/{model → tasks}/intersection_observer.rs

@@ -16,10 +16,10 @@ use web_sys::*;
 
 use crate::config::ViewerConfigUpdate;
 use crate::js::*;
-use crate::model::*;
 use crate::presentation::Presentation;
 use crate::renderer::*;
 use crate::session::Session;
+use crate::tasks::*;
 use crate::utils::*;
 use crate::*;
 
@@ -71,18 +71,34 @@ impl Drop for IntersectionObserverHandle {
     }
 }
 
-#[derive(PerspectiveProperties!)]
 struct IntersectionObserverState {
     session: Session,
     renderer: Renderer,
     presentation: Presentation,
 }
 
+impl HasPresentation for IntersectionObserverState {
+    fn presentation(&self) -> &Presentation {
+        &self.presentation
+    }
+}
+
+impl HasRenderer for IntersectionObserverState {
+    fn renderer(&self) -> &Renderer {
+        &self.renderer
+    }
+}
+
+impl HasSession for IntersectionObserverState {
+    fn session(&self) -> &Session {
+        &self.session
+    }
+}
+
 impl IntersectionObserverState {
     async fn set_pause(self, intersect: bool) -> ApiResult<()> {
         if intersect {
             if self.session.set_pause(false) {
-                self.presentation.visibility_changed.emit(intersect);
                 self.restore_and_render(ViewerConfigUpdate::default(), async move { Ok(()) })
                     .await?;
             }

package/src/{less/containers/radio-list.less → rust/tasks/is_invalid_drop.rs}

@@ -10,20 +10,27 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
-:host {
-    .radio-list-item {
-        display: flex;
-        flex-wrap: wrap;
-        align-items: center;
+use perspective_client::config::ViewConfig;
 
-        // Fix radio buttons
-        input[type="radio"] {
-            width: 16px;
-            margin: 0 4px 0 0;
-        }
+/// Checks whether dropping `from_column` at `to_index` in the active columns
+/// list would be invalid (i.e. removing a required column to an empty slot).
+pub fn is_invalid_columns_column(
+    config: &ViewConfig,
+    min: Option<usize>,
+    from_column: &String,
+    to_index: usize,
+) -> bool {
+    let from_index = config
+        .columns
+        .iter()
+        .position(|x| x.as_ref() == Some(from_column));
 
-        input[type="radio"][disabled] ~ * {
-            opacity: 0.5;
-        }
-    }
+    let is_to_empty = !config
+        .columns
+        .get(to_index)
+        .map(|x| x.is_some())
+        .unwrap_or_default();
+    min.and_then(|x| from_index.map(|from_index| from_index < x))
+        .unwrap_or_default()
+        && is_to_empty
 }

package/src/rust/tasks/mod.rs

@@ -0,0 +1,52 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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 tasks and model traits for coordinating state between `Session`,
+//! `Renderer`, `Presentation`, and `DragDrop` singletons.
+//!
+//! Complex operations that span more than one state object are expressed as
+//! traits whose bounds name exactly the state objects they require (e.g.
+//! `UpdateAndRender: HasSession + HasRenderer`).  Blanket impls apply the
+//! trait to any struct that holds those fields and provides `Has*` accessors.
+
+mod column_locator;
+mod columns_iter_set;
+mod copy_export;
+mod edit_expression;
+mod eject;
+mod export_app;
+mod export_method;
+mod get_viewer_config;
+mod intersection_observer;
+mod is_invalid_drop;
+mod plugin_column_styles;
+mod resize_observer;
+mod restore_and_render;
+mod send_plugin_config;
+mod structural;
+mod update_and_render;
+
+pub use self::column_locator::*;
+pub use self::columns_iter_set::*;
+pub use self::copy_export::*;
+pub use self::edit_expression::*;
+pub use self::eject::*;
+pub use self::export_method::*;
+pub use self::get_viewer_config::*;
+pub use self::intersection_observer::*;
+pub use self::is_invalid_drop::is_invalid_columns_column;
+pub use self::plugin_column_styles::*;
+pub use self::resize_observer::*;
+pub use self::restore_and_render::*;
+pub use self::send_plugin_config::*;
+pub use self::structural::*;
+pub use self::update_and_render::*;

package/src/rust/{model → tasks}/plugin_column_styles.rs

@@ -11,64 +11,87 @@
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
 use itertools::Itertools;
+use perspective_client::config::ViewConfig;
 use perspective_js::utils::ApiResult;
 
 use super::{HasRenderer, HasSession};
 use crate::config::ColumnStyleOpts;
+use crate::renderer::Renderer;
+use crate::session::SessionMetadata;
 
-pub trait PluginColumnStyles: HasSession + HasRenderer {
-    /// This function will query the plugin to see if a given column can render
-    /// column styles.
-    fn can_render_column_styles(&self, column_name: &str) -> ApiResult<bool> {
-        let plugin = self.renderer().get_active_plugin()?;
-        let names: Vec<String> = plugin
-            .config_column_names()
-            .and_then(|jsarr| serde_wasm_bindgen::from_value(jsarr.into()).ok())
-            .unwrap_or_default();
+/// Queries the plugin to see if a given column can render column styles.
+pub fn can_render_column_styles(
+    renderer: &Renderer,
+    view_config: &ViewConfig,
+    metadata: &SessionMetadata,
+    column_name: &str,
+) -> ApiResult<bool> {
+    let plugin = renderer.get_active_plugin()?;
+    let names: Vec<String> = plugin
+        .config_column_names()
+        .and_then(|jsarr| serde_wasm_bindgen::from_value(jsarr.into()).ok())
+        .unwrap_or_default();
 
-        let group = self
-            .session()
-            .get_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 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 = self
-            .session()
-            .metadata()
-            .get_column_view_type(column_name)
-            .ok_or("Invalid column")?;
+    let view_type = metadata
+        .get_column_view_type(column_name)
+        .ok_or("Invalid column")?;
 
-        plugin.can_render_column_styles(&view_type.to_string(), group)
-    }
+    plugin.can_render_column_styles(&view_type.to_string(), group)
+}
 
-    /// Queries the plugins for the available plugin components.
-    fn get_column_style_control_options(&self, column_name: &str) -> ApiResult<ColumnStyleOpts> {
-        let plugin = self.renderer().get_active_plugin()?;
-        let names: Vec<String> = plugin
-            .config_column_names()
-            .and_then(|jsarr| serde_wasm_bindgen::from_value(jsarr.into()).ok())
-            .unwrap_or_default();
+/// Queries the plugin for the available style control options for a column.
+pub fn get_column_style_control_options(
+    renderer: &Renderer,
+    view_config: &ViewConfig,
+    metadata: &SessionMetadata,
+    column_name: &str,
+) -> ApiResult<ColumnStyleOpts> {
+    let plugin = renderer.get_active_plugin()?;
+    let names: Vec<String> = plugin
+        .config_column_names()
+        .and_then(|jsarr| serde_wasm_bindgen::from_value(jsarr.into()).ok())
+        .unwrap_or_default();
+
+    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 group = self
-            .session()
-            .get_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 = metadata
+        .get_column_view_type(column_name)
+        .ok_or("Invalid column")?;
 
-        let view_type = self
-            .session()
-            .metadata()
-            .get_column_view_type(column_name)
-            .ok_or("Invalid column")?;
+    let controls = plugin.column_style_controls(&view_type.to_string(), group)?;
+    serde_wasm_bindgen::from_value(controls).map_err(|e| e.into())
+}
+
+/// Trait facade — delegates to the standalone functions above.
+pub trait PluginColumnStyles: HasSession + HasRenderer {
+    fn can_render_column_styles(&self, column_name: &str) -> ApiResult<bool> {
+        can_render_column_styles(
+            self.renderer(),
+            &self.session().get_view_config(),
+            &self.session().metadata(),
+            column_name,
+        )
+    }
 
-        let controls = plugin.column_style_controls(&view_type.to_string(), group)?;
-        serde_wasm_bindgen::from_value(controls).map_err(|e| e.into())
+    fn get_column_style_control_options(&self, column_name: &str) -> ApiResult<ColumnStyleOpts> {
+        get_column_style_control_options(
+            self.renderer(),
+            &self.session().get_view_config(),
+            &self.session().metadata(),
+            column_name,
+        )
     }
 }