@perspective-dev/viewer 5.5.0 → 5.6.0

package/src/rust/tasks/restore_panel.rs

@@ -10,15 +10,18 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
+use std::rc::Rc;
+
 use perspective_client::clone;
 use perspective_client::utils::PerspectiveResultExt;
 
 use crate::config::*;
 use crate::presentation::Presentation;
 use crate::renderer::Renderer;
-use crate::session::{MissingTable, ResetOptions, Session, TableIntermediateState, probe_table};
+use crate::session::{BindPlan, MissingTable, OpCtx, OpKind, Session, probe_table};
+use crate::tasks::transactional_restore::{Outcome, commit_and_render, prepare};
 use crate::tasks::*;
-use crate::workspace::Workspace;
+use crate::workspace::{PanelId, Workspace};
 use crate::*;
 
 /// How a [`restore_panel`] call reached the pipeline — the only two genuine
@@ -28,7 +31,7 @@ pub(crate) enum RestoreMode {
     Fresh,
 }
 
-/// Where a failed restore's error goes.
+/// Where the error of a restore that COMMITTED and then failed to render goes.
 #[derive(Clone, Copy)]
 pub(crate) enum RestoreErrors {
     // Raise errors in the UI.
@@ -62,77 +65,67 @@ async fn probe(
     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<()> {
-    if session
-        .get_table()
-        .is_some_and(|t| t.get_name() == name.as_str())
-    {
-        return Ok(());
-    }
+/// What a restore naming `table` does to the panel's binding.
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub(crate) enum Rebind {
+    /// A caller's restore: a table that REPLACES what the panel showed (or
+    /// recovers an errored panel) starts from a default config.
+    Replace,
 
-    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(())
+    /// The table lifecycle completing a pending bind: the committed config is
+    /// the intent the bind exists to honor.
+    Complete,
 }
 
-/// Rebind a session to `name`, probing the incoming table before the
-/// outgoing binding is dropped and replaying the journal opened as
-/// `generation` over the incoming table's defaults.
-async fn rebind_table_task(
+/// Decide a restore's [`BindPlan`], probing the incoming table — without
+/// touching the session's own binding.
+#[allow(clippy::too_many_arguments)]
+async fn plan_binding(
+    ctx: &OpCtx,
     session: &Session,
     renderer: &Renderer,
     workspace: &Workspace,
-    name: String,
+    table: &TableUpdate,
+    fresh: bool,
+    rebind: Rebind,
     missing: MissingTable,
-    generation: u32,
-) -> ApiResult<()> {
-    let probed = probe(session, workspace, &name, missing).await;
-    let journal = session.take_pending_load(generation);
-    let (client, table) = probed?;
-    let Some(journal) = journal else {
-        return Ok(());
+) -> ApiResult<Option<BindPlan>> {
+    let OptionalUpdate::Update(table) = table else {
+        return Ok(Some(BindPlan::Keep));
     };
 
-    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?,
+    let name = table.name()?;
+    let same = session.get_table().is_some_and(|t| t.get_name() == name);
+
+    if same && !session.is_errored() && renderer.failure().is_none() {
+        return Ok(Some(BindPlan::Keep));
     }
 
-    session.commit_table_defaults();
-    for delta in journal {
-        session.commit_view_config(delta)?;
+    let (client, table) = probe(session, workspace, name, missing).await?;
+    if !fresh && ctx.is_superseded() {
+        return Ok(None);
     }
 
-    session.commit_table_defaults();
-    if session.get_table().is_none()
-        && let Some(plugin) = renderer.active_plugin()
+    if table.is_none()
+        && rebind == Rebind::Complete
+        && session.pending_table().as_deref() == Some(name)
     {
-        plugin.clear().await?;
+        return Ok(None);
     }
 
-    Ok(())
+    let reset = !fresh && rebind == Rebind::Replace;
+    Ok(Some(match table {
+        Some(table) => BindPlan::Bind {
+            client,
+            table: Box::new(table),
+            reset,
+        },
+        None => BindPlan::Pend {
+            client,
+            name: name.to_owned(),
+            reset,
+        },
+    }))
 }
 
 /// Apply a [`ViewerConfigUpdate`] to a single panel and re-draw — the one
@@ -145,111 +138,130 @@ pub(crate) async fn restore_panel(
     presentation: &Presentation,
     workspace: &Workspace,
     mode: RestoreMode,
+    update: ViewerConfigUpdate,
+    errors: RestoreErrors,
+    missing: MissingTable,
+    preamble: Option<futures::future::LocalBoxFuture<'static, ApiResult<()>>>,
+) -> ApiResult<()> {
+    let update = Rc::new(update);
+    let kind = OpKind::Restore {
+        update: (!matches!(mode, RestoreMode::Fresh)).then(|| update.clone()),
+    };
+
+    let ticket = session.submit(kind, {
+        clone!(session, renderer, presentation, workspace);
+        move |ctx| {
+            Box::pin(async move {
+                if let Some(preamble) = preamble {
+                    preamble.await?;
+                }
+
+                restore_panel_step(
+                    &ctx,
+                    &session,
+                    &renderer,
+                    &presentation,
+                    &workspace,
+                    mode,
+                    Rebind::Replace,
+                    RunOrigin::Public,
+                    Rc::unwrap_or_clone(update),
+                    errors,
+                    missing,
+                )
+                .await?;
+
+                Ok(None)
+            })
+        }
+    });
+
+    ticket.settle().await
+}
+
+/// The body of [`restore_panel`], to be called only from a running op's step.
+#[allow(clippy::too_many_arguments)]
+pub(crate) async fn restore_panel_step(
+    ctx: &OpCtx,
+    session: &Session,
+    renderer: &Renderer,
+    presentation: &Presentation,
+    workspace: &Workspace,
+    mode: RestoreMode,
+    rebind: Rebind,
+    origin: RunOrigin,
     mut update: ViewerConfigUpdate,
     errors: RestoreErrors,
     missing: MissingTable,
 ) -> ApiResult<()> {
     let active = matches!(mode, RestoreMode::Existing { active: true });
     let fresh = matches!(mode, RestoreMode::Fresh);
-    match &update.theme {
-        OptionalUpdate::Update(theme) => renderer.set_theme_stamped(Some(theme.clone())),
-        // `SetDefault` resolves to a CONCRETE registry default here, rather
-        // than clearing the panel's theme — nothing downstream re-resolves.
-        OptionalUpdate::SetDefault => {
-            renderer.set_theme_stamped(presentation.get_default_theme_name().await)
+
+    crate::tasks::resolve_table_ref(workspace, &mut update, missing).await?;
+
+    // A derived definition parked in the pending registry is a known-future
+    // table, never an unknown name — bind as PEND whatever the caller's
+    // missing-table mode.
+    let missing = match &update.table {
+        OptionalUpdate::Update(table)
+            if table
+                .name()
+                .is_ok_and(|name| workspace.is_derived_pending(name)) =>
+        {
+            MissingTable::Pend
         },
-        OptionalUpdate::Missing => {},
-    }
+        _ => missing,
+    };
 
-    if !active {
-        update.theme = OptionalUpdate::Missing;
-    }
+    renderer.check_plugin_update(&update.plugin)?;
+    let Some(plan) = plan_binding(
+        ctx,
+        session,
+        renderer,
+        workspace,
+        &update.table,
+        fresh,
+        rebind,
+        missing,
+    )
+    .await?
+    else {
+        return Ok(());
+    };
 
     if !fresh {
         tracing::info!("Restoring {update}");
     }
 
-    // NOTE: `update.settings` is deliberately NOT applied here. It is
-    // element-level chrome rather than panel state, so `restore()` — the
-    // only caller that can carry it — applies it before dispatching, and
-    // this pipeline stays per-panel. Applying it here reached only the
-    // `Existing { active: true }` mode, which is why a freshly created
-    // panel silently ignored it.
-
-    // Under `Suppress` the restore is TRANSACTIONAL, so snapshot the config
-    // it is about to overwrite — see the failure tail below for why.
-    let rollback =
-        matches!(errors, RestoreErrors::Suppress).then(|| session.get_view_config().clone());
-
-    let binding_before = (
-        session.get_table().map(|t| t.get_name().to_owned()),
-        session.pending_table(),
-    );
-
-    let generation = 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 overlay = renderer
+        .slot_name()
+        .map(|id| overlay_for(workspace, &PanelId::from(id)));
 
-    let result = restore_and_render(
+    let rebound = !matches!(plan, BindPlan::Keep);
+    let prepared = prepare(
         session,
         renderer,
         presentation,
-        RunOrigin::Public,
-        update.clone(),
-        {
-            clone!(session, renderer, update.table, workspace);
-            async move {
-                let OptionalUpdate::Update(name) = table else {
-                    return Ok(());
-                };
-
-                match generation {
-                    Some(generation) => {
-                        rebind_table_task(
-                            &session, &renderer, &workspace, name, missing, generation,
-                        )
-                        .await
-                    },
-                    None => bind_table_task(&session, &workspace, name, missing).await,
-                }
-            }
-        },
+        active,
+        plan,
+        overlay,
+        update,
     )
-    .await;
-
-    if let Some(generation) = generation {
-        session.take_pending_load(generation);
-    }
+    .await?;
+    let Outcome { committed, result } =
+        commit_and_render(session, renderer, presentation, origin, prepared).await;
 
-    if let Err(e) = &result {
-        match errors {
-            RestoreErrors::Publish => session.set_error(false, e.clone()).await?,
-            RestoreErrors::Suppress => {
-                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();
-                }
-            },
-        }
+    if let Err(e) = &result
+        && committed
+        && matches!(errors, RestoreErrors::Publish)
+    {
+        let _ = renderer.fail(e.clone());
     }
 
     result?;
+    if rebound {
+        workspace.bindings_changed().emit(());
+    }
 
     if fresh {
         renderer.resize().await.unwrap_or_log();

package/src/rust/tasks/send_column_config.rs

@@ -10,12 +10,13 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
+use futures::FutureExt;
 use perspective_client::clone;
 use perspective_js::utils::*;
 
 use crate::config::ColumnConfigFieldUpdate;
-use crate::renderer::Renderer;
-use crate::session::Session;
+use crate::renderer::{Renderer, StagedEdit};
+use crate::session::{EditDelta, OpKind, Session};
 
 /// Apply a [`ColumnConfigFieldUpdate`] from a column-style sidebar
 /// control to the active plugin's per-column config bucket on
@@ -30,31 +31,57 @@ pub fn send_column_config(
     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);
-
-    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
-            .ensure_plugin_selected()?
-            .restore(&plugin_token, Some(&columns_configs))?;
-
-        clone!(session);
-        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(())
-    })
+    let column = column_name.to_string();
+    let staged = renderer.stage(StagedEdit::ColumnField {
+        column: column.clone(),
+        update: update.clone(),
+    });
+
+    let kind = OpKind::Edit {
+        delta: EditDelta::Renderer,
+        swaps_plugin: false,
+    };
+
+    let ticket = session.submit(kind, {
+        clone!(session, renderer);
+        move |_ctx| {
+            Box::pin(async move {
+                let view_config = session.committed_view_config().clone();
+                renderer.update_columns_config_field(&view_config, &session, column, update);
+                drop(staged);
+                Ok(Some(
+                    async move {
+                        let view_config_snapshot = session.committed_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.committed_plugin_config(),
+                        )
+                        .unwrap();
+
+                        renderer
+                            .ensure_plugin_selected()?
+                            .restore(&plugin_token, Some(&columns_configs))?;
+
+                        clone!(session);
+                        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(())
+                    }
+                    .boxed_local(),
+                ))
+            })
+        }
+    });
+
+    ApiFuture::spawn(ticket.settle());
 }

package/src/rust/tasks/send_plugin_config.rs

@@ -10,12 +10,13 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
+use futures::FutureExt;
 use perspective_client::clone;
 use perspective_js::utils::*;
 
 use crate::config::ColumnConfigFieldUpdate;
-use crate::renderer::Renderer;
-use crate::session::Session;
+use crate::renderer::{Renderer, StagedEdit};
+use crate::session::{EditDelta, OpKind, Session};
 
 /// Apply a [`ColumnConfigFieldUpdate`] from the Plugin-settings tab to
 /// the active plugin's bucket on [`Renderer`], then re-`restore` the
@@ -28,27 +29,55 @@ use crate::session::Session;
 ///
 /// Column-style updates go through [`super::send_column_config`].
 pub fn send_plugin_config(session: &Session, renderer: &Renderer, update: ColumnConfigFieldUpdate) {
-    let view_config = session.get_view_config().clone();
-    let changed = renderer.update_plugin_config_field(&view_config, update);
-    clone!(session, renderer);
-    ApiFuture::spawn(async move {
-        if changed {
-            let plugin_config = renderer.get_plugin_config();
-            let plugin_token = wasm_bindgen::JsValue::from_serde_ext(&plugin_config).unwrap();
-            let view_config_snapshot = session.get_view_config().clone();
-            let columns_configs = renderer
-                .all_columns_configs_materialized(&view_config_snapshot, &session)
-                .await;
-            renderer
-                .ensure_plugin_selected()?
-                .restore(&plugin_token, Some(&columns_configs))?;
-            clone!(session);
-            renderer
-                .update_lazy(async move { Ok(session.get_view_with_dimensions()) })
-                .await?;
-            renderer.plugin_config_changed.emit(plugin_config);
+    let staged = renderer.stage(StagedEdit::PluginField(update.clone()));
+    let kind = OpKind::Edit {
+        delta: EditDelta::Renderer,
+        swaps_plugin: false,
+    };
+
+    let ticket = session.submit(kind, {
+        clone!(session, renderer);
+        move |_ctx| {
+            Box::pin(async move {
+                let view_config = session.committed_view_config().clone();
+                let changed = renderer.update_plugin_config_field(&view_config, update);
+                drop(staged);
+                Ok(Some(
+                    async move {
+                        if changed {
+                            deliver_plugin_config(&session, &renderer).await?;
+                        }
+
+                        Ok(())
+                    }
+                    .boxed_local(),
+                ))
+            })
         }
+    });
+
+    ApiFuture::spawn(ticket.settle());
+}
+
+/// Re-`restore` the active plugin with its committed buckets, repaint, and
+/// announce the plugin-level change.
+pub(super) async fn deliver_plugin_config(session: &Session, renderer: &Renderer) -> ApiResult<()> {
+    let plugin_config = renderer.committed_plugin_config();
+    let plugin_token = wasm_bindgen::JsValue::from_serde_ext(&plugin_config).unwrap();
+    let view_config_snapshot = session.committed_view_config().clone();
+    let columns_configs = renderer
+        .all_columns_configs_materialized(&view_config_snapshot, session)
+        .await;
+
+    renderer
+        .ensure_plugin_selected()?
+        .restore(&plugin_token, Some(&columns_configs))?;
+
+    clone!(session);
+    renderer
+        .update_lazy(async move { Ok(session.get_view_with_dimensions()) })
+        .await?;
 
-        Ok(())
-    })
+    renderer.plugin_config_changed.emit(plugin_config);
+    Ok(())
 }

package/src/rust/tasks/set_edit_mode.rs

@@ -10,12 +10,13 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
+use futures::FutureExt;
 use perspective_client::clone;
 use perspective_js::utils::*;
 
 use crate::config::*;
-use crate::renderer::Renderer;
-use crate::session::Session;
+use crate::renderer::{Renderer, StagedEdit};
+use crate::session::{EditDelta, OpKind, Session};
 
 /// Set the active plugin's `edit_mode`, persisting it in the [`Renderer`]'s
 /// plugin bucket and re-`restore`+rendering (the same merged-token path as
@@ -27,35 +28,42 @@ use crate::session::Session;
 /// (e.g. charts) schema-gate the key out in [`Renderer::update_plugin_config`],
 /// making this a no-op for them.
 pub fn set_edit_mode(session: &Session, renderer: &Renderer, mode: &str) {
-    let view_config = session.get_view_config().clone();
     let mut map = serde_json::Map::new();
     map.insert(
         "edit_mode".to_owned(),
         serde_json::Value::String(mode.to_owned()),
     );
 
-    let changed = renderer
-        .update_plugin_config(&view_config, OptionalUpdate::Update(map))
-        .unwrap_or_default();
-    clone!(session, renderer);
-    ApiFuture::spawn(async move {
-        if changed {
-            let plugin_config = renderer.get_plugin_config();
-            let plugin_token = wasm_bindgen::JsValue::from_serde_ext(&plugin_config).unwrap();
-            let view_config_snapshot = session.get_view_config().clone();
-            let columns_configs = renderer
-                .all_columns_configs_materialized(&view_config_snapshot, &session)
-                .await;
-            renderer
-                .ensure_plugin_selected()?
-                .restore(&plugin_token, Some(&columns_configs))?;
-            clone!(session);
-            renderer
-                .update_lazy(async move { Ok(session.get_view_with_dimensions()) })
-                .await?;
-            renderer.plugin_config_changed.emit(plugin_config);
+    let staged = renderer.stage(StagedEdit::PluginConfig(map.clone()));
+    let kind = OpKind::Edit {
+        delta: EditDelta::Renderer,
+        swaps_plugin: false,
+    };
+
+    let ticket = session.submit(kind, {
+        clone!(session, renderer);
+        move |_ctx| {
+            Box::pin(async move {
+                let view_config = session.committed_view_config().clone();
+                let changed = renderer
+                    .update_plugin_config(&view_config, OptionalUpdate::Update(map))
+                    .unwrap_or_default();
+
+                drop(staged);
+                Ok(Some(
+                    async move {
+                        if changed {
+                            super::send_plugin_config::deliver_plugin_config(&session, &renderer)
+                                .await?;
+                        }
+
+                        Ok(())
+                    }
+                    .boxed_local(),
+                ))
+            })
         }
+    });
 
-        Ok(())
-    })
+    ApiFuture::spawn(ticket.settle());
 }