1use 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
17pub 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}