@perspective-dev/viewer 4.0.0

package/src/rust/custom_events.rs

@@ -0,0 +1,214 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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::cell::RefCell;
+use std::ops::Deref;
+use std::rc::Rc;
+
+use perspective_client::{ViewWindow, clone};
+use perspective_js::json;
+use wasm_bindgen::prelude::*;
+use web_sys::*;
+use yew::html::ImplicitClone;
+
+use crate::config::*;
+use crate::js::JsPerspectiveViewerPlugin;
+use crate::model::*;
+use crate::presentation::Presentation;
+use crate::renderer::*;
+use crate::session::Session;
+use crate::utils::*;
+use crate::*;
+
+/// A collection of `Subscription` which should trigger an event on the
+/// JavaScript Custom Element as a `CustomEvent`.  There are no public methods
+/// on `CustomElements`, but when it is `drop()` the Custom Element will no
+/// longer dispatch events such as `"perspective-config-change"`.
+#[derive(Clone)]
+pub struct CustomEvents(Rc<(CustomEventsDataRc, [Subscription; 6])>);
+
+impl ImplicitClone for CustomEvents {}
+impl PartialEq for CustomEvents {
+    fn eq(&self, _: &Self) -> bool {
+        true
+    }
+}
+
+#[derive(Clone)]
+struct CustomEventsDataRc(Rc<CustomEventsData>);
+
+impl Deref for CustomEventsDataRc {
+    type Target = CustomEventsData;
+
+    fn deref(&self) -> &CustomEventsData {
+        &self.0
+    }
+}
+
+struct CustomEventsData {
+    elem: HtmlElement,
+    session: Session,
+    renderer: Renderer,
+    presentation: Presentation,
+    last_dispatched: RefCell<Option<ViewerConfig>>,
+}
+
+derive_model!(Renderer, Session, Presentation for CustomEventsData);
+
+impl CustomEvents {
+    pub fn new(
+        elem: &HtmlElement,
+        session: &Session,
+        renderer: &Renderer,
+        presentation: &Presentation,
+    ) -> Self {
+        let data = CustomEventsDataRc(Rc::new(CustomEventsData {
+            elem: elem.clone(),
+            session: session.clone(),
+            renderer: renderer.clone(),
+            presentation: presentation.clone(),
+            last_dispatched: Default::default(),
+        }));
+
+        let theme_sub = presentation.theme_config_updated.add_listener({
+            clone!(data);
+            move |_| data.clone().dispatch_config_update()
+        });
+
+        let settings_sub = presentation.settings_open_changed.add_listener({
+            clone!(data);
+            move |open| {
+                data.dispatch_settings_open_changed(open);
+                data.clone().dispatch_config_update();
+            }
+        });
+
+        let column_settings_sub = presentation.column_settings_open_changed.add_listener({
+            clone!(data);
+            move |(open, column_name)| {
+                data.dispatch_column_settings_open_changed(open, column_name);
+                // column_settings is ethereal; do not change the config
+            }
+        });
+
+        let plugin_sub = renderer.plugin_changed.add_listener({
+            clone!(data);
+            move |plugin| {
+                data.dispatch_plugin_changed(&plugin);
+                data.clone().dispatch_config_update();
+            }
+        });
+
+        let view_sub = session.view_created.add_listener({
+            clone!(data);
+            move |_| data.clone().dispatch_config_update()
+        });
+
+        let title_sub = presentation.title_changed.add_listener({
+            clone!(data);
+            move |_| data.clone().dispatch_config_update()
+        });
+
+        Self(Rc::new((data, [
+            theme_sub,
+            settings_sub,
+            column_settings_sub,
+            plugin_sub,
+            view_sub,
+            title_sub,
+        ])))
+    }
+
+    pub fn dispatch_column_style_changed(&self, config: &JsValue) {
+        let event_init = web_sys::CustomEventInit::new();
+        event_init.set_detail(config);
+        let event = web_sys::CustomEvent::new_with_event_init_dict(
+            "perspective-column-style-change",
+            &event_init,
+        );
+        self.0.0.elem.dispatch_event(&event.unwrap()).unwrap();
+        self.0.0.clone().dispatch_config_update();
+    }
+
+    pub fn dispatch_select(&self, view_window: Option<&ViewWindow>) -> ApiResult<()> {
+        let event_init = web_sys::CustomEventInit::new();
+        event_init.set_detail(&serde_wasm_bindgen::to_value(&view_window)?);
+        let event =
+            web_sys::CustomEvent::new_with_event_init_dict("perspective-select", &event_init);
+
+        self.0.0.elem.dispatch_event(&event.unwrap()).unwrap();
+        self.0.0.clone().dispatch_config_update();
+        Ok(())
+    }
+}
+
+impl CustomEventsDataRc {
+    fn dispatch_settings_open_changed(&self, open: bool) {
+        let event_init = web_sys::CustomEventInit::new();
+        event_init.set_detail(&JsValue::from(open));
+        let event = web_sys::CustomEvent::new_with_event_init_dict(
+            "perspective-toggle-settings",
+            &event_init,
+        );
+
+        self.elem
+            .toggle_attribute_with_force("settings", open)
+            .unwrap();
+        self.elem.dispatch_event(&event.unwrap()).unwrap();
+    }
+
+    fn dispatch_column_settings_open_changed(&self, open: bool, column_name: Option<String>) {
+        let event_init = web_sys::CustomEventInit::new();
+        event_init.set_detail(&JsValue::from(
+            json!( {"open": open, "column_name": column_name} ),
+        ));
+        let event = web_sys::CustomEvent::new_with_event_init_dict(
+            "perspective-toggle-column-settings",
+            &event_init,
+        );
+
+        self.elem.dispatch_event(&event.unwrap()).unwrap();
+    }
+
+    fn dispatch_plugin_changed(&self, plugin: &JsPerspectiveViewerPlugin) {
+        let event_init = web_sys::CustomEventInit::new();
+        event_init.set_detail(plugin);
+        let event = web_sys::CustomEvent::new_with_event_init_dict(
+            "perspective-plugin-update",
+            &event_init,
+        );
+
+        self.elem.dispatch_event(&event.unwrap()).unwrap();
+    }
+
+    fn dispatch_config_update(self) {
+        ApiFuture::spawn(async move {
+            let viewer_config = self.get_viewer_config().await?;
+            if viewer_config.view_config != Default::default()
+                && Some(&viewer_config) != self.last_dispatched.borrow().as_ref()
+            {
+                let json_config = JsValue::from_serde_ext(&viewer_config)?;
+                let event_init = web_sys::CustomEventInit::new();
+                event_init.set_detail(&json_config);
+                let event = web_sys::CustomEvent::new_with_event_init_dict(
+                    "perspective-config-update",
+                    &event_init,
+                );
+
+                *self.last_dispatched.borrow_mut() = Some(viewer_config);
+                self.elem.dispatch_event(&event.unwrap()).unwrap();
+            }
+
+            Ok(())
+        });
+    }
+}

