@perspective-dev/viewer 5.4.0 → 5.5.1

package/src/rust/tasks/sync_update_panels.rs

@@ -17,7 +17,7 @@ use wasm_bindgen::prelude::*;
 use crate::components::viewer::PerspectiveViewerMsg;
 use crate::config::*;
 use crate::renderer::*;
-use crate::session::Session;
+use crate::session::{Disposal, Session};
 use crate::tasks::*;
 use crate::workspace::PanelId;
 use crate::*;
@@ -26,6 +26,9 @@ use crate::*;
 extern "C" {
     #[wasm_bindgen(typescript_type = "ViewerConfigUpdate")]
     pub type JsViewerConfigUpdate;
+
+    #[wasm_bindgen(typescript_type = "WorkspaceConfigUpdate")]
+    pub type JsWorkspaceConfigUpdate;
 }
 
 pub type SyncUpdatePanelsResult = (
@@ -33,12 +36,12 @@ pub type SyncUpdatePanelsResult = (
     std::vec::Vec<perspective_js::utils::ApiFuture<()>>,
 );
 
-/// Update the panel state to match a `WorkspaceConfigUpdate`.
-///
-/// This method must be synchronous.
+/// Synchronously apply a `WorkspaceConfigUpdate` to the element's models
+/// field-wise, replacing the panel set only when `panels` is present, and
+/// return the fresh panels to restore plus the eject tasks.
 pub fn sync_update_panels(
     this: &PerspectiveViewerElement,
-    update: JsViewerConfigUpdate,
+    update: JsWorkspaceConfigUpdate,
 ) -> ApiResult<SyncUpdatePanelsResult> {
     let WorkspaceConfigUpdate {
         active,
@@ -49,98 +52,175 @@ pub fn sync_update_panels(
         palette,
     } = update.into_serde_ext()?;
 
-    let palette = validate_palette(palette.unwrap_or_default())
-        .map_err(|e| ApiError::from(JsValue::from_str(&e)))?;
+    let palette = match palette {
+        OptionalUpdate::Missing => None,
+        OptionalUpdate::SetDefault => Some(Default::default()),
+        OptionalUpdate::Update(palette) => {
+            Some(validate_palette(palette).map_err(|e| ApiError::from(JsValue::from_str(&e)))?)
+        },
+    };
+
     let old_ids = this.workspace.panel_ids();
+    let replace = panels.is_some();
 
     // Phase 1 — models only, NO renders and NO draws
     let mut id_map: HashMap<String, String> = Default::default();
-    let mut fallback_fresh: Option<String> = None;
-    let mut active_fresh: Option<String> = None;
     let mut contents = Vec::new();
-    // `panels` entries are `ViewerConfigInitial`s — `table` required by
-    // TYPE (a placed panel without a binding would be permanently blank),
-    // and no per-panel `settings` exists (element-level; carried by the
-    // top-level `active` field). An EMPTY `panels` map restores to the
-    // zero-panel empty stage — the former table-less fallback panel was
-    // exactly the blank-panel state this type exists to preclude.
-    for (saved_id, config) in panels {
-        let (fresh, session, renderer, config) = create_panel_model(
-            &this.elem,
-            &this.presentation,
-            &this.workspace,
-            None,
-            config.into(),
-            None,
-            Placement::Placed,
-        );
-
-        if active.as_deref() == Some(saved_id.as_str()) {
-            active_fresh = Some(fresh.as_str().to_owned());
-        }
-
-        fallback_fresh.get_or_insert_with(|| fresh.as_str().to_owned());
-        id_map.insert(saved_id, fresh.as_str().to_owned());
-        contents.push((fresh, session, renderer, config));
-    }
-
     let mut eject_tasks = Vec::new();
-    if let Some(panel) = this.workspace.take_reserved() {
-        eject_tasks.push(eject_panel(panel));
+    match panels {
+        // `panels` entries are `ViewerConfigInitial`s — `table` required by
+        // TYPE (a placed panel without a binding would be permanently blank),
+        // and no per-panel `settings` exists (element-level; carried by the
+        // top-level `active` field). An EMPTY `panels` map restores to the
+        // zero-panel empty stage — the former table-less fallback panel was
+        // exactly the blank-panel state this type exists to preclude.
+        Some(panels) => {
+            for (saved_id, config) in panels {
+                let (fresh, session, renderer, config) = create_panel_model(
+                    &this.elem,
+                    &this.presentation,
+                    &this.workspace,
+                    None,
+                    config.into(),
+                    None,
+                    Placement::Placed,
+                );
+
+                id_map.insert(saved_id, fresh.as_str().to_owned());
+                contents.push((fresh, session, renderer, config));
+            }
+
+            if let Some(panel) = this.workspace.take_reserved() {
+                eject_tasks.push(eject_panel(panel, Disposal::Reject));
+            }
+
+            for old in &old_ids {
+                if let Some(panel) = this.workspace.remove_panel(old) {
+                    eject_tasks.push(eject_panel(panel, Disposal::Reject));
+                }
+            }
+        },
+        None => {
+            for id in &old_ids {
+                id_map.insert(id.as_str().to_owned(), id.as_str().to_owned());
+            }
+        },
     }
 
-    for old in old_ids {
-        if let Some(panel) = this.workspace.remove_panel(&old) {
-            eject_tasks.push(eject_panel(panel));
-        }
+    if let Some(palette) = palette {
+        this.presentation.set_palette(palette)?;
     }
 
-    this.presentation.set_palette(palette)?;
-
     // Phase 2 — stage the remapped layout tree on the Workspace
+    let layout_staged = layout.is_some();
     if let Some(layout) = layout {
         this.workspace
             .set_pending_layout(layout.remap(&|name| id_map.get(name).cloned()));
+        if !replace {
+            this.workspace.layout_staged().emit(());
+        }
     }
 
     // Phase 3 — the single visible commit
-    if let Some(saved) = &active
-        && active_fresh.is_none()
-    {
-        tracing::warn!("`active` names unknown panel \"{saved}\"");
-    }
-
-    let sidebar_open = active_fresh.is_some();
-    if let Some(target) = active_fresh.or(fallback_fresh)
+    let active_target = match &active {
+        OptionalUpdate::Update(saved) => {
+            let target = id_map.get(saved).cloned();
+            if target.is_none() {
+                tracing::warn!("`active` names unknown panel \"{saved}\"");
+            }
+
+            target
+        },
+        _ => None,
+    };
+
+    let commit_target = if replace {
+        active_target
+            .clone()
+            .or_else(|| contents.first().map(|(id, ..)| id.as_str().to_owned()))
+    } else if layout_staged || active_target.is_some() {
+        active_target
+            .clone()
+            .or_else(|| this.workspace.active_id().map(|id| id.as_str().to_owned()))
+    } else {
+        None
+    };
+
+    if let Some(target) = commit_target
         && let Some(app) = this.root.borrow().as_ref()
     {
         app.send_message(PerspectiveViewerMsg::CommitWorkspaceRestore(target));
     }
 
-    if let Some(app) = this.root.borrow().as_ref() {
+    let settings = if replace {
+        Some(active_target.is_some())
+    } else {
+        match active {
+            OptionalUpdate::Update(_) => active_target.as_ref().map(|_| true),
+            OptionalUpdate::SetDefault => Some(false),
+            OptionalUpdate::Missing => None,
+        }
+    };
+
+    if let Some(open) = settings
+        && 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)),
+            Some(SettingsUpdate::Update(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())),
-            None => {
-                tracing::warn!("`masters` names unknown panel \"{saved}\"");
-                None
-            },
-        })
-        .collect::<Vec<_>>();
-
-    this.workspace.set_masters(masters);
-    this.workspace
-        .set_global_filters(global_filters.unwrap_or_default());
+    let masters = match masters {
+        OptionalUpdate::Missing => None,
+        OptionalUpdate::SetDefault => Some(Vec::new()),
+        OptionalUpdate::Update(masters) => Some(
+            masters
+                .into_iter()
+                .filter_map(|saved| match id_map.get(&saved) {
+                    Some(fresh) => Some(PanelId::from(fresh.as_str())),
+                    None => {
+                        tracing::warn!("`masters` names unknown panel \"{saved}\"");
+                        None
+                    },
+                })
+                .collect::<Vec<_>>(),
+        ),
+    };
+
+    if let Some(masters) = masters {
+        let before = this.workspace.masters();
+        this.workspace.set_masters(masters);
+        if !replace {
+            let after = this.workspace.masters();
+            for id in &old_ids {
+                let is_master = after.contains(id);
+                if before.contains(id) != is_master
+                    && let Some(panel) = this.workspace.panel(id)
+                {
+                    let mode = if is_master {
+                        "SELECT_ROW_TREE"
+                    } else {
+                        "READ_ONLY"
+                    };
+
+                    set_edit_mode(&panel.session, &panel.renderer, mode);
+                    if !is_master {
+                        this.workspace.clear_contribution(id);
+                    }
+                }
+            }
+        }
+    }
+
+    match global_filters {
+        OptionalUpdate::Missing => {},
+        OptionalUpdate::SetDefault => this.workspace.set_global_filters(Vec::new()),
+        OptionalUpdate::Update(filters) => this.workspace.set_global_filters(filters),
+    }
+
     Ok((contents, eject_tasks))
 }

package/src/rust/tasks/table_lifecycle.rs

@@ -150,7 +150,13 @@ async fn bind_pending(
                     return Ok(());
                 };
 
-                super::restore_panel::bind_table_task(&session, &workspace, name).await
+                super::restore_panel::bind_table_task(
+                    &session,
+                    &workspace,
+                    name,
+                    crate::session::MissingTable::Pend,
+                )
+                .await
             }
         },
     )

