presolve-compiler 0.1.0-alpha.5

The Presolve compiler toolchain for TypeScript web applications.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

//! I11 immutable declaration-level Form reset programs.

use std::collections::BTreeMap;

use crate::{
    FieldBindingId, FieldId, FieldResetOperationId, FormEntity, FormFieldBinding, FormFieldEntity,
    FormId, FormTrackingProducts, ResetPlanId, SerializableValue, SourceProvenance,
};

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum FieldResetStep {
    RestoreInitialValue,
    WriteBoundControls,
    ClearDirty,
    ClearTouched,
    ClearValidation,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct FieldResetOperation {
    pub id: FieldResetOperationId,
    pub field: FieldId,
    pub initial_value: SerializableValue,
    pub declaration_order: usize,
    pub bound_controls: Vec<FieldBindingId>,
    pub steps: Vec<FieldResetStep>,
    pub provenance: SourceProvenance,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct FormResetPlan {
    pub id: ResetPlanId,
    pub form: FormId,
    pub operations: Vec<FieldResetOperation>,
    pub clear_aggregate_validity: bool,
    pub clear_submission_state: bool,
    pub schedule_validation: bool,
}

#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub struct ResetProducts {
    pub plans: BTreeMap<ResetPlanId, FormResetPlan>,
}

#[must_use]
/// # Panics
///
/// Panics when a valid I3 Field does not have both mandatory I8 tracking
/// records. That is a violated staged-product invariant.
pub fn collect_reset_products(
    forms: &BTreeMap<FormId, FormEntity>,
    fields: &BTreeMap<FieldId, FormFieldEntity>,
    bindings: &BTreeMap<FieldBindingId, FormFieldBinding>,
    tracking: &FormTrackingProducts,
) -> ResetProducts {
    let mut plans = BTreeMap::new();
    for form in forms.values() {
        let id = ResetPlanId::for_form(&form.id);
        let mut form_fields = fields
            .values()
            .filter(|field| field.owner_form == form.id)
            .collect::<Vec<_>>();
        form_fields.sort_by(|left, right| {
            (left.declaration_order, &left.id).cmp(&(right.declaration_order, &right.id))
        });
        let operations = form_fields
            .into_iter()
            .map(|field| {
                let mut bound_controls = bindings
                    .values()
                    .filter(|binding| binding.field == field.id)
                    .collect::<Vec<_>>();
                bound_controls.sort_by(|left, right| {
                    (left.authored_order, &left.id).cmp(&(right.authored_order, &right.id))
                });
                assert!(
                    tracking.dirty.tracking(&field.id).is_some()
                        && tracking.touched.tracking(&field.id).is_some(),
                    "I11 requires exact I8 tracking records"
                );
                FieldResetOperation {
                    id: FieldResetOperationId::for_plan_and_field(&id, &field.id),
                    field: field.id.clone(),
                    initial_value: field.initial_value.clone(),
                    declaration_order: field.declaration_order,
                    bound_controls: bound_controls
                        .into_iter()
                        .map(|binding| binding.id.clone())
                        .collect(),
                    steps: vec![
                        FieldResetStep::RestoreInitialValue,
                        FieldResetStep::WriteBoundControls,
                        FieldResetStep::ClearDirty,
                        FieldResetStep::ClearTouched,
                        FieldResetStep::ClearValidation,
                    ],
                    provenance: field.provenance.clone(),
                }
            })
            .collect();
        plans.insert(
            id.clone(),
            FormResetPlan {
                id,
                form: form.id.clone(),
                operations,
                clear_aggregate_validity: true,
                clear_submission_state: true,
                schedule_validation: false,
            },
        );
    }
    ResetProducts { plans }
}

#[cfg(test)]
mod tests {
    #[test]
    fn creates_ordered_non_revalidating_reset_operations() {
        let parsed = presolve_parser::parse_file(
            "src/Form.tsx",
            r#"@component("x") class X { @form() form!: Form; @field(this.form) first = "a"; @field(this.form) second = false; render() { return <input field={this.first} />; } }"#,
        );
        let model = crate::build_application_semantic_model(&parsed);
        let form = crate::FormId::for_owner(&model.components[0].id, "form");
        let plan = &model.reset.plans[&crate::ResetPlanId::for_form(&form)];
        assert!(!plan.schedule_validation);
        assert_eq!(plan.operations.len(), 2);
        assert_eq!(plan.operations[0].bound_controls.len(), 1);
        assert!(plan.operations[1].bound_controls.is_empty());
    }
}