@perspective-dev/viewer 5.5.1 → 5.6.0

package/src/rust/custom_events.rs

@@ -103,8 +103,8 @@ 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.
+    // 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",
@@ -116,8 +116,8 @@ fn dispatch_column_settings_open_changed(
     // 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.
+    // 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))
@@ -149,19 +149,21 @@ fn dispatch_config_update(
     session: &Session,
     renderer: &Renderer,
     presentation: &Presentation,
+    workspace: &Workspace,
 ) {
     if session.get_table().is_none() && session.pending_table().is_none() {
         return;
     }
 
-    clone!(session, renderer, presentation);
+    clone!(session, renderer, presentation, workspace);
     let elem = elem.clone();
     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?;
+            .await?
+            .map_table(|name| workspace.inline_table_ref(&name));
 
         if viewer_config.view_config != Default::default()
             && Some(&viewer_config) != session.last_dispatched_config.borrow().as_deref()
@@ -215,7 +217,13 @@ pub fn wire_element_events(
         clone!(elem, presentation, workspace);
         move |_| {
             if let Some(panel) = workspace.active_panel() {
-                dispatch_config_update(&elem, &panel.session, &panel.renderer, &presentation);
+                dispatch_config_update(
+                    &elem,
+                    &panel.session,
+                    &panel.renderer,
+                    &presentation,
+                    &workspace,
+                );
             }
         }
     });
@@ -234,7 +242,13 @@ pub fn wire_element_events(
 
             dispatch_event(&elem, "toggle-settings", open).unwrap();
             if let Some(panel) = workspace.active_panel() {
-                dispatch_config_update(&elem, &panel.session, &panel.renderer, &presentation);
+                dispatch_config_update(
+                    &elem,
+                    &panel.session,
+                    &panel.renderer,
+                    &presentation,
+                    &workspace,
+                );
             }
         }
     });
