@perspective-dev/viewer 4.0.0

package/src/rust/config/viewer_config.rs

@@ -0,0 +1,337 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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 std::collections::HashMap;
+use std::io::{Read, Write};
+use std::ops::Deref;
+use std::str::FromStr;
+use std::sync::LazyLock;
+
+use flate2::Compression;
+use flate2::read::ZlibDecoder;
+use flate2::write::ZlibEncoder;
+use perspective_client::config::*;
+use perspective_js::utils::*;
+use serde::{Deserialize, Deserializer, Serialize};
+use serde_json::Value;
+use ts_rs::TS;
+use wasm_bindgen::JsCast;
+use wasm_bindgen::prelude::*;
+
+use super::ColumnConfigValues;
+use crate::presentation::ColumnConfigMap;
+
+pub enum ViewerConfigEncoding {
+    Json,
+    String,
+    ArrayBuffer,
+    JSONString,
+}
+
+impl FromStr for ViewerConfigEncoding {
+    type Err = JsValue;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "json" => Ok(Self::Json),
+            "string" => Ok(Self::String),
+            "arraybuffer" => Ok(Self::ArrayBuffer),
+            x => Err(format!("Unknown format \"{x}\"").into()),
+        }
+    }
+}
+
+/// The state of an entire `custom_elements::PerspectiveViewerElement` component
+/// and its `Plugin`.
+#[derive(Serialize, PartialEq)]
+#[serde(deny_unknown_fields)]
+pub struct ViewerConfig {
+    pub version: String,
+    pub plugin: String,
+    pub plugin_config: Value,
+    pub columns_config: ColumnConfigMap,
+    pub settings: bool,
+    pub theme: Option<String>,
+    pub title: Option<String>,
+
+    #[serde(flatten)]
+    pub view_config: ViewConfig,
+}
+
+// `#[serde(flatten)]` makes messagepack 2x as big as they can no longer be
+// struct fields, so make a tuple alternative for serialization in binary.
+type ViewerConfigBinarySerialFormat<'a> = (
+    &'a String,
+    &'a ColumnConfigMap,
+    &'a String,
+    &'a Value,
+    bool,
+    &'a Option<String>,
+    &'a Option<String>,
+    &'a ViewConfig,
+);
+
+type ViewerConfigBinaryDeserialFormat = (
+    VersionUpdate,
+    ColumnConfigUpdate,
+    PluginUpdate,
+    Option<Value>,
+    SettingsUpdate,
+    ThemeUpdate,
+    TitleUpdate,
+    ViewConfigUpdate,
+);
+
+pub static API_VERSION: LazyLock<&'static str> = LazyLock::new(|| {
+    #[derive(Deserialize)]
+    struct Package {
+        version: &'static str,
+    }
+    let pkg: &'static str = include_str!("../../../package.json");
+    let pkg: Package = serde_json::from_str(pkg).unwrap();
+    pkg.version
+});
+
+impl ViewerConfig {
+    fn token(&self) -> ViewerConfigBinarySerialFormat<'_> {
+        (
+            &self.version,
+            &self.columns_config,
+            &self.plugin,
+            &self.plugin_config,
+            self.settings,
+            &self.theme,
+            &self.title,
+            &self.view_config,
+        )
+    }
+
+    /// Encode a `ViewerConfig` to a `JsValue` in a supported type.
+    pub fn encode(&self, format: &Option<ViewerConfigEncoding>) -> ApiResult<JsValue> {
+        match format {
+            Some(ViewerConfigEncoding::String) => {
+                let mut encoder = ZlibEncoder::new(Vec::new(), Compression::default());
+                let bytes = rmp_serde::to_vec_named(&self.token())?;
+                encoder.write_all(&bytes)?;
+                let encoded = encoder.finish()?;
+                Ok(JsValue::from(base64::encode(encoded)))
+            },
+            Some(ViewerConfigEncoding::ArrayBuffer) => {
+                let mut encoder = ZlibEncoder::new(Vec::new(), Compression::default());
+                let bytes = rmp_serde::to_vec_named(&self.token())?;
+                encoder.write_all(&bytes)?;
+                let encoded = encoder.finish()?;
+                let array = js_sys::Uint8Array::from(&encoded[..]);
+                let start = array.byte_offset();
+                let len = array.byte_length();
+                Ok(array
+                    .buffer()
+                    .slice_with_end(start, start + len)
+                    .unchecked_into())
+            },
+            Some(ViewerConfigEncoding::JSONString) => {
+                Ok(JsValue::from(serde_json::to_string(self)?))
+            },
+            None | Some(ViewerConfigEncoding::Json) => Ok(JsValue::from_serde_ext(self)?),
+        }
+    }
+}
+
+#[derive(Clone, TS, Deserialize)]
+#[serde(transparent)]
+pub struct PluginConfig(serde_json::Value);
+
+// impl Type for PluginConfig {
+//     fn inline(type_map: &mut specta::TypeMap, generics: specta::Generics) ->
+// specta::DataType {         specta::Map::from(());
+//         // specta::Map {
+//         //     key_ty:
+//         // specta::DataType::Primitive(specta::PrimitiveType::String),
+//         //     value_ty: specta::DataType::Any,
+//         // }
+
+//         // specta::DataType::Map(specta::Map { Box::new((
+//         //     specta::DataType::Primitive(specta::PrimitiveType::String),
+//         //     specta::DataType::Any,
+//         // )))
+//     }
+//     // fn inline(_type_map: &mut specta::TypeMap, _generics:
+// &[specta::DataType]) ->     // specta::DataType {
+// specta::DataType::Map(Box::new((     //
+// specta::DataType::Primitive(specta::PrimitiveType::String),     //
+// specta::DataType::Any,     //     )))
+//     // }
+// }
+
+impl Deref for PluginConfig {
+    type Target = Value;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+#[derive(Clone, Deserialize, TS)]
+// #[serde(deny_unknown_fields)]
+pub struct ViewerConfigUpdate {
+    #[serde(default)]
+    #[ts(as = "Option<_>")]
+    #[ts(optional)]
+    pub version: VersionUpdate,
+
+    #[serde(default)]
+    #[ts(as = "Option<_>")]
+    #[ts(optional)]
+    pub plugin: PluginUpdate,
+
+    #[serde(default)]
+    #[ts(as = "Option<_>")]
+    #[ts(optional)]
+    pub title: TitleUpdate,
+
+    #[serde(default)]
+    #[ts(as = "Option<_>")]
+    #[ts(optional)]
+    pub theme: ThemeUpdate,
+
+    #[serde(default)]
+    #[ts(as = "Option<_>")]
+    #[ts(optional)]
+    pub settings: SettingsUpdate,
+
+    #[serde(default)]
+    #[ts(as = "Option<_>")]
+    #[ts(optional)]
+    pub plugin_config: Option<PluginConfig>,
+
+    #[serde(default)]
+    #[ts(as = "Option<_>")]
+    #[ts(optional)]
+    pub columns_config: ColumnConfigUpdate,
+
+    #[serde(flatten)]
+    pub view_config: ViewConfigUpdate,
+}
+
+impl ViewerConfigUpdate {
+    fn from_token(
+        (version, columns_config, plugin, plugin_config, settings, theme, title, view_config): ViewerConfigBinaryDeserialFormat,
+    ) -> ViewerConfigUpdate {
+        ViewerConfigUpdate {
+            version,
+            columns_config,
+            plugin,
+            plugin_config: plugin_config.map(PluginConfig),
+            settings,
+            theme,
+            title,
+            view_config,
+        }
+    }
+
+    /// Decode a `JsValue` into a `ViewerConfigUpdate` by auto-detecting format
+    /// from JavaScript type.
+    pub fn decode(update: &JsValue) -> ApiResult<Self> {
+        if update.is_string() {
+            let js_str = update.as_string().into_apierror()?;
+            let bytes = base64::decode(js_str)?;
+            let mut decoder = ZlibDecoder::new(&*bytes);
+            let mut decoded = vec![];
+            decoder.read_to_end(&mut decoded)?;
+            let token = rmp_serde::from_slice(&decoded[..])?;
+            Ok(ViewerConfigUpdate::from_token(token))
+        } else if update.is_instance_of::<js_sys::ArrayBuffer>() {
+            let uint8array = js_sys::Uint8Array::new(update);
+            let mut slice = vec![0; uint8array.length() as usize];
+            uint8array.copy_to(&mut slice[..]);
+            let mut decoder = ZlibDecoder::new(&*slice);
+            let mut decoded = vec![];
+            decoder.read_to_end(&mut decoded)?;
+            let token = rmp_serde::from_slice(&decoded[..])?;
+            Ok(ViewerConfigUpdate::from_token(token))
+        } else {
+            Ok(update.into_serde_ext()?)
+        }
+    }
+
+    pub fn migrate(&self) -> ApiResult<Self> {
+        // TODO: Call the migrate script from js
+        Ok(self.clone())
+    }
+}
+
+#[derive(Clone, Debug, Serialize, TS)]
+#[serde(untagged)]
+// #[ts(untagged)]
+pub enum OptionalUpdate<T: Clone> {
+    #[ts(skip)]
+    SetDefault,
+
+    // #[ts(skip)]
+    // #[ts(type = "undefined")]
+    Missing,
+
+    // #[ts(type = "_")]
+    // #[ts(untagged)]
+    Update(T),
+}
+
+// #[derive(Clone, Debug, Serialize, TS)]
+// #[serde(flatten)]
+// pub struct OptionalUpdate<T: Clone> {
+//     #[ts(optional)]
+//     inner: Option<OptionalUpdateInner<T>>,
+// }
+
+// // #[ts(optional = nullable)]
+
+// #[derive(Clone, Debug, Serialize, TS)]
+// pub struct OptionalUpdateInner<T: Clone>(Option<T>);
+
+pub type PluginUpdate = OptionalUpdate<String>;
+pub type SettingsUpdate = OptionalUpdate<bool>;
+pub type ThemeUpdate = OptionalUpdate<String>;
+pub type TitleUpdate = OptionalUpdate<String>;
+pub type VersionUpdate = OptionalUpdate<String>;
+pub type ColumnConfigUpdate = OptionalUpdate<HashMap<String, ColumnConfigValues>>;
+
+/// Handles `{}` when included as a field with `#[serde(default)]`.
+impl<T: Clone> Default for OptionalUpdate<T> {
+    fn default() -> Self {
+        Self::Missing
+    }
+}
+
+/// Handles `{plugin: null}` and `{plugin: val}` by treating this type as an
+/// option.
+impl<T: Clone> From<Option<T>> for OptionalUpdate<T> {
+    fn from(opt: Option<T>) -> Self {
+        match opt {
+            Some(v) => Self::Update(v),
+            None => Self::SetDefault,
+        }
+    }
+}
+
+/// Treats `PluginUpdate` enum as an `Option<T>` when present during
+/// deserialization.
+impl<'a, T> Deserialize<'a> for OptionalUpdate<T>
+where
+    T: Deserialize<'a> + Clone,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'a>,
+    {
+        Option::deserialize(deserializer).map(Into::into)
+    }
+}

