@perspective-dev/viewer 5.5.1 → 5.6.0

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

@@ -28,11 +28,12 @@ use super::wiring::{
     subscribe_panel_titles,
 };
 use crate::config::ViewerConfigInitial;
+use crate::derived::suggest_name;
 use crate::queries::*;
 use crate::renderer::Renderer;
 use crate::session::*;
 use crate::tasks::*;
-use crate::utils::{Completion, spawn_owned};
+use crate::utils::{Completion, PtrEqRc, spawn_owned};
 use crate::workspace::{Panel, PanelId};
 
 impl PerspectiveViewer {
@@ -215,7 +216,9 @@ impl PerspectiveViewer {
             let workspace = ctx.props().workspace.clone();
             let notify = ctx.link().callback(|_: ()| LayoutChanged);
             let activate = ctx.link().callback(|id| SetActivePanel(id, None));
+            let effect = workspace.effects().guard();
             ApiFuture::spawn(async move {
+                let _effect = effect;
                 let config = panel
                     .renderer
                     .clone()
@@ -247,6 +250,39 @@ impl PerspectiveViewer {
         false
     }
 
+    pub(super) fn on_derive_panel(&mut self, ctx: &Context<Self>, id: String) -> bool {
+        if let Some(panel) = ctx.props().workspace.panel(&PanelId::from(id)) {
+            let presentation = ctx.props().presentation.clone();
+            let workspace = ctx.props().workspace.clone();
+            let effect = workspace.effects().guard();
+            ApiFuture::spawn(async move {
+                let _effect = effect;
+                let config = PtrEqRc::new(panel.session.get_view_config().clone());
+                let table = panel.session.get_table().map(|x| x.get_name().to_owned());
+                let name = suggest_name(
+                    &fetch_hosted_tables(&workspace)
+                        .await
+                        .into_iter()
+                        .flat_map(|(_, tables)| tables)
+                        .collect(),
+                    &config,
+                    &table,
+                );
+
+                create_derived(
+                    &panel.session,
+                    &panel.renderer,
+                    &presentation,
+                    &workspace,
+                    name,
+                )
+                .await
+            });
+        }
+
+        false
+    }
+
     pub(super) fn on_new_panel(&mut self, ctx: &Context<Self>, id: String) -> bool {
         if let Some(panel) = ctx.props().workspace.panel(&PanelId::from(id)) {
             let Some(table_name) = panel.session.get_table().map(|t| t.get_name().to_owned())
@@ -260,7 +296,9 @@ impl PerspectiveViewer {
             let workspace = ctx.props().workspace.clone();
             let notify = ctx.link().callback(|_: ()| LayoutChanged);
             let activate = ctx.link().callback(|id| SetActivePanel(id, None));
+            let effect = workspace.effects().guard();
             ApiFuture::spawn(async move {
+                let _effect = effect;
                 let client = panel.session.get_client();
                 let new_id = create_panel(
                     &elem,
@@ -306,7 +344,9 @@ impl PerspectiveViewer {
         let workspace = ctx.props().workspace.clone();
         let notify = ctx.link().callback(|_: ()| LayoutChanged);
         let activate = ctx.link().callback(|id| SetActivePanel(id, None));
+        let effect = workspace.effects().guard();
         ApiFuture::spawn(async move {
+            let _effect = effect;
             let new_id = create_panel(
                 &elem,
                 &presentation,

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

@@ -179,6 +179,7 @@ impl PerspectiveViewer {
                             vec![NewPanelFrom { client, table }]
                         },
                         PanelCommand::Duplicate => vec![DuplicatePanel(id)],
+                        PanelCommand::Derive => vec![DerivePanel(id)],
                         PanelCommand::NewFromPanel(source) => vec![DuplicatePanel(source)],
                         PanelCommand::Reset => vec![ResetPanel(Some(id), false, None)],
                         PanelCommand::ToggleMaster => vec![ToggleMaster(id)],

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

@@ -200,8 +200,6 @@ impl PerspectiveViewer {
                     ToggleSettingsComplete(update, resolve)
                 });
 
-                // P2: at CLOSE time the open-state geometry is measurable —
-                // cache the deltas the next OPEN needs to presize with.
                 if is_open {
                     self.settings_geometry.open_deltas =
                         measure_settings_open_deltas(&ctx.props().elem);
@@ -213,16 +211,6 @@ impl PerspectiveViewer {
                 let elem = ctx.props().elem.clone();
 
                 ApiFuture::spawn(async move {
-                    // Resize every visible plugin (not just the active one) to its
-                    // new cell as the settings pane toggles. The pane is the outer
-                    // SplitPanel, which emits no `before-resize`, so this is driven
-                    // explicitly here. CLOSING grows the cells, so pre-size each
-                    // plugin to its grown box BEFORE collapsing the pane; OPENING
-                    // shrinks them, so pre-size to the shrunk box (from the deltas
-                    // cached at the last close; the first-ever open has none and
-                    // stays reactive) BEFORE the pane mounts — either way, one
-                    // clean resize with the reactive pass after as the exactness
-                    // finalizer.
                     let result: ApiResult<JsValue> = async {
                         if is_open {
                             let presents = presize_visible_panels_grown(&workspace, &elem).await;
@@ -230,17 +218,7 @@ impl PerspectiveViewer {
                             callback.emit(notify);
                             presentation.set_settings_open(false, announce);
                             rendered.await?;
-                            // `notify` fires in `rendered()` (same task as the
-                            // Yew DOM patch) and this future resumes as one of
-                            // its microtasks — so the staged reveal below and
-                            // the pane's geometry change reach the screen in a
-                            // single paint.
                             presents.reveal();
-                            // I6: the exactness-finalizer resize is part of
-                            // what this toggle caused — await it here rather
-                            // than leaving it to the ResizeObserver (whose
-                            // continuous pass remains as the reactive
-                            // backstop).
                             resize_visible_panels(&workspace).await;
                         } else {
                             let presents = if let Some((delta_w, delta_h)) = open_deltas {

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

@@ -23,7 +23,7 @@ use super::PerspectiveViewer;
 use crate::presentation::{DragDropProps, PresentationProps};
 use crate::renderer::RendererProps;
 use crate::session::{SessionProps, TableLoadState};
-use crate::tasks::resize_visible_panels;
+use crate::tasks::{resize_visible_panels, submit_theme};
 
 impl PerspectiveViewer {
     pub(super) fn refresh_session_snapshot(&mut self, ctx: &Context<Self>) {
@@ -105,7 +105,7 @@ impl PerspectiveViewer {
                     continue;
                 }
 
-                panel.renderer.set_theme(new_default.clone());
+                submit_theme(&panel.session, &panel.renderer, new_default.clone());
                 if panel.renderer.needs_restyle() {
                     let renderer = panel.renderer.clone();
                     crate::utils::spawn_owned("default-theme-restyle", async move {

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

@@ -53,6 +53,7 @@ impl Drop for ShiftListeners {
             win.remove_event_listener_with_callback("keyup", self.keyup.as_ref().unchecked_ref());
         let _ = win.remove_event_listener_with_callback("blur", self.blur.as_ref().unchecked_ref());
         let _ = self.elem.class_list().remove_1("shift-active");
+        crate::utils::stamp_plugin_host_state_all(&self.elem);
     }
 }
 
@@ -62,6 +63,7 @@ pub(super) fn install_shift_listeners(elem: web_sys::HtmlElement) -> ShiftListen
         Closure::wrap(Box::new(move |event: KeyboardEvent| {
             if event.key() == "Shift" {
                 let _ = elem.class_list().add_1("shift-active");
+                crate::utils::stamp_plugin_host_state_all(&elem);
             }
         }) as Box<dyn FnMut(KeyboardEvent)>)
     };
@@ -71,6 +73,7 @@ pub(super) fn install_shift_listeners(elem: web_sys::HtmlElement) -> ShiftListen
         Closure::wrap(Box::new(move |event: KeyboardEvent| {
             if event.key() == "Shift" {
                 let _ = elem.class_list().remove_1("shift-active");
+                crate::utils::stamp_plugin_host_state_all(&elem);
             }
         }) as Box<dyn FnMut(KeyboardEvent)>)
     };
@@ -79,6 +82,7 @@ pub(super) fn install_shift_listeners(elem: web_sys::HtmlElement) -> ShiftListen
         let elem = elem.clone();
         Closure::wrap(Box::new(move |_: FocusEvent| {
             let _ = elem.class_list().remove_1("shift-active");
+            crate::utils::stamp_plugin_host_state_all(&elem);
         }) as Box<dyn FnMut(FocusEvent)>)
     };
 
@@ -446,6 +450,15 @@ pub(super) fn inject_active_callbacks(
 
         *renderer.on_render_limits_changed.borrow_mut() = Some(cb);
     }
+
+    {
+        let r = renderer.clone();
+        let cb = ctx
+            .link()
+            .callback(move |_: ()| UpdateRenderer(Box::new(r.to_props(None))));
+
+        *renderer.on_render_failure_changed.borrow_mut() = Some(cb);
+    }
 }
 
 /// Clear the active panel's session/renderer direct callbacks so a
@@ -454,6 +467,7 @@ pub(super) fn clear_active_callbacks(session: &Session, renderer: &Renderer) {
     *session.on_stats_changed.borrow_mut() = None;
     *session.on_table_errored.borrow_mut() = None;
     *renderer.on_render_limits_changed.borrow_mut() = None;
+    *renderer.on_render_failure_changed.borrow_mut() = None;
 }
 
 /// Inject element-level (shared) presentation callbacks. Created once at

package/src/rust/components/viewer.rs

@@ -246,26 +246,37 @@ impl Component for PerspectiveViewer {
                 // config, so they survive. The `Completion`
                 // resolves only after ALL panels' reset runs complete
                 // (invariant I6 — previously it rode the active panel only,
-                // and the other panels' runs were unowned).
-                let workspace = &ctx.props().workspace;
+                // and the other panels' runs were unowned). An "all" reset
+                // FIRST purges the element's derived state (releasing any
+                // derived-bound panel to its root table), so the per-panel
+                // resets run against the surviving base bindings.
+                let workspace = ctx.props().workspace.clone();
+                let presentation = ctx.props().presentation.clone();
                 let origins = workspace.clear_global_filters();
-                clear_master_selections(workspace, origins);
-                let mut tasks = Vec::new();
-                for (id, panel) in workspace
-                    .panel_ids()
-                    .into_iter()
-                    .filter_map(|id| workspace.panel(&id).map(|p| (id, p)))
-                {
-                    stamp_global_overlay(workspace, &id, &panel.session);
-                    tasks.push(reset_all(
-                        &panel.session,
-                        &panel.renderer,
-                        &ctx.props().presentation,
-                        all,
-                    ));
-                }
-
+                clear_master_selections(&workspace, origins);
+                let effect = workspace.effects().guard();
                 let run = async move {
+                    let _effect = effect;
+                    if all {
+                        crate::tasks::purge_derived(&workspace, &presentation).await?;
+                    }
+
+                    let mut tasks = Vec::new();
+                    for (id, panel) in workspace
+                        .panel_ids()
+                        .into_iter()
+                        .filter_map(|id| workspace.panel(&id).map(|p| (id, p)))
+                    {
+                        let _ = id;
+                        drop(broadcast_overlay(&workspace, &panel));
+                        tasks.push(reset_all(
+                            &panel.session,
+                            &panel.renderer,
+                            &presentation,
+                            all,
+                        ));
+                    }
+
                     futures::future::join_all(tasks)
                         .await
                         .into_iter()
@@ -288,15 +299,23 @@ impl Component for PerspectiveViewer {
                 // rebuilt view re-applies it via `effective_view_config`,
                 // keeping a detail panel consistent with the rest of the
                 // workspace. A dangling id no-ops (dropping `sender` rejects
-                // the API promise).
+                // the API promise). An "all" reset FIRST purges the
+                // element's derived state (releasing every derived-bound
+                // panel to its root table) — "all" means the same thing from
+                // the status bar gesture and the `resetPanel()` API.
                 let id = id.map(crate::workspace::PanelId::from);
                 if let Some(panel) = ctx.props().workspace.panel_or_active(id.as_ref()) {
-                    let run = reset_all(
-                        &panel.session,
-                        &panel.renderer,
-                        &ctx.props().presentation,
-                        all,
-                    );
+                    let workspace = ctx.props().workspace.clone();
+                    let presentation = ctx.props().presentation.clone();
+                    let effect = workspace.effects().guard();
+                    let run = async move {
+                        let _effect = effect;
+                        if all {
+                            crate::tasks::purge_derived(&workspace, &presentation).await?;
+                        }
+
+                        reset_all(&panel.session, &panel.renderer, &presentation, all).await
+                    };
 
                     match sender {
                         Some(completion) => completion.resolve_after(run),
@@ -314,6 +333,7 @@ impl Component for PerspectiveViewer {
             PanelClosed(id) => self.on_panel_closed(ctx, id),
             CommitWorkspaceRestore(id) => self.on_commit_workspace_restore(ctx, id),
             DuplicatePanel(id) => self.on_duplicate_panel(ctx, id),
+            DerivePanel(id) => self.on_derive_panel(ctx, id),
             NewPanel(id) => self.on_new_panel(ctx, id),
             NewPanelFrom { client, table } => self.on_new_panel_from(ctx, client, table),
 

package/src/rust/components/window_editor.rs

@@ -24,7 +24,7 @@ use crate::components::dragdrop_list::{DragContext, DragDropList, DragDropListIt
 use crate::presentation::Presentation;
 use crate::session::{Session, SessionMetadataRc};
 use crate::ui::{IntlLabel, Select, SelectItem};
-use crate::utils::{AddListener, DragEffect, DragTarget, Subscription};
+use crate::utils::{AddListener, DragEffect, DragTarget, Subscription, left_click};
 
 /// The declared capabilities of one window aggregate, for a `source` column
 /// type. Which controls an aggregate needs is the data model's to state - the
@@ -846,9 +846,10 @@ impl Component for WindowEditor {
                             WindowSortDir::Asc
                         };
 
-                        let onmousedown = ctx
-                            .link()
-                            .callback(|_: MouseEvent| WindowEditorMsg::ToggleOrderDir);
+                        let onmousedown = left_click(
+                            ctx.link()
+                                .callback(|_: MouseEvent| WindowEditorMsg::ToggleOrderDir),
+                        );
 
                         yew::html_nested! {
                             <WindowSlotColumn