@perspective-dev/viewer 5.2.0 → 5.3.0

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);
         }