@perspective-dev/viewer 4.0.0

package/src/rust/model/columns_iter_set.rs

@@ -0,0 +1,340 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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::HashSet;
+
+use itertools::Itertools;
+use perspective_client::config::*;
+
+use super::{HasRenderer, HasSession, IsInvalidDrop};
+use crate::dragdrop::*;
+use crate::renderer::*;
+use crate::session::*;
+use crate::*;
+
+/// The possible states of a column (row) in the active columns list, including
+/// the `Option<String>` label type.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ActiveColumnState {
+    pub label: Label,
+    pub state: ActiveColumnStateData,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum ActiveColumnStateData {
+    Column(String),
+    Required,
+    DragOver,
+    Invalid,
+}
+
+impl From<&Option<String>> for ActiveColumnStateData {
+    fn from(value: &Option<String>) -> Self {
+        match value {
+            Some(x) => Self::Column(x.to_string()),
+            None => Self::Required,
+        }
+    }
+}
+
+impl ActiveColumnState {
+    pub fn get_name(&self) -> Option<&'_ str> {
+        match &self.state {
+            ActiveColumnStateData::Column(x) => Some(x.as_str()),
+            _ => None,
+        }
+    }
+}
+
+type Label = Option<String>;
+
+/// An iterator for columns state.
+///
+/// Encapsulates the logic of determining which columns go in the "Active" and
+/// "Inactive" column sections of the `ColumnSelector` component, via the
+/// iterator returning functions `active()`, `inactive()` and `expression()`.
+pub struct ColumnsIteratorSet<'a> {
+    config: &'a ViewConfig,
+    session: &'a Session,
+    renderer: &'a Renderer,
+    metadata: MetadataRef<'a>,
+    is_dragover_column: Option<(usize, String)>,
+    named_columns: Vec<String>,
+}
+
+impl HasRenderer for ColumnsIteratorSet<'_> {
+    fn renderer(&self) -> &'_ Renderer {
+        self.renderer
+    }
+}
+impl HasSession for ColumnsIteratorSet<'_> {
+    fn session(&self) -> &'_ Session {
+        self.session
+    }
+}
+
+impl<'a> ColumnsIteratorSet<'a> {
+    pub fn new(
+        config: &'a ViewConfig,
+        session: &'a Session,
+        renderer: &'a Renderer,
+        dragdrop: &DragDrop,
+    ) -> ColumnsIteratorSet<'a> {
+        let is_dragover_column = dragdrop.is_dragover(DragTarget::Active);
+        let named_columns = renderer.metadata().names.clone().unwrap_or_default();
+        ColumnsIteratorSet {
+            config,
+            session,
+            renderer,
+            metadata: session.metadata(),
+            is_dragover_column,
+            named_columns,
+        }
+    }
+
+    /// Generate an iterator for active columns, which are represented as
+    /// `Option` for dragover and missing columns.
+    pub fn active(&'a self) -> impl Iterator<Item = ActiveColumnState> + 'a {
+        let min_cols = self
+            .renderer
+            .metadata()
+            .names
+            .as_ref()
+            .map_or(0, |x| x.len());
+
+        let last_col = self.config.columns.last().and_then(|x| x.as_ref());
+        let has_blank_tail = last_col.is_none()
+            || self.config.columns.len() < self.named_columns.len()
+            || self.config.columns.iter().filter(|x| x.is_some()).count()
+                == self
+                    .session
+                    .metadata()
+                    .get_table_columns()
+                    .map(|x| x.len())
+                    .unwrap_or_default()
+                    + self.config.expressions.len();
+
+        match &self.is_dragover_column {
+            Some((to_index, from_column)) => {
+                let is_to_swap = self.renderer.metadata().is_swap(*to_index);
+                let to_column = self.config.columns.get(*to_index);
+                let is_to_empty = to_column.map(|x| x.is_none()).unwrap_or_default();
+                let from_index = self
+                    .config
+                    .columns
+                    .iter()
+                    .position(|x| x.as_ref() == Some(from_column));
+
+                let is_from_required = from_index
+                    .and_then(|x| self.renderer.metadata().min.map(|y| x < y))
+                    .unwrap_or_default();
+
+                let is_from_swap = from_index
+                    .map(|x| self.renderer.metadata().is_swap(x))
+                    .unwrap_or_default();
+
+                let is_swap_invalid = self.is_invalid_columns_column(from_column, *to_index);
+                let is_dragover_after_last = *to_index == self.config.columns.len();
+                if is_swap_invalid {
+                    let all_columns = self.config.columns.iter().map(|x| x.into());
+                    let before_cols = all_columns
+                        .clone()
+                        .pad_using(min_cols, |_| ActiveColumnStateData::Required)
+                        .take(*to_index);
+
+                    let after_cols = all_columns.skip(*to_index + 1);
+                    self.to_active_column_state(Box::new(
+                        before_cols
+                            .chain(std::iter::once(ActiveColumnStateData::Invalid))
+                            .chain(after_cols),
+                    ))
+                } else if is_to_swap || is_from_required {
+                    let all_columns = self.config.columns.iter().filter_map(move |x| match x {
+                        Some(x) if x == from_column => {
+                            if is_to_empty && !is_from_swap {
+                                None
+                            } else {
+                                Some(to_column.unwrap_or(&None).into())
+                            }
+                        },
+                        x => Some(x.into()),
+                    });
+
+                    let before_cols = all_columns
+                        .clone()
+                        .pad_using(min_cols, |_| ActiveColumnStateData::Required)
+                        .take(*to_index);
+
+                    let after_cols = all_columns.skip(*to_index + 1);
+                    self.to_active_column_state(Box::new(
+                        before_cols
+                            .chain(std::iter::once(ActiveColumnStateData::DragOver))
+                            .chain(after_cols),
+                    ))
+                } else if !is_from_swap && from_index.is_some() && is_dragover_after_last {
+                    let iter = self.config.columns.iter().map(|x| x.into());
+                    self.to_active_column_state(Box::new(
+                        iter.chain(std::iter::once(ActiveColumnStateData::Invalid)),
+                    ))
+                } else {
+                    let to_offset = match to_column {
+                        Some(Some(_)) => *to_index,
+                        _ => *to_index + 1,
+                    };
+
+                    let all_columns = self.config.columns.iter().filter_map(move |x| match x {
+                        Some(x) if x == from_column => {
+                            if !is_from_swap {
+                                // this is invalid
+                                None
+                            } else {
+                                Some(ActiveColumnStateData::Required)
+                            }
+                        },
+                        x => Some(x.into()),
+                    });
+
+                    let before_cols = all_columns
+                        .clone()
+                        .pad_using(min_cols, |_| ActiveColumnStateData::Required)
+                        .take(*to_index);
+
+                    let tail = if !is_from_swap && from_index.is_some() && !has_blank_tail {
+                        Some(ActiveColumnStateData::Required)
+                    } else {
+                        None
+                    };
+
+                    let after_cols = all_columns.skip(to_offset).chain(tail);
+                    self.to_active_column_state(Box::new(
+                        before_cols
+                            .chain(std::iter::once(ActiveColumnStateData::DragOver))
+                            .chain(after_cols),
+                    ))
+                }
+            },
+            _ => {
+                let iter = self.config.columns.iter().map(|x| x.into());
+                self.to_active_column_state(if has_blank_tail {
+                    Box::new(iter)
+                } else {
+                    Box::new(iter.chain(std::iter::once(ActiveColumnStateData::Required)))
+                })
+            },
+        }
+    }
+
+    fn to_active_column_state(
+        &'a self,
+        iter: Box<dyn Iterator<Item = ActiveColumnStateData> + 'a>,
+    ) -> impl Iterator<Item = ActiveColumnState> + 'a {
+        iter.pad_using(self.named_columns.len(), |_| {
+            ActiveColumnStateData::Required
+        })
+        .enumerate()
+        .map(move |(idx, state)| {
+            let label = self.named_columns.get(idx).cloned();
+            ActiveColumnState { state, label }
+        })
+    }
+
+    /// Generate an iterator for inactive expressions.
+    pub fn expression(&'a self) -> impl Iterator<Item = OrderedColumn<'a>> {
+        self.order_columns(self.metadata.get_expression_columns())
+    }
+
+    /// Generate an iterator for inactive columns, which also shows the columns
+    /// in sorted order by type, then name.
+    pub fn inactive(&'a self) -> impl Iterator<Item = OrderedColumn<'a>> {
+        self.order_columns(self.metadata.get_table_columns().into_iter().flatten())
+    }
+
+    fn order_columns(
+        &'a self,
+        values: impl Iterator<Item = &'a String>,
+    ) -> impl Iterator<Item = OrderedColumn<'a>> {
+        let is_drag_active = maybe! {
+            let dragover_col = self.is_dragover_column.as_ref();
+            let cols = &self.config.columns;
+            let (_, drag_name) = dragover_col?;
+            let is_drag_active = cols.iter().flatten().any(|x| x == drag_name);
+            Some(is_drag_active)
+        };
+
+        let col_set = self.config.columns.iter().collect::<HashSet<_>>();
+        let mut filtered = values
+            .filter_map(move |name| self.to_ordered_column(name, is_drag_active, &col_set))
+            .collect::<Vec<_>>();
+
+        filtered.sort();
+        filtered.into_iter()
+    }
+
+    /// Convert a column `name` into an `OrderedColumn` based on whether it is
+    /// active or in a drag state where an immediate drop would make it active.
+    fn to_ordered_column(
+        &'a self,
+        name: &'a str,
+        is_drag_active: Option<bool>,
+        col_set: &HashSet<&Option<String>>,
+    ) -> Option<OrderedColumn<'a>> {
+        let dragover_col = self.is_dragover_column.as_ref();
+        let cols = &self.config.columns;
+        let is_active = col_set.contains(&Some(name.to_string())); // cols.iter().flatten().any(|x| x == name);
+        let is_swap_over = maybe! {
+            let (drop_index, _) = dragover_col?;
+            let is_swap = self.renderer.metadata().is_swap(*drop_index);
+            let is_over = cols.get(*drop_index)?.as_ref()? == name;
+            Some(is_swap && is_over && !is_drag_active?)
+        };
+
+        if !is_active || is_swap_over.unwrap_or_default() {
+            let col_type = self.session.metadata().get_column_table_type(name)?;
+            let is_visible = dragover_col.is_none_or(|(_, x)| x != name);
+            Some(OrderedColumn {
+                is_visible,
+                name,
+                col_type,
+            })
+        } else {
+            None
+        }
+    }
+}
+
+pub struct OrderedColumn<'a> {
+    pub is_visible: bool,
+    pub name: &'a str,
+    col_type: ColumnType,
+}
+
+impl<'a> PartialEq for OrderedColumn<'a> {
+    fn eq(&self, rhs: &OrderedColumn<'a>) -> bool {
+        self.col_type == rhs.col_type && self.name == rhs.name
+    }
+}
+
+impl Eq for OrderedColumn<'_> {}
+
+impl<'a> PartialOrd for OrderedColumn<'a> {
+    fn partial_cmp(&self, rhs: &OrderedColumn<'a>) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(rhs))
+    }
+}
+
+impl<'a> Ord for OrderedColumn<'a> {
+    fn cmp(&self, rhs: &OrderedColumn<'a>) -> std::cmp::Ordering {
+        self.col_type
+            .cmp(&rhs.col_type)
+            .then(self.name.cmp(rhs.name))
+    }
+}

