@perspective-dev/viewer 4.5.2 → 5.1.0

package/src/rust/components/window_editor.rs

@@ -0,0 +1,1013 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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 std::rc::Rc;
+
+use perspective_client::config::{
+    ColumnType, WindowAggregate, WindowFrame, WindowSort, WindowSortDir, WindowSpec,
+};
+use wasm_bindgen::JsCast;
+use web_sys::{DragEvent, HtmlInputElement, MouseEvent};
+use yew::prelude::*;
+
+use crate::components::column_dropdown::{ColumnDropDownElement, ColumnDropDownPortal};
+use crate::components::column_selector::{ColumnSelectorColumnRow, InPlaceColumn, PivotColumn};
+use crate::components::containers::dragdrop_list::{
+    DragContext, DragDropList, DragDropListItemProps,
+};
+use crate::components::containers::select::{Select, SelectItem};
+use crate::presentation::Presentation;
+use crate::session::{Session, SessionMetadataRc};
+use crate::utils::{AddListener, DragEffect, DragTarget, Subscription};
+
+fn op_label(op: WindowAggregate) -> &'static str {
+    match op {
+        WindowAggregate::Sum => "sum",
+        WindowAggregate::Avg => "avg",
+        WindowAggregate::Count => "count",
+        WindowAggregate::Min => "min",
+        WindowAggregate::Max => "max",
+        WindowAggregate::Stddev => "stddev",
+        WindowAggregate::Var => "var",
+        WindowAggregate::First => "first",
+        WindowAggregate::Last => "last",
+        WindowAggregate::Lag => "lag",
+        WindowAggregate::Lead => "lead",
+        WindowAggregate::Diff => "diff",
+        WindowAggregate::Rate => "rate",
+        WindowAggregate::Ema => "ema",
+    }
+}
+
+fn op_from_label(label: &str) -> Option<WindowAggregate> {
+    Some(match label {
+        "sum" => WindowAggregate::Sum,
+        "avg" => WindowAggregate::Avg,
+        "count" => WindowAggregate::Count,
+        "min" => WindowAggregate::Min,
+        "max" => WindowAggregate::Max,
+        "stddev" => WindowAggregate::Stddev,
+        "var" => WindowAggregate::Var,
+        "first" => WindowAggregate::First,
+        "last" => WindowAggregate::Last,
+        "lag" => WindowAggregate::Lag,
+        "lead" => WindowAggregate::Lead,
+        "diff" => WindowAggregate::Diff,
+        "rate" => WindowAggregate::Rate,
+        "ema" => WindowAggregate::Ema,
+        _ => return None,
+    })
+}
+
+fn is_aggregating(op: WindowAggregate) -> bool {
+    matches!(
+        op,
+        WindowAggregate::Sum
+            | WindowAggregate::Avg
+            | WindowAggregate::Count
+            | WindowAggregate::Min
+            | WindowAggregate::Max
+            | WindowAggregate::Stddev
+            | WindowAggregate::Var
+    )
+}
+
+fn is_positional(op: WindowAggregate) -> bool {
+    matches!(
+        op,
+        WindowAggregate::Lag | WindowAggregate::Lead | WindowAggregate::Diff
+    )
+}
+
+fn is_orderable_for_range(ty: ColumnType) -> bool {
+    matches!(
+        ty,
+        ColumnType::Integer | ColumnType::Float | ColumnType::Date | ColumnType::Datetime
+    )
+}
+
+#[derive(Clone, Properties)]
+pub struct WindowEditorProps {
+    pub metadata: SessionMetadataRc,
+
+    /// The saved spec under edit, or `None` for the "new column" drawer.
+    pub initial: Option<WindowSpec>,
+
+    /// Fires on every form mutation with the draft spec when it validates,
+    /// else `None`. The spec's `name` is a placeholder - the editable header
+    /// owns naming.
+    pub on_change: Callback<Option<WindowSpec>>,
+
+    /// Incremented by the parent to discard the draft.
+    pub reset_count: u8,
+
+    /// Drag/drop state - the editor's column slots are STAGED drop targets
+    /// ([`DragTarget::is_staged`]): drops mutate the draft only, and the
+    /// drag origin never self-removes.
+    pub presentation: Presentation,
+
+    /// Threaded for the slots' autocomplete dropdown
+    /// ([`ColumnDropDownElement`]).
+    pub session: Session,
+
+    /// Selected theme name, threaded for the autocomplete dropdown's
+    /// `PortalModal`.
+    #[prop_or_default]
+    pub selected_theme: Option<String>,
+}
+
+impl PartialEq for WindowEditorProps {
+    fn eq(&self, other: &Self) -> bool {
+        self.metadata == other.metadata
+            && self.initial == other.initial
+            && self.reset_count == other.reset_count
+            && self.selected_theme == other.selected_theme
+    }
+}
+
+/// Input mirror of a draft [`WindowSpec`]. Free-text fields hold raw
+/// strings so invalid intermediate input is representable; the NUMBER
+/// fields are typed with default `1` and can never hold an invalid value -
+/// like the Style tab's `NumberField`, a non-numeric or out-of-domain
+/// input resets to the default at the keystroke. `validate` produces the
+/// spec (or the error shown inline), applying the same rules as `View`
+/// construction so a saveable draft cannot be rejected by the engine.
+#[derive(Clone, PartialEq)]
+struct WindowDraft {
+    op: String,
+    source: String,
+    order_by: String,
+    order_desc: bool,
+    partition_by: Vec<String>,
+    frame_type: String,
+    frame_rows: u32,
+    frame_range: f64,
+    offset: u32,
+    alpha: f64,
+}
+
+impl Default for WindowDraft {
+    fn default() -> Self {
+        Self {
+            op: String::default(),
+            source: String::default(),
+            order_by: String::default(),
+            order_desc: false,
+            partition_by: vec![],
+            frame_type: String::default(),
+            frame_rows: 1,
+            frame_range: 1.0,
+            offset: 1,
+            alpha: 1.0,
+        }
+    }
+}
+
+impl WindowDraft {
+    fn from_spec(spec: &WindowSpec) -> Self {
+        let (frame_type, frame_rows, frame_range) = match spec.frame {
+            Some(WindowFrame::Rows(n)) => ("Rows", n, 1.0),
+            Some(WindowFrame::Range(x)) => ("Range", 1, x),
+            Some(WindowFrame::Cumulative) | None => ("Cumulative", 1, 1.0),
+        };
+
+        Self {
+            op: op_label(spec.aggregate).to_string(),
+            source: spec.column.clone(),
+            order_by: spec
+                .order_by
+                .as_ref()
+                .map(|x| x.0.clone())
+                .unwrap_or_default(),
+            order_desc: spec
+                .order_by
+                .as_ref()
+                .map(|x| x.1 == WindowSortDir::Desc)
+                .unwrap_or_default(),
+            partition_by: spec.partition_by.clone(),
+            frame_type: frame_type.to_string(),
+            frame_rows,
+            frame_range,
+            offset: spec.offset.unwrap_or(1),
+            alpha: spec.alpha.unwrap_or(1.0),
+        }
+    }
+
+    fn new_default() -> Self {
+        Self {
+            op: "sum".to_string(),
+            frame_type: "Cumulative".to_string(),
+            ..Self::default()
+        }
+    }
+
+    fn validate(&self, metadata: &SessionMetadataRc) -> Result<WindowSpec, String> {
+        let op = op_from_label(&self.op).ok_or("Unknown op")?;
+
+        // Every slot takes true `Table` columns ONLY - expression aliases
+        // and other window columns would create dependency cycles (and
+        // force delete-blocking). The slots reject non-table drops with the
+        // invalid-X overlay, so these are backstops for API-authored specs
+        // opened in the editor.
+        let table_column = |col: &String| {
+            metadata
+                .get_table_columns()
+                .into_iter()
+                .flatten()
+                .any(|x| x == col)
+        };
+
+        if self.source.is_empty() {
+            return Err("Missing Column".to_string());
+        }
+
+        if !table_column(&self.source) {
+            // TODO I should not be
+            return Err(format!(
+                "\"{}\" must be a table column to source a window",
+                self.source
+            ));
+        }
+
+        let source_ty = metadata
+            .get_column_table_type(&self.source)
+            .ok_or_else(|| format!("Unknown source column \"{}\"", self.source))?;
+
+        // Backstop for API-authored specs opened in the editor - the op
+        // menu only offers the feature-declared set, so this is
+        // unreachable from the UI.
+        let available = metadata
+            .get_features()
+            .map(|x| x.get_window_aggregates(source_ty))
+            .unwrap_or_default();
+
+        if !available.contains(&op) {
+            return Err(format!(
+                "\"{}\" is not a supported window aggregate for this column",
+                op_label(op)
+            ));
+        }
+
+        // An EMPTY order slot is valid when the backend has a natural row
+        // order to fall back on (primary key order in the engine, `rowid`
+        // for SQL virtual servers); UNORDERED stores (`Features`) require
+        // an explicit order column.
+        let order_ty = if self.order_by.is_empty() {
+            if metadata
+                .get_features()
+                .map(|x| x.unordered)
+                .unwrap_or_default()
+            {
+                return Err("Missing Order By".to_string());
+            }
+
+            None
+        } else {
+            if !table_column(&self.order_by) {
+                // TODO I should not be
+                return Err(format!(
+                    "\"{}\" must be a table column to order by",
+                    self.order_by
+                ));
+            }
+
+            Some(
+                metadata
+                    .get_column_table_type(&self.order_by)
+                    .ok_or_else(|| format!("Unknown order by column \"{}\"", self.order_by))?,
+            )
+        };
+
+        for col in self.partition_by.iter() {
+            // TODO I should not be
+            if !table_column(col) {
+                return Err(format!(
+                    "\"{}\" must be a table column to partition by",
+                    col
+                ));
+            }
+        }
+
+        // The numeric fields are typed and input-clamped to their domains,
+        // so no parse or range errors are reachable here.
+        let frame = if is_aggregating(op) || op == WindowAggregate::Rate {
+            match self.frame_type.as_str() {
+                "Rows" | "Cumulative" if op == WindowAggregate::Rate => {
+                    return Err("\"rate\" requires a range frame".to_string());
+                },
+                "Rows" => Some(WindowFrame::Rows(self.frame_rows)),
+                "Range" => {
+                    // The natural-order fallback has no units, so `range`
+                    // frames require an explicit order column.
+                    let Some(order_ty) = order_ty else {
+                        return Err("Range frames require an order by column".to_string());
+                    };
+
+                    if !is_orderable_for_range(order_ty) {
+                        return Err("Range frames require a numeric, date or datetime order by \
+                                    column"
+                            .to_string());
+                    }
+
+                    Some(WindowFrame::Range(self.frame_range))
+                },
+                _ => None,
+            }
+        } else {
+            None
+        };
+
+        // Emit `None` at the engine default so a spec saved without an
+        // explicit `offset` round-trips unchanged (the name-stripped
+        // change-detection baseline compares specs structurally).
+        let offset = (is_positional(op) && self.offset != 1).then_some(self.offset);
+        let alpha = (op == WindowAggregate::Ema).then_some(self.alpha);
+
+        let mut partition_by = self.partition_by.clone();
+        partition_by.retain(|col| !col.is_empty());
+
+        Ok(WindowSpec {
+            column: self.source.clone(),
+            aggregate: op,
+            partition_by,
+            order_by: (!self.order_by.is_empty()).then(|| {
+                WindowSort(
+                    self.order_by.clone(),
+                    if self.order_desc {
+                        WindowSortDir::Desc
+                    } else {
+                        WindowSortDir::Asc
+                    },
+                )
+            }),
+            frame,
+            offset,
+            alpha,
+        })
+    }
+}
+
+#[derive(Clone, Debug)]
+pub enum WindowEditorMsg {
+    SetOp(String),
+    ClearSource,
+    ClearOrderBy,
+    ToggleOrderDir,
+    RemovePartition(usize),
+    SetFrameType(String),
+    /// Number-field messages carry the input's `value_as_number` (`NaN` for
+    /// empty or unparseable text); the handlers clamp to each field's
+    /// domain, resetting to the default `1` on invalid input.
+    SetFrameRows(f64),
+    SetFrameRange(f64),
+    SetOffset(f64),
+    SetAlpha(f64),
+    /// A completed drop concerning this editor: a staged target to fill,
+    /// and/or the staged origin slot (`DragEffect::Move` from a slot pill)
+    /// to clear.
+    Drop(String, DragTarget, Option<DragTarget>),
+    New(DragTarget, InPlaceColumn),
+    DragEnter(DragTarget, usize),
+    DragLeave(DragTarget),
+}
+
+/// [`DragContext`] bindings routing one [`DragDropList`] per staged target
+/// into [`WindowEditorMsg`]s - the same composition the config selector
+/// uses per zone, so the slots inherit its drop previews, autocomplete
+/// (`EmptyColumn`) and pill styling.
+struct WindowSourceContext;
+struct WindowOrderByContext;
+struct WindowPartitionByContext;
+
+impl DragContext<WindowEditorMsg> for WindowSourceContext {
+    fn close(_index: usize) -> WindowEditorMsg {
+        WindowEditorMsg::ClearSource
+    }
+
+    fn dragenter(index: usize) -> WindowEditorMsg {
+        WindowEditorMsg::DragEnter(DragTarget::WindowSource, index)
+    }
+
+    fn dragleave() -> WindowEditorMsg {
+        WindowEditorMsg::DragLeave(DragTarget::WindowSource)
+    }
+
+    fn create(col: InPlaceColumn) -> WindowEditorMsg {
+        WindowEditorMsg::New(DragTarget::WindowSource, col)
+    }
+
+    fn is_self_move(effect: DragTarget) -> bool {
+        effect == DragTarget::WindowSource
+    }
+}
+
+impl DragContext<WindowEditorMsg> for WindowOrderByContext {
+    fn close(_index: usize) -> WindowEditorMsg {
+        WindowEditorMsg::ClearOrderBy
+    }
+
+    fn dragenter(index: usize) -> WindowEditorMsg {
+        WindowEditorMsg::DragEnter(DragTarget::WindowOrderBy, index)
+    }
+
+    fn dragleave() -> WindowEditorMsg {
+        WindowEditorMsg::DragLeave(DragTarget::WindowOrderBy)
+    }
+
+    fn create(col: InPlaceColumn) -> WindowEditorMsg {
+        WindowEditorMsg::New(DragTarget::WindowOrderBy, col)
+    }
+
+    fn is_self_move(effect: DragTarget) -> bool {
+        effect == DragTarget::WindowOrderBy
+    }
+}
+
+impl DragContext<WindowEditorMsg> for WindowPartitionByContext {
+    fn close(index: usize) -> WindowEditorMsg {
+        WindowEditorMsg::RemovePartition(index)
+    }
+
+    fn dragenter(index: usize) -> WindowEditorMsg {
+        WindowEditorMsg::DragEnter(DragTarget::WindowPartitionBy, index)
+    }
+
+    fn dragleave() -> WindowEditorMsg {
+        WindowEditorMsg::DragLeave(DragTarget::WindowPartitionBy)
+    }
+
+    fn create(col: InPlaceColumn) -> WindowEditorMsg {
+        WindowEditorMsg::New(DragTarget::WindowPartitionBy, col)
+    }
+
+    fn is_self_move(effect: DragTarget) -> bool {
+        effect == DragTarget::WindowPartitionBy
+    }
+}
+
+/// A slot's filled state: the shared `ColumnSelectorColumnRow`, with the
+/// window `op` selector bound into its aggregate slot for the SOURCE slot -
+/// the ONLY op control in the UI. The pill is a drag ORIGIN with
+/// `DragEffect::Move(action)` (the same shape as `PivotColumn`) - the open
+/// [`WindowEditor`] consumes the staged origin from `drop_received` to
+/// complete the move by clearing this slot in its draft.
+#[derive(Clone, Properties)]
+pub struct WindowSlotColumnProps {
+    pub column: String,
+    pub column_type: Option<ColumnType>,
+
+    /// The staged slot this pill occupies - its drag origin.
+    pub action: DragTarget,
+
+    pub presentation: Presentation,
+
+    #[prop_or_default]
+    pub aggregate: Option<Html>,
+
+    /// Trailing affordance in the row (the order slot's staged sort-dir
+    /// toggle).
+    #[prop_or_default]
+    pub trailing: Html,
+}
+
+impl PartialEq for WindowSlotColumnProps {
+    fn eq(&self, other: &Self) -> bool {
+        self.column == other.column
+            && self.column_type == other.column_type
+            && self.action == other.action
+            && self.aggregate == other.aggregate
+            && self.trailing == other.trailing
+    }
+}
+
+impl DragDropListItemProps for WindowSlotColumnProps {
+    type Item = String;
+
+    fn get_item(&self) -> String {
+        self.column.clone()
+    }
+}
+
+pub struct WindowSlotColumn;
+
+impl Component for WindowSlotColumn {
+    type Message = ();
+    type Properties = WindowSlotColumnProps;
+
+    fn create(_ctx: &Context<Self>) -> Self {
+        Self
+    }
+
+    fn view(&self, ctx: &Context<Self>) -> Html {
+        let dragstart = Callback::from({
+            let column = ctx.props().column.clone();
+            let presentation = ctx.props().presentation.clone();
+            let action = ctx.props().action;
+            move |event: DragEvent| {
+                presentation.set_drag_image(&event).unwrap();
+                presentation.notify_drag_start(column.clone(), DragEffect::Move(action))
+            }
+        });
+
+        let dragend = Callback::from({
+            let presentation = ctx.props().presentation.clone();
+            move |_: DragEvent| presentation.notify_drag_end()
+        });
+
+        html! {
+            <div class="column-selector-column">
+                <ColumnSelectorColumnRow
+                    name={ctx.props().column.clone()}
+                    col_type={ctx.props().column_type}
+                    aggregate={ctx.props().aggregate.clone()}
+                    trailing={ctx.props().trailing.clone()}
+                    wrapper_class={classes!["column-selector-column-title"]}
+                    ondragstart={Some(dragstart)}
+                    ondragend={Some(dragend)}
+                />
+            </div>
+        }
+    }
+}
+
+pub struct WindowEditor {
+    draft: WindowDraft,
+    error: Option<String>,
+    column_dropdown: ColumnDropDownElement,
+    _drop_sub: Subscription,
+}
+
+impl WindowEditor {
+    fn initialize(ctx: &Context<Self>) -> WindowDraft {
+        ctx.props()
+            .initial
+            .as_ref()
+            .map(WindowDraft::from_spec)
+            .unwrap_or_else(WindowDraft::new_default)
+    }
+
+    fn emit(&mut self, ctx: &Context<Self>) {
+        match self.draft.validate(&ctx.props().metadata) {
+            Ok(spec) => {
+                self.error = None;
+                ctx.props().on_change.emit(Some(spec));
+            },
+            Err(msg) => {
+                self.error = Some(msg);
+                ctx.props().on_change.emit(None);
+            },
+        }
+    }
+}
+
+impl Component for WindowEditor {
+    type Message = WindowEditorMsg;
+    type Properties = WindowEditorProps;
+
+    fn create(ctx: &Context<Self>) -> Self {
+        let _drop_sub = {
+            let link = ctx.link().clone();
+            ctx.props().presentation.drop_received.add_listener(
+                move |(column, target, effect, _index): (String, DragTarget, DragEffect, usize)| {
+                    let staged_origin = match effect {
+                        DragEffect::Move(origin) if origin.is_staged() => Some(origin),
+                        _ => None,
+                    };
+
+                    if target.is_staged() || staged_origin.is_some() {
+                        link.send_message(WindowEditorMsg::Drop(column, target, staged_origin));
+                    }
+                },
+            )
+        };
+
+        let mut this = Self {
+            draft: Self::initialize(ctx),
+            error: None,
+            column_dropdown: ColumnDropDownElement::new(ctx.props().session.clone()),
+            _drop_sub,
+        };
+
+        this.emit(ctx);
+        this
+    }
+
+    fn changed(&mut self, ctx: &Context<Self>, old_props: &Self::Properties) -> bool {
+        if ctx.props().reset_count != old_props.reset_count
+            || ctx.props().initial != old_props.initial
+        {
+            self.draft = Self::initialize(ctx);
+            self.emit(ctx);
+            true
+        } else {
+            false
+        }
+    }
+
+    fn update(&mut self, ctx: &Context<Self>, msg: Self::Message) -> bool {
+        match msg {
+            WindowEditorMsg::DragEnter(target, index) => {
+                return ctx.props().presentation.notify_drag_enter(target, index);
+            },
+            WindowEditorMsg::DragLeave(target) => {
+                ctx.props().presentation.notify_drag_leave(target);
+                return true;
+            },
+            WindowEditorMsg::New(target, InPlaceColumn::Column(column)) => {
+                ctx.link()
+                    .send_message(WindowEditorMsg::Drop(column, target, None));
+                return false;
+            },
+            WindowEditorMsg::New(_, InPlaceColumn::Expression(_)) => {
+                // In-place expression creation is a config-selector affordance;
+                // staged window slots take existing columns only.
+                return false;
+            },
+            WindowEditorMsg::Drop(column, target, origin) => {
+                // The origin slot clears FIRST so a self-move (origin ==
+                // target) re-inserts the same column and nets to no change.
+                match origin {
+                    Some(DragTarget::WindowSource) => self.draft.source = String::default(),
+                    Some(DragTarget::WindowOrderBy) => self.draft.order_by = String::default(),
+                    Some(DragTarget::WindowPartitionBy) => {
+                        self.draft.partition_by.retain(|x| x != &column)
+                    },
+                    _ => {},
+                }
+
+                // Slots take true `Table` columns ONLY - a staged drop of
+                // an expression or window column is rejected outright (the
+                // list already showed the invalid-X overlay during hover).
+                let is_table_column = ctx
+                    .props()
+                    .metadata
+                    .get_table_columns()
+                    .into_iter()
+                    .flatten()
+                    .any(|x| *x == column);
+
+                match target {
+                    _ if target.is_staged() && !is_table_column => {},
+                    DragTarget::WindowSource => {
+                        self.draft.source = column;
+
+                        // The op selector only offers the feature-declared
+                        // set for the source's type, so an op orphaned by
+                        // the new source coerces to that set's first entry.
+                        let available = ctx
+                            .props()
+                            .metadata
+                            .get_column_table_type(&self.draft.source)
+                            .and_then(|ty| {
+                                ctx.props()
+                                    .metadata
+                                    .get_features()
+                                    .map(|x| x.get_window_aggregates(ty))
+                            })
+                            .unwrap_or_default();
+
+                        if !op_from_label(&self.draft.op)
+                            .map(|op| available.contains(&op))
+                            .unwrap_or_default()
+                            && let Some(first) = available.first()
+                        {
+                            self.draft.op = op_label(*first).to_string();
+                        }
+                    },
+                    DragTarget::WindowOrderBy => self.draft.order_by = column,
+                    DragTarget::WindowPartitionBy
+                        if !column.is_empty() && !self.draft.partition_by.contains(&column) =>
+                    {
+                        self.draft.partition_by.push(column);
+                    },
+                    // A committing target: the config zone handles its own
+                    // insert; only the staged origin cleanup applies here.
+                    _ => {},
+                }
+            },
+            WindowEditorMsg::SetOp(op) => {
+                self.draft.op = op;
+
+                // Keep the frame coherent as the op class changes (`rate`
+                // requires a Range frame; the frame-type dropdown omits the
+                // rest).
+                if op_from_label(&self.draft.op) == Some(WindowAggregate::Rate) {
+                    self.draft.frame_type = "Range".to_string();
+                }
+            },
+            WindowEditorMsg::ClearSource => self.draft.source = String::default(),
+            WindowEditorMsg::ClearOrderBy => self.draft.order_by = String::default(),
+            WindowEditorMsg::ToggleOrderDir => self.draft.order_desc = !self.draft.order_desc,
+            WindowEditorMsg::RemovePartition(idx) => {
+                if idx < self.draft.partition_by.len() {
+                    self.draft.partition_by.remove(idx);
+                }
+            },
+            WindowEditorMsg::SetFrameType(x) => self.draft.frame_type = x,
+            WindowEditorMsg::SetFrameRows(x) => {
+                self.draft.frame_rows = if x.is_finite() && x >= 0.0 {
+                    x as u32
+                } else {
+                    1
+                };
+            },
+            WindowEditorMsg::SetFrameRange(x) => {
+                self.draft.frame_range = if x.is_finite() && x > 0.0 { x } else { 1.0 };
+            },
+            WindowEditorMsg::SetOffset(x) => {
+                self.draft.offset = if x.is_finite() && x >= 0.0 {
+                    x as u32
+                } else {
+                    1
+                };
+            },
+            WindowEditorMsg::SetAlpha(x) => {
+                self.draft.alpha = if x.is_finite() && x > 0.0 && x <= 1.0 {
+                    x
+                } else {
+                    1.0
+                };
+            },
+        }
+
+        self.emit(ctx);
+        true
+    }
+
+    fn view(&self, ctx: &Context<Self>) -> Html {
+        let op = op_from_label(&self.draft.op);
+
+        // The op selector renders the FEATURE-DECLARED window aggregates
+        // for the source column's type, in the server's declared order -
+        // capability and type-validity both come from the data model
+        // (`GetFeaturesResp::window_aggregates`), not a hardcoded list.
+        let ops: Rc<Vec<SelectItem<String>>> = Rc::new(
+            ctx.props()
+                .metadata
+                .get_column_table_type(&self.draft.source)
+                .and_then(|ty| {
+                    ctx.props()
+                        .metadata
+                        .get_features()
+                        .map(|x| x.get_window_aggregates(ty))
+                })
+                .unwrap_or_default()
+                .into_iter()
+                .map(|x| SelectItem::Option(op_label(x).to_string()))
+                .collect(),
+        );
+
+        // Number inputs report `value_as_number` (`NaN` for empty/garbage),
+        // the Style tab `NumberField` idiom - the handlers reset invalid
+        // values to the default.
+        let on_number_input = |f: fn(f64) -> WindowEditorMsg| {
+            ctx.link().callback(move |event: InputEvent| {
+                let value = event
+                    .target()
+                    .and_then(|t| t.dyn_into::<HtmlInputElement>().ok())
+                    .map(|x| x.value_as_number())
+                    .unwrap_or(f64::NAN);
+                f(value)
+            })
+        };
+
+        // Frame type as a dropdown; like the op selector, invalid choices
+        // are omitted rather than disabled (`rate` requires a Range frame,
+        // and `SetOp` already coerces the draft there).
+        let frame_types: Rc<Vec<SelectItem<String>>> = Rc::new(
+            if op == Some(WindowAggregate::Rate) {
+                vec!["Range"]
+            } else {
+                vec!["Rows", "Range", "Cumulative"]
+            }
+            .into_iter()
+            .map(|x| SelectItem::Option(x.to_string()))
+            .collect(),
+        );
+
+        // Slots take true `Table` columns ONLY - expression aliases and
+        // other window columns would create dependency cycles (and force
+        // delete-blocking). They join every slot's `exclude` set (removing
+        // them from the autocomplete dropdowns), the drop handler rejects
+        // them, and an invalid hover shows the X overlay below.
+        let non_table: HashSet<String> = ctx
+            .props()
+            .metadata
+            .get_expression_columns()
+            .chain(ctx.props().metadata.get_window_columns())
+            .cloned()
+            .collect();
+
+        let is_invalid_drag = |target: DragTarget| {
+            ctx.props()
+                .presentation
+                .is_dragover(target)
+                .map(|(_, col)| non_table.contains(&col))
+                .unwrap_or_default()
+        };
+
+        // The op selector renders in the source pill's aggregate-selector
+        // space - the ONLY place a window op control exists in the UI.
+        let source_exclude: HashSet<String> = std::iter::once(self.draft.source.clone())
+            .chain(non_table.iter().cloned())
+            .collect();
+
+        let source_list = html! {
+            <DragDropList<WindowEditor, WindowSlotColumn, WindowSourceContext>
+                name="window-source"
+                parent={ctx.link().clone()}
+                presentation={ctx.props().presentation.clone()}
+                column_dropdown={self.column_dropdown.clone()}
+                exclude={source_exclude}
+                is_dragover={ctx.props().presentation.is_dragover(DragTarget::WindowSource)}
+                is_invalid={is_invalid_drag(DragTarget::WindowSource)}
+                single_slot=true
+            >
+                { for (!self.draft.source.is_empty()).then(|| yew::html_nested! {
+                        <WindowSlotColumn
+                            column={self.draft.source.clone()}
+                            column_type={ctx.props().metadata.get_column_table_type(&self.draft.source)}
+                            action={DragTarget::WindowSource}
+                            presentation={ctx.props().presentation.clone()}
+                            aggregate={html! {
+                                <div class="aggregate-selector-wrapper">
+                                    <Select<String>
+                                        wrapper_class="aggregate-selector"
+                                        values={ops.clone()}
+                                        selected={self.draft.op.clone()}
+                                        on_select={ctx.link().callback(WindowEditorMsg::SetOp)}
+                                    />
+                                </div>
+                            }}
+                        />
+                    }) }
+            </DragDropList<WindowEditor, WindowSlotColumn, WindowSourceContext>>
+        };
+
+        let order_exclude: HashSet<String> = std::iter::once(self.draft.order_by.clone())
+            .chain(non_table.iter().cloned())
+            .collect();
+        let order_list = html! {
+            <DragDropList<WindowEditor, WindowSlotColumn, WindowOrderByContext>
+                name="window-order-by"
+                parent={ctx.link().clone()}
+                presentation={ctx.props().presentation.clone()}
+                column_dropdown={self.column_dropdown.clone()}
+                exclude={order_exclude}
+                is_dragover={ctx.props().presentation.is_dragover(DragTarget::WindowOrderBy)}
+                is_invalid={is_invalid_drag(DragTarget::WindowOrderBy)}
+                single_slot=true
+            >
+                { for (!self.draft.order_by.is_empty()).then(|| {
+                        // The sort pill's direction affordance, staged: the
+                        // toggle mutates the draft only, committed by Save.
+                        let dir = if self.draft.order_desc {
+                            WindowSortDir::Desc
+                        } else {
+                            WindowSortDir::Asc
+                        };
+
+                        let onmousedown = ctx
+                            .link()
+                            .callback(|_: MouseEvent| WindowEditorMsg::ToggleOrderDir);
+
+                        yew::html_nested! {
+                            <WindowSlotColumn
+                                column={self.draft.order_by.clone()}
+                                column_type={ctx.props().metadata.get_column_table_type(&self.draft.order_by)}
+                                action={DragTarget::WindowOrderBy}
+                                presentation={ctx.props().presentation.clone()}
+                                trailing={html! {
+                                    <span
+                                        class={format!("sort-icon {}", dir)}
+                                        {onmousedown}
+                                    />
+                                }}
+                            />
+                        }
+                    }) }
+            </DragDropList<WindowEditor, WindowSlotColumn, WindowOrderByContext>>
+        };
+
+        let partition_exclude: HashSet<String> = self
+            .draft
+            .partition_by
+            .iter()
+            .cloned()
+            .chain(non_table.iter().cloned())
+            .collect();
+        let partition_list = html! {
+            <DragDropList<WindowEditor, PivotColumn, WindowPartitionByContext>
+                name="window-partition-by"
+                parent={ctx.link().clone()}
+                presentation={ctx.props().presentation.clone()}
+                column_dropdown={self.column_dropdown.clone()}
+                exclude={partition_exclude}
+                is_dragover={ctx.props().presentation.is_dragover(DragTarget::WindowPartitionBy)}
+                is_invalid={is_invalid_drag(DragTarget::WindowPartitionBy)}
+            >
+                { for self.draft.partition_by.iter().map(|col| yew::html_nested! {
+                        <PivotColumn
+                            column={col.clone()}
+                            column_type={ctx.props().metadata.get_column_table_type(col)}
+                            action={DragTarget::WindowPartitionBy}
+                            presentation={ctx.props().presentation.clone()}
+                        />
+                    }) }
+            </DragDropList<WindowEditor, PivotColumn, WindowPartitionByContext>>
+        };
+
+        let show_frame =
+            op.map(is_aggregating).unwrap_or_default() || op == Some(WindowAggregate::Rate);
+        let show_offset = op.map(is_positional).unwrap_or_default();
+        let show_alpha = op == Some(WindowAggregate::Ema);
+
+        html! {
+            <>
+                <div id="window-editor-slots">{ source_list }{ order_list }{ partition_list }</div>
+                <div id="window-editor-container">
+                    if show_frame {
+                        <div class="column-style-label"><label id="window-frame-label" /></div>
+                        <div class="row">
+                            <Select<String>
+                                id="window-frame-type"
+                                values={frame_types}
+                                selected={self.draft.frame_type.clone()}
+                                on_select={ctx.link().callback(WindowEditorMsg::SetFrameType)}
+                            />
+                        </div>
+                        if self.draft.frame_type == "Rows" {
+                            <div class="row">
+                                <input
+                                    type="number"
+                                    class="parameter"
+                                    min="0"
+                                    value={self.draft.frame_rows.to_string()}
+                                    oninput={on_number_input(WindowEditorMsg::SetFrameRows)}
+                                />
+                            </div>
+                        }
+                        if self.draft.frame_type == "Range" {
+                            <div class="row">
+                                <input
+                                    type="number"
+                                    class="parameter"
+                                    min="0"
+                                    value={self.draft.frame_range.to_string()}
+                                    oninput={on_number_input(WindowEditorMsg::SetFrameRange)}
+                                />
+                            </div>
+                        }
+                    }
+                    if show_offset {
+                        <div class="column-style-label">
+                            <label id="window-offset-label" class="indent" />
+                        </div>
+                        <div class="row">
+                            <input
+                                type="number"
+                                class="parameter"
+                                min="0"
+                                value={self.draft.offset.to_string()}
+                                oninput={on_number_input(WindowEditorMsg::SetOffset)}
+                            />
+                        </div>
+                    }
+                    if show_alpha {
+                        <div class="column-style-label">
+                            <label id="window-alpha-label" class="indent" />
+                        </div>
+                        <div class="row">
+                            <input
+                                type="number"
+                                class="parameter"
+                                step="0.05"
+                                min="0"
+                                max="1"
+                                value={self.draft.alpha.to_string()}
+                                oninput={on_number_input(WindowEditorMsg::SetAlpha)}
+                            />
+                        </div>
+                    }
+                    if let Some(error) = &self.error {
+                        <div class="row window-editor-error">{ error.clone() }</div>
+                    }
+                </div>
+                <ColumnDropDownPortal
+                    element={self.column_dropdown.clone()}
+                    theme={ctx.props().selected_theme.clone().unwrap_or_default()}
+                />
+            </>
+        }
+    }
+}