ts-native 0.1.4

A TypeScript to native executable compiler using Cranelift
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

use anyhow::Result;
use serde::{Deserialize, Serialize};
use std::path::PathBuf;

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct ProjectConfig {
    #[serde(default)]
    pub project: ProjectInfo,
    #[serde(default)]
    pub compile: CompileConfig,
    #[serde(default)]
    pub extensions: ExtensionsConfig,
    #[serde(default)]
    pub link: LinkConfig,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct ProjectInfo {
    #[serde(default)]
    pub name: String,
    #[serde(default)]
    pub version: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct CompileConfig {
    #[serde(default = "default_input")]
    pub input: String,
    #[serde(default = "default_output")]
    pub output: String,
    #[serde(default)]
    pub target: Option<String>,
}

fn default_input() -> String {
    "src/main.ts".to_string()
}

fn default_output() -> String {
    "a.exe".to_string()
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct ExtensionsConfig {
    #[serde(default = "default_true")]
    pub auto_discover: bool,
    #[serde(default)]
    pub items: Vec<ExtensionItem>,
    #[serde(default)]
    pub exclude: Vec<String>,
}

fn default_true() -> bool {
    true
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ExtensionItem {
    pub path: Option<String>,
    pub crate_name: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct LinkConfig {
    #[serde(default = "default_linker")]
    pub linker: String,
    #[serde(default)]
    pub flags: Vec<String>,
}

fn default_linker() -> String {
    "auto".to_string()
}

impl ProjectConfig {
    pub fn load(path: &std::path::Path) -> Result<Self> {
        if !path.exists() {
            return Ok(Self::default());
        }
        
        let content = std::fs::read_to_string(path)?;
        let config: Self = toml::from_str(&content)?;
        Ok(config)
    }
    
    pub fn load_from_dir(dir: &std::path::Path) -> Result<Self> {
        let config_path = dir.join("ts-native.toml");
        Self::load(&config_path)
    }
    
    pub fn has_explicit_extensions(&self) -> bool {
        !self.extensions.items.is_empty()
    }
    
    pub fn should_auto_discover(&self) -> bool {
        self.extensions.auto_discover && !self.has_explicit_extensions()
    }
    
    pub fn get_excluded_extensions(&self) -> &[String] {
        &self.extensions.exclude
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn test_default_config() {
        let config = ProjectConfig::default();
        assert_eq!(config.compile.input, "src/main.ts");
        assert!(config.extensions.auto_discover);
        assert!(!config.has_explicit_extensions());
    }
    
    #[test]
    fn test_parse_config() {
        let config_content = r#"
[project]
name = "my-app"
version = "0.1.0"

[compile]
input = "src/app.ts"
output = "dist/app.exe"

[extensions]
auto_discover = true
exclude = ["ts-native-fs"]
"#;
        let config: ProjectConfig = toml::from_str(config_content).unwrap();
        assert_eq!(config.project.name, "my-app");
        assert_eq!(config.compile.input, "src/app.ts");
        assert!(config.should_auto_discover());
        assert!(config.get_excluded_extensions().contains(&"ts-native-fs".to_string()));
    }
}