@perspective-dev/viewer 4.0.0

package/src/rust/presentation.rs

@@ -0,0 +1,370 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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::cell::RefCell;
+use std::collections::{HashMap, HashSet};
+use std::ops::Deref;
+use std::rc::Rc;
+
+use async_lock::Mutex;
+use perspective_js::utils::{ApiFuture, ApiResult, ToApiError, global};
+use wasm_bindgen::prelude::*;
+use web_sys::*;
+use yew::html::ImplicitClone;
+
+use crate::components::column_settings_sidebar::ColumnSettingsTab;
+use crate::components::viewer::ColumnLocator;
+use crate::config::{ColumnConfigUpdate, ColumnConfigValueUpdate, ColumnConfigValues};
+use crate::utils::*;
+
+/// The available themes as detected in the browser environment or set
+/// explicitly when CORS prevents detection.  Detection is expensive and
+/// typically must be performed only once, when `document.styleSheets` is
+/// up-to-date.
+#[derive(Clone)]
+pub struct Presentation(Rc<PresentationHandle>);
+
+impl PartialEq for Presentation {
+    fn eq(&self, other: &Self) -> bool {
+        Rc::ptr_eq(&self.0, &other.0)
+    }
+}
+
+impl Deref for Presentation {
+    type Target = PresentationHandle;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl ImplicitClone for Presentation {}
+
+#[derive(Clone, Default, Debug, PartialEq)]
+pub struct OpenColumnSettings {
+    pub locator: Option<ColumnLocator>,
+    pub tab: Option<ColumnSettingsTab>,
+}
+impl OpenColumnSettings {
+    pub fn name(&self) -> Option<String> {
+        self.locator
+            .as_ref()
+            .and_then(|l| l.name())
+            .map(|s| s.to_owned())
+    }
+}
+
+pub type ColumnConfigMap = HashMap<String, ColumnConfigValues>;
+
+pub struct PresentationHandle {
+    viewer_elem: HtmlElement,
+    theme_data: Mutex<ThemeData>,
+    name: RefCell<Option<String>>,
+    is_settings_open: RefCell<bool>,
+    open_column_settings: RefCell<OpenColumnSettings>,
+    is_workspace: RefCell<Option<bool>>,
+    columns_config: RefCell<ColumnConfigMap>,
+    pub settings_open_changed: PubSub<bool>,
+    pub column_settings_open_changed: PubSub<(bool, Option<String>)>,
+    pub column_settings_updated: PubSub<JsValue>,
+    pub theme_config_updated: PubSub<(Rc<Vec<String>>, Option<usize>)>,
+    pub title_changed: PubSub<Option<String>>,
+}
+
+#[derive(Default)]
+pub struct ThemeData {
+    themes: Option<Vec<String>>,
+}
+
+impl Presentation {
+    pub fn new(elem: &HtmlElement) -> Self {
+        let theme = Self(Rc::new(PresentationHandle {
+            viewer_elem: elem.clone(),
+            name: Default::default(),
+            theme_data: Default::default(),
+            settings_open_changed: Default::default(),
+            column_settings_open_changed: Default::default(),
+            column_settings_updated: Default::default(),
+            columns_config: Default::default(),
+            is_settings_open: Default::default(),
+            is_workspace: Default::default(),
+            open_column_settings: Default::default(),
+            theme_config_updated: PubSub::default(),
+            title_changed: PubSub::default(),
+        }));
+
+        ApiFuture::spawn(theme.clone().init());
+        theme
+    }
+
+    pub fn get_title(&self) -> Option<String> {
+        self.name.borrow().clone()
+    }
+
+    pub fn set_title(&self, title: Option<String>) {
+        self.name.borrow_mut().clone_from(&title);
+        self.title_changed.emit(title);
+    }
+
+    pub fn get_is_workspace(&self) -> bool {
+        if self.is_workspace.borrow().is_none() {
+            let is_workspace = self
+                .viewer_elem
+                .parent_element()
+                .map(|x| x.tag_name() == "PERSPECTIVE-WORKSPACE")
+                .unwrap_or_default();
+
+            *self.is_workspace.borrow_mut() = Some(is_workspace);
+        }
+
+        self.is_workspace.borrow().unwrap()
+    }
+
+    pub fn set_settings_attribute(&self, opt: bool) {
+        self.viewer_elem
+            .toggle_attribute_with_force("settings", opt)
+            .unwrap();
+    }
+
+    pub fn is_settings_open(&self) -> bool {
+        *self.is_settings_open.borrow()
+    }
+
+    pub fn set_settings_open(&self, open: Option<bool>) -> ApiResult<bool> {
+        let open_state = open.unwrap_or_else(|| !*self.is_settings_open.borrow());
+        if *self.is_settings_open.borrow() != open_state {
+            *self.is_settings_open.borrow_mut() = open_state;
+            self.set_settings_attribute(open_state);
+            self.settings_open_changed.emit(open_state);
+        }
+
+        Ok(open_state)
+    }
+
+    /// Sets the currently opened column settings. Emits an internal event on
+    /// change. Passing None is a shorthand for setting all fields to
+    /// None.
+    pub fn set_open_column_settings(&self, settings: Option<OpenColumnSettings>) {
+        let settings = settings.unwrap_or_default();
+        if *(self.open_column_settings.borrow()) != settings {
+            settings.clone_into(&mut *self.open_column_settings.borrow_mut());
+            self.column_settings_open_changed
+                .emit((true, settings.name()));
+        }
+    }
+
+    /// Gets a clone of the current OpenColumnSettings.
+    pub fn get_open_column_settings(&self) -> OpenColumnSettings {
+        self.open_column_settings.borrow().deref().clone()
+    }
+
+    async fn init(self) -> ApiResult<()> {
+        self.set_theme_attribute(self.get_selected_theme_name().await.as_deref())
+    }
+
+    /// Get the available theme names from the browser environment by parsing
+    /// readable stylesheets.  This method is memoized - the state can be
+    /// flushed by calling `reset()`.
+    pub async fn get_available_themes(&self) -> ApiResult<Rc<Vec<String>>> {
+        let mut data = self.0.theme_data.lock().await;
+        if data.themes.is_none() {
+            await_dom_loaded().await?;
+            let themes = get_theme_names(&self.0.viewer_elem)?;
+            data.themes = Some(themes);
+        }
+
+        Ok(data.themes.clone().unwrap().into())
+    }
+
+    /// Reset the state.  `styleSheets` will be re-parsed next time
+    /// `get_themes()` is called if the `themes` argument is `None`.
+    ///
+    /// # Returns
+    /// A `bool` indicating whether the internal state changed.
+    pub async fn reset_available_themes(&self, themes: Option<Vec<String>>) -> bool {
+        fn as_set(x: &Option<Vec<String>>) -> HashSet<&'_ String> {
+            x.as_ref()
+                .map(|x| x.iter().collect::<HashSet<_>>())
+                .unwrap_or_default()
+        }
+
+        let mut mutex = self.0.theme_data.lock().await;
+        let changed = as_set(&mutex.themes) != as_set(&themes);
+        mutex.themes = themes;
+        changed
+    }
+
+    pub async fn get_selected_theme_config(&self) -> ApiResult<(Rc<Vec<String>>, Option<usize>)> {
+        let themes = self.get_available_themes().await?;
+        let name = self.0.viewer_elem.get_attribute("theme");
+        let index = name
+            .and_then(|x| themes.iter().position(|y| y == &x))
+            .or(if !themes.is_empty() { Some(0) } else { None });
+
+        Ok((themes, index))
+    }
+
+    /// Returns the currently applied theme, or the default theme if no theme
+    /// has been set and themes are detected in the `document`, or `None` if
+    /// no themes are available.
+    pub async fn get_selected_theme_name(&self) -> Option<String> {
+        let (themes, index) = self.get_selected_theme_config().await.ok()?;
+        index.and_then(|x| themes.get(x).cloned())
+    }
+
+    fn set_theme_attribute(&self, theme: Option<&str>) -> ApiResult<()> {
+        if let Some(theme) = theme {
+            Ok(self.0.viewer_elem.set_attribute("theme", theme)?)
+        } else {
+            Ok(self.0.viewer_elem.remove_attribute("theme")?)
+        }
+    }
+
+    pub async fn reset_theme(&self) -> ApiResult<()> {
+        let themes = self.get_available_themes().await?;
+        let default_theme = themes.first().map(|x| x.as_str());
+        self.set_theme_name(default_theme).await?;
+        Ok(())
+    }
+
+    /// Set the theme by name, or `None` for the default theme.
+    ///
+    /// # Returns
+    /// A `bool` indicating whether the internal state changed.
+    pub async fn set_theme_name(&self, theme: Option<&str>) -> ApiResult<bool> {
+        let (themes, selected) = self.get_selected_theme_config().await?;
+        if let Some(x) = selected
+            && themes.get(x).map(|x| x.as_str()) == theme
+        {
+            return Ok(false);
+        }
+
+        let index = if let Some(theme) = theme {
+            self.set_theme_attribute(Some(theme))?;
+            themes.iter().position(|x| x == theme)
+        } else if !themes.is_empty() {
+            self.set_theme_attribute(themes.first().map(|x| x.as_str()))?;
+            Some(0)
+        } else {
+            self.set_theme_attribute(None)?;
+            None
+        };
+
+        self.theme_config_updated.emit((themes, index));
+        Ok(true)
+    }
+
+    /// Returns an owned copy of the curent column configuration map.
+    pub fn all_columns_configs(&self) -> ColumnConfigMap {
+        self.columns_config.borrow().clone()
+    }
+
+    pub fn reset_columns_configs(&self) {
+        *self.columns_config.borrow_mut() = ColumnConfigMap::new();
+    }
+
+    /// Gets a clone of the ColumnConfig for the given column name.
+    pub fn get_columns_config(&self, column_name: &str) -> Option<ColumnConfigValues> {
+        self.columns_config.borrow().get(column_name).cloned()
+    }
+
+    /// Updates the entire column config struct. (like from a restore() call)
+    pub fn update_columns_configs(&self, update: ColumnConfigUpdate) {
+        match update {
+            crate::config::OptionalUpdate::SetDefault => {
+                let mut config = self.columns_config.borrow_mut();
+                *config = HashMap::default()
+            },
+            crate::config::OptionalUpdate::Missing => {},
+            crate::config::OptionalUpdate::Update(update) => {
+                for (col_name, new_config) in update.into_iter() {
+                    self.columns_config
+                        .borrow_mut()
+                        .insert(col_name, new_config);
+                }
+            },
+        }
+    }
+
+    pub fn update_columns_config_value(
+        &self,
+        column_name: String,
+        update: ColumnConfigValueUpdate,
+    ) {
+        let mut config = self.columns_config.borrow_mut();
+        let value = config.remove(&column_name).unwrap_or_default();
+        let update = value.update(update);
+        if !update.is_empty() {
+            config.insert(column_name, update);
+        }
+    }
+}
+
+macro_rules! iter_index {
+    ($x:expr) => {
+        (0..$x.length()).map(|x| $x.item(x))
+    };
+}
+
+fn fill_rule_theme_names(
+    themes: &mut Vec<String>,
+    rule: &Option<CssRule>,
+    elem: &HtmlElement,
+) -> ApiResult<()> {
+    if let Some(rule) = rule.as_ref().into_apierror()?.dyn_ref::<CssStyleRule>() {
+        let txt = rule.selector_text();
+        if elem.matches(&txt)? {
+            let style = rule.style();
+            let x = (0..style.length()).map(|x| style.item(x));
+            for property in x {
+                if property == "--theme-name" {
+                    let name = style.get_property_value("--theme-name")?;
+                    let trimmed = name.trim();
+                    themes.push(trimmed[1..trimmed.len() - 1].to_owned());
+                }
+            }
+        }
+    }
+
+    Ok(())
+}
+
+fn fill_sheet_theme_names(
+    themes: &mut Vec<String>,
+    sheet: &Option<StyleSheet>,
+    elem: &HtmlElement,
+) -> ApiResult<()> {
+    let sheet = sheet
+        .as_ref()
+        .into_apierror()?
+        .unchecked_ref::<CssStyleSheet>();
+
+    if let Ok(rules) = sheet.css_rules() {
+        for rule in iter_index!(&rules) {
+            fill_rule_theme_names(themes, &rule, elem).unwrap_or_default();
+        }
+    }
+
+    Ok(())
+}
+
+/// Search the document's `styleSheets` for rules which apply to `elem` and
+/// provide the `--theme-name` CSS custom property.
+fn get_theme_names(elem: &HtmlElement) -> Result<Vec<String>, JsValue> {
+    let sheets = global::document().style_sheets();
+    let mut themes: Vec<String> = vec![];
+    for sheet in iter_index!(sheets) {
+        fill_sheet_theme_names(&mut themes, &sheet, elem)?;
+    }
+
+    Ok(themes)
+}

