@perspective-dev/viewer 4.3.0 → 4.4.0

package/src/rust/components/main_panel.rs

@@ -10,24 +10,48 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
-use futures::channel::oneshot::*;
 use perspective_js::utils::*;
 use wasm_bindgen::prelude::*;
 use yew::prelude::*;
 
 use super::render_warning::RenderWarning;
 use super::status_bar::StatusBar;
-use crate::PerspectiveProperties;
 use crate::custom_events::CustomEvents;
 use crate::presentation::Presentation;
+use crate::renderer::limits::RenderLimits;
 use crate::renderer::*;
-use crate::session::*;
+use crate::session::{Session, TableErrorState, TableLoadState, ViewStats};
 use crate::utils::*;
 
-#[derive(Clone, Properties, PerspectiveProperties!)]
+#[derive(Clone, Properties)]
 pub struct MainPanelProps {
     pub on_settings: Callback<()>,
 
+    /// Reset callback forwarded from the root component.  Fired when the user
+    /// clicks the reset button; `bool` is `true` for a full reset (expressions
+    /// + column configs), `false` for config-only.
+    pub on_reset: Callback<bool>,
+
+    /// Render-limit dimensions forwarded from the root's `RendererProps`.
+    /// `Some` when the active plugin is capping the rendered row/column count;
+    /// `None` when no limits are active (e.g. after a plugin change).
+    pub render_limits: Option<RenderLimits>,
+
+    /// Value props from root's `SessionProps`, threaded to `StatusBar` /
+    /// `StatusIndicator`.
+    pub has_table: Option<TableLoadState>,
+    pub is_errored: bool,
+    pub stats: Option<ViewStats>,
+    pub update_count: u32,
+    pub error: Option<TableErrorState>,
+    pub title: Option<String>,
+
+    /// Value props from root's `PresentationProps`, threaded to `StatusBar`.
+    pub is_settings_open: bool,
+    pub selected_theme: Option<String>,
+    pub available_themes: PtrEqRc<Vec<String>>,
+    pub is_workspace: bool,
+
     /// State
     pub custom_events: CustomEvents,
     pub session: Session,
@@ -36,28 +60,33 @@ pub struct MainPanelProps {
 }
 
 impl PartialEq for MainPanelProps {
-    fn eq(&self, _rhs: &Self) -> bool {
-        false
+    fn eq(&self, rhs: &Self) -> bool {
+        self.has_table == rhs.has_table
+            && self.is_errored == rhs.is_errored
+            && self.stats == rhs.stats
+            && self.update_count == rhs.update_count
+            && self.error == rhs.error
+            && self.title == rhs.title
+            && self.is_settings_open == rhs.is_settings_open
+            && self.selected_theme == rhs.selected_theme
+            && self.available_themes == rhs.available_themes
+            && self.is_workspace == rhs.is_workspace
+            && self.render_limits == rhs.render_limits
     }
 }
 
 impl MainPanelProps {
     fn is_title(&self) -> bool {
-        self.session.get_title().is_some()
+        self.title.is_some()
     }
 }
 
 #[derive(Debug)]
 pub enum MainPanelMsg {
-    Reset(bool, Option<Sender<()>>),
-    RenderLimits(Option<(usize, usize, Option<usize>, Option<usize>)>),
     PointerEvent(web_sys::PointerEvent),
-    Error,
 }
 
 pub struct MainPanel {
-    _subscriptions: [Subscription; 2],
-    dimensions: Option<(usize, usize, Option<usize>, Option<usize>)>,
     main_panel_ref: NodeRef,
 }
 
@@ -65,85 +94,14 @@ impl Component for MainPanel {
     type Message = MainPanelMsg;
     type Properties = MainPanelProps;
 
-    fn create(ctx: &Context<Self>) -> Self {
-        let session_sub = {
-            let callback = ctx.link().callback(move |(_, render_limits)| {
-                MainPanelMsg::RenderLimits(Some(render_limits))
-            });
-
-            ctx.props()
-                .renderer
-                .render_limits_changed
-                .add_listener(callback)
-        };
-
-        let error_sub = ctx
-            .props()
-            .session
-            .table_errored
-            .add_listener(ctx.link().callback(|_| MainPanelMsg::Error));
-
+    fn create(_ctx: &Context<Self>) -> Self {
         Self {
-            _subscriptions: [session_sub, error_sub],
-            dimensions: None,
             main_panel_ref: NodeRef::default(),
         }
     }
 
     fn update(&mut self, ctx: &Context<Self>, msg: Self::Message) -> bool {
         match msg {
-            MainPanelMsg::Error => true,
-            MainPanelMsg::Reset(all, sender) => {
-                ctx.props().presentation.set_open_column_settings(None);
-
-                clone!(
-                    ctx.props().renderer,
-                    ctx.props().session,
-                    ctx.props().presentation
-                );
-
-                ApiFuture::spawn(async move {
-                    session
-                        .reset(ResetOptions {
-                            config: true,
-                            expressions: all,
-                            ..ResetOptions::default()
-                        })
-                        .await?;
-                    let columns_config = if all {
-                        presentation.reset_columns_configs();
-                        None
-                    } else {
-                        Some(presentation.all_columns_configs())
-                    };
-
-                    renderer.reset(columns_config.as_ref()).await?;
-                    presentation.reset_available_themes(None).await;
-                    if all {
-                        presentation.reset_theme().await?;
-                    }
-
-                    let result = renderer.draw(session.validate().await?.create_view()).await;
-                    if let Some(sender) = sender {
-                        sender.send(()).unwrap();
-                    }
-
-                    renderer.reset_changed.emit(());
-                    result
-                });
-
-                false
-            },
-
-            MainPanelMsg::RenderLimits(dimensions) => {
-                if self.dimensions != dimensions {
-                    self.dimensions = dimensions;
-                    true
-                } else {
-                    false
-                }
-            },
-
             MainPanelMsg::PointerEvent(event) => {
                 if event.target().map(JsValue::from)
                     == self
@@ -175,8 +133,8 @@ impl Component for MainPanel {
             ..
         } = ctx.props();
 
-        let is_settings_open =
-            ctx.props().presentation.is_settings_open() && ctx.props().session.has_table();
+        let is_settings_open = ctx.props().is_settings_open
+            && matches!(ctx.props().has_table, Some(TableLoadState::Loaded));
 
         let on_settings = (!is_settings_open).then(|| ctx.props().on_settings.clone());
 
@@ -189,14 +147,35 @@ impl Component for MainPanel {
             class.push("titled");
         }
 
-        let on_reset = ctx.link().callback(|all| MainPanelMsg::Reset(all, None));
         let pointerdown = ctx.link().callback(MainPanelMsg::PointerEvent);
+        let on_dismiss_warning = {
+            clone!(renderer, session);
+            Callback::from(move |_: ()| {
+                clone!(renderer, session);
+                ApiFuture::spawn(async move {
+                    renderer.disable_active_plugin_render_warning();
+                    let view_task = session.get_view();
+                    renderer.update(view_task).await
+                });
+            })
+        };
+
         html! {
             <div id="main_column">
                 <StatusBar
                     id="status_bar"
                     {on_settings}
-                    on_reset={on_reset.clone()}
+                    on_reset={ctx.props().on_reset.clone()}
+                    has_table={ctx.props().has_table.clone()}
+                    is_errored={ctx.props().is_errored}
+                    stats={ctx.props().stats.clone()}
+                    update_count={ctx.props().update_count}
+                    error={ctx.props().error.clone()}
+                    title={ctx.props().title.clone()}
+                    is_settings_open={ctx.props().is_settings_open}
+                    selected_theme={ctx.props().selected_theme.clone()}
+                    available_themes={ctx.props().available_themes.clone()}
+                    is_workspace={ctx.props().is_workspace}
                     {custom_events}
                     {presentation}
                     {renderer}
@@ -208,7 +187,10 @@ impl Component for MainPanel {
                     {class}
                     onpointerdown={pointerdown}
                 >
-                    <RenderWarning {renderer} {session} dimensions={self.dimensions} />
+                    <RenderWarning
+                        on_dismiss={on_dismiss_warning}
+                        dimensions={ctx.props().render_limits}
+                    />
                     <slot />
                 </div>
             </div>

package/src/rust/components/mod.rs

@@ -22,7 +22,6 @@ pub mod copy_dropdown;
 pub mod datetime_column_style;
 pub mod editable_header;
 pub mod empty_row;
-pub mod error_message;
 pub mod export_dropdown;
 pub mod expression_editor;
 pub mod filter_dropdown;
@@ -33,6 +32,7 @@ pub mod main_panel;
 pub mod modal;
 pub mod number_column_style;
 pub mod plugin_selector;
+pub mod portal;
 pub mod render_warning;
 pub mod settings_panel;
 pub mod status_bar;

package/src/rust/components/modal.rs

@@ -78,7 +78,7 @@ where
             } => {
                 let opacity = if visible { "" } else { ";opacity:0" };
                 self.css = format!(":host{{top:{top}px;left:{left}px{opacity}}}");
-                self.rev_vert.0.set(rev_vert);
+                self.rev_vert.set(rev_vert);
                 true
             },
             ModalMsg::SubMsg(msg) => {
@@ -117,6 +117,12 @@ pub struct ModalOrientation(Rc<Cell<bool>>);
 
 impl ImplicitClone for ModalOrientation {}
 
+impl ModalOrientation {
+    pub fn set(&self, value: bool) {
+        self.0.set(value);
+    }
+}
+
 impl From<ModalOrientation> for bool {
     fn from(x: ModalOrientation) -> Self {
         x.0.get()

package/src/rust/components/number_column_style.rs

@@ -10,6 +10,7 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
+use perspective_client::config::Scalar;
 use yew::prelude::*;
 use yew::*;
 
@@ -65,8 +66,25 @@ impl ModalLink<NumberColumnStyle> for NumberColumnStyleProps {
 }
 
 impl PartialEq for NumberColumnStyleProps {
-    fn eq(&self, _other: &Self) -> bool {
-        false
+    fn eq(&self, other: &Self) -> bool {
+        self.config == other.config
+            && self.default_config == other.default_config
+            && self.column_name == other.column_name
+    }
+}
+
+fn scalar_to_f64(scalar: &Scalar) -> f64 {
+    match scalar {
+        Scalar::Float(x) => *x,
+        Scalar::String(x) => x.parse::<f64>().unwrap_or_default(),
+        Scalar::Bool(x) => {
+            if *x {
+                1.0
+            } else {
+                0.0
+            }
+        },
+        Scalar::Null => 0.0,
     }
 }
 
@@ -76,12 +94,9 @@ fn set_default_gradient(session: &Session, ctx: &Context<NumberColumnStyle>) {
         ctx.link().send_future(async move {
             let view = session.get_view().unwrap();
             let min_max = view.get_min_max(column_name).await.unwrap();
-            let abs_max = min_max
-                .0
-                .parse::<f64>()
-                .unwrap_or_default()
+            let abs_max = scalar_to_f64(&min_max.0)
                 .abs()
-                .max(min_max.1.parse::<f64>().unwrap_or_default().abs());
+                .max(scalar_to_f64(&min_max.1).abs());
 
             let gradient = (abs_max * 100.).round() / 100.;
             NumberColumnStyleMsg::DefaultGradientChanged(gradient)

package/src/rust/components/plugin_selector.rs

@@ -10,106 +10,52 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
-use perspective_client::config::ViewConfigUpdate;
-use perspective_js::utils::ApiFuture;
 use yew::prelude::*;
 
-use super::containers::select::*;
 use super::style::LocalStyle;
-use crate::config::*;
-use crate::js::*;
-use crate::model::*;
-use crate::presentation::Presentation;
-use crate::renderer::*;
-use crate::session::*;
-use crate::utils::*;
-use crate::{css, *};
-
-#[derive(Properties, PartialEq, PerspectiveProperties!)]
+use crate::css;
+use crate::utils::PtrEqRc;
+
+/// Pure value props — no engine handles, no PubSub subscriptions.
+/// The parent passes updated values whenever the renderer state changes.
+#[derive(Properties, PartialEq)]
 pub struct PluginSelectorProps {
-    pub presentation: Presentation,
-    pub renderer: Renderer,
-    pub session: Session,
+    /// Name of the currently active plugin.
+    pub plugin_name: Option<String>,
+
+    /// Flat list of all registered plugin names (all categories merged).
+    pub available_plugins: PtrEqRc<Vec<String>>,
+
+    /// Called when the user selects a different plugin.
+    pub on_select_plugin: Callback<String>,
 }
 
 #[derive(Debug)]
 pub enum PluginSelectorMsg {
     ComponentSelectPlugin(String),
-    RendererSelectPlugin(String),
     OpenMenu,
 }
 
 use PluginSelectorMsg::*;
 
 pub struct PluginSelector {
-    options: Vec<SelectItem<String>>,
     is_open: bool,
-    _plugin_sub: Subscription,
 }
 
 impl Component for PluginSelector {
     type Message = PluginSelectorMsg;
     type Properties = PluginSelectorProps;
 
-    fn create(ctx: &Context<Self>) -> Self {
-        let PluginSelectorProps { renderer, .. } = ctx.props();
-        let options = generate_plugin_optgroups(renderer);
-        let _plugin_sub = renderer.plugin_changed.add_listener({
-            let link = ctx.link().clone();
-            move |plugin: JsPerspectiveViewerPlugin| {
-                let name = plugin.name();
-                link.send_message(PluginSelectorMsg::RendererSelectPlugin(name))
-            }
-        });
-
-        Self {
-            options,
-            is_open: false,
-            _plugin_sub,
-        }
+    fn create(_ctx: &Context<Self>) -> Self {
+        Self { is_open: false }
     }
 
     fn update(&mut self, ctx: &Context<Self>, msg: Self::Message) -> bool {
-        let PluginSelectorProps {
-            presentation,
-            renderer,
-            session,
-            ..
-        } = ctx.props();
         match msg {
-            RendererSelectPlugin(_plugin_name) => true,
             ComponentSelectPlugin(plugin_name) => {
-                if !session.is_errored() {
-                    let metadata =
-                        renderer.get_next_plugin_metadata(&PluginUpdate::Update(plugin_name));
-
-                    let prev_metadata = renderer.metadata();
-                    let requirements = metadata.as_ref().unwrap_or(&*prev_metadata);
-                    let rollup_features = session
-                        .metadata()
-                        .get_features()
-                        .map(|x| x.get_group_rollup_modes())
-                        .unwrap();
-
-                    let group_rollups = requirements.get_group_rollups(&rollup_features);
-                    let mut update = ViewConfigUpdate {
-                        group_rollup_mode: group_rollups.first().cloned(),
-                        ..ViewConfigUpdate::default()
-                    };
-
-                    session.set_update_column_defaults(&mut update, requirements);
-
-                    if let Ok(task) = ctx.props().update_and_render(update) {
-                        ApiFuture::spawn(task);
-                    }
-
-                    presentation.set_open_column_settings(None);
-                    self.is_open = false;
-                    false
-                } else {
-                    self.is_open = false;
-                    true
-                }
+                ctx.props().on_select_plugin.emit(plugin_name);
+                self.is_open = false;
+                false
             },
             OpenMenu => {
                 self.is_open = !self.is_open;
@@ -124,22 +70,18 @@ impl Component for PluginSelector {
 
     fn view(&self, ctx: &Context<Self>) -> Html {
         let callback = ctx.link().callback(|_| OpenMenu);
-        let plugin_name = ctx.props().renderer.get_active_plugin().unwrap().name();
+        let plugin_name = ctx.props().plugin_name.clone().unwrap_or_default();
         let plugin_name2 = plugin_name.clone();
         let class = if self.is_open { "open" } else { "" };
-        let items = self.options.iter().map(|item| match item {
-            SelectItem::OptGroup(_cat, items) => html! {
-                items.iter().filter(|x| *x != &plugin_name2).map(|x| {
-                    let callback = ctx.link().callback(ComponentSelectPlugin);
-                    html! {
-                        <PluginSelect
-                            name={ x.to_owned() }
-                            on_click={ callback } />
-                    }
-                }).collect::<Html>()
-            },
-            SelectItem::Option(_item) => html! {},
-        });
+        let items = ctx
+            .props()
+            .available_plugins
+            .iter()
+            .filter(|x| x.as_str() != plugin_name2.as_str())
+            .map(|x| {
+                let callback = ctx.link().callback(ComponentSelectPlugin);
+                html! { <PluginSelect name={x.to_owned()} on_click={callback} /> }
+            });
 
         html! {
             <>
@@ -148,7 +90,9 @@ impl Component for PluginSelector {
                     <PluginSelect name={plugin_name} on_click={callback} />
                     <div id="plugin_selector_border" />
                     if self.is_open {
-                        <div class="plugin-selector-options">{ items.collect::<Html>() }</div>
+                        <div class="plugin-selector-options scrollable">
+                            { items.collect::<Html>() }
+                        </div>
                     }
                 </div>
             </>
@@ -156,19 +100,6 @@ impl Component for PluginSelector {
     }
 }
 
-/// Generate the opt groups for the plugin selector by collecting by category
-/// then sorting.
-fn generate_plugin_optgroups(renderer: &Renderer) -> Vec<SelectItem<String>> {
-    let mut options = renderer
-        .get_all_plugin_categories()
-        .into_iter()
-        .map(|(category, value)| SelectItem::OptGroup(category.into(), value))
-        .collect::<Vec<_>>();
-
-    options.sort_by_key(|x| x.name());
-    options
-}
-
 #[derive(Properties, PartialEq)]
 struct PluginSelectProps {
     name: String,
@@ -194,9 +125,10 @@ fn PluginSelect(props: &PluginSelectProps) -> Html {
         <div
             class="plugin-select-item"
             data-plugin={name.clone()}
-            style={format!("--default-column-title:var(--plugin-name-{}--content, \"{}\")", path, props.name)}
+            style={format!("--default-column-title:var(--psp-plugin-name--{}--content, \"{}\")", path, props.name)}
             onclick={props.on_click.reform(move |_| name.clone())}
         >
+            <span class="icon" />
             <span class="plugin-select-item-name" />
         </div>
     }