@perspective-dev/viewer 4.5.2 → 5.1.0

package/src/rust/tasks/edit_window.rs

@@ -0,0 +1,155 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+use perspective_client::clone;
+use perspective_client::config::{Filter, ViewConfigUpdate, WindowSpec};
+
+use super::apply_and_render;
+use crate::presentation::{ColumnLocator, ColumnSettingsTab, OpenColumnSettings, Presentation};
+use crate::renderer::Renderer;
+use crate::session::Session;
+use crate::*;
+
+fn reopen(presentation: &Presentation, name: String) {
+    presentation.set_open_column_settings(Some(OpenColumnSettings {
+        locator: Some(ColumnLocator::Window(name)),
+        tab: Some(ColumnSettingsTab::Window),
+    }));
+}
+
+/// Insert `spec` into the session's windows as `name` (replacing any spec
+/// under the same key) and re-render. After the render completes, opens the
+/// column-settings drawer on the new window column.
+pub fn save_window(
+    session: &Session,
+    renderer: &Renderer,
+    presentation: &Presentation,
+    name: String,
+    spec: WindowSpec,
+) -> ApiResult<()> {
+    let presentation = presentation.clone();
+    let task = {
+        let mut windows = session.get_view_config().windows.clone();
+        windows.insert(name.clone(), spec);
+        apply_and_render(session, renderer, ViewConfigUpdate {
+            windows: Some(windows),
+            ..Default::default()
+        })
+    }?;
+
+    ApiFuture::spawn(async move {
+        task.await?;
+        reopen(&presentation, name);
+        Ok(())
+    });
+
+    Ok(())
+}
+
+/// Replace the window at `old_name` with `spec` and re-render. A rename
+/// rewrites every config reference to the old name - `columns`, `group_by`,
+/// `split_by`, `sort`, `filter` and the `aggregates` key - so usage follows
+/// the column, as expression renames do.
+pub fn update_window(
+    session: &Session,
+    renderer: &Renderer,
+    presentation: &Presentation,
+    old_name: String,
+    new_name: String,
+    spec: WindowSpec,
+) {
+    clone!(session, renderer, presentation);
+    ApiFuture::spawn(async move {
+        let update = {
+            let config = session.get_view_config().clone();
+            let mut windows = config.windows.clone();
+            windows.remove(&old_name);
+            windows.insert(new_name.clone(), spec);
+
+            let rename = |col: &String| -> String {
+                if col == &old_name {
+                    new_name.clone()
+                } else {
+                    col.clone()
+                }
+            };
+
+            let mut update = ViewConfigUpdate {
+                windows: Some(windows),
+                ..Default::default()
+            };
+
+            if old_name != new_name {
+                update.columns = Some(
+                    config
+                        .columns
+                        .iter()
+                        .map(|col| col.as_ref().map(&rename))
+                        .collect(),
+                );
+                update.group_by = Some(config.group_by.iter().map(&rename).collect());
+                update.split_by = Some(config.split_by.iter().map(&rename).collect());
+                update.sort = Some(
+                    config
+                        .sort
+                        .iter()
+                        .map(|sort| {
+                            let mut sort = sort.clone();
+                            sort.0 = rename(&sort.0);
+                            sort
+                        })
+                        .collect(),
+                );
+                update.filter = Some(
+                    config
+                        .filter
+                        .iter()
+                        .map(|filter| {
+                            if filter.column() == old_name {
+                                Filter::new(new_name.as_str(), filter.op(), filter.term().clone())
+                            } else {
+                                filter.clone()
+                            }
+                        })
+                        .collect(),
+                );
+                update.aggregates = Some(
+                    config
+                        .aggregates
+                        .iter()
+                        .map(|(col, agg)| (rename(col), agg.clone()))
+                        .collect(),
+                );
+            }
+
+            update
+        };
+
+        apply_and_render(&session, &renderer, update)?.await?;
+        reopen(&presentation, new_name);
+        Ok(())
+    });
+}
+
+/// Remove the window named `name` from the session and re-render.
+pub fn delete_window(session: &Session, renderer: &Renderer, name: &str) -> ApiResult<()> {
+    let mut windows = session.get_view_config().windows.clone();
+    windows.remove(name);
+    let config = ViewConfigUpdate {
+        windows: Some(windows),
+        ..ViewConfigUpdate::default()
+    };
+
+    let task = apply_and_render(session, renderer, config)?;
+    ApiFuture::spawn(task);
+    Ok(())
+}

package/src/rust/tasks/eject.rs

@@ -10,35 +10,76 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
+use futures::future::join_all;
 use perspective_client::clone;
+use perspective_js::utils::{ApiError, ApiResult};
 use yew::Component;
 
 use crate::ApiFuture;
-use crate::renderer::Renderer;
 use crate::root::Root;
-use crate::session::{ResetOptions, Session, TableIntermediateState};
+use crate::session::{ResetOptions, TableIntermediateState};
+use crate::workspace::Workspace;
 