package/src/rust/renderer/activate.rs

@@ -0,0 +1,49 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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::future::Future;
+
+use perspective_js::utils::ApiResult;
+use wasm_bindgen::JsCast;
+use web_sys::*;
+
+use crate::js::plugin::JsPerspectiveViewerPlugin;
+
+/// Given an async `task` which draws `plugin`, activates the plugin in stages
+/// to prevent screen shearing.  First, and plugin is appended ot the DOM with
+/// opacity 0, then rendered.  After rendering, the previous plugin is removed
+/// and the opacity is set back to 1.
+///
+/// # Arguments
+/// - `viewer` the root `<perspective-viewer>` element.
+/// - `plugin` the plugin custom element.
+/// - `task` an async task which renders the plugin.
+pub async fn activate_plugin<T>(
+    viewer: &HtmlElement,
+    plugin: &JsPerspectiveViewerPlugin,
+    task: impl Future<Output = ApiResult<T>>,
+) -> ApiResult<T> {
+    let html_plugin = plugin.unchecked_ref::<HtmlElement>();
+    if html_plugin.parent_node().is_none() {
+        html_plugin.style().set_property("opacity", "0")?;
+        viewer.append_child(html_plugin)?;
+    }
+
+    let result = task.await;
+    let first_child = viewer.children().item(0).unwrap();
+    if first_child != *plugin.unchecked_ref::<Element>() {
+        viewer.remove_child(&first_child)?;
+    }
+
+    html_plugin.style().set_property("opacity", "1")?;
+    result
+}

