presolve-compiler 0.1.0-alpha.1

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
133
134
135
136
137
138
139
140

use serde::{Deserialize, Serialize};

use crate::{
    ContextValueSlotId, ContextValueSourceId, ExecutionBoundary, RuntimeContextRegistry,
    RuntimeContextSourceKind, SourceProvenance,
};

/// Stable serialized-state identity distinct from the live runtime slot.
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
#[serde(transparent)]
pub struct ContextResumeSlotId(String);

impl ContextResumeSlotId {
    #[must_use]
    pub fn for_source(source: &ContextValueSourceId) -> Self {
        let source = match source {
            ContextValueSourceId::Provider(provider) => provider.as_str().to_string(),
            ContextValueSourceId::ContextDefault(context) => {
                format!("{}/default", context.as_str())
            }
        };
        Self(format!("{source}/resume:context-slot"))
    }

    #[must_use]
    pub fn as_str(&self) -> &str {
        &self.0
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ContextSlotResumeStatus {
    Uninitialized,
    Initialized,
    Failed,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ContextResumeRecord {
    pub source: ContextValueSourceId,
    pub context: crate::ContextId,
    pub runtime_slot: ContextValueSlotId,
    pub resume_slot: ContextResumeSlotId,
    pub semantic_type: crate::SemanticTypeId,
    pub source_kind: RuntimeContextSourceKind,
    pub initial_status: ContextSlotResumeStatus,
    pub action_batches: Vec<crate::SemanticId>,
    pub consumers: Vec<crate::ConsumerId>,
    pub boundary: ExecutionBoundary,
    pub provenance: SourceProvenance,
}

#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub struct ContextResumePlan {
    pub records: Vec<ContextResumeRecord>,
}

#[must_use]
pub fn build_context_resume_plan(
    registry: &RuntimeContextRegistry,
    updates: &crate::ContextUpdatePlan,
) -> ContextResumePlan {
    ContextResumePlan {
        records: registry
            .sources
            .iter()
            .map(|source| ContextResumeRecord {
                source: source.source.clone(),
                context: source.context.clone(),
                runtime_slot: source.slot.clone(),
                resume_slot: ContextResumeSlotId::for_source(&source.source),
                semantic_type: source.semantic_type.clone(),
                source_kind: source.source_kind,
                initial_status: ContextSlotResumeStatus::Uninitialized,
                action_batches: updates
                    .actions
                    .iter()
                    .filter(|action| action.invalidated_sources.contains(&source.source))
                    .map(|action| action.action_batch.clone())
                    .collect(),
                consumers: registry
                    .consumers
                    .iter()
                    .filter(|consumer| consumer.selected_source == source.source)
                    .map(|consumer| consumer.consumer.clone())
                    .collect(),
                boundary: source.boundary,
                provenance: source.provenance.clone(),
            })
            .collect(),
    }
}

#[cfg(test)]
mod tests {
    use crate::{
        build_application_semantic_model, build_resume_manifest, build_resume_plan,
        ContextSlotResumeStatus,
    };

    #[test]
    fn plans_distinct_uninitialized_resume_slots_for_runtime_context_sources() {
        let model = build_application_semantic_model(&presolve_parser::parse_file(
            "src/App.tsx",
            r#"
@component("x-app")
class App extends Component {
  @context() locale: string = "en";
  @consume(App.locale) locale!: string;
  render() { return <main />; }
}
"#,
        ));
        let plan = build_resume_plan(&model);
        let record = plan
            .contexts
            .records
            .first()
            .expect("Context resume record");
        assert_eq!(
            record.initial_status,
            ContextSlotResumeStatus::Uninitialized
        );
        assert_ne!(record.resume_slot.as_str(), record.runtime_slot.as_str());
        let manifest = build_resume_manifest(&model);
        assert_eq!(manifest.schema_version, 6);
        assert_eq!(
            manifest
                .phase_i_component_resume_records
                .iter()
                .filter(|record| matches!(
                    record,
                    crate::ResumeManifestPhaseIComponentResumeRecord::ContextSlot { .. }
                ))
                .count(),
            1
        );
    }
}