@perspective-dev/viewer 4.5.1 → 5.0.0

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(())
+        });
+    }
+}

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

@@ -0,0 +1,243 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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 `view()`: composition of the settings pane, the
+//! column-settings drawer, and the multi-panel `MainPanel`.
+//!
+//! INVARIANT: the `SplitPanel` is ALWAYS rendered with `main_panel` as its
+//! last (flex-fill) pane — toggling the settings sidebar only adds/removes the
+//! leading pane, never reparents `main_panel` (a remount would tear down
+//! `<regular-layout>` + the plugin `<slot>`s).
+
+use yew::prelude::*;
+
+use super::PerspectiveViewer;
+use super::msg::PerspectiveViewerMsg::*;
+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::queries::*;
+use crate::session::TableLoadState;
+
+impl PerspectiveViewer {
+    pub(super) fn render(&self, ctx: &Context<Self>) -> Html {
+        // The settings panel + status bar bind to the *active* panel's engines;
+        // `presentation` is element-level (shared).
+        let presentation = &ctx.props().presentation;
+        let renderer = &self.active_renderer;
+        let session = &self.active_session;
+
+        let is_settings_open = self.settings_open
+            && matches!(self.session_props.has_table, Some(TableLoadState::Loaded));
+
+        let mut class = classes!();
+        if !is_settings_open {
+            class.push("settings-closed");
+        }
+
+        if self.session_props.title.is_some() {
+            class.push("titled");
+        }
+
+        let on_open_expr_panel = ctx.link().callback(|c| OpenColumnSettings {
+            locator: c,
+            sender: None,
+            toggle: true,
+        });
+
+        let on_column_settings_panel_resize = ctx
+            .link()
+            .callback(|(x, _)| ColumnSettingsPanelSizeUpdate(Some(x)));
+
+        let on_close_settings = ctx.link().callback(|()| ToggleSettingsInit(None, None));
+        let on_debug = ctx.link().callback(|_| ToggleDebug);
+        let selected_column = get_current_column_locator(
+            &self.presentation_props.open_column_settings,
+            renderer,
+            &self.session_props.config,
+            &self.session_props.metadata,
+        );
+
+        let selected_tab = self.presentation_props.open_column_settings.tab;
+        let plugin_name = self.renderer_props.plugin_name.clone();
+        let available_plugins = self.renderer_props.available_plugins.clone();
+        let has_table = self.session_props.has_table.clone();
+        let named_column_count = self.renderer_props.config.config_column_names.len();
+
+        let view_config = self.session_props.config.clone();
+        let drag_column = self.dragdrop_props.column.clone();
+        let metadata = self.session_props.metadata.clone();
+        let on_select_tab = ctx.link().callback(SettingsPanelTabChanged);
+        let on_auto_width = ctx.link().callback(SettingsPanelAutoWidth);
+        let settings_panel = if is_settings_open {
+            html! {
+                <SettingsPanel
+                    on_close={on_close_settings}
+                    on_resize={&self.on_resize}
+                    on_select_column={on_open_expr_panel}
+                    is_debug={self.debug_open}
+                    {on_debug}
+                    {plugin_name}
+                    {available_plugins}
+                    {has_table}
+                    {named_column_count}
+                    {view_config}
+                    plugin_config={self.renderer_props.plugin_config.clone()}
+                    {drag_column}
+                    metadata={metadata.clone()}
+                    open_column_settings={self.presentation_props.open_column_settings.clone()}
+                    selected_theme={self.presentation_props.selected_theme.clone()}
+                    selected_tab={self.settings_geometry.selected_tab}
+                    auto_width={self.settings_geometry.auto_width}
+                    on_dimensions_reset={&self.on_settings_panel_dimensions_reset}
+                    {on_select_tab}
+                    {on_auto_width}
+                    {presentation}
+                    {renderer}
+                    {session}
+                />
+            }
+        } else {
+            html! { <></> }
+        };
+
+        let on_settings = ctx.link().callback(|()| ToggleSettingsInit(None, None));
+        let on_select_tab = ctx.link().callback(ColumnSettingsTabChanged);
+        let column_settings_panel = html! {
+            if let Some(selected_column) = selected_column {
+                <SplitPanel
+                    id="modal_panel"
+                    reverse=true
+                    initial_size={self.settings_geometry.column_settings_width_override}
+                    on_reset={ctx.link().callback(|_| ColumnSettingsPanelSizeUpdate(None))}
+                    on_resize={on_column_settings_panel_resize}
+                >
+                    <ColumnSettingsPanel
+                        {selected_column}
+                        {selected_tab}
+                        on_close={self.on_close_column_settings.clone()}
+                        width_override={self.settings_geometry.column_settings_width_override}
+                        {on_select_tab}
+                        plugin_name={self.renderer_props.plugin_name.clone()}
+                        {metadata}
+                        view_config={self.session_props.config.clone()}
+                        column_stats={self.session_props.column_stats.clone()}
+                        selected_theme={self.presentation_props.selected_theme.clone()}
+                        {presentation}
+                        {renderer}
+                        {session}
+                    />
+                    <></>
+                </SplitPanel>
+            }
+        };
+
+        let on_reset = ctx.link().callback(|all| ResetPanel(None, all, None));
+        let main_panel = html! {
+            <MainPanel
+                {on_settings}
+                {on_reset}
+                on_activate_panel={ctx.link().callback(|id| SetActivePanel(id, None))}
+                on_close_panel={ctx.link().callback(|id| ClosePanel(id, None))}
+                on_panel_command={ctx.link().batch_callback(|(id, cmd): (String, PanelCommand)| {
+                    match cmd {
+                        PanelCommand::New => vec![NewPanel(id)],
+                        PanelCommand::NewFrom { client, table } => {
+                            vec![NewPanelFrom { client, table }]
+                        },
+                        PanelCommand::Duplicate => vec![DuplicatePanel(id)],
+                        PanelCommand::Reset => vec![ResetPanel(Some(id), false, None)],
+                        PanelCommand::ToggleMaster => vec![ToggleMaster(id)],
+                        PanelCommand::Close => vec![ClosePanel(id, None)],
+                        PanelCommand::Maximize | PanelCommand::Restore => vec![],
+                    }
+                })}
+                session_props={self.session_props.clone()}
+                renderer_props={self.renderer_props.clone()}
+                presentation_props={self.presentation_props.clone()}
+                {is_settings_open}
+                update_count={self.update_count}
+                panel_ids={ctx.props().workspace.panel_ids()}
+                panel_titles={ctx.props()
+                    .workspace
+                    .panel_ids()
+                    .iter()
+                    .map(|id| {
+                        let title = ctx
+                            .props()
+                            .workspace
+                            .panel(id)
+                            .and_then(|p| p.session.get_title())
+                            .filter(|t| !t.is_empty());
+                        (id.as_str().to_owned(), title)
+                    })
+                    .collect::<Vec<_>>()}
+                panel_themes={ctx.props()
+                    .workspace
+                    .panel_ids()
+                    .iter()
+                    .map(|id| {
+                        (
+                            id.as_str().to_owned(),
+                            ctx.props().workspace.panel(id).and_then(|p| p.renderer.theme()),
+                        )
+                    })
+                    .collect::<Vec<_>>()}
+                panel_masters={ctx.props().workspace.masters()}
+                workspace={ctx.props().workspace.clone()}
+                global_filters={self.global_filters.clone()}
+                on_remove_global_filter={ctx.link().callback(RemoveGlobalFilter)}
+                on_clear_global_filters={ctx.link().callback(|_| ClearGlobalFilters)}
+                {presentation}
+                {renderer}
+                {session}
+            />
+        };
+
+        let is_single_panel = if ctx.props().workspace.placed_count() == 1 {
+            "only-child"
+        } else {
+            ""
+        };
+
+        html! {
+            <StyleProvider root={ctx.props().elem.clone()}>
+                <div id="component_container" class={is_single_panel}>
+                    <div id="layout_area">
+                        <SplitPanel
+                            id="app_panel"
+                            reverse=true
+                            skip_empty=true
+                            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)}
+                        >
+                            { settings_panel }
+                            <div id="main_column_container">
+                                { main_panel }
+                                { column_settings_panel }
+                            </div>
+                        </SplitPanel>
+                    </div>
+                </div>
+                <FontLoader ..self.fonts.clone() />
+            </StyleProvider>
+        }
+    }
+}