bun_resolver 0.1.2

A Rust-native programmable browser runtime built on Servo and SpiderMonkey
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

use bun_sys::{S, Stat, Timespec};
// Zig: `std.hash.XxHash64` (streaming init/update/digest).
use bun_hash::XxHash64Streaming as XxHash64;
use bun_http_types::ETag::wtf;

#[derive(Default)]
pub struct StatHash {
    pub value: u64,

    pub last_modified_u64: u64,
    pub last_modified_buffer: [u8; 32],
    pub last_modified_buffer_len: u8,
    // TODO: add etag support here!
}

// Zig `std.posix.Stat.mtime()` — Rust `libc::stat` has no method, project the
// platform-specific fields here (mirrors `bun_sys::PosixStat::stat_mtime`).
#[inline]
fn stat_mtime(s: &Stat) -> Timespec {
    // The `libc` crate flattens BSD/Darwin `st_mtimespec` into
    // `st_mtime`/`st_mtime_nsec` so the access is uniform on all `unix`.
    #[cfg(unix)]
    {
        Timespec {
            sec: s.st_mtime,
            nsec: s.st_mtime_nsec,
        }
    }
    #[cfg(windows)]
    {
        Timespec {
            sec: s.mtim.sec as i64,
            nsec: s.mtim.nsec as i64,
        }
    }
}

impl StatHash {
    pub fn hash(&mut self, stat: &Stat, path: &[u8]) {
        let mut stat_hasher = XxHash64::new(42);
        let mtime = stat_mtime(stat);
        stat_hasher.update(bun_core::bytes_of(&stat.st_size));
        stat_hasher.update(bun_core::bytes_of(&stat.st_mode));
        stat_hasher.update(bun_core::bytes_of(&mtime));
        stat_hasher.update(bun_core::bytes_of(&stat.st_ino));
        stat_hasher.update(path);

        let prev = self.value;
        self.value = stat_hasher.digest();

        if prev != self.value && S::ISREG(stat.st_mode as u32) {
            let mtime_timespec = stat_mtime(stat);
            // Clamp negative values to 0 to avoid timestamp overflow issues on Windows
            let mtime = Timespec {
                nsec: mtime_timespec.nsec.max(0),
                sec: mtime_timespec.sec.max(0),
            };
            if mtime.ms() > 0 {
                self.last_modified_buffer_len = u8::try_from(
                    wtf::write_http_date(&mut self.last_modified_buffer, mtime.ms_unsigned()).len(),
                )
                .unwrap();
                self.last_modified_u64 = mtime.ms_unsigned();
            } else {
                self.last_modified_buffer_len = 0;
                self.last_modified_u64 = 0;
            }
        } else if !S::ISREG(stat.st_mode as u32) {
            self.last_modified_buffer_len = 0;
            self.last_modified_u64 = 0;
        }
    }

    pub fn last_modified(&self) -> Option<&[u8]> {
        if self.last_modified_buffer_len == 0 {
            return None;
        }

        Some(&self.last_modified_buffer[0..usize::from(self.last_modified_buffer_len)])
    }
}

// ported from: src/resolver/fs/stat_hash.zig