package/src/rust/renderer/limits.rs

@@ -0,0 +1,200 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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_js::utils::ApiError;
+
+use crate::js::plugin::*;
+
+pub async fn get_row_and_col_limits(
+    view: &perspective_client::View,
+    plugin_metadata: &ViewConfigRequirements,
+) -> Result<(usize, usize, Option<usize>, Option<usize>), ApiError> {
+    let dimensions = view.dimensions().await?;
+    let num_cols = dimensions.num_view_columns as usize;
+    let num_rows = dimensions.num_view_rows as usize;
+    match (plugin_metadata.max_columns, plugin_metadata.render_warning) {
+        (Some(_), false) => Ok((num_cols, num_rows, None, None)),
+        (max_columns, _) => {
+            let schema = view.schema().await?;
+            let keys = schema.keys();
+            let num_schema_columns = std::cmp::max(1, keys.len() as usize);
+            let max_cols = max_columns.and_then(|max_columns| {
+                let column_group_diff = max_columns % num_schema_columns;
+                let column_limit = max_columns + column_group_diff;
+                if column_limit < num_cols {
+                    Some(column_limit)
+                } else {
+                    None
+                }
+            });
+
+            let max_rows = plugin_metadata.max_cells.map(|max_cells| {
+                match max_cols {
+                    Some(max_cols) => max_cells as f64 / max_cols as f64,
+                    None => max_cells as f64 / num_cols as f64,
+                }
+                .ceil() as usize
+            });
+
+            Ok((num_cols, num_rows, max_cols, max_rows))
+        },
+    }
+}
+
+// #[cfg(test)]
+// mod tests {
+//     use super::*;
+
+//     fn closure_helper<T>(x: T) -> Closure<dyn Fn(JsValue) -> js_sys::Promise>
+//     where
+//         T: Into<JsValue>,
+//     {
+//         let val = x.into();
+//         Closure::new(move |_: JsValue| {
+//             clone!(val);
+//             future_to_promise(async move { Ok(val.clone()) })
+//         })
+//     }
+
+//     #[wasm_bindgen_test]
+//     pub async fn test_emtpy_schema_no_columns() {
+//         let closure = closure_helper(0);
+//         let closure2 = closure_helper(json!({}));
+//         let view = json!({
+//             "num_columns": closure.as_ref().unchecked_ref::<JsValue>(),
+//             "num_rows": closure.as_ref().unchecked_ref::<JsValue>(),
+//             "schema": closure2.as_ref().unchecked_ref::<JsValue>()
+//         })
+//         .unchecked_into::<JsPerspectiveView>();
+
+//         let reqs = ViewConfigRequirements {
+//             render_warning: true,
+//             ..ViewConfigRequirements::default()
+//         };
+//         let (_, _, max_cols, max_rows) = get_row_and_col_limits(&view,
+// &reqs).await.unwrap();         assert_eq!(max_cols, None);
+//         assert_eq!(max_rows, None);
+//     }
+
+//     #[wasm_bindgen_test]
+//     pub async fn test_columns_do_not_exceed_max_columns() {
+//         let closure = closure_helper(1);
+//         let closure2 = closure_helper(0);
+//         let closure3 = closure_helper(json!({}));
+//         let view = json!({
+//             "num_columns": closure.as_ref().unchecked_ref::<JsValue>(),
+//             "num_rows": closure2.as_ref().unchecked_ref::<JsValue>(),
+//             "schema": closure3.as_ref().unchecked_ref::<JsValue>()
+//         })
+//         .unchecked_into::<JsPerspectiveView>();
+
+//         let reqs = ViewConfigRequirements {
+//             max_columns: Some(2),
+//             render_warning: true,
+//             ..ViewConfigRequirements::default()
+//         };
+
+//         let (_, _, max_cols, max_rows) = get_row_and_col_limits(&view,
+// &reqs).await.unwrap();         assert_eq!(max_cols, None);
+//         assert_eq!(max_rows, None);
+//     }
+
+//     #[wasm_bindgen_test]
+//     pub async fn test_columns_exceed_max_columns() {
+//         let closure = closure_helper(2);
+//         let closure2 = closure_helper(0);
+//         let closure3 = closure_helper(json!({}));
+//         let view = json!({
+//             "num_columns": closure.as_ref().unchecked_ref::<JsValue>(),
+//             "num_rows": closure2.as_ref().unchecked_ref::<JsValue>(),
+//             "schema": closure3.as_ref().unchecked_ref::<JsValue>()
+//         })
+//         .unchecked_into::<JsPerspectiveView>();
+
+//         let reqs = ViewConfigRequirements {
+//             max_columns: Some(1),
+//             render_warning: true,
+//             ..ViewConfigRequirements::default()
+//         };
+//         let (_, _, max_cols, max_rows) = get_row_and_col_limits(&view,
+// &reqs).await.unwrap();         assert_eq!(max_cols, Some(1));
+//         assert_eq!(max_rows, None);
+//     }
+
+//     #[wasm_bindgen_test]
+//     pub async fn test_when_schema_columns_are_present() {
+//         let closure = closure_helper(100);
+//         let closure2 = closure_helper(0);
+//         let closure3 = closure_helper(json!({"x": "string", "y": "string"}));
+//         let view = json!({
+//             "num_columns": closure.as_ref().unchecked_ref::<JsValue>(),
+//             "num_rows": closure2.as_ref().unchecked_ref::<JsValue>(),
+//             "schema": closure3.as_ref().unchecked_ref::<JsValue>()
+//         })
+//         .unchecked_into::<JsPerspectiveView>();
+
+//         let reqs = ViewConfigRequirements {
+//             max_columns: Some(3),
+//             render_warning: true,
+//             ..ViewConfigRequirements::default()
+//         };
+//         let (_, _, max_cols, max_rows) = get_row_and_col_limits(&view,
+// &reqs).await.unwrap();         assert_eq!(max_cols, Some(4));
+//         assert_eq!(max_rows, None);
+//     }
+
+//     #[wasm_bindgen_test]
+//     pub async fn test_when_max_cells_exits() {
+//         let closure = closure_helper(1);
+//         let closure2 = closure_helper(0);
+//         let closure3 = closure_helper(json!({}));
+//         let view = json!({
+//             "num_columns": closure.as_ref().unchecked_ref::<JsValue>(),
+//             "num_rows": closure2.as_ref().unchecked_ref::<JsValue>(),
+//             "schema": closure3.as_ref().unchecked_ref::<JsValue>()
+//         })
+//         .unchecked_into::<JsPerspectiveView>();
+
+//         let reqs = ViewConfigRequirements {
+//             max_cells: Some(2),
+//             render_warning: true,
+//             ..ViewConfigRequirements::default()
+//         };
+//         let (_, _, max_cols, max_rows) = get_row_and_col_limits(&view,
+// &reqs).await.unwrap();         assert_eq!(max_cols, None);
+//         assert_eq!(max_rows, Some(2));
+//     }
+
+//     #[wasm_bindgen_test]
+//     pub async fn test_when_columns_exceed_max_columns_and_max_cells_exists()
+// {         let closure = closure_helper(4);
+//         let closure2 = closure_helper(0);
+//         let closure3 = closure_helper(json!({}));
+//         let view = json!({
+//             "num_columns": closure.as_ref().unchecked_ref::<JsValue>(),
+//             "num_rows": closure2.as_ref().unchecked_ref::<JsValue>(),
+//             "schema": closure3.as_ref().unchecked_ref::<JsValue>()
+//         })
+//         .unchecked_into::<JsPerspectiveView>();
+
+//         let reqs = ViewConfigRequirements {
+//             max_columns: Some(2),
+//             max_cells: Some(10),
+//             render_warning: true,
+//             ..ViewConfigRequirements::default()
+//         };
+
+//         let (_, _, max_cols, max_rows) = get_row_and_col_limits(&view,
+// &reqs).await.unwrap();         assert_eq!(max_cols, Some(2));
+//         assert_eq!(max_rows, Some(5));
+//     }
+// }

package/src/rust/renderer/plugin_store.rs

@@ -0,0 +1,45 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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::HashMap;
+
+use super::registry::*;
+use crate::js::plugin::*;
+
+#[derive(Default)]
+pub struct PluginStore {
+    plugins: Option<Vec<JsPerspectiveViewerPlugin>>,
+    plugin_records: Option<HashMap<String, Vec<String>>>,
+}
+
+impl PluginStore {
+    fn init_lazy(&mut self) {
+        self.plugins = Some(PLUGIN_REGISTRY.create_plugins());
+        self.plugin_records = Some(PLUGIN_REGISTRY.available_plugin_names_by_category());
+    }
+
+    pub fn plugins(&mut self) -> &Vec<JsPerspectiveViewerPlugin> {
+        if self.plugins.is_none() {
+            self.init_lazy();
+        }
+
+        self.plugins.as_ref().unwrap()
+    }
+
+    pub fn plugin_records(&mut self) -> &HashMap<String, Vec<String>> {
+        if self.plugins.is_none() {
+            self.init_lazy();
+        }
+
+        self.plugin_records.as_ref().unwrap()
+    }
+}