@perspective-dev/viewer 5.0.0 → 5.2.0

package/src/rust/components/containers/dragdrop_list.rs

@@ -52,6 +52,31 @@ where
 
     #[prop_or_default]
     pub allow_duplicates: bool,
+
+    /// Single-slot mode: the list holds at most one item, a dragover
+    /// preview REPLACES the current item rather than inserting beside it,
+    /// and the trailing `EmptyColumn` autocomplete renders only while the
+    /// slot is empty.
+    #[prop_or_default]
+    pub single_slot: bool,
+
+    /// The plugin-declared visual role this slot fills, e.g. `"X Axis"`
+    /// for a `Y Line`'s `group_by` (see `PluginStaticConfig`). Rendered
+    /// as the slot's label THROUGH the intl indirection: the role is a
+    /// key, not display text, so `--psp-label--role--x-axis--content`
+    /// supplies the words and a language variant can override them. A
+    /// role with no such label falls back to the declared English, and
+    /// no role at all falls back to the slot's own generic label.
+    #[prop_or_default]
+    pub role_label: Option<AttrValue>,
+
+    /// The in-flight drag is INVALID for this list (a parent-defined rule,
+    /// e.g. the window editor's Table-columns-only slots): the dragover
+    /// preview is suppressed and the invalid-X overlay renders instead,
+    /// like a duplicate drag over `group_by`/`split_by`. The parent's drop
+    /// handler is still responsible for ignoring the drop itself.
+    #[prop_or_default]
+    pub is_invalid: bool,
 }
 
 impl<T, U> PartialEq for DragDropListProps<T, U>
@@ -66,6 +91,9 @@ where
             && self.allow_duplicates == other.allow_duplicates
             && self.is_dragover == other.is_dragover
             && self.disabled == other.disabled
+            && self.single_slot == other.single_slot
+            && self.is_invalid == other.is_invalid
+            && self.role_label == other.role_label
     }
 }
 
@@ -202,7 +230,51 @@ where
         let invalid_drag: bool;
         let mut valid_duplicate_drag = false;
 
