@perspective-dev/viewer 4.5.2 → 5.1.0

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

@@ -0,0 +1,434 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+// ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+// ┃ This file is part of the Perspective library, distributed under the terms ┃
+// ┃ 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::*;
+use yew::prelude::*;
+
+use super::PerspectiveViewer;
+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::tasks::*;
+
+/// The settings sidebar's geometry state, folded into one field on
+/// [`PerspectiveViewer`]: the pane/drawer width overrides, the divider
+/// presize pump, and the open-state deltas cache.
+#[derive(Default)]
+pub(super) struct SettingsGeometry {
+    /// User-dragged settings-pane width (the deferred `SplitPanel`'s
+    /// controlled `size`); `None` until first dragged / after a reset.
+    pub pane_width_override: Option<i32>,
+
+    /// The selected settings-panel tab.
+    pub selected_tab: SelectedTab,
+
+    /// 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,
+
+    /// Open-state geometry deltas `(layout_area.w − mpc.w, main_column.h −
+    /// mpc.h)`, cached at settings *close* time — used to presize panels to
+    /// their shrunk boxes BEFORE the pane mounts on the next *open* (P2).
+    /// `None` until the first close (the first-ever open is reactive).
+    pub open_deltas: Option<(f64, f64)>,
+
+    /// 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 {
+    pub(super) fn on_toggle_settings_init(
+        &mut self,
+        ctx: &Context<Self>,
+        update: Option<SettingsUpdate>,
+        resolve: Option<Sender<ApiResult<JsValue>>>,
+    ) -> bool {
+        match (update, resolve) {
+            (Some(SettingsUpdate::Missing), None) => false,
+            (Some(SettingsUpdate::Missing), Some(resolve)) => {
+                resolve.send(Ok(JsValue::UNDEFINED)).unwrap();
+                false
+            },
+            (Some(SettingsUpdate::SetDefault), resolve) => {
+                self.init_toggle_settings_task(ctx, Some(false), resolve);
+                false
+            },
+            (Some(SettingsUpdate::Update(force)), resolve) => {
+                self.init_toggle_settings_task(ctx, Some(force), resolve);
+                false
+            },
+            (None, resolve) => {
+                self.init_toggle_settings_task(ctx, None, resolve);
+                false
+            },
+        }
+    }
+
+    pub(super) fn on_toggle_settings_complete(
+        &mut self,
+        ctx: &Context<Self>,
+        update: SettingsUpdate,
+        resolve: Sender<()>,
+    ) -> bool {
+        match update {
+            SettingsUpdate::SetDefault if self.settings_open => {
+                ctx.props().presentation.set_open_column_settings(None);
+                self.settings_open = false;
+                self.on_rendered.push(resolve);
+                true
+            },
+            SettingsUpdate::Update(force) if force != self.settings_open => {
+                ctx.props().presentation.set_open_column_settings(None);
+                self.settings_open = force;
+                self.on_rendered.push(resolve);
+                true
+            },
+            _ if matches!(self.fonts.get_status(), FontLoaderStatus::Finished) => {
+                if let Err(e) = resolve.send(()) {
+                    tracing::error!("toggle settings failed {:?}", e);
+                }
+
+                false
+            },
+            _ => {
+                ctx.props().presentation.set_open_column_settings(None);
+                self.on_rendered.push(resolve);
+                true
+            },
+        }
+    }
+
+    /// Toggle the settings, or force the settings panel either open (true) or
+    /// closed (false) explicitly.  In order to reduce apparent
+    /// screen-shear, `toggle_settings()` uses a somewhat complex render
+    /// order:  it first resize the plugin's `<div>` without moving it,
+    /// using `overflow: hidden` to hide the extra draw area;  then,
+    /// after the _async_ drawing of the plugin is complete, it will send a
+    /// message to complete the toggle action and re-render the element with
+    /// the settings removed.
+    ///
+    /// # Arguments
+    /// * `force` - Whether to explicitly set the settings panel state to
+    ///   Open/Close (`Some(true)`/`Some(false)`), or to just toggle the current
+    ///   state (`None`).
+    fn init_toggle_settings_task(
+        &mut self,
+        ctx: &Context<Self>,
+        force: Option<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 {
+                    sender.send(Ok(JsValue::UNDEFINED)).unwrap();
+                }
+            },
+            Some(_) | None => {
+                let force = !is_open;
+                let callback = ctx.link().callback(move |resolve| {
+                    let update = SettingsUpdate::Update(force);
+                    ToggleSettingsComplete(update, resolve)
+                });
+
+                // P2: at CLOSE time the open-state geometry is measurable —
+                // cache the deltas the next OPEN needs to presize with.
+                if is_open {
+                    self.settings_geometry.open_deltas =
+                        measure_settings_open_deltas(&ctx.props().elem);
+                }
+
+                let open_deltas = self.settings_geometry.open_deltas;
+                let workspace = ctx.props().workspace.clone();
+                let presentation = ctx.props().presentation.clone();
+                let elem = ctx.props().elem.clone();
+
+                ApiFuture::spawn(async move {
+                    // Resize every visible plugin (not just the active one) to its
+                    // new cell as the settings pane toggles. The pane is the outer
+                    // SplitPanel, which emits no `before-resize`, so this is driven
+                    // explicitly here. CLOSING grows the cells, so pre-size each
+                    // plugin to its grown box BEFORE collapsing the pane; OPENING
+                    // shrinks them, so pre-size to the shrunk box (from the deltas
+                    // cached at the last close; the first-ever open has none and
+                    // stays reactive) BEFORE the pane mounts — either way, one
+                    // clean resize with the reactive pass after as the exactness
+                    // finalizer.
+                    let result: ApiResult<JsValue> = async {
+                        if is_open {
+                            let presents = presize_visible_panels_grown(&workspace, &elem).await;
+                            let (notify, rendered) = channel::<()>();
+                            callback.emit(notify);
+                            presentation.set_settings_open(false);
+                            rendered.await?;
+                            // `notify` fires in `rendered()` (same task as the
+                            // Yew DOM patch) and this future resumes as one of
+                            // its microtasks — so the staged reveal below and
+                            // the pane's geometry change reach the screen in a
+                            // single paint.
+                            presents.reveal();
+                            // I6: the exactness-finalizer resize is part of
+                            // what this toggle caused — await it here rather
+                            // than leaving it to the ResizeObserver (whose
+                            // continuous pass remains as the reactive
+                            // backstop).
+                            resize_visible_panels(&workspace).await;
+                        } else {
+                            let presents = if let Some((delta_w, delta_h)) = open_deltas {
+                                presize_visible_panels_open(&workspace, &elem, delta_w, delta_h)
+                                    .await
+                            } else {
+                                StagedPresents::default()
+                            };
+
+                            let (notify, rendered) = channel::<()>();
+                            callback.emit(notify);
+                            presentation.set_settings_open(true);
+                            rendered.await?;
+                            presents.reveal();
+                            resize_visible_panels(&workspace).await;
+                        }
+                        Ok(JsValue::UNDEFINED)
+                    }
+                    .await;
+
+                    if let Some(sender) = sender {
+                        let msg = result.ignore_view_delete();
+                        sender
+                            .send(msg.map(|x| x.unwrap_or(JsValue::UNDEFINED)))
+                            .into_apierror()?;
+                    };
+
+                    Ok(JsValue::undefined())
+                });
+            },
+        };
+    }
+
+    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
+            },
+            None => {
+                self.settings_geometry.pane_width_override = None;
+                self.settings_geometry.auto_width = 0.0;
+                self.on_settings_panel_dimensions_reset.emit(());
+                true
+            },
+        }
+    }
+
+    pub(super) fn on_settings_divider_move(
+        &mut self,
+        ctx: &Context<Self>,
+        pane_width: i32,
+    ) -> bool {
+        // 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);
+        }
+
+        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;
+        }
+
+        false
+    }
+
+    pub(super) fn on_settings_divider_commit(
+        &mut self,
+        ctx: &Context<Self>,
+        pane_width: i32,
+    ) -> 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
+        // `size`, in the same task as the presizes' inline clears.
+        self.settings_geometry.pane_width_override = Some(pane_width);
+        ctx.link().send_message(SettingsDividerPump);
+        true
+    }
+
+    pub(super) fn on_settings_divider_finish(&mut self, ctx: &Context<Self>) -> bool {
+        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 {
+        let changed = tab != self.settings_geometry.selected_tab;
+        self.settings_geometry.selected_tab = tab;
+        changed
+    }
+
+    pub(super) fn on_settings_panel_auto_width(&mut self, w: f64) -> bool {
+        if w > self.settings_geometry.auto_width {
+            self.settings_geometry.auto_width = w;
+            true
+        } else {
+            false
+        }
+    }
+
+    pub(super) fn on_open_column_settings(
+        &mut self,
+        ctx: &Context<Self>,
+        locator: Option<ColumnLocator>,
+        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 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
+                        }
+                    })
+                })
+            };
+
+            ctx.props()
+                .presentation
+                .set_open_column_settings(Some(open_column_settings));
+
+            if locator.is_some() {
+                self.settings_geometry.selected_tab = SelectedTab::Query;
+            }
+        }
+
+        if let Some(sender) = sender {
+            // I6: resolve on the render commit that applies this change (the
+            // shared `on_rendered` queue, drained in `rendered()` once fonts
+            // settle), not at message-handling time.
+            self.on_rendered.push(sender);
+        }
+
+        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 {
+        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(
+        &mut self,
+        ctx: &Context<Self>,
+        tab: ColumnSettingsTab,
+    ) -> bool {
+        let mut open_column_settings = ctx.props().presentation.get_open_column_settings();
+        open_column_settings.tab.clone_from(&Some(tab));
+        ctx.props()
+            .presentation
+            .set_open_column_settings(Some(open_column_settings));
+        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

@@ -0,0 +1,134 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+// ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+// ┃ This file is part of the Perspective library, distributed under the terms ┃
+// ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+//! Value-semantic snapshot plumbing: the mechanical `Update*` handlers that
+//! copy fresh engine-state snapshots (dispatched by the [`super::wiring`]
+//! subscriptions/callbacks) into the root's props fields, re-rendering only
+//! on an actual change.
+
+use yew::prelude::*;
+
+use super::PerspectiveViewer;
+use crate::presentation::{DragDropProps, OpenColumnSettings, PresentationProps};
+use crate::renderer::RendererProps;
+use crate::session::{SessionProps, TableLoadState, ViewStats};
+
+impl PerspectiveViewer {
+    pub(super) fn on_update_session(&mut self, props: SessionProps) -> bool {
+        let changed = props != self.session_props;
+        self.session_props = props;
+        changed
+    }
+
+    pub(super) fn on_update_session_stats(
+        &mut self,
+        stats: Option<ViewStats>,
+        has_table: Option<TableLoadState>,
+    ) -> bool {
+        let changed =
+            stats != self.session_props.stats || has_table != self.session_props.has_table;
+        self.session_props.stats = stats;
+        self.session_props.has_table = has_table;
+        changed
+    }
+
+    pub(super) fn on_update_renderer(&mut self, props: RendererProps) -> bool {
+        let changed = props != self.renderer_props;
+        self.renderer_props = props;
+        changed
+    }
+
+    pub(super) fn on_update_presentation(
+        &mut self,
+        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.
+        let old_default = self.presentation_props.available_themes.first().cloned();
+        let new_default = props.available_themes.first().cloned();
+        if old_default != new_default {
+            for panel in ctx
+                .props()
+                .workspace
+                .panel_ids()
+                .into_iter()
+                .filter_map(|id| ctx.props().workspace.panel(&id))
+            {
+                panel.renderer.set_default_theme(new_default.clone());
+                if panel.renderer.needs_restyle() {
+                    let renderer = panel.renderer.clone();
+                    crate::utils::spawn_owned("default-theme-restyle", async move {
+                        renderer.restyle_all().await?;
+                        Ok(())
+                    });
+                }
+            }
+        }
+
+        let changed = props != self.presentation_props;
+        self.presentation_props = props;
+        changed
+    }
+
+    pub(super) fn on_update_settings_open(&mut self, open: bool) -> bool {
+        let changed = open != self.presentation_props.is_settings_open;
+        self.presentation_props.is_settings_open = open;
+        changed
+    }
+
+    pub(super) fn on_update_is_workspace(&mut self, is_workspace: bool) -> bool {
+        let changed = is_workspace != self.presentation_props.is_workspace;
+        self.presentation_props.is_workspace = is_workspace;
+        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;
+        changed
+    }
+
+    pub(super) fn on_update_global_filters(&mut self, ctx: &Context<Self>) -> bool {
+        let filters = ctx.props().workspace.global_filters();
+        let changed = filters != self.global_filters;
+        self.global_filters = filters;
+        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;
+        changed
+    }
+}