@perspective-dev/viewer 5.4.0 → 5.5.0

package/src/rust/session.rs

@@ -152,6 +152,51 @@ impl Deref for SessionHandle {
     }
 }
 
+/// What an un-hosted `table` name means to a bind, per the `wait_for_table`
+/// option.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum MissingTable {
+    /// A hard error that leaves the panel as it was.
+    Error,
+
+    /// The panel waits unbound and binds when the name is hosted.
+    Pend,
+}
+
+impl MissingTable {
+    /// Decode the `wait_for_table` option (absent = `false` = `Error`).
+    pub fn from_wait(wait_for_table: Option<bool>) -> Self {
+        if wait_for_table.unwrap_or_default() {
+            Self::Pend
+        } else {
+            Self::Error
+        }
+    }
+}
+
+/// Open `name` on `client`, returning `Ok(None)` when the name is not hosted
+/// and `missing` is [`MissingTable::Pend`].
+pub(crate) async fn probe_table(
+    client: &Client,
+    name: &str,
+    missing: MissingTable,
+) -> ApiResult<Option<perspective_client::Table>> {
+    match client.open_table(name.to_owned()).await {
+        Ok(table) => Ok(Some(table)),
+        Err(e) => {
+            let hosted = client.get_hosted_table_names().await.unwrap_or_default();
+            if hosted.iter().any(|n| n == name) {
+                return Err(e.into());
+            }
+
+            match missing {
+                MissingTable::Pend => Ok(None),
+                MissingTable::Error => Err(ApiError::new(format!("Unknown table \"{name}\""))),
+            }
+        },
+    }
+}
+
 /// Mutable state for `Session`.
 #[derive(Default)]
 pub struct SessionData {
@@ -309,6 +354,7 @@ impl Session {
     /// `Session`.
     pub fn reset(&self, options: ResetOptions) -> impl Future<Output = ApiResult<()>> + use<> {
         let view = self.0.borrow_mut().view_sub.take();
+        let had_table = self.borrow().table.is_some();
         let err = self.get_error();
         self.borrow_mut().error = None;
         if options.stats {
@@ -328,11 +374,13 @@ impl Session {
                 self.borrow_mut().is_loading = false;
                 self.borrow_mut().table = None;
                 self.borrow_mut().pending_table = None;
+                self.borrow_mut().metadata = SessionMetadata::default();
             },
             Some(TableIntermediateState::Reloaded) => {
                 self.borrow_mut().is_loading = true;
                 self.borrow_mut().table = None;
                 self.borrow_mut().pending_table = None;
+                self.borrow_mut().metadata = SessionMetadata::default();
             },
             _ => {
                 self.borrow_mut().is_loading = false;
@@ -353,7 +401,7 @@ impl Session {
         let session = self.clone();
         async move {
             let res = view.delete().await;
-            if options.table.is_some() {
+            if options.table.is_some() && had_table {
                 session.table_unloaded.emit(true)
             }
 
@@ -410,6 +458,8 @@ impl Session {
             Some(TableLoadState::Loaded)
         } else if data.is_loading {
             Some(TableLoadState::Loading)
+        } else if data.pending_table.is_some() {
+            Some(TableLoadState::Pending)
         } else {
             None
         }
@@ -470,10 +520,8 @@ impl Session {
     /// `table_name` is unique per `Client`, so if this value has not changed,
     /// `Session::set_table` does nothing and returns `Ok(false)`.
     ///
-    /// A name NO loaded client hosts (yet) is not an error: the session
-    /// records it PENDING ([`SessionData::pending_table`]) and returns
-    /// `Ok(false)`; the element's hosted-tables subscription
-    /// (`tasks::table_lifecycle`) re-runs the bind when the table is created.
+    /// A name no loaded client hosts pends ([`MissingTable::Pend`]) and
+    /// returns `Ok(false)` until the table lifecycle re-runs the bind.
     pub async fn set_table(&self, table_name: String) -> ApiResult<bool> {
         if Some(table_name.as_str()) == self.0.borrow().table.as_ref().map(|x| x.get_name()) {
             self.0.borrow_mut().pending_table = None;
@@ -481,60 +529,68 @@ impl Session {
         }
 
         let client = self.0.borrow().client.clone().into_apierror()?;
-        let table = match client.open_table(table_name.clone()).await {
-            Ok(table) => table,
-            Err(e) => {
-                // Distinguish "not hosted (yet)" — which PENDS — from a real
-                // open failure by the hosted set, not the error's text.
-                let hosted = client.get_hosted_table_names().await.unwrap_or_default();
-                if hosted.iter().any(|n| n == &table_name) {
-                    return Err(e.into());
-                }
-
-                self.0.borrow_mut().pending_table = Some(table_name);
-                return Ok(false);
+        match probe_table(&client, &table_name, MissingTable::Pend).await? {
+            Some(table) => match self.bind_table(table).await {
+                Ok(()) => Ok(true),
+                Err(err) => self.set_error(false, err).await.map(|_| false),
             },
-        };
+            None => {
+                self.pend_table(table_name).await?;
+                Ok(false)
+            },
+        }
+    }
 
-        match SessionMetadata::from_table(&table).await {
-            Ok(metadata) => {
-                let client = table.get_client();
-                let on_error = self.on_table_errored.borrow().clone();
-                let session = self.clone();
-                let poll_loop = LocalPollLoop::new(move |(message, reconnect): (ApiError, _)| {
-                    session.borrow_mut().error = Some(TableErrorState(message, reconnect));
-                    if let Some(cb) = &on_error {
-                        cb.emit(());
-                    }
-                    if let Some(sub) = session.borrow_mut().view_sub.take() {
-                        sub.dismiss();
-                    }
+    /// Bind an opened `Table`, replacing any previous binding and announcing
+    /// `table_loaded`.
+    pub(crate) async fn bind_table(&self, table: perspective_client::Table) -> ApiResult<()> {
+        let metadata = SessionMetadata::from_table(&table).await?;
+        let client = table.get_client();
+        let on_error = self.on_table_errored.borrow().clone();
+        let session = self.clone();
+        let poll_loop = LocalPollLoop::new(move |(message, reconnect): (ApiError, _)| {
+            session.borrow_mut().error = Some(TableErrorState(message, reconnect));
+            if let Some(cb) = &on_error {
+                cb.emit(());
+            }
+            if let Some(sub) = session.borrow_mut().view_sub.take() {
+                sub.dismiss();
+            }
 
-                    Ok(JsValue::UNDEFINED)
-                });
-
-                let _callback_id = client
-                    .on_error(Box::new(move |message: ClientError, reconnect| {
-                        let poll_loop = poll_loop.clone();
-                        async move {
-                            poll_loop.poll((message.into(), reconnect)).await;
-                            Ok(())
-                        }
-                    }))
-                    .await?;
+            Ok(JsValue::UNDEFINED)
+        });
 
-                let sub = self.borrow_mut().view_sub.take();
-                self.borrow_mut().metadata = metadata;
-                self.borrow_mut().table = Some(table);
-                self.borrow_mut().pending_table = None;
-                self.borrow_mut().is_loading = false;
-                self.borrow_mut().last_validated_expressions = None;
-                sub.delete().await?;
-                self.table_loaded.emit(());
-                Ok(true)
-            },
-            Err(err) => self.set_error(false, err).await.map(|_| false),
-        }
+        let _callback_id = client
+            .on_error(Box::new(move |message: ClientError, reconnect| {
+                let poll_loop = poll_loop.clone();
+                async move {
+                    poll_loop.poll((message.into(), reconnect)).await;
+                    Ok(())
+                }
+            }))
+            .await?;
+
+        let sub = self.borrow_mut().view_sub.take();
+        self.borrow_mut().metadata = metadata;
+        self.borrow_mut().table = Some(table);
+        self.borrow_mut().pending_table = None;
+        self.borrow_mut().is_loading = false;
+        self.borrow_mut().last_validated_expressions = None;
+        sub.delete().await?;
+        self.table_loaded.emit(());
+        Ok(())
+    }
+
+    /// Record `name` as pending, dropping any bound `Table` so nothing binds
+    /// against the outgoing table while the name waits for a host.
+    pub(crate) async fn pend_table(&self, name: String) -> ApiResult<()> {
+        let sub = self.borrow_mut().view_sub.take();
+        self.borrow_mut().table = None;
+        self.borrow_mut().metadata = SessionMetadata::default();
+        self.borrow_mut().pending_table = Some(name);
+        self.borrow_mut().is_loading = false;
+        self.borrow_mut().last_validated_expressions = None;
+        sub.delete().await
     }
 
     pub async fn set_error(&self, reset_table: bool, err: ApiError) -> ApiResult<()> {
@@ -1094,31 +1150,7 @@ impl Session {
             .clone()
             .ok_or("`restore()` called before `load()`")?;
 
-        // Populate the aggregates with defaults as a courtesy to the
-        // virtual server api. Snapshot-local — never written back.
-        let mut view_config = (*effective).clone();
-        for col in view_config
-            .columns
-            .iter()
-            .flatten()
-            .chain(view_config.sort.iter().map(|x| &x.0))
-        {
-            if !view_config.aggregates.contains_key(col.as_str()) {
-                let agg = self
-                    .metadata()
-                    .get_column_aggregates(col.as_str())
-                    .and_then(|mut aggs| aggs.next())
-                    .into_apierror();
-
-                match agg {
-                    Err(_) => {
-                        tracing::warn!("No default aggregate for column '{}' found, skipping", col)
-                    },
-                    Ok(agg) => _ = view_config.aggregates.insert(col.to_string(), agg),
-                };
-            }
-        }
-
+        let view_config = self.with_default_aggregates(&effective);
         let view = table.view(Some(view_config.into())).await?;
         let view_schema = view.schema().await?;
         self.metadata_mut().update_view_schema(&view_schema)?;
@@ -1150,6 +1182,43 @@ impl Session {
         }
     }
 
+    /// The engine config for a `View` built from `effective`, per-column
+    /// default aggregates filled in as a courtesy to the virtual server API.
+    fn with_default_aggregates(&self, effective: &ViewConfig) -> ViewConfig {
+        let mut view_config = effective.clone();
+        for col in view_config
+            .columns
+            .iter()
+            .flatten()
+            .chain(view_config.sort.iter().map(|x| &x.0))
+        {
+            if !view_config.aggregates.contains_key(col.as_str()) {
+                let agg = self
+                    .metadata()
+                    .get_column_aggregates(col.as_str())
+                    .and_then(|mut aggs| aggs.next())
+                    .into_apierror();
+
+                match agg {
+                    Err(_) => {
+                        tracing::warn!("No default aggregate for column '{}' found, skipping", col)
+                    },
+                    Ok(agg) => _ = view_config.aggregates.insert(col.to_string(), agg),
+                };
+            }
+        }
+
+        view_config
+    }
+
+    /// Build a caller-owned `View` from the effective config outside the
+    /// render pipeline, with no subscription and no interaction with pause.
+    pub async fn create_detached_view(&self) -> ApiResult<View> {
+        let table = self.borrow().table.clone().ok_or("No `Table` set")?;
+        let view_config = self.with_default_aggregates(&self.effective_view_config());
+        Ok(table.view(Some(view_config.into())).await?)
+    }
+
     /// Record a failed pipeline run: error state plus a reconnect affordance
     /// that resets the config (the error screen's reset button). Replaces
     /// the old `validate()` error path — the committed config is NOT rolled
@@ -1239,6 +1308,8 @@ impl Session {
                 Some(TableLoadState::Loaded)
             } else if data.is_loading {
                 Some(TableLoadState::Loading)
+            } else if data.pending_table.is_some() {
+                Some(TableLoadState::Pending)
             } else {
                 None
             },

package/src/rust/tasks/create_panel.rs

@@ -17,7 +17,7 @@ use crate::config::*;
 use crate::custom_events::wire_panel_events;
 use crate::presentation::*;
 use crate::renderer::*;
-use crate::session::{ResetOptions, Session};
+use crate::session::{MissingTable, ResetOptions, Session};
 use crate::tasks::*;
 use crate::utils::*;
 use crate::workspace::{Panel, PanelId, PanelPhase, Workspace};
@@ -76,6 +76,7 @@ fn wire_panel_render_sub(session: &Session, renderer: &Renderer) -> Subscription
 /// one. `theme` is stripped (element-level, not per-panel) and `client` —
 /// or the element's default client when `None` — is bound so the config's
 /// `table` resolves against it.
+#[allow(clippy::too_many_arguments)]
 pub(crate) async fn create_panel(
     elem: &HtmlElement,
     presentation: &Presentation,
@@ -84,6 +85,7 @@ pub(crate) async fn create_panel(
     id: Option<PanelId>,
     config: ViewerConfigInitial,
     client: Option<perspective_client::Client>,
+    missing: MissingTable,
 ) -> ApiResult<PanelId> {
     let (id, session, renderer, update) = create_panel_model(
         elem,
@@ -120,6 +122,7 @@ pub(crate) async fn create_panel(
         RestoreMode::Fresh,
         update,
         crate::tasks::RestoreErrors::Publish,
+        missing,
     )
     .await;
 

package/src/rust/tasks/pipeline.rs

@@ -251,6 +251,18 @@ pub(crate) async fn locked_run(
             let view_config_snapshot = session.get_view_config().clone();
             let plugin_config_changed =
                 renderer.update_plugin_config(&view_config_snapshot, spec.plugin_config)?;
+            let plugin_config_snapshot = renderer.get_plugin_config();
+            let plugin_update =
+                JsValue::from_serde_ext(&plugin_config_snapshot).unwrap_or(JsValue::NULL);
+
+            let plugin_restored = plugin_config_changed || plugin_swapped;
+            if plugin_restored {
+                let columns_config = renderer
+                    .all_columns_configs_materialized(&view_config_snapshot, &session)
+                    .await;
+                plugin.restore(&plugin_update, Some(&columns_config))?;
+            }
+
             let columns_config_changed = renderer.update_columns_configs(
                 &view_config_snapshot,
                 &session,
@@ -258,17 +270,16 @@ pub(crate) async fn locked_run(
             )?;
 
             let changed = plugin_config_changed || columns_config_changed;
-            if changed || plugin_swapped {
-                let plugin_config_snapshot = renderer.get_plugin_config();
-                let plugin_update =
-                    JsValue::from_serde_ext(&plugin_config_snapshot).unwrap_or(JsValue::NULL);
+            if columns_config_changed {
                 let columns_config = renderer
                     .all_columns_configs_materialized(&view_config_snapshot, &session)
                     .await;
                 plugin.restore(&plugin_update, Some(&columns_config))?;
-                if plugin_config_changed {
-                    renderer.plugin_config_changed.emit(plugin_config_snapshot);
-                }
+                renderer.columns_config_changed.emit(columns_config);
+            }
+
+            if plugin_config_changed {
+                renderer.plugin_config_changed.emit(plugin_config_snapshot);
             }
 
             if spec

package/src/rust/tasks/restore_panel.rs

@@ -16,7 +16,7 @@ use perspective_client::utils::PerspectiveResultExt;
 use crate::config::*;
 use crate::presentation::Presentation;
 use crate::renderer::Renderer;
-use crate::session::{ResetOptions, Session};
+use crate::session::{MissingTable, ResetOptions, Session, TableIntermediateState, probe_table};
 use crate::tasks::*;
 use crate::workspace::Workspace;
 use crate::*;
@@ -38,27 +38,107 @@ pub(crate) enum RestoreErrors {
     Suppress,
 }
 
+/// The client to bind and the opened `Table`, or `None` when pending.
+type Probed = (
+    perspective_client::Client,
+    Option<perspective_client::Table>,
+);
+
+/// Resolve and probe the client hosting `name` without touching the
+/// session's own binding.
+async fn probe(
+    session: &Session,
+    workspace: &Workspace,
+    name: &str,
+    missing: MissingTable,
+) -> ApiResult<Probed> {
+    let current = session.get_client();
+    let resolved = workspace
+        .resolve_client_for_table(name, current.as_ref())
+        .await;
+
+    let client = resolved.or(current).into_apierror()?;
+    let table = probe_table(&client, name, missing).await?;
+    Ok((client, table))
+}
+
+/// Bind an unbound or same-named session to `name`.
 pub(crate) async fn bind_table_task(
     session: &Session,
     workspace: &Workspace,
     name: String,
+    missing: MissingTable,
 ) -> ApiResult<()> {
-    let current = session.get_client();
-    if let Some(client) = workspace
-        .resolve_client_for_table(&name, current.as_ref())
-        .await
+    if session
+        .get_table()
+        .is_some_and(|t| t.get_name() == name.as_str())
     {
-        session.set_client(client);
+        return Ok(());
+    }
+
+    let (client, table) = probe(session, workspace, &name, missing).await?;
+    session.set_client(client);
+    match table {
+        Some(table) => session.bind_table(table).await?,
+        None => session.pend_table(name).await?,
+    }
+
+    session.commit_table_defaults();
+    Ok(())
+}
+
+/// Rebind a session to `name`, probing the incoming table before the
+/// outgoing binding is dropped and replaying the journal opened as
+/// `generation` over the incoming table's defaults.
+async fn rebind_table_task(
+    session: &Session,
+    renderer: &Renderer,
+    workspace: &Workspace,
+    name: String,
+    missing: MissingTable,
+    generation: u32,
+) -> ApiResult<()> {
+    let probed = probe(session, workspace, &name, missing).await;
+    let journal = session.take_pending_load(generation);
+    let (client, table) = probed?;
+    let Some(journal) = journal else {
+        return Ok(());
+    };
+
+    session
+        .reset(ResetOptions {
+            config: true,
+            expressions: true,
+            stats: true,
+            table: Some(TableIntermediateState::Reloaded),
+        })
+        .await?;
+
+    session.set_client(client);
+    match table {
+        Some(table) => session.bind_table(table).await?,
+        None => session.pend_table(name).await?,
     }
 
-    session.set_table(name).await?;
     session.commit_table_defaults();
+    for delta in journal {
+        session.commit_view_config(delta)?;
+    }
+
+    session.commit_table_defaults();
+    if session.get_table().is_none()
+        && let Some(plugin) = renderer.active_plugin()
+    {
+        plugin.clear().await?;
+    }
+
     Ok(())
 }
 
 /// Apply a [`ViewerConfigUpdate`] to a single panel and re-draw — the one
 /// pipeline shared by `restorePanel` (an existing panel), `restoreWorkspace`,
 /// and `addPanel` (both fresh panels).
+#[allow(clippy::too_many_arguments)]
 pub(crate) async fn restore_panel(
     session: &Session,
     renderer: &Renderer,
@@ -67,6 +147,7 @@ pub(crate) async fn restore_panel(
     mode: RestoreMode,
     mut update: ViewerConfigUpdate,
     errors: RestoreErrors,
+    missing: MissingTable,
 ) -> ApiResult<()> {
     let active = matches!(mode, RestoreMode::Existing { active: true });
     let fresh = matches!(mode, RestoreMode::Fresh);
@@ -100,21 +181,24 @@ pub(crate) async fn restore_panel(
     let rollback =
         matches!(errors, RestoreErrors::Suppress).then(|| session.get_view_config().clone());
 
-    let table_changed = !fresh
-        && matches!(&update.table, OptionalUpdate::Update(name)
-            if session.get_table().map(|t| t.get_name() != name.as_str()).unwrap_or(true));
+    let binding_before = (
+        session.get_table().map(|t| t.get_name().to_owned()),
+        session.pending_table(),
+    );
 
-    let errored_recovery =
-        session.is_errored() && matches!(&update.table, OptionalUpdate::Update(_));
-
-    let reset = (table_changed || errored_recovery).then(|| {
-        session.reset(ResetOptions {
-            config: true,
-            expressions: true,
-            stats: true,
-            ..ResetOptions::default()
-        })
-    });
+    let generation = match &update.table {
+        OptionalUpdate::Update(name)
+            if session.is_errored()
+                || (!fresh
+                    && session
+                        .get_table()
+                        .map(|t| t.get_name() != name.as_str())
+                        .unwrap_or(true)) =>
+        {
+            Some(session.begin_pending_load())
+        },
+        _ => None,
+    };
 
     let result = restore_and_render(
         session,
@@ -123,27 +207,42 @@ pub(crate) async fn restore_panel(
         RunOrigin::Public,
         update.clone(),
         {
-            clone!(session, update.table, workspace);
+            clone!(session, renderer, update.table, workspace);
             async move {
-                if let OptionalUpdate::Update(name) = table {
-                    if let Some(reset) = reset {
-                        reset.await?;
-                    }
+                let OptionalUpdate::Update(name) = table else {
+                    return Ok(());
+                };
 
-                    bind_table_task(&session, &workspace, name).await?;
+                match generation {
+                    Some(generation) => {
+                        rebind_table_task(
+                            &session, &renderer, &workspace, name, missing, generation,
+                        )
+                        .await
+                    },
+                    None => bind_table_task(&session, &workspace, name, missing).await,
                 }
-
-                Ok(())
             }
         },
     )
     .await;
 
+    if let Some(generation) = generation {
+        session.take_pending_load(generation);
+    }
+
     if let Err(e) = &result {
         match errors {
             RestoreErrors::Publish => session.set_error(false, e.clone()).await?,
             RestoreErrors::Suppress => {
-                if let Some(config) = rollback {
+                let binding_after = (
+                    session.get_table().map(|t| t.get_name().to_owned()),
+                    session.pending_table(),
+                );
+
+                if let Some(config) = rollback
+                    && binding_after == binding_before
+                {
                     session.commit_view_config(config.into()).unwrap_or_log();
                 }
             },

package/src/rust/tasks/send_column_config.rs

@@ -51,6 +51,9 @@ pub fn send_column_config(
         renderer
             .update_lazy(async move { Ok(session.get_view_with_dimensions()) })
             .await?;
+        renderer
+            .columns_config_changed
+            .emit(columns_configs.clone());
         renderer.column_style_changed.emit(columns_configs);
         Ok(())
     })