@perspective-dev/viewer 4.0.1 → 4.1.0

package/src/rust/model/structural.rs

@@ -15,59 +15,230 @@
 //! `struct`s only if the define accessors for the necessary applications state
 //! objects (which are conviently derivable with the `derive_model!` macro).
 
+use yew::Component;
+
+use crate::custom_events::*;
 use crate::dragdrop::*;
 use crate::presentation::*;
 use crate::renderer::*;
+use crate::root::*;
 use crate::session::*;
 
-pub trait HasSession {
-    fn session(&self) -> &'_ Session;
+pub trait HasCustomEvents {
+    fn custom_events(&self) -> &'_ CustomEvents;
 }
 
-pub trait HasRenderer {
-    fn renderer(&self) -> &'_ Renderer;
+pub trait HasDragDrop {
+    fn dragdrop(&self) -> &'_ DragDrop;
 }
 
 pub trait HasPresentation {
     fn presentation(&self) -> &'_ Presentation;
 }
 
-pub trait HasDragDrop {
-    fn dragdrop(&self) -> &'_ DragDrop;
+pub trait HasRoot {
+    /// Use an assoociated type to prevent a (circular) dependency on
+    /// [`crate::components`].
+    type RootComponent: Component;
+    fn root(&self) -> &'_ Root<Self::RootComponent>;
+}
+
+pub trait HasRenderer {
+    fn renderer(&self) -> &'_ Renderer;
+}
+
+pub trait HasSession {
+    fn session(&self) -> &'_ Session;
+}
+
+impl HasSession for Session {
+    fn session(&self) -> &'_ Session {
+        self
+    }
 }
 
 #[macro_export]
-macro_rules! derive_model {
-    (DragDrop for $key:ty) => {
-        impl $crate::model::HasDragDrop for $key {
-            fn dragdrop(&self) -> &'_ DragDrop {
+macro_rules! PerspectiveProperties {
+    // (impl @tuple $name:ident CustomEvents $x:tt) => {
+    //     impl $crate::model::HasCustomEvents for $name {
+    //         fn custom_events(&self) -> &'_ CustomEvents {
+    //             &self.$x
+    //         }
+    //     }
+    // };
+
+    // (impl @tuple $name:ident DragDrop $x:tt) => {
+    //     impl $crate::model::HasDragDrop for $name {
+    //         fn dragdrop(&self) -> &'_ DragDrop {
+    //             &self.$x
+    //         }
+    //     }
+    // };
+
+    // (impl @tuple $name:ident Presentatio $x:tt) => {
+    //     impl $crate::model::HasPresentation for $name {
+    //         fn presentation(&self) -> &'_ Presentation {
+    //             &self.$x
+    //         }
+    //     }
+    // };
+
+    // (impl @tuple $name:ident Renderer $x:tt) => {
+    //     impl $crate::model::HasRenderer for $name {
+    //         fn renderer(&self) -> &'_ Renderer {
+    //             &self.$x
+    //         }
+    //     }
+    // };
+
+    // (impl @tuple $name:ident Root $x:tt) => {
+    //     impl $crate::model::HasRoot for $name {
+    //         type RootComponent = $crate::components::viewer::PerspectiveViewer;
+    //         fn root(&self) -> &'_ Root<Self::RootComponent> {
+    //             &self.$x
+    //         }
+    //     }
+    // };
+
+    // (impl @tuple $name:ident Session $x:tt) => {
+    //     impl $crate::model::HasSession for $name {
+    //         fn session(&self) -> &'_ Session {
+    //             &self.$x
+    //         }
+    //     }
+    // };
+
+    // (impl @tuple $name:ident *_x:tt $x:tt) => {};
+
+    (impl @field $name:ident custom_events $value:ty) => {
+        impl $crate::model::HasCustomEvents for $name {
+            fn custom_events(&self) -> &'_ $value {
+                &self.custom_events
+            }
+        }
+    };
+
+    (impl @field $name:ident dragdrop $value:ty) => {
+        impl $crate::model::HasDragDrop for $name {
+            fn dragdrop(&self) -> &'_ $value {
                 &self.dragdrop
             }
         }
     };
-    (Renderer for $key:ty) => {
-        impl $crate::model::HasRenderer for $key {
-            fn renderer(&self) -> &'_ Renderer {
+
+    (impl @field $name:ident presentation $value:ty) => {
+        impl $crate::model::HasPresentation for $name {
+            fn presentation(&self) -> &'_ $value {
+                &self.presentation
+            }
+        }
+    };
+
+    (impl @field $name:ident renderer $value:ty) => {
+        impl $crate::model::HasRenderer for $name {
+            fn renderer(&self) -> &'_ $value {
                 &self.renderer
             }
         }
     };
-    (Session for $key:ty) => {
-        impl $crate::model::HasSession for $key {
-            fn session(&self) -> &'_ Session {
+
+    (impl @field $name:ident root $value:ty) => {
+        impl $crate::model::HasRoot for $name {
+            type RootComponent = $crate::components::viewer::PerspectiveViewer;
+            fn root(&self) -> &'_ $value {
+                &self.root
+            }
+        }
+    };
+
+    (impl @field $name:ident session $value:ty) => {
+        impl $crate::model::HasSession for $name {
+            fn session(&self) -> &'_ $value {
                 &self.session
             }
         }
     };
-    (Presentation for $key:ty) => {
-        impl $crate::model::HasPresentation for $key {
-            fn presentation(&self) -> &'_ Presentation {
-                &self.presentation
+
+    (impl @field $name:ident $x:ident $value:ty) => {};
+
+    (impl @fields_provider $name:ident {$($x:tt : $y:ty,)*} custom_events, $($field:ident,)*) => {
+        PerspectiveProperties!(impl @fields_provider $name { custom_events : CustomEvents, $($x : $y,)*} $($field,)*);
+    };
+
+    (impl @fields_provider $name:ident {$($x:tt : $y:ty,)*} dragdrop, $($field:ident,)*) => {
+        PerspectiveProperties!(impl @fields_provider $name { dragdrop : DragDrop, $($x : $y,)*} $($field,)*);
+    };
+
+    (impl @fields_provider $name:ident {$($x:tt : $y:ty,)*} presentation, $($field:ident,)*) => {
+        PerspectiveProperties!(impl @fields_provider $name { presentation : Presentation, $($x : $y,)*} $($field,)*);
+    };
+
+    (impl @fields_provider $name:ident {$($x:tt : $y:ty,)*} renderer, $($field:ident,)*) => {
+        PerspectiveProperties!(impl @fields_provider $name { renderer : Renderer, $($x : $y,)*} $($field,)*);
+    };
+
+     (impl @fields_provider $name:ident {$($x:tt : $y:ty,)*} root, $($field:ident,)*) => {
+        PerspectiveProperties!(impl @fields_provider $name { root : Root<$crate::components::viewer::PerspectiveViewer>, $($x : $y,)*} $($field,)*);
+    };
+
+    (impl @fields_provider $name:ident {$($x:tt : $y:ty,)*} session, $($field:ident,)*) => {
+        PerspectiveProperties!(impl @fields_provider $name { session : Session, $($x : $y,)*} $($field,)*);
+    };
+
+    (impl @fields_provider $name:ident {$($x:tt : $y:ty,)*} $_x:ident, $($field:ident,)*) => {
+        PerspectiveProperties!(impl @fields_provider $name {$($x : $y,)*} $($field,)*);
+    };
+
+    (impl @fields_provider $name:ident {}) => {};
+
+    (impl @fields_provider $name:ident {$($x:tt : $y:ty,)*}) => {
+        perspective_client::vendor::paste::paste! {
+            #[derive(PartialEq, Clone)]
+            pub struct [< $name State >] {
+                $($x: $y,)*
             }
+
+            impl $crate::model::StateProvider for $name {
+                type State = [< $name State >];
+                fn clone_state(&self) -> Self::State {
+                    Self::State {
+                        $($x : self.$x.clone(),)*
+                    }
+                }
+            }
+
+            PerspectiveProperties!(impl @fields [< $name State >] $($x : $y,)*);
         }
     };
-    ($i:ident, $($is:ident),+ for $key:ty) => {
-        derive_model!($i for $key);
-        derive_model!($($is),+ for $key);
+
+    (impl @fields $name:ident $field:ident : $value:ty, $($field_tail:ident : $value_tail:ty,)*) => {
+        PerspectiveProperties!(impl @field $name $field $value);
+        PerspectiveProperties!(impl @fields $name $($field_tail : $value_tail,)*);
+    };
+
+    (impl @fields $name:ident) => {};
+
+    // (impl @tuples $name:ident $value:tt : $acc:tt, $($value_tail:tt : $acc_tail:tt,)*) => {
+    //     PerspectiveProperties!(impl @tuple $name $value $acc);
+    //     PerspectiveProperties!(impl @tuples $name $($value_tail : $acc_tail,)*);
+    // };
+
+    // (impl @tuples $name:ident) => {};
+
+    ($(#[$m:meta])* $pub:vis struct $name:ident { $($(#[$_m:meta])* $_p:vis $field:ident : $value:ty),* $(,)? }) => {
+        PerspectiveProperties!(impl @fields $name $($field : $value,)*);
+        PerspectiveProperties!(impl @fields_provider $name {} $($field,)*);
     };
+
+    // ($(#[$m:meta])* $pub:vis struct $name:ident ( $($(#[$_m:meta])* $value:tt $(< $_ttt:ty >)?),* $(,)? );) => {
+    //     PerspectiveProperties!(impl @tuples $name $($value : ${index()} ,)*);
+    // };
+}
+
+pub trait StateProvider {
+    type State: Clone + 'static;
+
+    /// Clones _just_ the state objects fields into a new dedicated state
+    /// struct (generated by [`PerspectiveProperties`]).
+    fn clone_state(&self) -> Self::State;
 }

package/src/rust/model/update_and_render.rs

@@ -33,7 +33,7 @@ pub trait UpdateAndRender: HasRenderer + HasSession {
         Callback::from(move |_| {
             clone!(session, renderer);
             ApiFuture::spawn(async move {
-                renderer.draw(async { Ok(&session) }).await?;
+                renderer.draw(async { Ok(session.get_view()) }).await?;
                 Ok(())
             })
         })
@@ -41,11 +41,16 @@ pub trait UpdateAndRender: HasRenderer + HasSession {
 
     /// Create a `Callback` that resizes from the current `View` and `Plugin`.
     fn resize_callback(&self) -> Callback<()> {
-        clone!(self.renderer());
+        clone!(self.renderer(), self.session());
         Callback::from(move |_| {
-            clone!(renderer);
+            clone!(renderer, session);
             ApiFuture::spawn(async move {
-                renderer.resize().await?;
+                if !renderer.is_plugin_activated()? {
+                    update_and_render(session, renderer).await?
+                } else {
+                    renderer.resize().await?;
+                }
+
                 Ok(())
             })
         })
@@ -57,6 +62,11 @@ pub trait UpdateAndRender: HasRenderer + HasSession {
         clone!(self.session(), self.renderer());
         Ok(ApiFuture::new(update_and_render(session, renderer)))
     }
+
+    fn just_render(&self) -> ApiResult<ApiFuture<()>> {
+        clone!(self.session(), self.renderer());
+        Ok(ApiFuture::new(update_and_render(session, renderer)))
+    }
 }
 
 #[tracing::instrument(level = "debug", skip(session, renderer))]

package/src/rust/{model/create_col.rs → presentation/column_locator.rs}

@@ -10,50 +10,81 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
-use itertools::Itertools;
-
-use super::{HasPresentation, HasRenderer, HasSession, UpdateAndRender};
-use crate::config::{Expression, ViewConfigUpdate};
-use crate::utils::ApiFuture;
-
-pub trait CreateColumn: HasSession + HasPresentation + HasRenderer + UpdateAndRender {
-    fn clone_column(&self, name: &str, in_place: bool, open_settings: bool) -> ApiFuture<()> {
-        // 1. Create a new expression.
-        let expr_name = self.session().metadata().make_new_column_name(Some(name));
-        let expr = Expression::new(Some(&expr_name), &format!("\"{name}\""));
-        let view_config = self.session().get_view_config();
-        let mut serde_exprs = view_config.expressions.clone();
-        serde_exprs.retain(|name, _expr| name != &expr_name);
-        serde_exprs.insert(&expr);
-
-        // 2. Replace this column in the view configuration.
-        let mut cols = view_config.columns.clone();
-        if in_place {
-            let (idx, _val) = cols
-                .iter()
-                .find_position(|c| c.as_ref().map(|s| s == name).unwrap_or_default())
-                .unwrap_or_else(|| {
-                    web_sys::console::error_1(
-                        &format!("Couldn't find {name} in view config!").into(),
-                    );
-                    panic!();
-                });
-            cols[idx] = Some(expr_name.clone());
-        }
+use std::fmt::Display;
+
+/// Locates a view column.
+/// Table columns are those defined on the table, but their types will reflect
+/// the view type, not the table type.
+#[derive(Clone, Debug, PartialEq)]
+pub enum ColumnLocator {
+    Table(String),
+    Expression(String),
+    NewExpression,
+}
 
-        // 3. Ensure that the new column is opened
-        if open_settings {
-            self.presentation()
-                .set_open_column_settings(Some(expr_name));
+impl ColumnLocator {
+    /// Pulls the column's name from the locator.
+    /// If the column is a new expression which has yet to be saved, the
+    /// function will return None.
+    pub fn name(&self) -> Option<&String> {
+        match self {
+            Self::Table(s) | Self::Expression(s) => Some(s),
+            Self::NewExpression => None,
         }
+    }
+
+    #[inline(always)]
+    pub fn is_saved_expr(&self) -> bool {
+        matches!(self, ColumnLocator::Expression(_))
+    }
 
-        // 4. Update
-        drop(view_config);
-        self.update_and_render(ViewConfigUpdate {
-            expressions: Some(serde_exprs),
-            columns: Some(cols),
-            ..Default::default()
-        })
+    #[inline(always)]
+    pub fn is_expr(&self) -> bool {
+        matches!(
+            self,
+            ColumnLocator::Expression(_) | ColumnLocator::NewExpression
+        )
     }
+
+    #[inline(always)]
+    pub fn is_new_expr(&self) -> bool {
+        matches!(self, ColumnLocator::NewExpression)
+    }
+}
+
+#[derive(Debug, Default, Clone, Copy, PartialEq)]
+
+pub enum ColumnSettingsTab {
+    #[default]
+    Attributes,
+    Style,
 }
-impl<T: HasPresentation + HasSession + HasRenderer> CreateColumn for T {}
+
+impl Display for ColumnSettingsTab {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_fmt(format_args!("{self:?}"))
+    }
+}
+
+#[derive(Clone, Default, Debug, PartialEq)]
+pub struct OpenColumnSettings {
+    pub locator: Option<ColumnLocator>,
+    pub tab: Option<ColumnSettingsTab>,
+}
+
+impl OpenColumnSettings {
+    pub fn name(&self) -> Option<String> {
+        self.locator
+            .as_ref()
+            .and_then(|l| l.name())
+            .map(|s| s.to_owned())
+    }
+}
+
+pub trait ColumnTab: PartialEq + Display + Clone + Default + 'static {}
+
+impl ColumnTab for String {}
+
+impl ColumnTab for &'static str {}
+
+impl ColumnTab for ColumnSettingsTab {}

package/src/rust/{utils/wasm_abi.rs → presentation/sheets.rs}

@@ -10,52 +10,66 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
-/// A macro for implementing the `wasm_bindgen` boilerplate for types which
-/// implement `serde::{Serialize, Deserialize}`.
-///
-/// # Examples
-///
-/// ```
-/// struct MyStruct { .. }
-/// derive_wasm_abi!(MyStruct, FromWasmAbi);
-///
-/// #[wasm_bindgen]
-/// pub fn process_my_struct(s: MyStruct) {}
-/// ```
-#[macro_export]
-macro_rules! derive_wasm_abi {
-    ($type:ty) => {
-        impl wasm_bindgen::describe::WasmDescribe for $type {
-            fn describe() {
-                <js_sys::Object as wasm_bindgen::describe::WasmDescribe>::describe()
-            }
-        }
+use perspective_js::utils::{ApiResult, ToApiError, global};
+use wasm_bindgen::prelude::*;
+use web_sys::*;
+
+macro_rules! iter_index {
+    ($x:expr) => {
+        (0..$x.length()).map(|x| $x.item(x))
     };
+}
+
+/// Search the document's `styleSheets` for rules which apply to `elem` and
+/// provide the `--theme-name` CSS custom property.
+pub fn get_theme_names(elem: &HtmlElement) -> Result<Vec<String>, JsValue> {
+    let sheets = global::document().style_sheets();
+    let mut themes: Vec<String> = vec![];
+    for sheet in iter_index!(sheets) {
+        fill_sheet_theme_names(&mut themes, &sheet, elem)?;
+    }
+
+    Ok(themes)
+}
 
-    ($type:ty, FromWasmAbi $(, $symbols:tt)*) => {
-        impl wasm_bindgen::convert::FromWasmAbi for $type {
-            type Abi = <js_sys::Object as wasm_bindgen::convert::IntoWasmAbi>::Abi;
-            #[inline]
-            unsafe fn from_abi(js: Self::Abi) -> Self {
-                let obj = unsafe { js_sys::Object::from_abi(js) };
-                use ::perspective_js::utils::JsValueSerdeExt;
-                wasm_bindgen::JsValue::from(obj).into_serde_ext().unwrap()
+fn fill_rule_theme_names(
+    themes: &mut Vec<String>,
+    rule: &Option<CssRule>,
+    elem: &HtmlElement,
+) -> ApiResult<()> {
+    if let Some(rule) = rule.as_ref().into_apierror()?.dyn_ref::<CssStyleRule>() {
+        let txt = rule.selector_text();
+        if elem.matches(&txt)? {
+            let style = rule.style();
+            let x = (0..style.length()).map(|x| style.item(x));
+            for property in x {
+                if property == "--theme-name" {
+                    let name = style.get_property_value("--theme-name")?;
+                    let trimmed = name.trim();
+                    themes.push(trimmed[1..trimmed.len() - 1].to_owned());
+                }
             }
         }
+    }
 
-        derive_wasm_abi!($type $(, $symbols)*);
-    };
+    Ok(())
+}
 
-    ($type:ty, IntoWasmAbi $(, $symbols:tt)*) => {
-        impl wasm_bindgen::convert::IntoWasmAbi for $type {
-            type Abi = <js_sys::Object as wasm_bindgen::convert::IntoWasmAbi>::Abi;
-            #[inline]
-            fn into_abi(self) -> Self::Abi {
-                use wasm_bindgen::JsCast;
-                <wasm_bindgen::JsValue as ::perspective_js::utils::JsValueSerdeExt>::from_serde_ext(&self).unwrap().unchecked_into::<js_sys::Object>().into_abi()
-            }
+fn fill_sheet_theme_names(
+    themes: &mut Vec<String>,
+    sheet: &Option<StyleSheet>,
+    elem: &HtmlElement,
+) -> ApiResult<()> {
+    let sheet = sheet
+        .as_ref()
+        .into_apierror()?
+        .unchecked_ref::<CssStyleSheet>();
+
+    if let Ok(rules) = sheet.css_rules() {
+        for rule in iter_index!(&rules) {
+            fill_rule_theme_names(themes, &rule, elem).unwrap_or_default();
         }
+    }
 
-        derive_wasm_abi!($type $(, $symbols)*);
-    };
+    Ok(())
 }