@perspective-dev/viewer 5.5.1 → 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();
@@ -118,6 +119,7 @@ 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();
@@ -197,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(),
@@ -208,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();
@@ -286,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

@@ -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)
 }
@@ -223,7 +248,7 @@ pub(crate) fn place_reserved(
 /// 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, disposal: Disposal) -> ApiFuture<()> {
-    panel.session.mark_disposed(disposal);
+    panel.session.dispose(disposal);
     ApiFuture::new(async move {
         panel.renderer.dispose().await?;
         let was_errored = panel.session.is_errored();

package/src/rust/tasks/derive.rs

@@ -0,0 +1,312 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+//! Create a derived `Table` from a panel's view, and release a panel back to
+//! the `Table` its own derived one reads.
+
+use perspective_client::config::{ViewConfig, ViewConfigUpdate};
+use perspective_client::{Client, DeleteOptions, TableData, TableInitOptions};
+use perspective_js::utils::*;
+
+use crate::config::{DerivedTableConfig, OptionalUpdate, TableRef, ViewerConfigUpdate};
+use crate::derived::{DerivedSource, DerivedTable, suggest_name};
+use crate::presentation::Presentation;
+use crate::queries::fetch_hosted_tables;
+use crate::renderer::Renderer;
+use crate::session::{MissingTable, Session, probe_table};
+use crate::tasks::{RestoreErrors, RestoreMode, restore_panel};
+use crate::utils::PtrEqRc;
+use crate::workspace::Workspace;
+
+/// Whether this panel's `Client` can derive a `Table` from a `View`.
+pub fn can_derive(session: &Session) -> bool {
+    session
+        .metadata()
+        .get_features()
+        .is_some_and(|x| x.view_derivations)
+}
+
+/// Rewrite an inline derived-table definition in `update.table` to a concrete
+/// hosted name, rebinding to a structurally identical live derivation where
+/// one exists and building (or pending, per `missing`) the rest.
+pub async fn resolve_table_ref(
+    workspace: &Workspace,
+    update: &mut ViewerConfigUpdate,
+    missing: MissingTable,
+) -> ApiResult<()> {
+    if !matches!(&update.table, OptionalUpdate::Update(TableRef::Derived(_))) {
+        return Ok(());
+    }
+
+    let OptionalUpdate::Update(table_ref) =
+        std::mem::replace(&mut update.table, OptionalUpdate::Missing)
+    else {
+        return Ok(());
+    };
+
+    let mut levels = vec![];
+    let mut cursor = table_ref;
+    let base = loop {
+        match cursor {
+            TableRef::Name(name) => break name,
+            TableRef::Derived(config) => {
+                levels.push(config.view_config);
+                cursor = config.table;
+            },
+        }
+    };
+
+    let mut pending = workspace.derived_pending();
+    let mut taken = fetch_hosted_tables(workspace)
+        .await
+        .into_iter()
+        .flat_map(|(_, tables)| tables)
+        .collect::<std::collections::BTreeSet<_>>();
+
+    taken.extend(pending.keys().cloned());
+    let mut parent = base;
+    for view_config in levels.into_iter().rev() {
+        let config = DerivedTableConfig {
+            table: parent.clone(),
+            view_config,
+        };
+
+        if let Some(existing) = workspace.derived_find_structural(&config) {
+            parent = existing;
+            continue;
+        }
+
+        if let Some(existing) = pending.iter().find(|(_, x)| **x == config) {
+            parent = existing.0.clone();
+            continue;
+        }
+
+        let name = suggest_name(
+            &taken,
+            &PtrEqRc::new(config.view_config.clone()),
+            &Some(config.table.clone()),
+        );
+
+        taken.insert(name.clone());
+        let built = match workspace
+            .resolve_client_for_table(&config.table, None)
+            .await
+        {
+            Some(client) => {
+                build_derived(
+                    &client,
+                    workspace,
+                    &name,
+                    &config.table,
+                    &config.view_config,
+                )
+                .await?
+            },
+            None => false,
+        };
+
+        if !built {
+            if matches!(missing, MissingTable::Error) {
+                return Err(ApiError::new(format!("Unknown table \"{}\"", config.table)));
+            }
+
+            pending.insert(name.clone(), config);
+        }
+
+        parent = name;
+    }
+
+    workspace.set_derived_pending(pending);
+    update.table = OptionalUpdate::Update(TableRef::Name(parent));
+    Ok(())
+}
+
+/// Build a derived `Table` named `name` from `parent`'s `view_config`, and
+/// register it on `workspace`.
+pub async fn build_derived(
+    client: &Client,
+    workspace: &Workspace,
+    name: &str,
+    parent: &str,
+    view_config: &ViewConfig,
+) -> ApiResult<bool> {
+    let Some(parent_table) = probe_table(client, parent, MissingTable::Pend).await? else {
+        return Ok(false);
+    };
+
+    // An empty `columns` in a derived DEFINITION means "all columns" (the
+    // engine's absent-columns default), not a key-only view — `ViewConfig`'s
+    // serde default materializes `[]` for definitions that omit the key.
+    let mut update: ViewConfigUpdate = view_config.clone().into();
+    if update.columns.as_ref().is_none_or(|x| x.is_empty()) {
+        update.columns = None;
+    }
+
+    let view = parent_table.view(Some(update)).await?;
+    let derived = match client
+        .table(TableData::View(view.clone()), TableInitOptions {
+            name: Some(name.to_owned()),
+            ..TableInitOptions::default()
+        })
+        .await
+    {
+        Ok(derived) => derived,
+        Err(err) => {
+            view.delete().await?;
+            return Err(err.into());
+        },
+    };
+
+    workspace.register_derived(
+        name.to_owned(),
+        DerivedTable::new(
+            parent.to_owned(),
+            view_config.clone(),
+            DerivedSource::Restored(view),
+            derived,
+        ),
+    );
+
+    Ok(true)
+}
+
+/// Promote the panel's current `View` to a derived `Table` named `name`,
+/// consuming that `View` and rebinding the panel to the result.
+pub async fn create_derived(
+    session: &Session,
+    renderer: &Renderer,
+    presentation: &Presentation,
+    workspace: &Workspace,
+    name: String,
+) -> ApiResult<()> {
+    if !can_derive(session) {
+        return Err("This data source cannot derive a Table from a View".into());
+    }
+
+    let client = session.get_client().ok_or("`load()` has not been called")?;
+    let table = session.get_table().ok_or("`load()` has not been called")?;
+    let parent = table.get_name().to_owned();
+    let plugin = renderer.metadata().name.clone();
+    let sub = session
+        .take_view_sub()
+        .ok_or("Panel has no View to derive from")?;
+
+    let view_config = (*sub.get_view_config()).clone();
+    let derived = match client
+        .table(TableData::View(sub.get_view().clone()), TableInitOptions {
+            name: Some(name.clone()),
+            ..TableInitOptions::default()
+        })
+        .await
+    {
+        Ok(derived) => derived,
+        Err(err) => {
+            session.put_view_sub(sub);
+            return Err(err.into());
+        },
+    };
+
+    // The promoted `View` now feeds the derived `Table`, not this panel —
+    // silence its Session-bound stats/update channels, or every PARENT tick
+    // keeps writing the parent's stats over the panel's.
+    if let Err(err) = sub.quiesce().await {
+        session.put_view_sub(sub);
+        derived.delete(DeleteOptions::default()).await?;
+        return Err(err);
+    }
+
+    workspace.register_derived(
+        name.clone(),
+        DerivedTable::new(parent, view_config, DerivedSource::Panel(sub), derived),
+    );
+
+    let update = ViewerConfigUpdate {
+        table: OptionalUpdate::Update(name.clone().into()),
+        plugin: OptionalUpdate::Update(plugin),
+        ..ViewerConfigUpdate::default()
+    };
+
+    let restored = restore_panel(
+        session,
+        renderer,
+        presentation,
+        workspace,
+        RestoreMode::Existing { active: true },
+        update,
+        RestoreErrors::Publish,
+        MissingTable::Error,
+        None,
+    )
+    .await;
+
+    if restored.is_err()
+        && let Some(derived) = workspace.take_derived(&name)
+    {
+        derived.delete().await?;
+    }
+
+    restored
+}
+
+/// Rebind the panel to the `Table` its derived one reads, deleting that
+/// derivation when `delete` and nothing else consumes it.
+pub async fn release_derived(
+    session: &Session,
+    renderer: &Renderer,
+    presentation: &Presentation,
+    workspace: &Workspace,
+    delete: bool,
+) -> ApiResult<()> {
+    let table = session.get_table().ok_or("Panel has no table")?;
+    let name = table.get_name().to_owned();
+    let config = workspace
+        .derived_config(&name)
+        .ok_or("Panel is not bound to a derived table")?;
+
+    let update = ViewerConfigUpdate {
+        table: OptionalUpdate::Update(config.table.clone().into()),
+        view_config: config.view_config.into(),
+        ..ViewerConfigUpdate::default()
+    };
+
+    restore_panel(
+        session,
+        renderer,
+        presentation,
+        workspace,
+        RestoreMode::Existing { active: true },
+        update,
+        RestoreErrors::Publish,
+        MissingTable::Error,
+        None,
+    )
+    .await?;
+
+    if delete {
+        delete_derived(workspace, &name).await?;
+    }
+
+    Ok(())
+}
+
+/// Delete a derived `Table` that nothing consumes.
+pub async fn delete_derived(workspace: &Workspace, name: &str) -> ApiResult<()> {
+    let consumers = workspace.derived_consumers(name);
+    if consumers > 0 {
+        return Err(format!("`{name}` is still read by {consumers} panels or tables").into());
+    }
+
+    match workspace.take_derived(name) {
+        Some(derived) => derived.delete().await,
+        None => Err(format!("`{name}` is not a derived table").into()),
+    }
+}

package/src/rust/tasks/mod.rs

@@ -25,6 +25,7 @@ mod apply_global_filters;
 mod auto_pause;
 mod copy_export;
 mod create_panel;
+mod derive;
 mod dismiss_render_warning;
 mod edit_expression;
 mod edit_window;
@@ -33,13 +34,14 @@ mod pipeline;
 mod presize_panels;
 mod reset_all;
 mod resize_observer;
-mod restore_and_render;
+mod restore_derived;
 mod restore_panel;
 mod send_column_config;
 mod send_plugin_config;
 mod set_edit_mode;
 mod sync_update_panels;
 mod table_lifecycle;
+mod transactional_restore;
 mod update_theme;
 mod validate_expression;
 
@@ -57,6 +59,7 @@ 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::derive::*;
 pub use self::dismiss_render_warning::*;
 pub use self::edit_expression::*;
 pub use self::edit_window::*;
@@ -65,12 +68,13 @@ 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 use self::restore_derived::*;
 pub(crate) use self::restore_panel::*;
 pub use self::send_column_config::*;
 pub use self::send_plugin_config::*;
 pub use self::set_edit_mode::*;
 pub(crate) use self::sync_update_panels::*;
 pub(crate) use self::table_lifecycle::*;
+pub(crate) use self::transactional_restore::{commit_and_render_locked, prepare};
 pub use self::update_theme::*;
 pub use self::validate_expression::*;