@perspective-dev/viewer 5.5.1 → 5.6.0

package/src/rust/custom_elements/viewer.rs

@@ -19,7 +19,6 @@ use futures::channel::oneshot::channel;
 use futures::future::join_all;
 use js_sys::{Array, JsString};
 use perspective_client::config::ViewConfigUpdate;
-use perspective_client::utils::PerspectiveResultExt;
 use perspective_js::utils::global;
 use perspective_js::{JsViewConfig, JsViewWindow, Table, View, apierror};
 use wasm_bindgen::JsCast;
@@ -38,7 +37,7 @@ use crate::js::*;
 use crate::presentation::*;
 use crate::queries::*;
 use crate::root::Root;
-use crate::session::{Disposal, MissingTable, ResetOptions, TableLoadState};
+use crate::session::{BindPlan, Disposal, MissingTable, OpKind, ResetOptions, TableLoadState};
 use crate::tasks::*;
 use crate::utils::*;
 use crate::workspace::{Panel, PanelId, Workspace};
@@ -212,13 +211,13 @@ impl PerspectiveViewerElement {
             .panels()
             .into_iter()
             .filter(|panel| !fresh.contains(&panel.id))
-            .filter(|panel| stamp_global_overlay(&self.workspace, &panel.id, &panel.session))
             .collect::<Vec<_>>();
 
-        join_all(retained.iter().map(|panel| async move {
-            apply_and_render(&panel.session, &panel.renderer, ViewConfigUpdate::default())?.await?;
-            Ok(())
-        }))
+        join_all(
+            retained
+                .iter()
+                .map(|panel| broadcast_overlay(&self.workspace, panel)),
+        )
         .await
         .into_iter()
         .collect::<ApiResult<Vec<_>>>()?;
@@ -237,7 +236,8 @@ impl PerspectiveViewerElement {
 
     async fn workspace_config(this: Self, full_palette: bool) -> ApiResult<JsValue> {
         this.workspace.effects().settle().await;
-        let mut panels: std::collections::BTreeMap<String, PanelViewerConfig> = Default::default();
+        let mut panels: std::collections::BTreeMap<String, PanelViewerConfig<String, String>> =
+            Default::default();
         for id in &this.workspace.panel_ids() {
             let panel = this.workspace.panel(id).into_apierror()?;
             let config = panel
@@ -288,6 +288,7 @@ impl PerspectiveViewerElement {
             active,
             layout,
             panels,
+            derived_tables: this.workspace.derived_configs(),
             global_filters: this.workspace.global_filters(),
             masters: this
                 .workspace
@@ -492,41 +493,17 @@ impl PerspectiveViewerElement {
             .dyn_into::<js_sys::Promise>()
             .unwrap_or_else(|_| js_sys::Promise::resolve(&table));
 
-        // Resolve the target panel. On an EMPTY element (zero panels):
-        //  - a synchronously-detectable `Client` registers inertly with NO panel (the
-        //    common `load(client)` — no phantom panel is left behind);
-        //  - otherwise (a resolved `Table`, or a `Promise` whose type isn't yet known)
-        //    the first panel is RESERVED synchronously here — a full panel model held
-        //    in the workspace's reservation slot, NOT placed — so its ordering position
-        //    is fixed at the call site: a `restore()` fired right after an unawaited
-        //    `load()` CLAIMS the reservation (placing it) and targets THIS panel, not a
-        //    second one. The reservation is likewise placed when the payload proves to
-        //    be a `Table` (or the load fails, surfacing its error), and discarded —
-        //    only while still unclaimed — for an inert `Client` payload. Placement and
-        //    discard are both atomic slot transfers (`Workspace::claim_reserved` /
-        //    `Workspace::take_reserved`), so an inert payload disposing a panel a
-        //    racing `restore` claimed is unrepresentable.
-        // A pre-existing active panel is used as-is (a `Client` registers
-        // inertly against it, never clearing its table).
         let (panel, notify) = match self.workspace.active_panel() {
             Some(panel) => (panel, None),
             None => {
-                // Empty element — classify the payload synchronously where possible.
                 if let Ok(Some(client)) =
                     try_from_js_option::<perspective_js::Client>(table.clone())
                 {
-                    // A resolved `Client` registers SYNCHRONOUSLY (so an unawaited
-                    // `load(client)` is visible to a `restore()` fired right after,
-                    // which creates the first panel and federates against loaded
-                    // clients) and creates NO panel — inert.
                     self.workspace
                         .set_default_client(client.get_client().clone());
                     return Ok(ApiFuture::new(async { Ok(()) }));
                 }
 
-                // A resolved `Table` (or a `Promise` whose type isn't yet known)
-                // adopts the pending reservation (a second `load()` on a
-                // still-empty element), else reserves a fresh panel model.
                 let panel = self.workspace.reserved_panel().unwrap_or_else(|| {
                     create_panel_model(
                         &self.elem,
@@ -548,23 +525,28 @@ impl PerspectiveViewerElement {
 
         let session = panel.session;
         let renderer = panel.renderer;
-        let load = session.begin_pending_load();
         clone!(self.workspace, self.presentation);
-        Ok(ApiFuture::new_throttled(async move {
-            let _effect = effect;
-            enum Discard {
-                Unclaimed(Panel),
-                Evicted(Panel),
-            }
+        enum Discard {
+            Unclaimed(Panel),
+            Evicted(Panel),
+        }
 
-            renderer.set_throttle(None);
-            let _run_token = session.begin_config_run();
-            let result = {
-                clone!(session, renderer, workspace, notify, load);
-                renderer
+        let table_known = matches!(
+            try_from_js_option::<perspective_js::Table>(table.clone()),
+            Ok(Some(_))
+        );
+
+        let ticket = session.submit(OpKind::Load { table_known }, {
+            clone!(session, renderer);
+            move |load| {
+                Box::pin(async move {
+                    let _effect = effect;
+                    renderer.set_throttle(None);
+                    let result = {
+                        clone!(session, renderer, workspace, notify, load);
+                        renderer
                     .clone()
                     .render_task(|guard| async move {
-                        seed_panel_theme(&presentation, &renderer).await;
                         renderer.stamp_theme(None);
                         let jstable = JsFuture::from(promise)
                             .await
@@ -574,30 +556,17 @@ impl PerspectiveViewerElement {
                             try_from_js_option::<perspective_js::Table>(jstable.clone())
                         {
                             tracing::warn!("{}", DEPRECATED_TABLE_MESSAGE);
-                            let Some(journal) = load.claim() else {
+                            if load.is_superseded() {
                                 return Ok(None);
-                            };
+                            }
 
                             if let Some(notify) = &notify {
                                 place_reserved(&workspace, notify, true);
                             }
 
-                            let _plugin = renderer.ensure_plugin_selected()?;
-                            let _ = renderer.mount_active_plugin();
-                            session
-                                .reset(ResetOptions {
-                                    config: true,
-                                    expressions: true,
-                                    stats: true,
-                                    table: Some(session::TableIntermediateState::Reloaded),
-                                })
-                                .await
-                                .unwrap_or_log();
-
                             let client = table.get_client().await;
                             let inner_client = client.get_client().clone();
-                            session.set_client(inner_client.clone());
-                            workspace.set_default_client(inner_client);
+                            workspace.set_default_client(inner_client.clone());
                             let name = table.get_name().await;
                             tracing::debug!(
                                 "Loading {:.0} rows from `Table` {}",
@@ -605,21 +574,40 @@ impl PerspectiveViewerElement {
                                 name
                             );
 
-                            session.set_table(name).await?;
-                            for delta in journal {
-                                session.commit_view_config(delta)?;
-                            }
-
-                            session.commit_table_defaults();
-                            let (disposition, _pin) =
-                                crate::tasks::bind_snapshot(&guard, &session, &renderer).await?;
+                            let plan = match session::probe_table(
+                                &inner_client,
+                                &name,
+                                MissingTable::Pend,
+                            )
+                            .await?
+                            {
+                                Some(table) => BindPlan::Bind {
+                                    client: inner_client,
+                                    table: Box::new(table),
+                                    reset: true,
+                                },
+                                None => BindPlan::Pend {
+                                    client: inner_client,
+                                    name,
+                                    reset: true,
+                                },
+                            };
 
-                            crate::tasks::dispatch_bound(
-                                &guard,
+                            let prepared = crate::tasks::prepare(
+                                &session,
                                 &renderer,
-                                disposition,
+                                &presentation,
                                 false,
-                                crate::tasks::RunOrigin::Public,
+                                plan,
+                                renderer
+                                    .slot_name()
+                                    .map(|id| overlay_for(&workspace, &PanelId::from(id))),
+                                ViewerConfigUpdate::default(),
+                            )
+                            .await?;
+
+                            crate::tasks::commit_and_render_locked(
+                                guard, &session, &renderer, prepared,
                             )
                             .await?;
 
@@ -631,11 +619,8 @@ impl PerspectiveViewerElement {
                             // INERT: register the client only — never rebind or
                             // reset the active panel (its table is preserved).
                             // Panels bind their client lazily at table-resolution
-                            // time (`Workspace::resolve_client_for_table`). The
-                            // window is discarded (not replayed): a `Client`
-                            // performs no reset, and any racing `restore`'s
-                            // commits already applied live (`commit_view_config`).
-                            let owned_window = load.claim().is_some();
+                            // time (`Workspace::resolve_client_for_table`).
+                            let owned_window = !load.is_superseded();
                             let discard = if owned_window && notify.is_some() {
                                 match workspace.take_reserved() {
                                     Some(panel) => Some(Discard::Unclaimed(panel)),
@@ -671,34 +656,36 @@ impl PerspectiveViewerElement {
                             workspace.set_default_client(client.get_client().clone());
                             Ok(discard)
                         } else {
-                            load.close();
                             Err(ApiError::new("Invalid argument"))
                         }
                     })
                     .await
-            };
+                    };
 
-            match result {
-                Err(e) => {
-                    load.close();
-                    if let Some(notify) = &notify {
-                        place_reserved(&workspace, notify, true);
-                    }
+                    match result {
+                        Err(e) => {
+                            if let Some(notify) = &notify {
+                                place_reserved(&workspace, notify, true);
+                            }
 
-                    session.set_error(false, e.clone()).await?;
-                    Err(e)
-                },
-                Ok(Some(Discard::Unclaimed(panel))) => {
-                    eject_panel(panel, Disposal::Reject).await?;
-                    Ok(())
-                },
-                Ok(Some(Discard::Evicted(panel))) => {
-                    eject_panel(panel, Disposal::Resolve).await?;
-                    Err(ApiError::new(CREATE_REQUIRES_TABLE))
-                },
-                Ok(None) => Ok(()),
+                            session.set_error(false, e.clone()).await?;
+                            Err(e)
+                        },
+                        Ok(Some(Discard::Unclaimed(panel))) => {
+                            eject_panel(panel, Disposal::Reject).await?;
+                            Ok(None)
+                        },
+                        Ok(Some(Discard::Evicted(panel))) => {
+                            eject_panel(panel, Disposal::Resolve).await?;
+                            Err(ApiError::new(CREATE_REQUIRES_TABLE))
+                        },
+                        Ok(None) => Ok(None),
+                    }
+                })
             }
-        }))
+        });
+
+        Ok(ApiFuture::new_throttled(ticket.settle()))
     }
 
     /// Delete all internal [`View`]s and all associated state, rendering this
@@ -1006,6 +993,7 @@ impl PerspectiveViewerElement {
 
                 let mut fulfilled = false;
                 for panel in &panels {
+                    panel.session.settle_ops().await;
                     panel.renderer.clone().with_lock(async { Ok(()) }).await?;
                     panel.renderer.clone().with_lock(async { Ok(()) }).await?;
                     panel.session.settle_dispatches().await?;
@@ -1013,6 +1001,7 @@ impl PerspectiveViewerElement {
                         && presentation.is_visible()
                         && !panel.renderer.is_plugin_activated()?
                         && panel.session.get_error().is_none()
+                        && panel.renderer.failure().is_none()
                         && matches!(panel.session.has_table(), Some(TableLoadState::Loaded))
                     {
                         set_panel_paused(&panel.session, &panel.renderer, &presentation, true)
@@ -1064,11 +1053,9 @@ impl PerspectiveViewerElement {
     ///   either "json", "string" or "arraybuffer" format.
     /// - `options.panel` - The panel to target, or the active panel when
     ///   omitted.
-    /// - `options.suppress_errors` - when `true`, a failed restore only rejects
-    ///   the returned `Promise` and rolls the view config back, leaving the
-    ///   viewer's visible error state and any element-level state the call
-    ///   already applied (theme, title, plugin, a successful `table` change)
-    ///   untouched.
+    /// - `options.suppress_errors` - when `true`, a config that was applied and
+    ///   then failed to render only rejects the returned `Promise`, without
+    ///   raising the panel's visible error state.
     /// - `options.wait_for_table` - when `true`, a `table` no loaded client
     ///   hosts yet leaves the panel empty and pending until the table is
     ///   created, instead of the default error.
@@ -1120,6 +1107,7 @@ impl PerspectiveViewerElement {
                 Create(Box<ViewerConfigInitial>),
             }
 
+            crate::tasks::resolve_table_ref(&this.workspace, &mut update, missing).await?;
             let notify = this.layout_changed_notify();
             let target = match this.workspace.panel_or_active(id.as_ref()) {
                 // An existing (or the active) panel — update it in place.
@@ -1142,14 +1130,24 @@ impl PerspectiveViewerElement {
                 },
             };
 
-            if !matches!(settings, OptionalUpdate::Missing) {
-                let (sender, receiver) = channel::<ApiResult<JsValue>>();
-                this.root.borrow().as_ref().into_apierror()?.send_message(
-                    PerspectiveViewerMsg::ToggleSettingsInit(Some(settings), false, Some(sender)),
-                );
+            let settings_toggle: Option<futures::future::LocalBoxFuture<'static, ApiResult<()>>> =
+                (!matches!(settings, OptionalUpdate::Missing)).then(|| {
+                    let this = this.clone();
+                    Box::pin(async move {
+                        let (sender, receiver) = channel::<ApiResult<JsValue>>();
+                        this.root.borrow().as_ref().into_apierror()?.send_message(
+                            PerspectiveViewerMsg::ToggleSettingsInit(
+                                Some(settings),
+                                false,
+                                Some(sender),
+                            ),
+                        );
 
-                receiver.await.map_err(|_| ApiError::new("Cancelled"))??;
-            }
+                        receiver.await.map_err(|_| ApiError::new("Cancelled"))??;
+                        Ok(())
+                    })
+                        as futures::future::LocalBoxFuture<'static, ApiResult<()>>
+                });
 
             match target {
                 Target::Existing { panel, active } => {
@@ -1162,6 +1160,7 @@ impl PerspectiveViewerElement {
                         update,
                         errors,
                         missing,
+                        settings_toggle,
                     )
                     .await
                 },
@@ -1175,10 +1174,15 @@ impl PerspectiveViewerElement {
                         update,
                         errors,
                         missing,
+                        settings_toggle,
                     )
                     .await
                 },
                 Target::Create(config) => {
+                    if let Some(settings_toggle) = settings_toggle {
+                        settings_toggle.await?;
+                    }
+
                     create_panel(
                         &this.elem,
                         &this.presentation,
@@ -1234,7 +1238,22 @@ impl PerspectiveViewerElement {
             let _effect = effect;
             let RestoreWorkspaceOptions { wait_for_table } = parse_options(options)?;
             let missing = MissingTable::from_wait(wait_for_table);
-            let (contents, eject_tasks) = sync_update_panels(&this, update)?;
+            let (contents, eject_tasks, derived_tables) = sync_update_panels(&this, update)?;
+
+            // The outgoing panels' ejects must settle BEFORE the derived
+            // pass: a stale derivation is undeletable (and so cannot be
+            // redefined or pruned) while an ejecting panel still holds a
+            // `View` on it. Their errors are surfaced LAST, after the
+            // replacement set is in place.
+            let ejected = join_all(eject_tasks)
+                .await
+                .into_iter()
+                .collect::<ApiResult<Vec<_>>>();
+
+            if let Some(derived_tables) = derived_tables.clone() {
+                crate::tasks::apply_derived_tables(&this.workspace, derived_tables).await?;
+            }
+
             let fresh = contents
                 .iter()
                 .map(|(id, ..)| id.clone())
@@ -1242,9 +1261,9 @@ impl PerspectiveViewerElement {
             let results = join_all(contents.into_iter().map(|(id, session, renderer, config)| {
                 let presentation = this.presentation.clone();
                 let workspace = this.workspace.clone();
+                let notify = this.layout_changed_notify();
                 async move {
-                    stamp_global_overlay(&workspace, &id, &session);
-                    restore_panel(
+                    let result = restore_panel(
                         &session,
                         &renderer,
                         &presentation,
@@ -1253,8 +1272,15 @@ impl PerspectiveViewerElement {
                         config,
                         crate::tasks::RestoreErrors::Publish,
                         missing,
+                        None,
                     )
-                    .await?;
+                    .await;
+
+                    if discard_rejected(&workspace, &id, &session, &result).await? {
+                        notify.emit(());
+                    }
+
+                    result?;
                     if workspace.is_master(&id) {
                         set_edit_mode(&session, &renderer, "SELECT_ROW_TREE");
                     }
@@ -1266,11 +1292,12 @@ impl PerspectiveViewerElement {
 
             results.into_iter().collect::<ApiResult<Vec<_>>>()?;
             this.rerender_retained_overlays(&fresh).await?;
-            join_all(eject_tasks)
-                .await
-                .into_iter()
-                .collect::<ApiResult<Vec<_>>>()?;
+            if let Some(derived_tables) = derived_tables {
+                let keep = derived_tables.keys().cloned().collect();
+                crate::tasks::prune_derived(&this.workspace, &keep).await?;
+            }
 
+            ejected?;
             Ok(())
         });
 
@@ -1286,10 +1313,19 @@ impl PerspectiveViewerElement {
         };
 
         let reset_effect = self.workspace.effects().guard();
-        let reset_task = panel.session.reset(ResetOptions::default());
+        let reset = panel.session.submit(OpKind::Restore { update: None }, {
+            let session = panel.session.clone();
+            move |_ctx| {
+                Box::pin(async move {
+                    session.reset(ResetOptions::default()).await?;
+                    Ok(None)
+                })
+            }
+        });
+
         ApiFuture::spawn(async move {
             let _effect = reset_effect;
-            reset_task.await
+            reset.settle().await
         });
 
         let effect = self.workspace.effects().guard();
@@ -1342,7 +1378,9 @@ impl PerspectiveViewerElement {
                 })
                 .await?;
 
-            viewer_config.encode()
+            viewer_config
+                .map_table(|name| this.workspace.inline_table_ref(&name))
+                .encode()
         });
 
         js_sys::Promise::from(fut).unchecked_into()
@@ -1406,9 +1444,14 @@ impl PerspectiveViewerElement {
             };
 
             let panel = this.resolve_panel(name)?;
-            let blob =
-                export_method_to_blob(&panel.session, &panel.renderer, &this.presentation, method)
-                    .await?;
+            let blob = export_method_to_blob(
+                &panel.session,
+                &panel.renderer,
+                &this.presentation,
+                &this.workspace,
+                method,
+            )
+            .await?;
             let is_chart = panel.renderer.is_chart();
             download(
                 format!("untitled{}", method.as_filename(is_chart)).as_ref(),
@@ -1454,8 +1497,14 @@ impl PerspectiveViewerElement {
             };
 
             let panel = this.resolve_panel(name)?;
-            export_method_to_jsvalue(&panel.session, &panel.renderer, &this.presentation, method)
-                .await
+            export_method_to_jsvalue(
+                &panel.session,
+                &panel.renderer,
+                &this.presentation,
+                &this.workspace,
+                method,
+            )
+            .await
         })
     }
 
@@ -1493,8 +1542,13 @@ impl PerspectiveViewerElement {
             };
 
             let panel = this.resolve_panel(name)?;
-            let js_task =
-                export_method_to_blob(&panel.session, &panel.renderer, &this.presentation, method);
+            let js_task = export_method_to_blob(
+                &panel.session,
+                &panel.renderer,
+                &this.presentation,
+                &this.workspace,
+                method,
+            );
             copy_to_clipboard(js_task, MimeType::TextPlain).await
         })
     }
@@ -1510,7 +1564,9 @@ impl PerspectiveViewerElement {
     /// # Arguments
     ///
     /// - `reset_all` - If set, will clear expressions and column settings as
-    ///   well.
+    ///   well, and tear down the element's ENTIRE derived-table state: every
+    ///   panel bound to a derived `Table` is released to its root table, and
+    ///   every derivation (pending ones included) is deleted.
     /// - `options` - An optional `{panel?: string}`; the panel to reset, or
     ///   every panel when omitted.
     ///
@@ -1834,7 +1890,7 @@ impl PerspectiveViewerElement {
                 // alone must repaint nothing.
                 let stale = theme.as_ref().is_none_or(|x| !available.contains(x));
                 if (stale || theme == previous) && theme != active {
-                    panel.renderer.set_theme(active.clone());
+                    submit_theme(&panel.session, &panel.renderer, active.clone());
                     if panel.renderer.needs_restyle() {
                         panel.renderer.restyle_all().await?;
                     }