vize_l3 0.481.0

L3 - the Davinci reactivity IR (codename Impeto): flat scheduled ops with explicit state and effect edges
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

//! Target policy identities for shared L3 analysis.
//!
//! The policy-specific criteria belong here, never in the L4 encoders.
//! This bounded policy filters dynamic attached bindings only. Hoist/cache
//! eligibility and target-specific emission remain unfinished.

/// The canonical op that owns an attached binding.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum BindingOwner {
    /// A native element.
    Element,
    /// A component reference.
    Component,
    /// A slot outlet's props surface.
    Slot,
}

/// The binding distinction needed by the admitted output policy.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum BindingRole {
    /// An event handler.
    Event,
    /// Compile-time cloak marker.
    Cloak,
    /// Every other attached binding, conservatively dynamic.
    Other,
}

/// Target whose eligibility criteria the L3 decision producer must apply.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TargetPolicy {
    /// DOM placement and dynamic-binding eligibility.
    Dom,
    /// Server rendering placement and ordering eligibility.
    Ssr,
    /// Reactive program placement and effect eligibility.
    Vapor,
}

impl TargetPolicy {
    /// Whether an attached binding affects this target's output.
    ///
    /// `v-cloak` is compile-time only. SSR omits native-element events,
    /// while component events and slot props remain dynamic. DOM and Vapor
    /// otherwise retain every binding; this does not claim effect lowering.
    #[must_use]
    pub const fn binding_is_dynamic(self, owner: BindingOwner, role: BindingRole) -> bool {
        !matches!(role, BindingRole::Cloak)
            && !matches!(
                (self, owner, role),
                (Self::Ssr, BindingOwner::Element, BindingRole::Event)
            )
    }
}

/// DOM decision policy namespace.
pub mod dom {
    use super::TargetPolicy;

    /// Select DOM-specific eligibility criteria in the native producer.
    pub const POLICY: TargetPolicy = TargetPolicy::Dom;
}

/// Server rendering decision policy namespace.
pub mod ssr {
    use super::TargetPolicy;

    /// Select server rendering criteria in the native producer.
    pub const POLICY: TargetPolicy = TargetPolicy::Ssr;
}

/// Reactive program decision policy namespace.
pub mod vapor {
    use super::TargetPolicy;

    /// Select reactive program criteria in the native producer.
    pub const POLICY: TargetPolicy = TargetPolicy::Vapor;
}

#[cfg(test)]
mod tests {
    use super::{BindingOwner, BindingRole, TargetPolicy};

    #[test]
    fn cloak_is_compile_time_for_every_owner_and_target() {
        for policy in [TargetPolicy::Dom, TargetPolicy::Ssr, TargetPolicy::Vapor] {
            for owner in [
                BindingOwner::Element,
                BindingOwner::Component,
                BindingOwner::Slot,
            ] {
                assert!(!policy.binding_is_dynamic(owner, BindingRole::Cloak));
                assert!(policy.binding_is_dynamic(owner, BindingRole::Other));
            }
        }
    }

    #[test]
    fn only_ssr_native_element_events_are_omitted() {
        for policy in [TargetPolicy::Dom, TargetPolicy::Ssr, TargetPolicy::Vapor] {
            for owner in [
                BindingOwner::Element,
                BindingOwner::Component,
                BindingOwner::Slot,
            ] {
                assert_eq!(
                    policy.binding_is_dynamic(owner, BindingRole::Event),
                    !(policy == TargetPolicy::Ssr && owner == BindingOwner::Element),
                );
            }
        }
    }
}