@perspective-dev/viewer 4.2.0 → 4.4.0

package/src/rust/lib.rs

@@ -16,7 +16,6 @@
 // Required by yew's `html` macro.
 #![recursion_limit = "1024"]
 #![feature(const_type_name)]
-#![feature(macro_metavar_expr)]
 #![feature(iter_intersperse)]
 #![feature(stmt_expr_attributes)]
 #![feature(try_blocks)]
@@ -39,11 +38,12 @@ pub mod exprtk;
 mod js;
 mod root;
 
-#[doc(hidden)]
-pub mod model;
+pub mod engines;
 mod presentation;
 mod renderer;
 mod session;
+#[doc(hidden)]
+pub mod tasks;
 pub mod utils;
 
 #[macro_use]
@@ -67,6 +67,7 @@ import type {
     ColumnWindow,
     ViewWindow, 
     OnUpdateOptions,
+    JoinOptions,
     UpdateOptions,
     DeleteOptions,
     ViewConfigUpdate,
@@ -106,8 +107,8 @@ pub fn js_init() {
 pub fn bootstrap_web_components(psp: &JsValue) {
     define_web_component::<PerspectiveViewerElement>(psp);
     define_web_component::<PerspectiveDebugPluginElement>(psp);
-    define_web_component::<ExportDropDownMenuElement>(psp);
     define_web_component::<CopyDropDownMenuElement>(psp);
+    define_web_component::<ExportDropDownMenuElement>(psp);
 }
 
 /// Defining the web components needs an extern struct to reference the

package/src/rust/presentation/props.rs

@@ -0,0 +1,39 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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::presentation::OpenColumnSettings;
+use crate::utils::PtrEqRc;
+
+/// Value-semantic snapshot of the presentation/UI state used by the root
+/// component to drive `is_settings_open`, `selected_theme`, and
+/// `available_themes` into child components via plain props.
+///
+/// The `HtmlElement` handle, async theme-detection machinery, column-settings
+/// state, and per-column config live in `PresentationEngine` and are not
+/// passed as props.
+#[derive(Clone, Debug, PartialEq, Default)]
+pub struct PresentationProps {
+    /// Whether the settings panel is currently open.
+    pub is_settings_open: bool,
+
+    /// Detected theme names, in discovery order.
+    pub available_themes: PtrEqRc<Vec<String>>,
+
+    /// The currently selected theme name, if any theme is active.
+    pub selected_theme: Option<String>,
+
+    /// Snapshot of the currently opened column-settings sidebar state.
+    pub open_column_settings: OpenColumnSettings,
+
+    /// Whether this viewer is hosted inside a `<perspective-workspace>`.
+    pub is_workspace: bool,
+}

package/src/rust/presentation/sheets.rs

@@ -21,7 +21,7 @@ macro_rules! iter_index {
 }
 
 /// Search the document's `styleSheets` for rules which apply to `elem` and
-/// provide the `--theme-name` CSS custom property.
+/// provide the `--psp-theme-name` CSS custom property.
 pub fn get_theme_names(elem: &HtmlElement) -> Result<Vec<String>, JsValue> {
     let sheets = global::document().style_sheets();
     let mut themes: Vec<String> = vec![];
@@ -43,8 +43,8 @@ fn fill_rule_theme_names(
             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")?;
+                if property == "--psp-theme-name" {
+                    let name = style.get_property_value("--psp-theme-name")?;
                     let trimmed = name.trim();
                     let theme = &trimmed[1..trimmed.len() - 1];
                     if themes.iter().find(|x| x == &theme).is_none() {

package/src/rust/presentation.rs

@@ -11,6 +11,7 @@
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
 mod column_locator;
+mod props;
 mod sheets;
 
 use std::cell::RefCell;
@@ -20,11 +21,12 @@ use std::rc::Rc;
 
 use async_lock::Mutex;
 use perspective_js::utils::{ApiFuture, ApiResult};
-use wasm_bindgen::prelude::*;
 use web_sys::*;
 use yew::html::ImplicitClone;
+use yew::prelude::*;
 
 pub use self::column_locator::{ColumnLocator, ColumnSettingsTab, ColumnTab, OpenColumnSettings};
+pub use self::props::PresentationProps;
 use crate::config::{ColumnConfigUpdate, ColumnConfigValueUpdate, ColumnConfigValues};
 use crate::utils::*;
 
@@ -48,11 +50,13 @@ pub struct PresentationHandle {
     columns_config: RefCell<ColumnConfigMap>,
     is_workspace: RefCell<Option<bool>>,
     pub settings_open_changed: PubSub<bool>,
+
+    /// Injected callback from the root component, replacing the former
+    /// `is_workspace_changed: PubSub` field.
+    pub on_is_workspace_changed: RefCell<Option<Callback<bool>>>,
     pub settings_before_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 visibility_changed: PubSub<bool>,
+    pub theme_config_updated: PubSub<(PtrEqRc<Vec<String>>, Option<usize>)>,
     pub on_eject: PubSub<()>,
 }
 
@@ -86,13 +90,12 @@ impl Presentation {
             settings_open_changed: Default::default(),
             settings_before_open_changed: Default::default(),
             column_settings_open_changed: Default::default(),
-            column_settings_updated: Default::default(),
+            on_is_workspace_changed: Default::default(),
             columns_config: Default::default(),
             is_settings_open: Default::default(),
             open_column_settings: Default::default(),
             theme_config_updated: PubSub::default(),
             on_eject: PubSub::default(),
-            visibility_changed: PubSub::default(),
         }));
 
         ApiFuture::spawn(theme.clone().init());
@@ -110,6 +113,13 @@ impl Presentation {
         elem.is_some() && &self.viewer_elem.shadow_root().unwrap().active_element() == elem
     }
 
+    pub fn reset_attached(&self) {
+        *self.0.is_workspace.borrow_mut() = None;
+        if let Some(cb) = self.on_is_workspace_changed.borrow().as_ref() {
+            cb.emit(self.get_is_workspace());
+        }
+    }
+
     pub fn get_is_workspace(&self) -> bool {
         if self.is_workspace.borrow().is_none() {
             if !self.viewer_elem.is_connected() {
@@ -174,7 +184,7 @@ impl Presentation {
     /// 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>>> {
+    pub async fn get_available_themes(&self) -> ApiResult<PtrEqRc<Vec<String>>> {
         let mut data = self.0.theme_data.lock().await;
         if data.themes.is_none() {
             await_dom_loaded().await?;
@@ -203,7 +213,9 @@ impl Presentation {
         changed
     }
 
-    pub async fn get_selected_theme_config(&self) -> ApiResult<(Rc<Vec<String>>, Option<usize>)> {
+    pub async fn get_selected_theme_config(
+        &self,
+    ) -> ApiResult<(PtrEqRc<Vec<String>>, Option<usize>)> {
         let themes = self.get_available_themes().await?;
         let name = self.0.viewer_elem.get_attribute("theme");
         let index = name
@@ -308,4 +320,28 @@ impl Presentation {
             config.insert(column_name, update);
         }
     }
+
+    /// Snapshot the current presentation state as a [`PresentationProps`]
+    /// value suitable for passing as a Yew prop.  Called by the root component
+    /// whenever a presentation-related PubSub event fires.
+    ///
+    /// `available_themes` must be provided by the caller because theme
+    /// detection is async and therefore not available synchronously here.
+    pub fn to_props(&self, available_themes: PtrEqRc<Vec<String>>) -> PresentationProps {
+        let theme_attr = self.0.viewer_elem.get_attribute("theme");
+        let selected_theme = theme_attr.as_deref().and_then(|name| {
+            available_themes
+                .iter()
+                .find(|x| x.as_str() == name)
+                .cloned()
+        });
+
+        PresentationProps {
+            is_settings_open: self.is_settings_open(),
+            available_themes,
+            selected_theme,
+            open_column_settings: self.get_open_column_settings(),
+            is_workspace: self.get_is_workspace(),
+        }
+    }
 }

package/src/rust/renderer/limits.rs

@@ -14,15 +14,38 @@ use perspective_js::utils::ApiError;
 
 use crate::js::plugin::*;
 
+/// The row/column limits computed for the current view and plugin
+/// configuration.
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct RenderLimits {
+    /// Whether this render was an incremental update (`true`) or a full
+    /// draw (`false`).
+    pub is_update: bool,
+    /// Total number of columns in the view.
+    pub num_cols: usize,
+    /// Total number of rows in the view.
+    pub num_rows: usize,
+    /// Maximum number of columns the plugin will render, if capped.
+    pub max_cols: Option<usize>,
+    /// Maximum number of rows the plugin will render, if capped.
+    pub max_rows: Option<usize>,
+}
+
 pub async fn get_row_and_col_limits(
     view: &perspective_client::View,
     plugin_metadata: &ViewConfigRequirements,
-) -> Result<(usize, usize, Option<usize>, Option<usize>), ApiError> {
+) -> Result<RenderLimits, 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)),
+        (Some(_), false) => Ok(RenderLimits {
+            is_update: false,
+            num_cols,
+            num_rows,
+            max_cols: None,
+            max_rows: None,
+        }),
         (max_columns, _) => {
             let schema = view.schema().await?;
             let keys = schema.keys();
@@ -45,7 +68,13 @@ pub async fn get_row_and_col_limits(
                 .ceil() as usize
             });
 
-            Ok((num_cols, num_rows, max_cols, max_rows))
+            Ok(RenderLimits {
+                is_update: false,
+                num_cols,
+                num_rows,
+                max_cols,
+                max_rows,
+            })
         },
     }
 }

package/src/{less/dom/scrollbar.less → rust/renderer/props.rs}

@@ -10,26 +10,25 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
-@mixin scrollbar {
-    &:hover {
-        --fix: ;
-    }
+use crate::js::plugin::ViewConfigRequirements;
+use crate::renderer::limits::RenderLimits;
+use crate::utils::PtrEqRc;
 
-    &::-webkit-scrollbar-thumb {
-        border-radius: 2px;
-        border: 2px solid transparent;
-        box-shadow: inset 0px 0px 0 4px var(--inactive--color);
-    }
+/// Value-semantic snapshot of the renderer state read by components.
+///
+/// The actual plugin JS objects, draw lock, and render timer live in
+/// `RendererEngine` and are not passed as props.
+#[derive(Clone, Debug, PartialEq, Default)]
+pub struct RendererProps {
+    /// Name of the currently active plugin (e.g. `"Datagrid"`).
+    pub plugin_name: Option<String>,
 
-    &:hover::-webkit-scrollbar-thumb {
-        border: 1px solid transparent;
-        box-shadow: inset 0px 0px 0 4px var(--inactive--color);
-    }
+    /// Column count / config requirements reported by the active plugin.
+    pub requirements: ViewConfigRequirements,
 
-    &::-webkit-scrollbar,
-    &::-webkit-scrollbar-corner {
-        background-color: transparent;
-        width: 6px;
-        height: 6px;
-    }
+    /// Most recently emitted render limits, if any.
+    pub render_limits: Option<RenderLimits>,
+
+    /// Names of all registered plugins, in registration order.
+    pub available_plugins: PtrEqRc<Vec<String>>,
 }

package/src/rust/renderer/registry.rs

@@ -102,7 +102,14 @@ pub impl LocalKey<Rc<RefCell<Vec<PluginRecord>>>> {
                     .unwrap_or_else(|| "Custom".to_owned()),
                 priority: plugin_inst.priority().unwrap_or_default(),
             };
+
             let mut plugins = plugin.borrow_mut();
+            if let Some(first) = plugins.first()
+                && first.tag_name.as_str() == "perspective-viewer-plugin"
+            {
+                plugins.clear();
+            }
+
             plugins.push(record);
             plugins.sort_by(|a, b| Ord::cmp(&b.priority, &a.priority));
         });
@@ -121,7 +128,7 @@ fn register_default() {
                 name: "Debug".to_owned(),
                 category: "Custom".to_owned(),
                 tag_name: "perspective-viewer-plugin".to_owned(),
-                priority: 0,
+                priority: -1,
             })
         }
     })

