Skip to main content

vibe/web_runtime/form_state/
lifecycle.rs

1//! Form State Lifecycle, Dirty Tracking, Diffing, Reset, and Submission (`form.*`).
2
3use std::collections::{BTreeMap, BTreeSet};
4
5use crate::error::{DiagCode, Diagnostic};
6use crate::span::Span;
7use crate::value::Value;
8
9use super::{
10    extract_record, extract_schema_base, extract_str, get_sub_list, get_sub_record, push_bounded,
11};
12
13/// Handle form lifecycle operations.
14pub(crate) fn call_lifecycle(
15    path: &str,
16    args: &[Value],
17    span: Span,
18) -> Result<Option<Value>, Diagnostic> {
19    match path {
20        "form.create" => {
21            let form_id =
22                extract_str(args, 0, "form.create(form_id, schema_iri, initial_fields)", span)?;
23            let schema_iri =
24                extract_str(args, 1, "form.create(form_id, schema_iri, initial_fields)", span)?;
25            let initial_fields =
26                extract_record(args, 2, "form.create(form_id, schema_iri, initial_fields)", span)?;
27
28            Ok(Some(build_form_record(form_id, schema_iri, initial_fields)))
29        }
30        "form.get_value" => {
31            let form = extract_record(args, 0, "form.get_value(form, field_id)", span)?;
32            let field_id = extract_str(args, 1, "form.get_value(form, field_id)", span)?;
33            let values = get_sub_record(&form, "values");
34            let schema_base = extract_schema_base(&form);
35            let scoped_key = format!("{schema_base}{field_id}");
36            let val = values
37                .get(&field_id)
38                .or_else(|| values.get(&scoped_key))
39                .or_else(|| form.get(&field_id))
40                .cloned()
41                .unwrap_or(Value::Null);
42            Ok(Some(val))
43        }
44        "form.set_value" => {
45            let mut form =
46                extract_record(args, 0, "form.set_value(form, field_id, new_value)", span)?;
47            let field_id =
48                extract_str(args, 1, "form.set_value(form, field_id, new_value)", span)?;
49            let new_value = args.get(2).cloned().ok_or_else(|| {
50                Diagnostic::new(
51                    DiagCode::E100,
52                    span,
53                    "form.set_value(form, field_id, new_value): missing new_value",
54                )
55            })?;
56
57            let mut values = get_sub_record(&form, "values");
58            let mut history = get_sub_list(&form, "history");
59            push_bounded(&mut history, Value::Record(values.clone()));
60
61            values.insert(field_id.clone(), new_value);
62
63            let mut clocks = get_sub_record(&form, "clocks");
64            let next_clk = clocks
65                .get(&field_id)
66                .and_then(Value::as_i64)
67                .unwrap_or(0)
68                .saturating_add(1);
69            clocks.insert(field_id, Value::I64(next_clk));
70
71            form.insert("values".to_string(), Value::Record(values));
72            form.insert("clocks".to_string(), Value::Record(clocks));
73            form.insert("history".to_string(), Value::List(history));
74            form.insert("redo_stack".to_string(), Value::List(Vec::new()));
75            Ok(Some(Value::Record(form)))
76        }
77        "form.get_group_value" => {
78            let form = extract_record(args, 0, "form.get_group_value(form, group_name)", span)?;
79            let group_name = extract_str(args, 1, "form.get_group_value(form, group_name)", span)?;
80            let values = get_sub_record(&form, "values");
81
82            if let Some(direct) = values.get(&group_name) {
83                match direct {
84                    Value::Record(sub) => {
85                        if sub.get("checked") == Some(&Value::Bool(true)) {
86                            return Ok(Some(
87                                sub.get("value").cloned().unwrap_or(Value::Bool(true)),
88                            ));
89                        }
90                    }
91                    Value::List(items) => {
92                        for item in items {
93                            if let Value::Record(sub) = item {
94                                if sub.get("checked") == Some(&Value::Bool(true)) {
95                                    return Ok(Some(
96                                        sub.get("value").cloned().unwrap_or(Value::Bool(true)),
97                                    ));
98                                }
99                            }
100                        }
101                        return Ok(Some(Value::Null));
102                    }
103                    other => return Ok(Some(other.clone())),
104                }
105            }
106
107            for (key, val) in &values {
108                if let Value::Record(sub) = val {
109                    let group_matches = sub
110                        .get("group")
111                        .or_else(|| sub.get("name"))
112                        .and_then(|v| match v {
113                            Value::String(s) => Some(s.as_str() == group_name),
114                            _ => None,
115                        })
116                        .unwrap_or(false);
117                    let checked = sub.get("checked") == Some(&Value::Bool(true));
118                    if group_matches && checked {
119                        let out = sub
120                            .get("value")
121                            .cloned()
122                            .unwrap_or_else(|| Value::String(key.clone()));
123                        return Ok(Some(out));
124                    }
125                }
126            }
127            Ok(Some(Value::Null))
128        }
129        "form.reset" => {
130            let mut form = extract_record(args, 0, "form.reset(form)", span)?;
131            let values = get_sub_record(&form, "values");
132            let defaults = get_sub_record(&form, "default_values");
133
134            let all_keys: BTreeSet<&String> = values.keys().chain(defaults.keys()).collect();
135            let mut patches = Vec::new();
136            for k in all_keys {
137                let cur = values.get(k);
138                let def = defaults.get(k);
139                if cur != def {
140                    let mut patch = BTreeMap::new();
141                    patch.insert("op".to_string(), Value::String("ui.patch".to_string()));
142                    patch.insert("target_id".to_string(), Value::String(k.clone()));
143                    patch.insert("property".to_string(), Value::String("value".to_string()));
144                    patch.insert("value".to_string(), def.cloned().unwrap_or(Value::Null));
145                    patches.push(Value::Record(patch));
146                }
147            }
148
149            form.insert("values".to_string(), Value::Record(defaults));
150            form.insert("redo_stack".to_string(), Value::List(Vec::new()));
151            form.insert("patches".to_string(), Value::List(patches));
152            Ok(Some(Value::Record(form)))
153        }
154        "form.is_dirty" => {
155            let form = extract_record(args, 0, "form.is_dirty(form)", span)?;
156            let values = get_sub_record(&form, "values");
157            let defaults = get_sub_record(&form, "default_values");
158            Ok(Some(Value::Bool(values != defaults)))
159        }
160        "form.field_is_dirty" => {
161            let form = extract_record(args, 0, "form.field_is_dirty(form, field_id)", span)?;
162            let field_id = extract_str(args, 1, "form.field_is_dirty(form, field_id)", span)?;
163            let values = get_sub_record(&form, "values");
164            let defaults = get_sub_record(&form, "default_values");
165            Ok(Some(Value::Bool(
166                values.get(&field_id) != defaults.get(&field_id),
167            )))
168        }
169        "form.diff" => {
170            let form = extract_record(args, 0, "form.diff(form)", span)?;
171            let values = get_sub_record(&form, "values");
172            let defaults = get_sub_record(&form, "default_values");
173            let all_keys: BTreeSet<&String> = values.keys().chain(defaults.keys()).collect();
174
175            let mut diff = BTreeMap::new();
176            for k in all_keys {
177                let cur = values.get(k);
178                let def = defaults.get(k);
179                if cur != def {
180                    let mut entry = BTreeMap::new();
181                    entry.insert("initial".to_string(), def.cloned().unwrap_or(Value::Null));
182                    entry.insert("current".to_string(), cur.cloned().unwrap_or(Value::Null));
183                    diff.insert(k.clone(), Value::Record(entry));
184                }
185            }
186            Ok(Some(Value::Record(diff)))
187        }
188        "form.commit_defaults" => {
189            let mut form = extract_record(args, 0, "form.commit_defaults(form)", span)?;
190            let values = get_sub_record(&form, "values");
191            form.insert("default_values".to_string(), Value::Record(values));
192            Ok(Some(Value::Record(form)))
193        }
194        "form.request_submit" => {
195            let form = extract_record(args, 0, "form.request_submit(form, submitter_id)", span)?;
196            let submitter_id = args
197                .get(1)
198                .and_then(|v| match v {
199                    Value::String(s) | Value::Iri(s) => Some(s.clone()),
200                    _ => None,
201                })
202                .unwrap_or_else(|| "default".to_string());
203
204            let form_id = form
205                .get("form_id")
206                .cloned()
207                .unwrap_or_else(|| Value::String(String::new()));
208            let values = get_sub_record(&form, "values");
209            let defaults = get_sub_record(&form, "default_values");
210            let dirty = values != defaults;
211            let field_count = values.len() as i64;
212
213            let mut env = BTreeMap::new();
214            env.insert("submitted".to_string(), Value::Bool(true));
215            env.insert("form_id".to_string(), form_id);
216            env.insert("submitter_id".to_string(), Value::String(submitter_id));
217            env.insert("values".to_string(), Value::Record(values));
218            env.insert("dirty".to_string(), Value::Bool(dirty));
219            env.insert("field_count".to_string(), Value::I64(field_count));
220            Ok(Some(Value::Record(env)))
221        }
222        _ => Ok(None),
223    }
224}
225
226pub(crate) fn build_form_record(
227    form_id: String,
228    schema_iri: String,
229    initial_fields: BTreeMap<String, Value>,
230) -> Value {
231    let mut clocks = BTreeMap::new();
232    for k in initial_fields.keys() {
233        clocks.insert(k.clone(), Value::I64(1));
234    }
235
236    let mut form = BTreeMap::new();
237    form.insert("form_id".to_string(), Value::String(form_id));
238    form.insert("schema_iri".to_string(), Value::Iri(schema_iri));
239    form.insert(
240        "default_values".to_string(),
241        Value::Record(initial_fields.clone()),
242    );
243    form.insert("values".to_string(), Value::Record(initial_fields));
244    form.insert("clocks".to_string(), Value::Record(clocks));
245    form.insert("history".to_string(), Value::List(Vec::new()));
246    form.insert("redo_stack".to_string(), Value::List(Vec::new()));
247    form.insert("checkpoints".to_string(), Value::Record(BTreeMap::new()));
248    form.insert("step_index".to_string(), Value::I64(0));
249    Value::Record(form)
250}