@perspective-dev/viewer 5.1.0 → 5.3.0

package/src/rust/custom_events.rs

@@ -150,6 +150,10 @@ fn dispatch_config_update(
     renderer: &Renderer,
     presentation: &Presentation,
 ) {
+    if session.get_table().is_none() && session.pending_table().is_none() {
+        return;
+    }
+
     clone!(session, renderer, presentation);
     let elem = elem.clone();
     let tracker = session.clone();
@@ -218,7 +222,16 @@ pub fn wire_element_events(
 
     let settings_sub = presentation.settings_open_changed.add_listener({
         clone!(elem, presentation, workspace);
-        move |open: bool| {
+        move |(open, announce): (bool, bool)| {
+            // A silent toggle (`restore`/`restoreWorkspace`) is announced
+            // by its own view-config commit dispatch — emitting here too
+            // would double-fire `perspective-config-update`, the first
+            // carrying the intermediate config (see
+            // `PresentationHandle::settings_open_changed`).
+            if !announce {
+                return;
+            }
+
             dispatch_event(&elem, "toggle-settings", open).unwrap();
             if let Some(panel) = workspace.active_panel() {
                 dispatch_config_update(&elem, &panel.session, &panel.renderer, &presentation);
@@ -261,7 +274,36 @@ pub fn wire_element_events(
         }
     });
 
+    let layout_sub = workspace.layout_changed().add_listener({
+        clone!(elem);
+        move |panels: Vec<crate::workspace::PanelId>| {
+            let ids = panels
+                .iter()
+                .map(|id| JsValue::from_str(id.as_str()))
+                .collect::<js_sys::Array>();
+
+            let detail = js_sys::Object::new();
+            let _ = js_sys::Reflect::set(&detail, &JsValue::from_str("panels"), &ids);
+            dispatch_event(&elem, "layout-update", JsValue::from(detail)).unwrap();
+        }
+    });
+
+    let active_panel_sub = workspace.active_changed().add_listener({
+        clone!(elem);
+        move |active: Option<crate::workspace::PanelId>| {
+            let panel = active
+                .map(|id| JsValue::from_str(id.as_str()))
+                .unwrap_or(JsValue::NULL);
+
+            let detail = js_sys::Object::new();
+            let _ = js_sys::Reflect::set(&detail, &JsValue::from_str("panel"), &panel);
+            dispatch_event(&elem, "active-panel-update", JsValue::from(detail)).unwrap();
+        }
+    });
+
     vec![
+        layout_sub,
+        active_panel_sub,
         theme_sub,
         before_settings_sub,
         settings_sub,

package/src/rust/js/regular_layout.rs

@@ -235,9 +235,9 @@ impl Layout {
     }
 
     /// Rewrite every panel id through `f`, returning the remapped tree. Ids for
-    /// which `f` returns `None` are left unchanged. Used by whole-element
-    /// `restore`, which recreates panels under fresh (collision-free) ids and
-    /// must point the saved layout tree at them.
+    /// which `f` returns `None` are left unchanged. Used by `restoreWorkspace`,
+    /// which recreates panels under fresh (collision-free) ids and must point
+    /// the saved layout tree at them.
     pub fn remap(&self, f: &impl Fn(&str) -> Option<String>) -> Layout {
         match self {
             Layout::Split(split) => Layout::Split(SplitLayout {

package/src/rust/lib.rs

@@ -31,6 +31,8 @@
 // `SESSION_CONFIG_COHERENCE_PLAN.md`) — deny, don't warn.
 #![deny(clippy::await_holding_refcell_ref)]
 
+#[cfg(feature = "llm-agent")]
+mod agent;
 pub mod components;
 pub mod config;
 pub mod custom_elements;
@@ -86,22 +88,35 @@ import type {
 
 export type * from "../../src/ts/ts-rs/ViewerConfig.d.ts";
 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/WorkspaceConfigUpdate.d.ts";
 export type * from "../../src/ts/ts-rs/ExportMethod.d.ts";
 export type * from "../../src/ts/ts-rs/PanelOptions.d.ts";
+export type * from "../../src/ts/ts-rs/RestoreOptions.d.ts";
+export type * from "../../src/ts/ts-rs/SaveWorkspaceOptions.d.ts";
 export type * from "../../src/ts/ts-rs/ClientOptions.d.ts";
 export type * from "../../src/ts/ts-rs/ExportOptions.d.ts";
 export type * from "../../src/ts/ts-rs/GetTableOptions.d.ts";
 export type * from "../../src/ts/ts-rs/GetClientOptions.d.ts";
+export type * from "../../src/ts/ts-rs/CustomNumberFormatConfig.d.ts";
+export type * from "../../src/ts/ts-rs/NumberFormatStyle.d.ts";
+export type * from "../../src/ts/ts-rs/Notation.d.ts";
+export type * from "../../src/ts/ts-rs/DatetimeFormatType.d.ts";
+export type * from "../../src/ts/ts-rs/StringColorMode.d.ts";
+export type * from "../../src/ts/ts-rs/DatetimeColorMode.d.ts";
+export type * from "../../src/ts/ts-rs/FormatMode.d.ts";
 import type {GetTableOptions} from "../../src/ts/ts-rs/GetTableOptions.d.ts";
 import type {PanelOptions} from "../../src/ts/ts-rs/PanelOptions.d.ts";
+import type {RestoreOptions} from "../../src/ts/ts-rs/RestoreOptions.d.ts";
+import type {SaveWorkspaceOptions} from "../../src/ts/ts-rs/SaveWorkspaceOptions.d.ts";
 import type {ExportOptions} from "../../src/ts/ts-rs/ExportOptions.d.ts";
 import type {GetClientOptions} from "../../src/ts/ts-rs/GetClientOptions.d.ts";
 import type {ClientOptions} from "../../src/ts/ts-rs/ClientOptions.d.ts";
 import type {ViewerConfig} from "../../src/ts/ts-rs/ViewerConfig.d.ts";
 import type {ViewerConfigUpdate} from "../../src/ts/ts-rs/ViewerConfigUpdate.d.ts";
+import type {ViewerConfigInitial} from "../../src/ts/ts-rs/ViewerConfigInitial.d.ts";
 import type {WorkspaceConfig} from "../../src/ts/ts-rs/WorkspaceConfig.d.ts";
 import type {WorkspaceConfigUpdate} from "../../src/ts/ts-rs/WorkspaceConfigUpdate.d.ts";
 "#;

package/src/rust/presentation/column_locator.rs

@@ -66,6 +66,23 @@ impl ColumnLocator {
     }
 }
 
+/// What the column-settings drawer is opened on, as held in presentation
+/// state: a column by name, or the not-yet-saved expression.
+#[derive(Clone, Debug, PartialEq)]
+pub enum ColumnSettingsTarget {
+    Column(String),
+    NewExpression,
+}
+
+impl ColumnSettingsTarget {
+    pub fn name(&self) -> Option<&String> {
+        match self {
+            Self::Column(name) => Some(name),
+            Self::NewExpression => None,
+        }
+    }
+}
+
 #[derive(Debug, Default, Clone, Copy, PartialEq)]
 
 pub enum ColumnSettingsTab {
@@ -83,16 +100,13 @@ impl Display for ColumnSettingsTab {
 
 #[derive(Clone, Default, Debug, PartialEq)]
 pub struct OpenColumnSettings {
-    pub locator: Option<ColumnLocator>,
+    pub target: Option<ColumnSettingsTarget>,
     pub tab: Option<ColumnSettingsTab>,
 }
 
 impl OpenColumnSettings {
     pub fn name(&self) -> Option<String> {
-        self.locator
-            .as_ref()
-            .and_then(|l| l.name())
-            .map(|s| s.to_owned())
+        self.target.as_ref().and_then(|t| t.name()).cloned()
     }
 }
 

package/src/rust/presentation.rs

@@ -15,8 +15,8 @@ pub mod drag_helpers;
 mod props;
 mod sheets;
 
-use std::cell::RefCell;
-use std::collections::HashSet;
+use std::cell::{Cell, RefCell};
+use std::collections::{BTreeMap, HashSet};
 use std::ops::Deref;
 use std::rc::Rc;
 
@@ -27,10 +27,13 @@ use web_sys::*;
 use yew::html::ImplicitClone;
 use yew::prelude::*;
 
-pub use self::column_locator::{ColumnLocator, ColumnSettingsTab, ColumnTab, OpenColumnSettings};
+pub use self::column_locator::{
+    ColumnLocator, ColumnSettingsTab, ColumnSettingsTarget, ColumnTab, OpenColumnSettings,
+};
 use self::drag_helpers::DragTargetState;
 pub use self::drag_helpers::{DragDropContainer, DragEndCallback};
 pub use self::props::{DragDropProps, PresentationProps};
+use crate::config::{CssKind, NamedValue, assign_palette_names};
 use crate::utils::*;
 
 #[derive(Clone, Debug)]
@@ -63,6 +66,12 @@ impl DragState {
 pub struct PresentationHandle {
     viewer_elem: HtmlElement,
 
+    /// The embedded LLM agent's shared model (runtime + chat transcript) —
+    /// carried here so the settings sidebar can render the chat tab without
+    /// threading a new prop chain from the element.
+    #[cfg(feature = "llm-agent")]
+    pub agent: crate::agent::AgentSlot,
+
     /// The available themes as detected in the browser environment or set
     /// explicitly when CORS prevents detection — a MEMO of a document
     /// external, not component state. `None` until first parsed (detection
@@ -79,6 +88,18 @@ pub struct PresentationHandle {
     /// concurrent `get_available_themes` calls await one parse instead of
     /// racing their own.
     theme_init: Mutex<()>,
+
+    /// Whether the host's theme was ever EXPLICITLY chosen — authored as a
+    /// `theme` attribute, or set by name through [`Self::set_theme_name`].
+    ///
+    /// `false` means the host merely displays the registry default, which
+    /// [`Self::reset_themes`] is free to move; `true` pins the selection
+    /// until it leaves the registry. The `theme` attribute alone cannot
+    /// carry this, because `init` stamps it unconditionally so the document
+    /// cascade has a theme to match.
+    theme_selected: Cell<bool>,
+
+    palette: RefCell<BTreeMap<String, String>>,
     is_settings_open: RefCell<bool>,
     open_column_settings: RefCell<OpenColumnSettings>,
     is_workspace: RefCell<Option<bool>>,
@@ -103,11 +124,20 @@ pub struct PresentationHandle {
     /// dragged element from the shadow tree.
     host_dragend: RefCell<Option<DragEndCallback>>,
 
+    source_dragend: RefCell<Option<(web_sys::EventTarget, DragEndCallback)>>,
+
     /// IntersectionObserver-based fallback for the drag image, kept alive for
     /// the duration of the drag.
     drag_target: RefCell<Option<DragTargetState>>,
 
-    pub settings_open_changed: PubSub<bool>,
+    /// `(open, announce)` — `announce` says this toggle is the SOLE carrier
+    /// of the config change (a user gesture: toolbar, `toggleConfig`), so
+    /// the element must emit `toggle-settings` + a config-update for it. An
+    /// API restore's toggle is announced by its own view-config commit
+    /// dispatch instead — announcing here too would double-emit, the first
+    /// carrying the intermediate config (settings flipped, view fields not
+    /// yet committed).
+    pub settings_open_changed: PubSub<(bool, bool)>,
 
     /// Injected callback from the root component, replacing the former
     /// `is_workspace_changed: PubSub` field.
@@ -148,8 +178,12 @@ impl Presentation {
     pub fn new(elem: &HtmlElement) -> Self {
         let theme = Self(Rc::new(PresentationHandle {
             viewer_elem: elem.clone(),
+            #[cfg(feature = "llm-agent")]
+            agent: Default::default(),
             themes: Default::default(),
             theme_init: Default::default(),
+            theme_selected: Cell::new(elem.get_attribute("theme").is_some()),
+            palette: Default::default(),
             is_workspace: Default::default(),
             settings_open_changed: Default::default(),
             settings_before_open_changed: Default::default(),
@@ -165,6 +199,7 @@ impl Presentation {
             on_dragstart: Default::default(),
             on_dragend: Default::default(),
             host_dragend: Default::default(),
+            source_dragend: Default::default(),
             drag_target: Default::default(),
         }));
 
@@ -230,13 +265,84 @@ impl Presentation {
         }
     }
 
-    pub fn set_settings_open(&self, open: bool) {
-        self.settings_open_changed.emit(open);
+    /// See [`PresentationHandle::settings_open_changed`] for `announce`.
+    pub fn set_settings_open(&self, open: bool, announce: bool) {
+        self.settings_open_changed.emit((open, announce));
     }
 
     /// Sets the currently opened column settings. Emits an internal event on
     /// change. Passing None is a shorthand for setting all fields to
     /// None.
+    /// The workspace palette as last restored (canonical values).
+    pub fn palette(&self) -> BTreeMap<String, String> {
+        self.0.palette.borrow().clone()
+    }
+
+    /// Replace the host palette: every previously-applied `--psp-user--*`
+    /// inline property is removed, then `palette` is applied.
+    pub fn set_palette(&self, palette: BTreeMap<String, String>) -> ApiResult<()> {
+        let style = self.0.viewer_elem.style();
+        for name in self.0.palette.borrow().keys() {
+            style.remove_property(name)?;
+        }
+
+        for (name, value) in &palette {
+            style.set_property(name, value)?;
+        }
+
+        *self.0.palette.borrow_mut() = palette;
+        Ok(())
+    }
+
+    /// Pin `literal` into the restored palette, named by the same rules
+    /// as the derived set and applied to the host.
+    pub fn pin_style(&self, kind: CssKind, literal: &str) -> ApiResult<()> {
+        let Ok(value) = kind.canonicalize(literal) else {
+            return Ok(());
+        };
+
+        let current = self.palette();
+        let host = self.host_named_values(kind);
+        let set = assign_palette_names(&current, &host, &[(kind, value)], &|name| {
+            self.resolve_css_var(name).is_some()
+        });
+
+        let style = self.0.viewer_elem.style();
+        for (name, value) in &set {
+            if !current.contains_key(name) {
+                style.set_property(name, value)?;
+            }
+        }
+
+        *self.0.palette.borrow_mut() = set;
+        Ok(())
+    }
+
+    /// The host's computed value for custom property `name` (inline
+    /// palette, then theme/page stylesheets), or `None` if undefined.
+    pub fn resolve_css_var(&self, name: &str) -> Option<String> {
+        read_custom_property(&self.0.viewer_elem, name)
+    }
+
+    /// Theme/page-authored named values of `kind` on the host, canonical,
+    /// discovered by the contiguous-numbering walk `--psp-user--<kind>-1`,
+    /// `-2`, … up to the first undefined name.
+    pub fn host_named_values(&self, kind: CssKind) -> Vec<NamedValue> {
+        let mut out = vec![];
+        for n in 1.. {
+            let name = format!("{}{n}", kind.var_prefix());
+            let Some(raw) = self.resolve_css_var(&name) else {
+                break;
+            };
+
+            if let Ok(value) = kind.canonicalize(&raw) {
+                out.push(NamedValue { name, value });
+            }
+        }
+
+        out
+    }
+
     pub fn set_open_column_settings(&self, settings: Option<OpenColumnSettings>) {
         let settings = settings.unwrap_or_default();
         if *(self.open_column_settings.borrow()) != settings {
@@ -307,22 +413,24 @@ impl Presentation {
         index.and_then(|x| themes.get(x).cloned())
     }
 
-    /// The default theme (first registered), used to resolve a panel's
-    /// effective theme when it has no per-panel override. `None` if no
+    /// The theme a NEW panel is born with: the host's if it has one, else
+    /// the registry default. Synchronous, because panel creation is — the
+    /// registry fallback is `None` until the registry first parses, which
+    /// [`crate::tasks::seed_panel_theme`] fills in.
+    pub fn active_theme_name_sync(&self) -> Option<String> {
+        self.0
+            .viewer_elem
+            .get_attribute("theme")
+            .or_else(|| self.0.themes.borrow().as_ref()?.first().cloned())
+    }
+
+    /// The registry default — the FIRST registered theme, which a panel or
+    /// host resolves to only when it has no theme of its own. `None` if no
     /// themes exist.
     pub async fn get_default_theme_name(&self) -> Option<String> {
         self.get_available_themes().await.ok()?.first().cloned()
     }
 
-    /// SYNC read of the registry default theme name, derived on demand from
-    /// the memoized registry — `None` until the registry first parses (or
-    /// when no themes exist). For synchronous stamping paths that must not
-    /// await registry init; prefer [`Self::get_default_theme_name`] where
-    /// awaiting is acceptable.
-    pub fn default_theme_name_sync(&self) -> Option<String> {
-        self.0.themes.borrow().as_ref()?.first().cloned()
-    }
-
     fn set_theme_attribute(&self, theme: Option<&str>) -> ApiResult<()> {
         if let Some(theme) = theme {
             Ok(self.0.viewer_elem.set_attribute("theme", theme)?)
@@ -333,12 +441,39 @@ impl Presentation {
 
     pub async fn reset_theme(&self) -> ApiResult<()> {
         *self.0.is_workspace.borrow_mut() = None;
-        let themes = self.get_available_themes().await?;
-        let default_theme = themes.first().map(|x| x.as_str());
-        self.set_theme_name(default_theme).await?;
+        self.set_theme_name(None).await?;
         Ok(())
     }
 
+    /// Adopt `themes` as the available set, KEEPING the host's theme unless
+    /// it was never explicitly chosen or has left the set — the only two
+    /// cases in which re-ordering the registry may move the viewer.
+    ///
+    /// Always re-stamps; the caller publishes ([`Self::publish_theme_config`])
+    /// once its restyles have resolved, because the available list has
+    /// changed even when the selection has not.
+    ///
+    /// @param themes the new set, or `None` to re-parse the document.
+    ///
+    /// # Returns
+    /// The active theme after the change.
+    pub async fn reset_themes(&self, themes: Option<Vec<String>>) -> ApiResult<Option<String>> {
+        let selected = self
+            .0
+            .theme_selected
+            .get()
+            .then(|| self.0.viewer_elem.get_attribute("theme"))
+            .flatten();
+
+        self.reset_available_themes(themes).await;
+        let available = self.get_available_themes().await?;
+        let kept = selected.filter(|name| available.contains(name));
+        self.0.theme_selected.set(kept.is_some());
+        let active = kept.or_else(|| available.first().cloned());
+        self.set_theme_attribute(active.as_deref())?;
+        Ok(active)
+    }
+
     /// Set the theme by name, or `None` for the default theme.
     ///
     /// A NAMED theme's host attribute write is SYNCHRONOUS ("stamp with
@@ -360,6 +495,7 @@ impl Presentation {
     /// # Returns
     /// A `bool` indicating whether the internal state changed.
     pub async fn set_theme_name(&self, theme: Option<&str>) -> ApiResult<bool> {
+        self.0.theme_selected.set(theme.is_some());
         if let Some(theme) = theme {
             if self.0.viewer_elem.get_attribute("theme").as_deref() == Some(theme) {
                 return Ok(false);
@@ -369,20 +505,27 @@ impl Presentation {
         }
 
         let themes = self.get_available_themes().await?;
-        let index = if let Some(theme) = theme {
-            themes.iter().position(|x| x == theme)
-        } else if !themes.is_empty() {
+        if theme.is_none() {
             self.set_theme_attribute(themes.first().map(|x| x.as_str()))?;
-            Some(0)
-        } else {
-            self.set_theme_attribute(None)?;
-            None
-        };
+        }
 
-        self.theme_config_updated.emit((themes, index));
         Ok(true)
     }
 
+    /// Publish the `theme_config_updated` snapshot — the available themes
+    /// and the host's current selection — to the component tree.
+    pub async fn publish_theme_config(&self) -> ApiResult<()> {
+        let themes = self.get_available_themes().await?;
+        let index = self
+            .0
+            .viewer_elem
+            .get_attribute("theme")
+            .and_then(|active| themes.iter().position(|x| *x == active));
+
+        self.theme_config_updated.emit((themes, index));
+        Ok(())
+    }
+
     /// Snapshot the drag state as a [`DragDropProps`] value for threading
     /// through the component tree without PubSub subscriptions.
     pub fn drag_drop_props(&self) -> DragDropProps {
@@ -419,6 +562,7 @@ impl Presentation {
 
     pub fn set_drag_image(&self, event: &DragEvent) -> ApiResult<()> {
         event.stop_propagation();
+        self.register_source_dragend(event)?;
         if let Some(dt) = event.data_transfer() {
             dt.set_drop_effect("move");
         }
@@ -477,8 +621,7 @@ impl Presentation {
             _ => None,
         };
 
-        self.drag_target.borrow_mut().take();
-        *self.drag_state.borrow_mut() = DragState::NoDrag;
+        self.end_drag();
         if let Some(action) = action {
             self.drop_received.emit(action);
         }
@@ -502,11 +645,15 @@ impl Presentation {
     /// End the drag/drop action by resetting the state to default.
     pub fn notify_drag_end(&self) {
         if self.drag_state.borrow().is_drag_in_progress() {
-            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(());
-            }
+            self.end_drag();
+        }
+    }
+
+    fn end_drag(&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(());
         }
     }
 
@@ -514,6 +661,23 @@ impl Presentation {
     /// element so that drag-end cleanup fires even when Yew re-renders
     /// remove the original dragged element from the shadow DOM.  The host
     /// element is outside the virtual DOM and therefore stable.
+    fn register_source_dragend(&self, event: &DragEvent) -> ApiResult<()> {
+        let target = event.target().into_apierror()?;
+        if let Some((prev_target, prev)) = self.source_dragend.borrow_mut().take() {
+            let _ = prev_target
+                .remove_event_listener_with_callback("dragend", prev.as_ref().unchecked_ref());
+        }
+
+        let this = self.clone();
+        let closure = Closure::wrap(Box::new(move |_event: DragEvent| {
+            this.notify_drag_end();
+        }) as Box<dyn FnMut(DragEvent)>);
+
+        target.add_event_listener_with_callback("dragend", closure.as_ref().unchecked_ref())?;
+        *self.source_dragend.borrow_mut() = Some((target, closure));
+        Ok(())
+    }
+
     fn register_host_dragend(&self) {
         if let Some(prev) = self.host_dragend.borrow_mut().take() {
             let _ = self

package/src/rust/queries/column_locator.rs

@@ -12,26 +12,29 @@
 
 use perspective_client::config::ViewConfig;
 
-use crate::presentation::{ColumnLocator, OpenColumnSettings};
+use crate::presentation::{ColumnLocator, ColumnSettingsTarget, OpenColumnSettings};
 use crate::renderer::Renderer;
 use crate::session::SessionMetadata;
 
-/// Returns a [`ColumnLocator`] for a given column name, or [`None`] if no
-/// such column exists.
-pub fn get_column_locator(
+/// Classify a column name against the session, config-first: the view
+/// config is the commit of record for expressions and windows.
+pub fn classify_column(
+    name: &str,
+    view_config: &ViewConfig,
     metadata: &SessionMetadata,
-    name: Option<String>,
 ) -> Option<ColumnLocator> {
-    name.and_then(|name| {
-        if metadata.is_column_expression(&name) {
-            Some(ColumnLocator::Expression(name))
-        } else {
-            metadata.get_table_columns().and_then(|x| {
-                x.iter()
-                    .find_map(|n| (n == &name).then_some(ColumnLocator::Table(name.clone())))
-            })
-        }
-    })
+    if view_config.windows.contains_key(name) || metadata.is_column_window(name) {
+        Some(ColumnLocator::Window(name.to_owned()))
+    } else if view_config.expressions.contains_key(name) || metadata.is_column_expression(name) {
+        Some(ColumnLocator::Expression(name.to_owned()))
+    } else if metadata
+        .get_table_columns()
+        .is_some_and(|cols| cols.iter().any(|col| col == name))
+    {
+        Some(ColumnLocator::Table(name.to_owned()))
+    } else {
+        None
+    }
 }
 
 /// Gets a [`ColumnLocator`] for the current UI's column settings state,
@@ -43,35 +46,62 @@ pub fn get_current_column_locator(
     open_column_settings: &OpenColumnSettings,
     renderer: &Renderer,
     view_config: &ViewConfig,
-    _metadata: &SessionMetadata,
+    metadata: &SessionMetadata,
 ) -> Option<ColumnLocator> {
-    open_column_settings
-        .locator
-        .clone()
-        .filter(|locator| match locator {
-            ColumnLocator::Table(_name) => {
-                locator
-                    .name()
-                    .map(|name| {
-                        view_config.columns.iter().any(|maybe_col| {
-                            maybe_col
-                                .as_ref()
-                                .map(|col| col == name)
-                                .unwrap_or_default()
+    match open_column_settings.target.as_ref()? {
+        ColumnSettingsTarget::NewExpression => Some(ColumnLocator::NewExpression),
+        ColumnSettingsTarget::Column(name) => {
+            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)
+                },
+                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);
+    }
 
-                            //     }) || view_config.group_by.iter().any(|col|
-                            // col == name)         ||
-                            // view_config.split_by.iter().any(|col| col ==
-                            // name)         ||
-                            // view_config.filter.iter().any(|col| col.column()
-                            // == name)         ||
-                            // view_config.sort.iter().any(|col| &col.0 == name)
-                            // })
-                        })
-                    })
-                    .unwrap_or_default()
-                    && renderer.can_render_column_styles()
-            },
-            _ => true,
-        })
+    #[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()))
+        );
+    }
 }