vibe/web_runtime/input_format/
mask_and_step.rs1use 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
12pub 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
142pub 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 if raw_idx < raw_chars.len() && raw_chars[raw_idx] == m {
177 raw_idx += 1;
178 formatted.push(m);
179 } else {
180 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
214pub 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
246pub 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}