@perspective-dev/viewer 5.5.1 → 5.6.0

package/src/rust/components/new_panel_menu.rs

@@ -29,12 +29,23 @@ pub type HostedTables = Rc<Vec<(String, Vec<String>)>>;
 /// `(panel id, title)` per panel, in layout-insertion order.
 pub type PanelLabels = Rc<Vec<(String, Option<String>)>>;
 
+/// Consumer count per derived `Table` name, which marks those rows and gates
+/// their delete affordance.
+pub type DerivedCounts = Rc<std::collections::BTreeMap<String, usize>>;
+
 #[derive(Properties, PartialEq)]
 pub struct NewPanelMenuProps {
     /// `None` while the hosted-table fetch is in flight.
     pub tables: Option<HostedTables>,
     pub panels: PanelLabels,
     pub callback: Callback<NewPanelPick>,
+
+    #[prop_or_default]
+    pub derived: DerivedCounts,
+
+    /// Delete a derived `Table`, offered only where nothing reads it.
+    #[prop_or_default]
+    pub on_delete: Option<Callback<String>>,
 }
 
 /// The "New" menu body shared by the status bar dropdown and the context
@@ -58,7 +69,48 @@ pub fn NewPanelMenu(props: &NewPanelMenuProps) -> Html {
                             client: client.clone(),
                             table: table.clone(),
                         });
-                        html! { <span class="dropdown-menu-item" {onmousedown}>{ table }</span> }
+
+                        let consumers = props.derived.get(table).copied();
+                        let mut class = classes!("dropdown-menu-item");
+                        if consumers.is_some() {
+                            class.push("is-derived");
+                        }
+
+                        let on_delete = props
+                            .on_delete
+                            .clone()
+                            .filter(|_| consumers == Some(0))
+                            .map(|cb| {
+                                let table = table.clone();
+                                Callback::from(move |event: MouseEvent| {
+                                    event.stop_propagation();
+                                    cb.emit(table.clone());
+                                })
+                            });
+
+                        html! {
+                            <span {class} {onmousedown}>
+                                { table }
+                                if let Some(count) = consumers.filter(|x| *x > 0) {
+                                    <span class="derived_consumers">{ count }</span>
+                                }
+                                if let Some(on_delete) = on_delete {
+                                    <span
+                                        class="derived_delete"
+                                        title="Delete this derived table"
+                                        onmousedown={on_delete}
+                                        // The menu stays OPEN after a delete, so the
+                                        // CLICK half of the gesture must not bubble to
+                                        // the context-menu flyout's Submenu row, whose
+                                        // own `onclick` would fire "New" AND close the
+                                        // session.
+                                        onclick={Callback::from(|event: MouseEvent| {
+                                            event.stop_propagation();
+                                        })}
+                                    />
+                                }
+                            </span>
+                        }
                     });
 
                     html! {
@@ -95,3 +147,19 @@ pub fn NewPanelMenu(props: &NewPanelMenuProps) -> Html {
         </div>
     }
 }
+
+/// Consumer counts for every derived `Table` the workspace owns.
+pub fn derived_counts(
+    workspace: &crate::workspace::Workspace,
+) -> crate::components::new_panel_menu::DerivedCounts {
+    std::rc::Rc::new(
+        workspace
+            .derived_names()
+            .into_iter()
+            .map(|name| {
+                let count = workspace.derived_consumers(&name);
+                (name, count)
+            })
+            .collect(),
+    )
+}

package/src/rust/components/panel_menu.rs

@@ -35,13 +35,13 @@ use yew::prelude::*;
 
 use crate::components::copy_dropdown::CopyDropDownMenu;
 use crate::components::export_dropdown::ExportDropDownMenu;
-use crate::components::new_panel_menu::{HostedTables, NewPanelMenu, NewPanelPick};
+use crate::components::new_panel_menu::{HostedTables, NewPanelMenu, NewPanelPick, derived_counts};
 use crate::components::style::StyleSurface;
 use crate::config::*;
 use crate::js::copy_to_clipboard;
 use crate::presentation::Presentation;
 use crate::queries::fetch_hosted_tables;
-use crate::tasks::export_method_to_blob;
+use crate::tasks::{can_derive, delete_derived, export_method_to_blob};
 use crate::ui::{ContextMenu, ContextMenuEntry, ContextMenuItem, MODAL_SLOT, PortalModal};
 use crate::utils::*;
 use crate::workspace::{PanelId, Workspace};