package/src/rust/custom_elements/column_dropdown.rs

@@ -0,0 +1,123 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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 std::collections::HashSet;
+
+use perspective_client::clone;
+use perspective_client::config::Expression;
+use perspective_js::json;
+use perspective_js::utils::global;
+use wasm_bindgen::JsCast;
+use wasm_bindgen::prelude::*;
+use web_sys::*;
+use yew::html::ImplicitClone;
+use yew::{Callback, props};
+
+use crate::components::column_dropdown::*;
+use crate::components::column_selector::InPlaceColumn;
+use crate::custom_elements::modal::*;
+use crate::session::Session;
+use crate::*;
+
+#[wasm_bindgen]
+#[derive(Clone)]
+pub struct ColumnDropDownElement {
+    modal: ModalElement<ColumnDropDown>,
+    session: Session,
+}
+
+impl ImplicitClone for ColumnDropDownElement {}
+
+impl ColumnDropDownElement {
+    pub fn new(session: Session) -> Self {
+        let dropdown = global::document()
+            .create_element("perspective-dropdown")
+            .unwrap()
+            .unchecked_into::<HtmlElement>();
+
+        let props = props!(ColumnDropDownProps {});
+        let modal = ModalElement::new(dropdown, props, false, None);
+        Self { modal, session }
+    }
+
+    pub fn autocomplete(
+        &self,
+        target: HtmlInputElement,
+        exclude: HashSet<String>,
+        callback: Callback<InPlaceColumn>,
+    ) -> Option<()> {
+        let input = target.value();
+        let metadata = self.session.metadata();
+        let mut values: Vec<InPlaceColumn> = vec![];
+        let small_input = input.to_lowercase();
+        for col in metadata.get_table_columns()? {
+            if !exclude.contains(col) && col.to_lowercase().contains(&small_input) {
+                values.push(InPlaceColumn::Column(col.to_owned()));
+            }
+        }
+
+        for col in self.session.metadata().get_expression_columns() {
+            if !exclude.contains(col) && col.to_lowercase().contains(&small_input) {
+                values.push(InPlaceColumn::Column(col.to_owned()));
+            }
+        }
+
+        clone!(self.modal, self.session);
+        ApiFuture::spawn(async move {
+            if !exclude.contains(&input) {
+                let is_expr = session.validate_expr(&input).await?.is_none();
+
+                if is_expr {
+                    values.push(InPlaceColumn::Expression(Expression::new(
+                        None,
+                        input.into(),
+                    )));
+                }
+            }
+
+            let classes = modal.custom_element.class_list();
+            let no_results = json!(["no-results"]);
+            if values.is_empty() {
+                classes.add(&no_results).unwrap();
+            } else {
+                classes.remove(&no_results).unwrap();
+            }
+
+            modal.send_message_batch(vec![
+                ColumnDropDownMsg::SetCallback(callback),
+                ColumnDropDownMsg::SetValues(values, target.get_bounding_client_rect().width()),
+            ]);
+
+            modal.open(target.unchecked_into(), None).await
+        });
+
+        Some(())
+    }
+
+    pub fn item_select(&self) {
+        self.modal.send_message(ColumnDropDownMsg::ItemSelect);
+    }
+
+    pub fn item_down(&self) {
+        self.modal.send_message(ColumnDropDownMsg::ItemDown);
+    }
+
+    pub fn item_up(&self) {
+        self.modal.send_message(ColumnDropDownMsg::ItemUp);
+    }
+
+    pub fn hide(&self) -> ApiResult<()> {
+        self.modal.hide()
+    }
+
+    pub fn connected_callback(&self) {}
+}

