Skip to main content

vibe/web_runtime/form_state/
history_crdt.rs

1//! Form Transactional Undo/Redo Stack, Named Checkpoints, and Lamport LWW CRDT Merge (`form.*`).
2
3use std::collections::{BTreeMap, BTreeSet};
4
5use crate::error::Diagnostic;
6use crate::span::Span;
7use crate::value::Value;
8
9use super::{extract_record, extract_str, get_sub_list, get_sub_record, push_bounded};
10
11/// Handle undo/redo, checkpointing, and CRDT merge operations.
12pub(crate) fn call_history_crdt(
13    path: &str,
14    args: &[Value],
15    span: Span,
16) -> Result<Option<Value>, Diagnostic> {
17    match path {
18        "form.checkpoint" => {
19            let mut form = extract_record(args, 0, "form.checkpoint(form, label)", span)?;
20            let label = extract_str(args, 1, "form.checkpoint(form, label)", span)?;
21            let values = get_sub_record(&form, "values");
22            let mut checkpoints = get_sub_record(&form, "checkpoints");
23            checkpoints.insert(label, Value::Record(values));
24            form.insert("checkpoints".to_string(), Value::Record(checkpoints));
25            Ok(Some(Value::Record(form)))
26        }
27        "form.undo" => {
28            let mut form = extract_record(args, 0, "form.undo(form)", span)?;
29            let mut history = get_sub_list(&form, "history");
30            if let Some(prev) = history.pop() {
31                let cur_values = get_sub_record(&form, "values");
32                let mut redo = get_sub_list(&form, "redo_stack");
33                push_bounded(&mut redo, Value::Record(cur_values));
34                form.insert("values".to_string(), prev);
35                form.insert("history".to_string(), Value::List(history));
36                form.insert("redo_stack".to_string(), Value::List(redo));
37            }
38            Ok(Some(Value::Record(form)))
39        }
40        "form.redo" => {
41            let mut form = extract_record(args, 0, "form.redo(form)", span)?;
42            let mut redo = get_sub_list(&form, "redo_stack");
43            if let Some(next) = redo.pop() {
44                let cur_values = get_sub_record(&form, "values");
45                let mut history = get_sub_list(&form, "history");
46                push_bounded(&mut history, Value::Record(cur_values));
47                form.insert("values".to_string(), next);
48                form.insert("history".to_string(), Value::List(history));
49                form.insert("redo_stack".to_string(), Value::List(redo));
50            }
51            Ok(Some(Value::Record(form)))
52        }
53        "form.can_undo" => {
54            let form = extract_record(args, 0, "form.can_undo(form)", span)?;
55            let history = get_sub_list(&form, "history");
56            Ok(Some(Value::Bool(!history.is_empty())))
57        }
58        "form.can_redo" => {
59            let form = extract_record(args, 0, "form.can_redo(form)", span)?;
60            let redo = get_sub_list(&form, "redo_stack");
61            Ok(Some(Value::Bool(!redo.is_empty())))
62        }
63        "form.rollback_to" => {
64            let mut form = extract_record(args, 0, "form.rollback_to(form, label)", span)?;
65            let label = extract_str(args, 1, "form.rollback_to(form, label)", span)?;
66            let checkpoints = get_sub_record(&form, "checkpoints");
67            if let Some(Value::Record(cp_vals)) = checkpoints.get(&label) {
68                let cur_values = get_sub_record(&form, "values");
69                let mut history = get_sub_list(&form, "history");
70                push_bounded(&mut history, Value::Record(cur_values));
71                form.insert("values".to_string(), Value::Record(cp_vals.clone()));
72                form.insert("history".to_string(), Value::List(history));
73                form.insert("redo_stack".to_string(), Value::List(Vec::new()));
74            }
75            Ok(Some(Value::Record(form)))
76        }
77        "form.crdt_merge" => {
78            let mut local_form =
79                extract_record(args, 0, "form.crdt_merge(local_form, remote_form)", span)?;
80            let remote_form =
81                extract_record(args, 1, "form.crdt_merge(local_form, remote_form)", span)?;
82
83            let l_vals = get_sub_record(&local_form, "values");
84            let r_vals = get_sub_record(&remote_form, "values");
85            let l_clks = get_sub_record(&local_form, "clocks");
86            let r_clks = get_sub_record(&remote_form, "clocks");
87
88            let all_keys: BTreeSet<&String> = l_vals.keys().chain(r_vals.keys()).collect();
89            let mut merged_vals = BTreeMap::new();
90            let mut merged_clks = BTreeMap::new();
91
92            for k in all_keys {
93                let l_clk = l_clks.get(k).and_then(Value::as_i64).unwrap_or(0);
94                let r_clk = r_clks.get(k).and_then(Value::as_i64).unwrap_or(0);
95                match (l_vals.get(k), r_vals.get(k)) {
96                    (Some(lv), Some(rv)) => {
97                        let remote_wins = if r_clk != l_clk {
98                            r_clk > l_clk
99                        } else {
100                            format!("{rv}") > format!("{lv}")
101                        };
102                        if remote_wins {
103                            merged_vals.insert(k.clone(), rv.clone());
104                            merged_clks.insert(k.clone(), Value::I64(r_clk));
105                        } else {
106                            merged_vals.insert(k.clone(), lv.clone());
107                            merged_clks.insert(k.clone(), Value::I64(l_clk));
108                        }
109                    }
110                    (None, Some(rv)) => {
111                        merged_vals.insert(k.clone(), rv.clone());
112                        merged_clks.insert(k.clone(), Value::I64(r_clk.max(1)));
113                    }
114                    (Some(lv), None) => {
115                        merged_vals.insert(k.clone(), lv.clone());
116                        merged_clks.insert(k.clone(), Value::I64(l_clk.max(1)));
117                    }
118                    (None, None) => {}
119                }
120            }
121
122            local_form.insert("values".to_string(), Value::Record(merged_vals));
123            local_form.insert("clocks".to_string(), Value::Record(merged_clks));
124            Ok(Some(Value::Record(local_form)))
125        }
126        _ => Ok(None),
127    }
128}