package/src/rust/renderer.rs

@@ -18,8 +18,9 @@
 //! references throughout the application.
 
 mod activate;
-mod limits;
+pub mod limits;
 mod plugin_store;
+mod props;
 mod registry;
 mod render_timer;
 
@@ -38,10 +39,13 @@ use perspective_js::utils::ApiResult;
 use wasm_bindgen::prelude::*;
 use web_sys::*;
 use yew::html::ImplicitClone;
+use yew::prelude::*;
 
 use self::activate::*;
+pub use self::limits::RenderLimits;
 use self::limits::*;
 use self::plugin_store::*;
+pub use self::props::RendererProps;
 pub use self::registry::*;
 use self::render_timer::*;
 use crate::config::*;
@@ -54,9 +58,13 @@ pub struct RendererData {
     plugin_data: RefCell<RendererMutData>,
     draw_lock: DebounceMutex,
     pub plugin_changed: PubSub<JsPerspectiveViewerPlugin>,
-    pub render_limits_changed: PubSub<(bool, RenderLimits)>,
     pub style_changed: PubSub<()>,
     pub reset_changed: PubSub<()>,
+
+    /// Injected callback from the root component, replacing the former
+    /// `render_limits_changed: PubSub` field.  Fires after every draw/update
+    /// with the computed render limits.
+    pub on_render_limits_changed: RefCell<Option<Callback<RenderLimits>>>,
 }
 
 /// Mutable state
