@perspective-dev/viewer 4.5.2 → 5.0.0

package/src/rust/presentation.rs

@@ -33,15 +33,6 @@ pub use self::drag_helpers::{DragDropContainer, DragEndCallback};
 pub use self::props::{DragDropProps, PresentationProps};
 use crate::utils::*;
 
-/// The available themes as detected in the browser environment or set
-/// explicitly when CORS prevents detection.  Detection is expensive and
-/// typically must be performed only once, when `document.styleSheets` is
-/// up-to-date.
-#[derive(Default)]
-struct ThemeData {
-    themes: Option<Vec<String>>,
-}
-
 #[derive(Clone, Debug)]
 struct DragFrom {
     column: String,
@@ -71,7 +62,23 @@ impl DragState {
 /// Actual presentations tate struct with some fields hidden.
 pub struct PresentationHandle {
     viewer_elem: HtmlElement,
-    theme_data: Mutex<ThemeData>,
+
+    /// The available themes as detected in the browser environment or set
+    /// explicitly when CORS prevents detection — a MEMO of a document
+    /// external, not component state. `None` until first parsed (detection
+    /// is expensive and must wait for `document.styleSheets`). Sync-readable
+    /// (a `RefCell`, never borrowed across an await) so synchronous paths
+    /// ("stamp with commit" — panel creation, theme mutation sites) can
+    /// derive the registry default without awaiting registry init; derived
+    /// values (e.g. the default theme = first registered) are computed from
+    /// it on demand, never mirrored.
+    themes: RefCell<Option<Vec<String>>>,
+
+    /// Single-flight guard for the stylesheet parse that populates
+    /// [`Self::themes`] (and exclusion against `reset_available_themes`) —
+    /// concurrent `get_available_themes` calls await one parse instead of
+    /// racing their own.
+    theme_init: Mutex<()>,
     is_settings_open: RefCell<bool>,
     open_column_settings: RefCell<OpenColumnSettings>,
     is_workspace: RefCell<Option<bool>>,
@@ -100,13 +107,6 @@ pub struct PresentationHandle {
     /// the duration of the drag.
     drag_target: RefCell<Option<DragTargetState>>,
 
-    /// Per-element dedup cell for `perspective-config-update` event
-    /// dispatch. Read+written by `crate::custom_events::dispatch_*`
-    /// helpers; living here means every consumer with a `&Presentation`
-    /// (subscriptions in `wire_custom_events`, `tasks::send_plugin_config`,
-    /// `setSelection`) sees the same cache without separate plumbing.
-    pub last_dispatched_config: RefCell<Option<crate::config::ViewerConfig>>,
-
     pub settings_open_changed: PubSub<bool>,
 
     /// Injected callback from the root component, replacing the former
@@ -118,7 +118,7 @@ pub struct PresentationHandle {
     pub on_eject: PubSub<()>,
 
     /// Fires for status-bar / main-panel pointer events that target the
-    /// statusbar element. `wire_custom_events` formats the `PointerEvent`'s
+    /// statusbar element. `wire_element_events` formats the `PointerEvent`'s
     /// `type_()` into a `perspective-statusbar-{type}` `CustomEvent` name.
     pub statusbar_pointer_event: PubSub<PointerEvent>,
 }
@@ -148,7 +148,8 @@ impl Presentation {
     pub fn new(elem: &HtmlElement) -> Self {
         let theme = Self(Rc::new(PresentationHandle {
             viewer_elem: elem.clone(),
-            theme_data: Default::default(),
+            themes: Default::default(),
+            theme_init: Default::default(),
             is_workspace: Default::default(),
             settings_open_changed: Default::default(),
             settings_before_open_changed: Default::default(),
@@ -159,7 +160,6 @@ impl Presentation {
             theme_config_updated: PubSub::default(),
             on_eject: PubSub::default(),
             statusbar_pointer_event: PubSub::default(),
-            last_dispatched_config: Default::default(),
             drag_state: Default::default(),
             drop_received: Default::default(),
             on_dragstart: Default::default(),
@@ -259,14 +259,14 @@ impl Presentation {
     /// readable stylesheets.  This method is memoized - the state can be
     /// flushed by calling `reset()`.
     pub async fn get_available_themes(&self) -> ApiResult<PtrEqRc<Vec<String>>> {
-        let mut data = self.0.theme_data.lock().await;
-        if data.themes.is_none() {
+        let _guard = self.0.theme_init.lock().await;
+        if self.0.themes.borrow().is_none() {
             await_dom_loaded().await?;
             let themes = sheets::get_theme_names(&self.0.viewer_elem)?;
-            data.themes = Some(themes);
+            *self.0.themes.borrow_mut() = Some(themes);
         }
 
-        Ok(data.themes.clone().unwrap().into())
+        Ok(self.0.themes.borrow().clone().unwrap().into())
     }
 
     /// Reset the state.  `styleSheets` will be re-parsed next time
@@ -281,9 +281,9 @@ impl Presentation {
                 .unwrap_or_default()
         }
 
-        let mut mutex = self.0.theme_data.lock().await;
-        let changed = as_set(&mutex.themes) != as_set(&themes);
-        mutex.themes = themes;
+        let _guard = self.0.theme_init.lock().await;
+        let changed = as_set(&self.0.themes.borrow()) != as_set(&themes);
+        *self.0.themes.borrow_mut() = themes;
         changed
     }
 
@@ -307,6 +307,22 @@ impl Presentation {
         index.and_then(|x| themes.get(x).cloned())
     }
 
+    /// The default theme (first registered), used to resolve a panel's
+    /// effective theme when it has no per-panel override. `None` if no
+    /// themes exist.
+    pub async fn get_default_theme_name(&self) -> Option<String> {
+        self.get_available_themes().await.ok()?.first().cloned()
+    }
+
+    /// SYNC read of the registry default theme name, derived on demand from
+    /// the memoized registry — `None` until the registry first parses (or
+    /// when no themes exist). For synchronous stamping paths that must not
+    /// await registry init; prefer [`Self::get_default_theme_name`] where
+    /// awaiting is acceptable.
+    pub fn default_theme_name_sync(&self) -> Option<String> {
+        self.0.themes.borrow().as_ref()?.first().cloned()
+    }
+
     fn set_theme_attribute(&self, theme: Option<&str>) -> ApiResult<()> {
         if let Some(theme) = theme {
             Ok(self.0.viewer_elem.set_attribute("theme", theme)?)
@@ -325,18 +341,35 @@ impl Presentation {
 
     /// Set the theme by name, or `None` for the default theme.
     ///
+    /// A NAMED theme's host attribute write is SYNCHRONOUS ("stamp with
+    /// commit") — no await separates the caller's config commit from the
+    /// attribute the document cascade styles, so a slow theme-registry
+    /// init can no longer hold the host on the former theme while e.g. an
+    /// initial `restore()`'s first draw resolves. The registry-dependent
+    /// tail (theme-list resolution + `theme_config_updated`) follows
+    /// asynchronously. `None` (reset to the registry default) still
+    /// resolves through the registry first, as the default name is not
+    /// knowable synchronously on a cold cache.
+    ///
+    /// The attribute is stamped even when the requested name is not (yet)
+    /// a registered theme — matching the prior behavior for unknown
+    /// names, and additionally making an explicitly-requested name that
+    /// HAPPENS to be the registry default explicit on the element (the
+    /// old resolved-selection no-op left it absent).
+    ///
     /// # Returns
     /// A `bool` indicating whether the internal state changed.
     pub async fn set_theme_name(&self, theme: Option<&str>) -> ApiResult<bool> {
-        let (themes, selected) = self.get_selected_theme_config().await?;
-        if let Some(x) = selected
-            && themes.get(x).map(|x| x.as_str()) == theme
-        {
-            return Ok(false);
+        if let Some(theme) = theme {
+            if self.0.viewer_elem.get_attribute("theme").as_deref() == Some(theme) {
+                return Ok(false);
+            }
+
+            self.set_theme_attribute(Some(theme))?;
         }
 
+        let themes = self.get_available_themes().await?;
         let index = if let Some(theme) = theme {
-            self.set_theme_attribute(Some(theme))?;
             themes.iter().position(|x| x == theme)
         } else if !themes.is_empty() {
             self.set_theme_attribute(themes.first().map(|x| x.as_str()))?;

package/src/rust/queries/get_viewer_config.rs

@@ -28,27 +28,45 @@ pub async fn get_viewer_config(
     presentation: &Presentation,
 ) -> ApiResult<ViewerConfig> {
     let version = config::API_VERSION.to_string();
-    let view_config = if let Some(rendered) = session.get_rendered_view_config() {
+    let mut view_config = if let Some(rendered) = session.get_rendered_view_config() {
         (*rendered).clone()
     } else {
         session.get_view_config().clone()
     };
+
+    // The rendered config may carry transient element-level global filters
+    // (master/detail) appended at view-creation; the stored `config.filter` is
+    // always the panel's own user filter, so use it here to keep `save`/
+    // `getViewConfig` free of global filters.
+    view_config.filter = session.get_view_config().filter.clone();
     let settings = presentation.is_settings_open();
     let plugin = renderer.metadata().name.clone();
     let plugin_config = renderer.get_plugin_config();
-    let theme = presentation.get_selected_theme_name().await;
+    // Per-panel theme: a panel's own theme takes precedence; a panel with none
+    // records the registry DEFAULT (first registered theme) it actually renders
+    // — every panel has a concrete theme and none inherits the active panel's.
+    // `None` only when no themes are registered.
+    let theme = match renderer.theme() {
+        theme @ Some(_) => theme,
+        None => presentation.get_selected_theme_name().await,
+    };
     let title = session.get_title();
-    let table = session.get_table().map(|x| x.get_name().to_owned());
+    let table = session
+        .get_table()
+        .map(|x| x.get_name().to_owned())
+        .or_else(|| session.pending_table());
     let columns_config = renderer.all_columns_configs();
     Ok(ViewerConfig {
-        version,
-        plugin,
-        title,
-        plugin_config,
-        columns_config,
         settings,
-        table,
-        view_config,
-        theme,
+        panel: PanelViewerConfig {
+            version,
+            plugin,
+            title,
+            plugin_config,
+            columns_config,
+            table,
+            view_config,
+            theme,
+        },
     })
 }

package/src/rust/queries/plugin_column_styles.rs

@@ -37,7 +37,7 @@ pub fn get_plugin_config_schema(
     renderer: &Renderer,
     view_config: &ViewConfig,
 ) -> ApiResult<ColumnConfigSchema> {
-    let plugin = renderer.get_active_plugin()?;
+    let plugin = renderer.ensure_plugin_selected()?;
     let view_config_js =
         wasm_bindgen::JsValue::from_serde_ext(view_config).unwrap_or(wasm_bindgen::JsValue::NULL);
     let raw = plugin._plugin_config_schema(&view_config_js)?;
@@ -60,7 +60,7 @@ pub fn get_column_config_schema(
     current_value: Option<&serde_json::Map<String, serde_json::Value>>,
     abs_max: Option<f64>,
 ) -> ApiResult<ColumnConfigSchema> {
-    let plugin = renderer.get_active_plugin()?;
+    let plugin = renderer.ensure_plugin_selected()?;
     let plugin_config = renderer.metadata();
     let names = &plugin_config.config_column_names;
     let group = view_config

package/src/rust/renderer/activate.rs

@@ -17,36 +17,62 @@ use wasm_bindgen::JsCast;
 use web_sys::*;
 
 use crate::js::plugin::JsPerspectiveViewerPlugin;
+use crate::utils::RenderGuard;
 
-/// Given an async `task` which draws `plugin`, activates the plugin in stages
-/// to prevent screen shearing.  First, and plugin is appended ot the DOM with
-/// opacity 0, then rendered.  After rendering, the previous plugin is removed
-/// and the opacity is set back to 1.
+/// Mount `plugin` (once) under its layout slot in the viewer's light DOM.
+/// Idempotent — a plugin that already has a parent is left untouched (only
+/// its `slot` attribute is refreshed). No style read happens here: the
+/// mount may precede the theme stamp, and the plugin's first `draw()`
+/// captures its `--psp-*` CSS fresh by construction ("stamp before draw").
 ///
 /// # Arguments
 /// - `viewer` the root `<perspective-viewer>` element.
 /// - `plugin` the plugin custom element.
-/// - `task` an async task which renders the plugin.
-pub async fn activate_plugin<T>(
+/// - `slot` the layout slot name (panel id) to mount the plugin under, or
+///   `None` to use the default unnamed `<slot>` (legacy single-panel behavior).
+pub fn mount_plugin(
     viewer: &HtmlElement,
     plugin: &JsPerspectiveViewerPlugin,
-    task: impl Future<Output = ApiResult<T>>,
-) -> ApiResult<T> {
+    slot: Option<&str>,
+) -> ApiResult<()> {
     let html_plugin = plugin.unchecked_ref::<HtmlElement>();
+    if let Some(slot) = slot {
+        html_plugin.set_attribute("slot", slot)?;
+    }
+
     if html_plugin.parent_node().is_none() {
-        html_plugin.style().set_property("opacity", "0")?;
-        viewer.append_child(html_plugin)?;
-        plugin.restyle();
+        // TODO(texodus): Place at the bottom of the stack so it is rendered
+        // but not visible during a tab switch. This is dumb - fix this with
+        // a real life cycle.
+        viewer.prepend_with_node_1(html_plugin)?;
     }
 
-    let result = task.await;
-    html_plugin.style().set_property("opacity", "1")?;
-    result
+    Ok(())
 }
 
+/// Given an async `task` which draws `plugin`, [`mount_plugin`] it, then run
+/// `task`. Requires the [`RenderGuard`] lock witness — plugin dispatch
+/// outside a locked run does not compile (invariants I3/I6 of the merge;
+/// see `SESSION_CONFIG_COHERENCE_PLAN.md`).
+pub async fn activate_plugin<T>(
+    _guard: &RenderGuard,
+    viewer: &HtmlElement,
+    plugin: &JsPerspectiveViewerPlugin,
+    slot: Option<&str>,
+    task: impl Future<Output = ApiResult<T>>,
+) -> ApiResult<T> {
+    mount_plugin(viewer, plugin, slot)?;
+    task.await
+}
+
+/// Remove the previously-active plugin for a panel from the viewer's light DOM.
+///
+/// When `slot` is `Some`, only a plugin mounted under that same slot (panel) is
+/// removed, so the active plugins of *other* panels are left untouched.
 pub fn remove_inactive_plugin(
     viewer: &HtmlElement,
     plugin: &JsPerspectiveViewerPlugin,
+    slot: Option<&str>,
     plugins: &[JsPerspectiveViewerPlugin],
 ) -> ApiResult<()> {
     for idx in 0..viewer.children().length() {
@@ -55,6 +81,7 @@ pub fn remove_inactive_plugin(
             && plugins
                 .iter()
                 .any(|x| *x.unchecked_ref::<Element>() == elem)
+            && (slot.is_none() || elem.get_attribute("slot").as_deref() == slot)
         {
             viewer.remove_child(&elem)?;
             break;