package/src/rust/custom_elements/copy_dropdown.rs

@@ -0,0 +1,112 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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 std::cell::RefCell;
+use std::rc::Rc;
+
+use ::perspective_js::utils::{global, *};
+use wasm_bindgen::prelude::*;
+use wasm_bindgen_futures::spawn_local;
+use web_sys::*;
+use yew::*;
+
+use super::modal::*;
+use super::viewer::PerspectiveViewerElement;
+use crate::components::copy_dropdown::{CopyDropDownMenu, CopyDropDownMenuProps};
+use crate::js::*;
+use crate::model::*;
+use crate::utils::*;
+
+#[wasm_bindgen]
+#[derive(Clone)]
+pub struct CopyDropDownMenuElement {
+    elem: HtmlElement,
+    modal: Rc<RefCell<Option<ModalElement<CopyDropDownMenu>>>>,
+}
+
+impl CustomElementMetadata for CopyDropDownMenuElement {
+    const CUSTOM_ELEMENT_NAME: &'static str = "perspective-copy-menu";
+}
+
+#[wasm_bindgen]
+impl CopyDropDownMenuElement {
+    #[wasm_bindgen(constructor)]
+    pub fn new(elem: HtmlElement) -> Self {
+        Self {
+            elem,
+            modal: Default::default(),
+        }
+    }
+
+    pub fn open(&self, target: HtmlElement) {
+        if let Some(x) = &*self.modal.borrow() {
+            ApiFuture::spawn(x.clone().open(target, None));
+        }
+    }
+
+    pub fn hide(&self) -> ApiResult<()> {
+        let borrowed = self.modal.borrow();
+        borrowed.as_ref().into_apierror()?.hide()
+    }
+
+    /// Internal Only.
+    ///
+    /// Set this custom element model's raw pointer.
+    pub fn set_model(&self, parent: &PerspectiveViewerElement) {
+        self.set_config_model(parent)
+    }
+
+    pub fn connected_callback(&self) {}
+}
+
+impl CopyDropDownMenuElement {
+    pub fn new_from_model<A: GetViewerConfigModel>(model: &A) -> 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
+    }
+
+    pub fn set_config_model<A: GetViewerConfigModel>(&self, model: &A) {
+        let callback = Callback::from({
+            let model = model.cloned();
+            let modal_rc = self.modal.clone();
+            move |x: ExportFile| {
+                let model = model.clone();
+                let modal = modal_rc.borrow().clone().unwrap();
+                spawn_local(async move {
+                    let mime = x.method.mimetype(x.is_chart);
+                    let task = model.export_method_to_jsvalue(x.method);
+                    let result = copy_to_clipboard(task, mime).await;
+                    crate::js_log_maybe!({
+                        result?;
+                        modal.hide()?;
+                    })
+                })
+            }
+        });
+
+        let renderer = model.renderer().clone();
+        let props = props!(CopyDropDownMenuProps {
+            renderer,
+            callback,
+            root: self.elem.clone()
+        });
+
+        let modal = ModalElement::new(self.elem.clone(), props, true, None);
+        *self.modal.borrow_mut() = Some(modal);
+    }
+}

