@perspective-dev/viewer 5.1.0 → 5.3.0

package/src/rust/components/settings_panel.rs

@@ -21,19 +21,21 @@ 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::presentation::{ColumnLocator, OpenColumnSettings, Presentation};
+use crate::config::{PluginStaticConfig, PluginUpdate};
+use crate::presentation::{ColumnLocator, ColumnSettingsTarget, OpenColumnSettings, Presentation};
+use crate::queries::classify_column;
 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 {
     pub on_close: Callback<()>,
     pub on_resize: Rc<PubSub<()>>,
-    pub on_select_column: Callback<Option<ColumnLocator>>,
+    pub on_select_column: Callback<Option<ColumnSettingsTarget>>,
     pub on_debug: Callback<()>,
     pub is_debug: bool,
 
@@ -42,6 +44,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 +101,7 @@ pub struct SettingsPanelProps {
     pub session: Session,
     pub renderer: Renderer,
     pub presentation: Presentation,
+    pub workspace: Workspace,
 }
 
 impl PartialEq for SettingsPanelProps {
@@ -99,6 +111,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 +129,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]
@@ -128,25 +146,28 @@ pub fn SettingsPanel(props: &SettingsPanelProps) -> Html {
     } = &props;
 
     let selected_column = {
-        let locator = props.open_column_settings.locator.clone();
         let config = &props.view_config;
-        locator.filter(|locator| match locator {
-            ColumnLocator::Table(_name) => {
-                locator
-                    .name()
-                    .map(|n| {
-                        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)
-                            || config.filter.iter().any(|col| col.column() == n)
-                            || config.sort.iter().any(|col| &col.0 == n)
-                    })
-                    .unwrap_or_default()
-                    && props.renderer.can_render_column_styles()
-            },
-            _ => true,
-        })
+        props
+            .open_column_settings
+            .target
+            .as_ref()
+            .and_then(|target| match target {
+                ColumnSettingsTarget::NewExpression => Some(ColumnLocator::NewExpression),
+                ColumnSettingsTarget::Column(n) => {
+                    let locator = classify_column(n, config, &props.metadata)?;
+                    if !matches!(locator, ColumnLocator::Table(_)) {
+                        return Some(locator);
+                    }
+
+                    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)
+                        || 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)
+                },
+            })
     };
 
     let plugin_name = props.plugin_name.clone();
@@ -186,13 +207,21 @@ 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()
             };
 
             update.set_update_column_defaults(
                 &session_metadata,
+                &view_config,
                 &view_config.columns,
                 plugin_config,
             );
@@ -237,6 +266,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 +345,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 +354,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 +375,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 +390,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

@@ -22,7 +22,9 @@ use wasm_bindgen::JsValue;
 
 use crate::components::settings_panel::SelectedTab;
 use crate::config::*;
-use crate::presentation::{ColumnLocator, ColumnSettingsTab, DragDropProps, PresentationProps};
+use crate::presentation::{
+    ColumnSettingsTab, ColumnSettingsTarget, DragDropProps, PresentationProps,
+};
 use crate::renderer::RendererProps;
 use crate::session::{SessionProps, TableLoadState, ViewStats};
 use crate::utils::Completion;
