routa-core 0.18.0

Routa.js core domain — models, stores, protocols, and JSON-RPC (transport-agnostic)
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

use serde::Deserialize;
use std::sync::OnceLock;

#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CanvasGenerationPromptContract {
    pub artifact_description: String,
    pub require_source_only: bool,
    pub allow_markdown_code_fences: bool,
    pub allow_prose: bool,
}

#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CanvasGenerationOutputContract {
    pub default_export_forms: Vec<String>,
    pub json_source_keys: Vec<String>,
}

#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CanvasGenerationImportContract {
    pub allowed_modules: Vec<String>,
    pub normalized_prefixes: Vec<String>,
}

#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CanvasGenerationRuntimeContract {
    pub forbidden_globals: Vec<String>,
}

#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CanvasGenerationLayoutContract {
    pub forbidden_shell_chrome: Vec<String>,
}

#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CanvasGenerationStyleContract {
    pub principles: Vec<String>,
    pub forbidden_patterns: Vec<String>,
}

#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CanvasGenerationStorageContract {
    pub project_canvas_root: String,
}

#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CanvasGenerationContract {
    pub schema_version: u32,
    pub prompt: CanvasGenerationPromptContract,
    pub output: CanvasGenerationOutputContract,
    pub imports: CanvasGenerationImportContract,
    pub runtime: CanvasGenerationRuntimeContract,
    pub layout: CanvasGenerationLayoutContract,
    pub style: CanvasGenerationStyleContract,
    pub storage: CanvasGenerationStorageContract,
}

const CANVAS_GENERATION_CONTRACT_JSON: &str = include_str!(concat!(
    env!("CARGO_MANIFEST_DIR"),
    "/../../resources/canvas/canvas-generation-contract.json"
));

static CANVAS_GENERATION_CONTRACT: OnceLock<CanvasGenerationContract> = OnceLock::new();

pub fn get_canvas_generation_contract() -> &'static CanvasGenerationContract {
    CANVAS_GENERATION_CONTRACT.get_or_init(|| {
        serde_json::from_str(CANVAS_GENERATION_CONTRACT_JSON)
            .expect("canvas generation contract must parse")
    })
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn loads_canvas_generation_contract() {
        let contract = get_canvas_generation_contract();

        assert_eq!(contract.schema_version, 1);
        assert!(contract
            .imports
            .allowed_modules
            .contains(&"@canvas-sdk".to_string()));
        assert_eq!(
            contract.storage.project_canvas_root,
            "~/.routa/projects/{folderSlug}/canvases"
        );
    }
}