Skip to main content

vibe/web_runtime/ui_controls/
composite.rs

1//! Composite & Uplift UI Controls (`ui.*`) for VibeScript v0.02.
2//!
3//! Implements interval sliders, tag chips, fuzzy comboboxes, tri-state tree
4//! selectors, transfer lists, segmented controls, steppers, ratings, virtualized
5//! data grids, spectral color pickers, bezier ink pads, and OTP inputs.
6
7use std::collections::BTreeMap;
8
9use crate::error::{DiagCode, Diagnostic};
10use crate::span::Span;
11use crate::value::Value;
12
13use super::{
14    extract_f64, extract_i64, extract_list, extract_str, opt_bool, opt_f64, opt_i64, opt_str,
15};
16
17/// Dispatch a composite uplift `ui.*` widget function call.
18pub fn call_composite_control(
19    path: &str,
20    args: &[Value],
21    span: Span,
22) -> Result<Option<Value>, Diagnostic> {
23    match path {
24        "ui.range_interval" => {
25            let id = extract_str(args, 0, "ui.range_interval", span)?;
26            let min = extract_f64(args, 1, "ui.range_interval", span)?;
27            let max = extract_f64(args, 2, "ui.range_interval", span)?.max(min);
28            let mut lo = extract_f64(args, 3, "ui.range_interval", span)?.clamp(min, max);
29            let mut hi = extract_f64(args, 4, "ui.range_interval", span)?.clamp(min, max);
30            if lo > hi {
31                std::mem::swap(&mut lo, &mut hi);
32            }
33            let min_gap = opt_f64(args, 5, 0.0).max(0.0).min(max - min);
34            if hi - lo < min_gap {
35                hi = (lo + min_gap).min(max);
36                lo = (hi - min_gap).max(min);
37            }
38            let scale = opt_str(args, 6, "linear");
39            let ratio_lo = scale_ratio(lo, min, max, &scale, span)?;
40            let ratio_hi = scale_ratio(hi, min, max, &scale, span)?;
41            let mut rec = BTreeMap::new();
42            rec.insert("id".into(), Value::String(id));
43            rec.insert("kind".into(), Value::String("range-interval".into()));
44            rec.insert("min".into(), Value::F64(min));
45            rec.insert("max".into(), Value::F64(max));
46            rec.insert("lo".into(), Value::F64(lo));
47            rec.insert("hi".into(), Value::F64(hi));
48            rec.insert("span".into(), Value::F64(hi - lo));
49            rec.insert("ratio_lo".into(), Value::F64(ratio_lo));
50            rec.insert("ratio_hi".into(), Value::F64(ratio_hi));
51            rec.insert("scale".into(), Value::String(scale));
52            Ok(Some(Value::Record(rec)))
53        }
54        "ui.tag_input" => {
55            let id = extract_str(args, 0, "ui.tag_input", span)?;
56            let existing = extract_list(args, 1, "ui.tag_input", span)?;
57            let raw_entry = extract_str(args, 2, "ui.tag_input", span)?;
58            let max_tags = opt_i64(args, 3, 64).max(1) as usize;
59            let allow_duplicates = opt_bool(args, 4, false);
60
61            let mut tags: Vec<String> = Vec::new();
62            for item in existing {
63                if let Value::String(s) = item {
64                    let t = s.trim().to_string();
65                    if !t.is_empty()
66                        && (allow_duplicates || !tags.contains(&t))
67                        && tags.len() < max_tags
68                    {
69                        tags.push(t);
70                    }
71                }
72            }
73            for token in raw_entry.split([',', ';', '\n']) {
74                let t = token.trim().to_string();
75                if !t.is_empty()
76                    && (allow_duplicates || !tags.contains(&t))
77                    && tags.len() < max_tags
78                {
79                    tags.push(t);
80                }
81            }
82            let count = tags.len() as i64;
83            let quota_reached = tags.len() >= max_tags;
84            let mut rec = BTreeMap::new();
85            rec.insert("id".into(), Value::String(id));
86            rec.insert("kind".into(), Value::String("tag-input".into()));
87            rec.insert(
88                "tags".into(),
89                Value::List(tags.into_iter().map(Value::String).collect()),
90            );
91            rec.insert("count".into(), Value::I64(count));
92            rec.insert("quota_reached".into(), Value::Bool(quota_reached));
93            Ok(Some(Value::Record(rec)))
94        }
95        "ui.combobox" => {
96            let id = extract_str(args, 0, "ui.combobox", span)?;
97            let query = extract_str(args, 1, "ui.combobox", span)?;
98            let options = extract_list(args, 2, "ui.combobox", span)?;
99            let max_visible = opt_i64(args, 3, 10).max(1) as usize;
100            let q = query.trim().to_ascii_lowercase();
101
102            let mut scored: Vec<(i64, usize, BTreeMap<String, Value>)> = Vec::new();
103            for (idx, opt) in options.into_iter().enumerate() {
104                if let Value::Record(mut map) = opt {
105                    let s = score_option(&map, &q);
106                    if s > 0 {
107                        map.insert("score".into(), Value::I64(s));
108                        scored.push((s, idx, map));
109                    }
110                }
111            }
112            scored.sort_by(|a, b| b.0.cmp(&a.0).then_with(|| a.1.cmp(&b.1)));
113            let total_matches = scored.len() as i64;
114            let matches: Vec<Value> = scored
115                .into_iter()
116                .take(max_visible)
117                .map(|(_, _, m)| Value::Record(m))
118                .collect();
119
120            let mut rec = BTreeMap::new();
121            rec.insert("id".into(), Value::String(id));
122            rec.insert("kind".into(), Value::String("combobox".into()));
123            rec.insert("query".into(), Value::String(query));
124            rec.insert("matches".into(), Value::List(matches));
125            rec.insert("total_matches".into(), Value::I64(total_matches));
126            Ok(Some(Value::Record(rec)))
127        }
128        "ui.tree_select" => eval_tree_select(args, span),
129        "ui.transfer_list" => {
130            let id = extract_str(args, 0, "ui.transfer_list", span)?;
131            let mut available = extract_list(args, 1, "ui.transfer_list", span)?;
132            let mut assigned = extract_list(args, 2, "ui.transfer_list", span)?;
133            let move_items = extract_list(args, 3, "ui.transfer_list", span)?;
134            let direction = extract_str(args, 4, "ui.transfer_list", span)?;
135            match direction.as_str() {
136                "to_assigned" => {
137                    available.retain(|x| !move_items.contains(x));
138                    for item in move_items {
139                        if !assigned.contains(&item) {
140                            assigned.push(item);
141                        }
142                    }
143                }
144                "to_available" => {
145                    assigned.retain(|x| !move_items.contains(x));
146                    for item in move_items {
147                        if !available.contains(&item) {
148                            available.push(item);
149                        }
150                    }
151                }
152                _ => {
153                    return Err(Diagnostic::new(
154                        DiagCode::E100,
155                        span,
156                        format!("ui.transfer_list: invalid direction '{direction}'"),
157                    ))
158                }
159            }
160            let mut rec = BTreeMap::new();
161            rec.insert("id".into(), Value::String(id));
162            rec.insert("available".into(), Value::List(available));
163            rec.insert("assigned".into(), Value::List(assigned));
164            Ok(Some(Value::Record(rec)))
165        }
166        "ui.segmented_control" => {
167            let id = extract_str(args, 0, "ui.segmented_control", span)?;
168            let segments = extract_list(args, 1, "ui.segmented_control", span)?;
169            let active = extract_str(args, 2, "ui.segmented_control", span)?;
170            let mut rec = BTreeMap::new();
171            rec.insert("id".into(), Value::String(id));
172            rec.insert("kind".into(), Value::String("segmented-control".into()));
173            rec.insert("segments".into(), Value::List(segments));
174            rec.insert("active".into(), Value::String(active));
175            Ok(Some(Value::Record(rec)))
176        }
177        "ui.stepper" => {
178            let id = extract_str(args, 0, "ui.stepper", span)?;
179            let steps = extract_list(args, 1, "ui.stepper", span)?;
180            let max_idx = (steps.len() as i64 - 1).max(0);
181            let current_index = extract_i64(args, 2, "ui.stepper", span)?.clamp(0, max_idx);
182            let progress_pct = if steps.len() <= 1 {
183                100.0
184            } else {
185                (current_index as f64 / max_idx as f64) * 100.0
186            };
187            let mut rec = BTreeMap::new();
188            rec.insert("id".into(), Value::String(id));
189            rec.insert("kind".into(), Value::String("stepper".into()));
190            rec.insert("steps".into(), Value::List(steps.clone()));
191            rec.insert("current_index".into(), Value::I64(current_index));
192            rec.insert("progress_pct".into(), Value::F64(progress_pct));
193            rec.insert("can_prev".into(), Value::Bool(current_index > 0));
194            rec.insert(
195                "can_next".into(),
196                Value::Bool((current_index as usize) + 1 < steps.len()),
197            );
198            Ok(Some(Value::Record(rec)))
199        }
200        "ui.rating" => {
201            let id = extract_str(args, 0, "ui.rating", span)?;
202            let raw_val = extract_f64(args, 1, "ui.rating", span)?;
203            let max_stars = opt_i64(args, 2, 5).max(1);
204            let clamped = raw_val.clamp(0.0, max_stars as f64);
205            let value = (clamped * 2.0).round() / 2.0;
206            let mut rec = BTreeMap::new();
207            rec.insert("id".into(), Value::String(id));
208            rec.insert("kind".into(), Value::String("rating".into()));
209            rec.insert("value".into(), Value::F64(value));
210            rec.insert("max_stars".into(), Value::I64(max_stars));
211            Ok(Some(Value::Record(rec)))
212        }
213        "ui.data_grid" => {
214            let id = extract_str(args, 0, "ui.data_grid", span)?;
215            let columns = extract_list(args, 1, "ui.data_grid", span)?;
216            let rows = extract_list(args, 2, "ui.data_grid", span)?;
217            let total_rows = rows.len() as i64;
218            let start_row = opt_i64(args, 3, 0).max(0).min(total_rows);
219            let row_count = opt_i64(args, 4, total_rows).max(0);
220            let end = ((start_row + row_count) as usize).min(rows.len());
221            let visible_rows = rows[start_row as usize..end].to_vec();
222            let mut rec = BTreeMap::new();
223            rec.insert("id".into(), Value::String(id));
224            rec.insert("kind".into(), Value::String("data-grid".into()));
225            rec.insert("column_count".into(), Value::I64(columns.len() as i64));
226            rec.insert("total_rows".into(), Value::I64(total_rows));
227            rec.insert("visible_rows".into(), Value::List(visible_rows));
228            rec.insert("start_row".into(), Value::I64(start_row));
229            Ok(Some(Value::Record(rec)))
230        }
231        "ui.spectral_picker" => eval_spectral_picker(args, span),
232        "ui.ink_pad" => eval_ink_pad(args, span),
233        "ui.otp_input" => eval_otp_input(args, span),
234        _ => Ok(None),
235    }
236}
237
238fn eval_tree_select(args: &[Value], span: Span) -> Result<Option<Value>, Diagnostic> {
239    let id = extract_str(args, 0, "ui.tree_select", span)?;
240    let nodes = extract_list(args, 1, "ui.tree_select", span)?;
241    let selected_list = extract_list(args, 2, "ui.tree_select", span)?;
242    let selected_ids: Vec<String> = selected_list
243        .iter()
244        .filter_map(|v| match v {
245            Value::String(s) => Some(s.clone()),
246            _ => None,
247        })
248        .collect();
249
250    let mut all_ids: Vec<String> = Vec::new();
251    let mut children_map: BTreeMap<String, Vec<String>> = BTreeMap::new();
252    for node in &nodes {
253        if let Value::Record(m) = node {
254            if let Some(Value::String(nid)) = m.get("id") {
255                if !all_ids.contains(nid) {
256                    all_ids.push(nid.clone());
257                }
258                if let Some(Value::String(pid)) = m.get("parent_id") {
259                    if !pid.is_empty() {
260                        children_map.entry(pid.clone()).or_default().push(nid.clone());
261                    }
262                }
263                if let Some(Value::List(ch)) = m.get("children") {
264                    for c in ch {
265                        let cid_opt = match c {
266                            Value::String(s) => Some(s.clone()),
267                            Value::Record(cm) => cm.get("id").and_then(|v| match v {
268                                Value::String(s) => Some(s.clone()),
269                                _ => None,
270                            }),
271                            _ => None,
272                        };
273                        if let Some(cid) = cid_opt {
274                            if !all_ids.contains(&cid) {
275                                all_ids.push(cid.clone());
276                            }
277                            children_map.entry(nid.clone()).or_default().push(cid);
278                        }
279                    }
280                }
281            }
282        }
283    }
284
285    let mut node_states = BTreeMap::new();
286    for nid in &all_ids {
287        let st = resolve_tree_state(nid, &children_map, &selected_ids, 0);
288        node_states.insert(nid.clone(), Value::String(st.into()));
289    }
290    let mut rec = BTreeMap::new();
291    rec.insert("id".into(), Value::String(id));
292    rec.insert("kind".into(), Value::String("tree-select".into()));
293    rec.insert("selected_ids".into(), Value::List(selected_list));
294    rec.insert("node_states".into(), Value::Record(node_states));
295    Ok(Some(Value::Record(rec)))
296}
297
298fn resolve_tree_state<'a>(
299    nid: &str,
300    children_map: &BTreeMap<String, Vec<String>>,
301    selected: &[String],
302    depth: usize,
303) -> &'a str {
304    if depth > 16 {
305        return "unchecked";
306    }
307    if let Some(children) = children_map.get(nid) {
308        if !children.is_empty() {
309            let mut checked_cnt = 0usize;
310            let mut indet_cnt = 0usize;
311            for c in children {
312                match resolve_tree_state(c, children_map, selected, depth + 1) {
313                    "checked" => checked_cnt += 1,
314                    "indeterminate" => indet_cnt += 1,
315                    _ => {}
316                }
317            }
318            return if checked_cnt == children.len() {
319                "checked"
320            } else if checked_cnt == 0 && indet_cnt == 0 && !selected.iter().any(|s| s == nid) {
321                "unchecked"
322            } else {
323                "indeterminate"
324            };
325        }
326    }
327    if selected.iter().any(|s| s == nid) {
328        "checked"
329    } else {
330        "unchecked"
331    }
332}
333
334fn eval_spectral_picker(args: &[Value], span: Span) -> Result<Option<Value>, Diagnostic> {
335    let id = extract_str(args, 0, "ui.spectral_picker", span)?;
336    let alpha = extract_f64(args, 1, "ui.spectral_picker", span)?.clamp(0.0, 1.0);
337    let mu_nm = extract_f64(args, 2, "ui.spectral_picker", span)?.clamp(380.0, 780.0);
338    let sigma_nm = extract_f64(args, 3, "ui.spectral_picker", span)?.max(1.0);
339    let (r, g, b) = wavelength_to_srgb(mu_nm);
340    let ri = (r * 255.0).round().clamp(0.0, 255.0) as u8;
341    let gi = (g * 255.0).round().clamp(0.0, 255.0) as u8;
342    let bi = (b * 255.0).round().clamp(0.0, 255.0) as u8;
343    let hex = format!("#{ri:02x}{gi:02x}{bi:02x}");
344    let oklch_l = (0.2126 * r + 0.7152 * g + 0.0722 * b).cbrt();
345    let oklch_c = ((r - g).powi(2) + (g - b).powi(2) + (b - r).powi(2)).sqrt() * 0.25;
346    let oklch_h = ((780.0 - mu_nm) / 400.0 * 300.0).clamp(0.0, 360.0);
347    let mut rec = BTreeMap::new();
348    rec.insert("id".into(), Value::String(id));
349    rec.insert("kind".into(), Value::String("spectral-picker".into()));
350    rec.insert("alpha".into(), Value::F64(alpha));
351    rec.insert("mu_nm".into(), Value::F64(mu_nm));
352    rec.insert("sigma_nm".into(), Value::F64(sigma_nm));
353    rec.insert("hex".into(), Value::String(hex));
354    rec.insert("r".into(), Value::F64(r));
355    rec.insert("g".into(), Value::F64(g));
356    rec.insert("b".into(), Value::F64(b));
357    rec.insert("oklch_l".into(), Value::F64(oklch_l));
358    rec.insert("oklch_c".into(), Value::F64(oklch_c));
359    rec.insert("oklch_h".into(), Value::F64(oklch_h));
360    Ok(Some(Value::Record(rec)))
361}
362
363fn eval_ink_pad(args: &[Value], span: Span) -> Result<Option<Value>, Diagnostic> {
364    let id = extract_str(args, 0, "ui.ink_pad", span)?;
365    let points = extract_list(args, 1, "ui.ink_pad", span)?;
366    let mut coords: Vec<(f64, f64, f64)> = Vec::new();
367    for pt in points {
368        if let Value::Record(m) = pt {
369            let x = m.get("x").and_then(Value::as_f64).unwrap_or(0.0);
370            let y = m.get("y").and_then(Value::as_f64).unwrap_or(0.0);
371            let p = m.get("pressure").and_then(Value::as_f64).unwrap_or(0.5);
372            coords.push((x, y, p));
373        }
374    }
375    let point_count = coords.len() as i64;
376    let (svg_path, mean_pressure) = if coords.is_empty() {
377        (String::new(), 0.0)
378    } else {
379        let mut path = format!("M {} {}", coords[0].0, coords[0].1);
380        for i in 1..coords.len() {
381            let (x0, y0, _) = coords[i - 1];
382            let (x1, y1, _) = coords[i];
383            let mx = (x0 + x1) * 0.5;
384            let my = (y0 + y1) * 0.5;
385            path.push_str(&format!(" Q {x0} {y0} {mx} {my}"));
386        }
387        let sum_p: f64 = coords.iter().map(|c| c.2).sum();
388        (path, sum_p / (coords.len() as f64))
389    };
390    let mut rec = BTreeMap::new();
391    rec.insert("id".into(), Value::String(id));
392    rec.insert("kind".into(), Value::String("ink-pad".into()));
393    rec.insert("point_count".into(), Value::I64(point_count));
394    rec.insert("svg_path".into(), Value::String(svg_path));
395    rec.insert("mean_pressure".into(), Value::F64(mean_pressure));
396    Ok(Some(Value::Record(rec)))
397}
398
399fn eval_otp_input(args: &[Value], span: Span) -> Result<Option<Value>, Diagnostic> {
400    let id = extract_str(args, 0, "ui.otp_input", span)?;
401    let digits = extract_i64(args, 1, "ui.otp_input", span)?.max(1);
402    let raw_input = extract_str(args, 2, "ui.otp_input", span)?;
403    let masked = opt_bool(args, 3, false);
404    let value: String = raw_input
405        .chars()
406        .filter(|c| c.is_ascii_digit())
407        .take(digits as usize)
408        .collect();
409    let display = if masked {
410        "*".repeat(value.len())
411    } else {
412        value.clone()
413    };
414    let mut cells = Vec::with_capacity(digits as usize);
415    let chars: Vec<char> = display.chars().collect();
416    for i in 0..(digits as usize) {
417        cells.push(Value::String(
418            chars.get(i).map(|c| c.to_string()).unwrap_or_default(),
419        ));
420    }
421    let complete = value.len() == digits as usize;
422    let next_focus_index = (value.len() as i64).min(digits - 1);
423    let mut rec = BTreeMap::new();
424    rec.insert("id".into(), Value::String(id));
425    rec.insert("kind".into(), Value::String("otp-input".into()));
426    rec.insert("digits".into(), Value::I64(digits));
427    rec.insert("value".into(), Value::String(value));
428    rec.insert("display".into(), Value::String(display));
429    rec.insert("cells".into(), Value::List(cells));
430    rec.insert("complete".into(), Value::Bool(complete));
431    rec.insert("next_focus_index".into(), Value::I64(next_focus_index));
432    Ok(Some(Value::Record(rec)))
433}
434
435fn scale_ratio(v: f64, min: f64, max: f64, scale: &str, span: Span) -> Result<f64, Diagnostic> {
436    let t = if (max - min).abs() < 1e-12 {
437        0.0
438    } else {
439        ((v - min) / (max - min)).clamp(0.0, 1.0)
440    };
441    match scale {
442        "linear" => Ok(t),
443        "sqrt" => Ok(t.sqrt()),
444        "logarithmic" | "decibel" => Ok((1.0 + 9.0 * t).log10().clamp(0.0, 1.0)),
445        _ => Err(Diagnostic::new(
446            DiagCode::E100,
447            span,
448            format!("ui.range_interval: unsupported scale '{scale}'"),
449        )),
450    }
451}
452
453fn score_option(map: &BTreeMap<String, Value>, q: &str) -> i64 {
454    if q.is_empty() {
455        return 100;
456    }
457    let mut best = 0;
458    for key in ["label", "value", "keywords"] {
459        if let Some(Value::String(s)) = map.get(key) {
460            let cand = s.to_ascii_lowercase();
461            let s_val = if cand == q {
462                100
463            } else if cand.starts_with(q) {
464                80
465            } else if cand.contains(q) {
466                60
467            } else if is_subsequence(q, &cand) {
468                40
469            } else {
470                0
471            };
472            if s_val > best {
473                best = s_val;
474            }
475        }
476    }
477    best
478}
479
480fn is_subsequence(needle: &str, haystack: &str) -> bool {
481    let mut it = haystack.chars();
482    for nc in needle.chars() {
483        if !it.any(|hc| hc == nc) {
484            return false;
485        }
486    }
487    true
488}
489
490fn wavelength_to_srgb(wl: f64) -> (f64, f64, f64) {
491    let (r, g, b) = if wl < 440.0 {
492        (-(wl - 440.0) / 60.0, 0.0, 1.0)
493    } else if wl < 490.0 {
494        (0.0, (wl - 440.0) / 50.0, 1.0)
495    } else if wl < 510.0 {
496        (0.0, 1.0, -(wl - 510.0) / 20.0)
497    } else if wl < 580.0 {
498        ((wl - 510.0) / 70.0, 1.0, 0.0)
499    } else if wl < 645.0 {
500        (1.0, -(wl - 645.0) / 65.0, 0.0)
501    } else {
502        (1.0, 0.0, 0.0)
503    };
504    (r.clamp(0.0, 1.0), g.clamp(0.0, 1.0), b.clamp(0.0, 1.0))
505}