bun_sm 0.1.0

SpiderMonkey-backed API compatibility layer replacing bun_jsc
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

// @trace REQ-ENG-001
//! Hot module reloader — file watcher for HMR.
//!
//! Uses `notify` crate for file system watching when available.
//! Phase 1: polling-based change detection with in-memory file timestamps.

use ::std::collections::HashMap;
use ::std::path::PathBuf;
use ::std::sync::Mutex;
use ::std::time::SystemTime;

pub struct HotReloader {
    watched: Mutex<HashMap<PathBuf, SystemTime>>,
}

impl HotReloader {
    pub fn new() -> Self {
        HotReloader {
            watched: Mutex::new(HashMap::new()),
        }
    }

    pub fn enable_hot_module_reloading(&self) {}

    pub fn watch(&self, path: &str) -> Result<(), ()> {
        let p = PathBuf::from(path);
        if let Ok(metadata) = ::std::fs::metadata(&p) {
            if let Ok(modified) = metadata.modified() {
                self.watched
                    .lock()
                    .unwrap_or_else(|e| e.into_inner())
                    .insert(p, modified);
            }
        }
        Ok(())
    }

    pub fn unwatch(&self, path: &str) {
        let p = PathBuf::from(path);
        self.watched
            .lock()
            .unwrap_or_else(|e| e.into_inner())
            .remove(&p);
    }

    pub fn has_changes(&self) -> bool {
        let watched = self.watched.lock().unwrap_or_else(|e| e.into_inner());
        for (path, prev_time) in watched.iter() {
            if let Ok(metadata) = ::std::fs::metadata(path) {
                if let Ok(modified) = metadata.modified() {
                    if modified > *prev_time {
                        return true;
                    }
                }
            }
        }
        false
    }

    pub fn changed_files(&self) -> Vec<String> {
        let mut watched = self.watched.lock().unwrap_or_else(|e| e.into_inner());
        let mut changed = Vec::new();
        for (path, prev_time) in watched.iter_mut() {
            if let Ok(metadata) = ::std::fs::metadata(path) {
                if let Ok(modified) = metadata.modified() {
                    if modified > *prev_time {
                        changed.push(path.to_string_lossy().to_string());
                        *prev_time = modified;
                    }
                }
            }
        }
        changed
    }
}

impl Default for HotReloader {
    fn default() -> Self {
        Self::new()
    }
}

pub struct ImportWatcher {
    imports: Mutex<HashMap<String, Vec<String>>>,
}

impl ImportWatcher {
    pub fn new() -> Self {
        ImportWatcher {
            imports: Mutex::new(HashMap::new()),
        }
    }

    pub fn register_import(&self, from: &str, to: &str) {
        self.imports
            .lock()
            .unwrap_or_else(|e| e.into_inner())
            .entry(from.to_string())
            .or_default()
            .push(to.to_string());
    }

    pub fn get_importers(&self, path: &str) -> Vec<String> {
        let imports = self.imports.lock().unwrap_or_else(|e| e.into_inner());
        let mut result = Vec::new();
        for (from, targets) in imports.iter() {
            if targets.iter().any(|t| t == path) {
                result.push(from.clone());
            }
        }
        result
    }
}

impl Default for ImportWatcher {
    fn default() -> Self {
        Self::new()
    }
}

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

    #[test]
    fn import_watcher() {
        let w = ImportWatcher::new();
        w.register_import("a.js", "b.js");
        w.register_import("c.js", "b.js");
        let importers = w.get_importers("b.js");
        assert_eq!(importers.len(), 2);
    }

    #[test]
    fn no_changes_initially() {
        let h = HotReloader::new();
        assert!(!h.has_changes());
    }
}