@perspective-dev/viewer 5.0.0 → 5.2.0

package/src/rust/components/panel_menu.rs

@@ -299,6 +299,7 @@ impl PanelMenu {
 
         html! {
             <PortalModal
+                key="perspective-context-menu"
                 tag_name="perspective-context-menu"
                 surface={StyleSurface::ContextMenu}
                 target={Some(self.anchor.clone())}
@@ -453,7 +454,13 @@ impl PanelMenu {
         };
 
         html! {
+            // Keyed by host tag: the menu→picker swap happens at the same
+            // vdom position, and `PortalModal`'s host element + adopted
+            // surface sheet are create-time-only — unkeyed reuse would leave
+            // the picker inside the `<perspective-context-menu>` host with
+            // the context-menu sheet.
             <PortalModal
+                key={tag_name}
                 {tag_name}
                 surface={StyleSurface::DropdownMenu}
                 {target}

package/src/rust/components/panel_tab.rs

@@ -316,6 +316,11 @@ impl Component for PanelTab {
 
         let link = ctx.link().clone();
         let contextmenu = Closure::wrap(Box::new(move |event: MouseEvent| {
+            // Shift+right-click passes through to the native browser menu.
+            if event.shift_key() {
+                return;
+            }
+
             event.prevent_default();
             event.stop_propagation();
             link.send_message(PanelTabMsg::ContextMenu(

package/src/rust/components/portal.rs

@@ -170,6 +170,13 @@ impl Component for PortalModal {
     }
 
     fn changed(&mut self, ctx: &Context<Self>, old_props: &Self::Properties) -> bool {
+        // The host element (`tag_name`) and its adopted sheet (`surface`) are
+        // fixed at `create` — a swap at the same vdom position must be keyed
+        // so Yew recreates the component (see `PanelMenu`'s menu→picker
+        // stages).
+        debug_assert_eq!(ctx.props().tag_name, old_props.tag_name);
+        debug_assert_eq!(ctx.props().surface, old_props.surface);
+
         let new_target = &ctx.props().target;
         let old_target = &old_props.target;
 

package/src/rust/components/settings_panel.rs

@@ -21,13 +21,14 @@ use super::plugin_selector::PluginSelector;
 use super::plugin_tab::PluginTab;
 use crate::components::containers::sidebar_close_button::SidebarCloseButton;
 use crate::components::form::debug::DebugPanel;
-use crate::config::PluginUpdate;
+use crate::config::{PluginStaticConfig, PluginUpdate};
 use crate::presentation::{ColumnLocator, OpenColumnSettings, Presentation};
 use crate::renderer::*;
 use crate::session::column_defaults_update::*;
 use crate::session::*;
 use crate::tasks::update_plugin_and_render;
 use crate::utils::*;
+use crate::workspace::Workspace;
 
 #[derive(Clone, Properties)]
 pub struct SettingsPanelProps {
@@ -42,6 +43,15 @@ pub struct SettingsPanelProps {
     pub available_plugins: PtrEqRc<Vec<String>>,
     pub has_table: Option<TableLoadState>,
     pub named_column_count: usize,
+
+    /// The ACTIVE plugin's declared contract, threaded as a value prop so
+    /// that switching plugins re-renders the panes that read it. The
+    /// renderer handle cannot serve this: it is excluded from prop
+    /// equality (it is a handle, not a value), so a plugin swap that
+    /// leaves the view config untouched — Y Line back to Datagrid, both
+    /// of which name one column slot — would otherwise change nothing any
+    /// component compares.
+    pub plugin_static_config: Rc<PluginStaticConfig>,
     pub view_config: PtrEqRc<ViewConfig>,
 
     /// Snapshot of the active plugin's `plugin_config` bucket, threaded
@@ -90,6 +100,7 @@ pub struct SettingsPanelProps {
     pub session: Session,
     pub renderer: Renderer,
     pub presentation: Presentation,
+    pub workspace: Workspace,
 }
 
 impl PartialEq for SettingsPanelProps {
@@ -99,6 +110,7 @@ impl PartialEq for SettingsPanelProps {
             && self.available_plugins == rhs.available_plugins
             && self.has_table == rhs.has_table
             && self.named_column_count == rhs.named_column_count
+            && self.plugin_static_config == rhs.plugin_static_config
             && self.view_config == rhs.view_config
             && self.plugin_config == rhs.plugin_config
             && self.drag_column == rhs.drag_column
@@ -116,6 +128,11 @@ pub enum SelectedTab {
     Query,
     Plugin,
     Debug,
+
+    /// The embedded LLM agent's chat panel. The variant exists in every
+    /// build; its tab button and body render only under the `llm-agent`
+    /// feature, and only once `agentConfig()` has been called.
+    Chat,
 }
 
 #[function_component]
@@ -186,8 +203,15 @@ pub fn SettingsPanel(props: &SettingsPanelProps) -> Html {
                 .unwrap();
 
             let group_rollups = plugin_config.get_group_rollups(&rollup_features);
+            let split_rollup_features = session_metadata
+                .get_features()
+                .map(|x| x.get_split_rollup_modes())
+                .unwrap();
+
+            let split_rollups = plugin_config.get_split_rollups(&split_rollup_features);
             let mut update = ViewConfigUpdate {
                 group_rollup_mode: group_rollups.first().cloned(),
+                split_rollup_mode: split_rollups.first().cloned(),
                 ..ViewConfigUpdate::default()
             };
 
@@ -237,6 +261,52 @@ pub fn SettingsPanel(props: &SettingsPanelProps) -> Html {
         }
     };
 
+    // The chat tab is zero-affordance until `agentConfig()` is called; the
+    // subscription re-renders this panel when that happens (and as the
+    // transcript updates while the chat body is mounted).
+    #[cfg(feature = "llm-agent")]
+    let (chat_tab_button, chat_body) = {
+        let update = use_force_update();
+        let agent = presentation.agent.clone();
+        use_effect_with((), move |_| {
+            let sub = agent
+                .on_update
+                .add_notify_listener(&Callback::from(move |_| update.force_update()));
+
+            move || drop(sub)
+        });
+
+        let button = if presentation.agent.is_configured() {
+            let on_select_column = props.on_select_column.clone();
+            let set_chat = {
+                let on_select_tab = props.on_select_tab.clone();
+                Callback::from(move |_: PointerEvent| {
+                    on_select_tab.emit(SelectedTab::Chat);
+                    on_select_column.emit(None)
+                })
+            };
+
+            html! {
+                <div
+                    id="chat_tabbar_tab"
+                    class={tab_class(selected, SelectedTab::Chat)}
+                    onpointerdown={set_chat}
+                />
+            }
+        } else {
+            html! {}
+        };
+
+        let body = html! {
+            <crate::components::chat_panel::ChatPanel agent={presentation.agent.clone()} />
+        };
+
+        (button, body)
+    };
+
+    #[cfg(not(feature = "llm-agent"))]
+    let (chat_tab_button, chat_body) = (html! {}, html! {});
+
     let on_open_expr_panel = use_callback(props.on_select_column.clone(), |c, on_select| {
         on_select.emit(Some(c))
     });
@@ -270,6 +340,7 @@ pub fn SettingsPanel(props: &SettingsPanelProps) -> Html {
                     class={tab_class(selected, SelectedTab::Debug)}
                     onpointerdown={set_debug}
                 />
+                { chat_tab_button }
             </div>
             if selected == SelectedTab::Query {
                 <ColumnSelector
@@ -278,6 +349,7 @@ pub fn SettingsPanel(props: &SettingsPanelProps) -> Html {
                     {selected_column}
                     has_table={props.has_table.clone()}
                     named_column_count={props.named_column_count}
+                    plugin_static_config={props.plugin_static_config.clone()}
                     view_config={props.view_config.clone()}
                     drag_column={props.drag_column.clone()}
                     metadata={props.metadata.clone()}
@@ -298,11 +370,14 @@ pub fn SettingsPanel(props: &SettingsPanelProps) -> Html {
                 // initial_width={width}
                 // on_auto_width={on_auto_width.clone()}
                 />
+            } else if selected == SelectedTab::Chat {
+                { chat_body }
             } else {
                 <DebugPanel
                     {presentation}
                     {renderer}
                     {session}
+                    workspace={props.workspace.clone()}
                     initial_width={width}
                     on_auto_width={on_auto_width.clone()}
                 />
@@ -310,7 +385,10 @@ pub fn SettingsPanel(props: &SettingsPanelProps) -> Html {
             // Sibling sizer keeps the panel width pinned across tab
             // switches; lives outside the tab-body so it survives the
             // tab subtree's unmount.
-            <div class="scroll-panel-auto-width" style={format!("width:{}px", width)} />
+            <div
+                class="scroll-panel-auto-width"
+                style={format!("width:{}px", width)}
+            />
         </div>
     }
 }

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

@@ -46,6 +46,8 @@ pub struct MasterSelection {
 #[derive(Debug)]
 pub enum PerspectiveViewerMsg {
     ColumnSettingsPanelSizeUpdate(Option<i32>),
+    ColumnSettingsPanelAutoWidth(f64),
+    ToggleColumnSettingsPin,
     ColumnSettingsTabChanged(ColumnSettingsTab),
     OpenColumnSettings {
         locator: Option<ColumnLocator>,

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

@@ -27,7 +27,7 @@ use super::wiring::{
     clear_active_callbacks, create_active_subscriptions, inject_active_callbacks,
     subscribe_panel_titles,
 };
-use crate::config::{TableUpdate, ViewerConfigUpdate};
+use crate::config::{ViewerConfigInitial, ViewerConfigUpdate};
 use crate::queries::*;
 use crate::renderer::Renderer;
 use crate::session::*;
@@ -216,18 +216,18 @@ impl PerspectiveViewer {
 
     pub(super) fn on_new_panel(&mut self, ctx: &Context<Self>, id: String) -> bool {
         if let Some(panel) = ctx.props().workspace.panel(&PanelId::from(id)) {
-            let table_name = panel.session.get_table().map(|t| t.get_name().to_owned());
+            let Some(table_name) = panel.session.get_table().map(|t| t.get_name().to_owned())
+            else {
+                tracing::warn!("Source panel has no `Table` to create a new panel from");
+                return false;
+            };
+
             let elem = ctx.props().elem.clone();
             let presentation = ctx.props().presentation.clone();
             let workspace = ctx.props().workspace.clone();
             let notify = ctx.link().callback(|_: ()| LayoutChanged);
             let activate = ctx.link().callback(|id| SetActivePanel(id, None));
             ApiFuture::spawn(async move {
-                let update = ViewerConfigUpdate {
-                    table: table_name.map(TableUpdate::Update).unwrap_or_default(),
-                    ..Default::default()
-                };
-
                 let client = panel.session.get_client();
                 let new_id = create_panel(
                     &elem,
@@ -235,7 +235,7 @@ impl PerspectiveViewer {
                     &workspace,
                     &notify,
                     None,
-                    update,
+                    ViewerConfigInitial::new(table_name).into(),
                     client,
                 )
                 .await?;
@@ -273,18 +273,13 @@ impl PerspectiveViewer {
         let notify = ctx.link().callback(|_: ()| LayoutChanged);
         let activate = ctx.link().callback(|id| SetActivePanel(id, None));
         ApiFuture::spawn(async move {
-            let update = ViewerConfigUpdate {
-                table: TableUpdate::Update(table),
-                ..Default::default()
-            };
-
             let new_id = create_panel(
                 &elem,
                 &presentation,
                 &workspace,
                 &notify,
                 None,
-                update,
+                ViewerConfigInitial::new(table).into(),
                 Some(client),
             )
             .await?;

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

@@ -94,6 +94,7 @@ impl PerspectiveViewer {
                     {available_plugins}
                     {has_table}
                     {named_column_count}
+                    plugin_static_config={self.renderer_props.config.clone()}
                     {view_config}
                     plugin_config={self.renderer_props.plugin_config.clone()}
                     {drag_column}
@@ -108,6 +109,7 @@ impl PerspectiveViewer {
                     {presentation}
                     {renderer}
                     {session}
+                    workspace={ctx.props().workspace.clone()}
                 />
             }
         } else {
@@ -116,10 +118,18 @@ impl PerspectiveViewer {
 
         let on_settings = ctx.link().callback(|()| ToggleSettingsInit(None, None));
         let on_select_tab = ctx.link().callback(ColumnSettingsTabChanged);
+        // Pinning the drawer is a pure CSS positioning flip on `#modal_panel`
+        // (absolute overlay over the main panel <-> static flex sibling
+        // between the main panel and the settings pane) - the drawer NEVER
+        // reparents, so neither `MainPanel` nor the drawer subtree remounts
+        // on toggle, and the divider/width-override machinery is identical
+        // in both modes.
+        let is_pinned = self.settings_geometry.column_settings_pinned;
         let column_settings_panel = html! {
             if let Some(selected_column) = selected_column {
                 <SplitPanel
                     id="modal_panel"
+                    class={classes!(is_pinned.then_some("pinned"))}
                     reverse=true
                     initial_size={self.settings_geometry.column_settings_width_override}
                     on_reset={ctx.link().callback(|_| ColumnSettingsPanelSizeUpdate(None))}
@@ -130,6 +140,10 @@ impl PerspectiveViewer {
                         {selected_tab}
                         on_close={self.on_close_column_settings.clone()}
                         width_override={self.settings_geometry.column_settings_width_override}
+                        auto_width={self.settings_geometry.column_settings_auto_width}
+                        on_auto_width={ctx.link().callback(ColumnSettingsPanelAutoWidth)}
+                        {is_pinned}
+                        on_toggle_pin={ctx.link().callback(|()| ToggleColumnSettingsPin)}
                         {on_select_tab}
                         plugin_name={self.renderer_props.plugin_name.clone()}
                         {metadata}

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

@@ -57,6 +57,18 @@ pub(super) struct SettingsGeometry {
 
     /// User-dragged column-settings drawer width override.
     pub column_settings_width_override: Option<i32>,
+
+    /// High-water-mark auto width reported by the column-settings drawer -
+    /// the trap-door shared across its Style/Attributes/Window tabs, lifted
+    /// here (like `auto_width`) so it survives drawer re-opens and clears
+    /// on divider reset.
+    pub column_settings_auto_width: f64,
+
+    /// Whether the column-settings drawer is PINNED - laid out as a static
+    /// flex sibling between the main panel and the settings panel - rather
+    /// than FLOATING over the main panel (the default absolute overlay).
+    /// Session UI state, not part of the saved config.
+    pub column_settings_pinned: bool,
 }
 
 impl PerspectiveViewer {
@@ -373,7 +385,27 @@ impl PerspectiveViewer {
 
     pub(super) fn on_column_settings_panel_size_update(&mut self, x: Option<i32>) -> bool {
         self.settings_geometry.column_settings_width_override = x;
-        false
+        if x.is_none() {
+            self.settings_geometry.column_settings_auto_width = 0.0;
+            true
+        } else {
+            false
+        }
+    }
+
+    pub(super) fn on_column_settings_panel_auto_width(&mut self, w: f64) -> bool {
+        if w > self.settings_geometry.column_settings_auto_width {
+            self.settings_geometry.column_settings_auto_width = w;
+            true
+        } else {
+            false
+        }
+    }
+
+    pub(super) fn on_toggle_column_settings_pin(&mut self) -> bool {
+        self.settings_geometry.column_settings_pinned =
+            !self.settings_geometry.column_settings_pinned;
+        true
     }
 
     pub(super) fn on_column_settings_tab_changed(

package/src/rust/components/viewer.rs

@@ -338,6 +338,8 @@ impl Component for PerspectiveViewer {
                 toggle,
             } => self.on_open_column_settings(ctx, locator, sender, toggle),
             ColumnSettingsPanelSizeUpdate(x) => self.on_column_settings_panel_size_update(x),
+            ColumnSettingsPanelAutoWidth(w) => self.on_column_settings_panel_auto_width(w),
+            ToggleColumnSettingsPin => self.on_toggle_column_settings_pin(),
             ColumnSettingsTabChanged(tab) => self.on_column_settings_tab_changed(ctx, tab),
             ToggleDebug => self.on_toggle_debug(ctx),