@perspective-dev/viewer 4.0.0

package/src/rust/model/resize_observer.rs

@@ -0,0 +1,98 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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::ApiFuture;
+use wasm_bindgen::JsCast;
+use wasm_bindgen::prelude::*;
+use web_sys::*;
+use yew::prelude::*;
+
+use crate::components::viewer::{PerspectiveViewer, PerspectiveViewerMsg};
+use crate::js::*;
+use crate::renderer::*;
+use crate::utils::*;
+
+pub struct ResizeObserverHandle {
+    elem: HtmlElement,
+    observer: ResizeObserver,
+    _callback: Closure<dyn FnMut(js_sys::Array)>,
+}
+
+impl ResizeObserverHandle {
+    pub fn new(
+        elem: &HtmlElement,
+        renderer: &Renderer,
+        root: &AppHandle<PerspectiveViewer>,
+    ) -> Self {
+        let on_resize = root.callback(|()| PerspectiveViewerMsg::Resize);
+        let mut state = ResizeObserverState {
+            elem: elem.clone(),
+            renderer: renderer.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);
+        observer.observe(elem);
+        Self {
+            elem: elem.clone(),
+            _callback,
+            observer,
+        }
+    }
+}
+
+impl Drop for ResizeObserverHandle {
+    fn drop(&mut self) {
+        self.observer.unobserve(&self.elem);
+    }
+}
+
+struct ResizeObserverState {
+    elem: HtmlElement,
+    renderer: Renderer,
+    width: i32,
+    height: i32,
+    on_resize: Callback<()>,
+}
+
+impl ResizeObserverState {
+    fn on_resize(&mut self, entries: &js_sys::Array) {
+        let is_visible = self
+            .elem
+            .offset_parent()
+            .map(|x| !x.is_null())
+            .unwrap_or(false);
+
+        for y in entries.iter() {
+            let entry: ResizeObserverEntry = y.unchecked_into();
+            let content = entry.content_rect();
+            let content_width = content.width().floor() as i32;
+            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);
+                ApiFuture::spawn(async move {
+                    renderer.resize().await?;
+                    on_resize.emit(());
+                    Ok(())
+                });
+            }
+
+            self.width = content_width;
+            self.height = content_height;
+        }
+    }
+}

package/src/rust/model/restore_and_render.rs

@@ -0,0 +1,113 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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 futures::Future;
+
+use super::structural::*;
+use crate::config::{OptionalUpdate, ViewerConfigUpdate};
+use crate::utils::*;
+use crate::*;
+
+pub trait RestoreAndRender: HasRenderer + HasSession + HasPresentation {
+    /// Apply a `ViewConfigUpdate` to the current `View` and render.
+    fn restore_and_render(
+        &self,
+        ViewerConfigUpdate {
+            plugin,
+            plugin_config,
+            columns_config,
+            settings,
+            theme: theme_name,
+            title,
+            mut view_config,
+            ..
+        }: crate::config::ViewerConfigUpdate,
+        task: impl Future<Output = Result<(), ApiError>> + 'static,
+    ) -> ApiFuture<()> {
+        clone!(self.session(), self.renderer(), self.presentation());
+        ApiFuture::new(async move {
+            if !session.has_table()
+                && let OptionalUpdate::Update(x) = settings
+            {
+                presentation.set_settings_attribute(x);
+            }
+
+            if let OptionalUpdate::Update(title) = title {
+                presentation.set_title(Some(title));
+            } else if matches!(title, OptionalUpdate::SetDefault) {
+                presentation.set_title(None);
+            }
+
+            let needs_restyle = match theme_name {
+                OptionalUpdate::SetDefault => {
+                    let current_name = presentation.get_selected_theme_name().await;
+                    if current_name.is_some() {
+                        presentation.set_theme_name(None).await?;
+                        true
+                    } else {
+                        false
+                    }
+                },
+                OptionalUpdate::Update(x) => {
+                    let current_name = presentation.get_selected_theme_name().await;
+                    if current_name.is_some() && current_name.as_ref().unwrap() != &x {
+                        presentation.set_theme_name(Some(&x)).await?;
+                        true
+                    } else {
+                        false
+                    }
+                },
+                _ => false,
+            };
+
+            if let Some(metadata) = renderer.get_next_plugin_metadata(&plugin) {
+                session.set_update_column_defaults(&mut view_config, &metadata);
+            }
+
+            session.update_view_config(view_config)?;
+            let draw_task = renderer.draw(async {
+                task.await?;
+                renderer.apply_pending_plugin()?;
+                let plugin = renderer.get_active_plugin()?;
+                let plugin_update = if let Some(x) = plugin_config {
+                    wasm_bindgen::JsValue::from_serde_ext(&*x).unwrap()
+                } else {
+                    plugin.save()?
+                };
+
+                presentation.update_columns_configs(columns_config);
+                let columns_config = presentation.all_columns_configs();
+                plugin.restore(&plugin_update, Some(&columns_config))?;
+
+                // The previous call which acquired the lock errored, so skip this render
+                if let Some(error) = session.get_error() {
+                    return Err(error);
+                }
+
+                session.validate().await?.create_view().await
+            });
+
+            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 {
+                let view = session.get_view().into_apierror()?;
+                renderer.restyle_all(&view).await?;
+            }
+
+            Ok(())
+        })
+    }
+}
+
+impl<T: HasRenderer + HasSession + HasPresentation> RestoreAndRender for T {}