@@ -59,6 +59,10 @@ pub enum PanelCommand {
     /// A fresh panel copied from the named panel.
     NewFromPanel(String),
     Duplicate,
+
+    /// Promote the panel's current `View` to a derived `Table` under a
+    /// generated name, and rebind the panel to it.
+    Derive,
     Reset,
     Maximize,
     Restore,
@@ -153,6 +157,10 @@ pub struct PanelMenu {
     /// loaded client, in registration order. `None` while the fetch spawned at
     /// menu open is still in flight.
     tables: Option<HostedTables>,
+
+    /// Keeps the [`Workspace::hosted_tables_changed`] listener attached for
+    /// the menu session, so the open listing tracks table creates/deletes.
+    _tables_sub: Subscription,
 }
 
 impl Component for PanelMenu {
@@ -160,13 +168,25 @@ impl Component for PanelMenu {
     type Properties = PanelMenuProps;
 
     fn create(ctx: &Context<Self>) -> Self {
-        let workspace = ctx.props().workspace.clone();
-        let link = ctx.link().clone();
-        ApiFuture::spawn(async move {
-            let tables = fetch_hosted_tables(&workspace).await;
-            link.send_message(PanelMenuMsg::TablesLoaded(tables));
-            Ok(())
-        });
+        let fetch = {
+            let workspace = ctx.props().workspace.clone();
+            let link = ctx.link().clone();
+            move || {
+                clone!(workspace, link);
+                ApiFuture::spawn(async move {
+                    let tables = fetch_hosted_tables(&workspace).await;
+                    link.send_message(PanelMenuMsg::TablesLoaded(tables));
+                    Ok(())
+                });
+            }
+        };
+
+        fetch();
+        let _tables_sub = ctx
+            .props()
+            .workspace
+            .hosted_tables_changed()
+            .add_listener(move |_| fetch());
 
         Self {
             anchor: session_anchor(
@@ -176,6 +196,7 @@ impl Component for PanelMenu {
             ),
             picker: None,
             tables: None,
+            _tables_sub,
         }
     }
 
@@ -251,6 +272,13 @@ impl PanelMenu {
             Some(panel_id) => {
                 let can_close = ctx.props().workspace.len() > 1;
                 let is_master = ctx.props().workspace.is_master(&PanelId::from(panel_id));
+                let panel = ctx.props().workspace.panel(&PanelId::from(panel_id));
+                let can_derive_view = panel.as_ref().is_some_and(|x| {
+                    let config = x.session.get_view_config();
+                    let is_pivoted = !config.group_by.is_empty() || !config.split_by.is_empty();
+                    is_pivoted && can_derive(&x.session)
+                });
+
                 vec![
                     ContextMenuEntry::Submenu {
                         label: "New".to_owned(),
@@ -258,6 +286,7 @@ impl PanelMenu {
                         entries: vec![ContextMenuEntry::Custom(self.new_submenu_body(ctx))],
                     },
                     item("Duplicate", cmd(PanelCommand::Duplicate), false),
+                    item("Derive Table", cmd(PanelCommand::Derive), !can_derive_view),
                     item("Reset", cmd(PanelCommand::Reset), false),
                     item(
                         "Export",
@@ -335,7 +364,25 @@ impl PanelMenu {
             vec![cmd, PanelMenuMsg::MenuClosed]
         });
 
-        html! { <NewPanelMenu tables={self.tables.clone()} {panels} {callback} /> }
+        let workspace = ctx.props().workspace.clone();
+        let on_delete = Callback::from(move |name: String| {
+            let workspace = workspace.clone();
+            let effect = workspace.effects().guard();
+            ApiFuture::spawn(async move {
+                let _effect = effect;
+                delete_derived(&workspace, &name).await
+            });
+        });
+
+        html! {
+            <NewPanelMenu
+                tables={self.tables.clone()}
+                {panels}
+                {callback}
+                derived={derived_counts(&ctx.props().workspace)}
+                {on_delete}
+            />
+        }
     }
 
     /// Export/Copy format-picker spawned in place of the context menu, anchored
@@ -364,18 +411,20 @@ impl PanelMenu {
                     clone!(presentation);
                     let session = panel.session.clone();
                     let renderer = panel.renderer.clone();
+                    let workspace = ctx.props().workspace.clone();
                     let link = ctx.link().clone();
                     Callback::from(move |file: ExportFile| {
                         if file.name.is_empty() {
                             return;
                         }
 
-                        clone!(session, renderer, presentation, link);
+                        clone!(session, renderer, presentation, workspace, link);
                         ApiFuture::spawn(async move {
                             let blob = export_method_to_blob(
                                 &session,
                                 &renderer,
                                 &presentation,
+                                &workspace,
                                 file.method,
                             )
                             .await?;
@@ -400,14 +449,16 @@ impl PanelMenu {
                     clone!(presentation);
                     let session = panel.session.clone();
                     let renderer = panel.renderer.clone();
+                    let workspace = ctx.props().workspace.clone();
                     let link = ctx.link().clone();
                     Callback::from(move |file: ExportFile| {
-                        clone!(session, renderer, presentation, link);
+                        clone!(session, renderer, presentation, workspace, link);
                         ApiFuture::spawn(async move {
                             let task = export_method_to_blob(
                                 &session,
                                 &renderer,
                                 &presentation,
+                                &workspace,
                                 file.method,
                             );
                             copy_to_clipboard(task, file.method.mimetype(file.is_chart)).await?;

package/src/rust/components/plugin_tab.rs

@@ -42,10 +42,10 @@ pub struct PluginTabProps {
     /// Active plugin's `plugin_config` bucket — threaded as a value
     /// snapshot from `RendererProps`. Changes on every mutation path
     /// that fires `plugin_config_changed` (in-tab edit,
-    /// `restore_and_render` JSON paste, `reset_all` with `all=true`)
+    /// `restore` JSON paste, `reset_all` with `all=true`)
     /// AND on plugin switch (the active bucket is keyed by plugin
     /// name, so `to_props()` produces a fresh `Rc` after
-    /// `commit_plugin_idx`). PluginTab is a pure function of this
+    /// a restore or edit commit). PluginTab is a pure function of this
     /// prop — no `Renderer::get_plugin_config()` reads against the
     /// interior-mutable handle.
     pub plugin_config: PtrEqRc<serde_json::Map<String, serde_json::Value>>,
@@ -256,6 +256,7 @@ fn render_leaf(
             max,
             step,
             include,
+            ..
         } => {
             let current = raw_config.get(&key).and_then(|v| v.as_f64());
             Some(html! {

package/src/rust/components/render_warning.rs

@@ -13,6 +13,7 @@
 use yew::prelude::*;
 
 use crate::renderer::limits::RenderLimits;
+use crate::utils::left_click;
 
 #[derive(Properties, PartialEq)]
 pub struct RenderWarningProps {
@@ -76,7 +77,7 @@ pub fn render_warning(props: &RenderWarningProps) -> Html {
         };
 
         let on_dismiss = props.on_dismiss.clone();
-        let onclick = Callback::from(move |_: MouseEvent| on_dismiss.emit(()));
+        let onclick = left_click(Callback::from(move |_: MouseEvent| on_dismiss.emit(())));
         html! {
             <>
                 <div

package/src/rust/components/settings_panel.rs

@@ -22,7 +22,7 @@ use super::plugin_tab::PluginTab;
 use crate::components::debug_panel::DebugPanel;
 use crate::config::{PluginStaticConfig, PluginUpdate};
 use crate::presentation::{ColumnLocator, ColumnSettingsTarget, OpenColumnSettings, Presentation};
-use crate::queries::classify_column;
+use crate::queries::{classify_column, is_pivot_column};
 use crate::renderer::*;
 use crate::session::column_defaults_update::*;
 use crate::session::*;
@@ -166,8 +166,7 @@ pub fn SettingsPanel(props: &SettingsPanelProps) -> Html {
 
                     let used = config.columns.iter().any(|maybe_col| {
                         maybe_col.as_ref().map(|col| col == n).unwrap_or_default()
-                    }) || config.group_by.iter().any(|col| col == n)
-                        || config.split_by.iter().any(|col| col == n)
+                    }) || is_pivot_column(n, config)
                         || config.filter.iter().any(|col| col.column() == n)
                         || config.sort.iter().any(|col| &col.0 == n);
                     (used && props.renderer.can_render_column_styles()).then_some(locator)
@@ -193,7 +192,7 @@ pub fn SettingsPanel(props: &SettingsPanelProps) -> Html {
         let session_metadata = props.metadata.clone();
         let view_config = props.view_config.clone();
         Callback::from(move |plugin_name: String| {
-            if session.is_errored() {
+            if session.is_errored() || renderer.failure().is_some() {
                 return;
             }
             // Pure resolve — the swap itself is committed inside the locked
@@ -368,6 +367,7 @@ pub fn SettingsPanel(props: &SettingsPanelProps) -> Html {
                     presentation={presentation.clone()}
                     renderer={renderer.clone()}
                     session={session.clone()}
+                    workspace={props.workspace.clone()}
                     initial_width={width}
                     on_auto_width={on_auto_width.clone()}
                     on_dimensions_reset={&props.on_dimensions_reset}

package/src/rust/components/status_bar.rs

@@ -21,7 +21,9 @@ use super::status_indicator::StatusIndicator;
 use crate::components::copy_dropdown::CopyDropDownMenu;
 use crate::components::export_dropdown::ExportDropDownMenu;
 use crate::components::global_filter_bar::GlobalFilterBar;
-use crate::components::new_panel_menu::{HostedTables, NewPanelMenu, NewPanelPick, PanelLabels};
+use crate::components::new_panel_menu::{
+    HostedTables, NewPanelMenu, NewPanelPick, PanelLabels, derived_counts,
+};
 use crate::components::style::StyleSurface;
 use crate::config::*;
 use crate::js::*;
@@ -50,6 +52,9 @@ pub struct StatusBarProps {
     /// `has_table_cells`, `error` from session_props; `selected_theme`,
     /// `available_themes` from presentation_props.
     pub session_props: SessionProps,
+
+    /// The failure of the active panel's last draw.
+    pub render_error: Option<RenderError>,
     pub presentation_props: PresentationProps,
 
     /// Derived from root: `settings_open && has_table_loaded`.  Used
@@ -106,6 +111,10 @@ pub enum StatusBarMsg {
 
     /// A pick in the "New" dropdown.
     NewPanelPick(NewPanelPick),
+
+    /// The hosted-table set changed: refresh the "New" dropdown's listing
+    /// in place, if it is open.
+    RefreshTables,
     Export,
     Copy,
     CloseExport,
@@ -128,16 +137,41 @@ pub struct StatusBar {
     /// The "New" dropdown's anchor and listings while it is open.
     new_menu: Option<(HtmlElement, HostedTables, PanelLabels)>,
 
+    /// Keeps the [`Workspace::hosted_tables_changed`] listener attached for
+    /// the component's lifetime.
+    _tables_sub: Subscription,
+
     /// Bumped per "New" click; a resolving fetch opens only if it is still
     /// the newest one.
     new_generation: u32,
 }
 
+impl StatusBar {
+    /// Fetch the hosted-table listing and (re)open the "New" dropdown with
+    /// it, guarded by `new_generation` against stale resolutions.
+    fn spawn_tables_fetch(&mut self, ctx: &Context<Self>) {
+        self.new_generation = self.new_generation.wrapping_add(1);
+        let generation = self.new_generation;
+        let workspace = ctx.props().workspace.clone();
+        let link = ctx.link().clone();
+        ApiFuture::spawn(async move {
+            let tables = fetch_hosted_tables(&workspace).await;
+            link.send_message(StatusBarMsg::OpenNewPanel(generation, Rc::new(tables)));
+            Ok(())
+        });
+    }
+}
+
 impl Component for StatusBar {
     type Message = StatusBarMsg;
     type Properties = StatusBarProps;
 
-    fn create(_ctx: &Context<Self>) -> Self {
+    fn create(ctx: &Context<Self>) -> Self {
+        let _tables_sub = ctx.props().workspace.hosted_tables_changed().add_listener({
+            let link = ctx.link().clone();
+            move |_| link.send_message(StatusBarMsg::RefreshTables)
+        });
+
         Self {
             copy_ref: NodeRef::default(),
             export_ref: NodeRef::default(),
@@ -146,6 +180,7 @@ impl Component for StatusBar {
             copy_target: None,
             export_target: None,
             new_menu: None,
+            _tables_sub,
             new_generation: 0,
         }
     }
@@ -158,15 +193,13 @@ impl Component for StatusBar {
                 false
             },
             StatusBarMsg::NewPanel => {
-                self.new_generation = self.new_generation.wrapping_add(1);
-                let generation = self.new_generation;
-                let workspace = ctx.props().workspace.clone();
-                let link = ctx.link().clone();
-                ApiFuture::spawn(async move {
-                    let tables = fetch_hosted_tables(&workspace).await;
-                    link.send_message(StatusBarMsg::OpenNewPanel(generation, Rc::new(tables)));
-                    Ok(())
-                });
+                self.spawn_tables_fetch(ctx);
+                false
+            },
+            StatusBarMsg::RefreshTables => {
+                if self.new_menu.is_some() {
+                    self.spawn_tables_fetch(ctx);
+                }
 
                 false
             },
@@ -198,15 +231,18 @@ impl Component for StatusBar {
             },
             StatusBarMsg::CloseNewPanel => {
                 self.new_menu = None;
+                self.new_generation = self.new_generation.wrapping_add(1);
                 true
             },
             StatusBarMsg::NewPanelPick(pick) => {
                 ctx.props().on_new_panel.emit(pick);
                 self.new_menu = None;
+                self.new_generation = self.new_generation.wrapping_add(1);
                 true
             },
             StatusBarMsg::ResetTheme => {
                 update_theme(
+                    &ctx.props().session,
                     &ctx.props().renderer,
                     &ctx.props().presentation,
                     &ctx.props().workspace,
@@ -216,6 +252,7 @@ impl Component for StatusBar {
             },
             StatusBarMsg::SetTheme(theme_name) => {
                 update_theme(
+                    &ctx.props().session,
                     &ctx.props().renderer,
                     &ctx.props().presentation,
                     &ctx.props().workspace,
@@ -261,7 +298,8 @@ impl Component for StatusBar {
         } = ctx.props();
 
         let has_table = ctx.props().session_props.has_table.clone();
-        let is_errored = ctx.props().session_props.is_errored();
+        let is_errored =
+            ctx.props().session_props.is_errored() || ctx.props().render_error.is_some();
         let is_settings_open = ctx.props().is_settings_open;
 
         let mut is_updating_class_name = classes!();
@@ -274,28 +312,35 @@ impl Component for StatusBar {
         }
 
         // TODO Memoizing these would reduce some vdom diffing later on
-        let onclose = ctx.link().callback(|_| StatusBarMsg::Eject);
+        let onclose = left_click(ctx.link().callback(|_| StatusBarMsg::Eject));
         let onpointerdown = ctx.link().callback(StatusBarMsg::PointerEvent);
-        let onexport = ctx.link().callback(|event: MouseEvent| {
+        let onexport = left_click(ctx.link().callback(|event: MouseEvent| {
             event.prevent_default();
             StatusBarMsg::Export
-        });
-        let oncopy = ctx.link().callback(|event: MouseEvent| {
+        }));
+        let oncopy = left_click(ctx.link().callback(|event: MouseEvent| {
             event.prevent_default();
             StatusBarMsg::Copy
-        });
-        let onreset = ctx.link().callback(StatusBarMsg::Reset);
-        let onnew = ctx.link().callback(|event: MouseEvent| {
+        }));
+        let onreset = left_click(ctx.link().callback(StatusBarMsg::Reset));
+        let onnew = left_click(ctx.link().callback(|event: MouseEvent| {
             event.prevent_default();
             StatusBarMsg::NewPanel
-        });
+        }));
         let on_new_select = ctx.link().callback(StatusBarMsg::NewPanelPick);
         let on_close_new = ctx.link().callback(|_| StatusBarMsg::CloseNewPanel);
+        let on_delete_derived = {
+            let workspace = ctx.props().workspace.clone();
+            Callback::from(move |name: String| {
+                let workspace = workspace.clone();
+                let effect = workspace.effects().guard();
+                ApiFuture::spawn(async move {
+                    let _effect = effect;
+                    delete_derived(&workspace, &name).await
+                });
+            })
+        };
 
-        // Project only the *active* panel's plugin toolbar into the shared status
-        // bar. Each panel's toolbar slots into `statusbar-extra-{its-panel-id}`
-        // (see datagrid `toolbar.ts`); the active panel's id comes from the
-        // active renderer this status bar is bound to.
         let extra_slot = ctx
             .props()
             .renderer
@@ -319,6 +364,7 @@ impl Component for StatusBar {
                         &props.session,
                         &props.renderer,
                         &props.presentation,
+                        &props.workspace,
                         x.method,
                     );
                     let result = copy_to_clipboard(task, mime).await;
@@ -345,6 +391,7 @@ impl Component for StatusBar {
                             &props.session,
                             &props.renderer,
                             &props.presentation,
+                            &props.workspace,
                             x.method,
                         )
                         .await
@@ -374,6 +421,7 @@ impl Component for StatusBar {
                             {session}
                             update_count={ctx.props().update_count}
                             session_props={ctx.props().session_props.clone()}
+                            render_error={ctx.props().render_error.clone()}
                         />
                         if is_panel_bar {
                             <div id="panel-bar" class="section">
@@ -449,6 +497,8 @@ impl Component for StatusBar {
                                 tables={Some(tables.clone())}
                                 panels={panels.clone()}
                                 callback={on_new_select}
+                                derived={derived_counts(&ctx.props().workspace)}
+                                on_delete={on_delete_derived}
                             />
                         }
                     </PortalModal>

package/src/rust/components/status_indicator.rs

@@ -15,7 +15,7 @@ use perspective_js::utils::ApiError;
 use web_sys::*;
 use yew::prelude::*;
 
-use crate::renderer::Renderer;
+use crate::renderer::{RenderError, Renderer};
 use crate::session::{Session, SessionProps, TableLoadState};
 use crate::tasks::apply_and_render;
 use crate::utils::*;
@@ -32,6 +32,7 @@ pub struct StatusIndicatorProps {
     /// TODO(texodus): remove this
     pub update_count: u32,
     pub session_props: SessionProps,
+    pub render_error: Option<RenderError>,
 }
 
 /// An indicator component which displays the current status of the perspective
@@ -47,6 +48,8 @@ pub fn StatusIndicator(props: &StatusIndicatorProps) -> Html {
             err.kind(),
             err.is_reconnect(),
         )
+    } else if let Some(RenderError(err)) = &props.render_error {
+        StatusIconState::Errored(err.message(), err.stacktrace(), err.kind(), true)
     } else if !has_table_cells
         && matches!(props.session_props.has_table, Some(TableLoadState::Loading))
     {
@@ -76,6 +79,10 @@ pub fn StatusIndicator(props: &StatusIndicatorProps) -> Html {
         async move |_: MouseEvent, (session, renderer, state)| {
             match &state {
                 StatusIconState::Errored(..) => {
+                    if renderer.failure().is_some() {
+                        session.reset_failed_config().await?;
+                    }
+
                     session.reconnect().await?;
                     apply_and_render(session, renderer, ViewConfigUpdate::default())?.await?;
                 },

package/src/rust/components/viewer/filters.rs

@@ -23,6 +23,7 @@ use yew::prelude::*;
 
 use super::PerspectiveViewer;
 use super::msg::MasterSelection;
+use crate::session::OverlayClause;
 use crate::tasks::*;
 use crate::workspace::PanelId;
 
@@ -107,7 +108,18 @@ impl PerspectiveViewer {
             },
         };
 
-        workspace.set_contribution(&id, filters);
+        let metadata = workspace.panel(&id).map(|p| p.session.metadata());
+        let clauses = filters
+            .into_iter()
+            .map(|filter| OverlayClause {
+                column_type: metadata
+                    .as_ref()
+                    .and_then(|m| m.get_column_table_type(filter.column())),
+                filter,
+            })
+            .collect();
+
+        workspace.set_contribution(&id, clauses);
         apply_global_filters(workspace);
         false
     }

package/src/rust/components/viewer/msg.rs

@@ -132,6 +132,10 @@ pub enum PerspectiveViewerMsg {
     /// panel appended to the layout.
     DuplicatePanel(String),
 
+    /// Promote the named panel's current `View` to a derived `Table` under a
+    /// generated name, rebinding the panel to it.
+    DerivePanel(String),
+
     /// New panel: a fresh (default-config) panel bound to the named panel's
     /// table (from the default client).
     NewPanel(String),