package/src/rust/custom_elements/debug_plugin.rs

@@ -0,0 +1,114 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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 wasm_bindgen::prelude::*;
+
+use crate::utils::*;
+use crate::*;
+
+/// The `<perspective-viewer-plugin>` element.
+///
+/// The default perspective plugin which is registered and activated
+/// automcatically when a `<perspective-viewer>` is loaded without plugins.
+/// While you will not typically instantiate this class directly, it is simple
+/// enough to function as a good "default" plugin implementation which can be
+/// extended to create custom plugins.
+///
+/// # Example
+/// ```javascript
+/// class MyPlugin extends customElements.get("perspective-viewer-plugin") {
+///    // Custom plugin overrides
+/// }
+/// ```
+#[wasm_bindgen]
+pub struct PerspectiveDebugPluginElement {
+    elem: web_sys::HtmlElement,
+}
+
+impl CustomElementMetadata for PerspectiveDebugPluginElement {
+    const CUSTOM_ELEMENT_NAME: &'static str = "perspective-viewer-plugin";
+}
+
+#[wasm_bindgen]
+impl PerspectiveDebugPluginElement {
+    #[wasm_bindgen(constructor)]
+    pub fn new(elem: web_sys::HtmlElement) -> Self {
+        Self { elem }
+    }
+
+    #[wasm_bindgen(getter)]
+    pub fn name(&self) -> String {
+        "Debug".to_owned()
+    }
+
+    #[wasm_bindgen(getter)]
+    pub fn select_mode(&self) -> String {
+        "select".to_owned()
+    }
+
+    #[wasm_bindgen(getter)]
+    pub fn min_config_columns(&self) -> JsValue {
+        JsValue::UNDEFINED
+    }
+
+    #[wasm_bindgen(getter)]
+    pub fn config_column_names(&self) -> JsValue {
+        JsValue::UNDEFINED
+    }
+
+    pub fn update(&self, view: &perspective_js::View) -> ApiFuture<()> {
+        self.draw(view)
+    }
+
+    /// # Notes
+    ///
+    /// When you pass a `wasm_bindgen` wrapped type _into_ Rust, it acts like a
+    /// move. Ergo, if you replace the `&` in the `view` argument, the JS copy
+    /// of the `View` will be invalid
+    pub fn draw(&self, view: &perspective_js::View) -> ApiFuture<()> {
+        let css = "margin:0;overflow:scroll;position:absolute;width:100%;height:100%";
+        clone!(self.elem, view);
+        ApiFuture::new(async move {
+            let csv = view.to_csv(None).await?;
+            elem.style().set_property("background-color", "#fff")?;
+            elem.set_inner_html(&format!("<pre style='{css}'>{csv}</pre>"));
+            Ok(())
+        })
+    }
+
+    pub fn clear(&self) -> ApiFuture<()> {
+        ApiFuture::default()
+    }
+
+    pub fn resize(&self) -> ApiFuture<()> {
+        ApiFuture::default()
+    }
+
+    pub fn restyle(&self) -> ApiFuture<()> {
+        ApiFuture::default()
+    }
+
+    pub fn save(&self) -> ApiFuture<()> {
+        ApiFuture::default()
+    }
+
+    pub fn restore(&self) -> ApiFuture<()> {
+        ApiFuture::default()
+    }
+
+    pub fn delete(&self) -> ApiFuture<()> {
+        ApiFuture::default()
+    }
+
+    #[wasm_bindgen(js_name = "connectedCallback")]
+    pub fn connected_callback(&self) {}
+}