Skip to main content

vibe/web_runtime/input_format/
mask_and_step.rs

1//! Stepping (`input.step`), IME-safe declarative masking (`input.apply_mask`),
2//! and text selection range operations (`selection.set_range`, `selection.replace_range`).
3
4use std::collections::BTreeMap;
5
6use crate::error::{DiagCode, Diagnostic};
7use crate::span::Span;
8use crate::value::{Instant, Quantity, Value};
9
10use super::{extract_i64, extract_opt_str, extract_str};
11
12/// `input.step(current, step_delta, min_opt, max_opt, step_size_opt)`
13pub fn eval_input_step(args: &[Value], span: Span) -> Result<Value, Diagnostic> {
14    let current = args.first().ok_or_else(|| {
15        Diagnostic::new(
16            DiagCode::E100,
17            span,
18            "input.step: missing current value argument",
19        )
20    })?;
21    let step_delta = extract_i64(args, 1, "input.step", span)?;
22    let min_opt = args.get(2);
23    let max_opt = args.get(3);
24    let step_size_opt = args.get(4);
25
26    match current {
27        Value::I64(cur) => {
28            let step_size = step_size_opt
29                .and_then(|v| v.as_i64().or_else(|| v.as_f64().map(|f| f as i64)))
30                .unwrap_or(1);
31            let mut next = cur.saturating_add(step_delta.saturating_mul(step_size));
32            if let Some(lo) =
33                min_opt.and_then(|v| v.as_i64().or_else(|| v.as_f64().map(|f| f as i64)))
34            {
35                next = next.max(lo);
36            }
37            if let Some(hi) =
38                max_opt.and_then(|v| v.as_i64().or_else(|| v.as_f64().map(|f| f as i64)))
39            {
40                next = next.min(hi);
41            }
42            Ok(Value::I64(next))
43        }
44        Value::U64(cur) => {
45            let step_size = step_size_opt
46                .and_then(|v| v.as_i64().or_else(|| v.as_f64().map(|f| f as i64)))
47                .unwrap_or(1);
48            let mut next = (*cur as i64).saturating_add(step_delta.saturating_mul(step_size));
49            if let Some(lo) =
50                min_opt.and_then(|v| v.as_i64().or_else(|| v.as_f64().map(|f| f as i64)))
51            {
52                next = next.max(lo);
53            }
54            if let Some(hi) =
55                max_opt.and_then(|v| v.as_i64().or_else(|| v.as_f64().map(|f| f as i64)))
56            {
57                next = next.min(hi);
58            }
59            Ok(Value::I64(next))
60        }
61        Value::F64(cur) => {
62            let step_size = step_size_opt.and_then(Value::as_f64).unwrap_or(1.0);
63            let mut next = *cur + (step_delta as f64) * step_size;
64            if let Some(lo) = min_opt.and_then(Value::as_f64) {
65                next = next.max(lo);
66            }
67            if let Some(hi) = max_opt.and_then(Value::as_f64) {
68                next = next.min(hi);
69            }
70            Ok(Value::F64(next))
71        }
72        Value::Quantity(q) => {
73            let step_size = step_size_opt.and_then(Value::as_f64).unwrap_or(1.0);
74            let mut next = q.value + (step_delta as f64) * step_size;
75            if let Some(lo) = min_opt.and_then(Value::as_f64) {
76                next = next.max(lo);
77            }
78            if let Some(hi) = max_opt.and_then(Value::as_f64) {
79                next = next.min(hi);
80            }
81            Ok(Value::Quantity(Quantity {
82                value: next,
83                unit: q.unit.clone(),
84            }))
85        }
86        Value::Instant(inst) => {
87            let step_size = match step_size_opt {
88                Some(Value::Duration(d)) => d.secs,
89                Some(other) => other
90                    .as_i64()
91                    .or_else(|| other.as_f64().map(|f| f as i64))
92                    .unwrap_or(1),
93                None => 1,
94            };
95            let mut next_secs = inst
96                .secs
97                .saturating_add(step_delta.saturating_mul(step_size));
98            let min_secs = match min_opt {
99                Some(Value::Instant(i)) => Some(i.secs),
100                Some(other) => other.as_i64().or_else(|| other.as_f64().map(|f| f as i64)),
101                None => None,
102            };
103            let max_secs = match max_opt {
104                Some(Value::Instant(i)) => Some(i.secs),
105                Some(other) => other.as_i64().or_else(|| other.as_f64().map(|f| f as i64)),
106                None => None,
107            };
108            if let Some(lo) = min_secs {
109                next_secs = next_secs.max(lo);
110            }
111            if let Some(hi) = max_secs {
112                next_secs = next_secs.min(hi);
113            }
114            Ok(Value::Instant(Instant {
115                secs: next_secs,
116                ..inst.clone()
117            }))
118        }
119        _ => Err(Diagnostic::new(
120            DiagCode::E100,
121            span,
122            "input.step: current value must be I64, F64, Quantity, or Instant",
123        )),
124    }
125}
126
127fn is_mask_token(m: char) -> bool {
128    matches!(m, '9' | 'a' | '*' | 'h' | '#')
129}
130
131fn matches_mask_token(c: char, token: char) -> bool {
132    match token {
133        '9' => c.is_ascii_digit(),
134        'a' => c.is_ascii_alphabetic(),
135        '*' => c.is_ascii_alphanumeric(),
136        'h' => c.is_ascii_hexdigit(),
137        '#' => c.is_ascii_digit() || c == '+' || c == '-',
138        _ => false,
139    }
140}
141
142/// `input.apply_mask(raw, mask)`
143pub fn eval_apply_mask(args: &[Value], span: Span) -> Result<Value, Diagnostic> {
144    let raw = extract_str(args, 0, "input.apply_mask(raw, mask)", span)?;
145    let mask = extract_str(args, 1, "input.apply_mask(raw, mask)", span)?;
146
147    let raw_chars: Vec<char> = raw.chars().collect();
148    let mask_chars: Vec<char> = mask.chars().collect();
149
150    let total_tokens = mask_chars.iter().filter(|&&m| is_mask_token(m)).count();
151    let mut filled_tokens = 0usize;
152    let mut raw_idx = 0usize;
153    let mut formatted = String::with_capacity(mask.len());
154    let mut raw_clean = String::with_capacity(total_tokens);
155
156    for (m_idx, &m) in mask_chars.iter().enumerate() {
157        if is_mask_token(m) {
158            let mut matched = None;
159            while raw_idx < raw_chars.len() {
160                let candidate = raw_chars[raw_idx];
161                raw_idx += 1;
162                if matches_mask_token(candidate, m) {
163                    matched = Some(candidate);
164                    break;
165                }
166            }
167            if let Some(ch) = matched {
168                formatted.push(ch);
169                raw_clean.push(ch);
170                filled_tokens += 1;
171            } else {
172                break;
173            }
174        } else {
175            // Fixed literal in mask
176            if raw_idx < raw_chars.len() && raw_chars[raw_idx] == m {
177                raw_idx += 1;
178                formatted.push(m);
179            } else {
180                // Insert literal automatically if there are remaining raw characters that can match
181                // upcoming mask tokens, or if all tokens have already been filled (trailing literal).
182                let next_token = mask_chars[m_idx + 1..]
183                    .iter()
184                    .copied()
185                    .find(|&tk| is_mask_token(tk));
186                let has_upcoming_match = match next_token {
187                    Some(tk) => raw_chars[raw_idx..]
188                        .iter()
189                        .any(|&c| matches_mask_token(c, tk)),
190                    None => filled_tokens == total_tokens && total_tokens > 0,
191                };
192                if has_upcoming_match {
193                    formatted.push(m);
194                } else if next_token.is_some() {
195                    break;
196                }
197            }
198        }
199    }
200
201    let complete = filled_tokens == total_tokens;
202    let valid = complete;
203    let cursor_pos = formatted.chars().count() as i64;
204
205    let mut rec = BTreeMap::new();
206    rec.insert("formatted".to_string(), Value::String(formatted));
207    rec.insert("raw_clean".to_string(), Value::String(raw_clean));
208    rec.insert("cursor_pos".to_string(), Value::I64(cursor_pos));
209    rec.insert("complete".to_string(), Value::Bool(complete));
210    rec.insert("valid".to_string(), Value::Bool(valid));
211    Ok(Value::Record(rec))
212}
213
214/// `selection.set_range(target_id, start, end, direction_opt)`
215pub fn eval_selection_set_range(args: &[Value], span: Span) -> Result<Value, Diagnostic> {
216    let target_id = extract_str(args, 0, "selection.set_range", span)?;
217    let start_raw = extract_i64(args, 1, "selection.set_range", span)?;
218    let end_raw = extract_i64(args, 2, "selection.set_range", span)?;
219    let dir = extract_opt_str(args, 3).unwrap_or_else(|| "none".to_string());
220
221    if !matches!(dir.as_str(), "forward" | "backward" | "none") {
222        return Err(Diagnostic::new(
223            DiagCode::E100,
224            span,
225            format!(
226                "selection.set_range: direction must be 'forward', 'backward', or 'none', got '{dir}'"
227            ),
228        ));
229    }
230
231    let start = start_raw.max(0);
232    let end = end_raw.max(start);
233
234    let mut rec = BTreeMap::new();
235    rec.insert(
236        "op".to_string(),
237        Value::String("selection.set_range".to_string()),
238    );
239    rec.insert("target_id".to_string(), Value::String(target_id));
240    rec.insert("selection_start".to_string(), Value::I64(start));
241    rec.insert("selection_end".to_string(), Value::I64(end));
242    rec.insert("selection_direction".to_string(), Value::String(dir));
243    Ok(Value::Record(rec))
244}
245
246/// `selection.replace_range(text, replacement, start, end, select_mode_opt)`
247pub fn eval_selection_replace_range(args: &[Value], span: Span) -> Result<Value, Diagnostic> {
248    let text = extract_str(args, 0, "selection.replace_range", span)?;
249    let replacement = extract_str(args, 1, "selection.replace_range", span)?;
250    let start_raw = extract_i64(args, 2, "selection.replace_range", span)?;
251    let end_raw = extract_i64(args, 3, "selection.replace_range", span)?;
252    let mode = extract_opt_str(args, 4).unwrap_or_else(|| "preserve".to_string());
253
254    let chars: Vec<char> = text.chars().collect();
255    let len = chars.len() as i64;
256    let start = start_raw.clamp(0, len);
257    let end = end_raw.clamp(start, len);
258    let rep_len = replacement.chars().count() as i64;
259
260    let (sel_start, sel_end) = match mode.as_str() {
261        "select" | "preserve" => (start, start + rep_len),
262        "start" => (start, start),
263        "end" => (start + rep_len, start + rep_len),
264        _ => {
265            return Err(Diagnostic::new(
266                DiagCode::E100,
267                span,
268                format!(
269                    "selection.replace_range: select_mode must be 'select', 'start', 'end', or 'preserve', got '{mode}'"
270                ),
271            ))
272        }
273    };
274
275    let mut new_text = String::with_capacity(text.len() + replacement.len());
276    for &c in &chars[..start as usize] {
277        new_text.push(c);
278    }
279    new_text.push_str(&replacement);
280    for &c in &chars[end as usize..] {
281        new_text.push(c);
282    }
283
284    let mut rec = BTreeMap::new();
285    rec.insert("text".to_string(), Value::String(new_text));
286    rec.insert("selection_start".to_string(), Value::I64(sel_start));
287    rec.insert("selection_end".to_string(), Value::I64(sel_end));
288    rec.insert("select_mode".to_string(), Value::String(mode));
289    Ok(Value::Record(rec))
290}