vibe/web_runtime/form_state/
lifecycle.rs1use 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
13pub(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}