@perspective-dev/viewer 4.0.1 → 4.1.1

package/src/rust/custom_events.rs

@@ -29,17 +29,18 @@ use crate::session::Session;
 use crate::utils::*;
 use crate::*;
 
-/// A collection of `Subscription` which should trigger an event on the
-/// JavaScript Custom Element as a `CustomEvent`.  There are no public methods
+/// A collection of [`Subscription`]s which should trigger an event on the
+/// JavaScript Custom Element as a [`CustomEvent`].  There are no public methods
 /// on `CustomElements`, but when it is `drop()` the Custom Element will no
 /// longer dispatch events such as `"perspective-config-change"`.
 #[derive(Clone)]
-pub struct CustomEvents(Rc<(CustomEventsDataRc, [Subscription; 6])>);
+pub struct CustomEvents(Rc<(CustomEventsDataRc, [Subscription; 8])>);
 
 impl ImplicitClone for CustomEvents {}
+
 impl PartialEq for CustomEvents {
-    fn eq(&self, _: &Self) -> bool {
-        true
+    fn eq(&self, other: &Self) -> bool {
+        Rc::ptr_eq(&self.0, &other.0)
     }
 }
 
@@ -54,6 +55,7 @@ impl Deref for CustomEventsDataRc {
     }
 }
 