@@ -328,12 +342,13 @@ pub fn wire_panel_events(
     session: &Session,
     renderer: &Renderer,
     presentation: &Presentation,
+    workspace: &Workspace,
 ) -> Vec<Subscription> {
     let plugin_sub = renderer.plugin_changed.add_listener({
-        clone!(elem, session, renderer, presentation);
+        clone!(elem, session, renderer, presentation, workspace);
         move |plugin| {
             dispatch_plugin_changed(&elem, &renderer, &plugin);
-            dispatch_config_update(&elem, &session, &renderer, &presentation);
+            dispatch_config_update(&elem, &session, &renderer, &presentation, &workspace);
         }
     });
 
@@ -343,13 +358,13 @@ pub fn wire_panel_events(
     // 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)
+        clone!(elem, session, renderer, presentation, workspace);
+        move |_| dispatch_config_update(&elem, &session, &renderer, &presentation, &workspace)
     });
 
     let title_sub = session.title_changed.add_listener({
-        clone!(elem, session, renderer, presentation);
-        move |_| dispatch_config_update(&elem, &session, &renderer, &presentation)
+        clone!(elem, session, renderer, presentation, workspace);
+        move |_| dispatch_config_update(&elem, &session, &renderer, &presentation, &workspace)
     });
 
     let unload_sub = session.table_unloaded.add_listener({
@@ -365,22 +380,22 @@ pub fn wire_panel_events(
     });
 
     let select_sub = renderer.selection_changed.add_listener({
-        clone!(elem, session, renderer, presentation);
+        clone!(elem, session, renderer, presentation, workspace);
         move |window: Option<ViewWindow>| {
             let detail = JsValue::from_serde_ext(&window).unwrap();
             annotate_panel(&detail, &renderer);
             let _ = dispatch_panel_event(&elem, &renderer, "select", &detail);
-            dispatch_config_update(&elem, &session, &renderer, &presentation);
+            dispatch_config_update(&elem, &session, &renderer, &presentation, &workspace);
         }
     });
 
     let column_style_sub = renderer.column_style_changed.add_listener({
-        clone!(elem, session, renderer, presentation);
+        clone!(elem, session, renderer, presentation, workspace);
         move |cfg: ColumnConfigMap| {
             let detail = JsValue::from_serde_ext(&cfg).unwrap();
             annotate_panel(&detail, &renderer);
             let _ = dispatch_panel_event(&elem, &renderer, "column-style-change", &detail);
-            dispatch_config_update(&elem, &session, &renderer, &presentation);
+            dispatch_config_update(&elem, &session, &renderer, &presentation, &workspace);
         }
     });
 

package/src/rust/derived.rs

@@ -0,0 +1,266 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+use std::collections::{BTreeMap, BTreeSet};
+
+use perspective_client::config::ViewConfig;
+use perspective_client::{DeleteOptions, Table, View};
+use perspective_js::utils::*;
+
+use crate::config::DerivedTableConfig;
+use crate::session::ViewSubscription;
+use crate::utils::PtrEqRc;
+
+/// The `View` a derived `Table` reads, which is a panel's own subscription when
+/// the derivation consumed it and a bare `View` when a restore rebuilt it.
+pub enum DerivedSource {
+    Panel(ViewSubscription),
+    Restored(View),
+}
+
+impl DerivedSource {
+    async fn delete(self) -> ApiResult<()> {
+        match self {
+            Self::Panel(sub) => sub.delete().await,
+            Self::Restored(view) => Ok(view.delete().await?),
+        }
+    }
+}
+
+/// A live derived `Table` and the `View` it reads.
+pub struct DerivedTable {
+    parent: String,
+    view_config: ViewConfig,
+    source: DerivedSource,
+    table: Table,
+}
+
+impl DerivedTable {
+    pub fn new(
+        parent: String,
+        view_config: ViewConfig,
+        source: DerivedSource,
+        table: Table,
+    ) -> Self {
+        Self {
+            parent,
+            view_config,
+            source,
+            table,
+        }
+    }
+
+    pub fn parent(&self) -> &str {
+        &self.parent
+    }
+
+    pub fn view_config(&self) -> &ViewConfig {
+        &self.view_config
+    }
+
+    pub fn table(&self) -> &Table {
+        &self.table
+    }
+
+    /// The persisted definition of this derivation.
+    pub fn config(&self) -> DerivedTableConfig {
+        DerivedTableConfig {
+            table: self.parent.clone(),
+            view_config: self.view_config.clone(),
+        }
+    }
+
+    /// Whether this derivation was built from `config`, and so may be reused.
+    pub fn matches(&self, config: &DerivedTableConfig) -> bool {
+        self.parent == config.table && self.view_config == config.view_config
+    }
+
+    /// Delete the `Table` before the `View` it reads, which the engine
+    /// requires in that order.
+    pub async fn delete(self) -> ApiResult<()> {
+        self.table.delete(DeleteOptions::default()).await?;
+        self.source.delete().await
+    }
+}
+
+/// The workspace's derived `Table`s: those live, and those whose parent is not
+/// yet hosted.
+#[derive(Default)]
+pub struct DerivedRegistry {
+    live: BTreeMap<String, DerivedTable>,
+    pending: BTreeMap<String, DerivedTableConfig>,
+}
+
+impl DerivedRegistry {
+    pub fn get(&self, name: &str) -> Option<&DerivedTable> {
+        self.live.get(name)
+    }
+
+    pub fn contains(&self, name: &str) -> bool {
+        self.live.contains_key(name)
+    }
+
+    pub fn insert(&mut self, name: String, table: DerivedTable) {
+        self.pending.remove(&name);
+        self.live.insert(name, table);
+    }
+
+    pub fn remove(&mut self, name: &str) -> Option<DerivedTable> {
+        self.pending.remove(name);
+        self.live.remove(name)
+    }
+
+    pub fn names(&self) -> Vec<String> {
+        self.live.keys().cloned().collect()
+    }
+
+    /// The name of a live derivation built from `config`, regardless of what
+    /// it is named, for inline-definition restores to rebind to.
+    pub fn find_structural(&self, config: &DerivedTableConfig) -> Option<String> {
+        self.live
+            .iter()
+            .find(|(_, table)| table.matches(config))
+            .map(|(name, _)| name.clone())
+    }
+
+    /// The definitions waiting on a parent that is not yet hosted.
+    pub fn pending(&self) -> BTreeMap<String, DerivedTableConfig> {
+        self.pending.clone()
+    }
+
+    pub fn set_pending(&mut self, pending: BTreeMap<String, DerivedTableConfig>) {
+        self.pending = pending;
+    }
+
+    /// Every derivation's persisted definition, live or pending, for
+    /// `saveWorkspace`.
+    pub fn configs(&self) -> BTreeMap<String, DerivedTableConfig> {
+        let mut out = self.pending.clone();
+        out.extend(
+            self.live
+                .iter()
+                .map(|(name, table)| (name.clone(), table.config())),
+        );
+
+        out
+    }
+
+    /// The names whose `parent` is `name`.
+    pub fn children(&self, name: &str) -> Vec<String> {
+        self.live
+            .iter()
+            .filter(|(_, table)| table.parent == name)
+            .map(|(child, _)| child.clone())
+            .chain(
+                self.pending
+                    .iter()
+                    .filter(|(_, config)| config.table == name)
+                    .map(|(child, _)| child.clone()),
+            )
+            .collect()
+    }
+
+    /// `name`'s ancestors, nearest first, stopping at the first non-derived
+    /// `Table`.
+    pub fn ancestors(&self, name: &str) -> Vec<String> {
+        let mut out = vec![];
+        let mut seen = BTreeSet::new();
+        let mut cursor = name.to_owned();
+        while let Some(entry) = self.live.get(&cursor) {
+            if !seen.insert(cursor.clone()) {
+                break;
+            }
+
+            out.push(entry.parent.clone());
+            cursor = entry.parent.clone();
+        }
+
+        out
+    }
+}
+
+/// Order `configs` parents-first, or report the names forming a cycle.
+pub fn topo_order(configs: &BTreeMap<String, DerivedTableConfig>) -> Result<Vec<String>, String> {
+    let mut pending = configs.keys().cloned().collect::<BTreeSet<_>>();
+    let mut out = Vec::with_capacity(configs.len());
+    while !pending.is_empty() {
+        let ready = pending
+            .iter()
+            .filter(|name| {
+                let parent = &configs[*name].table;
+                !pending.contains(parent)
+            })
+            .cloned()
+            .collect::<Vec<_>>();
+
+        if ready.is_empty() {
+            let cycle = pending.into_iter().collect::<Vec<_>>().join("`, `");
+            return Err(format!(
+                "`derived_tables` has a dependency cycle among `{cycle}`"
+            ));
+        }
+
+        for name in ready {
+            pending.remove(&name);
+            out.push(name);
+        }
+    }
+
+    Ok(out)
+}
+
+/// The subset of `order` that may be reused from `registry`, which requires
+/// every ancestor within `configs` to be reusable too.
+pub fn reusable(
+    order: &[String],
+    configs: &BTreeMap<String, DerivedTableConfig>,
+    registry: &DerivedRegistry,
+) -> BTreeSet<String> {
+    let mut out = BTreeSet::new();
+    for name in order {
+        let config = &configs[name];
+        let parent_ok = !configs.contains_key(&config.table) || out.contains(&config.table);
+        if parent_ok
+            && registry
+                .get(name)
+                .is_some_and(|table| table.matches(config))
+        {
+            out.insert(name.clone());
+        }
+    }
+
+    out
+}
+
+/// A `<table> GROUP BY <cols>`-style name that collides with nothing in
+/// `taken`.
+pub fn suggest_name(
+    taken: &BTreeSet<String>,
+    config: &PtrEqRc<ViewConfig>,
+    table: &Option<String>,
+) -> String {
+    let table_name = table.as_deref().unwrap_or("...");
+    let name = if config.group_by.is_empty() {
+        table_name.to_owned()
+    } else {
+        format!("{} GROUP BY {}", table_name, config.group_by.join(", "))
+    };
+
+    if taken.contains(&name) {
+        (1..)
+            .map(|n| format!("{name} {n}"))
+            .find(|name| !taken.contains(name))
+            .unwrap()
+    } else {
+        name
+    }
+}

package/src/rust/exprtk/tokenize.rs

@@ -151,57 +151,3 @@ pub fn tokenize(input: &str) -> Vec<Token<'_>> {
 
     tokens
 }
