@perspective-dev/viewer 4.0.0

package/src/rust/js/plugin.rs

@@ -0,0 +1,167 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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::*;
+use serde::*;
+use wasm_bindgen::prelude::*;
+
+use crate::presentation::ColumnConfigMap;
+
+/// Perspective FFI
+#[wasm_bindgen]
+#[rustfmt::skip]
+extern "C" {
+    #[derive(Clone)]
+    pub type JsPerspectiveViewerPlugin;
+
+    #[wasm_bindgen(method, getter)]
+    pub fn name(this: &JsPerspectiveViewerPlugin) -> String;
+
+    #[wasm_bindgen(method, getter)]
+    pub fn category(this: &JsPerspectiveViewerPlugin) -> Option<String>;
+
+    #[wasm_bindgen(method, getter)]
+    pub fn max_columns(this: &JsPerspectiveViewerPlugin) -> Option<usize>;
+
+    #[wasm_bindgen(method, getter)]
+    pub fn max_cells(this: &JsPerspectiveViewerPlugin) -> Option<usize>;
+
+    // TODO This can be an internal property
+    #[wasm_bindgen(method, getter)]
+    pub fn render_warning(this: &JsPerspectiveViewerPlugin) -> Option<bool>;
+
+    #[wasm_bindgen(method, setter)]
+    pub fn set_render_warning(this: &JsPerspectiveViewerPlugin, val: bool);
+
+    #[wasm_bindgen(method, getter)]
+    pub fn select_mode(this: &JsPerspectiveViewerPlugin) -> JsValue;
+
+    #[wasm_bindgen(method, getter)]
+    pub fn min_config_columns(this: &JsPerspectiveViewerPlugin) -> Option<usize>;
+
+    #[wasm_bindgen(method, getter)]
+    pub fn config_column_names(this: &JsPerspectiveViewerPlugin) -> Option<js_sys::Array>;
+
+    #[wasm_bindgen(method, getter)]
+    pub fn priority(this: &JsPerspectiveViewerPlugin) -> Option<i32>;
+
+    /// Don't call this method directly. Instead, call the corresponding method on the PluginColumnStyles model.
+    #[wasm_bindgen(method, catch)]
+    pub fn can_render_column_styles(this: &JsPerspectiveViewerPlugin, view_type: &str, group: Option<&str>) -> ApiResult<bool>;
+
+    #[wasm_bindgen(method, catch)]
+    pub fn column_style_controls(this: &JsPerspectiveViewerPlugin, view_type: &str, group: Option<&str>) -> ApiResult<JsValue>;
+
+    #[wasm_bindgen(method, catch)]
+    pub fn save(this: &JsPerspectiveViewerPlugin) -> ApiResult<JsValue>;
+
+    #[wasm_bindgen(method, js_name=restore, catch)]
+    pub fn _restore(this: &JsPerspectiveViewerPlugin, token: &JsValue, columns_config: &JsValue) -> ApiResult<()>;
+
+    #[wasm_bindgen(method)]
+    pub fn delete(this: &JsPerspectiveViewerPlugin);
+
+    #[wasm_bindgen(method, catch)]
+    pub async fn restyle(
+        this: &JsPerspectiveViewerPlugin,
+        view: perspective_js::View
+    ) -> ApiResult<JsValue>;
+
+    #[wasm_bindgen(method, catch)]
+    pub async fn draw(
+        this: &JsPerspectiveViewerPlugin,
+        view: perspective_js::View,
+        column_limit: Option<usize>,
+        row_limit: Option<usize>,
+        force: bool
+    ) -> ApiResult<()>;
+
+    #[wasm_bindgen(method, catch)]
+    pub async fn update(
+        this: &JsPerspectiveViewerPlugin,
+        view: perspective_js::View,
+        column_limit: Option<usize>,
+        row_limit: Option<usize>,
+        force: bool
+    ) -> ApiResult<()>;
+
+    #[wasm_bindgen(method, catch)]
+    pub async fn clear(this: &JsPerspectiveViewerPlugin) -> ApiResult<JsValue>;
+
+    #[wasm_bindgen(method, catch)]
+    pub async fn resize(this: &JsPerspectiveViewerPlugin) -> ApiResult<JsValue>;
+
+}
+
+impl JsPerspectiveViewerPlugin {
+    pub fn restore(
+        &self,
+        token: &JsValue,
+        columns_config: Option<&ColumnConfigMap>,
+    ) -> ApiResult<()> {
+        let columns_config = JsValue::from_serde_ext(&columns_config).unwrap();
+        self._restore(token, &columns_config)
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default, Deserialize, Eq, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub enum ColumnSelectMode {
+    #[default]
+    Toggle,
+    Select,
+}
+
+impl ColumnSelectMode {
+    pub fn css(&self) -> yew::Classes {
+        match self {
+            Self::Toggle => yew::classes!("toggle-mode", "is_column_active"),
+            Self::Select => yew::classes!("select-mode", "is_column_active"),
+        }
+    }
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct ViewConfigRequirements {
+    pub min: Option<usize>,
+    pub names: Option<Vec<String>>,
+    pub mode: ColumnSelectMode,
+    pub max_columns: Option<usize>,
+    pub max_cells: Option<usize>,
+    pub name: String,
+    pub render_warning: bool,
+}
+
+impl ViewConfigRequirements {
+    pub fn is_swap(&self, index: usize) -> bool {
+        self.names
+            .as_ref()
+            .map(|x| index < x.len() - 1)
+            .unwrap_or(false)
+    }
+}
+
+impl JsPerspectiveViewerPlugin {
+    pub fn get_requirements(&self) -> ApiResult<ViewConfigRequirements> {
+        Ok(ViewConfigRequirements {
+            min: self.min_config_columns(),
+            mode: self.select_mode().into_serde_ext()?,
+            names: self
+                .config_column_names()
+                .map(|x| x.into_serde_ext().unwrap()),
+            max_columns: self.max_columns(),
+            max_cells: self.max_cells(),
+            name: self.name(),
+            render_warning: self.render_warning().unwrap_or(true),
+        })
+    }
+}

package/src/rust/js/resize_observer.rs

@@ -0,0 +1,37 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+// `rustfmt` removes `async` from extern blocks in rust stable
+// [issue](https://github.com/rust-lang/rustfmt/issues/4288)
+
+use wasm_bindgen::prelude::*;
+// use web_sys::HtmlElement;
+
+#[wasm_bindgen(inline_js = "export const ResizeObserver = window.ResizeObserver")]
+extern "C" {
+    pub type ResizeObserver;
+
+    #[wasm_bindgen(constructor, js_class = "ResizeObserver")]
+    pub fn new(callback: &js_sys::Function) -> ResizeObserver;
+
+    #[wasm_bindgen(method)]
+    pub fn observe(this: &ResizeObserver, elem: &web_sys::HtmlElement);
+
+    #[wasm_bindgen(method)]
+    pub fn unobserve(this: &ResizeObserver, elem: &web_sys::HtmlElement);
+
+    pub type ResizeObserverEntry;
+
+    #[wasm_bindgen(method, getter, js_name = "contentRect")]
+    pub fn content_rect(this: &ResizeObserverEntry) -> web_sys::DomRectReadOnly;
+
+}

package/src/rust/js/testing.rs

@@ -0,0 +1,149 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+#[cfg(test)]
+use wasm_bindgen::prelude::*;
+
+// Must use inline build because the test runner does not import itself in
+// the browser with `type=module` which causes `import.meta` calls to fail,
+// and `currentScript` does not resolve dynamic imports so the polyfill
+// for `import.meta` does not work either.
+#[cfg(test)]
+#[wasm_bindgen(inline_js = "
+
+    export async function worker() {
+        await import('/dist/wasm/test/perspective.js');
+        return window.perspective.worker();
+    }
+
+")]
+extern "C" {
+    fn worker() -> js_sys::Promise;
+}
+
+// /// Generate a test `Table`, but only create teh webworker once or the tests
+// /// will figuratively literally run forever.
+// #[cfg(test)]
+// pub async fn get_mock_table() -> JsPerspectiveTable {
+//     thread_local! {
+//         static WORKER: RefCell<Option<JsPerspectiveWorker>> =
+// RefCell::new(None);     }
+
+//     let worker: JsPerspectiveWorker = match WORKER.with(|x|
+// x.borrow().clone()) {         Some(x) => x,
+//         None => JsFuture::from(worker()).await.unwrap().unchecked_into(),
+//     };
+
+//     WORKER.with(|x| {
+//         *x.borrow_mut() = Some(worker.clone());
+//     });
+
+//     worker
+//         .table(
+//             json!({
+//                 "A": [1, 2, 3]
+//             })
+//             .unchecked_into(),
+//         )
+//         .await
+//         .unwrap()
+// }
+
+/// A macro which set a property called `weak_link` on the container
+/// `Properties` when `cfg(test)`, such that unit tests may send messages to a
+/// component.
+///
+/// This macro needs to be called in `create()` on any Component which needs to
+/// receive messages in a test.
+#[macro_export]
+macro_rules! enable_weak_link_test {
+    ($props:expr, $link:expr) => {
+        #[cfg(test)]
+        {
+            *$props.weak_link.borrow_mut() = Some($link.clone());
+        }
+    };
+}
+
+/// A macro which derives a `yew::Component` for an arbitrary HTML snippet and
+/// mounts it, for testing.
+#[macro_export]
+macro_rules! test_html {
+    ($($html:tt)*) => {{
+        use wasm_bindgen::JsCast;
+        use yew::prelude::*;
+
+        struct TestElement {}
+
+        #[derive(Properties, PartialEq)]
+        struct TestElementProps {
+            html: Html,
+            root: NodeRef,
+        }
+
+        impl Component for TestElement {
+            type Message = ();
+            type Properties = TestElementProps;
+
+            fn create(_ctx: &Context<Self>) -> Self {
+                TestElement {}
+            }
+
+            fn update(&mut self, _ctx: &Context<Self>, _msg: Self::Message) -> bool {
+                false
+            }
+
+            fn changed(&mut self, _ctx: &Context<Self>, _old: &Self::Properties) -> bool {
+                true
+            }
+
+            fn view(&self, ctx: &Context<Self>) -> Html {
+                html! {
+                    <>
+                        <style>
+                            { "#test{position:absolute;top:0;bottom:0;left:0;right:0;}" }
+                        </style>
+                        <div ref={ ctx.props().root.clone() }>
+                            { ctx.props().html.clone() }
+                        </div>
+                    </>
+                }
+            }
+        }
+
+        let document = ::perspective_js::utils::global::document();
+        let body = document.body().unwrap();
+        let div = document.create_element("div").unwrap();
+        body.append_child(&div).unwrap();
+
+        let init = web_sys::ShadowRootInit::new(web_sys::ShadowRootMode::Open);
+        let shadow_root = div
+            .attach_shadow(&init)
+            .unwrap()
+            .unchecked_into::<web_sys::Element>();
+
+        let root = NodeRef::default();
+        let props = TestElementProps {
+            html: html!{ $($html)* },
+            root: root.clone(),
+        };
+
+        yew::Renderer::<TestElement>::with_root_and_props(shadow_root, props).render();
+        request_animation_frame().await;
+        root.cast::<web_sys::HtmlElement>()
+            .unwrap()
+            .children()
+            .get_with_index(0)
+            .unwrap()
+            .unchecked_into::<web_sys::HtmlElement>()
+    }}
+}

package/src/rust/lib.rs

@@ -0,0 +1,116 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+//! The API for the [`@perspective-dev/viewer`]() 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)]
+#![allow(async_fn_in_trait)]
+#![warn(
+    clippy::all,
+    clippy::panic_in_result_fn,
+    clippy::await_holding_refcell_ref
+)]
+
+pub mod components;
+pub mod config;
+pub mod custom_elements;
+mod custom_events;
+mod dragdrop;
+pub mod exprtk;
+mod js;
+
+#[doc(hidden)]
+pub mod model;
+mod presentation;
+mod renderer;
+mod session;
+pub mod utils;
+
+use perspective_js::utils::*;
+use wasm_bindgen::prelude::*;
+
+use crate::custom_elements::copy_dropdown::CopyDropDownMenuElement;
+use crate::custom_elements::debug_plugin::PerspectiveDebugPluginElement;
+use crate::custom_elements::export_dropdown::ExportDropDownMenuElement;
+use crate::custom_elements::viewer::PerspectiveViewerElement;
+use crate::utils::define_web_component;
+
+#[wasm_bindgen(typescript_custom_section)]
+const TS_APPEND_CONTENT: &'static str = r#"
+import type {
+    TableInitOptions, 
+    ColumnWindow,
+    ViewWindow, 
+    OnUpdateOptions,
+    UpdateOptions,
+    DeleteOptions,
+    ViewConfigUpdate,
+    SystemInfo,
+} from "@perspective-dev/client";
+"#;
+
+/// Register a plugin globally.
+#[wasm_bindgen]
+#[allow(non_snake_case)]
+pub fn registerPlugin(name: &str) {
+    use crate::renderer::*;
+    PLUGIN_REGISTRY.register_plugin(name);
+}
+
+/// Register this crate's Custom Elements in the browser's current session.
+///
+/// This must occur before calling any public API methods on these Custom
+/// Elements from JavaScript, as the methods themselves won't be defined yet.
+/// By default, this crate does not register `PerspectiveViewerElement` (as to
+/// preserve backwards-compatible synchronous API).
+#[cfg(not(feature = "external-bootstrap"))]
+#[wasm_bindgen(js_name = "init")]
+pub fn js_init() {
+    perspective_js::utils::set_global_logging();
+    define_web_components!("export * as psp from '../../perspective-viewer.js'");
+    tracing::info!("Perspective initialized.");
+}
+
+/// Register Web Components with the global registry, given a Perspective
+/// module.
+///
+/// This function shouldn't be called directly;  instead, use the
+/// `define_web_components!` macro to both call this method and hook the
+/// wasm_bindgen module object.
+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);
+}
+
+#[macro_export]
+macro_rules! define_web_components {
+    ($x:expr) => {{
+        #[wasm_bindgen::prelude::wasm_bindgen(inline_js = $x)]
+        extern "C" {
+            #[wasm_bindgen::prelude::wasm_bindgen(js_name = "psp")]
+            #[wasm_bindgen::prelude::wasm_bindgen(thread_local_v2)]
+            pub static PSP: wasm_bindgen::prelude::JsValue;
+        }
+
+        PSP.with(|x| $crate::bootstrap_web_components(x));
+    }};
+}