@@ -70,8 +78,6 @@ pub struct RendererMutData {
     pending_plugin: Option<usize>,
 }
 
-type RenderLimits = (usize, usize, Option<usize>, Option<usize>);
-
 /// The state object responsible for the active [`JsPerspectiveViewerPlugin`].
 #[derive(Clone)]
 pub struct Renderer(Rc<RendererData>);
@@ -120,9 +126,9 @@ impl Renderer {
             }),
             draw_lock: Default::default(),
             plugin_changed: Default::default(),
-            render_limits_changed: Default::default(),
             style_changed: Default::default(),
             reset_changed: Default::default(),
+            on_render_limits_changed: Default::default(),
         }))
     }
 
@@ -322,6 +328,31 @@ impl Renderer {
             .await
     }
 
+    pub async fn resize_with_dimensions(&self, width: f64, height: f64) -> ApiResult<()> {
+        let draw_mutex = self.draw_lock();
+        let timer = self.render_timer();
+        draw_mutex
+            .debounce(async {
+                set_timeout(timer.get_throttle()).await?;
+                let plugin = self.get_active_plugin()?;
+                let main_panel: &web_sys::HtmlElement = plugin.unchecked_ref();
+                let rect = main_panel.get_bounding_client_rect();
+                if (height - rect.height()).abs() > 0.5 || (width - rect.width()).abs() > 0.5 {
+                    let new_width = format!("{}px", width);
+                    let new_height = format!("{}px", height);
+                    main_panel.style().set_property("width", &new_width)?;
+                    main_panel.style().set_property("height", &new_height)?;
+                    let result = plugin.resize().await;
+                    main_panel.style().set_property("width", "")?;
+                    main_panel.style().set_property("height", "")?;
+                    result?;
+                }
+
+                Ok(())
+            })
+            .await
+    }
+
     /// This will take a future which _should_ create a new view and then will
     /// draw it. As the `session` closure is asynchronous, it can be cancelled
     /// by returning `None`.
