@perspective-dev/viewer 5.3.1 → 5.4.0

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

@@ -22,15 +22,15 @@ use yew::prelude::*;
 
 use super::PerspectiveViewer;
 use super::msg::PerspectiveViewerMsg::*;
+use super::msg::{Divider, PaneTarget};
 use crate::components::column_settings_sidebar::ColumnSettingsPanel;
-use crate::components::containers::split_panel::SplitPanel;
-use crate::components::font_loader::FontLoader;
 use crate::components::main_panel::MainPanel;
 use crate::components::panel_menu::PanelCommand;
 use crate::components::settings_panel::SettingsPanel;
-use crate::components::style::StyleProvider;
+use crate::components::style::StyleSurface;
 use crate::queries::*;
 use crate::session::TableLoadState;
+use crate::ui::{FontLoader, SplitPanel, StyleProvider};
 
 impl PerspectiveViewer {
     pub(super) fn render(&self, ctx: &Context<Self>) -> Html {
@@ -58,10 +58,6 @@ impl PerspectiveViewer {
             toggle: true,
         });
 
-        let on_column_settings_panel_resize = ctx
-            .link()
-            .callback(|(x, _)| ColumnSettingsPanelSizeUpdate(Some(x)));
-
         let on_close_settings = ctx
             .link()
             .callback(|()| ToggleSettingsInit(None, true, None));
@@ -135,9 +131,12 @@ impl PerspectiveViewer {
                     id="modal_panel"
                     class={classes!(is_pinned.then_some("pinned"))}
                     reverse=true
+                    deferred={is_pinned}
+                    size={self.settings_geometry.column_settings_width_override}
                     initial_size={self.settings_geometry.column_settings_width_override}
-                    on_reset={ctx.link().callback(|_| ColumnSettingsPanelSizeUpdate(None))}
-                    on_resize={on_column_settings_panel_resize}
+                    on_reset={ctx.link().callback(|_| DividerMove(Divider::ColumnSettings, PaneTarget::Natural))}
+                    on_resize={ctx.link().callback(|(x, _): (i32, i32)| DividerMove(Divider::ColumnSettings, PaneTarget::Width(x)))}
+                    on_resize_finished={ctx.link().callback(|_| DividerFinish(Divider::ColumnSettings))}
                 >
                     <ColumnSettingsPanel
                         {selected_column}
@@ -171,6 +170,7 @@ impl PerspectiveViewer {
                 {on_reset}
                 on_activate_panel={ctx.link().callback(|id| SetActivePanel(id, None))}
                 on_close_panel={ctx.link().callback(|id| ClosePanel(id, None))}
+                on_panel_closed={ctx.link().callback(PanelClosed)}
                 on_panel_command={ctx.link().batch_callback(|(id, cmd): (String, PanelCommand)| {
                     match cmd {
                         PanelCommand::New => vec![NewPanel(id)],
@@ -178,6 +178,7 @@ impl PerspectiveViewer {
                             vec![NewPanelFrom { client, table }]
                         },
                         PanelCommand::Duplicate => vec![DuplicatePanel(id)],
+                        PanelCommand::NewFromPanel(source) => vec![DuplicatePanel(source)],
                         PanelCommand::Reset => vec![ResetPanel(Some(id), false, None)],
                         PanelCommand::ToggleMaster => vec![ToggleMaster(id)],
                         PanelCommand::Close => vec![ClosePanel(id, None)],
@@ -233,8 +234,9 @@ impl PerspectiveViewer {
         };
 
         html! {
-            <StyleProvider root={ctx.props().elem.clone()}>
+            <StyleProvider root={ctx.props().elem.clone()} sheet={StyleSurface::Viewer.sheet()}>
                 <div id="component_container" class={is_single_panel}>
+                    <slot name="modal" />
                     <div id="layout_area">
                         <SplitPanel
                             id="app_panel"
@@ -243,9 +245,9 @@ impl PerspectiveViewer {
                             deferred=true
                             size={self.settings_geometry.pane_width_override}
                             initial_size={self.settings_geometry.pane_width_override}
-                            on_reset={ctx.link().callback(|_| SettingsPanelSizeUpdate(None))}
-                            on_resize={ctx.link().callback(|(x, _): (i32, i32)| SettingsDividerMove(x))}
-                            on_resize_finished={ctx.link().callback(|_| SettingsDividerFinish)}
+                            on_reset={ctx.link().callback(|_| DividerMove(Divider::Settings, PaneTarget::Natural))}
+                            on_resize={ctx.link().callback(|(x, _): (i32, i32)| DividerMove(Divider::Settings, PaneTarget::Width(x)))}
+                            on_resize_finished={ctx.link().callback(|_| DividerFinish(Divider::Settings))}
                         >
                             { settings_panel }
                             <div id="main_column_container">

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

@@ -10,11 +10,6 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
-//! Settings-sidebar handlers: the open/close toggle (with its presize
-//! choreography), the deferred divider's latest-wins presize pump
-//! (`PRESIZE_EVERYWHERE_PLAN.md` P1/P2), and the column-settings drawer. The
-//! presize sweeps themselves live in [`crate::tasks`] (`presize_panels`).
-
 use futures::channel::oneshot::{Sender, channel};
 use perspective_js::utils::*;
 use wasm_bindgen::prelude::*;
@@ -22,12 +17,13 @@ use yew::prelude::*;
 
 use super::PerspectiveViewer;
 use super::msg::PerspectiveViewerMsg::*;
-use crate::components::font_loader::FontLoaderStatus;
+use super::msg::{Divider, PaneTarget};
 use crate::components::settings_panel::SelectedTab;
 use crate::config::*;
 use crate::presentation::{ColumnSettingsTab, ColumnSettingsTarget, OpenColumnSettings};
 use crate::queries::get_current_column_locator;
 use crate::tasks::*;
+use crate::ui::FontLoaderStatus;
 
 /// The settings sidebar's geometry state, folded into one field on
 /// [`PerspectiveViewer`]: the pane/drawer width overrides, the divider
@@ -44,11 +40,9 @@ pub(super) struct SettingsGeometry {
     /// High-water-mark auto width reported by the settings panel.
     pub auto_width: f64,
 
-    /// Latest-wins presize pump for the (deferred) settings divider: the
-    /// newest proposed pane width not yet presized, and whether a pump
-    /// iteration is in flight. See `SettingsDividerMove`.
-    pub divider_target: Option<i32>,
-    pub divider_pumping: bool,
+    pub settings_divider: DividerPump,
+
+    pub column_settings_divider: DividerPump,
 
     /// Open-state geometry deltas `(layout_area.w − mpc.w, main_column.h −
     /// mpc.h)`, cached at settings *close* time — used to presize panels to
@@ -85,6 +79,29 @@ pub(super) struct SettingsGeometry {
     pub column_settings_docked_width: Option<f64>,
 }
 
+#[derive(Default)]
+pub(super) struct DividerPump {
+    pub target: Option<PaneTarget>,
+    pub pumping: bool,
+    pub finish_pending: bool,
+}
+
+impl SettingsGeometry {
+    fn pump_mut(&mut self, divider: Divider) -> &mut DividerPump {
+        match divider {
+            Divider::Settings => &mut self.settings_divider,
+            Divider::ColumnSettings => &mut self.column_settings_divider,
+        }
+    }
+
+    fn is_divider_deferred(&self, divider: Divider) -> bool {
+        match divider {
+            Divider::Settings => true,
+            Divider::ColumnSettings => self.column_settings_pinned,
+        }
+    }
+}
+
 impl PerspectiveViewer {
     pub(super) fn on_toggle_settings_init(
         &mut self,
@@ -257,84 +274,143 @@ impl PerspectiveViewer {
         };
     }
 
-    pub(super) fn on_settings_panel_size_update(&mut self, x: Option<i32>) -> bool {
-        match x {
-            Some(x) => {
-                self.settings_geometry.pane_width_override = Some(x);
-                false
+    fn apply_pane_target(&mut self, divider: Divider, target: PaneTarget) -> bool {
+        let deferred = self.settings_geometry.is_divider_deferred(divider);
+        match (divider, target) {
+            (Divider::Settings, PaneTarget::Width(w)) => {
+                self.settings_geometry.pane_width_override = Some(w);
+                true
             },
-            None => {
+            (Divider::Settings, PaneTarget::Natural) => {
                 self.settings_geometry.pane_width_override = None;
                 self.settings_geometry.auto_width = 0.0;
                 self.on_settings_panel_dimensions_reset.emit(());
                 true
             },
+            (Divider::ColumnSettings, PaneTarget::Width(w)) => {
+                self.settings_geometry.column_settings_width_override = Some(w);
+                deferred
+            },
+            (Divider::ColumnSettings, PaneTarget::Natural) => {
+                self.settings_geometry.column_settings_width_override = None;
+                self.settings_geometry.column_settings_auto_width = 0.0;
+                true
+            },
         }
     }
 
-    pub(super) fn on_settings_divider_move(
+    pub(super) fn on_divider_move(
         &mut self,
         ctx: &Context<Self>,
-        pane_width: i32,
+        divider: Divider,
+        target: PaneTarget,
     ) -> bool {
+        if !self.settings_geometry.is_divider_deferred(divider) {
+            return self.apply_pane_target(divider, target);
+        }
+
         // Latest-wins: overwrite the pending target; start the pump if
         // idle. Intermediate targets that arrive while a presize is in
         // flight are dropped (mirrors `PresizeQueue`'s single queued
         // slot) — the pane tracks the pointer at content-render rate.
-        self.settings_geometry.divider_target = Some(pane_width);
-        if !self.settings_geometry.divider_pumping {
-            self.settings_geometry.divider_pumping = true;
-            ctx.link().send_message(SettingsDividerPump);
+        let pump = self.settings_geometry.pump_mut(divider);
+        pump.target = Some(target);
+        if !pump.pumping {
+            pump.pumping = true;
+            ctx.link().send_message(DividerPump(divider));
         }
 
         false
     }
 
-    pub(super) fn on_settings_divider_pump(&mut self, ctx: &Context<Self>) -> bool {
-        if let Some(pane_width) = self.settings_geometry.divider_target.take() {
-            let workspace = ctx.props().workspace.clone();
-            let elem = ctx.props().elem.clone();
-            let link = ctx.link().clone();
-            ApiFuture::spawn(async move {
-                let presents =
-                    presize_visible_panels_pane_width(&workspace, &elem, pane_width as f64).await;
-                link.send_message(SettingsDividerCommit(pane_width));
-                // Same task as the commit's re-render (whether Yew drained it
-                // synchronously inside `send_message` or deferred it to a
-                // microtask): the staged reveal and the pane-width geometry
-                // land in one paint.
-                presents.reveal();
-                Ok(())
-            });
-        } else {
-            self.settings_geometry.divider_pumping = false;
-        }
+    pub(super) fn on_divider_pump(&mut self, ctx: &Context<Self>, divider: Divider) -> bool {
+        let workspace = ctx.props().workspace.clone();
+        let pump = self.settings_geometry.pump_mut(divider);
+        let Some(target) = pump.target.take() else {
+            pump.pumping = false;
+            if std::mem::take(&mut pump.finish_pending) {
+                ApiFuture::spawn(async move {
+                    resize_visible_panels(&workspace).await;
+                    Ok(())
+                });
+            }
+
+            return false;
+        };
+
+        let elem = ctx.props().elem.clone();
+        let pane_width = match target {
+            PaneTarget::Width(w) => Some(w as f64),
+            PaneTarget::Natural => measure_pane_natural_width(&elem, divider.pane_selector()),
+        };
+
+        let link = ctx.link().clone();
+        ApiFuture::spawn(async move {
+            let presents = match pane_width {
+                Some(pane_width) => {
+                    presize_visible_panels_pane_width(
+                        &workspace,
+                        &elem,
+                        divider.pane_selector(),
+                        pane_width,
+                    )
+                    .await
+                },
+                None => StagedPresents::default(),
+            };
+
+            link.send_message(DividerCommit(divider, target));
+            presents.reveal();
+            Ok(())
+        });
 
         false
     }
 
-    pub(super) fn on_settings_divider_commit(
+    pub(super) fn on_divider_commit(
         &mut self,
         ctx: &Context<Self>,
-        pane_width: i32,
+        divider: Divider,
+        target: PaneTarget,
     ) -> bool {
         // Every visible panel has rendered at (approximately) its
         // target box — NOW move the geometry: the re-render below
-        // applies this width to the deferred `SplitPanel`'s controlled
+        // applies this target to the deferred `SplitPanel`'s controlled
         // `size`, in the same task as the presizes' inline clears.
-        self.settings_geometry.pane_width_override = Some(pane_width);
-        ctx.link().send_message(SettingsDividerPump);
+        self.apply_pane_target(divider, target);
+        if target == PaneTarget::Natural {
+            self.settings_geometry.pump_mut(divider).finish_pending = true;
+        }
+
+        ctx.link().send_message(DividerPump(divider));
         true
     }
 
-    pub(super) fn on_settings_divider_finish(&mut self, ctx: &Context<Self>) -> bool {
+    pub(super) fn on_divider_finish(&mut self, ctx: &Context<Self>, divider: Divider) -> bool {
+        if !self.settings_geometry.is_divider_deferred(divider) {
+            return false;
+        }
+
+        let pump = self.settings_geometry.pump_mut(divider);
+        if pump.pumping {
+            pump.finish_pending = true;
+        } else {
+            let workspace = ctx.props().workspace.clone();
+            ApiFuture::spawn(async move {
+                resize_visible_panels(&workspace).await;
+                Ok(())
+            });
+        }
+
+        false
+    }
+
+    fn resize_for_ratchet(&self, ctx: &Context<Self>) {
         let workspace = ctx.props().workspace.clone();
         ApiFuture::spawn(async move {
             resize_visible_panels(&workspace).await;
             Ok(())
         });
-
-        false
     }
 
     pub(super) fn on_settings_panel_tab_changed(&mut self, tab: SelectedTab) -> bool {
@@ -343,9 +419,10 @@ impl PerspectiveViewer {
         changed
     }
 
-    pub(super) fn on_settings_panel_auto_width(&mut self, w: f64) -> bool {
+    pub(super) fn on_settings_panel_auto_width(&mut self, ctx: &Context<Self>, w: f64) -> bool {
         if w > self.settings_geometry.auto_width {
             self.settings_geometry.auto_width = w;
+            self.resize_for_ratchet(ctx);
             true
         } else {
             false
@@ -397,19 +474,17 @@ impl PerspectiveViewer {
         true
     }
 
-    pub(super) fn on_column_settings_panel_size_update(&mut self, x: Option<i32>) -> bool {
-        self.settings_geometry.column_settings_width_override = x;
-        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 {
+    pub(super) fn on_column_settings_panel_auto_width(
+        &mut self,
+        ctx: &Context<Self>,
+        w: f64,
+    ) -> bool {
         if w > self.settings_geometry.column_settings_auto_width {
             self.settings_geometry.column_settings_auto_width = w;
+            if self.settings_geometry.column_settings_pinned {
+                self.resize_for_ratchet(ctx);
+            }
+
             true
         } else {
             false
@@ -561,12 +636,6 @@ impl PerspectiveViewer {
         true
     }
 
-    /// Toggling the debug tab re-renders the settings panel only — the
-    /// `DebugPanel` populates itself (`get_viewer_config` on mount +
-    /// change subscriptions), so no plugin dispatch is owed. The old
-    /// `just_render` here relied on the pre-amendment unconditional
-    /// `Unchanged → update` arm and repainted the plugin as a side effect
-    /// (`PLUGIN_DRAW_INVARIANT_PLAN.md` amendment, migration 2).
     pub(super) fn on_toggle_debug(&mut self, _ctx: &Context<Self>) -> bool {
         self.debug_open = !self.debug_open;
         true

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

@@ -22,7 +22,7 @@ use yew::prelude::*;
 use super::PerspectiveViewer;
 use crate::presentation::{DragDropProps, PresentationProps};
 use crate::renderer::RendererProps;
-use crate::session::{SessionProps, TableLoadState, ViewStats};
+use crate::session::{SessionProps, TableLoadState};
 use crate::tasks::resize_visible_panels;
 
 impl PerspectiveViewer {
@@ -59,12 +59,12 @@ impl PerspectiveViewer {
 
     pub(super) fn on_update_session_stats(
         &mut self,
-        stats: Option<ViewStats>,
+        has_table_cells: bool,
         has_table: Option<TableLoadState>,
     ) -> bool {
-        let changed =
-            stats != self.session_props.stats || has_table != self.session_props.has_table;
-        self.session_props.stats = stats;
+        let changed = has_table_cells != self.session_props.has_table_cells
+            || has_table != self.session_props.has_table;
+        self.session_props.has_table_cells = has_table_cells;
         self.session_props.has_table = has_table;
         changed
     }
@@ -146,11 +146,6 @@ impl PerspectiveViewer {
         changed
     }
 
-    /// LEVEL-triggered spinner count: ASSIGN the absolute in-flight
-    /// config-run count from the session's RAII accounting — any missed or
-    /// reordered notification is corrected by the next one, unlike the
-    /// edge-counted increment/decrement pair this replaces (see
-    /// `UPDATE_COUNT_REGRESSION_PLAN.md`).
     pub(super) fn on_update_in_flight(&mut self, count: u32) -> bool {
         let changed = count != self.update_count;
         self.update_count = count;

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

@@ -280,28 +280,14 @@ pub(super) fn create_active_subscriptions(
 
         let sub1 = session.table_loaded.add_notify_listener(&cb);
         let sub2 = session.table_unloaded.add_notify_listener(&cb);
-        // Snapshot refresh on every RECONCILED commit (SKIP/REUSE/paused
-        // included), not just `View` construction.
         let sub3 = session.commit_reconciled.add_notify_listener(&cb);
         let sub4 = session.view_config_changed.add_notify_listener(&cb);
         let sub5 = session.title_changed.add_notify_listener(&cb);
-
-        // The `StatusIndicator` spinner count. LEVEL-triggered: the payload
-        // is the ABSOLUTE in-flight config-run count (RAII-settled by
-        // `ConfigRunToken`), which the handler ASSIGNS — replacing the
-        // edge-counted `view_config_changed`+1/`view_created`−1 pair, whose
-        // pairing the pipeline does not guarantee (stuck-spinner
-        // regression — see `UPDATE_COUNT_REGRESSION_PLAN.md`).
         let sub6 = session
             .run_state_changed
             .add_listener(ctx.link().callback(UpdateInFlight));
 
-        // Stats fetch resolution (populates session.column_stats) triggers
-        // a fresh `SessionProps` so `column_stats` reaches downstream
-        // components and the StyleTab re-queries the schema with the
-        // new value.
         let sub7 = session.column_stats_changed.add_notify_listener(&cb);
-
         vec![sub1, sub2, sub3, sub4, sub5, sub6, sub7]
     };
 
@@ -311,12 +297,6 @@ pub(super) fn create_active_subscriptions(
             move |_: JsPerspectiveViewerPlugin| UpdateRenderer(Box::new(renderer.to_props(None)))
         });
 
-        // Re-snapshot RendererProps when the plugin_config bucket
-        // changes (in-tab edit via `send_plugin_config`, JSON paste via
-        // `restore_and_render`, full clear via `reset_all` with
-        // `all=true`). Without this, `RendererProps.plugin_config`
-        // would stay frozen at its construct-time value and `PluginTab`
-        // would render stale.
         let cb_plugin_config = ctx.link().callback({
             let renderer = renderer.clone();
             move |_: serde_json::Map<String, serde_json::Value>| {
@@ -413,7 +393,7 @@ pub(super) fn inject_active_callbacks(
         let s = session.clone();
         let cb = ctx
             .link()
-            .callback(move |_: ()| UpdateSessionStats(s.get_table_stats(), s.has_table()));
+            .callback(move |_: ()| UpdateSessionStats(s.has_table_cells(), s.has_table()));
 
         *session.on_stats_changed.borrow_mut() = Some(cb);
     }

package/src/rust/components/viewer.rs

@@ -27,6 +27,7 @@ mod settings;
 mod snapshots;
 mod wiring;
 
+use std::collections::HashMap;
 use std::rc::Rc;
 
 use futures::channel::oneshot::Sender;
@@ -40,13 +41,13 @@ pub use self::msg::PerspectiveViewerMsg;
 use self::msg::PerspectiveViewerMsg::*;
 use self::settings::SettingsGeometry;
 use self::wiring::*;
-use super::font_loader::{FontLoaderProps, FontLoaderStatus};
 use crate::presentation::{Presentation, PresentationProps};
 use crate::renderer::{RendererProps, *};
 use crate::session::{SessionProps, *};
 use crate::tasks::*;
+use crate::ui::{FontLoaderProps, FontLoaderStatus};
 use crate::utils::*;
-use crate::workspace::Workspace;
+use crate::workspace::{PanelId, Workspace};
 
 #[derive(Clone, Properties)]
 pub struct PerspectiveViewerProps {
@@ -99,6 +100,10 @@ pub struct PerspectiveViewer {
     on_settings_panel_dimensions_reset: Rc<PubSub<()>>,
     settings_open: bool,
 
+    /// `removePanel()` completions awaiting their panel's `PanelClosed`
+    /// (the deferred eject — see `ClosePanel`).
+    pending_closes: HashMap<PanelId, Completion>,
+
     /// Render snapshot of the `Workspace`-owned global filter set (see
     /// `Workspace::global_filters`); refreshed by `UpdateGlobalFilters` via
     /// the `filters_changed` subscription. The status-bar chips render from
@@ -210,6 +215,7 @@ impl Component for PerspectiveViewer {
             on_resize: Default::default(),
             on_settings_panel_dimensions_reset: Default::default(),
             settings_open: false,
+            pending_closes: HashMap::new(),
             global_filters: Vec::new(),
             settings_geometry: Default::default(),
             session_props,
@@ -305,6 +311,7 @@ impl Component for PerspectiveViewer {
             LayoutChanged => self.on_layout_changed(ctx),
             SetActivePanel(id, completion) => self.on_set_active_panel(ctx, id, completion),
             ClosePanel(id, completion) => self.on_close_panel(ctx, id, completion),
+            PanelClosed(id) => self.on_panel_closed(ctx, id),
             CommitWorkspaceRestore(id) => self.on_commit_workspace_restore(ctx, id),
             DuplicatePanel(id) => self.on_duplicate_panel(ctx, id),
             NewPanel(id) => self.on_new_panel(ctx, id),
@@ -325,20 +332,18 @@ impl Component for PerspectiveViewer {
             ToggleSettingsComplete(update, resolve) => {
                 self.on_toggle_settings_complete(ctx, update, resolve)
             },
-            SettingsPanelSizeUpdate(x) => self.on_settings_panel_size_update(x),
-            SettingsDividerMove(w) => self.on_settings_divider_move(ctx, w),
-            SettingsDividerPump => self.on_settings_divider_pump(ctx),
-            SettingsDividerCommit(w) => self.on_settings_divider_commit(ctx, w),
-            SettingsDividerFinish => self.on_settings_divider_finish(ctx),
+            DividerMove(divider, target) => self.on_divider_move(ctx, divider, target),
+            DividerPump(divider) => self.on_divider_pump(ctx, divider),
+            DividerCommit(divider, target) => self.on_divider_commit(ctx, divider, target),
+            DividerFinish(divider) => self.on_divider_finish(ctx, divider),
             SettingsPanelTabChanged(tab) => self.on_settings_panel_tab_changed(tab),
-            SettingsPanelAutoWidth(w) => self.on_settings_panel_auto_width(w),
+            SettingsPanelAutoWidth(w) => self.on_settings_panel_auto_width(ctx, w),
             OpenColumnSettings {
                 target,
                 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),
+            ColumnSettingsPanelAutoWidth(w) => self.on_column_settings_panel_auto_width(ctx, w),
             ToggleColumnSettingsPin => self.on_toggle_column_settings_pin(ctx),
             ToggleColumnSettingsPinComplete(resolve) => {
                 self.on_toggle_column_settings_pin_complete(resolve)

package/src/rust/components/window_editor.rs

@@ -20,12 +20,10 @@ use yew::prelude::*;
 
 use crate::components::column_dropdown::{ColumnDropDownElement, ColumnDropDownPortal};
 use crate::components::column_selector::{ColumnSelectorColumnRow, InPlaceColumn, PivotColumn};
-use crate::components::containers::dragdrop_list::{
-    DragContext, DragDropList, DragDropListItemProps,
-};
-use crate::components::containers::select::{Select, SelectItem};
+use crate::components::dragdrop_list::{DragContext, DragDropList, DragDropListItemProps};
 use crate::presentation::Presentation;
 use crate::session::{Session, SessionMetadataRc};
+use crate::ui::{IntlLabel, Select, SelectItem};
 use crate::utils::{AddListener, DragEffect, DragTarget, Subscription};
 
 /// The declared capabilities of one window aggregate, for a `source` column
@@ -479,8 +477,9 @@ impl Component for WindowSlotColumn {
             let presentation = ctx.props().presentation.clone();
             let action = ctx.props().action;
             move |event: DragEvent| {
-                presentation.set_drag_image(&event).unwrap();
-                presentation.notify_drag_start(column.clone(), DragEffect::Move(action))
+                if presentation.set_drag_image(&event) {
+                    presentation.notify_drag_start(column.clone(), DragEffect::Move(action))
+                }
             }
         });
 
@@ -909,7 +908,7 @@ impl Component for WindowEditor {
                 <div id="window-editor-slots">{ source_list }{ order_list }{ partition_list }</div>
                 <div id="window-editor-container">
                     if show_frame {
-                        <div class="column-style-label"><label id="window-frame-label" /></div>
+                        <div class="column-style-label"><IntlLabel name="window-frame" /></div>
                         <div class="row">
                             <Select<String>
                                 id="window-frame-type"
@@ -943,7 +942,7 @@ impl Component for WindowEditor {
                     }
                     if show_offset {
                         <div class="column-style-label">
-                            <label id="window-offset-label" class="indent" />
+                            <IntlLabel name="window-offset" class="indent" />
                         </div>
                         <div class="row">
                             <input
@@ -957,7 +956,7 @@ impl Component for WindowEditor {
                     }
                     if show_alpha {
                         <div class="column-style-label">
-                            <label id="window-alpha-label" class="indent" />
+                            <IntlLabel name="window-alpha" class="indent" />
                         </div>
                         <div class="row">
                             <input

package/src/rust/config/column_config_schema.rs

@@ -16,9 +16,9 @@ use serde::{Deserialize, Serialize};
 use serde_json::Value;
 
 use super::{
-    CssKind, CustomNumberFormatConfig, DatetimeFormatType, KeyValueOpts,
-    NumberSeriesStyleDefaultConfig,
+    CustomNumberFormatConfig, DatetimeFormatType, KeyValueOpts, NumberSeriesStyleDefaultConfig,
 };
+use crate::utils::{CssKind, GradientStopSpec, canonicalize_gradient_stops};
 
 /// The full schema for one column at one point in time. Plugins may return
 /// different schemas for the same column based on the column's current
@@ -154,31 +154,6 @@ pub struct EnumVariant {
     pub label: Option<String>,
 }
 
-/// One stop of a [`ControlSpec::GradientStops`] value in its in-memory
-/// form: a `#rrggbb` color at `offset` ∈ `[0, 1]`.
-#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
-pub struct GradientStopSpec {
-    pub color: String,
-    pub offset: f64,
-}
-
-/// The [`ControlSpec::GradientStops`] canonical stop order: offsets
-/// clamped to `[0, 1]` and rounded to 3 decimals, stops sorted stably
-/// by offset.
-pub fn canonicalize_gradient_stops(mut stops: Vec<GradientStopSpec>) -> Vec<GradientStopSpec> {
-    for stop in &mut stops {
-        stop.offset = (stop.offset.clamp(0.0, 1.0) * 1000.0).round() / 1000.0;
-    }
-
-    stops.sort_by(|a, b| {
-        a.offset
-            .partial_cmp(&b.offset)
-            .unwrap_or(std::cmp::Ordering::Equal)
-    });
-
-    stops
-}
-
 /// Fit `stops` to a `discrete` field's fixed pair: an over-length value
 /// keeps only its two end colors, pinned to `0`/`1`.
 pub fn discrete_pair(stops: Vec<GradientStopSpec>) -> Vec<GradientStopSpec> {