-        let columns_html = {
+        let columns_html = if ctx.props().single_slot {
+            invalid_drag = ctx.props().is_invalid && ctx.props().is_dragover.is_some();
+
+            // Dragging the slot's own pill over its own slot is a no-op
+            // move - keep showing the pill instead of the drop preview
+            // (mirrors the multi-column branch's `is_self_move` handling).
+            let is_self_move = ctx
+                .props()
+                .presentation
+                .get_drag_target()
+                .map(|x| V::is_self_move(x))
+                .unwrap_or_default();
+
+            let close = ctx.props().parent.callback(|_| V::close(0));
+            let dragenter = ctx.props().parent.callback({
+                let container_noderef = container_noderef.clone();
+                move |event: DragEvent| {
+                    event.stop_propagation();
+                    event.prevent_default();
+                    if event.related_target().is_none()
+                        && let Some(elem) = container_noderef.cast::<HtmlElement>()
+                    {
+                        let _ = elem.dataset().set("safaridragleave", "true");
+                    }
+                    V::dragenter(0)
+                }
+            });
+
+            if ctx.props().is_dragover.is_some() && !is_self_move && !invalid_drag {
+                html! {
+                    <div class="pivot-column" ondragenter={dragenter}>
+                        <div class="config-drop" />
+                    </div>
+                }
+            } else if let Some(column) = ctx.props().children.iter().next() {
+                html! {
+                    <div class="pivot-column" ondragenter={dragenter}>
+                        { Html::from(column) }
+                        <span class="row_close" onmousedown={close} />
+                    </div>
+                }
+            } else {
+                html! {}
+            }
+        } else {
             let mut columns = ctx
                 .props()
                 .children
@@ -211,7 +283,10 @@ where
                 .enumerate()
                 .collect::<Vec<_>>();
 
-            invalid_drag = if let Some((x, column)) = &ctx.props().is_dragover {
+            invalid_drag = if ctx.props().is_invalid && ctx.props().is_dragover.is_some() {
+                // Parent-defined invalidity: no preview, X overlay only.
+                true
+            } else if let Some((x, column)) = &ctx.props().is_dragover {
                 let index = *x;
                 let is_append = index == columns.len();
                 let is_self_move = ctx
@@ -314,16 +389,48 @@ where
                 .collect::<Html>()
         };
 
+        let show_empty = if ctx.props().single_slot {
+            ctx.props().children.is_empty() && ctx.props().is_dragover.is_none()
+        } else {
+            ctx.props().is_dragover.is_none() | (!invalid_drag && valid_duplicate_drag)
+        };
+
         let column_dropdown = ctx.props().column_dropdown.clone();
         let exclude = ctx.props().exclude.clone();
         let on_select = ctx.props().parent.callback(V::create);
         let class = classes!("rrow");
         let is_enabled = true;
 
+        // The role is data from the plugin, so the var NAME is built
+        // here while the var VALUE stays in the stylesheets - custom
+        // properties inherit, so the label's `:before` picks it up.
+        let role_style = ctx.props().role_label.as_ref().map(|role| {
+            let slug = role
+                .chars()
+                .map(|x| {
+                    if x.is_ascii_alphanumeric() {
+                        x.to_ascii_lowercase()
+                    } else {
+                        '-'
+                    }
+                })
+                .collect::<String>();
+
+            // The second var is a PRESENCE FLAG: CSS cannot ask whether a
+            // custom property is set, so the slot's stylesheet reads it as
+            // the secondary label's `display` and gets `none` by fallback
+            // when no role was declared.
+            format!(
+                "--psp-label--pivot--content: var(--psp-label--role--{slug}--content, \
+                 \"{role}\"); --psp-label--pivot-secondary--display: inline-block"
+            )
+        });
+
         html! {
             <div ref={&self.elem} {class}>
                 <div
                     id={ctx.props().name}
+                    style={role_style}
                     ondragover={is_enabled.then_some(dragover)}
                     ondragenter={is_enabled.then_some(drag_container.dragenter)}
                     ondragleave={is_enabled.then_some(drag_container.dragleave)}
@@ -345,7 +452,7 @@ where
                                         onmousedown={ctx.props().parent.callback(move |_| V::close(0))}
                                     />
                                 </div>
-                            } else if ctx.props().is_dragover.is_none() | (!invalid_drag && valid_duplicate_drag) {
+                            } else if show_empty {
                                 <EmptyColumn {column_dropdown} {exclude} {on_select} />
                             } else if invalid_drag {
                                 <InvalidColumn />

package/src/rust/components/containers/sidebar.rs

@@ -11,14 +11,17 @@
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
 use perspective_client::clone;
-use web_sys::Element;
+use wasm_bindgen::JsCast;
+use wasm_bindgen::prelude::Closure;
+use web_sys::HtmlElement;
 use yew::{
-    Callback, Children, Html, Properties, function_component, html, use_effect_with, use_node_ref,
-    use_state_eq,
+    Callback, Children, Html, Properties, function_component, html, use_effect_with, use_mut_ref,
+    use_node_ref,
 };
 
 use crate::components::containers::sidebar_close_button::SidebarCloseButton;
 use crate::components::editable_header::{EditableHeader, EditableHeaderProps};
+use crate::js::{ResizeObserver, ResizeObserverEntry};
 
 #[derive(PartialEq, Clone, Properties)]
 pub struct SidebarProps {
@@ -31,6 +34,28 @@ pub struct SidebarProps {
     pub width_override: Option<i32>,
     pub selected_tab: Option<usize>,
     pub header_props: EditableHeaderProps,
+
+    /// Trap-door width shared across this sidebar's tabs: the lifted
+    /// running max of the widths this component reports through
+    /// `on_auto_width`. Held by the parent (ultimately
+    /// `PerspectiveViewer`'s geometry state, like the settings panel's
+    /// Query/Plugin/Debug trap-door) so it survives tab switches AND
+    /// sidebar re-mounts, and clears on divider reset.
+    #[prop_or_default]
+    pub auto_width: f64,
+
+    /// Fires with the sidebar's rendered width after each render; the
+    /// owner keeps the running max threaded back as `auto_width`.
+    #[prop_or_default]
+    pub on_auto_width: Callback<f64>,
+
+    /// Pinned state for the header's pin toggle; the button renders only
+    /// when `on_toggle_pin` is provided.
+    #[prop_or_default]
+    pub is_pinned: bool,
+
+    #[prop_or_default]
+    pub on_toggle_pin: Option<Callback<()>>,
 }
 
 /// Sidebars are designed to live in a
@@ -39,33 +64,85 @@ pub struct SidebarProps {
 pub fn Sidebar(p: &SidebarProps) -> Html {
     let id = &p.id_prefix;
     let noderef = use_node_ref();
-    let auto_width = use_state_eq(|| 0f64);
-
-    // this gets the last calculated width and ensures that
-    // the auto-width element is at least that big.
-    // this ensures the panel grows but does not shrink.
-    use_effect_with(p.clone(), {
-        clone!(noderef, auto_width);
-        move |p| {
-            if p.width_override.is_none() {
-                let updated_width = noderef
-                    .cast::<Element>()
-                    .map(|el| el.get_bounding_client_rect().width())
-                    .unwrap_or_default();
-                let new_auto_width = (*auto_width).max(updated_width);
-                auto_width.set(new_auto_width);
-            } else {
-                auto_width.set(0f64);
+
+    // The trap-door reports the sidebar's rendered width to its owner via
+    // a `ResizeObserver` on the sidebar element, NOT a render effect:
+    // width changes are driven by DOM mutations anywhere in the tab
+    // subtree (e.g. the window editor staging a long column name into a
+    // slot), which need not re-render this component at all. The observer
+    // sees every one. `contentRect` (not the border box) is load-bearing:
+    // the sizer below is a content child, so ratcheting the border box
+    // would feed any sidebar padding back into unbounded growth. A manual
+    // divider drag (`width_override`) disables the ratchet until the
+    // divider resets.
+    let live_props = use_mut_ref(|| (Callback::<f64>::default(), None::<i32>));
+    *live_props.borrow_mut() = (p.on_auto_width.clone(), p.width_override);
+    use_effect_with((), {
+        clone!(noderef, live_props);
+        move |_| {
+            let closure =
+                Closure::<dyn FnMut(js_sys::Array)>::new(move |entries: js_sys::Array| {
+                    let (on_auto_width, width_override) = live_props.borrow().clone();
+                    if width_override.is_none() {
+                        for entry in entries.iter() {
+                            let entry: ResizeObserverEntry = entry.unchecked_into();
+                            on_auto_width.emit(entry.content_rect().width());
+                        }
+                    }
+                });
+
+            let observer = ResizeObserver::new(closure.as_ref().unchecked_ref());
+            let elem = noderef.cast::<HtmlElement>();
+            if let Some(elem) = &elem {
+                observer.observe(elem);
+            }
+
+            move || {
+                if let Some(elem) = &elem {
+                    observer.unobserve(elem);
+                }
+
+                drop(closure);
             }
         }
     });
 
-    let width_style = format!("min-width: 200px; width: {}px", *auto_width);
+    let auto_width = if p.width_override.is_none() {
+        p.auto_width
+    } else {
+        0.0
+    };
+
+    let width_style = format!("min-width: 200px; width: {}px", auto_width);
+    let pin_button = p.on_toggle_pin.as_ref().map(|cb| {
+        let onclick = {
+            let cb = cb.clone();
+            Callback::from(move |_: web_sys::MouseEvent| cb.emit(()))
+        };
+
+        let mut class = yew::classes!("sidebar_pin_button");
+        if p.is_pinned {
+            class.push("is-pinned");
+        }
+
+        html! {
+            <span
+                id={format!("{id}_pin_button")}
+                {class}
+                title={if p.is_pinned { "Unpin" } else { "Pin" }}
+                {onclick}
+            />
+        }
+    });
+
     html! {
         <>
             <SidebarCloseButton id={format!("{id}_close_button")} on_close_sidebar={&p.on_close} />
             <div class="sidebar_column" id={format!("{id}_sidebar")} ref={noderef}>
-                <div class="sidebar_header"><EditableHeader ..p.header_props.clone() /></div>
+                <div class="sidebar_header">
+                    <EditableHeader ..p.header_props.clone() />
+                    { pin_button }
+                </div>
                 <div class="sidebar_border" id={format!("{id}_border")} />
                 { p.children.iter().collect::<Html>() }
                 <div class="sidebar-auto-width" style={width_style} />

package/src/rust/components/containers/split_panel.rs

@@ -26,6 +26,10 @@ pub struct SplitPanelProps {
     #[prop_or_default]
     pub id: Option<String>,
 
+    /// Extra classes on the root element (ignored under `no_wrap`).
+    #[prop_or_default]
+    pub class: Classes,
+
     #[prop_or_default]
     pub orientation: Orientation,
 
@@ -110,6 +114,7 @@ impl SplitPanelProps {
 impl PartialEq for SplitPanelProps {
     fn eq(&self, other: &Self) -> bool {
         self.id == other.id
+            && self.class == other.class
             && self.children == other.children
             && self.orientation == other.orientation
             && self.reverse == other.reverse
@@ -305,6 +310,7 @@ impl Component for SplitPanel {
         }
 
         let mut classes = classes!("split-panel");
+        classes.extend(ctx.props().class.clone());
         if orientation == Orientation::Vertical {
             classes.push("orient-vertical");
         }

package/src/rust/components/editable_header.rs

@@ -119,10 +119,12 @@ impl Component for EditableHeader {
                     }
                     let metadata = &ctx.props().metadata;
                     let expressions = metadata.get_expression_columns();
+                    let windows = metadata.get_window_columns();
                     let found = metadata
                         .get_table_columns()?
                         .iter()
                         .chain(expressions)
+                        .chain(windows)
                         .contains(&new_value);
                     Some(!found)
                 })()

package/src/rust/components/form/code_editor.rs

@@ -18,6 +18,7 @@ use web_sys::*;
 use yew::prelude::*;
 
 use crate::components::form::highlight::highlight;
+use crate::components::form::mirrored_textarea::MirroredTextarea;
 use crate::components::function_dropdown::{FunctionDropDownElement, FunctionDropDownPortal};
 use crate::exprtk::{Cursor, tokenize};
 use crate::utils::*;
@@ -174,30 +175,20 @@ pub fn code_editor(props: &CodeEditorProps) -> Html {
         <>
             <div id="editor" {class}>
                 <div id="line_numbers" ref={lineno_ref}>{ line_numbers }</div>
-                <div id="editor-inner" {class}>
-                    <textarea
-                        {disabled}
-                        id="textarea_editable"
-                        class="scrollable"
-                        ref={textarea_ref}
-                        spellcheck="false"
-                        {oninput}
-                        {onscroll}
-                        {onkeydown}
-                    />
+                <MirroredTextarea
+                    id="textarea_editable"
+                    mirror_id="content"
+                    class={classes!("editor-inner", class)}
+                    mirror={terms}
+                    {textarea_ref}
+                    mirror_ref={content_ref}
+                    {disabled}
+                    {oninput}
+                    {onscroll}
+                    {onkeydown}
+                >
                     <div id="editor-height-sizer" />
-                    <pre id="content" ref={content_ref}>
-                        { terms }
-                        { {
-                        // A linebreak which pushs a textarea into scroll overflow
-                        // may not necessarily do so in the `<pre>`, because there is
-                        // no cursor when the last line has no content, so add
-                        // some space here to make sure overlfow is in sync
-                        // with the text area.
-                        " "
-                    } }
-                    </pre>
-                </div>
+                </MirroredTextarea>
             </div>
             <FunctionDropDownPortal
                 element={(*portal_dropdown).clone()}

package/src/rust/components/form/debug.rs

@@ -23,12 +23,14 @@ use crate::presentation::*;
 use crate::renderer::*;
 use crate::session::*;
 use crate::utils::*;
+use crate::workspace::Workspace;
 
 #[derive(Clone, PartialEq, Properties)]
 pub struct DebugPanelProps {
     pub presentation: Presentation,
     pub renderer: Renderer,
     pub session: Session,
+    pub workspace: Workspace,
 
     /// Trap-door width pinned by the parent `SettingsPanel` so switching
     /// tabs doesn't shrink the panel. Threaded into the hidden sizer
@@ -236,15 +238,16 @@ impl DebugPanelProps {
         ApiFuture::spawn(async move {
             match serde_json::from_str(&text) {
                 Ok(config) => {
-                    match crate::tasks::restore_and_render(
+                    let active =
+                        props.workspace.active_renderer().as_ref() == Some(&props.renderer);
+                    match crate::tasks::restore_panel(
                         &props.session,
                         &props.renderer,
                         &props.presentation,
-                        // A user-pasted config apply — an explicit request,
-                        // same affordance as the public `restore()`.
-                        crate::tasks::RunOrigin::Public,
+                        &props.workspace,
+                        crate::tasks::RestoreMode::Existing { active },
                         config,
-                        async { Ok(()) },
+                        crate::tasks::RestoreErrors::Suppress,
                     )
                     .await
                     {

package/src/rust/components/form/mirrored_textarea.rs

@@ -0,0 +1,165 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+//! A `<textarea>` whose box is sized by its own text.
+//!
+//! A textarea cannot grow with its content — it scrolls at whatever height
+//! it was given. The technique here, shared by [`CodeEditor`] and the chat
+//! prompt, is to make the textarea a purely functional layer: it takes the
+//! keystrokes, the selection and the caret, but paints no glyphs
+//! (`color: transparent`). Underneath sits a `<pre>` mirror of the same
+//! characters which IS painted and IS in flow, so the ordinary layout
+//! engine sizes the box.
+//!
+//! This is deliberately not a JS measure-and-resize loop
+//! (`scrollHeight` → inline `height`): that re-measures on a reflow it
+//! just forced, drifts whenever font-size or the loaded font changes
+//! without an `input` event to re-trigger it, and jitters at fractional
+//! line heights. Here the two layers share their text metrics, so growth
+//! is exact by construction and free at runtime.
+//!
+//! Consumers decide the AXES: the mirror's `white-space` governs growth,
+//! so `pre-wrap` grows only downward (the chat prompt) while `pre` also
+//! grows sideways (the expression editor). They also own the box —
+//! padding, borders, min/max size — with `mirrored-textarea.css` fixing
+//! only what MUST agree between the two layers.
+//!
+//! [`CodeEditor`]: super::code_editor::CodeEditor
+
+use yew::html::IntoPropValue;
+use yew::prelude::*;
+
+#[derive(Clone)]
+pub struct Mirror(pub Html);
+
+impl PartialEq for Mirror {
+    fn eq(&self, _other: &Self) -> bool {
+        false
+    }
+}
+
+impl IntoPropValue<Mirror> for Html {
+    fn into_prop_value(self) -> Mirror {
+        Mirror(self)
+    }
+}
+
+#[derive(Properties, PartialEq)]
+pub struct MirroredTextareaProps {
+    /// `id` of the `<textarea>` itself — consumer CSS and tests key on it.
+    pub id: AttrValue,
+
+    /// The mirror's content: the same characters the textarea holds,
+    /// as plain text, or marked up (`CodeEditor` passes highlighted
+    /// spans). A stale mirror means a caret that drifts from the glyphs,
+    /// so this is re-rendered unconditionally — see [`Mirror`].
+    pub mirror: Mirror,
+
+    /// `id` of the mirror `<pre>`, for consumers that style it directly.
+    #[prop_or_default]
+    pub mirror_id: Option<AttrValue>,
+
+    /// Extra classes for the positioned container.
+    #[prop_or_default]
+    pub class: Classes,
+
+    #[prop_or_default]
+    pub textarea_ref: NodeRef,
+
+    #[prop_or_default]
+    pub mirror_ref: NodeRef,
+
+    /// The `placeholder` ATTRIBUTE, which exists for assistive tech: it
+    /// is painted transparent, because a CSS-`content` label cannot be
+    /// written into an attribute and so cannot be localized. The text a
+    /// sighted user reads comes from the mirror instead — see
+    /// [`Self::is_empty`].
+    #[prop_or_default]
+    pub placeholder: AttrValue,
+
+    /// Whether [`Self::mirror`] is empty, which the component cannot see
+    /// for itself (the mirror is opaque `Html`). Tags the mirror with
+    /// `is-empty` so a consumer's stylesheet can supply placeholder text
+    /// through `content`, and therefore through the intl label
+    /// mechanism, rather than through the untranslatable attribute.
+    #[prop_or_default]
+    pub is_empty: bool,
+
+    #[prop_or_default]
+    pub disabled: bool,
+
+    #[prop_or_default]
+    pub oninput: Callback<InputEvent>,
+
+    #[prop_or_default]
+    pub onkeydown: Callback<KeyboardEvent>,
+
+    #[prop_or_default]
+    pub onscroll: Callback<Event>,
+
+    /// Extra nodes inside the positioned container, e.g. `CodeEditor`'s
+    /// minimum-height sizer.
+    #[prop_or_default]
+    pub children: Children,
+}
+
+#[function_component]
+pub fn MirroredTextarea(props: &MirroredTextareaProps) -> Html {
+    html! {
+        <div class={classes!("mirrored-textarea", props.class.clone())}>
+            // `scrollable` is the viewer's webkit scrollbar styling: the
+            // input layer scrolls wherever a consumer lets it (the
+            // expression editor syncs its `scrollTop` to the mirror and
+            // line numbers), and is inert where it does not (the chat
+            // prompt, whose wrapper scrolls instead).
+            <textarea
+                id={props.id.clone()}
+                ref={props.textarea_ref.clone()}
+                class="mirrored-textarea-input scrollable"
+                spellcheck="false"
+                placeholder={props.placeholder.clone()}
+                disabled={props.disabled}
+                oninput={props.oninput.clone()}
+                onkeydown={props.onkeydown.clone()}
+                onscroll={props.onscroll.clone()}
+            />
+            { props.children.iter().collect::<Html>() }
+            <pre
+                id={props.mirror_id.clone()}
+                ref={props.mirror_ref.clone()}
+                class={classes!(
+                    "mirrored-textarea-mirror",
+                    props.is_empty.then_some("is-empty"),
+                )}
+            >
+                { props.mirror.0.clone() }
+                // A trailing newline opens a line box in the textarea but
+                // not in the `<pre>` (which has no caret to place there),
+                // so the mirror would come up one line short exactly when
+                // the text is about to overflow. The space forces it.
+                { " " }
+            </pre>
+        </div>
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn mirror_never_compares_equal() {
+        let mirror = Mirror(Html::default());
+        assert!(mirror != mirror.clone());
+        assert!(Mirror(Html::default()) != Mirror(Html::default()));
+    }
+}

package/src/rust/components/form/mod.rs

@@ -20,6 +20,7 @@ pub mod code_editor;
 pub mod color_range_selector;
 pub mod color_selector;
 pub mod debug;
+pub mod mirrored_textarea;
 pub mod number_field;
 pub mod number_input;
 pub mod number_range_field;

package/src/rust/components/main_panel.rs

@@ -291,6 +291,11 @@ impl Component for MainPanel {
             .link()
             .callback(|(id, x, y)| MainPanelMsg::ContextMenu(id, x, y));
         let contextmenu_listener = Closure::wrap(Box::new(move |event: web_sys::Event| {
+            // Shift+right-click passes through to the native browser menu.
+            if event.unchecked_ref::<web_sys::MouseEvent>().shift_key() {
+                return;
+            }
+
             let path = event.composed_path();
             let mut panel_id = None;
             for i in 0..path.length() {

package/src/rust/components/mod.rs

@@ -14,6 +14,8 @@
 //! necessary for public Custom Elements.  The rest are internal components of
 //! these 4.
 
+#[cfg(feature = "llm-agent")]
+pub mod chat_panel;
 pub mod column_dropdown;
 pub mod column_selector;
 pub mod column_settings_sidebar;
@@ -48,3 +50,4 @@ pub mod style;
 pub mod style_controls;
 pub mod type_icon;
 pub mod viewer;
+pub mod window_editor;