@@ -367,14 +398,17 @@ impl Renderer {
     async fn draw_view(&self, view: &perspective_client::View, is_update: bool) -> ApiResult<()> {
         let plugin = self.get_active_plugin()?;
         let meta = self.metadata().clone();
-        let limits = get_row_and_col_limits(view, &meta).await?;
-        self.render_limits_changed.emit((is_update, limits));
+        let mut limits = get_row_and_col_limits(view, &meta).await?;
+        limits.is_update = is_update;
+        if let Some(cb) = self.0.on_render_limits_changed.borrow().as_ref() {
+            cb.emit(limits);
+        }
         let viewer_elem = &self.0.borrow().viewer_elem.clone();
         if is_update {
-            let task = plugin.update(view.clone().into(), limits.2, limits.3, false);
+            let task = plugin.update(view.clone().into(), limits.max_cols, limits.max_rows, false);
             activate_plugin(viewer_elem, &plugin, task).await?;
         } else {
-            let task = plugin.draw(view.clone().into(), limits.2, limits.3, false);
+            let task = plugin.draw(view.clone().into(), limits.max_cols, limits.max_rows, false);
             activate_plugin(viewer_elem, &plugin, task).await?;
         }
 
@@ -477,3 +511,43 @@ fn make_short_name(name: &str) -> String {
         .filter(|x| x.is_alphabetic())
         .collect()
 }
+
+impl Renderer {
+    /// Snapshot the current renderer state as a [`RendererProps`] value
+    /// suitable for passing as a Yew prop.  Called by the root component
+    /// whenever a renderer-related PubSub event fires.
+    pub fn to_props(&self, render_limits: Option<RenderLimits>) -> RendererProps {
+        // Guard: don't touch the PluginStore if no plugin has been explicitly
+        // selected yet.  Calling `get_active_plugin()` or `get_all_plugins()`
+        // triggers `PluginStore::init_lazy()`, which snapshots the
+        // PLUGIN_REGISTRY.  If this happens during component `create()` —
+        // before JavaScript has called `registerPlugin()` — the cache will
+        // only contain the default Debug plugin and custom plugins registered
+        // later will never be found.
+        let has_plugin = self.0.borrow().plugins_idx.is_some();
+        if has_plugin {
+            let plugin_name = self.get_active_plugin().ok().map(|p| p.name());
+            let requirements = self.metadata().clone();
+            let available_plugins = self
+                .get_all_plugins()
+                .into_iter()
+                .map(|p| p.name())
+                .collect::<Vec<_>>()
+                .into();
+
+            RendererProps {
+                plugin_name,
+                requirements,
+                render_limits,
+                available_plugins,
+            }
+        } else {
+            RendererProps {
+                plugin_name: None,
+                requirements: ViewConfigRequirements::default(),
+                render_limits,
+                available_plugins: PtrEqRc::new(vec![]),
+            }
+        }
+    }
+}

package/src/rust/session/column_defaults_update.rs

@@ -31,6 +31,24 @@ pub impl ViewConfigUpdate {
         columns: &[Option<String>],
         requirements: &ViewConfigRequirements,
     ) {
+        let rollup_features = metadata
+            .get_features()
+            .map(|x| x.get_group_rollup_modes())
+            .unwrap_or_default();
+
+        let group_rollups = requirements.get_group_rollups(&rollup_features);
+        if !group_rollups.contains(
+            self.group_rollup_mode
+                .as_ref()
+                .unwrap_or(&GroupRollupMode::Rollup),
+        ) {
+            self.group_rollup_mode = group_rollups.first().cloned();
+            tracing::debug!(
+                "Setting plugin-advised rollup mode {:?}",
+                self.group_rollup_mode
+            );
+        }
+
         if let (
             None,
             ViewConfigRequirements {

package/src/rust/session/metadata.rs

@@ -17,8 +17,10 @@ use std::ops::{Deref, DerefMut};
 use perspective_client::config::*;
 use perspective_js::apierror;
 
+use crate::utils::PtrEqRc;
 use crate::*;
 
+#[derive(Clone, PartialEq)]
 struct SessionViewExpressionMetadata {
     edited: HashMap<String, String>,
     expressions: perspective_client::ExprValidationResult,
@@ -28,9 +30,17 @@ struct SessionViewExpressionMetadata {
 /// do so without `async`.  It must be recreated by any `async` method which
 /// changes the `View` and may temporarily be out-of-sync with the
 /// `View`/`ViewConfig`.
-#[derive(Default)]
+#[derive(Clone, Default, PartialEq)]
 pub struct SessionMetadata(Option<SessionMetadataState>);
 
+pub type SessionMetadataRc = PtrEqRc<SessionMetadata>;
+
+impl std::fmt::Debug for SessionMetadata {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str("SessionMetadata { .. }")
+    }
+}
+
 impl Deref for SessionMetadata {
     type Target = Option<SessionMetadataState>;
 
@@ -50,7 +60,7 @@ pub type MetadataMutRef<'a> = std::cell::RefMut<'a, SessionMetadata>;
 
 /// TODO the multiple `Option` types could probably be merged since they are
 /// populated within an async lock
-#[derive(Default)]
+#[derive(Clone, Default, PartialEq)]
 pub struct SessionMetadataState {
     features: perspective_client::Features,
     column_names: Vec<String>,
@@ -118,6 +128,17 @@ impl SessionMetadata {
 
     /// Returns the unique column names in this session that are expression
     /// columns.
+    pub fn get_expression_schema(&self) -> Option<&HashMap<String, ColumnType>> {
+        Some(
+            &self
+                .as_ref()?
+                .expr_meta
+                .as_ref()?
+                .expressions
+                .expression_schema,
+        )
+    }
+
     pub fn get_expression_columns(&self) -> impl Iterator<Item = &'_ String> {
         maybe!(Some(
             self.as_ref()?