amberjs 1.17.0

JavaScript/TypeScript runtime built with Rust and V8
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

//! Zero-dependency environment variable parser (`amber:std/dotenv`).

use std::collections::HashMap;
use std::fs;
use std::path::Path;

/// Parse `.env` file formatted content into a key-value map
pub fn parse_dotenv(content: &str) -> HashMap<String, String> {
    let mut map: HashMap<String, String> = HashMap::new();

    for line in content.lines() {
        let trimmed = line.trim();
        // Ignore empty lines and comments
        if trimmed.is_empty() || trimmed.starts_with('#') {
            continue;
        }

        // Strip optional "export " prefix
        let clean_line = if trimmed.starts_with("export ") {
            trimmed["export ".len()..].trim_start()
        } else {
            trimmed
        };

        if let Some((raw_key, raw_val)) = clean_line.split_once('=') {
            let key = raw_key.trim().to_string();
            if key.is_empty() {
                continue;
            }

            let val_trimmed = raw_val.trim();
            let parsed_val = if val_trimmed.starts_with('\'')
                && val_trimmed.ends_with('\'')
                && val_trimmed.len() >= 2
            {
                // Single quoted: literal string
                val_trimmed[1..val_trimmed.len() - 1].to_string()
            } else if val_trimmed.starts_with('"')
                && val_trimmed.ends_with('"')
                && val_trimmed.len() >= 2
            {
                // Double quoted: unescape newlines and tabs
                let inner = &val_trimmed[1..val_trimmed.len() - 1];
                inner
                    .replace("\\n", "\n")
                    .replace("\\r", "\r")
                    .replace("\\t", "\t")
                    .replace("\\\"", "\"")
            } else {
                // Strip inline comment if any
                let mut val = val_trimmed;
                if let Some(idx) = val.find(" #") {
                    val = val[..idx].trim_end();
                }
                val.to_string()
            };

            // Basic variable interpolation: $KEY or ${KEY}
            let mut interpolated = parsed_val.clone();
            for (k, v) in map.iter() {
                interpolated = interpolated.replace(&format!("${{{}}}", k), v);
                interpolated = interpolated.replace(&format!("${}", k), v);
            }
            map.insert(key, interpolated);
        }
    }

    map
}

/// Load a `.env` file from disk and return the parsed key-values
pub fn load_dotenv_file(path: &Path) -> Option<HashMap<String, String>> {
    if path.exists() && path.is_file() {
        if let Ok(content) = fs::read_to_string(path) {
            return Some(parse_dotenv(&content));
        }
    }
    None
}