Skip to main content

vibe/web_runtime/input_format/
mod.rs

1//! Input formatting, stepping, masking, typed parsing, and text selection primitives
2//! (`input.*` and `selection.*` stdlib bindings for VibeScript v0.02 Zero-JS UI).
3
4pub mod mask_and_step;
5pub mod typed_parsers;
6
7use crate::error::{DiagCode, Diagnostic};
8use crate::span::Span;
9use crate::value::Value;
10
11/// Dispatch an `input.*` or `selection.*` call in the VibeScript engine.
12pub fn call_input_format(
13    path: &str,
14    args: &[Value],
15    span: Span,
16) -> Result<Option<Value>, Diagnostic> {
17    match path {
18        "input.step" => mask_and_step::eval_input_step(args, span).map(Some),
19        "input.apply_mask" => mask_and_step::eval_apply_mask(args, span).map(Some),
20        "selection.set_range" => mask_and_step::eval_selection_set_range(args, span).map(Some),
21        "selection.replace_range" => {
22            mask_and_step::eval_selection_replace_range(args, span).map(Some)
23        }
24        "input.parse_quantity" => typed_parsers::eval_parse_quantity(args, span).map(Some),
25        "input.parse_currency" => typed_parsers::eval_parse_currency(args, span).map(Some),
26        "input.parse_uncertainty" => typed_parsers::eval_parse_uncertainty(args, span).map(Some),
27        "input.parse_coordinate" => typed_parsers::eval_parse_coordinate(args, span).map(Some),
28        "input.parse_instant" => typed_parsers::eval_parse_instant(args, span).map(Some),
29        "input.parse_duration" => typed_parsers::eval_parse_duration(args, span).map(Some),
30        _ => Ok(None),
31    }
32}
33
34pub(crate) fn extract_str(
35    args: &[Value],
36    idx: usize,
37    ctx: &str,
38    span: Span,
39) -> Result<String, Diagnostic> {
40    match args.get(idx) {
41        Some(Value::String(s)) | Some(Value::Iri(s)) => Ok(s.clone()),
42        _ => Err(Diagnostic::new(
43            DiagCode::E100,
44            span,
45            format!("{ctx}: argument #{idx} must be a string"),
46        )),
47    }
48}
49
50pub(crate) fn extract_opt_str(args: &[Value], idx: usize) -> Option<String> {
51    match args.get(idx) {
52        Some(Value::String(s)) | Some(Value::Iri(s)) if !s.is_empty() => Some(s.clone()),
53        _ => None,
54    }
55}
56
57pub(crate) fn extract_i64(
58    args: &[Value],
59    idx: usize,
60    ctx: &str,
61    span: Span,
62) -> Result<i64, Diagnostic> {
63    match args.get(idx) {
64        Some(Value::I64(n)) => Ok(*n),
65        Some(Value::U64(n)) => Ok(*n as i64),
66        Some(Value::F64(n)) => Ok(*n as i64),
67        _ => Err(Diagnostic::new(
68            DiagCode::E100,
69            span,
70            format!("{ctx}: argument #{idx} must be an integer"),
71        )),
72    }
73}
74
75pub(crate) fn extract_f64(
76    args: &[Value],
77    idx: usize,
78    ctx: &str,
79    span: Span,
80) -> Result<f64, Diagnostic> {
81    match args.get(idx).and_then(Value::as_f64) {
82        Some(n) => Ok(n),
83        None => Err(Diagnostic::new(
84            DiagCode::E100,
85            span,
86            format!("{ctx}: argument #{idx} must be a number"),
87        )),
88    }
89}