@perspective-dev/viewer 4.4.0 → 4.5.0

package/src/rust/custom_elements/copy_dropdown.rs

@@ -23,8 +23,11 @@ use super::viewer::PerspectiveViewerElement;
 use crate::components::copy_dropdown::CopyDropDownMenu;
 use crate::components::portal::PortalModal;
 use crate::components::style::StyleProvider;
+use crate::config::*;
 use crate::js::*;
+use crate::presentation::Presentation;
 use crate::renderer::*;
+use crate::session::Session;
 use crate::tasks::*;
 use crate::utils::*;
 use crate::*;
@@ -130,57 +133,66 @@ impl CopyDropDownMenuElement {
     }
 
     pub fn __set_model(&self, parent: &PerspectiveViewerElement) {
-        self.set_config_model(parent)
+        self.set_config_model(&parent.session, &parent.renderer, &parent.presentation)
     }
 
     pub fn connected_callback(&self) {}
 }
 
 impl CopyDropDownMenuElement {
-    pub fn new_from_model<A>(model: &A) -> Self
-    where
-        A: GetViewerConfigModel + StateProvider,
-        <A as StateProvider>::State: HasPresentation + HasRenderer + HasSession,
-    {
+    pub fn new_from_model(
+        session: &Session,
+        renderer: &Renderer,
+        presentation: &Presentation,
+    ) -> Self {
         let dropdown = global::document()
             .create_element("perspective-copy-menu")
             .unwrap()
             .unchecked_into::<HtmlElement>();
 
         let elem = Self::new(dropdown);
-        elem.set_config_model(model);
+        elem.set_config_model(session, renderer, presentation);
         elem
     }
 
-    pub fn set_config_model<A>(&self, model: &A)
-    where
-        A: GetViewerConfigModel + StateProvider,
-        <A as StateProvider>::State: HasPresentation + HasRenderer + HasSession,
-    {
+    pub fn set_config_model(
+        &self,
+        session: &Session,
+        renderer: &Renderer,
+        presentation: &Presentation,
+    ) {
         let callback = Callback::from({
-            let model = model.clone_state();
+            let session = session.clone();
+            let renderer = renderer.clone();
+            let presentation = presentation.clone();
             let target = self.target.clone();
             let root = self.root.clone();
             move |x: ExportFile| {
-                let model = model.clone();
+                let session = session.clone();
+                let renderer = renderer.clone();
+                let presentation = presentation.clone();
                 let target = target.clone();
                 let root = root.clone();
                 spawn_local(async move {
                     let mime = x.method.mimetype(x.is_chart);
-                    let task = model.export_method_to_blob(x.method);
+                    let task = export_method_to_blob(&session, &renderer, &presentation, x.method);
                     let result = copy_to_clipboard(task, mime).await;
-                    crate::maybe_log!({
+                    let r = (|| -> ApiResult<()> {
                         result?;
                         *target.borrow_mut() = None;
                         if let Some(root) = root.borrow().as_ref() {
                             root.send_message(CopyDropDownWrapperMsg::Close);
                         }
-                    })
+                        Ok(())
+                    })();
+                    if let Err(e) = r {
+                        web_sys::console::warn_1(&e.into());
+                    }
                 })
             }
         });
 
-        let renderer = model.renderer().clone();
+        let renderer = renderer.clone();
         let init = ShadowRootInit::new(ShadowRootMode::Open);
         let shadow_root = self
             .elem

package/src/rust/custom_elements/debug_plugin.rs

@@ -93,16 +93,14 @@ impl PerspectiveDebugPluginElement {
         ApiFuture::default()
     }
 
-    pub fn restyle(&self) -> ApiFuture<()> {
-        ApiFuture::default()
-    }
+    pub fn restyle(&self) {}
 
-    pub fn save(&self) -> ApiFuture<()> {
-        ApiFuture::default()
+    pub fn save(&self) -> ApiResult<JsValue> {
+        Ok(JsValue::null())
     }
 
-    pub fn restore(&self) -> ApiFuture<()> {
-        ApiFuture::default()
+    pub fn restore(&self, _config: Option<JsValue>) -> ApiResult<()> {
+        Ok(())
     }
 
     pub fn delete(&self) -> ApiFuture<()> {

package/src/rust/custom_elements/export_dropdown.rs

@@ -23,6 +23,8 @@ use super::viewer::PerspectiveViewerElement;
 use crate::components::export_dropdown::ExportDropDownMenu;
 use crate::components::portal::PortalModal;
 use crate::components::style::StyleProvider;
+use crate::config::*;
+use crate::presentation::Presentation;
 use crate::renderer::*;
 use crate::session::*;
 use crate::tasks::*;
@@ -132,43 +134,49 @@ impl ExportDropDownMenuElement {
     }
 
     pub fn __set_model(&self, parent: &PerspectiveViewerElement) {
-        self.set_config_model(parent)
+        self.set_config_model(&parent.session, &parent.renderer, &parent.presentation)
     }
 
     pub fn connected_callback(&self) {}
 }
 
 impl ExportDropDownMenuElement {
-    pub fn new_from_model<A>(model: &A) -> Self
-    where
-        A: GetViewerConfigModel + StateProvider,
-        <A as StateProvider>::State: HasPresentation + HasRenderer + HasSession,
-    {
+    pub fn new_from_model(
+        session: &Session,
+        renderer: &Renderer,
+        presentation: &Presentation,
+    ) -> Self {
         let dropdown = global::document()
             .create_element("perspective-export-menu")
             .unwrap()
             .unchecked_into::<HtmlElement>();
 
         let elem = Self::new(dropdown);
-        elem.set_config_model(model);
+        elem.set_config_model(session, renderer, presentation);
         elem
     }
 
-    fn set_config_model<A>(&self, model: &A)
-    where
-        A: GetViewerConfigModel + StateProvider,
-        <A as StateProvider>::State: HasPresentation + HasRenderer + HasSession,
-    {
+    fn set_config_model(
+        &self,
+        session: &Session,
+        renderer: &Renderer,
+        presentation: &Presentation,
+    ) {
         let callback = Callback::from({
-            let model = model.clone_state();
+            let session = session.clone();
+            let renderer = renderer.clone();
+            let presentation = presentation.clone();
             let target = self.target.clone();
             let root = self.root.clone();
             move |x: ExportFile| {
                 if !x.name.is_empty() {
-                    clone!(target, root, model);
+                    clone!(target, root, session, renderer, presentation);
                     spawn_local(async move {
-                        let val = model.export_method_to_blob(x.method).await.unwrap();
-                        let is_chart = model.renderer().is_chart();
+                        let val =
+                            export_method_to_blob(&session, &renderer, &presentation, x.method)
+                                .await
+                                .unwrap();
+                        let is_chart = renderer.is_chart();
                         download(&x.as_filename(is_chart), &val).unwrap();
                         *target.borrow_mut() = None;
                         if let Some(root) = root.borrow().as_ref() {
@@ -179,8 +187,8 @@ impl ExportDropDownMenuElement {
             }
         });
 
-        let renderer = model.renderer().clone();
-        let session = model.session().clone();
+        let renderer = renderer.clone();
+        let session = session.clone();
         let init = ShadowRootInit::new(ShadowRootMode::Open);
         let shadow_root = self
             .elem

package/src/rust/custom_elements/viewer.rs

@@ -29,9 +29,9 @@ use web_sys::HtmlElement;
 use crate::components::viewer::{PerspectiveViewerMsg, PerspectiveViewerProps};
 use crate::config::*;
 use crate::custom_events::*;
-use crate::dragdrop::*;
 use crate::js::*;
 use crate::presentation::*;
+use crate::queries::*;
 use crate::renderer::*;
 use crate::root::Root;
 use crate::session::{ResetOptions, Session, TableLoadState};
@@ -39,6 +39,15 @@ use crate::tasks::*;
 use crate::utils::*;
 use crate::*;
 
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(typescript_type = "Promise<ViewerConfig>")]
+    pub type JsViewerConfigPromise;
+
+    #[wasm_bindgen(typescript_type = "ViewerConfigUpdate")]
+    pub type JsViewerConfigUpdate;
+}
+
 #[derive(serde::Deserialize, Default)]
 struct ResizeOptions {
     dimensions: Option<ResizeDimensions>,
@@ -81,48 +90,17 @@ pub struct PerspectiveViewerElement {
     root: Root<components::viewer::PerspectiveViewer>,
     resize_handle: Rc<RefCell<Option<ResizeObserverHandle>>>,
     intersection_handle: Rc<RefCell<Option<IntersectionObserverHandle>>>,
-    session: Session,
-    renderer: Renderer,
-    presentation: Presentation,
-    custom_events: CustomEvents,
+    pub(crate) session: Session,
+    pub(crate) renderer: Renderer,
+    pub(crate) presentation: Presentation,
     _subscriptions: Rc<[Subscription; 2]>,
-}
-
-impl HasCustomEvents for PerspectiveViewerElement {
-    fn custom_events(&self) -> &CustomEvents {
-        &self.custom_events
-    }
-}
-
-impl HasPresentation for PerspectiveViewerElement {
-    fn presentation(&self) -> &Presentation {
-        &self.presentation
-    }
-}
-
-impl HasRenderer for PerspectiveViewerElement {
-    fn renderer(&self) -> &Renderer {
-        &self.renderer
-    }
-}
-
-impl HasSession for PerspectiveViewerElement {
-    fn session(&self) -> &Session {
-        &self.session
-    }
-}
-
-impl StateProvider for PerspectiveViewerElement {
-    type State = PerspectiveViewerElement;
-
-    fn clone_state(&self) -> Self::State {
-        self.clone()
-    }
+    _custom_event_subs: Rc<Vec<Subscription>>,
 }
 
 impl CustomElementMetadata for PerspectiveViewerElement {
     const CUSTOM_ELEMENT_NAME: &'static str = "perspective-viewer";
-    const STATICS: &'static [&'static str] = ["registerPlugin"].as_slice();
+    const STATICS: &'static [&'static str] =
+        ["registerPlugin", "get_wasm_module", "get_worker_url"].as_slice();
 }
 
 #[wasm_bindgen]
@@ -144,7 +122,7 @@ impl PerspectiveViewerElement {
         let session = Session::new();
         let renderer = Renderer::new(&elem);
         let presentation = Presentation::new(&elem);
-        let custom_events = CustomEvents::new(&elem, &session, &renderer, &presentation);
+        let custom_event_subs = wire_custom_events(&elem, &session, &renderer, &presentation);
 
         // Create Yew App
         let props = yew::props!(PerspectiveViewerProps {
@@ -152,11 +130,9 @@ impl PerspectiveViewerElement {
             session: session.clone(),
             renderer: renderer.clone(),
             presentation: presentation.clone(),
-            dragdrop: DragDrop::new(&elem),
-            custom_events: custom_events.clone(),
         });
 
-        let state = props.clone_state();
+        let state = props.clone();
         let root = Root::new(shadow_root, props);
 
         // Create callbacks
@@ -176,7 +152,7 @@ impl PerspectiveViewerElement {
 
         let eject_sub = presentation.on_eject.add_listener({
             let root = root.clone();
-            move |_| ApiFuture::spawn(state.delete_all(&root))
+            move |_| ApiFuture::spawn(delete_all(&state.session, &state.renderer, &root))
         });
 
         let resize_handle =
@@ -193,8 +169,8 @@ impl PerspectiveViewerElement {
             presentation,
             resize_handle: Rc::new(RefCell::new(Some(resize_handle))),
             intersection_handle: Rc::new(RefCell::new(Some(intersect_handle))),
-            custom_events,
             _subscriptions: Rc::new([update_sub, eject_sub]),
+            _custom_event_subs: Rc::new(custom_event_subs),
         }
     }
 
@@ -361,7 +337,7 @@ impl PerspectiveViewerElement {
     /// await viewer.delete();
     /// ```
     pub fn delete(self) -> ApiFuture<()> {
-        self.delete_all(&self.root)
+        delete_all(&self.session, &self.renderer, &self.root)
     }
 
     /// Restart this `<perspective-viewer>` to its initial state, before
@@ -414,12 +390,24 @@ impl PerspectiveViewerElement {
     /// [`PerspectiveViewerElement::save`]), and also makes no API calls to the
     /// server (unlike [`PerspectiveViewerElement::getView`] followed by
     /// [`View::get_config`])
+    ///
+    /// Returns the [`ViewConfig`] the currently-bound `View` was constructed
+    /// from, so the value is consistent with what the active plugin is
+    /// rendering even if a queued [`Self::restore`]/`update_and_render` has
+    /// already mutated the live config in anticipation of the next draw.
+    /// Falls back to the live session config when no `View` has yet been
+    /// created (e.g., after `load` but before the first render).
     #[wasm_bindgen]
     pub fn getViewConfig(&self) -> ApiFuture<JsViewConfig> {
         let session = self.session.clone();
         ApiFuture::new(async move {
-            let config = session.get_view_config();
-            Ok(JsValue::from_serde_ext(&*config)?.unchecked_into())
+            let config = if let Some(rendered) = session.get_rendered_view_config() {
+                (*rendered).clone()
+            } else {
+                session.get_view_config().clone()
+            };
+
+            Ok(JsValue::from_serde_ext(&config)?.unchecked_into())
         })
     }
 
@@ -563,7 +551,7 @@ impl PerspectiveViewerElement {
     /// ```javascript
     /// await viewer.restore({group_by: ["State"]});
     /// ```
-    pub fn restore(&self, update: JsValue) -> ApiFuture<()> {
+    pub fn restore(&self, update: JsViewerConfigUpdate) -> ApiFuture<()> {
         let this = self.clone();
         ApiFuture::new_throttled(async move {
             let decoded_update = ViewerConfigUpdate::decode(&update)?;
@@ -586,8 +574,12 @@ impl PerspectiveViewerElement {
                 None
             };
 
-            let result = this
-                .restore_and_render(decoded_update.clone(), {
+            let result = restore_and_render(
+                &this.session,
+                &this.renderer,
+                &this.presentation,
+                decoded_update.clone(),
+                {
                     clone!(this, decoded_update.table);
                     async move {
                         if let OptionalUpdate::Update(name) = table {
@@ -605,11 +597,12 @@ impl PerspectiveViewerElement {
                         receiver.await.unwrap_or_log();
                         Ok(())
                     }
-                })
-                .await;
+                },
+            )
+            .await;
 
             if let Err(e) = &result {
-                this.session().set_error(false, e.clone()).await?;
+                this.session.set_error(false, e.clone()).await?;
             }
             result
         })
@@ -622,7 +615,7 @@ impl PerspectiveViewerElement {
         ApiFuture::spawn(self.session.reset(ResetOptions::default()));
         let this = self.clone();
         ApiFuture::new_throttled(async move {
-            this.update_and_render(ViewConfigUpdate::default())?.await?;
+            update_and_render(&this.session, &this.renderer, ViewConfigUpdate::default())?.await?;
             Ok(())
         })
     }
@@ -646,17 +639,21 @@ impl PerspectiveViewerElement {
     ///     await viewer.restore(token);
     /// });
     /// ```
-    pub fn save(&self) -> ApiFuture<JsValue> {
+    pub fn save(&self) -> JsViewerConfigPromise {
         let this = self.clone();
-        ApiFuture::new(async move {
+        let fut = ApiFuture::new(async move {
             let viewer_config = this
                 .renderer
                 .clone()
-                .with_lock(async { this.get_viewer_config().await })
+                .with_lock(async {
+                    get_viewer_config(&this.session, &this.renderer, &this.presentation).await
+                })
                 .await?;
 
             viewer_config.encode()
-        })
+        });
+
+        js_sys::Promise::from(fut).unchecked_into()
     }
 
     /// Download this viewer's internal [`View`] data via a browser download
@@ -685,7 +682,9 @@ impl PerspectiveViewerElement {
                 ExportMethod::Csv
             };
 
-            let blob = this.export_method_to_blob(method).await?;
+            let blob =
+                export_method_to_blob(&this.session, &this.renderer, &this.presentation, method)
+                    .await?;
             let is_chart = this.renderer.is_chart();
             download(
                 format!("untitled{}", method.as_filename(is_chart)).as_ref(),
@@ -700,7 +699,7 @@ impl PerspectiveViewerElement {
     ///
     /// This method is only really useful for the `"plugin"` method, which
     /// will use the configured plugin's export (e.g. PNG for
-    /// `@perspective-dev/viewer-d3fc`). Otherwise, prefer to call the
+    /// `@perspective-dev/viewer-charts`). Otherwise, prefer to call the
     /// equivalent method on the underlying [`View`] directly.
     ///
     /// # Arguments
@@ -724,7 +723,8 @@ impl PerspectiveViewerElement {
                 ExportMethod::Csv
             };
 
-            this.export_method_to_jsvalue(method).await
+            export_method_to_jsvalue(&this.session, &this.renderer, &this.presentation, method)
+                .await
         })
     }
 
@@ -755,7 +755,8 @@ impl PerspectiveViewerElement {
                 ExportMethod::Csv
             };
 
-            let js_task = this.export_method_to_blob(method);
+            let js_task =
+                export_method_to_blob(&this.session, &this.renderer, &this.presentation, method);
             copy_to_clipboard(js_task, MimeType::TextPlain).await
         })
     }
@@ -816,19 +817,18 @@ impl PerspectiveViewerElement {
             .unwrap_or_default()
             .unwrap_or_default();
 
-        let state = self.clone_state();
+        let state = self.clone();
         ApiFuture::new_throttled(async move {
-            if !state.renderer().is_plugin_activated()? {
-                state
-                    .update_and_render(ViewConfigUpdate::default())?
+            if !state.renderer.is_plugin_activated()? {
+                update_and_render(&state.session, &state.renderer, ViewConfigUpdate::default())?
                     .await?;
             } else if let Some(dims) = opts.dimensions {
                 state
-                    .renderer()
+                    .renderer
                     .resize_with_dimensions(dims.width, dims.height)
                     .await?;
             } else {
-                state.renderer().resize().await?;
+                state.renderer.resize().await?;
             }
 
             Ok(())
@@ -903,9 +903,13 @@ impl PerspectiveViewerElement {
         } else {
             *self.intersection_handle.borrow_mut() = None;
             if self.session.set_pause(false) {
-                return ApiFuture::new(
-                    self.restore_and_render(ViewerConfigUpdate::default(), async move { Ok(()) }),
-                );
+                return ApiFuture::new(restore_and_render(
+                    &self.session,
+                    &self.renderer,
+                    &self.presentation,
+                    ViewerConfigUpdate::default(),
+                    async move { Ok(()) },
+                ));
             }
         }
 
@@ -923,10 +927,6 @@ impl PerspectiveViewerElement {
     #[wasm_bindgen]
     pub fn setSelection(&self, window: Option<JsViewWindow>) -> ApiResult<()> {
         let window = window.map(|x| x.into_serde_ext()).transpose()?;
-        if self.renderer.get_selection() != window {
-            self.custom_events.dispatch_select(window.as_ref())?;
-        }
-
         self.renderer.set_selection(window);
         Ok(())
     }
@@ -1097,7 +1097,7 @@ impl PerspectiveViewerElement {
     pub fn toggleColumnSettings(&self, column_name: String) -> ApiFuture<()> {
         clone!(self.session, self.root);
         ApiFuture::new_throttled(async move {
-            let locator = session.get_column_locator(Some(column_name));
+            let locator = get_column_locator(&session.metadata(), Some(column_name));
             let (sender, receiver) = channel::<()>();
             root.borrow().as_ref().into_apierror()?.send_message(
                 PerspectiveViewerMsg::OpenColumnSettings {
@@ -1119,7 +1119,7 @@ impl PerspectiveViewerElement {
         column_name: Option<String>,
         toggle: Option<bool>,
     ) -> ApiFuture<()> {
-        let locator = self.get_column_locator(column_name);
+        let locator = get_column_locator(&self.session.metadata(), column_name);
         clone!(self.root);
         ApiFuture::new_throttled(async move {
             let (sender, receiver) = channel::<()>();