rari 0.13.6

rari: Runtime Accelerated Rendering Infrastructure - A high-performance React Server Components framework powered by Rust
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

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct JsReloadResult {
    pub success: bool,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub specifier: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timestamp: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stack: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct JsModuleCacheInfo {
    pub found: bool,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub component_id: Option<String>,
    pub specifier: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stack: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct JsComponentVerification {
    pub success: bool,
    pub component_id: String,
    pub exists: bool,
    pub is_function: bool,
    pub is_valid_component: bool,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub component_name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub component_type: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stack: Option<String>,
    pub timestamp: f64,
}

impl JsReloadResult {
    pub fn success(specifier: String) -> Self {
        Self {
            success: true,
            specifier: Some(specifier),
            timestamp: Some(
                std::time::SystemTime::now()
                    .duration_since(std::time::UNIX_EPOCH)
                    .unwrap_or_default()
                    .as_secs_f64(),
            ),
            error: None,
            stack: None,
            name: None,
        }
    }

    pub fn failure(error: String) -> Self {
        Self {
            success: false,
            specifier: None,
            timestamp: Some(
                std::time::SystemTime::now()
                    .duration_since(std::time::UNIX_EPOCH)
                    .unwrap_or_default()
                    .as_secs_f64(),
            ),
            error: Some(error),
            stack: None,
            name: Some("ReloadError".to_string()),
        }
    }
}

impl JsModuleCacheInfo {
    pub fn found(component_id: String, specifier: String) -> Self {
        Self { found: true, component_id: Some(component_id), specifier, error: None, stack: None }
    }

    pub fn not_found(specifier: String) -> Self {
        Self { found: false, component_id: None, specifier, error: None, stack: None }
    }
}

impl JsComponentVerification {
    pub fn success(component_id: String) -> Self {
        Self {
            success: true,
            component_id,
            exists: true,
            is_function: true,
            is_valid_component: true,
            component_name: None,
            component_type: None,
            error: None,
            stack: None,
            timestamp: std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap_or_default()
                .as_secs_f64(),
        }
    }

    pub fn failure(component_id: String, error: String) -> Self {
        Self {
            success: false,
            component_id,
            exists: false,
            is_function: false,
            is_valid_component: false,
            component_name: None,
            component_type: None,
            error: Some(error),
            stack: None,
            timestamp: std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap_or_default()
                .as_secs_f64(),
        }
    }
}