@perspective-dev/viewer 5.0.0 → 5.2.0

package/src/rust/tasks/restore_panel.rs

@@ -10,15 +10,12 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
-use futures::channel::oneshot::channel;
 use perspective_client::clone;
 use perspective_client::utils::PerspectiveResultExt;
 
-use crate::components::viewer::{PerspectiveViewer, PerspectiveViewerMsg};
 use crate::config::*;
 use crate::presentation::Presentation;
 use crate::renderer::Renderer;
-use crate::root::Root;
 use crate::session::{ResetOptions, Session};
 use crate::tasks::*;
 use crate::workspace::Workspace;
@@ -31,6 +28,20 @@ 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.
+#[derive(Clone, Copy)]
+pub(crate) enum RestoreErrors {
+    Publish,
+    Suppress,
+}
+
 pub(crate) async fn bind_table_task(
     session: &Session,
     workspace: &Workspace,
@@ -57,9 +68,9 @@ pub(crate) async fn restore_panel(
     renderer: &Renderer,
     presentation: &Presentation,
     workspace: &Workspace,
-    root: Option<&Root<PerspectiveViewer>>,
     mode: RestoreMode,
     mut update: ViewerConfigUpdate,
+    errors: RestoreErrors,
 ) -> ApiResult<()> {
     let active = matches!(mode, RestoreMode::Existing { active: true });
     let fresh = matches!(mode, RestoreMode::Fresh);
@@ -77,17 +88,17 @@ pub(crate) async fn restore_panel(
         tracing::info!("Restoring {update}");
     }
 
-    let (sender, receiver) = channel::<()>();
-    match (active, root) {
-        (true, Some(root)) => {
-            root.borrow().as_ref().into_apierror()?.send_message(
-                PerspectiveViewerMsg::ToggleSettingsComplete(update.settings.clone(), sender),
-            );
-        },
-        _ => {
-            let _ = sender.send(());
-        },
-    }
+    // NOTE: `update.settings` is deliberately NOT applied here. It is
+    // element-level chrome rather than panel state, so `restore()` — the
+    // only caller that can carry it — applies it before dispatching, and
+    // this pipeline stays per-panel. Applying it here reached only the
+    // `Existing { active: true }` mode, which is why a freshly created
+    // panel silently ignored it.
+
+    // Under `Suppress` the restore is TRANSACTIONAL, so snapshot the config
+    // it is about to overwrite — see the failure tail below for why.
+    let rollback =
+        matches!(errors, RestoreErrors::Suppress).then(|| session.get_view_config().clone());
 
     let table_changed = !fresh
         && matches!(&update.table, OptionalUpdate::Update(name)
@@ -122,7 +133,6 @@ pub(crate) async fn restore_panel(
                     bind_table_task(&session, &workspace, name).await?;
                 }
 
-                receiver.await.unwrap_or_log();
                 Ok(())
             }
         },
@@ -130,7 +140,14 @@ pub(crate) async fn restore_panel(
     .await;
 
     if let Err(e) = &result {
-        session.set_error(false, e.clone()).await?;
+        match errors {
+            RestoreErrors::Publish => session.set_error(false, e.clone()).await?,
+            RestoreErrors::Suppress => {
+                if let Some(config) = rollback {
+                    session.commit_view_config(config.into()).unwrap_or_log();
+                }
+            },
+        }
     }
 
     result?;

package/src/rust/tasks/sync_update_panels.rs

@@ -55,20 +55,19 @@ pub fn sync_update_panels(
     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 {
-        if !matches!(config.settings, OptionalUpdate::Missing) {
-            #[rustfmt::skip]
-            tracing::warn!(
-                "`settings` on panel \"{saved_id}\" is ignored in a whole-element config; use the top-level `active` field"
-            );
-        }
-
         let (fresh, session, renderer, config) = create_panel_model(
             &this.elem,
             &this.presentation,
             &this.workspace,
             None,
-            config,
+            config.into(),
             None,
             Placement::Placed,
         );
@@ -82,21 +81,6 @@ pub fn sync_update_panels(
         contents.push((fresh, session, renderer, config));
     }
 
-    if contents.is_empty() {
-        let (fresh, session, renderer, config) = create_panel_model(
-            &this.elem,
-            &this.presentation,
-            &this.workspace,
-            None,
-            ViewerConfigUpdate::default(),
-            None,
-            Placement::Placed,
-        );
-
-        fallback_fresh = Some(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));

package/src/rust/utils/browser/dragdrop.rs

@@ -17,6 +17,18 @@ pub enum DragTarget {
     SplitBy,
     Sort,
     Filter,
+    WindowSource,
+    WindowOrderBy,
+    WindowPartitionBy,
+}
+
+impl DragTarget {
+    pub fn is_staged(&self) -> bool {
+        matches!(
+            self,
+            Self::WindowSource | Self::WindowOrderBy | Self::WindowPartitionBy
+        )
+    }
 }
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]

package/src/rust/utils/browser/tests/debounce.rs

@@ -86,6 +86,55 @@ pub async fn test_lock_seq() {
     assert_eq!(cell.get(), 10);
 }
 
+/// A dedicated [`DebounceSlot`]'s task must RUN even when the default slot
+/// has a parked runner — coalescing is scoped per slot. Pre-slot (one
+/// shared parked flag), `t4` would resolve via `t2`'s settle without its
+/// closure ever running: the resize-eaten-by-parked-update bug.
+#[wasm_bindgen_test]
+pub async fn test_slot_isolated_from_default_coalescing() {
+    let debounce_mutex = DebounceMutex::default();
+    let slot = debounce_mutex.slot();
+    let defaults: Rc<Cell<u32>> = Rc::new(Cell::new(0));
+    let slots: Rc<Cell<u32>> = Rc::new(Cell::new(0));
+
+    let t1 = debounce_mutex.lock(async {
+        set_timeout(10).await.unwrap();
+    });
+
+    let t2 = {
+        let defaults = defaults.clone();
+        debounce_mutex.debounce(async move {
+            defaults.set(defaults.get() + 1);
+            Ok(())
+        })
+    };
+
+    let t3 = {
+        let defaults = defaults.clone();
+        debounce_mutex.debounce(async move {
+            defaults.set(defaults.get() + 100);
+            Ok(())
+        })
+    };
+
+    let t4 = {
+        let slots = slots.clone();
+        slot.debounce_with(|_| async move {
+            slots.set(slots.get() + 1);
+            Ok(())
+        })
+    };
+
+    let (_, r2, r3, r4) = futures::join!(t1, t2, t3, t4);
+    r2.unwrap();
+    r3.unwrap();
+    r4.unwrap();
+
+    // `t3` coalesced onto the parked `t2`; `t4` ran its own closure.
+    assert_eq!(defaults.get(), 1);
+    assert_eq!(slots.get(), 1);
+}
+
 #[wasm_bindgen_test]
 pub async fn test_debounce_seq() {
     let debounce_mutex = DebounceMutex::default();

package/src/rust/utils/debounce.rs

@@ -33,16 +33,27 @@ pub struct RenderGuard {
     _private: (),
 }
 
+/// The per-slot debounce bookkeeping: one running + one parked evaluation,
+/// with coalesced callers awaiting the parked runner's settle. Kept
+/// per-[`DebounceSlot`] so coalescing is only expressible WITHIN a kind —
+/// a caller can never be absorbed by a parked runner of a different kind
+/// whose work does not subsume it (the resize-eaten-by-parked-update bug).
 #[derive(Default)]
-struct DebounceMutexData {
+struct SlotState {
     id: Cell<u64>,
-    held: Cell<bool>,
-    mutex: Mutex<u64>,
+    last: Cell<u64>,
     parked: Cell<bool>,
     settled_id: Cell<u64>,
     on_settle: PubSub<()>,
 }
 
+#[derive(Default)]
+struct DebounceMutexData {
+    held: Cell<bool>,
+    mutex: Mutex<()>,
+    default_slot: Rc<SlotState>,
+}
+
 /// Clears the `held` flag on drop, so cancellation of a locked task (its
 /// future dropped mid-await) can't leave [`DebounceMutex::is_held`] stuck
 /// `true`.
@@ -67,25 +78,25 @@ impl Drop for HeldFlag<'_> {
 /// mid-run still frees the parked slot and releases its coalesced waiters,
 /// so they can never be stranded awaiting a settle that no task will emit.
 struct SettleGuard<'a> {
-    data: &'a DebounceMutexData,
+    state: &'a SlotState,
     next: u64,
 }
 
 impl<'a> SettleGuard<'a> {
-    fn park(data: &'a DebounceMutexData, next: u64) -> Self {
-        data.parked.set(true);
-        Self { data, next }
+    fn park(state: &'a SlotState, next: u64) -> Self {
+        state.parked.set(true);
+        Self { state, next }
     }
 }
 
 impl Drop for SettleGuard<'_> {
     fn drop(&mut self) {
-        self.data.parked.set(false);
-        if self.data.settled_id.get() < self.next {
-            self.data.settled_id.set(self.next);
+        self.state.parked.set(false);
+        if self.state.settled_id.get() < self.next {
+            self.state.settled_id.set(self.next);
         }
 
-        self.data.on_settle.emit(());
+        self.state.on_settle.emit(());
     }
 }
 
@@ -123,12 +134,11 @@ impl DebounceMutex {
         F: FnOnce(RenderGuard) -> Fut,
         Fut: Future<Output = T>,
     {
-        let mut last = self.0.mutex.lock().await;
-        let next = self.0.id.get();
+        let guard = self.0.mutex.lock().await;
         let held = HeldFlag::set(&self.0.held);
         let result = f(RenderGuard { _private: () }).await;
         drop(held);
-        *last = next;
+        drop(guard);
         result
     }
 
@@ -144,23 +154,62 @@ impl DebounceMutex {
         F: FnOnce(RenderGuard) -> Fut,
         Fut: Future<Output = ApiResult<T>>,
     {
-        let next = self.0.id.get() + 1;
-        if self.0.parked.get() {
+        DebounceSlot {
+            mutex: self.clone(),
+            state: self.0.default_slot.clone(),
+        }
+        .debounce_with(f)
+        .await
+    }
+
+    /// A NEW debounce slot over this mutex: its tasks serialize against
+    /// every other locked task, but coalesce only among themselves.
+    pub fn slot(&self) -> DebounceSlot {
+        DebounceSlot {
+            mutex: self.clone(),
+            state: Default::default(),
+        }
+    }
+}
+
+/// One debounce KIND over a shared [`DebounceMutex`]. Execution is
+/// exclusive across the whole mutex; coalescing (a caller resolving via a
+/// parked runner instead of queueing) is scoped to the slot. A coalesced
+/// caller's work must be subsumable by any same-slot runner that runs no
+/// earlier than the call — which is why parameterized tasks sharing a slot
+/// must read their parameters at RUN time (e.g. the [`Renderer`] geometry
+/// command cell), never capture them at call time.
+#[derive(Clone)]
+pub struct DebounceSlot {
+    mutex: DebounceMutex,
+    state: Rc<SlotState>,
+}
+
+impl DebounceSlot {
+    pub async fn debounce_with<T, F, Fut>(&self, f: F) -> ApiResult<T>
+    where
+        T: Default,
+        F: FnOnce(RenderGuard) -> Fut,
+        Fut: Future<Output = ApiResult<T>>,
+    {
+        let state = &self.state;
+        let next = state.id.get() + 1;
+        if state.parked.get() {
             self.await_settled(next).await;
             return Ok(T::default());
         }
 
-        let settle = SettleGuard::park(&self.0, next);
-        let mut last = self.0.mutex.lock().await;
-        self.0.parked.set(false);
-        let result = if *last < next {
-            let next = self.0.id.get() + 1;
-            self.0.id.set(next);
-            let held = HeldFlag::set(&self.0.held);
+        let settle = SettleGuard::park(state, next);
+        let guard = self.mutex.0.mutex.lock().await;
+        state.parked.set(false);
+        let result = if state.last.get() < next {
+            let next = state.id.get() + 1;
+            state.id.set(next);
+            let held = HeldFlag::set(&self.mutex.0.held);
             let result = f(RenderGuard { _private: () }).await;
             drop(held);
             if result.is_ok() {
-                *last = next;
+                state.last.set(next);
             }
 
             result
@@ -168,14 +217,14 @@ impl DebounceMutex {
             Ok(T::default())
         };
 
-        drop(last);
+        drop(guard);
         drop(settle);
         result
     }
 
     async fn await_settled(&self, next: u64) {
-        while self.0.settled_id.get() < next {
-            if self.0.on_settle.read_next().await.is_err() {
+        while self.state.settled_id.get() < next {
+            if self.state.on_settle.read_next().await.is_err() {
                 break;
             }
         }

package/src/rust/workspace.rs

@@ -21,7 +21,7 @@ use perspective_client::config::Filter;
 
 use crate::renderer::Renderer;
 use crate::session::Session;
-use crate::utils::{EffectLedger, PubSub, Subscription};
+use crate::utils::{EffectLedger, PubSub, Subscription, spawn_owned};
 
 /// A unique identifier for a [`Panel`] within a [`Workspace`].
 #[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
@@ -243,6 +243,22 @@ struct WorkspaceData {
     /// In-flight effects (public mutators + scheduled internal flows),
     /// drained by `flush()` — see [`EffectLedger`].
     effects: EffectLedger,
+
+    /// The PLACED panel set changed since the last emit. Mutation sites set
+    /// this and emit NOTHING; the coalescing flush task owns delivery (see
+    /// [`Workspace::schedule_layout_flush`]).
+    layout_dirty: bool,
+    layout_changed: Rc<PubSub<Vec<PanelId>>>,
+
+    /// The active panel changed since the last emit. A separate channel from
+    /// `layout_dirty`: "which panel is selected" and "which panels exist" are
+    /// distinct facts, and one event may not mean both.
+    active_dirty: bool,
+    active_changed: Rc<PubSub<Option<PanelId>>>,
+
+    /// A flush task is already queued — the flag that makes N mutations
+    /// within one operation schedule ONE task rather than N.
+    flush_scheduled: bool,
 }
 
 impl Default for Workspace {
@@ -269,6 +285,11 @@ impl Workspace {
             staged_changed: Rc::new(PubSub::default()),
             reserved: None,
             effects: EffectLedger::default(),
+            layout_dirty: false,
+            layout_changed: Rc::new(PubSub::default()),
+            active_dirty: false,
+            active_changed: Rc::new(PubSub::default()),
+            flush_scheduled: false,
         })))
     }
 
@@ -277,6 +298,62 @@ impl Workspace {
         self.0.borrow().effects.clone()
     }
 
+    pub fn layout_changed(&self) -> Rc<PubSub<Vec<PanelId>>> {
+        self.0.borrow().layout_changed.clone()
+    }
+
+    pub fn active_changed(&self) -> Rc<PubSub<Option<PanelId>>> {
+        self.0.borrow().active_changed.clone()
+    }
+
+    /// Queue the coalescing layout-event flush, if anything is dirty and no
+    /// flush is already pending.
+    fn schedule_layout_flush(&self) {
+        let schedule = {
+            let mut data = self.0.borrow_mut();
+            let dirty = data.layout_dirty || data.active_dirty;
+            let queued = data.flush_scheduled;
+            data.flush_scheduled |= dirty;
+            dirty && !queued
+        };
+
+        if !schedule {
+            return;
+        }
+
+        let effects = self.effects();
+        let this = self.clone();
+        spawn_owned("workspace_layout_flush", async move {
+            effects.settle().await;
+            this.flush_layout_events();
+            Ok(())
+        });
+    }
+
+    /// Emit whatever is dirty, outside any borrow.
+    fn flush_layout_events(&self) {
+        let (layout, active, panels, active_id, layout_pubsub, active_pubsub) = {
+            let mut data = self.0.borrow_mut();
+            data.flush_scheduled = false;
+            (
+                std::mem::take(&mut data.layout_dirty),
+                std::mem::take(&mut data.active_dirty),
+                data.panels.iter().map(|p| p.id.clone()).collect::<Vec<_>>(),
+                data.active.clone(),
+                data.layout_changed.clone(),
+                data.active_changed.clone(),
+            )
+        };
+
+        if layout {
+            layout_pubsub.emit(panels);
+        }
+
+        if active {
+            active_pubsub.emit(active_id);
+        }
+    }
+
     /// Stage a layout tree for `MainPanel` to apply at its next `rendered`
     /// pass (see `WorkspaceData::pending_layout`).
     pub fn set_pending_layout(&self, layout: crate::js::Layout) {
@@ -512,16 +589,22 @@ impl Workspace {
     /// Append a [`Panel`]. When the element had zero panels, the inserted panel
     /// becomes the active one (there is no other candidate).
     pub fn insert_panel(&self, panel: Panel) {
-        let mut data = self.0.borrow_mut();
-        if data.active.is_none() {
-            data.active = Some(panel.id.clone());
+        {
+            let mut data = self.0.borrow_mut();
+            if data.active.is_none() {
+                data.active = Some(panel.id.clone());
+                data.active_dirty = true;
+            }
+
+            panel
+                .renderer
+                .set_active_flag(data.active.as_ref() == Some(&panel.id));
+            data.panels.push(panel);
+            data.layout_dirty = true;
+            Self::sync_solo_flags(&data);
         }
 
-        panel
-            .renderer
-            .set_active_flag(data.active.as_ref() == Some(&panel.id));
-        data.panels.push(panel);
-        Self::sync_solo_flags(&data);
+        self.schedule_layout_flush();
     }
 
     /// Hold `panel` in the reservation slot (see [`WorkspaceData::reserved`]):
@@ -585,8 +668,10 @@ impl Workspace {
 
             if data.active.as_ref() == Some(id) {
                 data.active = None;
+                data.active_dirty = true;
             }
 
+            data.layout_dirty |= removed.is_some();
             Self::sync_solo_flags(&data);
             (
                 removed,
@@ -605,25 +690,32 @@ impl Workspace {
             staged_pubsub.emit(());
         }
 
+        self.schedule_layout_flush();
         removed
     }
 
     /// Set the active panel. Returns `false` (no-op) if `id` is not a known
     /// panel.
     pub fn set_active(&self, id: PanelId) -> bool {
-        let mut data = self.0.borrow_mut();
-        if data.panels.iter().any(|p| p.id == id) {
-            data.active = Some(id);
-            for panel in data.panels.iter() {
-                panel
-                    .renderer
-                    .set_active_flag(data.active.as_ref() == Some(&panel.id));
+        let known = {
+            let mut data = self.0.borrow_mut();
+            if data.panels.iter().any(|p| p.id == id) {
+                data.active_dirty |= data.active.as_ref() != Some(&id);
+                data.active = Some(id);
+                for panel in data.panels.iter() {
+                    panel
+                        .renderer
+                        .set_active_flag(data.active.as_ref() == Some(&panel.id));
+                }
+
+                true
+            } else {
+                false
             }
+        };
 
-            true
-        } else {
-            false
-        }
+        self.schedule_layout_flush();
+        known
     }
 
     /// The default [`Client`], if one has been loaded.

package/src/svg/pin-icon.svg

@@ -0,0 +1,5 @@
+<svg width="14" height="14" viewBox="0 0 22 22" fill="none" xmlns="http://www.w3.org/2000/svg">
+    <path
+        d="M8 2h6v2l-1 1v4l3 2v2h-4v6l-1 2-1-2v-6H6v-2l3-2V5L8 4z"
+        stroke="#042121" />
+</svg>

package/src/themes/icons.css

@@ -52,6 +52,7 @@ perspective-viewer-tab {
     --psp-icon--sort-none--mask-image: url("../svg/sort-none-icon.svg");
     --psp-icon--add-expression--mask-image: url("../svg/expression.svg");
     --psp-icon--close--mask-image: url("../svg/close-icon.svg");
+    --psp-icon--pin--mask-image: url("../svg/pin-icon.svg");
     --psp-label--inactive-column-selector--content: url("../svg/checkbox-unchecked-icon.svg");
     --psp-label--active-column-selector--content: url("../svg/checkbox-checked-icon.svg");
     --psp-icon--select-arrow-light--mask-image: url("../svg/dropdown-selector-light.svg");

package/src/themes/intl/de.css

@@ -108,9 +108,32 @@ perspective-dropdown {
     /* Tabs */
     --psp-label--style-tab--content: "Stil";
     --psp-label--attributes-tab--content: "Attribute";
+    --psp-label--window-tab--content: "Fenster";
+    --psp-label--window-source--content: "Spalte";
+    --psp-label--window-order-by--content: "Sortieren nach";
+    --psp-label--window-partition-by--content: "Partitionieren nach";
+    --psp-label--window-frame--content: "Rahmen";
+    --psp-label--window-offset--content: "Versatz";
+    --psp-label--window-alpha--content: "Alpha";
     --psp-label--query-tab--content: "Abfrage";
     --psp-label--plugin-tab--content: "Plugin";
     --psp-label--debug-tab--content: "JSON";
+    --psp-label--chat-tab--content: "Chat";
+
+    /* Chat panel */
+    --psp-label--chat-reasoning--content: "Denkprozess";
+    --psp-label--chat-send--content: "Senden";
+    --psp-label--chat-stop--content: "Stopp";
+    --psp-label--chat-placeholder--content: "Frage zu Ihren Daten…";
+
+    /* Plugin-declared pivot roles (PluginStaticConfig) */
+    --psp-label--role--x-axis--content: "X-Achse";
+    --psp-label--role--y-axis--content: "Y-Achse";
+    --psp-label--role--series--content: "Serien";
+    --psp-label--role--hierarchy--content: "Hierarchie";
+    --psp-label--role--facets--content: "Facetten";
+    --psp-label--role--row-groups--content: "Zeilengruppen";
+    --psp-label--role--column-groups--content: "Spaltengruppen";
 
     /* Plugin settings */
     --psp-label--edit-mode--content: "Bearbeitungsmodus";

package/src/themes/intl/es.css

@@ -108,9 +108,32 @@ perspective-dropdown {
     /* Tabs */
     --psp-label--style-tab--content: "Estilo";
     --psp-label--attributes-tab--content: "Atributos";
+    --psp-label--window-tab--content: "Ventana";
+    --psp-label--window-source--content: "Columna";
+    --psp-label--window-order-by--content: "Ordenar por";
+    --psp-label--window-partition-by--content: "Particionar por";
+    --psp-label--window-frame--content: "Marco";
+    --psp-label--window-offset--content: "Desplazamiento";
+    --psp-label--window-alpha--content: "Alfa";
     --psp-label--query-tab--content: "Consulta";
     --psp-label--plugin-tab--content: "Plugin";
     --psp-label--debug-tab--content: "JSON";
+    --psp-label--chat-tab--content: "Chat";
+
+    /* Chat panel */
+    --psp-label--chat-reasoning--content: "Razonamiento";
+    --psp-label--chat-send--content: "Enviar";
+    --psp-label--chat-stop--content: "Detener";
+    --psp-label--chat-placeholder--content: "Pregunta sobre tus datos…";
+
+    /* Plugin-declared pivot roles (PluginStaticConfig) */
+    --psp-label--role--x-axis--content: "Eje X";
+    --psp-label--role--y-axis--content: "Eje Y";
+    --psp-label--role--series--content: "Series";
+    --psp-label--role--hierarchy--content: "Jerarquía";
+    --psp-label--role--facets--content: "Facetas";
+    --psp-label--role--row-groups--content: "Grupos de filas";
+    --psp-label--role--column-groups--content: "Grupos de columnas";
 
     /* Plugin settings */
     --psp-label--edit-mode--content: "Modo de edición";