@perspective-dev/viewer 4.3.0 → 4.4.1

package/src/rust/components/datetime_column_style/custom.rs

@@ -40,8 +40,8 @@ impl ModalLink<DatetimeStyleCustom> for DatetimeStyleCustomProps {
 }
 
 impl PartialEq for DatetimeStyleCustomProps {
-    fn eq(&self, _other: &Self) -> bool {
-        false
+    fn eq(&self, other: &Self) -> bool {
+        self.enable_time_config == other.enable_time_config && self.config == other.config
     }
 }
 

package/src/rust/components/datetime_column_style/simple.rs

@@ -36,8 +36,8 @@ impl ModalLink<DatetimeStyleSimple> for DatetimeStyleSimpleProps {
 }
 
 impl PartialEq for DatetimeStyleSimpleProps {
-    fn eq(&self, _other: &Self) -> bool {
-        false
+    fn eq(&self, other: &Self) -> bool {
+        self.enable_time_config == other.enable_time_config && self.config == other.config
     }
 }
 

package/src/rust/components/datetime_column_style.rs

@@ -56,8 +56,10 @@ impl ModalLink<DatetimeColumnStyle> for DatetimeColumnStyleProps {
 }
 
 impl PartialEq for DatetimeColumnStyleProps {
-    fn eq(&self, _other: &Self) -> bool {
-        false
+    fn eq(&self, other: &Self) -> bool {
+        self.enable_time_config == other.enable_time_config
+            && self.config == other.config
+            && self.default_config == other.default_config
     }
 }
 

package/src/rust/components/editable_header.rs

@@ -18,10 +18,10 @@ use yew::{Callback, Component, Html, NodeRef, Properties, TargetCast, classes, h
 
 use super::type_icon::TypeIconType;
 use crate::components::type_icon::TypeIcon;
-use crate::session::Session;
-use crate::*;
+use crate::maybe;
+use crate::session::{Session, SessionMetadataRc};
 
-#[derive(Clone, PartialEq, Properties, PerspectiveProperties!)]
+#[derive(Clone, PartialEq, Properties)]
 pub struct EditableHeaderProps {
     pub icon_type: Option<TypeIconType>,
     pub on_change: Callback<(Option<String>, bool)>,
@@ -32,6 +32,9 @@ pub struct EditableHeaderProps {
     #[prop_or_default]
     pub reset_count: u8,
 
+    /// Session metadata snapshot — threaded from `SessionProps`.
+    pub metadata: SessionMetadataRc,
+
     // State
     pub session: Session,
 }
@@ -111,7 +114,7 @@ impl Component for EditableHeader {
                     if !self.edited {
                         return Some(true);
                     }
-                    let metadata = ctx.props().session.metadata();
+                    let metadata = &ctx.props().metadata;
                     let expressions = metadata.get_expression_columns();
                     let found = metadata
                         .get_table_columns()?

package/src/rust/components/empty_row.rs

@@ -19,9 +19,9 @@ use wasm_bindgen::JsCast;
 use web_sys::*;
 use yew::prelude::*;
 
+use crate::components::filter_dropdown::FilterDropDownElement;
 use crate::components::style::LocalStyle;
 use crate::css;
-use crate::custom_elements::FilterDropDownElement;
 
 #[derive(Properties, Derivative)]
 #[derivative(Debug)]

package/src/rust/components/export_dropdown.rs

@@ -12,16 +12,12 @@
 
 use std::rc::Rc;
 
-use session::Session;
 use yew::prelude::*;
 
 use super::containers::dropdown_menu::*;
-use super::modal::{ModalLink, SetModalLink};
-use super::style::StyleProvider;
-use crate::model::*;
 use crate::renderer::*;
-use crate::utils::*;
-use crate::*;
+use crate::session::Session;
+use crate::tasks::*;
 
 pub type ExportDropDownMenuItem = DropDownMenuItem<ExportFile>;
 
@@ -30,16 +26,6 @@ pub struct ExportDropDownMenuProps {
     pub renderer: Renderer,
     pub session: Session,
     pub callback: Callback<ExportFile>,
-    pub root: web_sys::HtmlElement,
-
-    #[prop_or_default]
-    weak_link: WeakScope<ExportDropDownMenu>,
-}
-
-impl ModalLink<ExportDropDownMenu> for ExportDropDownMenuProps {
-    fn weak_link(&self) -> &'_ utils::WeakScope<ExportDropDownMenu> {
-        &self.weak_link
-    }
 }
 
 pub enum ExportDropDownMenuMsg {
@@ -49,7 +35,6 @@ pub enum ExportDropDownMenuMsg {
 #[derive(Default)]
 pub struct ExportDropDownMenu {
     title: String,
-    _sub: Option<Subscription>,
     input_ref: NodeRef,
     invalid: bool,
 }
@@ -61,11 +46,9 @@ impl Component for ExportDropDownMenu {
     fn view(&self, ctx: &Context<Self>) -> yew::virtual_dom::VNode {
         let callback = ctx.link().callback(|_| ExportDropDownMenuMsg::TitleChange);
         let plugin = ctx.props().renderer.get_active_plugin().unwrap();
-        // let has_render = js_sys::Reflect::has(&plugin,
-        // js_intern::js_intern!("render")).unwrap();
         let is_chart = plugin.name().as_str() != "Datagrid";
         html! {
-            <StyleProvider root={ctx.props().root.clone()}>
+            <>
                 <span class="dropdown-group-label">{ "Save as" }</span>
                 <input
                     class={if self.invalid { "invalid" } else { "" }}
@@ -77,7 +60,7 @@ impl Component for ExportDropDownMenu {
                     values={Rc::new(get_menu_items(&self.title, is_chart))}
                     callback={&ctx.props().callback}
                 />
-            </StyleProvider>
+            </>
         }
     }
 
@@ -97,21 +80,12 @@ impl Component for ExportDropDownMenu {
     }
 
     fn create(ctx: &Context<Self>) -> Self {
-        ctx.set_modal_link();
-        let _sub = Some(
-            ctx.props()
-                .renderer
-                .plugin_changed
-                .add_listener(ctx.link().callback(|_| ExportDropDownMenuMsg::TitleChange)),
-        );
-
         Self {
             title: ctx
                 .props()
                 .session
                 .get_title()
                 .unwrap_or_else(|| "untitled".to_owned()),
-            _sub,
             ..Default::default()
         }
     }

package/src/rust/components/expression_editor.rs

@@ -17,11 +17,10 @@ use yew::prelude::*;
 
 use super::form::code_editor::*;
 use super::style::LocalStyle;
-use crate::model::*;
-use crate::session::Session;
+use crate::session::{Session, SessionMetadata, SessionMetadataRc};
 use crate::*;
 
-#[derive(Properties, PartialEq, PerspectiveProperties!, Clone)]
+#[derive(Properties, PartialEq, Clone)]
 pub struct ExpressionEditorProps {
     pub on_save: Callback<()>,
     pub on_validate: Callback<bool>,
@@ -32,6 +31,13 @@ pub struct ExpressionEditorProps {
     #[prop_or_default]
     pub reset_count: u8,
 
+    /// Session metadata snapshot — threaded from `SessionProps`.
+    pub metadata: SessionMetadataRc,
+
+    /// Selected theme name, threaded for PortalModal consumers.
+    #[prop_or_default]
+    pub selected_theme: Option<String>,
+
     // State
     pub session: Session,
 }
@@ -55,7 +61,7 @@ impl Component for ExpressionEditor {
 
     fn create(ctx: &Context<Self>) -> Self {
         let oninput = ctx.link().callback(ExpressionEditorMsg::SetExpr);
-        let expr = initial_expr(&ctx.props().session, &ctx.props().alias);
+        let expr = initial_expr(&ctx.props().metadata, &ctx.props().alias);
         ctx.link()
             .send_message(Self::Message::SetExpr(expr.clone()));
 
@@ -89,8 +95,8 @@ impl Component for ExpressionEditor {
                 if self.error.is_none() {
                     maybe!({
                         let alias = ctx.props().alias.as_ref()?;
-                        let session = ctx.props().session();
-                        let old = session.metadata().get_expression_by_alias(alias)?;
+                        let session = &ctx.props().session;
+                        let old = ctx.props().metadata.get_expression_by_alias(alias)?;
                         let is_edited = *self.expr != old;
                         session
                             .metadata_mut()
@@ -124,6 +130,7 @@ impl Component for ExpressionEditor {
                         {disabled}
                         oninput={self.oninput.clone()}
                         onsave={ctx.props().on_save.clone()}
+                        theme={ctx.props().selected_theme.clone().unwrap_or_default()}
                     />
                     <div id="psp-expression-editor-meta">
                         <div class="error">
@@ -136,11 +143,13 @@ impl Component for ExpressionEditor {
     }
 
     fn changed(&mut self, ctx: &Context<Self>, old_props: &Self::Properties) -> bool {
-        if ctx.props().alias != old_props.alias || ctx.props().reset_count != old_props.reset_count
+        if ctx.props().alias != old_props.alias
+            || ctx.props().reset_count != old_props.reset_count
+            || (ctx.props().alias.is_some() && ctx.props().metadata != old_props.metadata)
         {
             ctx.link()
                 .send_message(ExpressionEditorMsg::SetExpr(initial_expr(
-                    &ctx.props().session,
+                    &ctx.props().metadata,
                     &ctx.props().alias,
                 )));
             false
@@ -150,10 +159,10 @@ impl Component for ExpressionEditor {
     }
 }
 
-fn initial_expr(session: &Session, alias: &Option<String>) -> Rc<String> {
+fn initial_expr(metadata: &SessionMetadata, alias: &Option<String>) -> Rc<String> {
     alias
         .as_ref()
-        .and_then(|alias| session.metadata().get_expression_by_alias(alias))
+        .and_then(|alias| metadata.get_expression_by_alias(alias))
         .unwrap_or_default()
         .into()
 }

package/src/rust/components/filter_dropdown.rs

@@ -10,135 +10,279 @@
 // ┃ 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 web_sys::*;
+use yew::html::ImplicitClone;
 use yew::prelude::*;
 
-use super::modal::*;
-use crate::utils::WeakScope;
+use super::portal::PortalModal;
+use crate::session::Session;
+use crate::utils::*;
+use crate::*;
 
 static CSS: &str = include_str!(concat!(env!("OUT_DIR"), "/css/filter-dropdown.css"));
 
-#[derive(Properties, PartialEq)]
-pub struct FilterDropDownProps {
-    #[prop_or_default]
-    pub weak_link: WeakScope<FilterDropDown>,
-}
-
-impl ModalLink<FilterDropDown> for FilterDropDownProps {
-    fn weak_link(&self) -> &'_ WeakScope<FilterDropDown> {
-        &self.weak_link
-    }
+#[derive(Default)]
+struct FilterDropDownState {
+    values: Vec<String>,
+    selected: usize,
+    on_select: Option<Callback<String>>,
+    target: Option<HtmlElement>,
 }
 
-pub enum FilterDropDownMsg {
-    SetValues(Vec<String>),
-    SetCallback(Callback<String>),
-    ItemDown,
-    ItemUp,
-    ItemSelect,
+#[derive(Clone)]
+pub struct FilterDropDownElement {
+    state: Rc<RefCell<FilterDropDownState>>,
+    session: Session,
+    column: Rc<RefCell<Option<(usize, String)>>>,
+    all_values: Rc<RefCell<Option<Vec<String>>>>,
+    notify: Rc<PubSub<()>>,
 }
 
-pub struct FilterDropDown {
-    values: Option<Vec<String>>,
-    selected: usize,
-    on_select: Option<Callback<String>>,
+impl PartialEq for FilterDropDownElement {
+    fn eq(&self, other: &Self) -> bool {
+        Rc::ptr_eq(&self.state, &other.state)
+    }
 }
 
-impl Component for FilterDropDown {
-    type Message = FilterDropDownMsg;
-    type Properties = FilterDropDownProps;
+impl ImplicitClone for FilterDropDownElement {}
 
-    fn create(ctx: &Context<Self>) -> Self {
-        ctx.set_modal_link();
+impl FilterDropDownElement {
+    pub fn new(session: Session) -> Self {
         Self {
-            values: Some(vec![]),
-            selected: 0,
-            on_select: None,
+            state: Default::default(),
+            session,
+            column: Default::default(),
+            all_values: Default::default(),
+            notify: Rc::default(),
         }
     }
 
-    fn update(&mut self, _ctx: &Context<Self>, msg: Self::Message) -> bool {
-        match msg {
-            FilterDropDownMsg::SetCallback(callback) => {
-                self.on_select = Some(callback);
-                false
-            },
-            FilterDropDownMsg::SetValues(values) => {
-                self.values = Some(values);
-                self.selected = 0;
-                true
-            },
-            FilterDropDownMsg::ItemSelect => {
-                if let Some(ref values) = self.values {
-                    match values.get(self.selected) {
-                        None => {
-                            console::error_1(&"Selected out-of-bounds".into());
-                            false
-                        },
-                        Some(x) => {
-                            self.on_select.as_ref().unwrap().emit(x.clone());
-                            false
-                        },
-                    }
+    pub fn reautocomplete(&self) {
+        // Re-open portal with current target
+        self.notify.emit(());
+    }
+
+    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.all_values, &exclude);
+                if values.len() == 1 && values[0] == input {
+                    let _ = self.hide();
                 } else {
-                    console::error_1(&"No Values".into());
-                    false
+                    let mut s = self.state.borrow_mut();
+                    s.values = values;
+                    s.selected = 0;
+                    s.on_select = Some(callback);
+                    if s.target.is_none() {
+                        s.target = Some(target);
+                    }
+
+                    drop(s);
+                    self.notify.emit(());
                 }
             },
-            FilterDropDownMsg::ItemDown => {
-                self.selected += 1;
-                if let Some(ref values) = self.values
-                    && self.selected >= values.len()
-                {
-                    self.selected = 0;
-                };
-
-                true
-            },
-            FilterDropDownMsg::ItemUp => {
-                if let Some(ref values) = self.values
-                    && self.selected < 1
-                {
-                    self.selected = values.len();
-                };
-
-                self.selected -= 1;
-                true
+            _ => {
+                clone!(
+                    self.state,
+                    self.session,
+                    self.all_values,
+                    self.notify,
+                    old_column = self.column
+                );
+                ApiFuture::spawn(async move {
+                    let fetched = session.get_column_values(column.1.clone()).await?;
+                    *all_values.borrow_mut() = Some(fetched);
+                    let values = filter_values(&input, &all_values, &exclude);
+                    let should_hide = values.len() == 1 && values[0] == input;
+
+                    *old_column.borrow_mut() = Some(column);
+                    {
+                        let mut s = state.borrow_mut();
+                        s.on_select = Some(callback);
+                        if should_hide {
+                            let fv = self::filter_values("", &all_values, &exclude);
+                            s.values = fv;
+                            s.target = Some(target);
+                        } else {
+                            s.values = values;
+                            s.target = Some(target);
+                        }
+                        s.selected = 0;
+                    }
+                    if should_hide {
+                        state.borrow_mut().target = None;
+                    }
+
+                    notify.emit(());
+                    Ok(())
+                });
             },
         }
     }
 
-    fn changed(&mut self, _ctx: &Context<Self>, _old: &Self::Properties) -> bool {
-        false
+    pub fn item_select(&self) {
+        let state = self.state.borrow();
+        if let Some(value) = state.values.get(state.selected)
+            && let Some(ref cb) = state.on_select
+        {
+            cb.emit(value.clone());
+        }
     }
 
-    fn view(&self, _ctx: &Context<Self>) -> Html {
-        let body = html! {
-            if let Some(ref values) = self.values {
-                if !values.is_empty() {
-                    { for values
-                            .iter()
-                            .enumerate()
-                            .map(|(idx, value)| {
-                                let click = self.on_select.as_ref().unwrap().reform({
-                                    let value = value.clone();
-                                    move |_: MouseEvent| value.clone()
-                                });
-
-                                html! {
-                                    if idx == self.selected {
-                                        <span onmousedown={ click } class="selected">{ value }</span>
-                                    } else {
-                                        <span onmousedown={ click }>{ value }</span>
-                                    }
-                                }
-                            }) }
-                } else {
-                    <span class="no-results">{ "No Completions" }</span>
-                }
-            }
+    pub fn item_down(&self) {
+        let mut state = self.state.borrow_mut();
+        state.selected += 1;
+        if state.selected >= state.values.len() {
+            state.selected = 0;
+        }
+
+        drop(state);
+        self.notify.emit(());
+    }
+
+    pub fn item_up(&self) {
+        let mut state = self.state.borrow_mut();
+        if state.selected < 1 {
+            state.selected = state.values.len();
+        }
+
+        state.selected -= 1;
+        drop(state);
+        self.notify.emit(());
+    }
+
+    pub fn hide(&self) -> ApiResult<()> {
+        self.state.borrow_mut().target = None;
+        self.column.borrow_mut().take();
+        self.notify.emit(());
+        Ok(())
+    }
+}
+
+#[derive(Properties, PartialEq)]
+pub struct FilterDropDownPortalProps {
+    pub element: FilterDropDownElement,
+    pub theme: String,
+}
+
+pub struct FilterDropDownPortal {
+    _sub: Subscription,
+}
+
+impl Component for FilterDropDownPortal {
+    type Message = ();
+    type Properties = FilterDropDownPortalProps;
+
+    fn create(ctx: &Context<Self>) -> Self {
+        let link = ctx.link().clone();
+        let sub = ctx
+            .props()
+            .element
+            .notify
+            .add_listener(move |()| link.send_message(()));
+        Self { _sub: sub }
+    }
+
+    fn update(&mut self, _ctx: &Context<Self>, _msg: ()) -> bool {
+        true
+    }
+
+    fn view(&self, ctx: &Context<Self>) -> Html {
+        let state = ctx.props().element.state.borrow();
+        let target = state.target.clone();
+        let on_close = {
+            let element = ctx.props().element.clone();
+            Callback::from(move |()| {
+                let _ = element.hide();
+            })
         };
 
-        html! { <><style>{ CSS }</style>{ body }</> }
+        if target.is_some() {
+            let values = state.values.clone();
+            let selected = state.selected;
+            let on_select = state.on_select.clone();
+            drop(state);
+
+            html! {
+                <PortalModal
+                    tag_name="perspective-dropdown"
+                    {target}
+                    own_focus=false
+                    {on_close}
+                    theme={ctx.props().theme.clone()}
+                >
+                    <FilterDropDownView {values} {selected} {on_select} />
+                </PortalModal>
+            }
+        } else {
+            html! {}
+        }
+    }
+}
+
+#[derive(Properties, PartialEq)]
+struct FilterDropDownViewProps {
+    values: Vec<String>,
+    selected: usize,
+    on_select: Option<Callback<String>>,
+}
+
+#[function_component]
+fn FilterDropDownView(props: &FilterDropDownViewProps) -> Html {
+    let body = html! {
+        if !props.values.is_empty() {
+            { for props.values
+                    .iter()
+                    .enumerate()
+                    .map(|(idx, value)| {
+                        let click = props.on_select.as_ref().unwrap().reform({
+                            let value = value.clone();
+                            move |_: MouseEvent| value.clone()
+                        });
+
+                        html! {
+                            if idx == props.selected {
+                                <span onmousedown={click} class="selected">{ value }</span>
+                            } else {
+                                <span onmousedown={click}>{ value }</span>
+                            }
+                        }
+                    }) }
+        } else {
+            <span class="no-results">{ "No Completions" }</span>
+        }
+    };
+
+    html! { <><style>{ CSS }</style>{ body }</> }
+}
+
+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![]
     }
 }