package/src/rust/dragdrop.rs

@@ -0,0 +1,362 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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::cell::RefCell;
+use std::ops::Deref;
+use std::rc::Rc;
+
+use perspective_client::clone;
+use wasm_bindgen::prelude::*;
+use web_sys::*;
+use yew::html::ImplicitClone;
+use yew::prelude::*;
+
+use crate::utils::*;
+use crate::*;
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum DragTarget {
+    Active,
+    GroupBy,
+    SplitBy,
+    Sort,
+    Filter,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum DragEffect {
+    Copy,
+    Move(DragTarget),
+}
+
+#[derive(Clone, Debug)]
+struct DragFrom {
+    column: String,
+    effect: DragEffect,
+}
+
+#[derive(Debug)]
+struct DragOver {
+    target: DragTarget,
+    index: usize,
+}
+
+#[derive(Debug)]
+enum DragState {
+    NoDrag,
+    DragInProgress(DragFrom),
+    DragOverInProgress(DragFrom, DragOver),
+}
+
+impl Default for DragState {
+    fn default() -> Self {
+        Self::NoDrag
+    }
+}
+
+impl DragState {
+    const fn is_drag_in_progress(&self) -> bool {
+        !matches!(self, Self::NoDrag)
+    }
+}
+
+#[derive(Default)]
+pub struct DragDropState {
+    drag_state: RefCell<DragState>,
+    pub drop_received: PubSub<(String, DragTarget, DragEffect, usize)>,
+    pub dragstart_received: PubSub<DragEffect>,
+    pub dragend_received: PubSub<()>,
+}
+
+/// The `<perspective-viewer>` drag/drop service, which manages drag/drop user
+/// interactions across components.  It is a component-level service, since only
+/// one drag/drop action can be executed by the user at a time.
+#[derive(Clone, Default)]
+pub struct DragDrop(Rc<DragDropState>);
+
+impl Deref for DragDrop {
+    type Target = Rc<DragDropState>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl PartialEq for DragDrop {
+    fn eq(&self, other: &Self) -> bool {
+        Rc::ptr_eq(&self.0, &other.0)
+    }
+}
+
+impl ImplicitClone for DragDrop {}
+
+impl DragDrop {
+    /// Get the column name currently being drag/dropped.
+    pub fn get_drag_column(&self) -> Option<String> {
+        match *self.drag_state.borrow() {
+            DragState::DragInProgress(DragFrom { ref column, .. })
+            | DragState::DragOverInProgress(DragFrom { ref column, .. }, _) => Some(column.clone()),
+            _ => None,
+        }
+    }
+
+    pub fn get_drag_target(&self) -> Option<DragTarget> {
+        match *self.drag_state.borrow() {
+            DragState::DragInProgress(DragFrom {
+                effect: DragEffect::Move(target),
+                ..
+            })
+            | DragState::DragOverInProgress(
+                DragFrom {
+                    effect: DragEffect::Move(target),
+                    ..
+                },
+                _,
+            ) => Some(target),
+            _ => None,
+        }
+    }
+
+    pub fn set_drag_image(&self, event: &DragEvent) -> ApiResult<()> {
+        event.stop_propagation();
+        if let Some(dt) = event.data_transfer() {
+            dt.set_drop_effect("move");
+            dt.set_data("text/plain", "{}").unwrap();
+        }
+
+        let original: HtmlElement = event.target().into_apierror()?.unchecked_into();
+        let elem: HtmlElement = original
+            .children()
+            .get_with_index(0)
+            .unwrap()
+            .clone_node_with_deep(true)?
+            .unchecked_into();
+
+        elem.class_list().toggle("snap-drag-image")?;
+        original.append_child(&elem)?;
+        event.data_transfer().into_apierror()?.set_drag_image(
+            &elem,
+            event.offset_x(),
+            event.offset_y(),
+        );
+
+        ApiFuture::spawn(async move {
+            request_animation_frame().await;
+            original.remove_child(&elem)?;
+            Ok(())
+        });
+
+        Ok(())
+    }
+
+    // Is the drag/drop state currently in `action`?
+    pub fn is_dragover(&self, drag_target: DragTarget) -> Option<(usize, String)> {
+        match *self.drag_state.borrow() {
+            DragState::DragOverInProgress(
+                DragFrom { ref column, .. },
+                DragOver { target, index },
+            ) if target == drag_target => Some((index, column.clone())),
+            _ => None,
+        }
+    }
+
+    pub fn notify_drop(&self, event: &DragEvent) {
+        event.prevent_default();
+        event.stop_propagation();
+        let action = match &*self.drag_state.borrow() {
+            DragState::DragOverInProgress(
+                DragFrom { column, effect },
+                DragOver { target, index },
+            ) => Some((column.to_string(), *target, *effect, *index)),
+            _ => None,
+        };
+
+        *self.drag_state.borrow_mut() = DragState::NoDrag;
+        if let Some(action) = action {
+            self.drop_received.emit(action);
+        }
+    }
+
+    /// Start the drag/drop action with the name of the column being dragged.
+    pub fn notify_drag_start(&self, column: String, effect: DragEffect) {
+        *self.drag_state.borrow_mut() = DragState::DragInProgress(DragFrom { column, effect });
+        let emit = self.dragstart_received.callback();
+        ApiFuture::spawn(async move {
+            request_animation_frame().await;
+            emit.emit(effect);
+            Ok(())
+        });
+    }
+
+    /// 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_state.borrow_mut() = DragState::NoDrag;
+            let emit = self.dragend_received.callback();
+            emit.emit(());
+        }
+    }
+
+    /// Leave the `action` zone.
+    pub fn notify_drag_leave(&self, drag_target: DragTarget) {
+        let reset = match *self.drag_state.borrow() {
+            DragState::DragOverInProgress(
+                DragFrom { ref column, effect },
+                DragOver { target, .. },
+            ) if target == drag_target => Some((column.clone(), effect)),
+            _ => None,
+        };
+
+        if let Some((column, effect)) = reset {
+            self.notify_drag_start(column, effect);
+        }
+    }
+
+    // Enter the `action` zone at `index`, which must be <= the number of children
+    // in the container.
+    pub fn notify_drag_enter(&self, target: DragTarget, index: usize) -> bool {
+        let mut drag_state = self.drag_state.borrow_mut();
+        let should_render = match &*drag_state {
+            DragState::DragOverInProgress(_, drag_to) => {
+                drag_to.target != target || drag_to.index != index
+            },
+            _ => true,
+        };
+
+        *drag_state = match &*drag_state {
+            DragState::DragOverInProgress(drag_from, _) | DragState::DragInProgress(drag_from) => {
+                DragState::DragOverInProgress(drag_from.clone(), DragOver { target, index })
+            },
+            _ => DragState::NoDrag,
+        };
+
+        should_render
+    }
+}
+
+/// Safari does not set `relatedTarget` on `"dragleave"`, which makes it
+/// impossible to determine whether a logical drag leave has happened with just
+/// this event, so use function on `"dragenter"` to capture the `relatedTarget`.
+pub fn dragenter_helper(callback: impl Fn() + 'static, target: NodeRef) -> Callback<DragEvent> {
+    Callback::from({
+        move |event: DragEvent| {
+            js_log_maybe!({
+                event.stop_propagation();
+                event.prevent_default();
+                if event.related_target().is_none() {
+                    target
+                        .cast::<HtmlElement>()
+                        .into_apierror()?
+                        .dataset()
+                        .set("safaridragleave", "true")?;
+                }
+            });
+
+            callback();
+        }
+    })
+}
+
+/// HTML drag/drop will fire a bubbling `dragleave` event over all children of a
+/// `dragleave`-listened-to element, so we need to filter out the events from
+/// the children elements with this esoteric DOM arcana.
+pub fn dragleave_helper(callback: impl Fn() + 'static, drag_ref: NodeRef) -> Callback<DragEvent> {
+    Callback::from({
+        clone!(drag_ref);
+        move |event: DragEvent| {
+            js_log_maybe!({
+                event.stop_propagation();
+                event.prevent_default();
+
+                let mut related_target = event
+                    .related_target()
+                    .or_else(|| Some(JsValue::UNDEFINED.unchecked_into::<EventTarget>()))
+                    .and_then(|x| x.dyn_into::<Element>().ok());
+
+                // This is a wild chrome bug. `dragleave` can fire with the `relatedTarget`
+                // property set to an element inside the closed `ShadowRoot` hosted by a
+                // browser-native `<select>` tag, which fails the `.contains()` check
+                // below.  This mystery `ShadowRoot` has a structure that looks like this
+                // (tested in Chrome 92), which we try to detect as best we can below.
+                //
+                // ```html
+                // <div aria-hidden="true">Selected Text Here</siv>
+                // <slot name="user-agent-custom-assign-slot"></slot>
+                // ```
+                //
+                // This is pretty course though, since there is no guarantee this structure
+                // will be maintained in future Chrome versions; the `.expect()` in this
+                // method chain should at least warn us if this regresses.
+                //
+                // Wait - you don't believe me?  Throw a debugger statement inside this
+                // conditional and drag a column over a pivot-mode active columns list.
+                if related_target
+                    .as_ref()
+                    .map(|x| x.has_attribute("aria-hidden"))
+                    .unwrap_or_default()
+                {
+                    related_target = Some(
+                        related_target
+                            .into_apierror()?
+                            .parent_node()
+                            .into_apierror()?
+                            .dyn_ref::<ShadowRoot>()
+                            .ok_or_else(|| JsValue::from("Chrome drag/drop bug detection failed"))?
+                            .host()
+                            .unchecked_into::<Element>(),
+                    )
+                }
+
+                let current_target = drag_ref.cast::<HtmlElement>().unwrap();
+                match related_target {
+                    Some(ref related) => {
+                        // Due to virtual dom these events sometimes fire after
+                        // the node is removed ...
+                        if !current_target.contains(Some(related))
+                            && related.parent_element().is_some()
+                        {
+                            callback();
+                        }
+                    },
+                    None => {
+                        // Safari (OSX and iOS) don't set `relatedTarget`, so we need to
+                        // read a memoized value from the `"dragenter"` event.
+                        let dataset = current_target.dataset();
+                        if dataset.get("safaridragleave").is_some() {
+                            dataset.delete("safaridragleave");
+                        } else {
+                            callback();
+                        }
+                    },
+                };
+            })
+        }
+    })
+}
+
+#[derive(Clone)]
+pub struct DragDropContainer {
+    pub noderef: NodeRef,
+    pub dragenter: Callback<DragEvent>,
+    pub dragleave: Callback<DragEvent>,
+}
+
+impl DragDropContainer {
+    pub fn new<F: Fn() + 'static, G: Fn() + 'static>(ondragenter: F, ondragleave: G) -> Self {
+        let noderef = NodeRef::default();
+        Self {
+            dragenter: dragenter_helper(ondragenter, noderef.clone()),
+            dragleave: dragleave_helper(ondragleave, noderef.clone()),
+            noderef,
+        }
+    }
+}