-/// Tear down the entire viewer: emit `table_unloaded`, lock the renderer
-/// while it's destroyed, drop the Yew root, and reset the session to its
-/// ejected state.
-pub fn delete_all<T: Component>(
-    session: &Session,
-    renderer: &Renderer,
-    root: &Root<T>,
-) -> ApiFuture<()> {
-    session.table_unloaded.emit(false);
-    clone!(session, renderer, root);
-    ApiFuture::new(renderer.clone().with_lock(async move {
-        renderer.delete()?;
-        root.borrow_mut().take().ok_or("Already deleted")?.destroy();
-        session
-            .reset(ResetOptions {
-                config: true,
-                expressions: true,
-                table: Some(TableIntermediateState::Ejected),
-                ..ResetOptions::default()
+/// Tear down the entire viewer: dispose EVERY panel's engines (emit
+/// `table_unloaded`, destroy the renderer under its own draw lock, eject the
+/// session), then drop the Yew root once. Fans out over all panels — not just
+/// the seed — so panels added via `addPanel` or a whole-element `restore` don't
+/// leak their `View`/`Table` + plugin when the element is deleted or ejected.
+pub fn delete_all<T: Component>(workspace: &Workspace, root: &Root<T>) -> ApiFuture<()> {
+    clone!(workspace, root);
+    ApiFuture::new(async move {
+        let panels = workspace
+            .take_reserved()
+            .into_iter()
+            .chain(
+                workspace
+                    .panel_ids()
+                    .into_iter()
+                    .filter_map(|id| workspace.panel(&id)),
+            )
+            .collect::<Vec<_>>();
+
+        // Each panel owns its own `Renderer`/draw lock, so dispose them
+        // concurrently. `renderer.delete()` must hold the draw lock (it runs
+        // `plugin.delete()` synchronously), hence the per-panel `with_lock`.
+        // BEST-EFFORT teardown: attempt EVERY panel and ALWAYS destroy the
+        // Yew root, then report the first error. Aborting on the first
+        // failed panel (the previous behavior) leaked the root and every
+        // remaining panel's `View`/plugin.
+        let results = join_all(panels.iter().map(|panel| {
+            clone!(panel.session, panel.renderer);
+            session.table_unloaded.emit(false);
+            let was_errored = session.is_errored();
+            renderer.clone().with_lock(async move {
+                renderer.delete()?;
+                let reset = session
+                    .reset(ResetOptions {
+                        config: true,
+                        expressions: true,
+                        table: Some(TableIntermediateState::Ejected),
+                        ..ResetOptions::default()
+                    })
+                    .await;
+
+                match reset {
+                    Err(_) if was_errored => Ok(()),
+                    other => other,
+                }
             })
-            .await?;
+        }))
+        .await;
+
+        // Drop the Yew root once, after every panel's teardown was
+        // attempted — UNCONDITIONALLY, before error propagation, so a failed
+        // panel can't leak it.
+        let root_result = root
+            .borrow_mut()
+            .take()
+            .ok_or_else(|| ApiError::from("Already deleted"))
+            .map(|x| x.destroy());
+
+        results.into_iter().collect::<ApiResult<Vec<_>>>()?;
+        root_result?;
         Ok(())
-    }))
+    })
 }

package/src/rust/tasks/mod.rs

@@ -21,30 +21,56 @@
 //! [`Renderer`]: crate::renderer::Renderer
 //! [`Presentation`]: crate::presentation::Presentation
 
+mod apply_global_filters;
+mod auto_pause;
 mod copy_export;
+mod create_panel;
 mod dismiss_render_warning;
 mod edit_expression;
+mod edit_window;
 mod eject;
-mod intersection_observer;
+mod pipeline;
+mod presize_panels;
 mod reset_all;
 mod resize_observer;
 mod restore_and_render;
+mod restore_panel;
 mod send_column_config;
 mod send_plugin_config;
-mod update_and_render;
+mod set_edit_mode;
+mod sync_update_panels;
+mod table_lifecycle;
 mod update_theme;
 mod validate_expression;
 
+/// How long staged work (a hidden first draw, a presize sweep) may withhold
+/// a layout transition before it is released anyway — the progressive-reveal
+/// fallback for slow (e.g. remote) tables.
+pub(crate) const STAGING_DEADLINE_MS: i32 = 500;
+
+/// Fallback panel chrome `(width, height)` px (margin + border + titlebar)
+/// when no frame is available to measure live (see
+/// [`presize_panels::plugin_chrome`]).
+pub(crate) const CHROME_FALLBACK: (f64, f64) = (8.0, 33.0);
+
+pub use self::apply_global_filters::*;
+pub use self::auto_pause::*;
 pub use self::copy_export::*;
+pub(crate) use self::create_panel::*;
 pub use self::dismiss_render_warning::*;
 pub use self::edit_expression::*;
+pub use self::edit_window::*;
 pub use self::eject::*;
-pub use self::intersection_observer::*;
+pub use self::pipeline::*;
+pub use self::presize_panels::*;
 pub use self::reset_all::*;
 pub use self::resize_observer::*;
 pub use self::restore_and_render::*;
+pub(crate) use self::restore_panel::*;
 pub use self::send_column_config::*;
 pub use self::send_plugin_config::*;
-pub use self::update_and_render::*;
+pub use self::set_edit_mode::*;
+pub(crate) use self::sync_update_panels::*;
+pub(crate) use self::table_lifecycle::*;
 pub use self::update_theme::*;
 pub use self::validate_expression::*;