-
-#[cfg(test)]
-mod tests {
-    use wasm_bindgen_test::*;
-
-    use super::*;
-
-    #[wasm_bindgen_test]
-    fn test_simple() {
-        let s = "123 abc 'hello' \"Sales\"";
-        assert_eq!(tokenize(s), vec![
-            Literal("123"),
-            Whitespace(" "),
-            Symbol("abc"),
-            Whitespace(" "),
-            Column("'hello'"),
-            Whitespace(" "),
-            Literal("\"Sales\"")
-        ]);
-    }
-
-    #[wasm_bindgen_test]
-    fn test_complex_string() {
-        let s = "'this is 'a \"test of\" strings";
-        assert_eq!(tokenize(s), vec![
-            Column("'this is '"),
-            Symbol("a"),
-            Whitespace(" "),
-            Literal("\"test of\""),
-            Whitespace(" "),
-            Symbol("strings"),
-        ]);
-    }
-
-    #[wasm_bindgen_test]
-    fn test_comment_newline() {
-        let s = "// Title\n1 + 2";
-        assert_eq!(tokenize(s), vec![
-            Comment("// Title"),
-            Break("\n"),
-            Literal("1"),
-            Whitespace(" "),
-            Operator("+"),
-            Whitespace(" "),
-            Literal("2"),
-        ]);
-    }
-
-    #[wasm_bindgen_test]
-    fn test_escape_strings() {
-        let s = "'test\\/'";
-        assert_eq!(tokenize(s), vec![Literal("'test\\/'"),]);
-    }
-}