package/src/rust/exprtk/cursor.rs

@@ -0,0 +1,81 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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::ExprValidationError;
+use yew::prelude::*;
+
+/// A tokenizer cursor for ExprTK parsing.
+///
+/// Because ExprTK reports errors in column/row coordinates and visually needs
+/// to be applied to an entire token rather than a single character, we need
+/// fairly obnoxious counter logic to figure out how to generate the resulting
+/// syntax-highlighted HTML. The `Counter<'a>` struct encpsulates this logic,
+/// generating a `NodeRef` to any autocomplete-able `<span>` tokens, as well
+/// as other convenient data for HTML rendering, and can be called incrementally
+/// while iterating tokens after parsing.
+pub struct Cursor<'a> {
+    row: u32,
+    col: u32,
+    index: u32,
+    pub err: &'a Option<ExprValidationError>,
+    pub txt: &'a str,
+    pub noderef: NodeRef,
+    pub auto: Option<String>,
+}
+
+impl<'a> Cursor<'a> {
+    pub fn new(err: &'a Option<ExprValidationError>) -> Self {
+        Self {
+            row: 1,
+            col: 0,
+            index: 0,
+            err,
+            txt: "",
+            auto: None,
+            noderef: NodeRef::default(),
+        }
+    }
+
+    /// Is the cursor currently overlapping a token with an error?
+    pub const fn is_error(&self) -> bool {
+        if let Some(err) = &self.err {
+            err.line + 1 == self.row
+                && err.column >= self.col
+                && err.column < (self.col + self.txt.len() as u32)
+        } else {
+            false
+        }
+    }
+
+    /// Is the cursor currently overlapping an  autocomplete-able token?
+    pub const fn is_autocomplete(&self, position: u32) -> bool {
+        position > self.index && position <= self.index + self.txt.len() as u32
+    }
+
+    /// TODO this is alot of type backage for what could just be `num_rows()`.
+    pub fn map_rows<T, F: Fn(u32) -> T>(self, f: F) -> impl Iterator<Item = T> {
+        (0..self.row).map(f)
+    }
+
+    /// Increment the counter column by `size` characters.
+    pub fn increment_column(&mut self, size: u32) {
+        self.col += size;
+        self.index += size;
+    }
+
+    /// Increment to the next line, typewriter-style.
+    pub fn increment_line(&mut self) {
+        self.row += 1;
+        self.col = 0;
+        self.index += 1;
+    }
+}

package/src/rust/exprtk/mod.rs

@@ -0,0 +1,17 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+mod cursor;
+mod tokenize;
+
+pub use cursor::*;
+pub use tokenize::*;