@perspective-dev/viewer 5.2.0 → 5.3.1

package/src/rust/tasks/reset_all.rs

@@ -61,11 +61,11 @@ pub fn reset_all(
 
         presentation.reset_available_themes(None).await;
         if all {
-            // Clear this panel's own per-panel theme so it reverts to inheriting
-            // the (reset-to-default) host theme — `reset_theme` only resets the
-            // host, which an explicitly-themed panel would otherwise override.
-            renderer.set_theme(None);
+            // Put this panel back on the registry default CONCRETELY —
+            // `reset_theme` only resets the host, which an explicitly-themed
+            // panel would otherwise keep overriding.
             presentation.reset_theme().await?;
+            renderer.set_theme(presentation.get_default_theme_name().await);
         }
 
         // For `all = true`, route the bucket clears through `restore_and_render`'s

package/src/rust/tasks/restore_and_render.rs

@@ -18,6 +18,7 @@ use futures::Future;
 use perspective_client::clone;
 
 use super::pipeline::{RunOrigin, RunSpec, locked_run};
+use super::update_theme::seed_panel_theme;
 use crate::config::{OptionalUpdate, ViewerConfigUpdate};
 use crate::presentation::Presentation;
 use crate::renderer::Renderer;
@@ -70,11 +71,6 @@ pub fn restore_and_render(
             session.set_title(None);
         }
 
-        // Mirror a config-carried theme onto the host attribute (the shared
-        // chrome). The restyle a theme change requires is owned by the
-        // MUTATION SITES (`restorePanel`'s own-theme tail, the theme-picker
-        // task), not here — this run's own draw below already stamps the new
-        // effective theme before the plugin's first style read.
         match theme_name {
             OptionalUpdate::SetDefault => {
                 let current_name = presentation.get_selected_theme_name().await;
@@ -83,59 +79,31 @@ pub fn restore_and_render(
                 }
             },
             OptionalUpdate::Update(x) => {
-                // No pre-resolution gate: `set_theme_name` stamps the host
-                // attribute SYNCHRONOUSLY before its registry await and
-                // no-ops on literal equality itself. The old
-                // `get_selected_theme_name().await` guard was precisely
-                // the former-theme window on a cold registry — the host
-                // held the old attribute until stylesheet parsing (and
-                // everything queued behind it) resolved.
                 presentation.set_theme_name(Some(&x)).await?;
             },
             _ => {},
         };
 
-        // Resolve the target plugin here (pure — needed now for
-        // `set_update_column_defaults`), but COMMIT it only inside the locked
-        // run below, atomically with the view rebind it belongs to. No swap
-        // intent may exist outside that run: an unrelated run that wins the
-        // lock first (e.g. a `table_updated` redraw) must observe either the
-        // fully-old or fully-new world, never a staged half of this one.
         let resolved_plugin = renderer.resolve_plugin_update(&plugin);
         if let Some((_, metadata)) = &resolved_plugin {
             session.set_update_column_defaults(&mut view_config, metadata);
         } else {
-            // Same-plugin (or plugin-less) restore: `resolve_plugin_update`
-            // returns `None`, but the plugin-advised `group_rollup_mode`
-            // must STILL be enforced against the active plugin's metadata —
-            // `restorePanel`'s table-change reset wipes the committed mode,
-            // and nothing else on this path would restore it, leaving a
-            // flat-only chart (Treemap / Sunburst) rendering rollup
-            // subtotal rows. Rollup only; the full column-defaults pass is
-            // reserved for plugin swaps, where `columns` genuinely needs
-            // re-defaulting.
-            session.set_update_rollup_defaults(&mut view_config, &renderer.metadata());
+            let metadata = if renderer.active_plugin().is_none() {
+                renderer
+                    .resolve_plugin_update(&OptionalUpdate::SetDefault)
+                    .map(|(_, metadata)| metadata)
+                    .unwrap_or_else(|| renderer.metadata())
+            } else {
+                renderer.metadata()
+            };
+
+            session.set_update_rollup_defaults(&mut view_config, &metadata);
         }
 
         let plugin_idx = resolved_plugin.map(|(idx, _)| idx);
-
-        // The config COMMIT: synchronous, validated, atomic (I1/I4). Under
-        // I2/I3 committing before the lock is safe — whichever queued run
-        // snapshots next picks it up, and this run's own snapshot (taken
-        // inside the lock below) can only be this commit or fresher.
         session.commit_view_config(view_config)?;
-
-        // Spinner accounting (RAII): held to the end of this restore —
-        // INCLUDING the deferred-draw exit (no table yet → no
-        // `bind_snapshot`), which under the old edge-counted scheme
-        // stranded the `StatusIndicator` spinner permanently.
         let _run_token = session.begin_config_run();
-
-        // Awaits theme-registry init, so the stamp below can never observe a
-        // pre-init (empty) theme set on a cold first load. Seeds this
-        // panel's renderer default-theme cache, which every locked draw
-        // stamps the effective theme from.
-        renderer.set_default_theme(presentation.get_default_theme_name().await);
+        seed_panel_theme(&presentation, &renderer).await;
         locked_run(&session, &renderer, RunSpec {
             origin,
             plugin_idx,
@@ -146,6 +114,11 @@ pub fn restore_and_render(
         })
         .await?;
 
+        if renderer.needs_restyle() {
+            renderer.restyle_all().await?;
+        }
+
+        presentation.publish_theme_config().await?;
         Ok(())
     })
 }

