@perspective-dev/viewer 5.3.0 → 5.4.0

package/src/rust/config/datetime_column_style.rs

@@ -41,10 +41,6 @@ impl Default for DatetimeFormatType {
 }
 
 impl DatetimeFormatType {
-    fn is_simple(&self) -> bool {
-        self == &Self::Simple(SimpleDatetimeStyleConfig::default())
-    }
-
     pub fn time_zone(&self) -> &Option<String> {
         match self {
             DatetimeFormatType::Custom(x) => &x.time_zone,
@@ -62,12 +58,13 @@ impl DatetimeFormatType {
 
 /// A model for the JSON serialized style configuration for a column of type
 /// `datetime`.
-#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize, TS)]
+#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq, Serialize, TS)]
 // #[derive(WasmDescribe!, FromWasmAbi!)]
 pub struct DatetimeColumnStyleConfig {
     #[serde(default)]
-    #[serde(skip_serializing_if = "DatetimeFormatType::is_simple")]
-    pub date_format: DatetimeFormatType,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[ts(optional, as = "Option<_>")]
+    pub date_format: Option<DatetimeFormatType>,
 
     #[serde(default)]
     #[serde(skip_serializing_if = "DatetimeColorMode::is_none")]
@@ -78,17 +75,3 @@ pub struct DatetimeColumnStyleConfig {
     #[ts(skip)]
     pub color: Option<String>,
 }
-
-impl Default for DatetimeColumnStyleConfig {
-    fn default() -> Self {
-        Self {
-            date_format: DatetimeFormatType::Simple(SimpleDatetimeStyleConfig {
-                time_zone: Default::default(),
-                date_style: SimpleDatetimeFormat::Short,
-                time_style: SimpleDatetimeFormat::Medium,
-            }),
-            datetime_color_mode: Default::default(),
-            color: Default::default(),
-        }
-    }
-}

package/src/rust/config/mod.rs

@@ -15,7 +15,6 @@
 
 mod column_config_schema;
 mod columns_config;
-mod css_scale;
 mod datetime_column_style;
 mod export_method;
 mod kvpair;
@@ -30,7 +29,6 @@ mod workspace_config;
 
 pub use column_config_schema::*;
 pub use columns_config::*;
-pub use css_scale::*;
 pub use datetime_column_style::*;
 pub use export_method::*;
 pub use number_series_style::*;

package/src/rust/config/number_string_format.rs

@@ -255,13 +255,106 @@ pub struct CustomNumberFormatConfig {
     pub sign_display: Option<SignDisplay>,
 }
 
+/// The active plugin's `NumberFormat` default overlaid on the built-in
+/// `number_format` values.
+#[derive(Clone, Debug, PartialEq)]
+pub struct NumberFormatDefaults {
+    pub is_float: bool,
+    pub style: NumberFormatStyle,
+    pub notation: Notation,
+    pub minimum_integer_digits: f64,
+    pub fraction: (f64, f64),
+    pub significant: (f64, f64),
+    pub rounding_priority: RoundingPriority,
+    pub rounding_mode: RoundingMode,
+    pub trailing_zero_display: TrailingZeroDisplay,
+    pub use_grouping: UseGrouping,
+    pub sign_display: SignDisplay,
+}
+
+impl NumberFormatDefaults {
+    pub fn builtin(is_float: bool) -> Self {
+        Self {
+            is_float,
+            style: NumberFormatStyle::default(),
+            notation: Notation::default(),
+            minimum_integer_digits: 1.,
+            fraction: if is_float { (2., 2.) } else { (0., 0.) },
+            significant: (1., 21.),
+            rounding_priority: RoundingPriority::default(),
+            rounding_mode: RoundingMode::default(),
+            trailing_zero_display: TrailingZeroDisplay::default(),
+            use_grouping: UseGrouping::default(),
+            sign_display: SignDisplay::default(),
+        }
+    }
+
+    /// Overlay a plugin-declared partial default onto [`Self::builtin`].
+    pub fn resolve(spec_default: Option<&CustomNumberFormatConfig>, is_float: bool) -> Self {
+        let mut out = Self::builtin(is_float);
+        let Some(d) = spec_default else {
+            return out;
+        };
+
+        if let Some(style) = &d._style {
+            out.style = style.clone();
+        }
+
+        if let Some(notation) = &d._notation {
+            out.notation = notation.clone();
+        }
+
+        if let Some(v) = d.minimum_integer_digits {
+            out.minimum_integer_digits = v;
+        }
+
+        if let Some(v) = d.minimum_fraction_digits {
+            out.fraction.0 = v;
+        }
+
+        if let Some(v) = d.maximum_fraction_digits {
+            out.fraction.1 = v;
+        }
+
+        if let Some(v) = d.minimum_significant_digits {
+            out.significant.0 = v;
+        }
+
+        if let Some(v) = d.maximum_significant_digits {
+            out.significant.1 = v;
+        }
+
+        if let Some(v) = d.rounding_priority {
+            out.rounding_priority = v;
+        }
+
+        if let Some(v) = d.rounding_mode {
+            out.rounding_mode = v;
+        }
+
+        if let Some(v) = d.trailing_zero_display {
+            out.trailing_zero_display = v;
+        }
+
+        if let Some(v) = d.use_grouping {
+            out.use_grouping = v;
+        }
+
+        if let Some(v) = d.sign_display {
+            out.sign_display = v;
+        }
+
+        out
+    }
+}
+
 impl CustomNumberFormatConfig {
-    pub fn filter_default(self, is_float: bool) -> Self {
-        let (frac_min, frac_max) = if is_float { (2., 2.) } else { (0., 0.) };
+    pub fn filter_default(self, defaults: &NumberFormatDefaults) -> Self {
+        let (frac_min, frac_max) = defaults.fraction;
         let rounding_increment = self.rounding_increment;
         let use_grouping = self
             .use_grouping
-            .filter(|val| *val != UseGrouping::default());
+            .filter(|val| *val != defaults.use_grouping);
 
         let mut minimum_fraction_digits =
             self.minimum_fraction_digits.filter(|val| *val != frac_min);
@@ -269,7 +362,7 @@ impl CustomNumberFormatConfig {
         let mut maximum_fraction_digits =
             self.maximum_fraction_digits.filter(|val| *val != frac_max);
 
-        let mut show_frac = is_float
+        let mut show_frac = defaults.is_float
             && (minimum_fraction_digits.is_some()
                 || maximum_fraction_digits.is_some()
                 || use_grouping.is_some()
@@ -277,7 +370,7 @@ impl CustomNumberFormatConfig {
                     self._style,
                     Some(NumberFormatStyle::Percent | NumberFormatStyle::Unit(_))
                 ))
-            || !is_float && matches!(self._style, Some(NumberFormatStyle::Currency(_)));
+            || !defaults.is_float && matches!(self._style, Some(NumberFormatStyle::Currency(_)));
 
         // Rounding increment does not work unless `minimum_fraction_digits`
         // and `maximum_fraction_digits` are set to 0.
@@ -287,39 +380,139 @@ impl CustomNumberFormatConfig {
             maximum_fraction_digits = Some(0.);
         }
 
-        let minimum_significant_digits = self.minimum_significant_digits.filter(|val| *val != 1.);
-        let maximum_significant_digits = self.maximum_significant_digits.filter(|val| *val != 21.);
+        let minimum_significant_digits = self
+            .minimum_significant_digits
+            .filter(|val| *val != defaults.significant.0);
+
+        let maximum_significant_digits = self
+            .maximum_significant_digits
+            .filter(|val| *val != defaults.significant.1);
+
         let show_sig = minimum_significant_digits.is_some() || maximum_significant_digits.is_some();
         Self {
-            _style: self
-                ._style
-                .filter(|style| !matches!(style, NumberFormatStyle::Decimal)),
-            minimum_integer_digits: self.minimum_integer_digits.filter(|val| *val != 1.),
+            _style: self._style.filter(|style| *style != defaults.style),
+            minimum_integer_digits: self
+                .minimum_integer_digits
+                .filter(|val| *val != defaults.minimum_integer_digits),
             minimum_fraction_digits: show_frac
                 .then_some(minimum_fraction_digits.unwrap_or(frac_min)),
             maximum_fraction_digits: show_frac
                 .then_some(maximum_fraction_digits.unwrap_or(frac_max)),
             minimum_significant_digits: show_sig
-                .then_some(minimum_significant_digits.unwrap_or(1.)),
+                .then_some(minimum_significant_digits.unwrap_or(defaults.significant.0)),
             maximum_significant_digits: show_sig
-                .then_some(minimum_significant_digits.unwrap_or(21.)),
+                .then_some(maximum_significant_digits.unwrap_or(defaults.significant.1)),
             rounding_priority: self
                 .rounding_priority
-                .filter(|val| *val != RoundingPriority::default()),
+                .filter(|val| *val != defaults.rounding_priority),
             rounding_increment,
             rounding_mode: self
                 .rounding_mode
-                .filter(|val| *val != RoundingMode::default()),
+                .filter(|val| *val != defaults.rounding_mode),
             trailing_zero_display: self
                 .trailing_zero_display
-                .filter(|val| *val != TrailingZeroDisplay::default()),
+                .filter(|val| *val != defaults.trailing_zero_display),
             _notation: self
                 ._notation
-                .filter(|notation| !matches!(notation, Notation::Standard)),
+                .filter(|notation| *notation != defaults.notation),
             use_grouping,
             sign_display: self
                 .sign_display
-                .filter(|val| *val != SignDisplay::default()),
+                .filter(|val| *val != defaults.sign_display),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn sig(min: f64, max: f64) -> CustomNumberFormatConfig {
+        CustomNumberFormatConfig {
+            minimum_significant_digits: Some(min),
+            maximum_significant_digits: Some(max),
+            ..Default::default()
         }
     }
+
+    #[test]
+    fn resolve_overlays_partial_default_on_builtin() {
+        let spec = CustomNumberFormatConfig {
+            _notation: Some(Notation::Compact(CompactDisplay::Short)),
+            minimum_fraction_digits: Some(0.),
+            maximum_fraction_digits: Some(1.),
+            ..Default::default()
+        };
+
+        let defaults = NumberFormatDefaults::resolve(Some(&spec), true);
+        assert_eq!(defaults.notation, Notation::Compact(CompactDisplay::Short));
+        assert_eq!(defaults.fraction, (0., 1.));
+        assert_eq!(defaults.style, NumberFormatStyle::Decimal);
+        assert_eq!(defaults.significant, (1., 21.));
+        assert_eq!(
+            NumberFormatDefaults::resolve(None, true),
+            NumberFormatDefaults::builtin(true)
+        );
+    }
+
+    #[test]
+    fn filter_preserves_max_significant_digits() {
+        let filtered = sig(1., 5.).filter_default(&NumberFormatDefaults::builtin(true));
+        assert_eq!(filtered.minimum_significant_digits, Some(1.));
+        assert_eq!(filtered.maximum_significant_digits, Some(5.));
+
+        let filtered = sig(3., 21.).filter_default(&NumberFormatDefaults::builtin(true));
+        assert_eq!(filtered.minimum_significant_digits, Some(3.));
+        assert_eq!(filtered.maximum_significant_digits, Some(21.));
+    }
+
+    #[test]
+    fn filter_elides_values_equal_to_resolved_defaults() {
+        let defaults = NumberFormatDefaults {
+            fraction: (0., 1.),
+            notation: Notation::Compact(CompactDisplay::Short),
+            ..NumberFormatDefaults::builtin(true)
+        };
+
+        let config = CustomNumberFormatConfig {
+            _notation: Some(Notation::Compact(CompactDisplay::Short)),
+            minimum_fraction_digits: Some(0.),
+            maximum_fraction_digits: Some(1.),
+            ..Default::default()
+        };
+
+        assert_eq!(
+            config.filter_default(&defaults),
+            CustomNumberFormatConfig::default()
+        );
+    }
+
+    #[test]
+    fn filter_serializes_builtin_values_under_override() {
+        let defaults = NumberFormatDefaults {
+            notation: Notation::Compact(CompactDisplay::Short),
+            ..NumberFormatDefaults::builtin(true)
+        };
+
+        let config = CustomNumberFormatConfig {
+            _notation: Some(Notation::Standard),
+            ..Default::default()
+        };
+
+        let filtered = config.filter_default(&defaults);
+        assert_eq!(filtered._notation, Some(Notation::Standard));
+    }
+
+    #[test]
+    fn filter_bakes_fraction_digits_for_percent_style() {
+        let config = CustomNumberFormatConfig {
+            _style: Some(NumberFormatStyle::Percent),
+            ..Default::default()
+        };
+
+        let filtered = config.filter_default(&NumberFormatDefaults::builtin(true));
+        assert_eq!(filtered._style, Some(NumberFormatStyle::Percent));
+        assert_eq!(filtered.minimum_fraction_digits, Some(2.));
+        assert_eq!(filtered.maximum_fraction_digits, Some(2.));
+    }
 }

package/src/rust/config/workspace_config.rs

@@ -14,7 +14,8 @@ use std::collections::BTreeMap;
 
 use perspective_client::config::Filter;
 
-use crate::config::{CssKind, PanelViewerConfig, ViewerConfigInitial};
+use crate::config::{PanelViewerConfig, ViewerConfigInitial};
+use crate::utils::CssKind;
 
 /// The workspace config format (`{version, active?, layout, panels}`) —
 /// the multi-panel counterpart of the single-panel [`ViewerConfig`] — as

package/src/rust/custom_elements/debug_plugin.rs

@@ -66,16 +66,7 @@ impl PerspectiveDebugPluginElement {
     }
 
     /// Delegates to `draw()` VIRTUALLY — through the JS element's `draw`
-    /// property, never `self.draw(view)` (Rust static dispatch). This
-    /// element is the documented base class for custom plugins
-    /// (`class MyPlugin extends
-    /// customElements.get("perspective-viewer-plugin")`), whose contract is
-    /// "`update()` defaults to dispatch to `draw()`" — a
-    /// subclass overriding only `draw` must receive `update`-path repaints
-    /// (`BindDisposition::Unchanged`/`Adopted` runs,
-    /// `PLUGIN_DRAW_INVARIANT_PLAN.md`); the static call bypassed the
-    /// override and repainted the Debug CSV instead (the
-    /// `view_lifecycle.spec` regression).
+    /// property, never `self.draw(view)` (Rust static dispatch).
     pub fn update(&self, view: &perspective_js::View) -> ApiFuture<()> {
         clone!(self.elem, view);
         ApiFuture::new(async move {

package/src/rust/custom_elements/mod.rs

@@ -13,8 +13,5 @@
 //! Each file in `custom_elements` exports a single struct which will be the
 //! public [`wasm_bindgen`] API to a JavaScript Custom Element.
 
-pub mod copy_dropdown;
 pub mod debug_plugin;
-pub mod export_dropdown;
-pub mod modal;
 pub mod viewer;

package/src/rust/custom_elements/viewer.rs

@@ -512,31 +512,13 @@ impl PerspectiveViewerElement {
                         .expect("just-reserved panel is present")
                 });
 
-                // Carrying `Some(notify)` marks this load as the reservation's
-                // owner — the only call that may place or discard it below.
                 (panel, Some(self.layout_changed_notify()))
             },
         };
 
-        // A `Table` payload targets this panel's engines; a `Client` registers
-        // inertly against it. Selecting the panel here (not at construction)
-        // keeps the registry race safe — by `load()` time real plugins have
-        // registered.
         let session = panel.session;
         let renderer = panel.renderer;
-
-        // Open the pending-load window SYNCHRONOUSLY, at the call site — this
-        // is what fixes the ordering. The payload's RESET disposition (a
-        // `Table` resets the view; a `Client` does not) is unknown until the
-        // promise resolves, but the window's POSITION on the config-commit
-        // stream is fixed NOW. A `restore()` a caller fires immediately after
-        // this unawaited `load()` (the React prop-binding pattern, which has
-        // no async ordering guarantees) commits INTO this window's journal and
-        // is replayed over the reset base if the payload proves to be a
-        // `Table` — so a moved-async reset can no longer clobber a later
-        // commit. See `SESSION_CONFIG_COHERENCE_PLAN.md`.
         let generation = session.begin_pending_load();
-
         clone!(self.workspace, self.presentation);
         Ok(ApiFuture::new_throttled(async move {
             let _effect = effect;

package/src/rust/js/plugin.rs

@@ -30,92 +30,6 @@ extern "C" {
     pub type JsPerspectiveViewer;
 
     /// A `<perspective-viewer>` plugin custom element.
-    ///
-    /// # Capability tiers
-    ///
-    /// Only `get_static_config`, `draw`, `save`/`restore` and `delete` are
-    /// REQUIRED. Every other method is optional — detected once per element
-    /// tag ([`PluginCapabilities`], methods live on the class prototype) —
-    /// with a defined host fallback, so a minimal plugin renders correctly
-    /// and each added method buys performance or polish, never correctness:
-    ///
-    /// | method     | host fallback when absent                              |
-    /// |------------|--------------------------------------------------------|
-    /// | `update`   | `draw` — every repaint is a full render (such plugins  |
-    /// |            | must NOT treat `draw` as a state-reset license)        |
-    /// | `resize`   | no-op — CSS reflows the box; next dispatch repaints    |
-    /// | `restyle`  | no-op — the plugin re-reads CSS at its next render     |
-    /// | `clear`    | no-op                                                  |
-    /// | `deselect` | no-op                                                  |
-    /// | `presize`  | held style-override presize (`Renderer` resize paths)  |
-    /// | `render`   | image export reports unsupported                       |
-    ///
-    /// # Call discipline
-    ///
-    /// Plugin implementations assume the host NEVER overlaps calls on the
-    /// same element: each of the rendering methods (`draw`, `update`,
-    /// `render`, `clear`, `resize`) and `delete` must run to completion
-    /// before the next begins. Every call site must therefore hold that
-    /// plugin's per-`Renderer` draw lock, witnessed by
-    /// [`crate::utils::RenderGuard`] — the guard-taking dispatch helpers
-    /// (`Renderer::draw_fresh`/`update_bound`,
-    /// `renderer::activate::activate_plugin`) and the already-locked
-    /// `render_task`/`update_lazy`/`resize`/`restyle_all`/`dispose`
-    /// entrypoints do not compile from an unlocked context. Synchronous
-    /// calls (`restore`, `restyle`, the schema queries) are exempt, though
-    /// `restyle` should ride inside a locked restyle-then-update sequence
-    /// (see `Renderer::restyle_all`).
-    ///
-    /// # Dispatch semantics (`PLUGIN_DRAW_INVARIANT_PLAN.md`, amended
-    /// 2026-07-16)
-    ///
-    /// The host invokes `draw` **iff there is a NEW `View` for this
-    /// plugin** — `bind_view` REBUILT the engine `View`, or a
-    /// freshly-selected plugin element owes its first paint of the bound
-    /// one — so implementations may treat `draw` as "new data shape"
-    /// (reset zoom/scroll/domain state). The witness enforcing this is
-    /// [`crate::session::FreshView`], which only the rebuild and
-    /// first-paint paths mint.
-    ///
-    /// `update` is a repaint of the SAME `View`, invoked iff a
-    /// plugin-visible SOURCE changed — one of exactly six: (1) data
-    /// (`View::on_update`), (2) an adopted placeholder-config delta,
-    /// (3) a genuinely CHANGED `plugin_config`/`columns_config` the host
-    /// just delivered via `restore` (so `update`-after-`restore` is the
-    /// sanctioned delivery pairing), (4) genuinely changed CSS vars just
-    /// applied via `restyle` (`Renderer::restyle_all`, or the fused
-    /// stale-capture restyle immediately preceding a dispatch inside
-    /// `draw_view` — gated by `Renderer::needs_restyle`), (5) a
-    /// render-limits change (warning dismissed), (6) an explicit PUBLIC
-    /// element-API call that reconciled as a no-op
-    /// ([`crate::tasks::RunOrigin::Public`] — the documented
-    /// `viewer.restore({})` refresh affordance). An INTERNAL run that
-    /// changed none of these dispatches nothing.
-    ///
-    /// `resize` is geometry/chrome only, from retained state (and is also
-    /// the activation-chrome nudge — implementations should no-op it
-    /// while hidden).
-    ///
-    /// `restore`/`save` are state transfer, NOT rendering: plugins must
-    /// not render internally from them, and must not call host APIs from
-    /// inside `restore` (a `restore`-triggered `restorePanel` echo is how
-    /// the initial-load double render happened — user gestures may echo,
-    /// host-delivered restores must not). (The built-in `Debug` plugin's
-    /// own `resize()` delegating to its `draw()` is plugin-INTERNAL and
-    /// exempt.)
-    ///
-    /// # Render-callable contract (invariant I5,
-    /// `SESSION_CONFIG_COHERENCE_PLAN.md`)
-    ///
-    /// From inside `draw`/`update`/`render`/`resize`, a plugin may call
-    /// back into its host `<perspective-viewer>` ONLY the per-panel
-    /// snapshot getters — `getViewConfigPanel`, `getTablePanel`,
-    /// `getClientPanel`, `getEditPortPanel` — which answer from the run's
-    /// pinned `RenderContext`, so plugin-visible state always equals the
-    /// snapshot being drawn, never a fresher in-flight commit.
-    /// Lock-acquiring host methods (`savePanel`, `restorePanel`, `flush`,
-    /// `download`/`export`/`copy`, …) DEADLOCK on the non-reentrant draw
-    /// lock if called from a render and are forbidden.
     #[derive(Clone)]
     pub type JsPerspectiveViewerPlugin;
 

package/src/rust/lib.rs

@@ -26,9 +26,6 @@
     clippy::fallible_impl_from,
     clippy::unneeded_field_pattern
 )]
-// Holding a `Ref` across an `await` is the sibling footgun of the config
-// write-back race this crate was rearchitected against (see
-// `SESSION_CONFIG_COHERENCE_PLAN.md`) — deny, don't warn.
 #![deny(clippy::await_holding_refcell_ref)]
 
 #[cfg(feature = "llm-agent")]
@@ -49,6 +46,7 @@ mod session;
 
 #[doc(hidden)]
 pub mod tasks;
+pub mod ui;
 pub mod utils;
 mod workspace;
 
@@ -61,9 +59,7 @@ use std::cell::RefCell;
 use perspective_js::utils::*;
 use wasm_bindgen::prelude::*;
 
-use crate::custom_elements::copy_dropdown::CopyDropDownMenuElement;
 use crate::custom_elements::debug_plugin::PerspectiveDebugPluginElement;
-use crate::custom_elements::export_dropdown::ExportDropDownMenuElement;
 use crate::custom_elements::viewer::PerspectiveViewerElement;
 use crate::utils::define_web_component;
 
@@ -71,19 +67,21 @@ use crate::utils::define_web_component;
 const TS_APPEND_CONTENT: &'static str = r#"
 import type {
     ColumnType,
-    TableInitOptions,
     ColumnWindow,
-    ViewWindow,
-    TypedArrayWindow,
-    OnUpdateOptions,
+    DeleteOptions,
+    Features,
     JoinOptions,
+    OnRemoveData,
+    OnUpdateData,
+    OnUpdateOptions,
+    Scalar,
+    SystemInfo,
+    TableInitOptions,
+    TypedArrayWindow,
     UpdateOptions,
-    DeleteOptions,
     ViewConfig,
     ViewConfigUpdate,
-    SystemInfo,
-    Scalar,
-    Features,
+    ViewWindow,
 } from "@perspective-dev/client";
 
 export type * from "../../src/ts/ts-rs/ViewerConfig.d.ts";
@@ -107,6 +105,7 @@ 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";
@@ -177,8 +176,6 @@ pub fn js_get_worker_url() -> Result<web_sys::Url, JsValue> {
 pub fn bootstrap_web_components(psp: &JsValue) {
     define_web_component::<PerspectiveViewerElement>(psp);
     define_web_component::<PerspectiveDebugPluginElement>(psp);
-    define_web_component::<CopyDropDownMenuElement>(psp);
-    define_web_component::<ExportDropDownMenuElement>(psp);
 }
 
 /// Defining the web components needs an extern struct to reference the

package/src/rust/presentation/column_locator.rs

@@ -12,6 +12,8 @@
 
 use std::fmt::Display;
 
+use crate::ui::TabItem;
+
 /// Locates a view column.
 /// Table columns are those defined on the table, but their types will reflect
 /// the view type, not the table type.
@@ -110,10 +112,4 @@ impl OpenColumnSettings {
     }
 }
 
-pub trait ColumnTab: PartialEq + Display + Clone + Default + 'static {}
-
-impl ColumnTab for String {}
-
-impl ColumnTab for &'static str {}
-
-impl ColumnTab for ColumnSettingsTab {}
+impl TabItem for ColumnSettingsTab {}