package/src/rust/ui/containers/tab_list.rs

@@ -80,7 +80,7 @@ impl<T: TabItem> Component for TabList<T> {
 
             let onclick = ctx.link().callback(move |_| TabListMsg::SetSelected(idx));
             let title = tab.to_string();
-            let style = intl_content_style(&format!("{}-tab", intl_slug(&title)), &title);
+            let style = intl_content_style(&format!("{}-tab", intl_slug(&title)));
             html! {
                 <span {class} {onclick}>
                     <div class="tab-title" id={title} {style} />

package/src/rust/ui/form/intl_label.rs

@@ -26,29 +26,10 @@ pub fn intl_slug(key: &str) -> String {
         .collect()
 }
 
-fn humanize(key: &str) -> String {
-    let mut out = String::with_capacity(key.len());
-    for x in key.chars() {
-        if x.is_alphanumeric() {
-            if out.is_empty() {
-                out.extend(x.to_uppercase());
-            } else {
-                out.push(x);
-            }
-        } else if matches!(x, '_' | '-') || x.is_whitespace() {
-            out.push(' ');
-        }
-    }
-
-    out
-}
-
 /// The inline `style` that routes an element's `:before` text through the intl
-/// indirection: `--psp-label--content` is set to a reference to
-/// `--psp-label--{var}--content`, falling back to `fallback`, and a generic
-/// stylesheet rule renders it.
-pub fn intl_content_style(var: &str, fallback: &str) -> String {
-    format!("--psp-label--content: var(--psp-label--{var}--content, \"{fallback}\")")
+/// indirection.
+pub fn intl_content_style(var: &str) -> String {
+    format!("--psp-label--content: var(--psp-label--{var}--content)")
 }
 
 #[derive(Properties, PartialEq)]
@@ -75,7 +56,7 @@ pub fn intl_label(props: &IntlLabelProps) -> Html {
         (format!("{}-label", props.name), slug)
     };
 
-    let style = intl_content_style(&var, &humanize(&props.name));
+    let style = intl_content_style(&var);
     let class = classes!("intl-label", props.class.clone());
     html! { <label {class} {id} {style} /> }
 }

package/src/rust/ui/portal.rs

@@ -351,6 +351,7 @@ impl Component for PortalModal {
                 if ctx.props().own_focus {
                     self.host.set_attribute("tabindex", "0").unwrap();
                     self.setup_dismiss_handlers(ctx);
+                    let _ = self.host.focus();
                 }
 
                 let link = ctx.link().clone();

package/src/rust/utils/css_vars.rs

@@ -24,3 +24,16 @@ pub fn read_custom_property(elem: &Element, name: &str) -> Option<String> {
     let value = value.trim();
     (!value.is_empty()).then(|| value.to_owned())
 }
+
+/// The intl string `--psp-label--{slug}--content` as inherited by `elem`,
+/// unquoted, or `None` when no theme defines it.
+pub fn read_intl_string(elem: &Element, slug: &str) -> Option<String> {
+    let raw = read_custom_property(elem, &format!("--psp-label--{slug}--content"))?;
+    let unquoted = raw
+        .strip_prefix('"')
+        .and_then(|x| x.strip_suffix('"'))
+        .or_else(|| raw.strip_prefix('\'').and_then(|x| x.strip_suffix('\'')))
+        .unwrap_or(&raw);
+
+    Some(unquoted.replace("\\\"", "\""))
+}

package/src/rust/{config/datetime_column_style/color_mode.rs → utils/in_flight.rs}

@@ -10,53 +10,65 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
-use std::fmt::Display;
-use std::str::FromStr;
+use std::cell::Cell;
+use std::rc::Rc;
 
-use serde::{Deserialize, Serialize};
-use strum::EnumIter;
-use ts_rs::TS;
+use super::pubsub::PubSub;
 
-#[derive(Clone, Copy, Debug, Default, Deserialize, EnumIter, Eq, PartialEq, Serialize, TS)]
-pub enum DatetimeColorMode {
-    #[default]
-    #[serde(rename = "none")]
-    None,
+/// A refcounted account of concurrent in-flight work, moved only by
+/// [`InFlightGuard`]'s `Drop` so no exit path can strand the count.
+#[derive(Clone, Default)]
+pub struct InFlight(Rc<InFlightData>);
 
-    #[serde(rename = "foreground")]
-    Foreground,
-
-    #[serde(rename = "background")]
-    Background,
+#[derive(Default)]
+struct InFlightData {
+    count: Cell<u32>,
+    changed: PubSub<u32>,
 }
 
-impl Display for DatetimeColorMode {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let text = match self {
-            Self::None => "none",
-            Self::Foreground => "foreground",
-            Self::Background => "background",
-        };
+/// One unit of in-flight work, moved INTO the future it accounts for.
+#[must_use]
+pub struct InFlightGuard(InFlight);
 
-        write!(f, "{text}")
+impl InFlight {
+    pub fn guard(&self) -> InFlightGuard {
+        let count = self.0.count.get() + 1;
+        self.0.count.set(count);
+        self.0.changed.emit(count);
+        InFlightGuard(self.clone())
+    }
+
+    pub fn count(&self) -> u32 {
+        self.0.count.get()
     }
-}
 
-impl FromStr for DatetimeColorMode {
-    type Err = String;
+    pub fn is_empty(&self) -> bool {
+        self.0.count.get() == 0
+    }
+
+    /// Fires with the ABSOLUTE [`Self::count`] on both edges, so subscribers
+    /// assign rather than accumulate.
+    pub fn changed(&self) -> &PubSub<u32> {
+        &self.0.changed
+    }
 
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "none" => Ok(Self::None),
-            "foreground" => Ok(Self::Foreground),
-            "background" => Ok(Self::Background),
-            x => Err(format!("Unknown DatetimeColorMode::{x}")),
+    /// Resolve once every unit in flight has settled.
+    pub async fn settle(&self) {
+        while self.0.count.get() > 0 {
+            if self.0.changed.read_next().await.is_err() {
+                break;
+            }
         }
     }
 }
 
-impl DatetimeColorMode {
-    pub fn is_none(&self) -> bool {
-        self == &Self::None
+impl Drop for InFlightGuard {
+    fn drop(&mut self) {
+        let data = &self.0.0;
+        let count = data.count.get();
+        debug_assert!(count > 0, "InFlight underflow");
+        let count = count.saturating_sub(1);
+        data.count.set(count);
+        data.changed.emit(count);
     }
 }