package/src/rust/tasks/restore_panel.rs

@@ -28,17 +28,13 @@ pub(crate) enum RestoreMode {
     Fresh,
 }
 
-/// Where a failed restore's error goes. `Publish` (every user-facing path)
-/// commits it to the session — the visible error UI and errored session
-/// state. `Suppress` (the agent's `set_view_config` tool) returns it ONLY
-/// to the caller: the model receives the error as a tool result and
-/// self-corrects, so the transient failure is noise to the human user —
-/// and the errored session state would otherwise BLOCK the corrected
-/// retry, since error recovery below requires a `table` field the model's
-/// patches don't carry.
+/// Where a failed restore's error goes.
 #[derive(Clone, Copy)]
 pub(crate) enum RestoreErrors {
+    // Raise errors in the UI.
     Publish,
+
+    // Report only in the API.
     Suppress,
 }
 
@@ -61,8 +57,8 @@ pub(crate) async fn bind_table_task(
 }
 
 /// Apply a [`ViewerConfigUpdate`] to a single panel and re-draw — the one
-/// pipeline shared by `restorePanel` (an existing panel), whole-element
-/// `restoreWorkspace`, and `addPanel` (both fresh panels).
+/// pipeline shared by `restorePanel` (an existing panel), `restoreWorkspace`,
+/// and `addPanel` (both fresh panels).
 pub(crate) async fn restore_panel(
     session: &Session,
     renderer: &Renderer,
@@ -76,7 +72,11 @@ pub(crate) async fn restore_panel(
     let fresh = matches!(mode, RestoreMode::Fresh);
     match &update.theme {
         OptionalUpdate::Update(theme) => renderer.set_theme_stamped(Some(theme.clone())),
-        OptionalUpdate::SetDefault => renderer.set_theme_stamped(None),
+        // `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)
+        },
         OptionalUpdate::Missing => {},
     }
 
@@ -154,8 +154,6 @@ pub(crate) async fn restore_panel(
 
     if fresh {
         renderer.resize().await.unwrap_or_log();
-    } else if renderer.needs_restyle() {
-        renderer.restyle_all().await?;
     }
 
     Ok(())

package/src/rust/tasks/set_edit_mode.rs

@@ -34,7 +34,9 @@ pub fn set_edit_mode(session: &Session, renderer: &Renderer, mode: &str) {
         serde_json::Value::String(mode.to_owned()),
     );
 
-    let changed = renderer.update_plugin_config(&view_config, OptionalUpdate::Update(map));
+    let changed = renderer
+        .update_plugin_config(&view_config, OptionalUpdate::Update(map))
+        .unwrap_or_default();
     clone!(session, renderer);
     ApiFuture::spawn(async move {
         if changed {

package/src/rust/tasks/sync_update_panels.rs

@@ -46,8 +46,11 @@ pub fn sync_update_panels(
         panels,
         global_filters,
         masters,
+        palette,
     } = update.into_serde_ext()?;
 
+    let palette = validate_palette(palette.unwrap_or_default())
+        .map_err(|e| ApiError::from(JsValue::from_str(&e)))?;
     let old_ids = this.workspace.panel_ids();
 
     // Phase 1 — models only, NO renders and NO draws
@@ -92,6 +95,8 @@ pub fn sync_update_panels(
         }
     }
 
+    this.presentation.set_palette(palette)?;
+
     // Phase 2 — stage the remapped layout tree on the Workspace
     if let Some(layout) = layout {
         this.workspace
@@ -113,13 +118,17 @@ pub fn sync_update_panels(
     }
 
     if let Some(app) = this.root.borrow().as_ref() {
+        // Silent (`announce: false`): each restored panel's own view-config
+        // commit dispatch announces the config, settings field included.
         app.send_message(PerspectiveViewerMsg::ToggleSettingsInit(
             Some(SettingsUpdate::Update(sidebar_open)),
+            false,
             None,
         ));
     }
 
     let masters = masters
+        .unwrap_or_default()
         .into_iter()
         .filter_map(|saved| match id_map.get(&saved) {
             Some(fresh) => Some(PanelId::from(fresh.as_str())),
@@ -131,6 +140,7 @@ pub fn sync_update_panels(
         .collect::<Vec<_>>();
 
     this.workspace.set_masters(masters);
-    this.workspace.set_global_filters(global_filters);
+    this.workspace
+        .set_global_filters(global_filters.unwrap_or_default());
     Ok((contents, eject_tasks))
 }

package/src/rust/tasks/update_theme.rs

@@ -19,20 +19,21 @@ use crate::presentation::Presentation;
 use crate::renderer::Renderer;
 use crate::workspace::Workspace;
 
-/// Re-seed every panel renderer's cached registry default theme from the
-/// (awaited, so initialized) theme registry, returning the default name.
-/// Every consumer of `Renderer::needs_restyle` after a registry-affecting
-/// change must run this first — a cold cache compares against `None`.
-pub(crate) async fn seed_default_themes(
-    presentation: &Presentation,
-    workspace: &Workspace,
-) -> Option<String> {
-    let default = presentation.get_default_theme_name().await;
-    for panel in workspace.panels() {
-        panel.renderer.set_default_theme(default.clone());
+/// Give `renderer` the concrete registry default IF it has none yet — the
+/// cold-boot case, where the panel was created before the registry first
+/// parsed and `active_theme_name_sync` had nothing to resolve. Only ever
+/// FILLS IN, never overwrites, so it cannot repaint a themed panel.
+pub(crate) async fn seed_panel_theme(presentation: &Presentation, renderer: &Renderer) {
+    if renderer.theme().is_none() {
+        renderer.set_theme(presentation.get_default_theme_name().await);
     }
+}
 
-    default
+/// [`seed_panel_theme`] for every panel.
+pub(crate) async fn seed_default_themes(presentation: &Presentation, workspace: &Workspace) {
+    for panel in workspace.panels() {
+        seed_panel_theme(presentation, &panel.renderer).await;
+    }
 }
 
 /// Apply a theme change and restyle the affected panel's view.
@@ -59,14 +60,17 @@ pub fn update_theme(
     workspace: &Workspace,
     theme: Option<String>,
 ) {
-    // Per-panel: record the theme on the (active) renderer so this panel keeps
-    // it independent of which panel is active. `set_theme_name` below mirrors
-    // the same value onto the host `theme` attribute (driving the chrome), and
-    // MainPanel inlines this renderer's theme on its frame only when it
-    renderer.set_theme_stamped(theme.clone());
+    // A NAMED theme needs no registry, so it stamps SYNCHRONOUSLY — no await
+    // separates the caller's config commit from the attribute the document
+    // cascade styles. Only "reset to default" has to await the registry, and
+    // it records the resolved NAME, never an empty theme.
+    if let Some(name) = &theme {
+        renderer.set_theme_stamped(Some(name.clone()));
+    }
 
     let presentation = presentation.clone();
     let workspace = workspace.clone();
+    let renderer = renderer.clone();
     ApiFuture::spawn(async move {
         match theme {
             Some(name) => {
@@ -74,10 +78,10 @@ pub fn update_theme(
             },
             None => {
                 presentation.reset_theme().await?;
+                renderer.set_theme_stamped(presentation.get_default_theme_name().await);
             },
         }
 
-        seed_default_themes(&presentation, &workspace).await;
         let panels = workspace.panels();
         join_all(panels.iter().map(|panel| async move {
             if panel.renderer.needs_restyle() {
@@ -90,6 +94,7 @@ pub fn update_theme(
         .into_iter()
         .collect::<ApiResult<Vec<_>>>()?;
 
+        presentation.publish_theme_config().await?;
         Ok(())
     });
 }

package/src/rust/utils/css_vars.rs

@@ -0,0 +1,26 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+use web_sys::Element;
+
+/// The computed value of custom property `name` on `elem`, trimmed, or
+/// `None` when undefined/empty.
+pub fn read_custom_property(elem: &Element, name: &str) -> Option<String> {
+    let value = web_sys::window()?
+        .get_computed_style(elem)
+        .ok()??
+        .get_property_value(name)
+        .ok()?;
+
+    let value = value.trim();
+    (!value.is_empty()).then(|| value.to_owned())
+}

package/src/rust/utils/mod.rs

@@ -18,6 +18,7 @@
 
 mod browser;
 mod completion;
+mod css_vars;
 mod custom_element;
 mod datetime;
 mod debounce;
@@ -35,6 +36,7 @@ mod tests;
 
 pub use browser::*;
 pub use completion::*;
+pub use css_vars::*;
 pub use custom_element::*;
 pub use datetime::*;
 pub use debounce::*;

package/src/rust/utils/spawn.rs

@@ -23,7 +23,7 @@ use perspective_js::utils::*;
 /// (invariant I6); use this only at event-listener leaves where no caller
 /// exists.
 pub fn spawn_owned(tag: &'static str, fut: impl Future<Output = ApiResult<()>> + 'static) {
-    ApiFuture::spawn(async move {
+    ApiFuture::spawn_named(tag, async move {
         if let Err(e) = fut.await.ignore_view_delete() {
             tracing::error!("[{}] unhandled task error: {}", tag, e);
         }