vize_atelier_core 0.232.0

Atelier Core - The core workshop for Vize Vue template parsing, transform lanes, and code generation
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
141
142
143
144
145
146

//! Runtime helper registration and lookup.

use crate::RuntimeHelper;
use vize_carton::FxHashMap;

/// Runtime helper set for tracking used helpers
#[derive(Debug, Default)]
pub struct RuntimeHelpers {
    helpers: FxHashMap<RuntimeHelper, u32>,
    order: std::vec::Vec<RuntimeHelper>,
}

impl RuntimeHelpers {
    pub fn new() -> Self {
        Self::default()
    }

    /// Register a helper usage
    pub fn add(&mut self, helper: RuntimeHelper) {
        if !self.helpers.contains_key(&helper) {
            self.order.push(helper);
        }
        *self.helpers.entry(helper).or_insert(0) += 1;
    }

    /// Remove a helper usage
    pub fn remove(&mut self, helper: RuntimeHelper) {
        if let Some(count) = self.helpers.get_mut(&helper) {
            *count = count.saturating_sub(1);
            if *count == 0 {
                self.helpers.remove(&helper);
                self.order.retain(|ordered| *ordered != helper);
            }
        }
    }

    /// Check if a helper is used
    pub fn contains(&self, helper: RuntimeHelper) -> bool {
        self.helpers.contains_key(&helper)
    }

    /// Get all used helpers
    pub fn iter(&self) -> impl Iterator<Item = RuntimeHelper> + '_ {
        self.order
            .iter()
            .copied()
            .filter(|helper| self.helpers.contains_key(helper))
    }

    /// Get the count of a helper usage
    pub fn count(&self, helper: RuntimeHelper) -> u32 {
        self.helpers.get(&helper).copied().unwrap_or(0)
    }

    /// Clear all helpers
    pub fn clear(&mut self) {
        self.helpers.clear();
        self.order.clear();
    }
}

/// Get the helper for creating VNodes
pub fn get_vnode_helper(ssr: bool, is_component: bool) -> RuntimeHelper {
    if ssr || is_component {
        RuntimeHelper::CreateVNode
    } else {
        RuntimeHelper::CreateElementVNode
    }
}

/// Get the helper for creating block VNodes
pub fn get_vnode_block_helper(ssr: bool, is_component: bool) -> RuntimeHelper {
    if ssr || is_component {
        RuntimeHelper::CreateBlock
    } else {
        RuntimeHelper::CreateElementBlock
    }
}

#[cfg(test)]
mod tests {
    use super::{RuntimeHelper, RuntimeHelpers};

    #[test]
    fn test_helpers() {
        let mut helpers = RuntimeHelpers::new();

        helpers.add(RuntimeHelper::CreateVNode);
        assert!(helpers.contains(RuntimeHelper::CreateVNode));
        assert_eq!(helpers.count(RuntimeHelper::CreateVNode), 1);

        helpers.add(RuntimeHelper::CreateVNode);
        assert_eq!(helpers.count(RuntimeHelper::CreateVNode), 2);

        helpers.remove(RuntimeHelper::CreateVNode);
        assert_eq!(helpers.count(RuntimeHelper::CreateVNode), 1);

        helpers.remove(RuntimeHelper::CreateVNode);
        assert!(!helpers.contains(RuntimeHelper::CreateVNode));
    }

    #[test]
    fn test_helpers_preserve_insertion_order() {
        let mut helpers = RuntimeHelpers::new();

        helpers.add(RuntimeHelper::ToDisplayString);
        helpers.add(RuntimeHelper::CreateElementVNode);
        helpers.add(RuntimeHelper::OpenBlock);
        helpers.add(RuntimeHelper::CreateElementVNode);

        assert_eq!(
            helpers.iter().collect::<Vec<_>>(),
            [
                RuntimeHelper::ToDisplayString,
                RuntimeHelper::CreateElementVNode,
                RuntimeHelper::OpenBlock,
            ]
        );

        helpers.remove(RuntimeHelper::CreateElementVNode);
        assert_eq!(
            helpers.iter().collect::<Vec<_>>(),
            [
                RuntimeHelper::ToDisplayString,
                RuntimeHelper::CreateElementVNode,
                RuntimeHelper::OpenBlock,
            ]
        );

        helpers.remove(RuntimeHelper::CreateElementVNode);
        assert_eq!(
            helpers.iter().collect::<Vec<_>>(),
            [RuntimeHelper::ToDisplayString, RuntimeHelper::OpenBlock]
        );

        helpers.add(RuntimeHelper::CreateElementVNode);
        assert_eq!(
            helpers.iter().collect::<Vec<_>>(),
            [
                RuntimeHelper::ToDisplayString,
                RuntimeHelper::OpenBlock,
                RuntimeHelper::CreateElementVNode,
            ]
        );
    }
}