@perspective-dev/viewer 5.4.0 → 5.5.1

package/src/rust/tasks/copy_export.rs

@@ -107,6 +107,13 @@ 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,
@@ -152,6 +159,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(),
@@ -212,6 +249,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()

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::{ResetOptions, Session};
+use crate::session::{Disposal, MissingTable, ResetOptions, Session};
 use crate::tasks::*;
 use crate::utils::*;
 use crate::workspace::{Panel, PanelId, PanelPhase, Workspace};
@@ -76,6 +76,7 @@ fn wire_panel_render_sub(session: &Session, renderer: &Renderer) -> Subscription
 /// one. `theme` is stripped (element-level, not per-panel) and `client` —
 /// or the element's default client when `None` — is bound so the config's
 /// `table` resolves against it.
+#[allow(clippy::too_many_arguments)]
 pub(crate) async fn create_panel(
     elem: &HtmlElement,
     presentation: &Presentation,
@@ -84,6 +85,7 @@ pub(crate) async fn create_panel(
     id: Option<PanelId>,
     config: ViewerConfigInitial,
     client: Option<perspective_client::Client>,
+    missing: MissingTable,
 ) -> ApiResult<PanelId> {
     let (id, session, renderer, update) = create_panel_model(
         elem,
@@ -120,6 +122,7 @@ pub(crate) async fn create_panel(
         RestoreMode::Fresh,
         update,
         crate::tasks::RestoreErrors::Publish,
+        missing,
     )
     .await;
 
@@ -219,19 +222,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.mark_disposed(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(()),

package/src/rust/tasks/pipeline.rs

@@ -22,7 +22,7 @@ use yew::prelude::*;
 use crate::config::{ColumnConfigUpdate, PluginConfigUpdate};
 use crate::presentation::Presentation;
 use crate::renderer::{RenderContext, Renderer};
-use crate::session::{BindDisposition, Session};
+use crate::session::{BindDisposition, Disposal, Session};
 use crate::utils::RenderGuard;
 
 /// Snapshot → validate → bind → cache + pin the [`RenderContext`]. The core
@@ -227,6 +227,13 @@ pub(crate) async fn locked_run(
     renderer
         .clone()
         .render_task(|guard| async move {
+            if let Some(disposal) = session.disposal() {
+                return match (disposal, spec.origin) {
+                    (Disposal::Reject, RunOrigin::Public) => Err(ApiError::new("Panel disposed")),
+                    _ => Ok(()),
+                };
+            }
+
             renderer.mount_active_plugin()?;
             if let Some(task) = spec.task {
                 task.await?;
@@ -251,6 +258,18 @@ pub(crate) async fn locked_run(
             let view_config_snapshot = session.get_view_config().clone();
             let plugin_config_changed =
                 renderer.update_plugin_config(&view_config_snapshot, spec.plugin_config)?;
+            let plugin_config_snapshot = renderer.get_plugin_config();
+            let plugin_update =
+                JsValue::from_serde_ext(&plugin_config_snapshot).unwrap_or(JsValue::NULL);
+
+            let plugin_restored = plugin_config_changed || plugin_swapped;
+            if plugin_restored {
+                let columns_config = renderer
+                    .all_columns_configs_materialized(&view_config_snapshot, &session)
+                    .await;
+                plugin.restore(&plugin_update, Some(&columns_config))?;
+            }
+
             let columns_config_changed = renderer.update_columns_configs(
                 &view_config_snapshot,
                 &session,
@@ -258,17 +277,16 @@ pub(crate) async fn locked_run(
             )?;
 
             let changed = plugin_config_changed || columns_config_changed;
-            if changed || plugin_swapped {
-                let plugin_config_snapshot = renderer.get_plugin_config();
-                let plugin_update =
-                    JsValue::from_serde_ext(&plugin_config_snapshot).unwrap_or(JsValue::NULL);
+            if columns_config_changed {
                 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);
-                }
+                renderer.columns_config_changed.emit(columns_config);
+            }
+
+            if plugin_config_changed {
+                renderer.plugin_config_changed.emit(plugin_config_snapshot);
             }
 
             if spec

package/src/rust/tasks/restore_panel.rs

@@ -16,7 +16,9 @@ use perspective_client::utils::PerspectiveResultExt;
 use crate::config::*;
 use crate::presentation::Presentation;
 use crate::renderer::Renderer;
-use crate::session::{ResetOptions, Session};
+use crate::session::{
+    LoadGuard, MissingTable, ResetOptions, Session, TableIntermediateState, probe_table,
+};
 use crate::tasks::*;
 use crate::workspace::Workspace;
 use crate::*;
@@ -38,27 +40,107 @@ pub(crate) enum RestoreErrors {
     Suppress,
 }
 
+/// The client to bind and the opened `Table`, or `None` when pending.
+type Probed = (
+    perspective_client::Client,
+    Option<perspective_client::Table>,
+);
+
+/// Resolve and probe the client hosting `name` without touching the
+/// session's own binding.
+async fn probe(
+    session: &Session,
+    workspace: &Workspace,
+    name: &str,
+    missing: MissingTable,
+) -> ApiResult<Probed> {
+    let current = session.get_client();
+    let resolved = workspace
+        .resolve_client_for_table(name, current.as_ref())
+        .await;
+
+    let client = resolved.or(current).into_apierror()?;
+    let table = probe_table(&client, name, missing).await?;
+    Ok((client, table))
+}
+
+/// Bind an unbound or same-named session to `name`.
 pub(crate) async fn bind_table_task(
     session: &Session,
     workspace: &Workspace,
     name: String,
+    missing: MissingTable,
 ) -> ApiResult<()> {
-    let current = session.get_client();
-    if let Some(client) = workspace
-        .resolve_client_for_table(&name, current.as_ref())
-        .await
+    if session
+        .get_table()
+        .is_some_and(|t| t.get_name() == name.as_str())
     {
-        session.set_client(client);
+        return Ok(());
+    }
+
+    let (client, table) = probe(session, workspace, &name, missing).await?;
+    session.set_client(client);
+    match table {
+        Some(table) => session.bind_table(table).await?,
+        None => session.pend_table(name).await?,
+    }
+
+    session.commit_table_defaults();
+    Ok(())
+}
+
+/// Rebind a session to `name`, probing the incoming table before the
+/// outgoing binding is dropped and replaying `load`'s journal over the
+/// incoming table's defaults.
+async fn rebind_table_task(
+    session: &Session,
+    renderer: &Renderer,
+    workspace: &Workspace,
+    name: String,
+    missing: MissingTable,
+    load: &LoadGuard,
+) -> ApiResult<()> {
+    let probed = probe(session, workspace, &name, missing).await;
+    let journal = load.claim();
+    let (client, table) = probed?;
+    let Some(journal) = journal else {
+        return Ok(());
+    };
+
+    session
+        .reset(ResetOptions {
+            config: true,
+            expressions: true,
+            stats: true,
+            table: Some(TableIntermediateState::Reloaded),
+        })
+        .await?;
+
+    session.set_client(client);
+    match table {
+        Some(table) => session.bind_table(table).await?,
+        None => session.pend_table(name).await?,
     }
 
-    session.set_table(name).await?;
     session.commit_table_defaults();
+    for delta in journal {
+        session.commit_view_config(delta)?;
+    }
+
+    session.commit_table_defaults();
+    if session.get_table().is_none()
+        && let Some(plugin) = renderer.active_plugin()
+    {
+        plugin.clear().await?;
+    }
+
     Ok(())
 }
 
 /// Apply a [`ViewerConfigUpdate`] to a single panel and re-draw — the one
 /// pipeline shared by `restorePanel` (an existing panel), `restoreWorkspace`,
 /// and `addPanel` (both fresh panels).
+#[allow(clippy::too_many_arguments)]
 pub(crate) async fn restore_panel(
     session: &Session,
     renderer: &Renderer,
@@ -67,6 +149,7 @@ pub(crate) async fn restore_panel(
     mode: RestoreMode,
     mut update: ViewerConfigUpdate,
     errors: RestoreErrors,
+    missing: MissingTable,
 ) -> ApiResult<()> {
     let active = matches!(mode, RestoreMode::Existing { active: true });
     let fresh = matches!(mode, RestoreMode::Fresh);
@@ -100,21 +183,24 @@ pub(crate) async fn restore_panel(
     let rollback =
         matches!(errors, RestoreErrors::Suppress).then(|| session.get_view_config().clone());
 
-    let table_changed = !fresh
-        && matches!(&update.table, OptionalUpdate::Update(name)
-            if session.get_table().map(|t| t.get_name() != name.as_str()).unwrap_or(true));
+    let binding_before = (
+        session.get_table().map(|t| t.get_name().to_owned()),
+        session.pending_table(),
+    );
 
-    let errored_recovery =
-        session.is_errored() && matches!(&update.table, OptionalUpdate::Update(_));
-
-    let reset = (table_changed || errored_recovery).then(|| {
-        session.reset(ResetOptions {
-            config: true,
-            expressions: true,
-            stats: true,
-            ..ResetOptions::default()
-        })
-    });
+    let load = match &update.table {
+        OptionalUpdate::Update(name)
+            if session.is_errored()
+                || (!fresh
+                    && session
+                        .get_table()
+                        .map(|t| t.get_name() != name.as_str())
+                        .unwrap_or(true)) =>
+        {
+            Some(session.begin_pending_load())
+        },
+        _ => None,
+    };
 
     let result = restore_and_render(
         session,
@@ -123,27 +209,40 @@ pub(crate) async fn restore_panel(
         RunOrigin::Public,
         update.clone(),
         {
-            clone!(session, update.table, workspace);
+            clone!(session, renderer, update.table, workspace, load);
             async move {
-                if let OptionalUpdate::Update(name) = table {
-                    if let Some(reset) = reset {
-                        reset.await?;
-                    }
+                let OptionalUpdate::Update(name) = table else {
+                    return Ok(());
+                };
 
-                    bind_table_task(&session, &workspace, name).await?;
+                match &load {
+                    Some(load) => {
+                        rebind_table_task(&session, &renderer, &workspace, name, missing, load)
+                            .await
+                    },
+                    None => bind_table_task(&session, &workspace, name, missing).await,
                 }
-
-                Ok(())
             }
         },
     )
     .await;
 
+    if let Some(load) = &load {
+        load.close();
+    }
+
     if let Err(e) = &result {
         match errors {
             RestoreErrors::Publish => session.set_error(false, e.clone()).await?,
             RestoreErrors::Suppress => {
-                if let Some(config) = rollback {
+                let binding_after = (
+                    session.get_table().map(|t| t.get_name().to_owned()),
+                    session.pending_table(),
+                );
+
+                if let Some(config) = rollback
+                    && binding_after == binding_before
+                {
                     session.commit_view_config(config.into()).unwrap_or_log();
                 }
             },

package/src/rust/tasks/send_column_config.rs

@@ -51,6 +51,9 @@ pub fn send_column_config(
         renderer
             .update_lazy(async move { Ok(session.get_view_with_dimensions()) })
             .await?;
+        renderer
+            .columns_config_changed
+            .emit(columns_configs.clone());
         renderer.column_style_changed.emit(columns_configs);
         Ok(())
     })