@perspective-dev/viewer 5.1.0 → 5.3.0

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

@@ -25,7 +25,8 @@ use super::msg::PerspectiveViewerMsg::*;
 use crate::components::font_loader::FontLoaderStatus;
 use crate::components::settings_panel::SelectedTab;
 use crate::config::*;
-use crate::presentation::{ColumnLocator, ColumnSettingsTab};
+use crate::presentation::{ColumnSettingsTab, ColumnSettingsTarget, OpenColumnSettings};
+use crate::queries::get_current_column_locator;
 use crate::tasks::*;
 
 /// The settings sidebar's geometry state, folded into one field on
@@ -69,6 +70,19 @@ pub(super) struct SettingsGeometry {
     /// than FLOATING over the main panel (the default absolute overlay).
     /// Session UI state, not part of the saved config.
     pub column_settings_pinned: bool,
+
+    /// Latest-wins deferred `open_column_settings` snapshot: the newest
+    /// target not yet applied while a docked-drawer presize sweep is in
+    /// flight. `UpdateColumnSettingsCommit` applies THIS slot (not a copy
+    /// captured at spawn), so a newer target arriving mid-sweep wins and
+    /// out-of-order commits are inexpressible.
+    pub column_settings_target: Option<OpenColumnSettings>,
+    pub column_settings_commit_pending: bool,
+
+    /// The docked drawer's span, cached whenever it is measurable (pin
+    /// toggle, docked unmount) - used to presize for a drawer that MOUNTS
+    /// directly into pinned mode, when it isn't in the DOM to measure.
+    pub column_settings_docked_width: Option<f64>,
 }
 
 impl PerspectiveViewer {
@@ -76,6 +90,7 @@ impl PerspectiveViewer {
         &mut self,
         ctx: &Context<Self>,
         update: Option<SettingsUpdate>,
+        announce: bool,
         resolve: Option<Sender<ApiResult<JsValue>>>,
     ) -> bool {
         match (update, resolve) {
@@ -85,15 +100,15 @@ impl PerspectiveViewer {
                 false
             },
             (Some(SettingsUpdate::SetDefault), resolve) => {
-                self.init_toggle_settings_task(ctx, Some(false), resolve);
+                self.init_toggle_settings_task(ctx, Some(false), announce, resolve);
                 false
             },
             (Some(SettingsUpdate::Update(force)), resolve) => {
-                self.init_toggle_settings_task(ctx, Some(force), resolve);
+                self.init_toggle_settings_task(ctx, Some(force), announce, resolve);
                 false
             },
             (None, resolve) => {
-                self.init_toggle_settings_task(ctx, None, resolve);
+                self.init_toggle_settings_task(ctx, None, announce, resolve);
                 false
             },
         }
@@ -150,10 +165,10 @@ impl PerspectiveViewer {
         &mut self,
         ctx: &Context<Self>,
         force: Option<bool>,
+        announce: bool,
         sender: Option<Sender<ApiResult<JsValue>>>,
     ) {
         let is_open = ctx.props().presentation.is_settings_open();
-        ctx.props().presentation.set_settings_before_open(!is_open);
         match force {
             Some(force) if is_open == force => {
                 if let Some(sender) = sender {
@@ -161,6 +176,7 @@ impl PerspectiveViewer {
                 }
             },
             Some(_) | None => {
+                ctx.props().presentation.set_settings_before_open(!is_open);
                 let force = !is_open;
                 let callback = ctx.link().callback(move |resolve| {
                     let update = SettingsUpdate::Update(force);
@@ -195,7 +211,7 @@ impl PerspectiveViewer {
                             let presents = presize_visible_panels_grown(&workspace, &elem).await;
                             let (notify, rendered) = channel::<()>();
                             callback.emit(notify);
-                            presentation.set_settings_open(false);
+                            presentation.set_settings_open(false, announce);
                             rendered.await?;
                             // `notify` fires in `rendered()` (same task as the
                             // Yew DOM patch) and this future resumes as one of
@@ -219,7 +235,7 @@ impl PerspectiveViewer {
 
                             let (notify, rendered) = channel::<()>();
                             callback.emit(notify);
-                            presentation.set_settings_open(true);
+                            presentation.set_settings_open(true, announce);
                             rendered.await?;
                             presents.reveal();
                             resize_visible_panels(&workspace).await;
@@ -339,36 +355,34 @@ impl PerspectiveViewer {
     pub(super) fn on_open_column_settings(
         &mut self,
         ctx: &Context<Self>,
-        locator: Option<ColumnLocator>,
+        target: Option<ColumnSettingsTarget>,
         sender: Option<Sender<()>>,
         toggle: bool,
     ) -> bool {
         let mut open_column_settings = ctx.props().presentation.get_open_column_settings();
-        if locator == open_column_settings.locator {
+        if target == open_column_settings.target {
             if toggle {
                 ctx.props().presentation.set_open_column_settings(None);
             }
         } else {
-            open_column_settings.locator.clone_from(&locator);
-            open_column_settings.tab = if matches!(locator, Some(ColumnLocator::NewExpression)) {
-                Some(ColumnSettingsTab::Attributes)
-            } else {
-                locator.as_ref().and_then(|x| {
-                    x.name().map(|x| {
-                        if self.session_props.is_column_active(x) {
-                            ColumnSettingsTab::Style
-                        } else {
-                            ColumnSettingsTab::Attributes
-                        }
+            open_column_settings.target.clone_from(&target);
+            open_column_settings.tab = match &target {
+                Some(ColumnSettingsTarget::NewExpression) => Some(ColumnSettingsTab::Attributes),
+                Some(ColumnSettingsTarget::Column(name)) => {
+                    Some(if self.session_props.is_column_active(name) {
+                        ColumnSettingsTab::Style
+                    } else {
+                        ColumnSettingsTab::Attributes
                     })
-                })
+                },
+                None => None,
             };
 
             ctx.props()
                 .presentation
                 .set_open_column_settings(Some(open_column_settings));
 
-            if locator.is_some() {
+            if target.is_some() {
                 self.settings_geometry.selected_tab = SelectedTab::Query;
             }
         }
@@ -402,9 +416,135 @@ impl PerspectiveViewer {
         }
     }
 
-    pub(super) fn on_toggle_column_settings_pin(&mut self) -> bool {
+    pub(super) fn on_toggle_column_settings_pin(&mut self, ctx: &Context<Self>) -> bool {
+        let is_pinned = self.settings_geometry.column_settings_pinned;
+        let delta_w = measure_column_settings_pin_delta(&ctx.props().elem, is_pinned);
+        if let Some(delta_w) = delta_w {
+            self.settings_geometry.column_settings_docked_width = Some(delta_w.abs());
+        }
+
+        self.presize_column_settings_shift(ctx, delta_w, ToggleColumnSettingsPinComplete);
+        false
+    }
+
+    pub(super) fn on_toggle_column_settings_pin_complete(&mut self, resolve: Sender<()>) -> bool {
         self.settings_geometry.column_settings_pinned =
             !self.settings_geometry.column_settings_pinned;
+        self.on_rendered.push(resolve);
+        true
+    }
+
+    /// Shared presize choreography for a column-settings geometry shift:
+    /// pre-size every visible panel by `delta_w` (`None` = no sweep, commit
+    /// only), send `commit_msg` to apply the deferred state on the render
+    /// commit, reveal the staged frames in that same paint, then reactively
+    /// finalize at the exact settled cells (I6).
+    fn presize_column_settings_shift(
+        &self,
+        ctx: &Context<Self>,
+        delta_w: Option<f64>,
+        commit_msg: fn(Sender<()>) -> super::msg::PerspectiveViewerMsg,
+    ) {
+        let workspace = ctx.props().workspace.clone();
+        let elem = ctx.props().elem.clone();
+        let callback = ctx.link().callback(commit_msg);
+        ApiFuture::spawn(async move {
+            let presents = match delta_w {
+                Some(delta_w) => presize_visible_panels_open(&workspace, &elem, delta_w, 0.0).await,
+                None => StagedPresents::default(),
+            };
+
+            let (notify, rendered) = channel::<()>();
+            callback.emit(notify);
+            rendered.await?;
+            presents.reveal();
+            resize_visible_panels(&workspace).await;
+            Ok(())
+        });
+    }
+
+    /// Whether the drawer renders for this `open_column_settings` snapshot
+    /// (the `render()` mount predicate). Sensitive to the session snapshot
+    /// too — `snapshots.rs` re-evaluates it across an `UpdateSession` apply,
+    /// which can invalidate the open column's locator (e.g. a drag
+    /// replacing it in `columns`) and unmount the drawer without any
+    /// `UpdateColumnSettings` traffic.
+    pub(super) fn is_column_settings_mounted(&self, ocs: &OpenColumnSettings) -> bool {
+        get_current_column_locator(
+            ocs,
+            &self.active_renderer,
+            &self.session_props.config,
+            &self.session_props.metadata,
+        )
+        .is_some()
+    }
+
+    /// The `open_column_settings` snapshot handler: mount/unmount of the
+    /// DOCKED drawer moves `#main_panel_container`'s flex box just like the
+    /// pin toggle — and no `before-resize` fires for it — so those
+    /// transitions defer the snapshot behind the presize choreography.
+    /// Floating transitions and in-place locator changes apply synchronously
+    /// as before, unless a deferred commit is in flight (they queue into the
+    /// latest-wins slot to preserve commit order).
+    pub(super) fn on_update_column_settings(
+        &mut self,
+        ctx: &Context<Self>,
+        ocs: OpenColumnSettings,
+    ) -> bool {
+        self.refresh_session_snapshot(ctx);
+        let effective = self
+            .settings_geometry
+            .column_settings_target
+            .as_ref()
+            .unwrap_or(&self.presentation_props.open_column_settings);
+        if ocs == *effective {
+            return false;
+        }
+
+        let was_mounted =
+            self.is_column_settings_mounted(&self.presentation_props.open_column_settings);
+        let will_mount = self.is_column_settings_mounted(&ocs);
+        let needs_presize =
+            self.settings_geometry.column_settings_pinned && was_mounted != will_mount;
+        if !needs_presize && !self.settings_geometry.column_settings_commit_pending {
+            self.presentation_props.open_column_settings = ocs;
+            return true;
+        }
+
+        self.settings_geometry.column_settings_target = Some(ocs);
+        if self.settings_geometry.column_settings_commit_pending {
+            return false;
+        }
+
+        self.settings_geometry.column_settings_commit_pending = true;
+        let delta_w = if !needs_presize {
+            None
+        } else if was_mounted {
+            // Unmounting - the docked drawer is still in the DOM, and its
+            // freed span is the same measurement as an unpin.
+            let delta = measure_column_settings_pin_delta(&ctx.props().elem, true);
+            if let Some(delta) = delta {
+                self.settings_geometry.column_settings_docked_width = Some(delta.abs());
+            }
+
+            delta
+        } else {
+            // Mounting directly into pinned mode - not yet in the DOM; the
+            // span cached at the last dock/unmount predicts the shrink.
+            self.settings_geometry.column_settings_docked_width
+        };
+
+        self.presize_column_settings_shift(ctx, delta_w, UpdateColumnSettingsCommit);
+        false
+    }
+
+    pub(super) fn on_update_column_settings_commit(&mut self, resolve: Sender<()>) -> bool {
+        self.settings_geometry.column_settings_commit_pending = false;
+        self.on_rendered.push(resolve);
+        if let Some(ocs) = self.settings_geometry.column_settings_target.take() {
+            self.presentation_props.open_column_settings = ocs;
+        }
+
         true
     }
 

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

@@ -15,17 +15,45 @@
 //! subscriptions/callbacks) into the root's props fields, re-rendering only
 //! on an actual change.
 
+use futures::channel::oneshot::channel;
+use perspective_js::utils::ApiFuture;
 use yew::prelude::*;
 
 use super::PerspectiveViewer;
-use crate::presentation::{DragDropProps, OpenColumnSettings, PresentationProps};
+use crate::presentation::{DragDropProps, PresentationProps};
 use crate::renderer::RendererProps;
 use crate::session::{SessionProps, TableLoadState, ViewStats};
+use crate::tasks::resize_visible_panels;
 
 impl PerspectiveViewer {
-    pub(super) fn on_update_session(&mut self, props: SessionProps) -> bool {
+    pub(super) fn refresh_session_snapshot(&mut self, ctx: &Context<Self>) {
+        let props = self.active_session.to_props();
+        if props != self.session_props {
+            self.on_update_session(ctx, props);
+        }
+    }
+
+    pub(super) fn on_update_session(&mut self, ctx: &Context<Self>, props: SessionProps) -> bool {
         let changed = props != self.session_props;
+        let was_mounted =
+            self.is_column_settings_mounted(&self.presentation_props.open_column_settings);
         self.session_props = props;
+        let now_mounted =
+            self.is_column_settings_mounted(&self.presentation_props.open_column_settings);
+        if self.settings_geometry.column_settings_pinned
+            && was_mounted != now_mounted
+            && !self.settings_geometry.column_settings_commit_pending
+        {
+            let (notify, rendered) = channel::<()>();
+            self.on_rendered.push(notify);
+            let workspace = ctx.props().workspace.clone();
+            ApiFuture::spawn(async move {
+                rendered.await?;
+                resize_visible_panels(&workspace).await;
+                Ok(())
+            });
+        }
+
         changed
     }
 
@@ -52,18 +80,17 @@ impl PerspectiveViewer {
         ctx: &Context<Self>,
         props: PresentationProps,
     ) -> bool {
-        // Default-theme fan-out: when the registry default (first available
-        // theme) changes — the async theme discovery resolving at boot, or a
-        // `resetThemes` — push the new default into every panel's renderer
-        // cache (locked draws stamp the effective theme from it), and
-        // restyle the panels whose captured `--psp-*` CSS is STALE against
-        // the new effective value (`Renderer::needs_restyle` — the plugin's
-        // captured theme is the baseline; plugins only re-read CSS at
-        // `restyle()`/first-draw, so a plain redraw would not repaint a
-        // panel that first drew before discovery resolved, while a panel
-        // that captured post-discovery — or owes its first paint — restyles
-        // nothing). The outer default-diff scopes the scan; the per-panel
-        // gate is state, never call history or DOM state.
+        // Boot fill-in: theme discovery resolving turns an empty registry
+        // into a real one, and any panel created before that has no theme to
+        // stamp. Give those — and ONLY those — the new default, then restyle
+        // the ones whose captured `--psp-*` CSS is now stale
+        // (`Renderer::needs_restyle`; plugins re-read CSS only at
+        // `restyle()`/first-draw, so a plain redraw would not repaint them).
+        //
+        // A panel that already has a theme is never touched here: `theme` is
+        // concrete state, so re-ordering the registry — or any other
+        // `resetThemes` that leaves a panel's theme available — must repaint
+        // nothing.
         let old_default = self.presentation_props.available_themes.first().cloned();
         let new_default = props.available_themes.first().cloned();
         if old_default != new_default {
@@ -74,7 +101,11 @@ impl PerspectiveViewer {
                 .into_iter()
                 .filter_map(|id| ctx.props().workspace.panel(&id))
             {
-                panel.renderer.set_default_theme(new_default.clone());
+                if panel.renderer.theme().is_some() {
+                    continue;
+                }
+
+                panel.renderer.set_theme(new_default.clone());
                 if panel.renderer.needs_restyle() {
                     let renderer = panel.renderer.clone();
                     crate::utils::spawn_owned("default-theme-restyle", async move {
@@ -102,12 +133,6 @@ impl PerspectiveViewer {
         changed
     }
 
-    pub(super) fn on_update_column_settings(&mut self, ocs: OpenColumnSettings) -> bool {
-        let changed = ocs != self.presentation_props.open_column_settings;
-        self.presentation_props.open_column_settings = ocs;
-        changed
-    }
-
     pub(super) fn on_update_dragdrop(&mut self, props: DragDropProps) -> bool {
         let changed = props != self.dragdrop_props;
         self.dragdrop_props = props;

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

@@ -343,7 +343,9 @@ pub(super) fn create_active_subscriptions(
 pub(super) fn create_shared_subscriptions(ctx: &Context<PerspectiveViewer>) -> Vec<Subscription> {
     let presentation_props_sub = {
         let presentation = ctx.props().presentation.clone();
-        let cb_settings = ctx.link().callback(UpdateSettingsOpen);
+        let cb_settings = ctx
+            .link()
+            .callback(|(open, _): (bool, bool)| UpdateSettingsOpen(open));
         let cb_theme = {
             let pres = presentation.clone();
             ctx.link()
@@ -368,17 +370,6 @@ pub(super) fn create_shared_subscriptions(ctx: &Context<PerspectiveViewer>) -> V
         vec![sub1, sub2, sub3]
     };
 
-    let dragdrop_props_sub = {
-        let cb_clear = ctx.link().callback(|_: ()| UpdateDragDrop(Box::default()));
-        let sub1 = ctx
-            .props()
-            .presentation
-            .drop_received
-            .add_notify_listener(&cb_clear);
-
-        vec![sub1]
-    };
-
     // The `Workspace`-owned global filter set → the root's render snapshot.
     let filters_sub = {
         let cb = ctx.link().callback(|_: ()| UpdateGlobalFilters);
@@ -388,11 +379,12 @@ pub(super) fn create_shared_subscriptions(ctx: &Context<PerspectiveViewer>) -> V
             .add_notify_listener(&cb)
     };
 
-    // Staged-set transitions (`Workspace::stage_panel`/`clear_staged`) → a
-    // root re-render for the stage-level chrome (`only-child` class,
-    // binding resync). `MainPanel` inserts/reveals promoted panels via its
-    // OWN `staged_changed` subscription (`MainPanelMsg::StagedChanged`) —
-    // see `WorkspaceData::staged_changed`.
+    // Panel-phase transitions (`Workspace::insert_panel` at
+    // `PanelPhase::Staging` / `Workspace::promote`) → a root re-render for
+    // the stage-level chrome (`only-child` class, binding resync).
+    // `MainPanel` inserts/reveals promoted panels via its OWN
+    // `staged_changed` subscription (`MainPanelMsg::StagedChanged`) — see
+    // `WorkspaceData::staged_changed`.
     let staged_sub = {
         let cb = ctx.link().callback(|_: ()| LayoutChanged);
         ctx.props()
@@ -403,7 +395,6 @@ pub(super) fn create_shared_subscriptions(ctx: &Context<PerspectiveViewer>) -> V
 
     let mut subscriptions = Vec::new();
     subscriptions.extend(presentation_props_sub);
-    subscriptions.extend(dragdrop_props_sub);
     subscriptions.push(filters_sub);
     subscriptions.push(staged_sub);
     subscriptions
@@ -446,15 +437,13 @@ pub(super) fn inject_active_callbacks(
         let cb = ctx.link().batch_callback(move |limits: RenderLimits| {
             let mut msgs = vec![UpdateRenderer(Box::new(r.to_props(Some(limits))))];
             if !limits.is_update {
-                let locator = get_current_column_locator(
-                    &presentation.get_open_column_settings(),
-                    &r,
-                    &s.get_view_config(),
-                    &s.metadata(),
-                );
+                let ocs = presentation.get_open_column_settings();
+                let still_open =
+                    get_current_column_locator(&ocs, &r, &s.get_view_config(), &s.metadata())
+                        .is_some();
 
                 msgs.push(OpenColumnSettings {
-                    locator,
+                    target: ocs.target.filter(|_| still_open),
                     sender: None,
                     toggle: false,
                 });

package/src/rust/components/viewer.rs

@@ -166,7 +166,7 @@ impl Component for PerspectiveViewer {
         let renderer_props = active_renderer.to_props(None);
         let presentation_props = ctx.props().presentation.to_props(PtrEqRc::new(vec![]));
         let on_close_column_settings = ctx.link().callback(|_| OpenColumnSettings {
-            locator: None,
+            target: None,
             sender: None,
             toggle: false,
         });
@@ -319,8 +319,8 @@ impl Component for PerspectiveViewer {
             ClearGlobalFilters => self.on_clear_global_filters(ctx),
 
             // Settings sidebar + divider pump + column settings (`settings.rs`)
-            ToggleSettingsInit(update, resolve) => {
-                self.on_toggle_settings_init(ctx, update, resolve)
+            ToggleSettingsInit(update, announce, resolve) => {
+                self.on_toggle_settings_init(ctx, update, announce, resolve)
             },
             ToggleSettingsComplete(update, resolve) => {
                 self.on_toggle_settings_complete(ctx, update, resolve)
@@ -333,25 +333,29 @@ impl Component for PerspectiveViewer {
             SettingsPanelTabChanged(tab) => self.on_settings_panel_tab_changed(tab),
             SettingsPanelAutoWidth(w) => self.on_settings_panel_auto_width(w),
             OpenColumnSettings {
-                locator,
+                target,
                 sender,
                 toggle,
-            } => self.on_open_column_settings(ctx, locator, sender, toggle),
+            } => self.on_open_column_settings(ctx, target, 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(),
+            ToggleColumnSettingsPin => self.on_toggle_column_settings_pin(ctx),
+            ToggleColumnSettingsPinComplete(resolve) => {
+                self.on_toggle_column_settings_pin_complete(resolve)
+            },
             ColumnSettingsTabChanged(tab) => self.on_column_settings_tab_changed(ctx, tab),
             ToggleDebug => self.on_toggle_debug(ctx),
 
             // Value-semantic snapshot plumbing (`snapshots.rs`)
-            UpdateSession(props) => self.on_update_session(*props),
+            UpdateSession(props) => self.on_update_session(ctx, *props),
             UpdateSessionStats(stats, has_table) => self.on_update_session_stats(stats, has_table),
             UpdateGlobalFilters => self.on_update_global_filters(ctx),
             UpdateRenderer(props) => self.on_update_renderer(*props),
             UpdatePresentation(props) => self.on_update_presentation(ctx, *props),
             UpdateSettingsOpen(open) => self.on_update_settings_open(open),
             UpdateIsWorkspace(is_workspace) => self.on_update_is_workspace(is_workspace),
-            UpdateColumnSettings(ocs) => self.on_update_column_settings(*ocs),
+            UpdateColumnSettings(ocs) => self.on_update_column_settings(ctx, *ocs),
+            UpdateColumnSettingsCommit(resolve) => self.on_update_column_settings_commit(resolve),
             UpdateDragDrop(props) => self.on_update_dragdrop(*props),
             UpdateInFlight(count) => self.on_update_in_flight(count),
         }