@perspective-dev/viewer 4.0.0

package/src/rust/custom_elements/export_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::viewer::PerspectiveViewerElement;
+use crate::components::export_dropdown::*;
+use crate::custom_elements::modal::*;
+use crate::model::*;
+use crate::utils::*;
+use crate::*;
+
+#[wasm_bindgen]
+#[derive(Clone)]
+pub struct ExportDropDownMenuElement {
+    elem: HtmlElement,
+    modal: Rc<RefCell<Option<ModalElement<ExportDropDownMenu>>>>,
+}
+
+impl CustomElementMetadata for ExportDropDownMenuElement {
+    const CUSTOM_ELEMENT_NAME: &'static str = "perspective-export-menu";
+}
+
+#[wasm_bindgen]
+impl ExportDropDownMenuElement {
+    #[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 ExportDropDownMenuElement {
+    pub fn new_from_model<A: GetViewerConfigModel>(model: &A) -> 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
+    }
+
+    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| {
+                if !x.name.is_empty() {
+                    clone!(modal_rc, model);
+                    spawn_local(async move {
+                        let val = model.export_method_to_jsvalue(x.method).await.unwrap();
+                        let is_chart = model.renderer().is_chart();
+                        download(&x.as_filename(is_chart), &val).unwrap();
+                        modal_rc.borrow().clone().unwrap().hide().unwrap();
+                    })
+                }
+            }
+        });
+
+        let renderer = model.renderer().clone();
+        let presentation = model.presentation().clone();
+        let props = props!(ExportDropDownMenuProps {
+            renderer,
+            presentation,
+            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/filter_dropdown.rs

@@ -0,0 +1,179 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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::collections::HashSet;
+use std::rc::Rc;
+
+use perspective_client::clone;
+use perspective_js::utils::global;
+use wasm_bindgen::JsCast;
+use wasm_bindgen::prelude::*;
+use web_sys::*;
+use yew::html::ImplicitClone;
+use yew::*;
+
+use crate::components::filter_dropdown::*;
+use crate::custom_elements::modal::*;
+use crate::session::Session;
+use crate::*;
+
+#[wasm_bindgen]
+#[derive(Clone)]
+pub struct FilterDropDownElement {
+    modal: ModalElement<FilterDropDown>,
+    session: Session,
+    column: Rc<RefCell<Option<(usize, String)>>>,
+    values: Rc<RefCell<Option<Vec<String>>>>,
+    target: Rc<RefCell<Option<HtmlElement>>>,
+}
+
+impl PartialEq for FilterDropDownElement {
+    fn eq(&self, other: &Self) -> bool {
+        self.column == other.column && self.values == other.values && self.target == other.target
+    }
+}
+
+impl ImplicitClone for FilterDropDownElement {}
+
+impl FilterDropDownElement {
+    pub fn new(session: Session) -> Self {
+        let dropdown = global::document()
+            .create_element("perspective-dropdown")
+            .unwrap()
+            .unchecked_into::<HtmlElement>();
+
+        let column: Rc<RefCell<Option<(usize, String)>>> = Rc::new(RefCell::new(None));
+        let props = props!(FilterDropDownProps {});
+        let modal = ModalElement::new(dropdown, props, false, None);
+        let values = Rc::new(RefCell::new(None));
+        Self {
+            modal,
+            session,
+            column,
+            values,
+            target: Default::default(),
+        }
+    }
+
+    pub fn reautocomplete(&self) {
+        ApiFuture::spawn(
+            self.modal
+                .clone()
+                .open(self.target.borrow().clone().unwrap(), None),
+        );
+    }
+
+    pub fn autocomplete(
+        &self,
+        column: (usize, String),
+        input: String,
+        exclude: HashSet<String>,
+        target: HtmlElement,
+        callback: Callback<String>,
+    ) {
+        let current_column = self.column.borrow().clone();
+        match current_column {
+            Some(filter_col) if filter_col == column => {
+                let values = filter_values(&input, &self.values, &exclude);
+                if values.len() == 1 && values[0] == input {
+                    self.hide().unwrap();
+                } else {
+                    self.modal.send_message_batch(vec![
+                        FilterDropDownMsg::SetCallback(callback),
+                        FilterDropDownMsg::SetValues(values),
+                    ]);
+
+                    if let Some(x) = self.target.borrow().clone()
+                        && !self.modal.is_open()
+                    {
+                        ApiFuture::spawn(self.modal.clone().open(x, None))
+                    }
+                }
+            },
+            _ => {
+                ApiFuture::spawn({
+                    clone!(
+                        self.modal,
+                        self.session,
+                        self.values,
+                        old_column = self.column,
+                        old_target = self.target
+                    );
+                    async move {
+                        let all_values = session.get_column_values(column.1.clone()).await?;
+                        *values.borrow_mut() = Some(all_values);
+                        let filter_values = filter_values(&input, &values, &exclude);
+                        if filter_values.len() == 1 && filter_values[0] == input {
+                            *old_column.borrow_mut() = Some(column);
+                            *old_target.borrow_mut() = Some(target.clone());
+                            let filter_values = self::filter_values("", &values, &exclude);
+                            modal.send_message_batch(vec![
+                                FilterDropDownMsg::SetCallback(callback),
+                                FilterDropDownMsg::SetValues(filter_values),
+                            ]);
+
+                            modal.hide()
+                        } else {
+                            *old_column.borrow_mut() = Some(column);
+                            *old_target.borrow_mut() = Some(target.clone());
+                            modal.send_message_batch(vec![
+                                FilterDropDownMsg::SetCallback(callback),
+                                FilterDropDownMsg::SetValues(filter_values),
+                            ]);
+
+                            modal.open(target, None).await
+                        }
+                    }
+                });
+            },
+        }
+    }
+
+    pub fn item_select(&self) {
+        self.modal.send_message(FilterDropDownMsg::ItemSelect);
+    }
+
+    pub fn item_down(&self) {
+        self.modal.send_message(FilterDropDownMsg::ItemDown);
+    }
+
+    pub fn item_up(&self) {
+        self.modal.send_message(FilterDropDownMsg::ItemUp);
+    }
+
+    pub fn hide(&self) -> ApiResult<()> {
+        let result = self.modal.hide();
+        drop(self.column.borrow_mut().take());
+        result
+    }
+
+    pub fn connected_callback(&self) {}
+}
+
+fn filter_values(
+    input: &str,
+    values: &Rc<RefCell<Option<Vec<String>>>>,
+    exclude: &HashSet<String>,
+) -> Vec<String> {
+    let input = input.to_lowercase();
+    if let Some(values) = &*values.borrow() {
+        values
+            .iter()
+            .filter(|x| x.to_lowercase().contains(&input) && !exclude.contains(x.as_str()))
+            .take(10)
+            .cloned()
+            .collect::<Vec<String>>()
+    } else {
+        vec![]
+    }
+}

package/src/rust/custom_elements/function_dropdown.rs

@@ -0,0 +1,115 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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_client::config::{COMPLETIONS, CompletionItemSuggestion};
+use perspective_js::utils::global;
+use wasm_bindgen::JsCast;
+use wasm_bindgen::prelude::*;
+use web_sys::*;
+use yew::html::ImplicitClone;
+use yew::*;
+
+use crate::components::function_dropdown::*;
+use crate::custom_elements::modal::*;
+use crate::*;
+
+#[wasm_bindgen]
+#[derive(Clone)]
+pub struct FunctionDropDownElement {
+    modal: ModalElement<FunctionDropDown>,
+    target: Rc<RefCell<Option<HtmlElement>>>,
+}
+
+impl PartialEq for FunctionDropDownElement {
+    fn eq(&self, _other: &Self) -> bool {
+        true
+    }
+}
+
+impl ImplicitClone for FunctionDropDownElement {}
+
+impl FunctionDropDownElement {
+    pub fn reautocomplete(&self) {
+        ApiFuture::spawn(
+            self.modal
+                .clone()
+                .open(self.target.borrow().clone().unwrap(), None),
+        );
+    }
+
+    pub fn autocomplete(
+        &self,
+        input: String,
+        target: HtmlElement,
+        callback: Callback<CompletionItemSuggestion>,
+    ) -> ApiResult<()> {
+        let values = filter_values(&input);
+        if values.is_empty() {
+            self.modal.hide()?;
+        } else {
+            self.modal.send_message_batch(vec![
+                FunctionDropDownMsg::SetCallback(callback),
+                FunctionDropDownMsg::SetValues(values),
+            ]);
+
+            ApiFuture::spawn(self.modal.clone().open(target, None));
+        }
+
+        Ok(())
+    }
+
+    pub fn item_select(&self) {
+        self.modal.send_message(FunctionDropDownMsg::ItemSelect);
+    }
+
+    pub fn item_down(&self) {
+        self.modal.send_message(FunctionDropDownMsg::ItemDown);
+    }
+
+    pub fn item_up(&self) {
+        self.modal.send_message(FunctionDropDownMsg::ItemUp);
+    }
+
+    pub fn hide(&self) -> ApiResult<()> {
+        self.modal.hide()
+    }
+
+    pub fn connected_callback(&self) {}
+}
+
+impl Default for FunctionDropDownElement {
+    fn default() -> Self {
+        let dropdown = global::document()
+            .create_element("perspective-dropdown")
+            .unwrap()
+            .unchecked_into::<HtmlElement>();
+
+        let props = props!(FunctionDropDownProps {});
+        let modal = ModalElement::new(dropdown, props, false, None);
+        Self {
+            modal,
+            target: Default::default(),
+        }
+    }
+}
+
+fn filter_values(input: &str) -> Vec<CompletionItemSuggestion> {
+    let input = input.to_lowercase();
+    COMPLETIONS
+        .iter()
+        .filter(|x| x.label.to_lowercase().starts_with(&input))
+        .cloned()
+        .collect::<Vec<_>>()
+}

package/src/rust/custom_elements/mod.rs

@@ -0,0 +1,24 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+mod column_dropdown;
+pub mod copy_dropdown;
+pub mod debug_plugin;
+pub mod export_dropdown;
+mod filter_dropdown;
+mod function_dropdown;
+pub mod modal;
+pub mod viewer;
+
+pub use self::column_dropdown::*;
+pub use self::filter_dropdown::*;
+pub use self::function_dropdown::*;