@perspective-dev/viewer 5.5.0 → 5.6.0

package/src/rust/tasks/apply_global_filters.rs

@@ -10,50 +10,64 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
-use perspective_client::config::ViewConfigUpdate;
+use std::rc::Rc;
 
-use super::apply_and_render;
-use crate::session::Session;
+use futures::FutureExt;
+use perspective_client::clone;
+use perspective_js::utils::ApiFuture;
+
+use super::pipeline::{RunCommit, render_run};
+use super::transactional_restore::{commit_edit, prepare_overlay};
+use crate::session::{OpKind, OverlayClause};
 use crate::utils::spawn_owned;
-use crate::workspace::{PanelId, Workspace};
+use crate::workspace::{Panel, PanelId, Workspace};
 
-/// Stamp `session`'s transient global-filter overlay from the
-/// [`Workspace`]'s current set — EMPTY for master (filter-source) panels,
-/// the full set for details. Master immunity is enforced here and only
-/// here. Returns whether the overlay changed.
-///
-/// Synchronous, so panel-creation paths can stamp BEFORE the panel's first
-/// locked bind — the initial render then picks the overlay up via its
-/// `ConfigSnapshot.effective`, with no second render and no unfiltered
-/// first paint.
-pub fn stamp_global_overlay(workspace: &Workspace, id: &PanelId, session: &Session) -> bool {
-    let filters = if workspace.is_master(id) {
+/// The element's global filter as broadcast to panel `id` — EMPTY for master
+/// (filter-source) panels, the full set for details.
+pub(crate) fn overlay_for(workspace: &Workspace, id: &PanelId) -> Rc<Vec<OverlayClause>> {
+    Rc::new(if workspace.is_master(id) {
         Vec::new()
     } else {
-        workspace.global_filters()
-    };
+        workspace.overlay()
+    })
+}
+
+/// Broadcast the [`Workspace`]'s current global filter to one panel, as an op
+/// on ITS queue: the overlay is panel state, committed with the description of
+/// the config it yields, like any other write.
+pub fn broadcast_overlay(workspace: &Workspace, panel: &Panel) -> ApiFuture<()> {
+    let overlay = overlay_for(workspace, &panel.id);
+    clone!(panel.session, panel.renderer);
+    let ticket = panel.session.submit(OpKind::Overlay, move |_ctx| {
+        Box::pin(async move {
+            if *session.committed_overlay() == *overlay {
+                return Ok(None);
+            }
+
+            let bound = session.get_table().is_some();
+            let prepared = prepare_overlay(&session, &renderer, overlay).await?;
+            let committed = commit_edit(&session, &renderer, prepared);
+            Ok(if bound {
+                Some(render_run(session, renderer, RunCommit::Done(committed)).boxed_local())
+            } else {
+                None
+            })
+        })
+    });
 
-    session.set_global_filter(filters)
+    ApiFuture::new(ticket.settle())
 }
 
-/// Re-stamp every panel's overlay and re-render those whose overlay CHANGED
-/// (details are usually non-active, so they need an explicit re-render
-/// rather than relying on a subscription; unchanged panels aren't touched
-/// at all).
+/// Broadcast the global filter to every panel; panels whose overlay is
+/// unchanged aren't touched at all.
 pub fn apply_global_filters(workspace: &Workspace) {
-    for pid in workspace.panel_ids() {
-        if let Some(panel) = workspace.panel(&pid)
-            && stamp_global_overlay(workspace, &pid, &panel.session)
-        {
-            let effect = workspace.effects().guard();
-            let session = panel.session.clone();
-            let renderer = panel.renderer.clone();
-            spawn_owned("apply-global-filters", async move {
-                let _effect = effect;
-                apply_and_render(&session, &renderer, ViewConfigUpdate::default())?.await?;
-                Ok(())
-            });
-        }
+    for panel in workspace.panels() {
+        let effect = workspace.effects().guard();
+        let task = broadcast_overlay(workspace, &panel);
+        spawn_owned("apply-global-filters", async move {
+            let _effect = effect;
+            task.await
+        });
     }
 }
 

package/src/rust/tasks/auto_pause.rs

@@ -18,11 +18,12 @@ use wasm_bindgen::JsCast;
 use wasm_bindgen::prelude::*;
 use web_sys::*;
 
+use super::transactional_restore::restore_in_place;
 use crate::config::ViewerConfigUpdate;
 use crate::js::*;
 use crate::presentation::Presentation;
 use crate::renderer::*;
-use crate::session::Session;
+use crate::session::{OpKind, Session};
 use crate::utils::*;
 use crate::workspace::Workspace;
 use crate::*;
@@ -148,19 +149,28 @@ pub(crate) async fn set_panel_paused(
 ) -> ApiResult<()> {
     if visible {
         if session.set_pause(false) {
-            let result = super::restore_and_render(
-                session,
-                renderer,
-                presentation,
-                super::RunOrigin::Internal,
-                ViewerConfigUpdate::default(),
-                async move { Ok(()) },
-            )
-            .await;
+            let ticket = session.submit(OpKind::Restore { update: None }, {
+                clone!(session, renderer, presentation);
+                move |_ctx| {
+                    Box::pin(async move {
+                        restore_in_place(
+                            &session,
+                            &renderer,
+                            &presentation,
+                            super::RunOrigin::Internal,
+                            ViewerConfigUpdate::default(),
+                        )
+                        .await?;
+
+                        Ok(None)
+                    })
+                }
+            });
+
+            let result = ticket.settle().await;
 
             if let Err(e) = result.ignore_view_delete() {
-                session.set_run_error(e.clone()).await?;
-                return Err(e);
+                return renderer.fail(e);
             }
         }
     } else {

package/src/rust/tasks/copy_export.rs

@@ -29,6 +29,7 @@ use crate::queries::{export_app, get_viewer_config};
 use crate::renderer::Renderer;
 use crate::session::Session;
 use crate::utils::*;
+use crate::workspace::Workspace;
 
 fn tag_name_to_package(plugin: &JsPerspectiveViewerPlugin) -> String {
     let tag_name = plugin.unchecked_ref::<web_sys::HtmlElement>().tag_name();
@@ -107,10 +108,18 @@ pub async fn txt_as_jsvalue(
 }
 
 /// Generate a result `Blob` for all types of [`ExportMethod`].
+/// The `window` (or a default one) with Arrow IPC body compression `codec`.
+fn compressed(window: Option<ViewWindow>, codec: &str) -> Option<ViewWindow> {
+    let mut window = window.unwrap_or_default();
+    window.compression = Some(codec.to_owned());
+    Some(window)
+}
+
 pub async fn export_method_to_blob(
     session: &Session,
     renderer: &Renderer,
     presentation: &Presentation,
+    workspace: &Workspace,
     method: ExportMethod,
 ) -> ApiResult<web_sys::Blob> {
     let viewport = renderer.get_selection();
@@ -152,6 +161,36 @@ pub async fn export_method_to_blob(
         ExportMethod::ArrowAll => crate::queries::arrow_as_jsvalue(session, true, None)
             .await?
             .as_blob(),
+        ExportMethod::ArrowLz4 => {
+            crate::queries::arrow_as_jsvalue(session, false, compressed(None, "lz4"))
+                .await?
+                .as_blob()
+        },
+        ExportMethod::ArrowLz4Selected => {
+            crate::queries::arrow_as_jsvalue(session, false, compressed(viewport, "lz4"))
+                .await?
+                .as_blob()
+        },
+        ExportMethod::ArrowLz4All => {
+            crate::queries::arrow_as_jsvalue(session, true, compressed(None, "lz4"))
+                .await?
+                .as_blob()
+        },
+        ExportMethod::ArrowZstd => {
+            crate::queries::arrow_as_jsvalue(session, false, compressed(None, "zstd"))
+                .await?
+                .as_blob()
+        },
+        ExportMethod::ArrowZstdSelected => {
+            crate::queries::arrow_as_jsvalue(session, false, compressed(viewport, "zstd"))
+                .await?
+                .as_blob()
+        },
+        ExportMethod::ArrowZstdAll => {
+            crate::queries::arrow_as_jsvalue(session, true, compressed(None, "zstd"))
+                .await?
+                .as_blob()
+        },
         ExportMethod::Html => html_as_jsvalue(session, renderer, presentation)
             .await?
             .as_blob(),
@@ -160,6 +199,7 @@ pub async fn export_method_to_blob(
         ExportMethod::JsonConfig => js_sys::JSON::stringify(
             &get_viewer_config(session, renderer, presentation)
                 .await?
+                .map_table(|name| workspace.inline_table_ref(&name))
                 .encode()?,
         )?
         .as_blob(),
@@ -171,6 +211,7 @@ pub async fn export_method_to_jsvalue(
     session: &Session,
     renderer: &Renderer,
     presentation: &Presentation,
+    workspace: &Workspace,
     method: ExportMethod,
 ) -> ApiResult<JsValue> {
     let viewport = renderer.get_selection();
@@ -212,6 +253,36 @@ pub async fn export_method_to_jsvalue(
         ExportMethod::ArrowAll => crate::queries::arrow_as_jsvalue(session, true, None)
             .await?
             .into(),
+        ExportMethod::ArrowLz4 => {
+            crate::queries::arrow_as_jsvalue(session, false, compressed(None, "lz4"))
+                .await?
+                .into()
+        },
+        ExportMethod::ArrowLz4Selected => {
+            crate::queries::arrow_as_jsvalue(session, false, compressed(viewport, "lz4"))
+                .await?
+                .into()
+        },
+        ExportMethod::ArrowLz4All => {
+            crate::queries::arrow_as_jsvalue(session, true, compressed(None, "lz4"))
+                .await?
+                .into()
+        },
+        ExportMethod::ArrowZstd => {
+            crate::queries::arrow_as_jsvalue(session, false, compressed(None, "zstd"))
+                .await?
+                .into()
+        },
+        ExportMethod::ArrowZstdSelected => {
+            crate::queries::arrow_as_jsvalue(session, false, compressed(viewport, "zstd"))
+                .await?
+                .into()
+        },
+        ExportMethod::ArrowZstdAll => {
+            crate::queries::arrow_as_jsvalue(session, true, compressed(None, "zstd"))
+                .await?
+                .into()
+        },
         ExportMethod::Html => html_as_jsvalue(session, renderer, presentation).await?,
         ExportMethod::Plugin if renderer.is_chart() => {
             png_as_jsvalue(session, renderer).await?.into()
@@ -219,6 +290,7 @@ pub async fn export_method_to_jsvalue(
         ExportMethod::Plugin => txt_as_jsvalue(session, renderer, viewport).await?.into(),
         ExportMethod::JsonConfig => get_viewer_config(session, renderer, presentation)
             .await?
+            .map_table(|name| workspace.inline_table_ref(&name))
             .encode()?,
     })
 }

package/src/rust/tasks/create_panel.rs

@@ -17,7 +17,7 @@ use crate::config::*;
 use crate::custom_events::wire_panel_events;
 use crate::presentation::*;
 use crate::renderer::*;
-use crate::session::{MissingTable, ResetOptions, Session};
+use crate::session::{Disposal, MissingTable, ResetOptions, Session};
 use crate::tasks::*;
 use crate::utils::*;
 use crate::workspace::{Panel, PanelId, PanelPhase, Workspace};
@@ -31,11 +31,18 @@ use crate::*;
 pub(crate) fn wire_panel_subs(
     elem: &HtmlElement,
     presentation: &Presentation,
+    workspace: &Workspace,
     session: &Session,
     renderer: &Renderer,
 ) -> Vec<Subscription> {
     let mut subs = vec![wire_panel_render_sub(session, renderer)];
-    subs.extend(wire_panel_events(elem, session, renderer, presentation));
+    subs.extend(wire_panel_events(
+        elem,
+        session,
+        renderer,
+        presentation,
+        workspace,
+    ));
     subs
 }
 
@@ -97,7 +104,6 @@ pub(crate) async fn create_panel(
         Placement::Staged,
     );
 
-    stamp_global_overlay(workspace, &id, &session);
     notify.emit(());
 
     ApiFuture::spawn({
@@ -123,12 +129,12 @@ pub(crate) async fn create_panel(
         update,
         crate::tasks::RestoreErrors::Publish,
         missing,
+        None,
     )
     .await;
 
-    // Promote on completion AND error — a failed restore's error state
-    // must become visible too.
-    if workspace.promote(&id) {
+    let discarded = discard_rejected(workspace, &id, &session, &result).await?;
+    if discarded || workspace.promote(&id) {
         notify.emit(());
     }
 
@@ -136,6 +142,26 @@ pub(crate) async fn create_panel(
     Ok(id)
 }
 
+/// Remove the panel a rejected CREATING restore was for.
+pub(crate) async fn discard_rejected(
+    workspace: &Workspace,
+    id: &PanelId,
+    session: &Session,
+    result: &ApiResult<()>,
+) -> ApiResult<bool> {
+    if result.is_ok() || session.get_table().is_some() || session.pending_table().is_some() {
+        return Ok(false);
+    }
+
+    match workspace.remove_panel(id) {
+        Some(panel) => {
+            eject_panel(panel, Disposal::Resolve).await?;
+            Ok(true)
+        },
+        None => Ok(false),
+    }
+}
+
 /// Where [`create_panel_model`] registers the new panel model.
 pub(crate) enum Placement {
     /// Into the placed panel set at [`PanelPhase::Placed`] — a live, visible
@@ -173,7 +199,7 @@ pub(crate) fn create_panel_model(
     let renderer = Renderer::new(elem);
     let id = id.unwrap_or_else(|| workspace.generate_id());
     renderer.set_slot_name(id.as_str());
-    let subs = wire_panel_subs(elem, presentation, &session, &renderer);
+    let subs = wire_panel_subs(elem, presentation, workspace, &session, &renderer);
     let panel = Panel::new(id.clone(), session.clone(), renderer.clone(), subs);
     match placement {
         Placement::Placed => workspace.insert_panel(panel, PanelPhase::Placed),
@@ -182,7 +208,7 @@ pub(crate) fn create_panel_model(
     }
 
     update.settings = OptionalUpdate::Missing;
-    renderer.set_theme(match &update.theme {
+    renderer.commit_theme(match &update.theme {
         OptionalUpdate::Update(theme) => Some(theme.clone()),
         _ => presentation.active_theme_name_sync(),
     });
@@ -213,7 +239,6 @@ pub(crate) fn place_reserved(
     has_table: bool,
 ) -> Option<Panel> {
     let panel = workspace.claim_reserved(has_table)?;
-    stamp_global_overlay(workspace, &panel.id, &panel.session);
     notify.emit(());
     Some(panel)
 }
@@ -222,19 +247,19 @@ pub(crate) fn place_reserved(
 /// renderer (slot-scoped plugin + light-DOM cleanup) and eject its table.
 /// Shared by the root's `ClosePanel` handler and `restoreWorkspace`'s
 /// batch replacement of the pre-existing panel set.
-pub(crate) fn eject_panel(panel: Panel) -> ApiFuture<()> {
-    let was_errored = panel.session.is_errored();
-    let dispose_task = panel.renderer.dispose();
-    let reset_task = panel.session.reset(ResetOptions {
-        config: true,
-        expressions: true,
-        table: Some(session::TableIntermediateState::Ejected),
-        ..ResetOptions::default()
-    });
-
+pub(crate) fn eject_panel(panel: Panel, disposal: Disposal) -> ApiFuture<()> {
+    panel.session.dispose(disposal);
     ApiFuture::new(async move {
-        dispose_task.await?;
-        match reset_task.await.ignore_view_delete() {
+        panel.renderer.dispose().await?;
+        let was_errored = panel.session.is_errored();
+        let reset = panel.session.reset(ResetOptions {
+            config: true,
+            expressions: true,
+            table: Some(session::TableIntermediateState::Ejected),
+            ..ResetOptions::default()
+        });
+
+        match reset.await.ignore_view_delete() {
             Err(_) if was_errored => Ok(()),
             Err(e) => Err(e),
             Ok(_) => Ok(()),