package/src/rust/js/plugin.rs

@@ -51,7 +51,7 @@ extern "C" {
     /// call — the view re-renders and re-queries the schema once the
     /// async fetch resolves.
     #[wasm_bindgen(method, catch, js_name = column_config_schema)]
-    pub fn _column_config_schema(this: &JsPerspectiveViewerPlugin, view_type: &str, group: Option<&str>, column_name: &str, current_value: &JsValue, view_config: &JsValue, column_stats: &JsValue) -> ApiResult<JsValue>;
+    pub fn _column_config_schema(this: &JsPerspectiveViewerPlugin, view_type: &str, group: Option<&str>, column_name: &str, current_value: &JsValue, view_config: &JsValue, plugin_config: &JsValue, role: &str) -> ApiResult<JsValue>;
 
     /// The plugin-level settings schema as it applies to `current_value`, the
     /// `plugin_config` state the schema should describe.

package/src/rust/lib.rs

@@ -34,6 +34,7 @@ pub mod components;
 pub mod config;
 pub mod custom_elements;
 mod custom_events;
+mod derived;
 pub mod exprtk;
 mod js;
 mod presentation;
@@ -89,6 +90,8 @@ export type * from "../../src/ts/ts-rs/ViewerConfigUpdate.d.ts";
 export type * from "../../src/ts/ts-rs/ViewerConfigInitial.d.ts";
 export type * from "../../src/ts/ts-rs/PluginStaticConfig.d.ts";
 export type * from "../../src/ts/ts-rs/WorkspaceConfig.d.ts";
+export type * from "../../src/ts/ts-rs/TableRef.d.ts";
+export type * from "../../src/ts/ts-rs/DerivedTableConfig.d.ts";
 export type * from "../../src/ts/ts-rs/WorkspaceConfigUpdate.d.ts";
 export type * from "../../src/ts/ts-rs/ExportMethod.d.ts";
 export type * from "../../src/ts/ts-rs/PanelOptions.d.ts";

package/src/rust/presentation.rs

@@ -233,6 +233,8 @@ impl Presentation {
         self.viewer_elem
             .toggle_attribute_with_force("settings", opt)
             .unwrap();
+
+        crate::utils::stamp_plugin_host_state_all(&self.viewer_elem);
     }
 
     pub fn is_settings_open(&self) -> bool {
@@ -652,10 +654,12 @@ impl Presentation {
             _ => None,
         };
 
-        self.end_drag();
+        self.reset_drag_state();
         if let Some(action) = action {
             self.drop_received.emit(action);
         }
+
+        self.emit_drag_end();
     }
 
     /// Start the drag/drop action with the name of the column being dragged.
@@ -681,11 +685,26 @@ impl Presentation {
     }
 
     fn end_drag(&self) {
+        self.reset_drag_state();
+        self.emit_drag_end();
+    }
+
+    fn reset_drag_state(&self) {
         self.drag_target.borrow_mut().take();
         *self.drag_state.borrow_mut() = DragState::NoDrag;
-        if let Some(cb) = self.on_dragend.borrow().as_ref() {
-            cb.emit(());
-        }
+    }
+
+    /// Notify the root one microtask late, so a drop's config edit (itself
+    /// notified through a microtask) lands in the same render batch.
+    fn emit_drag_end(&self) {
+        let emit = self.on_dragend.borrow().clone();
+        ApiFuture::spawn(async move {
+            if let Some(cb) = emit {
+                cb.emit(());
+            }
+
+            Ok(())
+        });
     }
 
     /// Register a `dragend` listener on the host `<perspective-viewer>`

package/src/rust/queries/column_locator.rs

@@ -10,7 +10,7 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
-use perspective_client::config::ViewConfig;
+use perspective_client::config::{ColumnType, ViewConfig};
 
 use crate::presentation::{ColumnLocator, ColumnSettingsTarget, OpenColumnSettings};
 use crate::renderer::Renderer;
@@ -37,11 +37,62 @@ pub fn classify_column(
     }
 }
 
