@perspective-dev/viewer 4.5.2 → 5.0.0

package/src/rust/custom_events.rs

@@ -10,10 +10,12 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
-//! Wire engine PubSub fanout to JavaScript `CustomEvent` dispatch on the host
-//! element. [`wire_custom_events`] is the single subscription site; every
-//! `perspective-*` `CustomEvent` originates from a PubSub fire on `Session`,
-//! `Renderer`, or `Presentation`.
+//! Wire engine PubSub fanout to JavaScript `CustomEvent` dispatch. Split into
+//! [`wire_element_events`] (element-level, `Presentation`-driven, wired once)
+//! and [`wire_panel_events`] (one panel's `Session`/`Renderer`, wired per
+//! panel and owned by the `Panel`). Every `perspective-*` `CustomEvent`
+//! originates from a PubSub fire; per-panel events dispatch on the originating
+//! panel's plugin so `event.target` identifies the panel.
 
 use perspective_client::{ViewWindow, clone};
 use perspective_js::json;
@@ -27,6 +29,7 @@ use crate::queries::get_viewer_config;
 use crate::renderer::{ColumnConfigMap, Renderer};
 use crate::session::Session;
 use crate::utils::{AddListener, Subscription};
+use crate::workspace::Workspace;
 
 /// Dispatch a JS `CustomEvent` named `perspective-{name}` on `elem`.
 fn dispatch_event<T: Into<JsValue>>(elem: &HtmlElement, name: &str, event: T) -> ApiResult<()> {
@@ -41,7 +44,57 @@ fn dispatch_event<T: Into<JsValue>>(elem: &HtmlElement, name: &str, event: T) ->
     Ok(())
 }
 
+/// The event target for a panel's events: the panel's own plugin element (so
+/// `event.target`/`composedPath()` carries its `slot=<panel-id>`, identifying
+/// the originating panel), falling back to the host when no plugin is drawn.
+/// Events dispatched here bubble to the host, so element-level listeners still
+/// fire.
+fn panel_target(elem: &HtmlElement, renderer: &Renderer) -> EventTarget {
+    renderer
+        .active_plugin()
+        .filter(|plugin| elem.contains(Some(plugin.unchecked_ref::<web_sys::Node>())))
+        .map(|plugin| plugin.unchecked_into::<EventTarget>())
+        .unwrap_or_else(|| elem.clone().unchecked_into())
+}
+
+/// Dispatch a `perspective-{name}` `CustomEvent` for a single panel — on the
+/// panel's plugin (see [`panel_target`]), bubbling + composed so it reaches the
+/// host. The originating panel is identifiable from `event.target`; `detail`
+/// shapes are otherwise unchanged from the single-panel case.
+fn dispatch_panel_event(
+    elem: &HtmlElement,
+    renderer: &Renderer,
+    name: &str,
+    detail: &JsValue,
+) -> ApiResult<()> {
+    let event_init = web_sys::CustomEventInit::new();
+    event_init.set_detail(detail);
+    event_init.set_bubbles(true);
+    event_init.set_composed(true);
+    let event = web_sys::CustomEvent::new_with_event_init_dict(
+        format!("perspective-{}", name).as_str(),
+        &event_init,
+    )?;
+
+    panel_target(elem, renderer).dispatch_event(&event)?;
+    Ok(())
+}
+
+/// Annotate an object `detail` with its originating panel id (`detail.panel`),
+/// for the events whose detail is a plain JSON object (`select`,
+/// `column-style-change`). Additive — existing single-panel listeners reading
+/// the prior fields are unaffected; skipped when `detail` isn't an object (e.g.
+/// a null selection) or the panel has no slot.
+fn annotate_panel(detail: &JsValue, renderer: &Renderer) {
+    if detail.is_object()
+        && let Some(id) = renderer.slot_name()
+    {
+        let _ = js_sys::Reflect::set(detail, &JsValue::from_str("panel"), &JsValue::from_str(&id));
+    }
+}
+
 fn dispatch_column_settings_open_changed(
+    workspace: &Workspace,
     elem: &HtmlElement,
     open: bool,
     column_name: Option<String>,
@@ -50,28 +103,47 @@ fn dispatch_column_settings_open_changed(
     event_init.set_detail(&JsValue::from(
         json!({"open": open, "column_name": column_name}),
     ));
+    // Bubble so the event still reaches the host (and any public listeners) even
+    // though it's dispatched on a panel's plugin below it.
+    event_init.set_bubbles(true);
     let event = web_sys::CustomEvent::new_with_event_init_dict(
         "perspective-toggle-column-settings",
         &event_init,
-    );
+    )
+    .unwrap();
 
-    elem.dispatch_event(&event.unwrap()).unwrap();
-}
+    // Dispatch on the ACTIVE panel's plugin, not the shared host. The merged
+    // viewer hosts every panel's plugin under one element, and each datagrid
+    // listens for this event on itself — so dispatching on the host (which the
+    // event bubbles to) would highlight EVERY datagrid. The column settings
+    // apply to the active panel, so scope the highlight to its plugin; fall back
+    // to the host if none is drawn.
+    let target: web_sys::EventTarget = workspace
+        .active_id()
+        .and_then(|id| workspace.panel(&id))
+        .and_then(|panel| panel.renderer.active_plugin())
+        .map(|plugin| plugin.unchecked_into())
+        .unwrap_or_else(|| elem.clone().unchecked_into());
 