package/src/rust/model/copy_export.rs

@@ -0,0 +1,157 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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::HashSet;
+
+use futures::join;
+use itertools::Itertools;
+use perspective_client::ViewWindow;
+use perspective_js::utils::ApiResult;
+use wasm_bindgen::JsCast;
+use wasm_bindgen_futures::JsFuture;
+
+use super::export_app;
+use super::export_method::*;
+use super::get_viewer_config::*;
+use super::structural::*;
+use crate::config::*;
+use crate::js::JsPerspectiveViewerPlugin;
+use crate::utils::*;
+
+fn tag_name_to_package(plugin: &JsPerspectiveViewerPlugin) -> String {
+    let tag_name = plugin.unchecked_ref::<web_sys::HtmlElement>().tag_name();
+    let tag_parts = tag_name.split('-').take(3).map(|x| x.to_lowercase());
+    Itertools::intersperse(tag_parts, "-".to_owned()).collect::<String>()
+}
+
+/// A model trait for Copy/Export UI task behavior,
+///
+/// Export functionality, for downloads and copy-to-clipboard, are mostly shared
+/// behavior, but require access to a few state objects depending on which
+/// format is desired.  The `CopyExportModel` groups this functionality in a
+/// shared location, rather than distributing in the various state objects
+/// that are relevent per-format.
+pub trait CopyExportModel:
+    HasSession + HasRenderer + HasPresentation + GetViewerConfigModel
+{
+    async fn html_as_jsvalue(&self) -> ApiResult<web_sys::Blob> {
+        let view_config = self.get_viewer_config();
+        let session = self.session().clone();
+        let plugins = self
+            .renderer()
+            .get_all_plugins()
+            .iter()
+            .map(tag_name_to_package)
+            .collect::<HashSet<String>>()
+            .into_iter()
+            .collect::<Vec<_>>();
+
+        let (arrow, config) = join!(session.arrow_as_vec(true, None), view_config);
+        let arrow = arrow?;
+        let mut config = config?;
+        config.settings = false;
+        let js_config = serde_json::to_string(&config)?;
+        let html = export_app::render(&base64::encode(arrow), &js_config, &plugins);
+        js_sys::JsString::from(html.trim()).as_blob()
+    }
+
+    /// Create a blob of this plugin's `.png` rendering by calling the
+    /// `Plugin::render` method dynamically (as it may not exist e.g. for
+    /// datagrid).
+    ///
+    /// # Errors
+    ///
+    /// It is assumed that `Plugin::render` exists on the plugin's Custom
+    /// Element.
+    async fn png_as_jsvalue(&self) -> ApiResult<web_sys::Blob> {
+        let renderer = self.renderer().clone();
+        let plugin = renderer.get_active_plugin()?;
+        let render = js_sys::Reflect::get(&plugin, js_intern::js_intern!("render"))?;
+        let render_fun = render.unchecked_into::<js_sys::Function>();
+        let png = render_fun.call0(&plugin)?;
+        let result = JsFuture::from(png.unchecked_into::<js_sys::Promise>())
+            .await?
+            .unchecked_into();
+        Ok(result)
+    }
+
+    async fn txt_as_jsvalue(&self, viewport: Option<ViewWindow>) -> ApiResult<web_sys::Blob> {
+        let renderer = self.renderer().clone();
+        let plugin = renderer.get_active_plugin()?;
+        let render = js_sys::Reflect::get(&plugin, js_intern::js_intern!("render"))?;
+        let render_fun = render.unchecked_into::<js_sys::Function>();
+        let txt = render_fun.call1(&plugin, &serde_wasm_bindgen::to_value(&viewport)?)?;
+        let result = JsFuture::from(txt.unchecked_into::<js_sys::Promise>())
+            .await?
+            .unchecked_into();
+        Ok(result)
+    }
+
+    /// Generate a result `Blob` for all types of `ExportMethod`.
+    async fn export_method_to_jsvalue(&self, method: ExportMethod) -> ApiResult<web_sys::Blob> {
+        let viewport = self.renderer().get_selection();
+
+        match method {
+            ExportMethod::Csv => self.session().csv_as_jsvalue(false, None).await?.as_blob(),
+            ExportMethod::CsvSelected => self
+                .session()
+                .csv_as_jsvalue(false, viewport)
+                .await?
+                .as_blob(),
+            ExportMethod::CsvAll => self.session().csv_as_jsvalue(true, None).await?.as_blob(),
+            ExportMethod::Json => self.session().json_as_jsvalue(false, None).await?.as_blob(),
+            ExportMethod::JsonSelected => self
+                .session()
+                .json_as_jsvalue(false, viewport)
+                .await?
+                .as_blob(),
+            ExportMethod::JsonAll => self.session().json_as_jsvalue(true, None).await?.as_blob(),
+            ExportMethod::Ndjson => self
+                .session()
+                .ndjson_as_jsvalue(false, None)
+                .await?
+                .as_blob(),
+            ExportMethod::NdjsonSelected => self
+                .session()
+                .ndjson_as_jsvalue(false, viewport)
+                .await?
+                .as_blob(),
+            ExportMethod::NdjsonAll => self
+                .session()
+                .ndjson_as_jsvalue(true, None)
+                .await?
+                .as_blob(),
+            ExportMethod::Arrow => self
+                .session()
+                .arrow_as_jsvalue(false, None)
+                .await?
+                .as_blob(),
+            ExportMethod::ArrowSelected => self
+                .session()
+                .arrow_as_jsvalue(false, viewport)
+                .await?
+                .as_blob(),
+            ExportMethod::ArrowAll => self.session().arrow_as_jsvalue(true, None).await?.as_blob(),
+            ExportMethod::Html => self.html_as_jsvalue().await,
+            ExportMethod::Plugin if self.renderer().is_chart() => self.png_as_jsvalue().await,
+            ExportMethod::Plugin => self.txt_as_jsvalue(viewport).await,
+            ExportMethod::JsonConfig => self
+                .get_viewer_config()
+                .await?
+                .encode(&Some(ViewerConfigEncoding::JSONString))?
+                .dyn_into::<js_sys::JsString>()?
+                .as_blob(),
+        }
+    }
+}
+
+impl<T: HasRenderer + HasSession + HasPresentation> CopyExportModel for T {}