package/src/rust/model/structural.rs

@@ -0,0 +1,73 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+//! A simple "structurally-typed" method extension implementation.  This
+//! collection of `trait`s allows methods to be automatically defined for
+//! `struct`s only if the define accessors for the necessary applications state
+//! objects (which are conviently derivable with the `derive_model!` macro).
+
+use crate::dragdrop::*;
+use crate::presentation::*;
+use crate::renderer::*;
+use crate::session::*;
+
+pub trait HasSession {
+    fn session(&self) -> &'_ Session;
+}
+
+pub trait HasRenderer {
+    fn renderer(&self) -> &'_ Renderer;
+}
+
+pub trait HasPresentation {
+    fn presentation(&self) -> &'_ Presentation;
+}
+
+pub trait HasDragDrop {
+    fn dragdrop(&self) -> &'_ DragDrop;
+}
+
+#[macro_export]
+macro_rules! derive_model {
+    (DragDrop for $key:ty) => {
+        impl $crate::model::HasDragDrop for $key {
+            fn dragdrop(&self) -> &'_ DragDrop {
+                &self.dragdrop
+            }
+        }
+    };
+    (Renderer for $key:ty) => {
+        impl $crate::model::HasRenderer for $key {
+            fn renderer(&self) -> &'_ Renderer {
+                &self.renderer
+            }
+        }
+    };
+    (Session for $key:ty) => {
+        impl $crate::model::HasSession for $key {
+            fn session(&self) -> &'_ Session {
+                &self.session
+            }
+        }
+    };
+    (Presentation for $key:ty) => {
+        impl $crate::model::HasPresentation for $key {
+            fn presentation(&self) -> &'_ Presentation {
+                &self.presentation
+            }
+        }
+    };
+    ($i:ident, $($is:ident),+ for $key:ty) => {
+        derive_model!($i for $key);
+        derive_model!($($is),+ for $key);
+    };
+}

package/src/rust/model/update_and_render.rs

@@ -0,0 +1,74 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+// ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+// ┃ This file is part of the Perspective library, distributed under the terms ┃
+// ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+use perspective_client::config::ViewConfigUpdate;
+use yew::prelude::*;
+
+use super::structural::*;
+use crate::renderer::Renderer;
+use crate::session::Session;
+use crate::utils::*;
+use crate::*;
+
+/// A model trait for updating both `View` state and completing a render.
+///
+/// While `Renderer` manages the plugin and thus the render call itself, the
+/// current `View` is handled by the `Session` which must be validated and
+/// locked while drawing is in progress.  `UpdateAndRender` provides methods
+/// that synchronize this behavior, so these methods should be used to initiate
+/// rendering of the current `Plugin` and `View`.
+pub trait UpdateAndRender: HasRenderer + HasSession {
+    /// Create a `Callback` that renders from the current `View` and `Plugin`.
+    fn render_callback(&self) -> Callback<()> {
+        clone!(self.session(), self.renderer());
+        Callback::from(move |_| {
+            clone!(session, renderer);
+            ApiFuture::spawn(async move {
+                renderer.draw(async { Ok(&session) }).await?;
+                Ok(())
+            })
+        })
+    }
+
+    /// Create a `Callback` that resizes from the current `View` and `Plugin`.
+    fn resize_callback(&self) -> Callback<()> {
+        clone!(self.renderer());
+        Callback::from(move |_| {
+            clone!(renderer);
+            ApiFuture::spawn(async move {
+                renderer.resize().await?;
+                Ok(())
+            })
+        })
+    }
+
+    /// Apply a `ViewConfigUpdate` to the current `View` and render.
+    fn update_and_render(&self, update: ViewConfigUpdate) -> ApiResult<ApiFuture<()>> {
+        self.session().update_view_config(update)?;
+        clone!(self.session(), self.renderer());
+        Ok(ApiFuture::new(update_and_render(session, renderer)))
+    }
+}
+
+#[tracing::instrument(level = "debug", skip(session, renderer))]
+async fn update_and_render(session: Session, renderer: Renderer) -> ApiResult<()> {
+    // The previous call which acquired the lock errored, so skip this render
+    if session.get_error().is_some() {
+        return Ok(());
+    }
+
+    renderer.apply_pending_plugin()?;
+    let view = session.validate().await?;
+    renderer.draw(view.create_view()).await
+}
+
+impl<T: HasRenderer + HasSession> UpdateAndRender for T {}