-fn dispatch_plugin_changed(elem: &HtmlElement, plugin: &JsPerspectiveViewerPlugin) {
-    let event_init = web_sys::CustomEventInit::new();
-    event_init.set_detail(plugin);
-    let event =
-        web_sys::CustomEvent::new_with_event_init_dict("perspective-plugin-update", &event_init);
+    target.dispatch_event(&event).unwrap();
+}
 
-    elem.dispatch_event(&event.unwrap()).unwrap();
+fn dispatch_plugin_changed(
+    elem: &HtmlElement,
+    renderer: &Renderer,
+    plugin: &JsPerspectiveViewerPlugin,
+) {
+    // Detail is the plugin element itself (identity is via `event.target`, the
+    // panel's plugin — see `panel_target`).
+    let _ = dispatch_panel_event(elem, renderer, "plugin-update", plugin.as_ref());
 }
 
-/// Per-element memoized config-change dispatcher. Reads/writes the dedup
-/// cell on `presentation.last_dispatched_config` so each viewer instance
-/// has its own cache — without this, a second viewer reloading the same
-/// table the first viewer used would have its initial `config-update`
-/// suppressed.
+/// Per-panel memoized config-change dispatcher. The dedup cell now lives on the
+/// `Session` (per panel) rather than the `Presentation` (per element), so N
+/// panels don't cross-suppress each other's `config-update`s. The event is
+/// dispatched on the panel's plugin (bubbling to the host), so `event.target`
+/// identifies the panel; `detail` remains the bare [`ViewerConfig`] — NOT
+/// wrapped — so `viewer.restore(e.detail)` round-trips unchanged.
 fn dispatch_config_update(
     elem: &HtmlElement,
     session: &Session,
@@ -80,47 +152,77 @@ fn dispatch_config_update(
 ) {
     clone!(session, renderer, presentation);
     let elem = elem.clone();
-    perspective_js::utils::ApiFuture::spawn(async move {
-        let viewer_config = get_viewer_config(&session, &renderer, &presentation).await?;
+    let tracker = session.clone();
+    tracker.track_dispatch(async move {
+        let viewer_config = renderer
+            .clone()
+            .with_lock(async { get_viewer_config(&session, &renderer, &presentation).await })
+            .await?;
+
         if viewer_config.view_config != Default::default()
-            && Some(&viewer_config) != presentation.last_dispatched_config.borrow().as_ref()
+            && Some(&viewer_config) != session.last_dispatched_config.borrow().as_deref()
         {
-            let json_config = JsValue::from_serde_ext(&viewer_config)?;
+            let viewer_config = std::rc::Rc::new(viewer_config);
+            *session.last_dispatched_config.borrow_mut() = Some(viewer_config.clone());
+            let memo = std::cell::RefCell::new(None);
+            let get_config = Closure::<dyn Fn() -> Result<JsValue, JsValue>>::new(move || {
+                let mut memo = memo.borrow_mut();
+                if memo.is_none() {
+                    *memo = Some(JsValue::from_serde_ext(&*viewer_config).map_err(JsValue::from)?);
+                }
+
+                Ok(memo.as_ref().unwrap().clone())
+            });
+
+            let detail = js_sys::Object::new();
+            js_sys::Reflect::set(
+                &detail,
+                &JsValue::from_str("getConfig"),
+                get_config.as_ref(),
+            )?;
             let event_init = web_sys::CustomEventInit::new();
-            event_init.set_detail(&json_config);
+            event_init.set_detail(&detail);
+            event_init.set_bubbles(true);
+            event_init.set_composed(true);
             let event = web_sys::CustomEvent::new_with_event_init_dict(
                 "perspective-config-update",
                 &event_init,
-            );
+            )?;
 
-            *presentation.last_dispatched_config.borrow_mut() = Some(viewer_config);
-            elem.dispatch_event(&event.unwrap()).unwrap();
+            panel_target(&elem, &renderer).dispatch_event(&event)?;
+            drop(get_config);
         }
 
         Ok(())
     });
 }
 
-/// Wire PubSub channels on `session`, `renderer`, and `presentation` to the
-/// `perspective-*` `CustomEvent` set on `elem`. The returned
-/// `Vec<Subscription>` must be kept alive for the lifetime of the element;
-/// dropping it detaches all listeners.
-pub fn wire_custom_events(
+/// Wire the ELEMENT-level PubSub channels (`Presentation`-driven, not tied to
+/// any one panel) to the `perspective-*` `CustomEvent` set on `elem`. Wired
+/// ONCE for the element's lifetime. The config-update-bearing events
+/// (theme/settings) emit for the **active** panel, resolved from `workspace`
+/// at fire time. The returned `Vec<Subscription>` must outlive the element.
+pub fn wire_element_events(
     elem: &HtmlElement,
-    session: &Session,
-    renderer: &Renderer,
     presentation: &Presentation,
+    workspace: &Workspace,
 ) -> Vec<Subscription> {
     let theme_sub = presentation.theme_config_updated.add_listener({
-        clone!(elem, session, renderer, presentation);
-        move |_| dispatch_config_update(&elem, &session, &renderer, &presentation)
+        clone!(elem, presentation, workspace);
+        move |_| {
+            if let Some(panel) = workspace.active_panel() {
+                dispatch_config_update(&elem, &panel.session, &panel.renderer, &presentation);
+            }
+        }
     });
 
     let settings_sub = presentation.settings_open_changed.add_listener({
-        clone!(elem, session, renderer, presentation);
+        clone!(elem, presentation, workspace);
         move |open: bool| {
             dispatch_event(&elem, "toggle-settings", open).unwrap();
-            dispatch_config_update(&elem, &session, &renderer, &presentation);
+            if let Some(panel) = workspace.active_panel() {
+                dispatch_config_update(&elem, &panel.session, &panel.renderer, &presentation);
+            }
         }
     });
 
@@ -132,22 +234,73 @@ pub fn wire_custom_events(
     });
 
     let column_settings_sub = presentation.column_settings_open_changed.add_listener({
-        clone!(elem);
+        clone!(elem, workspace);
         move |(open, column_name)| {
-            dispatch_column_settings_open_changed(&elem, open, column_name);
+            dispatch_column_settings_open_changed(&workspace, &elem, open, column_name);
             // column_settings is ethereal; do not change the config
         }
     });
 
+    let statusbar_ptr_sub = presentation.statusbar_pointer_event.add_listener({
+        clone!(elem);
+        move |event: PointerEvent| {
+            dispatch_event(&elem, &format!("statusbar-{}", event.type_()), &event).unwrap();
+        }
+    });
+
+    // The element-level global (cross-) filter set changed — masters'
+    // selections, chip × / "Clear", role toggles, restore. `detail` is the
+    // flattened `Vec<Filter>`; deliberately NOT `perspective-config-update`
+    // (these filters are invisible to every panel's config by design).
+    let global_filters_sub = workspace.filters_changed().add_listener({
+        clone!(elem, workspace);
+        move |_: ()| {
+            let filters =
+                JsValue::from_serde_ext(&workspace.global_filters()).expect("serializable filters");
+            dispatch_event(&elem, "global-filter-update", filters).unwrap();
+        }
+    });
+
+    vec![
+        theme_sub,
+        before_settings_sub,
+        settings_sub,
+        column_settings_sub,
+        statusbar_ptr_sub,
+        global_filters_sub,
+    ]
+}
+
+/// Wire ONE panel's `session`/`renderer` PubSub channels to the
+/// `perspective-*` `CustomEvent` set, dispatched on that panel's plugin (so
+/// `event.target` identifies the panel — see [`dispatch_panel_event`]). Called
+/// per panel at creation; the returned subscriptions are owned by the `Panel`
+/// and drop when it is removed, so every panel (seed, `addPanel`, restored)
+/// fires its own events and non-active panels are no longer silent.
+///
+/// Needs no `Workspace`: each handler acts on its own `session`/`renderer`, and
+/// the panel id for annotation is read from `renderer.slot_name()` at fire
+/// time.
+pub fn wire_panel_events(
+    elem: &HtmlElement,
+    session: &Session,
+    renderer: &Renderer,
+    presentation: &Presentation,
+) -> Vec<Subscription> {
     let plugin_sub = renderer.plugin_changed.add_listener({
         clone!(elem, session, renderer, presentation);
         move |plugin| {
-            dispatch_plugin_changed(&elem, &plugin);
+            dispatch_plugin_changed(&elem, &renderer, &plugin);
             dispatch_config_update(&elem, &session, &renderer, &presentation);
         }
     });
 
-    let view_sub = session.view_created.add_listener({
+    // `commit_reconciled` (NOT `view_created`): the config-update event must
+    // fire for every reconciled commit — including SKIP/REUSE/paused binds
+    // that construct no `View` — or `flush()` has nothing to join (the
+    // paused-`load()` case). The dispatcher dedups, so REBUILD's pairing
+    // with `view_created` can't double-fire it.
+    let view_sub = session.commit_reconciled.add_listener({
         clone!(elem, session, renderer, presentation);
         move |_| dispatch_config_update(&elem, &session, &renderer, &presentation)
     });
@@ -158,13 +311,14 @@ pub fn wire_custom_events(
     });
 
     let unload_sub = session.table_unloaded.add_listener({
-        clone!(elem);
+        clone!(elem, renderer);
         move |x: bool| {
-            if !x {
-                dispatch_event(&elem, "table-delete-before", JsValue::UNDEFINED).unwrap();
+            let name = if !x {
+                "table-delete-before"
             } else {
-                dispatch_event(&elem, "table-delete", JsValue::UNDEFINED).unwrap()
-            }
+                "table-delete"
+            };
+            let _ = dispatch_panel_event(&elem, &renderer, name, &JsValue::UNDEFINED);
         }
     });
 
@@ -172,7 +326,8 @@ pub fn wire_custom_events(
         clone!(elem, session, renderer, presentation);
         move |window: Option<ViewWindow>| {
             let detail = JsValue::from_serde_ext(&window).unwrap();
-            dispatch_event(&elem, "select", &detail).unwrap();
+            annotate_panel(&detail, &renderer);
+            let _ = dispatch_panel_event(&elem, &renderer, "select", &detail);
             dispatch_config_update(&elem, &session, &renderer, &presentation);
         }
     });
@@ -181,28 +336,25 @@ pub fn wire_custom_events(
         clone!(elem, session, renderer, presentation);
         move |cfg: ColumnConfigMap| {
             let detail = JsValue::from_serde_ext(&cfg).unwrap();
-            dispatch_event(&elem, "column-style-change", &detail).unwrap();
+            annotate_panel(&detail, &renderer);
+            let _ = dispatch_panel_event(&elem, &renderer, "column-style-change", &detail);
             dispatch_config_update(&elem, &session, &renderer, &presentation);
         }
     });
 
     let status_click_sub = session.status_indicator_clicked.add_listener({
-        clone!(elem);
-        move |_| dispatch_event(&elem, "status-indicator-click", JsValue::UNDEFINED).unwrap()
-    });
-
-    let statusbar_ptr_sub = presentation.statusbar_pointer_event.add_listener({
-        clone!(elem);
-        move |event: PointerEvent| {
-            dispatch_event(&elem, &format!("statusbar-{}", event.type_()), &event).unwrap();
+        clone!(elem, renderer);
+        move |_| {
+            let _ = dispatch_panel_event(
+                &elem,
+                &renderer,
+                "status-indicator-click",
+                &JsValue::UNDEFINED,
+            );
         }
     });
 
     vec![
-        theme_sub,
-        before_settings_sub,
-        settings_sub,
-        column_settings_sub,
         plugin_sub,
         view_sub,
         title_sub,
@@ -210,6 +362,5 @@ pub fn wire_custom_events(
         select_sub,
         column_style_sub,
         status_click_sub,
-        statusbar_ptr_sub,
     ]
 }

package/src/rust/js/mod.rs

@@ -19,10 +19,12 @@ pub mod clipboard_item;
 mod intersection_observer;
 mod mimetype;
 pub mod plugin;
+pub mod regular_layout;
 pub mod resize_observer;
 
 pub use self::clipboard::*;
 pub use self::intersection_observer::*;
 pub use self::mimetype::*;
 pub use self::plugin::*;
+pub use self::regular_layout::*;
 pub use self::resize_observer::*;