+/// Whether `name` is one of `view_config`'s pivots, whose own raw values a
+/// plugin draws as a header label or axis tick and therefore formats with its
+/// TABLE type rather than an aggregate's view type.
+pub fn is_pivot_column(name: &str, view_config: &ViewConfig) -> bool {
+    view_config.group_by.iter().any(|col| col == name)
+        || view_config.split_by.iter().any(|col| col == name)
+}
+
+/// Whether `name` is configured AS a pivot: a pivot that is also in `columns`
+/// is configured as that aggregate instead, so its pivot copy is not
+/// separately configurable.
+pub fn is_pivot_only_column(name: &str, view_config: &ViewConfig) -> bool {
+    is_pivot_column(name, view_config)
+        && !view_config
+            .columns
+            .iter()
+            .any(|col| col.as_deref() == Some(name))
+}
+
+/// Whether the active plugin offers `name` any column config, gating every
+/// affordance that opens the Style tab.
+// TODO This hardcodes the set of types a plugin offers a pivot a format control
+// for, instead of asking it. `get_column_config_schema` answers exactly
+// (`!schema.leaf_fields().is_empty()`) but costs a plugin call per pivot pill
+// per render; switch to it if pills ever outgrow a handful, or if a plugin's
+// pivot controls stop being format-only.
+pub fn has_column_config(
+    name: &str,
+    view_config: &ViewConfig,
+    metadata: &SessionMetadata,
+    renderer: &Renderer,
+) -> bool {
+    if !renderer.can_render_column_styles() {
+        return false;
+    }
+
+    if view_config
+        .columns
+        .iter()
+        .any(|col| col.as_deref() == Some(name))
+    {
+        return true;
+    }
+
+    is_pivot_column(name, view_config)
+        && matches!(
+            metadata.get_column_table_type(name),
+            Some(ColumnType::Integer | ColumnType::Float | ColumnType::Date | ColumnType::Datetime)
+        )
+}
+
 /// Gets a [`ColumnLocator`] for the current UI's column settings state,
 /// or [`None`] if it is not currently active.
 ///
-/// Table columns only have a useful sidebar (the Style tab)
-/// when they're in `view_config.columns`.
+/// Table columns only have a useful sidebar (the Style tab) when they're in
+/// `view_config.columns` or are a pivot.
 pub fn get_current_column_locator(
     open_column_settings: &OpenColumnSettings,
     renderer: &Renderer,
@@ -54,54 +105,10 @@ pub fn get_current_column_locator(
             let locator = classify_column(name, view_config, metadata)?;
             match locator {
                 ColumnLocator::Table(_) => {
-                    let in_columns = view_config.columns.iter().any(|maybe_col| {
-                        maybe_col
-                            .as_ref()
-                            .map(|col| col == name)
-                            .unwrap_or_default()
-                    });
-
-                    (in_columns && renderer.can_render_column_styles()).then_some(locator)
+                    has_column_config(name, view_config, metadata, renderer).then_some(locator)
                 },
                 locator => Some(locator),
             }
         },
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use std::collections::HashMap;
-
-    use perspective_client::config::Expressions;
-
-    use super::*;
-
-    fn config_with_expression(name: &str, expr: &str) -> ViewConfig {
-        ViewConfig {
-            expressions: Expressions(HashMap::from([(name.to_owned(), expr.to_owned())])),
-            ..ViewConfig::default()
-        }
-    }
-
-    #[test]
-    fn classifies_from_the_config_before_metadata_catches_up() {
-        let config = config_with_expression("x", "1 + 1");
-        let metadata = SessionMetadata::default();
-        assert_eq!(
-            classify_column("x", &config, &metadata),
-            Some(ColumnLocator::Expression("x".to_owned()))
-        );
-        assert_eq!(classify_column("nope", &config, &metadata), None);
-    }
-
-    #[test]
-    fn unnamed_expressions_are_keyed_by_their_text() {
-        let config = config_with_expression("\"Sales\" + 1", "\"Sales\" + 1");
-        let metadata = SessionMetadata::default();
-        assert_eq!(
-            classify_column("\"Sales\" + 1", &config, &metadata),
-            Some(ColumnLocator::Expression("\"Sales\" + 1".to_owned()))
-        );
-    }
-}

package/src/rust/queries/get_viewer_config.rs

@@ -26,7 +26,7 @@ pub async fn get_viewer_config(
     session: &Session,
     renderer: &Renderer,
     presentation: &Presentation,
-) -> ApiResult<ViewerConfig> {
+) -> ApiResult<ViewerConfig<String, String>> {
     let version = config::API_VERSION.to_string();
     let mut view_config = if let Some(rendered) = session.get_rendered_view_config() {
         (*rendered).clone()