package/src/rust/model/create_col.rs

@@ -0,0 +1,59 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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 itertools::Itertools;
+
+use super::{HasPresentation, HasRenderer, HasSession, UpdateAndRender};
+use crate::config::{Expression, ViewConfigUpdate};
+use crate::utils::ApiFuture;
+
+pub trait CreateColumn: HasSession + HasPresentation + HasRenderer + UpdateAndRender {
+    fn clone_column(&self, name: &str, in_place: bool, open_settings: bool) -> ApiFuture<()> {
+        // 1. Create a new expression.
+        let expr_name = self.session().metadata().make_new_column_name(Some(name));
+        let expr = Expression::new(Some(&expr_name), &format!("\"{name}\""));
+        let view_config = self.session().get_view_config();
+        let mut serde_exprs = view_config.expressions.clone();
+        serde_exprs.retain(|name, _expr| name != &expr_name);
+        serde_exprs.insert(&expr);
+
+        // 2. Replace this column in the view configuration.
+        let mut cols = view_config.columns.clone();
+        if in_place {
+            let (idx, _val) = cols
+                .iter()
+                .find_position(|c| c.as_ref().map(|s| s == name).unwrap_or_default())
+                .unwrap_or_else(|| {
+                    web_sys::console::error_1(
+                        &format!("Couldn't find {name} in view config!").into(),
+                    );
+                    panic!();
+                });
+            cols[idx] = Some(expr_name.clone());
+        }
+
+        // 3. Ensure that the new column is opened
+        if open_settings {
+            self.presentation()
+                .set_open_column_settings(Some(expr_name));
+        }
+
+        // 4. Update
+        drop(view_config);
+        self.update_and_render(ViewConfigUpdate {
+            expressions: Some(serde_exprs),
+            columns: Some(cols),
+            ..Default::default()
+        })
+    }
+}
+impl<T: HasPresentation + HasSession + HasRenderer> CreateColumn for T {}

