@perspective-dev/viewer 4.0.0 → 4.1.0

package/src/rust/model/edit_expression.rs

@@ -14,20 +14,17 @@ use perspective_client::config::{Expression, ViewConfigUpdate};
 
 use super::UpdateAndRender;
 use super::structural::*;
-use crate::components::column_settings_sidebar::ColumnSettingsTab;
-use crate::components::viewer::ColumnLocator;
-use crate::presentation::{OpenColumnSettings, Presentation};
+use crate::presentation::{ColumnLocator, ColumnSettingsTab, OpenColumnSettings, Presentation};
 use crate::renderer::Renderer;
 use crate::session::Session;
 use crate::*;
 
-#[derive(PartialEq)]
+#[derive(PartialEq, PerspectiveProperties!)]
 pub struct ExpressionUpdater {
     presentation: Presentation,
     renderer: Renderer,
     session: Session,
 }
-derive_model!(Presentation, Renderer, Session for ExpressionUpdater);
 
 pub trait EditExpression: HasPresentation + HasRenderer + HasSession + UpdateAndRender {
     fn get_expression_updater(&self) -> ExpressionUpdater {

package/src/rust/model/eject.rs

@@ -0,0 +1,41 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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::clone;
+use yew::Component;
+
+use super::{HasRenderer, HasSession};
+use crate::ApiFuture;
+use crate::root::Root;
+use crate::session::ResetOptions;
+
+pub trait DeleteAll: HasSession + HasRenderer {
+    fn delete_all<T: Component>(&self, root: &Root<T>) -> ApiFuture<()> {
+        self.session().table_unloaded.emit(false);
+        clone!(self.renderer(), self.session(), root);
+        ApiFuture::new(self.renderer().clone().with_lock(async move {
+            renderer.delete()?;
+            root.borrow_mut().take().ok_or("Already deleted")?.destroy();
+            session
+                .reset(ResetOptions {
+                    config: true,
+                    expressions: true,
+                    table: true,
+                    ..ResetOptions::default()
+                })
+                .await?;
+            Ok(())
+        }))
+    }
+}
+
+impl<T: HasSession + HasRenderer> DeleteAll for T {}

package/src/rust/model/export_app.rs

@@ -16,9 +16,10 @@ static VERSION: &str = env!("CARGO_PKG_VERSION");
 
 fn render_plugin(tag_name: impl AsRef<str>) -> String {
     format!(
-        "import \"https://cdn.jsdelivr.net/npm/@perspective-dev/{0}@{1}/dist/cdn/{0}.js\";\n",
+        "import \"https://cdn.jsdelivr.net/npm/@perspective-dev/{0}@{1}/dist/cdn/{2}.js\";\n",
+        tag_name.as_ref().replace("perspective-", ""),
+        VERSION,
         tag_name.as_ref(),
-        VERSION
     )
 }
 

package/src/rust/model/get_viewer_config.rs

@@ -15,9 +15,6 @@ use perspective_client::config::ViewConfig;
 use super::columns_iter_set::*;
 use super::structural::*;
 use crate::config::*;
-use crate::presentation::Presentation;
-use crate::renderer::*;
-use crate::session::*;
 use crate::*;
 
 /// A `ViewerConfig` is constructed from various properties acrosss the
@@ -27,21 +24,7 @@ use crate::*;
 /// `GetViewerConfigModel` provides methods which should be used to get the
 /// applications `ViewerConfig` from across these state objects.
 pub trait GetViewerConfigModel: HasSession + HasRenderer + HasPresentation {
-    /// As these methods are asynchronous, it is commonly useful to be able to
-    /// discretely `.clone()` the state objects for dispatching to `async`.
-    ///
-    /// Calling `.cloned()` yields just the state object clones of
-    /// `GetViewerConfigModel` which itself implements this trait and other
-    /// `crate::model` traits.
-    fn cloned(&self) -> GetViewerConfigModelCloned {
-        GetViewerConfigModelCloned {
-            renderer: self.renderer().clone(),
-            session: self.session().clone(),
-            presentation: self.presentation().clone(),
-        }
-    }
-
-    /// Get the current ViewerConfig
+    /// Get the current [`ViewerConfig`]`
     async fn get_viewer_config(&self) -> ApiResult<ViewerConfig> {
         let version = config::API_VERSION.to_string();
         let view_config = self.session().get_view_config().clone();
@@ -50,7 +33,8 @@ pub trait GetViewerConfigModel: HasSession + HasRenderer + HasPresentation {
         let plugin = js_plugin.name();
         let plugin_config: serde_json::Value = js_plugin.save()?.into_serde_ext()?;
         let theme = self.presentation().get_selected_theme_name().await;
-        let title = self.presentation().get_title();
+        let title = self.session().get_title();
+        let table = self.session().get_table().map(|x| x.get_name().to_owned());
         let columns_config = self.presentation().all_columns_configs();
         Ok(ViewerConfig {
             version,
@@ -59,6 +43,7 @@ pub trait GetViewerConfigModel: HasSession + HasRenderer + HasPresentation {
             plugin_config,
             columns_config,
             settings,
+            table,
             view_config,
             theme,
         })
@@ -67,15 +52,6 @@ pub trait GetViewerConfigModel: HasSession + HasRenderer + HasPresentation {
 
 impl<T: HasRenderer + HasSession + HasPresentation> GetViewerConfigModel for T {}
 
-#[derive(Clone)]
-pub struct GetViewerConfigModelCloned {
-    renderer: Renderer,
-    session: Session,
-    presentation: Presentation,
-}
-
-derive_model!(Renderer, Session, Presentation for GetViewerConfigModelCloned);
-
 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())

package/src/rust/model/intersection_observer.rs

@@ -10,13 +10,14 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
-use perspective_client::config::ViewConfigUpdate;
 use wasm_bindgen::JsCast;
 use wasm_bindgen::prelude::*;
 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::utils::*;
@@ -29,16 +30,25 @@ pub struct IntersectionObserverHandle {
 }
 
 impl IntersectionObserverHandle {
-    pub fn new(elem: &HtmlElement, session: &Session, renderer: &Renderer) -> Self {
-        clone!(session, renderer);
+    pub fn new(
+        elem: &HtmlElement,
+        presentation: &Presentation,
+        session: &Session,
+        renderer: &Renderer,
+    ) -> Self {
+        clone!(session, renderer, presentation);
         let _callback = Closure::new(move |xs: js_sys::Array| {
             let intersect = xs
                 .get(0)
                 .unchecked_into::<IntersectionObserverEntry>()
                 .is_intersecting();
 
-            clone!(session, renderer);
-            let state = IntersectionObserverState { session, renderer };
+            clone!(session, renderer, presentation);
+            let state = IntersectionObserverState {
+                presentation,
+                session,
+                renderer,
+            };
             ApiFuture::spawn(state.set_pause(intersect));
         });
 
@@ -59,16 +69,20 @@ impl Drop for IntersectionObserverHandle {
     }
 }
 
+#[derive(PerspectiveProperties!)]
 struct IntersectionObserverState {
     session: Session,
     renderer: Renderer,
+    presentation: Presentation,
 }
 
 impl IntersectionObserverState {
     async fn set_pause(self, intersect: bool) -> ApiResult<()> {
         if intersect {
             if self.session.set_pause(false) {
-                self.update_and_render(ViewConfigUpdate::default())?.await?;
+                self.presentation.visibility_changed.emit(intersect);
+                self.restore_and_render(ViewerConfigUpdate::default(), async move { Ok(()) })
+                    .await?;
             }
         } else {
             self.session.set_pause(true);
@@ -77,5 +91,3 @@ impl IntersectionObserverState {
         Ok(())
     }
 }
-
-derive_model!(Renderer, Session for IntersectionObserverState);

package/src/rust/model/mod.rs

@@ -30,23 +30,22 @@
 //! # Examples
 //!
 //! ```rust
+//! #[derive(PerspectiveProperties!)]
 //! struct A {
 //!     session: Session,
 //! }
 //!
+//! #[derive(PerspectiveProperties!)]
 //! struct B {
 //!     renderer: Renderer,
 //! }
 //!
+//! #[derive(PerspectiveProperties!)]
 //! struct C {
 //!     session: Session,
 //!     renderer: Renderer,
 //! }
 //!
-//! derive_model!(Session for A);
-//! derive_model!(Renderer for B);
-//! derive_model!(Session, Renderer for C);
-//!
 //! trait SessionRenderModel: HasSession + HasRenderer {
 //!     fn render_session_now(&self) {
 //!         // Do some thing that requires `.session()` and `.renderer()`
@@ -65,29 +64,37 @@
 //! }
 //! ```
 
+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 reset_all;
 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::*;
 pub use self::plugin_column_styles::*;
+pub use self::reset_all::*;
 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/plugin_column_styles.rs

@@ -15,39 +15,8 @@ use perspective_js::utils::ApiResult;
 
 use super::{HasRenderer, HasSession};
 use crate::config::ColumnStyleOpts;
-use crate::derive_model;
-use crate::renderer::Renderer;
-use crate::session::Session;
-
-// TODO: This pattern of creating query objects to pass around would be
-// redundant if we had a grab-bag of models to clone around.
-// We could easily generate all the needed types for this in a proc_macro
-// crate. e.g. create structs like `SessionAndRendererModel {session,
-// renderer}` which are then called through a proc_macro like
-// `get_model!(Session, Renderer for self)` where the function is defined as
-// `get_model! => {($($name:ty),+ for $owner:ident)}`
-//
-// Or, we could just lump
-// all the state into a single object where all these model functions are
-// defined. Generally, we could keep the hub-and-spoke architecture "under the
-// hood", but just not expose it to the yew framework, since it requires a lot
-// of unecessary prop-drilling and complexity.
-
-#[derive(Clone)]
-pub struct PluginColumnStylesQuery {
-    session: Session,
-    renderer: Renderer,
-}
-derive_model!(Session, Renderer for PluginColumnStylesQuery);
 
 pub trait PluginColumnStyles: HasSession + HasRenderer {
-    fn get_plugin_column_styles_query(&self) -> PluginColumnStylesQuery {
-        PluginColumnStylesQuery {
-            session: self.session().clone(),
-            renderer: self.renderer().clone(),
-        }
-    }
-
     /// 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> {

package/src/rust/model/reset_all.rs

@@ -0,0 +1,38 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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 super::structural::*;
+use crate::session::ResetOptions;
+use crate::utils::*;
+use crate::*;
+
+pub trait ResetAll: HasRenderer + HasSession + HasPresentation {
+    /// Completely reset viewer state
+    fn reset_all(&self) -> ApiFuture<()> {
+        clone!(self.session(), self.renderer(), self.presentation());
+        ApiFuture::new(async move {
+            session
+                .reset(ResetOptions {
+                    config: true,
+                    expressions: true,
+                    ..ResetOptions::default()
+                })
+                .await?;
+            presentation.reset_columns_configs();
+            renderer.reset(None).await?;
+            presentation.reset_available_themes(None).await;
+            Ok(())
+        })
+    }
+}
+
+impl<T: HasRenderer + HasSession + HasPresentation> ResetAll for T {}

package/src/rust/model/resize_observer.rs

@@ -16,9 +16,13 @@ use wasm_bindgen::prelude::*;
 use web_sys::*;
 use yew::prelude::*;
 
+use crate::PerspectiveProperties;
 use crate::components::viewer::{PerspectiveViewer, PerspectiveViewerMsg};
 use crate::js::*;
+use crate::model::*;
 use crate::renderer::*;
+use crate::root::Root;
+use crate::session::Session;
 use crate::utils::*;
 
 pub struct ResizeObserverHandle {
@@ -31,20 +35,26 @@ impl ResizeObserverHandle {
     pub fn new(
         elem: &HtmlElement,
         renderer: &Renderer,
-        root: &AppHandle<PerspectiveViewer>,
+        session: &Session,
+        root: &Root<PerspectiveViewer>,
     ) -> Self {
-        let on_resize = root.callback(|()| PerspectiveViewerMsg::Resize);
+        let on_resize = root
+            .borrow()
+            .as_ref()
+            .unwrap()
+            .callback(|()| PerspectiveViewerMsg::Resize);
+
         let mut state = ResizeObserverState {
             elem: elem.clone(),
             renderer: renderer.clone(),
+            session: session.clone(),
             width: elem.offset_width(),
             height: elem.offset_height(),
             on_resize,
         };
 
-        let _callback = Closure::new(move |xs| state.on_resize(&xs));
-        let func = _callback.as_ref().unchecked_ref::<js_sys::Function>();
-        let observer = ResizeObserver::new(func);
+        let _callback = Closure::new(move |xs: js_sys::Array| state.on_resize(&xs));
+        let observer = ResizeObserver::new(_callback.as_ref().unchecked_ref::<js_sys::Function>());
         observer.observe(elem);
         Self {
             elem: elem.clone(),
@@ -60,9 +70,11 @@ impl Drop for ResizeObserverHandle {
     }
 }
 
+#[derive(PerspectiveProperties!)]
 struct ResizeObserverState {
     elem: HtmlElement,
     renderer: Renderer,
+    session: Session,
     width: i32,
     height: i32,
     on_resize: Callback<()>,
@@ -83,9 +95,24 @@ impl ResizeObserverState {
             let content_height = content.height().floor() as i32;
             let resized = self.width != content_width || self.height != content_height;
             if resized && is_visible {
-                clone!(self.on_resize, self.renderer);
+                let state = self.clone_state();
+                clone!(self.on_resize);
                 ApiFuture::spawn(async move {
-                    renderer.resize().await?;
+                    let needs_render = state
+                        .renderer()
+                        .clone()
+                        .with_lock(async {
+                            Ok(!state.renderer().is_plugin_activated()?
+                                && state.session().has_table())
+                        })
+                        .await?;
+
+                    if needs_render {
+                        state.update_and_render(Default::default())?.await?;
+                    } else {
+                        state.renderer().resize().await?;
+                    }
+
                     on_resize.emit(());
                     Ok(())
                 });

package/src/rust/model/restore_and_render.rs

@@ -35,16 +35,15 @@ pub trait RestoreAndRender: HasRenderer + HasSession + HasPresentation {
     ) -> ApiFuture<()> {
         clone!(self.session(), self.renderer(), self.presentation());
         ApiFuture::new(async move {
-            if !session.has_table()
-                && let OptionalUpdate::Update(x) = settings
-            {
+            if let OptionalUpdate::Update(x) = settings {
                 presentation.set_settings_attribute(x);
+                presentation.set_settings_before_open(x);
             }
 
             if let OptionalUpdate::Update(title) = title {
-                presentation.set_title(Some(title));
+                session.set_title(Some(title));
             } else if matches!(title, OptionalUpdate::SetDefault) {
-                presentation.set_title(None);
+                session.set_title(None);
             }
 
             let needs_restyle = match theme_name {
@@ -93,17 +92,23 @@ pub trait RestoreAndRender: HasRenderer + HasSession + HasPresentation {
                     return Err(error);
                 }
 
-                session.validate().await?.create_view().await
+                let view = session.validate().await?.create_view().await;
+                if !presentation.is_visible() {
+                    Ok(None)
+                } else {
+                    view
+                }
             });
 
             draw_task.await?;
 
             // TODO this should be part of the API for `draw()` above, such that
             // the plugin need not render twice when a theme is provided.
-            if needs_restyle {
+            if needs_restyle && presentation.is_visible() {
                 let view = session.get_view().into_apierror()?;
                 renderer.restyle_all(&view).await?;
             }
+            // }
 
             Ok(())
         })

package/src/rust/{utils/scope.rs → model/send_plugin_config.rs}

@@ -10,45 +10,42 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
-use extend::ext;
-use futures::channel::oneshot::*;
-use perspective_js::utils::ApiResult;
-use yew::html::Scope;
-use yew::prelude::*;
+use perspective_js::utils::*;
 
-#[ext]
-pub impl<T> Scope<T>
-where
-    T: Component,
-{
-    /// Send a message with a callback, then suspend until the callback is
-    /// invoked.
-    fn send_message_async<F, U>(&self, f: F) -> Receiver<U>
-    where
-        F: FnOnce(Sender<U>) -> T::Message,
-    {
-        let (sender, receiver) = channel::<U>();
-        self.send_message(f(sender));
-        receiver
-    }
+use crate::config::ColumnConfigValueUpdate;
+use crate::model::*;
+
+pub trait SendPluginConfig {
+    /// Update te urrent plugin with a [`ColumnonfigValueUpdate`]
+    fn send_plugin_config(&self, column_name: &str, update: ColumnConfigValueUpdate);
 }
 
-#[ext]
-pub(crate) impl<T> Callback<Sender<T>>
+impl<A> SendPluginConfig for A
 where
-    T: 'static,
+    A: Clone + HasCustomEvents + HasPresentation + HasRenderer + HasSession + 'static,
 {
-    /// This is "safe" because `emit()` is not called synchronously.  Normally
-    /// we want this to minimize the async by doing as much work synchronous
-    /// as possible (see `send_message_async()` e.g.), but this method calls
-    /// `Yew` which _never_ wants to be called synchronously.
-    ///
-    /// TODO Need test coverage for this - error behavior is that presize/render
-    /// blocking calls are out-of-order, e.g. toggle config `presize()` call.
-    /// Engineering the test to capture this faulty behavior may be difficult
-    async fn emit_async_safe(&self) -> ApiResult<T> {
-        let (sender, receiver) = channel::<T>();
-        self.emit(sender);
-        Ok(receiver.await?)
+    fn send_plugin_config(&self, column_name: &str, update: ColumnConfigValueUpdate) {
+        let name = column_name.to_string();
+        let props = self.clone();
+        ApiFuture::spawn(async move {
+            props
+                .presentation()
+                .update_columns_config_value(name.clone(), update);
+
+            let columns_configs = props.presentation().all_columns_configs();
+            let plugin_config = props.renderer().get_active_plugin()?.save()?;
+            props
+                .renderer()
+                .get_active_plugin()?
+                .restore(&plugin_config, Some(&columns_configs))?;
+
+            props.renderer().update(props.session().get_view()).await?;
+            let detail = serde_wasm_bindgen::to_value(&columns_configs).unwrap();
+            props
+                .custom_events()
+                .dispatch_column_style_changed(&detail)?;
+
+            Ok(())
+        })
     }
 }