@perspective-dev/viewer 4.4.1 → 4.5.1

package/src/rust/tasks/intersection_observer.rs

@@ -19,7 +19,6 @@ use crate::js::*;
 use crate::presentation::Presentation;
 use crate::renderer::*;
 use crate::session::Session;
-use crate::tasks::*;
 use crate::utils::*;
 use crate::*;
 
@@ -77,30 +76,18 @@ struct IntersectionObserverState {
     presentation: Presentation,
 }
 
-impl HasPresentation for IntersectionObserverState {
-    fn presentation(&self) -> &Presentation {
-        &self.presentation
-    }
-}
-
-impl HasRenderer for IntersectionObserverState {
-    fn renderer(&self) -> &Renderer {
-        &self.renderer
-    }
-}
-
-impl HasSession for IntersectionObserverState {
-    fn session(&self) -> &Session {
-        &self.session
-    }
-}
-
 impl IntersectionObserverState {
     async fn set_pause(self, intersect: bool) -> ApiResult<()> {
         if intersect {
             if self.session.set_pause(false) {
-                self.restore_and_render(ViewerConfigUpdate::default(), async move { Ok(()) })
-                    .await?;
+                super::restore_and_render(
+                    &self.session,
+                    &self.renderer,
+                    &self.presentation,
+                    ViewerConfigUpdate::default(),
+                    async move { Ok(()) },
+                )
+                .await?;
             }
         } else {
             self.session.set_pause(true);

package/src/rust/tasks/mod.rs

@@ -10,43 +10,41 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
-//! Async tasks and model traits for coordinating state between `Session`,
-//! `Renderer`, `Presentation`, and `DragDrop` singletons.
+//! State-mutating async business logic dispatched from user actions.
 //!
-//! Complex operations that span more than one state object are expressed as
-//! traits whose bounds name exactly the state objects they require (e.g.
-//! `UpdateAndRender: HasSession + HasRenderer`).  Blanket impls apply the
-//! trait to any struct that holds those fields and provides `Has*` accessors.
+//! Every function in this module ends in side effects on one or more of
+//! [`Session`], [`Renderer`], [`Presentation`] — applying a
+//! `ViewConfigUpdate`, drawing the active plugin, mutating expressions, etc.
+//! Read-only async derivations belong in [`crate::queries`].
+//!
+//! [`Session`]: crate::session::Session
+//! [`Renderer`]: crate::renderer::Renderer
+//! [`Presentation`]: crate::presentation::Presentation
 
-mod column_locator;
-mod columns_iter_set;
 mod copy_export;
+mod dismiss_render_warning;
 mod edit_expression;
 mod eject;
-mod export_app;
-mod export_method;
-mod get_viewer_config;
 mod intersection_observer;
-mod is_invalid_drop;
-mod plugin_column_styles;
+mod reset_all;
 mod resize_observer;
 mod restore_and_render;
+mod send_column_config;
 mod send_plugin_config;
-mod structural;
 mod update_and_render;
+mod update_theme;
+mod validate_expression;
 
-pub use self::column_locator::*;
-pub use self::columns_iter_set::*;
 pub use self::copy_export::*;
+pub use self::dismiss_render_warning::*;
 pub use self::edit_expression::*;
 pub use self::eject::*;
-pub use self::export_method::*;
-pub use self::get_viewer_config::*;
 pub use self::intersection_observer::*;
-pub use self::is_invalid_drop::is_invalid_columns_column;
-pub use self::plugin_column_styles::*;
+pub use self::reset_all::*;
 pub use self::resize_observer::*;
 pub use self::restore_and_render::*;
+pub use self::send_column_config::*;
 pub use self::send_plugin_config::*;
-pub use self::structural::*;
 pub use self::update_and_render::*;
+pub use self::update_theme::*;
+pub use self::validate_expression::*;

package/src/rust/tasks/reset_all.rs

@@ -0,0 +1,98 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+//! Cross-engine reset orchestration: reset session config, optionally clear
+//! presentation columns config / theme, then delegate to `restore_and_render`
+//! to switch back to the default plugin and redraw.
+
+use futures::channel::oneshot;
+use perspective_client::clone;
+use perspective_js::utils::ApiFuture;
+
+use super::restore_and_render;
+use crate::config::{
+    ColumnConfigUpdate, OptionalUpdate, PluginConfigUpdate, PluginUpdate, ViewerConfigUpdate,
+};
+use crate::presentation::Presentation;
+use crate::renderer::Renderer;
+use crate::session::{ResetOptions, Session};
+
+/// Reset the viewer's `ViewerConfig` to the default.
+///
+/// - `all = false`: clears the view config but preserves expressions and
+///   per-column style maps.
+/// - `all = true`: also clears expressions, per-column styles, and theme.
+///
+/// Optionally signals `sender` once the reset+redraw round-trip completes,
+/// then emits `renderer.reset_changed`.
+///
+/// Delegates plugin selection + draw to [`restore_and_render`], whose
+/// two-pass restore guarantees the default plugin sees materialized
+/// `columns_config` / `plugin_config` on its first draw — fixing a race
+/// where the raw post-reset bucket would reach the plugin before
+/// stats-dependent `include: true` defaults were resolved.
+pub fn reset_all(
+    session: &Session,
+    renderer: &Renderer,
+    presentation: &Presentation,
+    all: bool,
+    sender: Option<oneshot::Sender<()>>,
+) {
+    presentation.set_open_column_settings(None);
+    clone!(session, renderer, presentation);
+    ApiFuture::spawn(async move {
+        session
+            .reset(ResetOptions {
+                config: true,
+                expressions: all,
+                ..ResetOptions::default()
+            })
+            .await?;
+
+        presentation.reset_available_themes(None).await;
+        if all {
+            presentation.reset_theme().await?;
+        }
+
+        // For `all = true`, route the bucket clears through `restore_and_render`'s
+        // `update_*` paths as `SetDefault`. This guarantees the materialized
+        // restore fires even when the user is already on the default plugin
+        // (no plugin_swap signal), since `SetDefault` reports the bucket as
+        // `changed` when it was non-empty. The per-plugin bucket model means
+        // only the (post-swap) default plugin's bucket is cleared; other
+        // plugins' buckets persist with their per-plugin state.
+        let (columns_config, plugin_config) = if all {
+            (
+                ColumnConfigUpdate::SetDefault,
+                PluginConfigUpdate::SetDefault,
+            )
+        } else {
+            (OptionalUpdate::Missing, OptionalUpdate::Missing)
+        };
+
+        let update = ViewerConfigUpdate {
+            plugin: PluginUpdate::SetDefault,
+            plugin_config,
+            columns_config,
+            ..Default::default()
+        };
+
+        restore_and_render(&session, &renderer, &presentation, update, async { Ok(()) }).await?;
+
+        if let Some(sender) = sender {
+            sender.send(()).unwrap();
+        }
+
+        renderer.reset_changed.emit(());
+        Ok(())
+    })
+}

package/src/rust/tasks/resize_observer.rs

@@ -22,7 +22,6 @@ use crate::presentation::Presentation;
 use crate::renderer::*;
 use crate::root::Root;
 use crate::session::{Session, TableLoadState};
-use crate::tasks::*;
 use crate::utils::*;
 
 pub struct ResizeObserverHandle {
@@ -83,32 +82,6 @@ struct ResizeObserverState {
     on_resize: Callback<()>,
 }
 
-impl HasRenderer for ResizeObserverState {
-    fn renderer(&self) -> &Renderer {
-        &self.renderer
-    }
-}
-
-impl HasSession for ResizeObserverState {
-    fn session(&self) -> &Session {
-        &self.session
-    }
-}
-
-impl HasPresentation for ResizeObserverState {
-    fn presentation(&self) -> &'_ crate::presentation::Presentation {
-        &self.presentation
-    }
-}
-
-impl StateProvider for ResizeObserverState {
-    type State = ResizeObserverState;
-
-    fn clone_state(&self) -> Self::State {
-        self.clone()
-    }
-}
-
 impl ResizeObserverState {
     fn on_resize(&mut self, entries: &js_sys::Array) {
         let is_visible = self
@@ -124,16 +97,16 @@ impl ResizeObserverState {
             let content_height = content.height().floor() as i32;
             let resized = self.width != content_width || self.height != content_height;
             if resized && is_visible {
-                let state = self.clone_state();
+                let state = self.clone();
                 clone!(self.on_resize);
                 ApiFuture::spawn_throttled(async move {
                     let needs_render = state
-                        .renderer()
+                        .renderer
                         .clone()
                         .with_lock(async {
-                            Ok(!state.renderer().is_plugin_activated()?
+                            Ok(!state.renderer.is_plugin_activated()?
                                 && matches!(
-                                    state.session().has_table(),
+                                    state.session.has_table(),
                                     Some(TableLoadState::Loaded)
                                 ))
                         })
@@ -141,9 +114,14 @@ impl ResizeObserverState {
 
                     if needs_render {
                         state.presentation.reset_attached();
-                        state.update_and_render(Default::default())?.await?;
+                        super::update_and_render(
+                            &state.session,
+                            &state.renderer,
+                            Default::default(),
+                        )?
+                        .await?;
                     } else {
-                        state.renderer().resize().await?;
+                        state.renderer.resize().await?;
                     }
 
                     on_resize.emit(());

package/src/rust/tasks/restore_and_render.rs

@@ -10,110 +10,148 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
+//! Apply a full [`ViewerConfigUpdate`] (settings, theme, title, plugin,
+//! plugin_config, columns_config, view_config) and re-draw.
+
 use futures::Future;
+use perspective_client::clone;
 
-use super::structural::*;
 use crate::config::{OptionalUpdate, ViewerConfigUpdate};
-use crate::utils::*;
+use crate::presentation::Presentation;
+use crate::renderer::Renderer;
+use crate::session::Session;
 use crate::*;
 
-pub trait RestoreAndRender: HasRenderer + HasSession + HasPresentation {
-    /// Apply a `ViewConfigUpdate` to the current `View` and render.
-    fn restore_and_render(
-        &self,
-        ViewerConfigUpdate {
-            plugin,
-            plugin_config,
-            columns_config,
-            settings,
-            theme: theme_name,
-            title,
-            mut view_config,
-            ..
-        }: crate::config::ViewerConfigUpdate,
-        task: impl Future<Output = Result<(), ApiError>> + 'static,
-    ) -> ApiFuture<()> {
-        clone!(self.session(), self.renderer(), self.presentation());
-        ApiFuture::new(async move {
-            if let OptionalUpdate::Update(x) = settings {
-                presentation.set_settings_attribute(x);
-                presentation.set_settings_before_open(x);
-            }
+/// Apply a full [`ViewerConfigUpdate`] (theme, title, plugin selection,
+/// plugin config, columns config, view config) to the engines and re-draw.
+/// Returns an [`ApiFuture<()>`] which resolves when the draw completes.
+pub fn restore_and_render(
+    session: &Session,
+    renderer: &Renderer,
+    presentation: &Presentation,
+    ViewerConfigUpdate {
+        plugin,
+        plugin_config,
+        columns_config,
+        settings,
+        theme: theme_name,
+        title,
+        mut view_config,
+        ..
+    }: ViewerConfigUpdate,
+    task: impl Future<Output = Result<(), ApiError>> + 'static,
+) -> ApiFuture<()> {
+    clone!(session, renderer, presentation);
+    ApiFuture::new(async move {
+        if let OptionalUpdate::Update(x) = settings {
+            presentation.set_settings_attribute(x);
+            presentation.set_settings_before_open(x);
+        }
 
-            if let OptionalUpdate::Update(title) = title {
-                session.set_title(Some(title));
-            } else if matches!(title, OptionalUpdate::SetDefault) {
-                session.set_title(None);
-            }
+        if let OptionalUpdate::Update(title) = title {
+            session.set_title(Some(title));
+        } else if matches!(title, OptionalUpdate::SetDefault) {
+            session.set_title(None);
+        }
+
+        let needs_restyle = match theme_name {
+            OptionalUpdate::SetDefault => {
+                let current_name = presentation.get_selected_theme_name().await;
+                if current_name.is_some() {
+                    presentation.set_theme_name(None).await?;
+                    true
+                } else {
+                    false
+                }
+            },
+            OptionalUpdate::Update(x) => {
+                let current_name = presentation.get_selected_theme_name().await;
+                if current_name.is_some() && current_name.as_ref().unwrap() != &x {
+                    presentation.set_theme_name(Some(&x)).await?;
+                    true
+                } else {
+                    false
+                }
+            },
+            _ => false,
+        };
+
+        if let Some(metadata) = renderer.get_next_plugin_metadata(&plugin) {
+            session.set_update_column_defaults(&mut view_config, &metadata);
+        }
+
+        session.update_view_config(view_config)?;
+        let draw_task = renderer.draw(async {
+            task.await?;
+            let plugin_swapped = renderer.apply_pending_plugin()?;
+            let plugin = renderer.get_active_plugin()?;
 
-            let needs_restyle = match theme_name {
-                OptionalUpdate::SetDefault => {
-                    let current_name = presentation.get_selected_theme_name().await;
-                    if current_name.is_some() {
-                        presentation.set_theme_name(None).await?;
-                        true
-                    } else {
-                        false
-                    }
-                },
-                OptionalUpdate::Update(x) => {
-                    let current_name = presentation.get_selected_theme_name().await;
-                    if current_name.is_some() && current_name.as_ref().unwrap() != &x {
-                        presentation.set_theme_name(Some(&x)).await?;
-                        true
-                    } else {
-                        false
-                    }
-                },
-                _ => false,
-            };
-
-            if let Some(metadata) = renderer.get_next_plugin_metadata(&plugin) {
-                session.set_update_column_defaults(&mut view_config, &metadata);
+            // The previous call which acquired the lock errored, so skip this render
+            if let Some(error) = session.get_error() {
+                return Err(error);
             }
 
-            session.update_view_config(view_config)?;
-            let draw_task = renderer.draw(async {
-                task.await?;
-                renderer.apply_pending_plugin()?;
-                let plugin = renderer.get_active_plugin()?;
-                let plugin_update = if let Some(x) = plugin_config {
-                    wasm_bindgen::JsValue::from_serde_ext(&*x).unwrap()
-                } else {
-                    plugin.save()?
-                };
+            // Validate + create the view BEFORE applying
+            // columns_config / plugin_config updates, so the
+            // strip-on-write and materialize passes see fresh
+            // `expression_schema` and `view_schema`, and the
+            // materialize warm step can call `View::get_min_max`
+            // against a view that knows about any new expression
+            // columns. Previously this happened after the strip,
+            // which silently dropped any `columns_config` entry
+            // keyed by a new expression column.
+            let view = session.validate().await?.create_view().await?;
 
-                presentation.update_columns_configs(columns_config);
-                let columns_config = presentation.all_columns_configs();
-                plugin.restore(&plugin_update, Some(&columns_config))?;
+            // Apply incoming updates into the now-active plugin's
+            // bucket on `Renderer`. Per-plugin storage means no
+            // schema filter is needed before restore — foreign keys
+            // cannot appear in the bucket by construction. The
+            // renderer methods also strip schema-default entries so
+            // restored maps containing default values produce an
+            // empty bucket (correct: bucket-empty ⇒ reads-default).
+            let view_config_snapshot = session.get_view_config().clone();
+            let plugin_config_changed =
+                renderer.update_plugin_config(&view_config_snapshot, plugin_config);
+            let columns_config_changed =
+                renderer.update_columns_configs(&view_config_snapshot, &session, columns_config);
+            let changed = plugin_config_changed || columns_config_changed;
 
-                // The previous call which acquired the lock errored, so skip this render
-                if let Some(error) = session.get_error() {
-                    return Err(error);
+            // Force a materialized restore when the plugin just
+            // swapped — `commit_plugin_idx` already restored from the
+            // raw bucket, but the materialized restore is needed for
+            // schema-revealed `include: true` defaults to reach the
+            // plugin before its first draw.
+            if changed || plugin_swapped {
+                let plugin_config_snapshot = renderer.get_plugin_config();
+                let plugin_update =
+                    wasm_bindgen::JsValue::from_serde_ext(&plugin_config_snapshot).unwrap();
+                let columns_config = renderer
+                    .all_columns_configs_materialized(&view_config_snapshot, &session)
+                    .await;
+                plugin.restore(&plugin_update, Some(&columns_config))?;
+                if plugin_config_changed {
+                    renderer.plugin_config_changed.emit(plugin_config_snapshot);
                 }
+            }
 
-                let view = session.validate().await?.create_view().await;
-                if !presentation.is_visible() {
-                    Ok(None)
-                } else {
-                    view
-                }
-            });
+            if !presentation.is_visible() {
+                Ok(None)
+            } else {
+                Ok(view)
+            }
+        });
 
-            draw_task.await?;
+        draw_task.await?;
 
-            // TODO this should be part of the API for `draw()` above, such that
-            // the plugin need not render twice when a theme is provided.
-            if needs_restyle
-                && presentation.is_visible()
-                && let Some(view) = session.get_view()
-            {
-                renderer.restyle_all(&view).await?;
-            }
+        // TODO this should be part of the API for `draw()` above, such that
+        // the plugin need not render twice when a theme is provided.
+        if needs_restyle
+            && presentation.is_visible()
+            && let Some(view) = session.get_view()
+        {
+            renderer.restyle_all(&view).await?;
+        }
 
-            Ok(())
-        })
-    }
+        Ok(())
+    })
 }
-
-impl<T: HasRenderer + HasSession + HasPresentation> RestoreAndRender for T {}

package/src/rust/tasks/{get_viewer_config.rs → send_column_config.rs}

@@ -10,41 +10,45 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
-use super::structural::*;
-use crate::config::*;
-use crate::*;
+use perspective_client::clone;
+use perspective_js::utils::*;
 
-/// A `ViewerConfig` is constructed from various properties acrosss the
-/// application state
+use crate::config::ColumnConfigFieldUpdate;
+use crate::renderer::Renderer;
+use crate::session::Session;
+
+/// Apply a [`ColumnConfigFieldUpdate`] from a column-style sidebar
+/// control to the active plugin's per-column config bucket on
+/// [`Renderer`], then re-`restore` the active plugin with the
+/// updated maps and trigger a render.
 ///
-/// For example, the current `Plugin`, `ViewConfig`, and `Theme`.
-/// `GetViewerConfigModel` provides methods which should be used to get the
-/// applications `ViewerConfig` from across these state objects.
-pub trait GetViewerConfigModel: HasSession + HasRenderer + HasPresentation {
-    /// Get the current [`ViewerConfig`]`
-    async fn get_viewer_config(&self) -> ApiResult<ViewerConfig> {
-        let version = config::API_VERSION.to_string();
-        let view_config = self.session().get_view_config().clone();
-        let js_plugin = self.renderer().get_active_plugin()?;
-        let settings = self.presentation().is_settings_open();
-        let plugin = js_plugin.name();
-        let plugin_config: serde_json::Value = js_plugin.save()?.into_serde_ext()?;
-        let theme = self.presentation().get_selected_theme_name().await;
-        let title = self.session().get_title();
-        let table = self.session().get_table().map(|x| x.get_name().to_owned());
-        let columns_config = self.presentation().all_columns_configs();
-        Ok(ViewerConfig {
-            version,
-            plugin,
-            title,
-            plugin_config,
-            columns_config,
-            settings,
-            table,
-            view_config,
-            theme,
-        })
-    }
-}
+/// Plugin-level (non-column) field updates go through
+/// [`super::send_plugin_config`] instead.
+pub fn send_column_config(
+    session: &Session,
+    renderer: &Renderer,
+    column_name: &str,
+    update: ColumnConfigFieldUpdate,
+) {
+    // Apply the renderer write synchronously so the StyleTab's
+    // revision-bump re-render path sees the new state immediately.
+    let view_config = session.get_view_config().clone();
+    renderer.update_columns_config_field(&view_config, session, column_name.to_string(), update);
 
-impl<T: HasRenderer + HasSession + HasPresentation> GetViewerConfigModel for T {}
+    clone!(session, renderer);
+    ApiFuture::spawn(async move {
+        let view_config_snapshot = session.get_view_config().clone();
+        let columns_configs = renderer
+            .all_columns_configs_materialized(&view_config_snapshot, &session)
+            .await;
+        let plugin_token =
+            wasm_bindgen::JsValue::from_serde_ext(&renderer.get_plugin_config()).unwrap();
+        renderer
+            .get_active_plugin()?
+            .restore(&plugin_token, Some(&columns_configs))?;
+
+        renderer.update(session.get_view()).await?;
+        renderer.column_style_changed.emit(columns_configs);
+        Ok(())
+    })
+}