@perspective-dev/viewer 4.5.1 → 5.0.0

package/src/rust/components/style/style_provider.rs

@@ -10,9 +10,28 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
+use wasm_bindgen::{JsCast, JsValue};
 use yew::prelude::*;
 
-use super::style_cache::StyleCache;
+use super::surface_sheet;
+
+/// Which prebuilt CSS bundle a [`StyleProvider`] adopts into its root.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
+pub enum StyleSurface {
+    /// The `<perspective-viewer>` ShadowRoot.
+    #[default]
+    Viewer,
+    /// Column-name completion dropdown (inverted color scheme).
+    ColumnDropdown,
+    /// Filter-value completion dropdown.
+    FilterDropdown,
+    /// Expression function-completion dropdown.
+    FunctionDropdown,
+    /// Copy / Export menu (non-inverted color scheme).
+    DropdownMenu,
+    /// Panel context menu (right-click a panel).
+    ContextMenu,
+}
 
 #[derive(Properties, PartialEq)]
 pub struct StyleProviderProps {
@@ -20,32 +39,48 @@ pub struct StyleProviderProps {
 
     #[prop_or(true)]
     pub is_shadow: bool,
+
+    #[prop_or_default]
+    pub surface: StyleSurface,
+
     pub children: Children,
 }
 
-/// A context which injects any CSS snippet registered within its tree, doing
-/// so only once for each unqiue snippet name.
-///
-/// CSS can be registered within sub-components via the `<LocalStyle>` component
-/// and `css!()` resource inlining macro.
-pub struct StyleProvider {
-    cache: StyleCache,
-}
+/// Adopts the build-time CSS bundle for its [`StyleSurface`] into the root's
+/// `adoptedStyleSheets` once, on creation. Unlike the previous per-snippet
+/// `LocalStyle` registration, children no longer register CSS individually.
+pub struct StyleProvider;
 
 impl Component for StyleProvider {
     type Message = ();
     type Properties = StyleProviderProps;
 
     fn create(ctx: &Context<Self>) -> Self {
-        let cache = StyleCache::new(ctx.props().is_shadow, &ctx.props().root);
-        Self { cache }
+        adopt_surface_sheet(ctx.props());
+        Self
     }
 
     fn view(&self, ctx: &Context<Self>) -> Html {
-        html! {
-            <ContextProvider<StyleCache> context={self.cache.clone()}>
-                { for ctx.props().children.iter() }
-            </ContextProvider<StyleCache>>
-        }
+        html! { <>{ for ctx.props().children.iter() }</> }
+    }
+}
+
+/// Push the surface's shared stylesheet onto the root's `adoptedStyleSheets`,
+/// unless it is already present (a root may host more than one provider).
+fn adopt_surface_sheet(props: &StyleProviderProps) {
+    let root: JsValue = if props.is_shadow {
+        props.root.shadow_root().unwrap().into()
+    } else {
+        web_sys::window().unwrap().document().unwrap().into()
+    };
+
+    let sheets = js_sys::Reflect::get(&root, &"adoptedStyleSheets".into())
+        .unwrap()
+        .unchecked_into::<js_sys::Array>();
+
+    let sheet = surface_sheet(props.surface);
+    let sheet_val: &JsValue = sheet.as_ref();
+    if sheets.index_of(sheet_val, 0) < 0 {
+        sheets.push(sheet_val);
     }
 }

package/src/rust/components/style_controls/number_string_format.rs

@@ -19,9 +19,7 @@ use perspective_client::config::ColumnType;
 pub use types::*;
 use yew::{Callback, Component, Properties, html};
 
-use crate::components::style::LocalStyle;
 use crate::config::*;
-use crate::css;
 
 #[derive(Properties, PartialEq, Clone)]
 pub struct CustomNumberFormatProps {
@@ -211,12 +209,7 @@ impl Component for CustomNumberFormat {
 
     fn view(&self, ctx: &yew::prelude::Context<Self>) -> yew::prelude::Html {
         html! {
-            <>
-                <LocalStyle href={css!("column-style")} />
-                { self.style_section(ctx) }
-                { self.digits_section(ctx) }
-                { self.misc_section(ctx) }
-            </>
+            <>{ self.style_section(ctx) }{ self.digits_section(ctx) }{ self.misc_section(ctx) }</>
         }
     }
 }

package/src/rust/components/type_icon.rs

@@ -14,9 +14,6 @@ use perspective_client::config::ColumnType;
 use yew::html::IntoPropValue;
 use yew::{Properties, classes, function_component, html};
 
-use crate::components::style::LocalStyle;
-use crate::css;
-
 #[derive(PartialEq, Debug, Clone, Copy)]
 pub enum TypeIconType {
     Type(ColumnType),
@@ -31,7 +28,7 @@ pub struct TypeIconProps {
 #[function_component(TypeIcon)]
 pub fn type_icon(p: &TypeIconProps) -> yew::Html {
     let class = classes!(p.ty.to_string(), "type-icon");
-    html! { <><LocalStyle href={css!("type-icon")} /><span {class} /></> }
+    html! { <><span {class} /></> }
 }
 
 impl From<ColumnType> for TypeIconType {

package/src/rust/components/viewer/filters.rs

@@ -0,0 +1,133 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+//! Master/detail cross-filtering handlers. The filter set itself is OWNED BY
+//! THE [`Workspace`] model (fed by master-panel selections via the
+//! `perspective-global-filter` listener in [`super::wiring`], surfaced as
+//! chips in the `StatusBar`); these handlers mutate it and run the
+//! [`apply_global_filters`] task. Re-renders flow through the workspace's
+//! `filters_changed` PubSub → `UpdateGlobalFilters` snapshot refresh.
+//!
+//! [`Workspace`]: crate::workspace::Workspace
+
+use yew::prelude::*;
+
+use super::PerspectiveViewer;
+use super::msg::MasterSelection;
+use crate::tasks::*;
+use crate::workspace::PanelId;
+
+impl PerspectiveViewer {
+    pub(super) fn on_toggle_master(&mut self, ctx: &Context<Self>, id: String) -> bool {
+        let id = PanelId::from(id);
+        let is_master = ctx.props().workspace.toggle_master(&id);
+        // Drive the panel's plugin into (out of) a selection mode so a
+        // master emits `perspective-global-filter` selections via the
+        // plugin's built-in select mechanism. No-op for plugins without
+        // an `edit_mode` (e.g. charts, which select intrinsically).
+        if let Some(panel) = ctx.props().workspace.panel(&id) {
+            let mode = if is_master {
+                "SELECT_ROW_TREE"
+            } else {
+                "READ_ONLY"
+            };
+            set_edit_mode(&panel.session, &panel.renderer, mode);
+        }
+        // Demoting a master back to detail retracts (only) its own
+        // contribution — other masters' clauses and any restored bucket
+        // survive. Promotion needs no filter mutation: the re-stamp below
+        // grants the new master immunity (and details keep filtering).
+        if !is_master {
+            ctx.props().workspace.clear_contribution(&id);
+        }
+        apply_global_filters(&ctx.props().workspace);
+        // Re-render regardless of a filter change — the context menu's
+        // "Master"/"Detail" label reads the toggled state.
+        true
+    }
+
+    pub(super) fn on_master_contribution(
+        &mut self,
+        ctx: &Context<Self>,
+        panel_id: String,
+        selection: Option<MasterSelection>,
+    ) -> bool {
+        // A master's selection state REPLACES its per-panel contribution to
+        // the element-level global filter set (`None` = deselected = clears
+        // it) — then surfaces in the bar and applies to the details. The
+        // re-render arrives via `filters_changed` → `UpdateGlobalFilters`.
+        // Contributions are keyed by the ORIGINATING panel, so removing them
+        // from the bar can clear its selection state. Non-master events
+        // (plain detail-panel selections/clicks) don't broadcast.
+        let workspace = &ctx.props().workspace;
+        let id = PanelId::from(panel_id);
+        if !workspace.is_master(&id) {
+            return false;
+        }
+
+        let filters = match selection {
+            None => Vec::new(),
+            Some(selection) => {
+                // Broadcast only the selection-DERIVED clauses: the event's
+                // filters embed the master's own stored `filter` field (a
+                // select detail's configs extend the panel config), which
+                // must not leak into the details — subtract it. (Live `Ref`
+                // guard — scope it to this statement.)
+                let own = workspace
+                    .panel(&id)
+                    .map(|p| p.session.get_view_config().filter.clone())
+                    .unwrap_or_default();
+
+                let derived = selection
+                    .filters
+                    .into_iter()
+                    .filter(|x| !own.contains(x))
+                    .collect::<Vec<_>>();
+
+                if !derived.is_empty() {
+                    derived
+                } else {
+                    // Nothing derivable from the event's configs — fall back
+                    // to the clicked-cell clause if the detail carried one,
+                    // else leave the current contribution untouched.
+                    match selection.cell_fallback {
+                        Some(x) => vec![x],
+                        None => return false,
+                    }
+                }
+            },
+        };
+
+        workspace.set_contribution(&id, filters);
+        apply_global_filters(workspace);
+        false
+    }
+
+    pub(super) fn on_remove_global_filter(&mut self, ctx: &Context<Self>, index: usize) -> bool {
+        let workspace = &ctx.props().workspace;
+        let origins = workspace.remove_global_filter(index);
+        apply_global_filters(workspace);
+        // The chip's clause is gone — the master selection(s) that produced
+        // it must not stay highlighted, implying a filter that no longer
+        // exists. (Restored/unattributed clauses have no origin — no-op.)
+        clear_master_selections(workspace, origins);
+        false
+    }
+
+    pub(super) fn on_clear_global_filters(&mut self, ctx: &Context<Self>) -> bool {
+        let workspace = &ctx.props().workspace;
+        let origins = workspace.clear_global_filters();
+        apply_global_filters(workspace);
+        clear_master_selections(workspace, origins);
+        false
+    }
+}

package/src/rust/components/viewer/msg.rs

@@ -0,0 +1,180 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+//! The root component's message protocol. One flat enum — the `update()` match
+//! in `viewer.rs` is its dispatch table; handler bodies live in the sibling
+//! domain modules ([`super::panels`], [`super::settings`], [`super::filters`],
+//! [`super::snapshots`]).
+
+use futures::channel::oneshot::Sender;
+use perspective_client::config::Filter;
+use perspective_js::utils::ApiResult;
+use wasm_bindgen::JsValue;
+
+use crate::components::settings_panel::SelectedTab;
+use crate::config::*;
+use crate::presentation::{ColumnLocator, ColumnSettingsTab, DragDropProps, PresentationProps};
+use crate::renderer::RendererProps;
+use crate::session::{SessionProps, TableLoadState, ViewStats};
+use crate::utils::Completion;
+
+/// The filter-bearing payload of a master panel's selection or click event
+/// (`MasterContribution`), as decoded by the host listeners in
+/// [`super::wiring`].
+#[derive(Debug)]
+pub struct MasterSelection {
+    /// The event's filter clauses (`insertFilters` for the select-detail
+    /// family, `config.filter` for clicks) — BEFORE the master's own stored
+    /// filters are subtracted (see `on_master_contribution`).
+    pub filters: Vec<Filter>,
+
+    /// A synthesized clicked-cell `[column, "==", value]` clause, used when
+    /// `filters` derives to nothing — e.g. a FLAT (un-grouped) datagrid
+    /// master, whose clicks carry no group-by path to filter on.
+    pub cell_fallback: Option<Filter>,
+}
+
+#[derive(Debug)]
+pub enum PerspectiveViewerMsg {
+    ColumnSettingsPanelSizeUpdate(Option<i32>),
+    ColumnSettingsTabChanged(ColumnSettingsTab),
+    OpenColumnSettings {
+        locator: Option<ColumnLocator>,
+        sender: Option<Sender<()>>,
+        toggle: bool,
+    },
+    PreloadFontsUpdate,
+
+    /// Element-level reset (the public `reset()` API): reset EVERY panel and
+    /// clear the cross-filter overlay, symmetric with whole-element
+    /// `save`/`restore`. The `bool` also clears expressions/column settings.
+    Reset(bool, Option<Completion>),
+
+    /// Reset ONLY the named panel — or the active panel when `None` — to its
+    /// default `ViewerConfig` (the toolbar Reset button, the context menu's
+    /// "Reset" command, and the public `resetPanel()` API). The `bool` is
+    /// `Reset`'s expressions flag (toolbar shift-click); the `Completion`
+    /// resolves the `resetPanel()` promise after the reset's run completes
+    /// (invariant I6).
+    ResetPanel(Option<String>, bool, Option<Completion>),
+    Resize,
+
+    /// The set of layout panels changed (added/removed); re-render so the
+    /// layout host reconciles its `<regular-layout>` cells.
+    LayoutChanged,
+
+    /// Make the named panel active: re-target the settings panel + status bar
+    /// (and the root's session/renderer subscriptions) to its engines. The
+    /// `Completion` resolves `setActivePanel()` after the activation-chrome
+    /// nudge runs complete (invariant I6).
+    SetActivePanel(String, Option<Completion>),
+
+    /// The named panel's frame was closed (removed from the layout); remove it
+    /// from the workspace and dispose its engines. The `Completion` resolves
+    /// `removePanel()` after the eject's teardown run completes (invariant
+    /// I6) — carrying any teardown error, which was previously dropped.
+    ClosePanel(String, Option<Completion>),
+
+    /// Whole-element `restore` finished replacing the panel set in the
+    /// `Workspace` (new models inserted, old panels ejected, layout staged):
+    /// activate the named panel, re-subscribe the per-panel wiring, and
+    /// re-render — the SINGLE visible commit of the whole restore.
+    CommitWorkspaceRestore(String),
+
+    /// Duplicate the named panel: snapshot its config into a new independent
+    /// panel appended to the layout.
+    DuplicatePanel(String),
+
+    /// New panel: a fresh (default-config) panel bound to the named panel's
+    /// table (from the default client).
+    NewPanel(String),
+
+    /// New panel bound to the named `Table` on the named `Client` (the
+    /// context menu's "New" sub-menu). The `Client` is resolved by name from
+    /// the `Workspace` loaded-clients registry.
+    NewPanelFrom {
+        client: String,
+        table: String,
+    },
+
+    /// Toggle the named panel's master/detail (filter-source) role.
+    ToggleMaster(String),
+
+    /// A master panel's selection state, from EITHER host listener
+    /// (`perspective-global-filter` select/deselect or `perspective-click`):
+    /// `Some` REPLACES that panel's global-filter contribution, `None`
+    /// (deselect) clears it. Non-master sources are ignored by the handler.
+    MasterContribution(String, Option<MasterSelection>),
+
+    /// Remove the global filter at this index (GlobalFilterBar chip ×).
+    RemoveGlobalFilter(usize),
+
+    /// Clear all global filters (GlobalFilterBar "Clear").
+    ClearGlobalFilters,
+
+    /// Some panel's title changed (any panel, via `_title_subscriptions`);
+    /// re-render so the tab titles refresh.
+    TitlesChanged,
+    SettingsPanelSizeUpdate(Option<i32>),
+
+    /// The settings-pane divider proposed a new pane width (per pointermove,
+    /// from the *deferred* `SplitPanel` — it has NOT been applied). Feeds the
+    /// latest-wins presize pump (`PRESIZE_EVERYWHERE_PLAN.md` P1): geometry
+    /// commits only after every visible panel has rendered at its target.
+    SettingsDividerMove(i32),
+
+    /// Run one pump iteration: presize all visible panels at the newest
+    /// proposed pane width, then commit it.
+    SettingsDividerPump,
+
+    /// Presize for this pane width completed — commit it (the deferred
+    /// `SplitPanel`'s controlled `size`), then pump again if a newer target
+    /// arrived meanwhile.
+    SettingsDividerCommit(i32),
+
+    /// Divider drag ended: reactively finalize every visible panel at its
+    /// exact settled cell (debounced no-op when the presizes were exact).
+    SettingsDividerFinish,
+    SettingsPanelTabChanged(SelectedTab),
+    SettingsPanelAutoWidth(f64),
+    ToggleDebug,
+    ToggleSettingsComplete(SettingsUpdate, Sender<()>),
+    ToggleSettingsInit(Option<SettingsUpdate>, Option<Sender<ApiResult<JsValue>>>),
+    UpdateSession(Box<SessionProps>),
+    UpdateRenderer(Box<RendererProps>),
+    UpdatePresentation(Box<PresentationProps>),
+
+    /// Update only `is_settings_open` in the presentation snapshot without
+    /// touching `available_themes` (which requires async data).
+    UpdateSettingsOpen(bool),
+    UpdateIsWorkspace(bool),
+
+    /// Update only `open_column_settings` in the presentation snapshot.
+    UpdateColumnSettings(Box<crate::presentation::OpenColumnSettings>),
+    UpdateDragDrop(Box<DragDropProps>),
+
+    /// Update only stats-related fields of `session_props` without touching
+    /// `config`.  This prevents `stats_changed` events (e.g. from `reset()`)
+    /// from propagating a freshly-cleared config to the column selector.
+    UpdateSessionStats(Option<ViewStats>, Option<TableLoadState>),
+
+    /// Refresh the root's render snapshot of the `Workspace`-owned global
+    /// filter set (dispatched by its `filters_changed` PubSub).
+    UpdateGlobalFilters,
+
+    /// The active panel's in-flight config-run count changed. LEVEL-
+    /// triggered: the payload is the ABSOLUTE count (RAII-settled — see
+    /// `Session::begin_config_run`), which the handler ASSIGNS to
+    /// `update_count`; there is no delta arithmetic to drift. Threaded to
+    /// `StatusIndicator` as the "updating" spinner.
+    UpdateInFlight(u32),
+}