@perspective-dev/viewer 4.5.2 → 5.1.0

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

@@ -0,0 +1,182 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+//! The root component's message protocol. One flat enum — the `update()` match
+//! in `viewer.rs` is its dispatch table; handler bodies live in the sibling
+//! domain modules ([`super::panels`], [`super::settings`], [`super::filters`],
+//! [`super::snapshots`]).
+
+use futures::channel::oneshot::Sender;
+use perspective_client::config::Filter;
+use perspective_js::utils::ApiResult;
+use wasm_bindgen::JsValue;
+
+use crate::components::settings_panel::SelectedTab;
+use crate::config::*;
+use crate::presentation::{ColumnLocator, ColumnSettingsTab, DragDropProps, PresentationProps};
+use crate::renderer::RendererProps;
+use crate::session::{SessionProps, TableLoadState, ViewStats};
+use crate::utils::Completion;
+
+/// The filter-bearing payload of a master panel's selection or click event
+/// (`MasterContribution`), as decoded by the host listeners in
+/// [`super::wiring`].
+#[derive(Debug)]
+pub struct MasterSelection {
+    /// The event's filter clauses (`insertFilters` for the select-detail
+    /// family, `config.filter` for clicks) — BEFORE the master's own stored
+    /// filters are subtracted (see `on_master_contribution`).
+    pub filters: Vec<Filter>,
+
+    /// A synthesized clicked-cell `[column, "==", value]` clause, used when
+    /// `filters` derives to nothing — e.g. a FLAT (un-grouped) datagrid
+    /// master, whose clicks carry no group-by path to filter on.
+    pub cell_fallback: Option<Filter>,
+}
+
+#[derive(Debug)]
+pub enum PerspectiveViewerMsg {
+    ColumnSettingsPanelSizeUpdate(Option<i32>),
+    ColumnSettingsPanelAutoWidth(f64),
+    ToggleColumnSettingsPin,
+    ColumnSettingsTabChanged(ColumnSettingsTab),
+    OpenColumnSettings {
+        locator: Option<ColumnLocator>,
+        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.
+    Reset(bool, Option<Completion>),
+
+    /// Reset ONLY the named panel — or the active panel when `None` — to its
+    /// default `ViewerConfig` (the toolbar Reset button, the context menu's
+    /// "Reset" command, and the public `resetPanel()` API). The `bool` is
+    /// `Reset`'s expressions flag (toolbar shift-click); the `Completion`
+    /// resolves the `resetPanel()` promise after the reset's run completes
+    /// (invariant I6).
+    ResetPanel(Option<String>, bool, Option<Completion>),
+    Resize,
+
+    /// The set of layout panels changed (added/removed); re-render so the
+    /// layout host reconciles its `<regular-layout>` cells.
+    LayoutChanged,
+
+    /// Make the named panel active: re-target the settings panel + status bar
+    /// (and the root's session/renderer subscriptions) to its engines. The
+    /// `Completion` resolves `setActivePanel()` after the activation-chrome
+    /// nudge runs complete (invariant I6).
+    SetActivePanel(String, Option<Completion>),
+
+    /// The named panel's frame was closed (removed from the layout); remove it
+    /// from the workspace and dispose its engines. The `Completion` resolves
+    /// `removePanel()` after the eject's teardown run completes (invariant
+    /// I6) — carrying any teardown error, which was previously dropped.
+    ClosePanel(String, Option<Completion>),
+
+    /// Whole-element `restore` 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.
+    CommitWorkspaceRestore(String),
+
+    /// Duplicate the named panel: snapshot its config into a new independent
+    /// panel appended to the layout.
+    DuplicatePanel(String),
+
+    /// New panel: a fresh (default-config) panel bound to the named panel's
+    /// table (from the default client).
+    NewPanel(String),
+
+    /// New panel bound to the named `Table` on the named `Client` (the
+    /// context menu's "New" sub-menu). The `Client` is resolved by name from
+    /// the `Workspace` loaded-clients registry.
+    NewPanelFrom {
+        client: String,
+        table: String,
+    },
+
+    /// Toggle the named panel's master/detail (filter-source) role.
+    ToggleMaster(String),
+
+    /// A master panel's selection state, from EITHER host listener
+    /// (`perspective-global-filter` select/deselect or `perspective-click`):
+    /// `Some` REPLACES that panel's global-filter contribution, `None`
+    /// (deselect) clears it. Non-master sources are ignored by the handler.
+    MasterContribution(String, Option<MasterSelection>),
+
+    /// Remove the global filter at this index (GlobalFilterBar chip ×).
+    RemoveGlobalFilter(usize),
+
+    /// Clear all global filters (GlobalFilterBar "Clear").
+    ClearGlobalFilters,
+
+    /// Some panel's title changed (any panel, via `_title_subscriptions`);
+    /// re-render so the tab titles refresh.
+    TitlesChanged,
+    SettingsPanelSizeUpdate(Option<i32>),
+
+    /// The settings-pane divider proposed a new pane width (per pointermove,
+    /// from the *deferred* `SplitPanel` — it has NOT been applied). Feeds the
+    /// latest-wins presize pump (`PRESIZE_EVERYWHERE_PLAN.md` P1): geometry
+    /// commits only after every visible panel has rendered at its target.
+    SettingsDividerMove(i32),
+
+    /// Run one pump iteration: presize all visible panels at the newest
+    /// proposed pane width, then commit it.
+    SettingsDividerPump,
+
+    /// Presize for this pane width completed — commit it (the deferred
+    /// `SplitPanel`'s controlled `size`), then pump again if a newer target
+    /// arrived meanwhile.
+    SettingsDividerCommit(i32),
+
+    /// Divider drag ended: reactively finalize every visible panel at its
+    /// exact settled cell (debounced no-op when the presizes were exact).
+    SettingsDividerFinish,
+    SettingsPanelTabChanged(SelectedTab),
+    SettingsPanelAutoWidth(f64),
+    ToggleDebug,
+    ToggleSettingsComplete(SettingsUpdate, Sender<()>),
+    ToggleSettingsInit(Option<SettingsUpdate>, Option<Sender<ApiResult<JsValue>>>),
+    UpdateSession(Box<SessionProps>),
+    UpdateRenderer(Box<RendererProps>),
+    UpdatePresentation(Box<PresentationProps>),
+
+    /// Update only `is_settings_open` in the presentation snapshot without
+    /// touching `available_themes` (which requires async data).
+    UpdateSettingsOpen(bool),
+    UpdateIsWorkspace(bool),
+
+    /// Update only `open_column_settings` in the presentation snapshot.
+    UpdateColumnSettings(Box<crate::presentation::OpenColumnSettings>),
+    UpdateDragDrop(Box<DragDropProps>),
+
+    /// Update only stats-related fields of `session_props` without touching
+    /// `config`.  This prevents `stats_changed` events (e.g. from `reset()`)
+    /// from propagating a freshly-cleared config to the column selector.
+    UpdateSessionStats(Option<ViewStats>, Option<TableLoadState>),
+
+    /// Refresh the root's render snapshot of the `Workspace`-owned global
+    /// filter set (dispatched by its `filters_changed` PubSub).
+    UpdateGlobalFilters,
+
+    /// The active panel's in-flight config-run count changed. LEVEL-
+    /// triggered: the payload is the ABSOLUTE count (RAII-settled — see
+    /// `Session::begin_config_run`), which the handler ASSIGNS to
+    /// `update_count`; there is no delta arithmetic to drift. Threaded to
+    /// `StatusIndicator` as the "updating" spinner.
+    UpdateInFlight(u32),
+}

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

@@ -0,0 +1,326 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+//! Panel-lifecycle handlers: the [`Workspace`] panel set (add / duplicate /
+//! close) and active-panel targeting. INVARIANT: app-initiated layout changes
+//! mutate the `Workspace` FIRST, synchronously — `regular-layout` is
+//! reconciled as a downstream consequence of the re-render, never the source
+//! of truth (see `ClosePanel`).
+//!
+//! [`Workspace`]: crate::workspace::Workspace
+
+use perspective_js::utils::*;
+use yew::prelude::*;
+
+use super::PerspectiveViewer;
+use super::msg::PerspectiveViewerMsg::*;
+use super::wiring::{
+    clear_active_callbacks, create_active_subscriptions, inject_active_callbacks,
+    subscribe_panel_titles,
+};
+use crate::config::{TableUpdate, ViewerConfigUpdate};
+use crate::queries::*;
+use crate::renderer::Renderer;
+use crate::session::*;
+use crate::tasks::*;
+use crate::utils::{Completion, spawn_owned};
+use crate::workspace::PanelId;
+
+impl PerspectiveViewer {
+    pub(super) fn on_layout_changed(&mut self, ctx: &Context<Self>) -> bool {
+        self._title_subscriptions = subscribe_panel_titles(ctx);
+        self.resync_active(ctx);
+        true
+    }
+
+    /// Level-triggered binding sync: re-point the root's engine bindings at
+    /// the model's *current* active panel (or the detached empty engines at
+    /// zero panels) when they differ, by `Rc` identity. Catches model-side
+    /// activations that never dispatch `SetActivePanel`.
+    fn resync_active(&mut self, ctx: &Context<Self>) -> bool {
+        let session = ctx
+            .props()
+            .workspace
+            .active_session()
+            .unwrap_or_else(|| self.empty_session.clone());
+        let renderer = ctx
+            .props()
+            .workspace
+            .active_renderer()
+            .unwrap_or_else(|| self.empty_renderer.clone());
+
+        if session == self.active_session && renderer == self.active_renderer {
+            false
+        } else {
+            self.retarget_active(ctx, session, renderer);
+            true
+        }
+    }
+
+    pub(super) fn on_set_active_panel(
+        &mut self,
+        ctx: &Context<Self>,
+        id: String,
+        completion: Option<Completion>,
+    ) -> bool {
+        let id = PanelId::from(id);
+        let prev = ctx.props().workspace.active_id();
+        if prev.as_ref() == Some(&id) || !ctx.props().workspace.set_active(id.clone()) {
+            let resynced = self.resync_active(ctx);
+            if let Some(completion) = completion {
+                completion.resolve_after(async { Ok(()) });
+            }
+
+            resynced
+        } else {
+            let new_session = ctx
+                .props()
+                .workspace
+                .active_session()
+                .unwrap_or_else(|| self.empty_session.clone());
+
+            let new_renderer = ctx
+                .props()
+                .workspace
+                .active_renderer()
+                .unwrap_or_else(|| self.empty_renderer.clone());
+
+            self.retarget_active(ctx, new_session, new_renderer);
+            let mut nudges = Vec::new();
+            for pid in prev.iter().chain(std::iter::once(&id)) {
+                if let Some(panel) = ctx.props().workspace.panel(pid)
+                    && panel.renderer.is_plugin_activated().unwrap_or(false)
+                {
+                    nudges.push(activation_render(
+                        panel.session.clone(),
+                        panel.renderer.clone(),
+                    ));
+                }
+            }
+
+            let run = async move {
+                futures::future::join_all(nudges)
+                    .await
+                    .into_iter()
+                    .collect::<ApiResult<Vec<_>>>()?;
+                Ok(())
+            };
+
+            match completion {
+                Some(completion) => completion.resolve_after(run),
+                None => spawn_owned("set-active-panel", run),
+            }
+
+            true
+        }
+    }
+
+    /// Whole-element `restore`'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
+    /// `rendered` pass applies the staged layout and mounts every cell in
+    /// this one commit.
+    pub(super) fn on_commit_workspace_restore(&mut self, ctx: &Context<Self>, id: String) -> bool {
+        self._title_subscriptions = subscribe_panel_titles(ctx);
+        self.on_set_active_panel(ctx, id, None);
+        true
+    }
+
+    pub(super) fn on_close_panel(
+        &mut self,
+        ctx: &Context<Self>,
+        id: String,
+        completion: Option<Completion>,
+    ) -> bool {
+        let id = PanelId::from(id);
+
+        let was_active = ctx.props().workspace.active_id().as_ref() == Some(&id);
+        let removed = ctx.props().workspace.remove_panel(&id);
+        if was_active {
+            if let Some(next) = ctx.props().workspace.panel_ids().first().cloned() {
+                ctx.props().workspace.set_active(next);
+            }
+
+            let new_session = ctx
+                .props()
+                .workspace
+                .active_session()
+                .unwrap_or_else(|| self.empty_session.clone());
+            let new_renderer = ctx
+                .props()
+                .workspace
+                .active_renderer()
+                .unwrap_or_else(|| self.empty_renderer.clone());
+            self.retarget_active(ctx, new_session, new_renderer);
+        }
+
+        let eject = removed.map(eject_panel);
+        match (eject, completion) {
+            (Some(eject), Some(completion)) => completion.resolve_after(eject),
+            (Some(eject), None) => spawn_owned("close-panel", eject),
+            (None, Some(completion)) => completion.resolve_after(async { Ok(()) }),
+            (None, None) => {},
+        }
+
+        apply_global_filters(&ctx.props().workspace);
+        self._title_subscriptions = subscribe_panel_titles(ctx);
+        true
+    }
+
+    pub(super) fn on_duplicate_panel(&mut self, ctx: &Context<Self>, id: String) -> bool {
+        if let Some(panel) = ctx.props().workspace.panel(&PanelId::from(id)) {
+            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 config = panel
+                    .renderer
+                    .clone()
+                    .with_lock(async {
+                        get_viewer_config(&panel.session, &panel.renderer, &presentation).await
+                    })
+                    .await?;
+
+                let update = ViewerConfigUpdate::decode(&config.encode()?)?;
+                let client = panel.session.get_client();
+                let new_id = create_panel(
+                    &elem,
+                    &presentation,
+                    &workspace,
+                    &notify,
+                    None,
+                    update,
+                    client,
+                )
+                .await?;
+
+                activate.emit(new_id.to_string());
+                Ok(())
+            });
+        }
+
+        false
+    }
+
+    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 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,
+                    &presentation,
+                    &workspace,
+                    &notify,
+                    None,
+                    update,
+                    client,
+                )
+                .await?;
+
+                activate.emit(new_id.to_string());
+                Ok(())
+            });
+        }
+        false
+    }
+
+    /// `NewPanelFrom` — the context menu's "New" sub-menu: a fresh
+    /// (default-config) panel bound to the named `Table` on the named
+    /// `Client`, resolved from the `Workspace` loaded-clients registry.
+    pub(super) fn on_new_panel_from(
+        &mut self,
+        ctx: &Context<Self>,
+        client_name: String,
+        table: String,
+    ) -> bool {
+        let Some(client) = ctx
+            .props()
+            .workspace
+            .clients()
+            .into_iter()
+            .find(|c| c.get_name() == client_name)
+        else {
+            tracing::warn!("No loaded `Client` named \"{client_name}\"");
+            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: TableUpdate::Update(table),
+                ..Default::default()
+            };
+
+            let new_id = create_panel(
+                &elem,
+                &presentation,
+                &workspace,
+                &notify,
+                None,
+                update,
+                Some(client),
+            )
+            .await?;
+
+            activate.emit(new_id.to_string());
+            Ok(())
+        });
+
+        false
+    }
+
+    /// Re-point the root's per-active engine wiring + snapshots from the
+    /// current active panel to a new one: clear the old panel's direct
+    /// callbacks, set up the new panel's callbacks + subscriptions, refresh
+    /// the snapshots, and reset the in-flight render counter (which tracked
+    /// the old panel).
+    fn retarget_active(&mut self, ctx: &Context<Self>, session: Session, renderer: Renderer) {
+        clear_active_callbacks(&self.active_session, &self.active_renderer);
+        inject_active_callbacks(ctx, &session, &renderer);
+        self._active_subscriptions = create_active_subscriptions(ctx, &session, &renderer);
+        self.session_props = session.to_props();
+        self.renderer_props = renderer.to_props(None);
+        self.update_count = session.in_flight_config_runs();
+        self.active_session = session;
+        self.active_renderer = renderer;
+        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)
+            {
+                presentation.set_theme_name(Some(&theme)).await?;
+            }
+
+            Ok(())
+        });
+    }
+}