+#[derive(PerspectiveProperties!)]
 struct CustomEventsData {
     elem: HtmlElement,
     session: Session,
@@ -62,8 +64,6 @@ struct CustomEventsData {
     last_dispatched: RefCell<Option<ViewerConfig>>,
 }
 
-derive_model!(Renderer, Session, Presentation for CustomEventsData);
-
 impl CustomEvents {
     pub fn new(
         elem: &HtmlElement,
@@ -86,12 +86,20 @@ impl CustomEvents {
 
         let settings_sub = presentation.settings_open_changed.add_listener({
             clone!(data);
-            move |open| {
-                data.dispatch_settings_open_changed(open);
+            move |open: bool| {
+                data.dispatch_event("toggle-settings", open).unwrap();
                 data.clone().dispatch_config_update();
             }
         });
 
+        let before_settings_sub = presentation.settings_before_open_changed.add_listener({
+            clone!(data);
+            move |open: bool| {
+                data.dispatch_event("toggle-settings-before", open).unwrap();
+                // data.clone().dispatch_config_update();
+            }
+        });
+
         let column_settings_sub = presentation.column_settings_open_changed.add_listener({
             clone!(data);
             move |(open, column_name)| {
@@ -113,57 +121,72 @@ impl CustomEvents {
             move |_| data.clone().dispatch_config_update()
         });
 
-        let title_sub = presentation.title_changed.add_listener({
+        let title_sub = session.title_changed.add_listener({
             clone!(data);
             move |_| data.clone().dispatch_config_update()
         });
 
+        let unload_sub = session.table_unloaded.add_listener({
+            clone!(data);
+            move |x: bool| {
+                if !x {
+                    data.clone()
+                        .dispatch_event("table-delete-before", JsValue::UNDEFINED)
+                        .unwrap();
+                } else {
+                    data.clone()
+                        .dispatch_event("table-delete", JsValue::UNDEFINED)
+                        .unwrap()
+                }
+            }
+        });
+
         Self(Rc::new((data, [
             theme_sub,
+            before_settings_sub,
             settings_sub,
             column_settings_sub,
             plugin_sub,
             view_sub,
             title_sub,
+            unload_sub,
         ])))
     }
 
-    pub fn dispatch_column_style_changed(&self, config: &JsValue) {
-        let event_init = web_sys::CustomEventInit::new();
-        event_init.set_detail(config);
-        let event = web_sys::CustomEvent::new_with_event_init_dict(
-            "perspective-column-style-change",
-            &event_init,
-        );
-        self.0.0.elem.dispatch_event(&event.unwrap()).unwrap();
+    pub fn dispatch_column_style_changed(&self, config: &JsValue) -> ApiResult<()> {
+        self.dispatch_event("column-style-change", config)?;
         self.0.0.clone().dispatch_config_update();
+        Ok(())
     }
 
     pub fn dispatch_select(&self, view_window: Option<&ViewWindow>) -> ApiResult<()> {
-        let event_init = web_sys::CustomEventInit::new();
-        event_init.set_detail(&serde_wasm_bindgen::to_value(&view_window)?);
-        let event =
-            web_sys::CustomEvent::new_with_event_init_dict("perspective-select", &event_init);
-
-        self.0.0.elem.dispatch_event(&event.unwrap()).unwrap();
+        self.dispatch_event("select", &serde_wasm_bindgen::to_value(&view_window)?)?;
         self.0.0.clone().dispatch_config_update();
         Ok(())
     }
+
+    pub fn dispatch_event<T>(&self, name: &str, event: T) -> ApiResult<()>
+    where
+        T: Into<JsValue>,
+    {
+        self.0.0.dispatch_event(name, event)
+    }
 }
 
 impl CustomEventsDataRc {
-    fn dispatch_settings_open_changed(&self, open: bool) {
+    pub fn dispatch_event<T>(&self, name: &str, event: T) -> ApiResult<()>
+    where
+        T: Into<JsValue>,
+    {
         let event_init = web_sys::CustomEventInit::new();
-        event_init.set_detail(&JsValue::from(open));
+        event_init.set_detail(&event.into());
         let event = web_sys::CustomEvent::new_with_event_init_dict(
-            "perspective-toggle-settings",
+            format!("perspective-{}", name).as_str(),
             &event_init,
-        );
+        )?;
 
-        self.elem
-            .toggle_attribute_with_force("settings", open)
-            .unwrap();
-        self.elem.dispatch_event(&event.unwrap()).unwrap();
+        self.elem.dispatch_event(&event)?;
+        Ok(())
     }
 
     fn dispatch_column_settings_open_changed(&self, open: bool, column_name: Option<String>) {

package/src/rust/dragdrop.rs

@@ -23,21 +23,6 @@ use yew::prelude::*;
 use crate::utils::*;
 use crate::*;
 
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub enum DragTarget {
-    Active,
-    GroupBy,
-    SplitBy,
-    Sort,
-    Filter,
-}
-
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub enum DragEffect {
-    Copy,
-    Move(DragTarget),
-}
-
 #[derive(Clone, Debug)]
 struct DragFrom {
     column: String,
@@ -50,19 +35,14 @@ struct DragOver {
     index: usize,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Default)]
 enum DragState {
+    #[default]
     NoDrag,
     DragInProgress(DragFrom),
     DragOverInProgress(DragFrom, DragOver),
 }
 
-impl Default for DragState {
-    fn default() -> Self {
-        Self::NoDrag
-    }
-}
-
 impl DragState {
     const fn is_drag_in_progress(&self) -> bool {
         !matches!(self, Self::NoDrag)
@@ -249,7 +229,7 @@ impl DragDrop {
 pub fn dragenter_helper(callback: impl Fn() + 'static, target: NodeRef) -> Callback<DragEvent> {
     Callback::from({
         move |event: DragEvent| {
-            js_log_maybe!({
+            maybe_log!({
                 event.stop_propagation();
                 event.prevent_default();
                 if event.related_target().is_none() {
@@ -273,7 +253,7 @@ pub fn dragleave_helper(callback: impl Fn() + 'static, drag_ref: NodeRef) -> Cal
     Callback::from({
         clone!(drag_ref);
         move |event: DragEvent| {
-            js_log_maybe!({
+            maybe_log!({
                 event.stop_propagation();
                 event.prevent_default();
 

package/src/rust/exprtk/cursor.rs

@@ -18,7 +18,7 @@ use yew::prelude::*;
 /// Because ExprTK reports errors in column/row coordinates and visually needs
 /// to be applied to an entire token rather than a single character, we need
 /// fairly obnoxious counter logic to figure out how to generate the resulting
-/// syntax-highlighted HTML. The `Counter<'a>` struct encpsulates this logic,
+/// syntax-highlighted HTML. The `Counter<'a>` struct encapsulates this logic,
 /// generating a `NodeRef` to any autocomplete-able `<span>` tokens, as well
 /// as other convenient data for HTML rendering, and can be called incrementally
 /// while iterating tokens after parsing.
@@ -26,13 +26,22 @@ pub struct Cursor<'a> {
     row: u32,
     col: u32,
     index: u32,
+
+    /// Error text
     pub err: &'a Option<ExprValidationError>,
+
+    /// Expression text
     pub txt: &'a str,
+
+    /// Actual element
     pub noderef: NodeRef,
+
+    /// Auto complete text
     pub auto: Option<String>,
 }
 
 impl<'a> Cursor<'a> {
+    /// Create a new Cursor (given its error state).
     pub fn new(err: &'a Option<ExprValidationError>) -> Self {
         Self {
             row: 1,

package/src/rust/exprtk/mod.rs

@@ -10,6 +10,8 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
+//! Data processing functions for the Perspective/ExprTK language.
+
 mod cursor;
 mod tokenize;
 

package/src/rust/exprtk/tokenize.rs

@@ -35,22 +35,39 @@ use self::symbol::*;
 /// frequent pattern matching necessary when handling enum tokens.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum Token<'a> {
+    /// `//``
     Comment(&'a str),
+
+    /// ` `
     Whitespace(&'a str),
+
+    /// `\n`
     Break(&'a str),
+
+    /// `x`
     Symbol(&'a str),
+
+    /// `12`
     Literal(&'a str),
+
+    /// `+`
     Operator(&'a str),
+
+    /// `#`
     Unknown(&'a str),
+
+    /// `"Sales"`
     Column(&'a str),
 }
 
 use Token::*;
 
-impl ToHtml for Token<'_> {
-    fn to_html(&self) -> Html {
+impl Token<'_> {
+    pub fn to_html(&self) -> Html {
         html! {
-            if matches!(self, Break(_)) { <br /> } else {
+            if matches!(self, Break(_)) {
+                <br />
+            } else {
                 <span class={self.class_name()}>{ self.content() }</span>
             }
         }

package/src/rust/js/clipboard.rs

@@ -25,7 +25,7 @@ use crate::js::clipboard_item::*;
 use crate::*;
 
 pub async fn paste_from_clipboard() -> Option<String> {
-    JsFuture::from(global::clipboard().read_text())
+    JsFuture::from(global::navigator().clipboard().read_text())
         .await
         .ok()
         .and_then(|x| x.as_string())
@@ -58,7 +58,7 @@ fn poll(
         js_sys::Reflect::set(&options, &mimetype.into(), js_val)?;
         let item = ClipboardItem::new(&options);
         let items = std::iter::once(item).collect::<js_sys::Array>();
-        let _promise = global::clipboard().write(&items.into());
+        let _promise = global::navigator().clipboard().write(&items.into());
     } else {
         clone!(js_ref);
         if count == 200 {

package/src/rust/js/mimetype.rs

@@ -14,18 +14,13 @@ use std::fmt::Display;
 
 use wasm_bindgen::prelude::*;
 
-#[derive(Clone, Copy, Eq, PartialEq)]
+#[derive(Clone, Copy, Default, Eq, PartialEq)]
 pub enum MimeType {
+    #[default]
     TextPlain,
     ImagePng,
 }
 
-impl Default for MimeType {
-    fn default() -> Self {
-        Self::TextPlain
-    }
-}
-
 impl From<MimeType> for JsValue {
     fn from(x: MimeType) -> Self {
         Self::from(format!("{x}"))

package/src/rust/js/mod.rs

@@ -20,7 +20,6 @@ mod intersection_observer;
 mod mimetype;
 pub mod plugin;
 pub mod resize_observer;
-mod testing;
 
 pub use self::clipboard::*;
 pub use self::intersection_observer::*;

package/src/rust/js/plugin.rs

@@ -20,6 +20,13 @@ use crate::presentation::ColumnConfigMap;
 #[wasm_bindgen]
 #[rustfmt::skip]
 extern "C" {
+
+    #[derive(Clone)]
+    pub type JsPerspectiveViewer;
+
+    #[wasm_bindgen(method)]
+    pub fn get_model(this: &JsPerspectiveViewer) -> JsValue;
+
     #[derive(Clone)]
     pub type JsPerspectiveViewerPlugin;
 

package/src/rust/lib.rs

@@ -10,21 +10,24 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
-//! The API for the [`@perspective-dev/viewer`]() JavaScript
-//! library.
+//! The API for the [`@perspective-dev/viewer`](https://perspective-dev.github.io)
+//! JavaScript library.
 
 // Required by yew's `html` macro.
 #![recursion_limit = "1024"]
 #![feature(const_type_name)]
-#![feature(let_chains)]
 #![feature(macro_metavar_expr)]
 #![feature(iter_intersperse)]
 #![feature(stmt_expr_attributes)]
+#![feature(try_blocks)]
 #![allow(async_fn_in_trait)]
+#![feature(more_qualified_paths)]
 #![warn(
     clippy::all,
     clippy::panic_in_result_fn,
-    clippy::await_holding_refcell_ref
+    clippy::await_holding_refcell_ref,
+    clippy::fallible_impl_from,
+    clippy::unneeded_field_pattern
 )]
 
 pub mod components;
@@ -34,6 +37,7 @@ mod custom_events;
 mod dragdrop;
 pub mod exprtk;
 mod js;
+mod root;
 
 #[doc(hidden)]
 pub mod model;
@@ -42,6 +46,10 @@ mod renderer;
 mod session;
 pub mod utils;
 
+#[macro_use]
+extern crate macro_rules_attribute;
+extern crate alloc;
+
 use perspective_js::utils::*;
 use wasm_bindgen::prelude::*;
 
@@ -54,6 +62,7 @@ use crate::utils::define_web_component;
 #[wasm_bindgen(typescript_custom_section)]
 const TS_APPEND_CONTENT: &'static str = r#"
 import type {
+    ColumnType,
     TableInitOptions, 
     ColumnWindow,
     ViewWindow, 
@@ -82,6 +91,7 @@ pub fn registerPlugin(name: &str) {
 #[cfg(not(feature = "external-bootstrap"))]
 #[wasm_bindgen(js_name = "init")]
 pub fn js_init() {
+    console_error_panic_hook::set_once();
     perspective_js::utils::set_global_logging();
     define_web_components!("export * as psp from '../../perspective-viewer.js'");
     tracing::info!("Perspective initialized.");
@@ -96,11 +106,14 @@ 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);
 }
 
+/// Defining the web components needs an extern struct to reference the
+/// generated JavaSript glue. This is parameterized by an attribute macro which
+/// needs to be determined by the top-level compiled module - the JavaScript
+/// glue code emitted by `wasm-bindgen-cli`.
 #[macro_export]
 macro_rules! define_web_components {
     ($x:expr) => {{

package/src/rust/model/column_locator.rs

@@ -0,0 +1,82 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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::ColumnType;
+
+use super::HasSession;
+use crate::model::{HasPresentation, HasRenderer, PluginColumnStyles};
+use crate::presentation::ColumnLocator;
+
+pub trait ColumnLocatorExt: HasSession {
+    fn locator_name_or_default(&self, locator: &ColumnLocator) -> String {
+        match locator {
+            ColumnLocator::Table(s) | ColumnLocator::Expression(s) => s.clone(),
+            ColumnLocator::NewExpression => self.session().metadata().make_new_column_name(None),
+        }
+    }
+
+    fn is_locator_active(&self, locator: &ColumnLocator) -> bool {
+        locator
+            .name()
+            .map(|name| self.session().is_column_active(name))
+            .unwrap_or_default()
+    }
+
+    fn locator_view_type(&self, locator: &ColumnLocator) -> Option<ColumnType> {
+        let name = locator.name().cloned().unwrap_or_default();
+        self.session()
+            .metadata()
+            .get_column_view_type(name.as_str())
+    }
+
+    /// This function will return a [`ColumnLocator`] for agiven column name, or
+    /// [`None`] if no such column already exists. If you want to
+    /// create a new expression column, use ColumnLocator::Expr(None)
+    fn get_column_locator(&self, name: Option<String>) -> Option<ColumnLocator> {
+        name.and_then(|name| {
+            if self.session().metadata().is_column_expression(&name) {
+                Some(ColumnLocator::Expression(name))
+            } else {
+                self.session().metadata().get_table_columns().and_then(|x| {
+                    x.iter()
+                        .find_map(|n| (n == &name).then_some(ColumnLocator::Table(name.clone())))
+                })
+            }
+        })
+    }
+}
+
+impl<T: HasSession> ColumnLocatorExt for T {}
+
+pub trait ColumnLocatorCurrentExt:
+    HasPresentation + HasRenderer + HasSession + PluginColumnStyles
+{
+    /// Gets a [`ColumnLocator`] for the current UI's column settings state,
+    /// or [`None`] if it is not currently active.
+    fn get_current_column_locator(&self) -> Option<ColumnLocator> {
+        self.presentation()
+            .get_open_column_settings()
+            .locator
+            .filter(|locator| match locator {
+                ColumnLocator::Table(name) => {
+                    self.session().is_locator_active(locator)
+                        && self.can_render_column_styles(name).unwrap_or_default()
+                },
+                _ => true,
+            })
+    }
+}
+
+impl<T: HasPresentation + HasRenderer + HasSession + PluginColumnStyles> ColumnLocatorCurrentExt
+    for T
+{
+}

package/src/rust/model/columns_iter_set.rs

@@ -19,6 +19,7 @@ use super::{HasRenderer, HasSession, IsInvalidDrop};
 use crate::dragdrop::*;
 use crate::renderer::*;
 use crate::session::*;
+use crate::utils::DragTarget;
 use crate::*;
 
 /// The possible states of a column (row) in the active columns list, including

package/src/rust/model/copy_export.rs

@@ -16,14 +16,13 @@ use futures::join;
 use itertools::Itertools;
 use perspective_client::ViewWindow;
 use perspective_js::utils::ApiResult;
-use wasm_bindgen::JsCast;
+use wasm_bindgen::{JsCast, JsValue, intern};
 use wasm_bindgen_futures::JsFuture;
 
 use super::export_app;
 use super::export_method::*;
 use super::get_viewer_config::*;
 use super::structural::*;
-use crate::config::*;
 use crate::js::JsPerspectiveViewerPlugin;
 use crate::utils::*;
 
@@ -43,7 +42,7 @@ fn tag_name_to_package(plugin: &JsPerspectiveViewerPlugin) -> String {
 pub trait CopyExportModel:
     HasSession + HasRenderer + HasPresentation + GetViewerConfigModel
 {
-    async fn html_as_jsvalue(&self) -> ApiResult<web_sys::Blob> {
+    async fn html_as_jsvalue(&self) -> ApiResult<JsValue> {
         let view_config = self.get_viewer_config();
         let session = self.session().clone();
         let plugins = self
@@ -61,7 +60,7 @@ pub trait CopyExportModel:
         config.settings = false;
         let js_config = serde_json::to_string(&config)?;
         let html = export_app::render(&base64::encode(arrow), &js_config, &plugins);
-        js_sys::JsString::from(html.trim()).as_blob()
+        Ok(js_sys::JsString::from(html.trim()).into())
     }
 
     /// Create a blob of this plugin's `.png` rendering by calling the
@@ -75,7 +74,7 @@ pub trait CopyExportModel:
     async fn png_as_jsvalue(&self) -> ApiResult<web_sys::Blob> {
         let renderer = self.renderer().clone();
         let plugin = renderer.get_active_plugin()?;
-        let render = js_sys::Reflect::get(&plugin, js_intern::js_intern!("render"))?;
+        let render = js_sys::Reflect::get(&plugin, &intern("render").into())?;
         let render_fun = render.unchecked_into::<js_sys::Function>();
         let png = render_fun.call0(&plugin)?;
         let result = JsFuture::from(png.unchecked_into::<js_sys::Promise>())
@@ -87,7 +86,7 @@ pub trait CopyExportModel:
     async fn txt_as_jsvalue(&self, viewport: Option<ViewWindow>) -> ApiResult<web_sys::Blob> {
         let renderer = self.renderer().clone();
         let plugin = renderer.get_active_plugin()?;
-        let render = js_sys::Reflect::get(&plugin, js_intern::js_intern!("render"))?;
+        let render = js_sys::Reflect::get(&plugin, &intern("render").into())?;
         let render_fun = render.unchecked_into::<js_sys::Function>();
         let txt = render_fun.call1(&plugin, &serde_wasm_bindgen::to_value(&viewport)?)?;
         let result = JsFuture::from(txt.unchecked_into::<js_sys::Promise>())
@@ -97,7 +96,7 @@ pub trait CopyExportModel:
     }
 
     /// Generate a result `Blob` for all types of `ExportMethod`.
-    async fn export_method_to_jsvalue(&self, method: ExportMethod) -> ApiResult<web_sys::Blob> {
+    async fn export_method_to_blob(&self, method: ExportMethod) -> ApiResult<web_sys::Blob> {
         let viewport = self.renderer().get_selection();
 
         match method {
@@ -141,17 +140,54 @@ pub trait CopyExportModel:
                 .await?
                 .as_blob(),
             ExportMethod::ArrowAll => self.session().arrow_as_jsvalue(true, None).await?.as_blob(),
-            ExportMethod::Html => self.html_as_jsvalue().await,
+            ExportMethod::Html => self.html_as_jsvalue().await?.as_blob(),
             ExportMethod::Plugin if self.renderer().is_chart() => self.png_as_jsvalue().await,
             ExportMethod::Plugin => self.txt_as_jsvalue(viewport).await,
-            ExportMethod::JsonConfig => self
-                .get_viewer_config()
-                .await?
-                .encode(&Some(ViewerConfigEncoding::JSONString))?
-                .dyn_into::<js_sys::JsString>()?
-                .as_blob(),
+            ExportMethod::JsonConfig => {
+                js_sys::JSON::stringify(&self.get_viewer_config().await?.encode()?)?.as_blob()
+            },
         }
     }
+
+    /// Generate a result `Blob` for all types of `ExportMethod`.
+    async fn export_method_to_jsvalue(&self, method: ExportMethod) -> ApiResult<JsValue> {
+        let viewport = self.renderer().get_selection();
+
+        Ok(match method {
+            ExportMethod::Csv => self.session().csv_as_jsvalue(false, None).await?.into(),
+            ExportMethod::CsvSelected => {
+                self.session().csv_as_jsvalue(false, viewport).await?.into()
+            },
+            ExportMethod::CsvAll => self.session().csv_as_jsvalue(true, None).await?.into(),
+            ExportMethod::Json => self.session().json_as_jsvalue(false, None).await?.into(),
+            ExportMethod::JsonSelected => self
+                .session()
+                .json_as_jsvalue(false, viewport)
+                .await?
+                .into(),
+            ExportMethod::JsonAll => self.session().json_as_jsvalue(true, None).await?.into(),
+            ExportMethod::Ndjson => self.session().ndjson_as_jsvalue(false, None).await?.into(),
+            ExportMethod::NdjsonSelected => self
+                .session()
+                .ndjson_as_jsvalue(false, viewport)
+                .await?
+                .into(),
+            ExportMethod::NdjsonAll => self.session().ndjson_as_jsvalue(true, None).await?.into(),
+            ExportMethod::Arrow => self.session().arrow_as_jsvalue(false, None).await?.into(),
+            ExportMethod::ArrowSelected => self
+                .session()
+                .arrow_as_jsvalue(false, viewport)
+                .await?
+                .into(),
+            ExportMethod::ArrowAll => self.session().arrow_as_jsvalue(true, None).await?.into(),
+            ExportMethod::Html => self.html_as_jsvalue().await?,
+            ExportMethod::Plugin if self.renderer().is_chart() => {
+                self.png_as_jsvalue().await?.into()
+            },
+            ExportMethod::Plugin => self.txt_as_jsvalue(viewport).await?.into(),
+            ExportMethod::JsonConfig => self.get_viewer_config().await?.encode()?,
+        })
+    }
 }
 
 impl<T: HasRenderer + HasSession + HasPresentation> CopyExportModel for T {}