@@ -48,17 +50,19 @@ pub enum PerspectiveViewerMsg {
     ColumnSettingsPanelSizeUpdate(Option<i32>),
     ColumnSettingsPanelAutoWidth(f64),
     ToggleColumnSettingsPin,
+    ToggleColumnSettingsPinComplete(Sender<()>),
     ColumnSettingsTabChanged(ColumnSettingsTab),
     OpenColumnSettings {
-        locator: Option<ColumnLocator>,
+        target: Option<ColumnSettingsTarget>,
         sender: Option<Sender<()>>,
         toggle: bool,
     },
     PreloadFontsUpdate,
 
     /// Element-level reset (the public `reset()` API): reset EVERY panel and
-    /// clear the cross-filter overlay, symmetric with whole-element
-    /// `save`/`restore`. The `bool` also clears expressions/column settings.
+    /// clear the cross-filter overlay, symmetric with
+    /// `saveWorkspace`/`restoreWorkspace`. The `bool` also clears
+    /// expressions/column settings.
     Reset(bool, Option<Completion>),
 
     /// Reset ONLY the named panel — or the active panel when `None` — to its
@@ -86,10 +90,10 @@ pub enum PerspectiveViewerMsg {
     /// I6) — carrying any teardown error, which was previously dropped.
     ClosePanel(String, Option<Completion>),
 
-    /// Whole-element `restore` finished replacing the panel set in the
+    /// `restoreWorkspace` finished replacing the panel set in the
     /// `Workspace` (new models inserted, old panels ejected, layout staged):
     /// activate the named panel, re-subscribe the per-panel wiring, and
-    /// re-render — the SINGLE visible commit of the whole restore.
+    /// re-render — the SINGLE visible commit of the restore.
     CommitWorkspaceRestore(String),
 
     /// Duplicate the named panel: snapshot its config into a new independent
@@ -149,8 +153,34 @@ pub enum PerspectiveViewerMsg {
     SettingsPanelTabChanged(SelectedTab),
     SettingsPanelAutoWidth(f64),
     ToggleDebug,
+
+    /// The toggle choreography's INTERNAL completion leaf: flip the pane
+    /// and resolve on the render commit. Never send this to toggle
+    /// settings from outside `settings.rs` — it skips the presize/resize
+    /// sweep (the pane's `SplitPanel` emits no `before-resize` and the
+    /// host box is unchanged, so nothing else resizes the plugins), which
+    /// leaves canvas plugins CSS-stretched at their old backing size. API
+    /// entry points send [`Self::ToggleSettingsInit`].
     ToggleSettingsComplete(SettingsUpdate, Sender<()>),
-    ToggleSettingsInit(Option<SettingsUpdate>, Option<Sender<ApiResult<JsValue>>>),
+
+    /// Toggle (or force) the settings pane with the FULL choreography:
+    /// presize every visible plugin to its post-toggle box, commit the
+    /// pane, then the exactness-finalizer resize. The `Sender` resolves
+    /// after the sweep. The one settings-toggle entry point for both the
+    /// toolbar and the element API (`toggleConfig`, `restore({settings})`,
+    /// `restoreWorkspace`).
+    ///
+    /// The `bool` is `announce`: `true` when this toggle is the SOLE
+    /// carrier of the config change (a user gesture — toolbar,
+    /// `toggleConfig`), which emits `toggle-settings` + one
+    /// `perspective-config-update`; `false` for the `restore` family,
+    /// whose own view-config commit dispatch announces the settings field
+    /// — one API call, one config-update.
+    ToggleSettingsInit(
+        Option<SettingsUpdate>,
+        bool,
+        Option<Sender<ApiResult<JsValue>>>,
+    ),
     UpdateSession(Box<SessionProps>),
     UpdateRenderer(Box<RendererProps>),
     UpdatePresentation(Box<PresentationProps>),
@@ -161,7 +191,16 @@ pub enum PerspectiveViewerMsg {
     UpdateIsWorkspace(bool),
 
     /// Update only `open_column_settings` in the presentation snapshot.
+    /// Handled in `settings.rs` (not `snapshots.rs`): a docked-drawer
+    /// mount/unmount defers the snapshot behind a presize sweep.
     UpdateColumnSettings(Box<crate::presentation::OpenColumnSettings>),
+
+    /// Every visible panel has rendered at its post-transition box — NOW
+    /// apply the newest deferred `open_column_settings` target (the
+    /// latest-wins slot, not a copy captured at sweep spawn); the `Sender`
+    /// resolves on the render commit so the staged presents reveal in the
+    /// same paint (mirrors `ToggleSettingsComplete`).
+    UpdateColumnSettingsCommit(Sender<()>),
     UpdateDragDrop(Box<DragDropProps>),
 
     /// Update only stats-related fields of `session_props` without touching

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;
 use crate::queries::*;
 use crate::renderer::Renderer;
 use crate::session::*;
@@ -124,7 +124,7 @@ impl PerspectiveViewer {
         }
     }
 
-    /// Whole-element `restore`'s single commit: the `Workspace` already holds
+    /// `restoreWorkspace`'s single commit: the `Workspace` already holds
     /// the final panel set (models inserted, olds ejected) and the staged
     /// layout. Re-subscribe the per-panel title wiring (the set changed
     /// wholesale), activate the restored panel, and re-render — `MainPanel`'s
@@ -193,7 +193,8 @@ impl PerspectiveViewer {
                     })
                     .await?;
 
-                let update = ViewerConfigUpdate::decode(&config.encode()?)?;
+                // TODO(texodus): what the ****?
+                let update = ViewerConfigInitial::decode(&config.encode()?)?;
                 let client = panel.session.get_client();
                 let new_id = create_panel(
                     &elem,
@@ -216,18 +217,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 +236,7 @@ impl PerspectiveViewer {
                     &workspace,
                     &notify,
                     None,
-                    update,
+                    ViewerConfigInitial::new(table_name),
                     client,
                 )
                 .await?;
@@ -273,18 +274,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),
                 Some(client),
             )
             .await?;
@@ -313,11 +309,12 @@ impl PerspectiveViewer {
         let presentation = ctx.props().presentation.clone();
         let workspace = ctx.props().workspace.clone();
         ApiFuture::spawn(async move {
-            let default_theme = presentation.get_default_theme_name().await;
-            if let Some(renderer) = workspace.active_renderer()
-                && let Some(theme) = renderer.theme().or(default_theme)
-            {
+            // Only an EXPLICITLY themed panel mirrors onto the host; an
+            // unpinned one inherits whatever the host already shows, so
+            // activating it must not restate (and thereby pin) that value.
+            if let Some(theme) = workspace.active_renderer().and_then(|x| x.theme()) {
                 presentation.set_theme_name(Some(&theme)).await?;
+                presentation.publish_theme_config().await?;
             }
 
             Ok(())

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

@@ -53,7 +53,7 @@ impl PerspectiveViewer {
         }
 
         let on_open_expr_panel = ctx.link().callback(|c| OpenColumnSettings {
-            locator: c,
+            target: c,
             sender: None,
             toggle: true,
         });
@@ -62,7 +62,9 @@ impl PerspectiveViewer {
             .link()
             .callback(|(x, _)| ColumnSettingsPanelSizeUpdate(Some(x)));
 
-        let on_close_settings = ctx.link().callback(|()| ToggleSettingsInit(None, None));
+        let on_close_settings = ctx
+            .link()
+            .callback(|()| ToggleSettingsInit(None, true, None));
         let on_debug = ctx.link().callback(|_| ToggleDebug);
         let selected_column = get_current_column_locator(
             &self.presentation_props.open_column_settings,
@@ -94,6 +96,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,13 +111,16 @@ impl PerspectiveViewer {
                     {presentation}
                     {renderer}
                     {session}
+                    workspace={ctx.props().workspace.clone()}
                 />
             }
         } else {
             html! { <></> }
         };
 
-        let on_settings = ctx.link().callback(|()| ToggleSettingsInit(None, None));
+        let on_settings = ctx
+            .link()
+            .callback(|()| ToggleSettingsInit(None, true, 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
@@ -151,6 +157,7 @@ impl PerspectiveViewer {
                         {presentation}
                         {renderer}
                         {session}
+                        workspace={ctx.props().workspace.clone()}
                     />
                     <></>
                 </SplitPanel>