package/src/rust/model/edit_expression.rs

@@ -0,0 +1,95 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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 perspective_client::config::{Expression, ViewConfigUpdate};
+
+use super::UpdateAndRender;
+use super::structural::*;
+use crate::components::column_settings_sidebar::ColumnSettingsTab;
+use crate::components::viewer::ColumnLocator;
+use crate::presentation::{OpenColumnSettings, Presentation};
+use crate::renderer::Renderer;
+use crate::session::Session;
+use crate::*;
+
+#[derive(PartialEq)]
+pub struct ExpressionUpdater {
+    presentation: Presentation,
+    renderer: Renderer,
+    session: Session,
+}
+derive_model!(Presentation, Renderer, Session for ExpressionUpdater);
+
+pub trait EditExpression: HasPresentation + HasRenderer + HasSession + UpdateAndRender {
+    fn get_expression_updater(&self) -> ExpressionUpdater {
+        ExpressionUpdater {
+            presentation: self.presentation().clone(),
+            renderer: self.renderer().clone(),
+            session: self.session().clone(),
+        }
+    }
+
+    /// Spawns a future which will update the expression.
+    fn update_expr(&self, old_name: String, new_expr: Expression<'static>) {
+        let this = self.get_expression_updater();
+        ApiFuture::spawn(async move {
+            let update = this
+                .session
+                .create_replace_expression_update(&old_name, &new_expr)
+                .await;
+
+            this.presentation
+                .set_open_column_settings(Some(OpenColumnSettings {
+                    locator: Some(ColumnLocator::Expression(new_expr.name.to_string())),
+                    tab: Some(ColumnSettingsTab::Attributes),
+                }));
+
+            this.update_and_render(update)?.await?;
+            Ok(())
+        });
+    }
+
+    /// Saves a new expression. Spawns a future.
+    fn save_expr(&self, expr: Expression) -> ApiResult<()> {
+        let task = {
+            let mut serde_exprs = self.session().get_view_config().expressions.clone();
+            serde_exprs.insert(&expr);
+            self.presentation()
+                .set_open_column_settings(Some(OpenColumnSettings {
+                    locator: Some(ColumnLocator::Expression(expr.name.clone().into())),
+                    tab: Some(ColumnSettingsTab::Attributes),
+                }));
+            self.update_and_render(ViewConfigUpdate {
+                expressions: Some(serde_exprs),
+                ..Default::default()
+            })
+        }?;
+
+        ApiFuture::spawn(task);
+        Ok(())
+    }
+
+    fn delete_expr(&self, expr_name: &str) -> ApiResult<()> {
+        let mut serde_exprs = self.session().get_view_config().expressions.clone();
+        serde_exprs.remove(expr_name);
+        let config = ViewConfigUpdate {
+            expressions: Some(serde_exprs),
+            ..ViewConfigUpdate::default()
+        };
+
+        let task = self.update_and_render(config)?;
+        ApiFuture::spawn(task);
+        Ok(())
+    }
+}
+
+impl<T: HasRenderer + HasSession + HasPresentation + UpdateAndRender> EditExpression for T {}