use serde::{Deserialize, Serialize};
pub(crate) fn unix_epoch_millis() -> u64 {
web_time::SystemTime::now()
.duration_since(web_time::UNIX_EPOCH)
.map(|duration| duration.as_millis() as u64)
.unwrap_or(0)
}
pub(crate) fn unix_epoch_seconds() -> u64 {
web_time::SystemTime::now()
.duration_since(web_time::UNIX_EPOCH)
.map(|duration| duration.as_secs())
.unwrap_or(0)
}
pub fn wall_clock_now() -> std::time::SystemTime {
let since = web_time::SystemTime::now()
.duration_since(web_time::UNIX_EPOCH)
.unwrap_or_default();
std::time::UNIX_EPOCH + since
}
#[derive(
Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize,
)]
#[serde(transparent)]
pub struct PortableInstant(pub u64);
impl PortableInstant {
pub const ORIGIN: Self = Self(0);
pub fn millis(self) -> u64 {
self.0
}
pub fn saturating_elapsed_since(self, earlier: Self) -> u64 {
self.0.saturating_sub(earlier.0)
}
pub fn saturating_add_ms(self, ms: u64) -> Self {
Self(self.0.saturating_add(ms))
}
pub fn has_reached(self, deadline: Self) -> bool {
self >= deadline
}
}
impl std::ops::Sub for PortableInstant {
type Output = u64;
fn sub(self, rhs: Self) -> u64 {
self.saturating_elapsed_since(rhs)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn origin_is_zero() {
assert_eq!(PortableInstant::ORIGIN.millis(), 0);
assert_eq!(PortableInstant::default(), PortableInstant::ORIGIN);
}
#[test]
fn saturating_elapsed_since_handles_reverse_order() {
let earlier = PortableInstant(100);
let later = PortableInstant(250);
assert_eq!(later.saturating_elapsed_since(earlier), 150);
assert_eq!(earlier.saturating_elapsed_since(later), 0);
}
#[test]
fn saturating_add_ms_saturates_at_max() {
let big = PortableInstant(u64::MAX - 5);
assert_eq!(big.saturating_add_ms(10), PortableInstant(u64::MAX));
}
#[test]
fn has_reached_is_true_at_and_after_deadline() {
let deadline = PortableInstant(500);
assert!(!PortableInstant(499).has_reached(deadline));
assert!(PortableInstant(500).has_reached(deadline));
assert!(PortableInstant(501).has_reached(deadline));
}
#[test]
fn sub_operator_mirrors_saturating_elapsed_since() {
let a = PortableInstant(300);
let b = PortableInstant(100);
assert_eq!(a - b, 200);
assert_eq!(b - a, 0);
}
#[test]
fn ordering_is_consistent_with_u64() {
assert!(PortableInstant(5) < PortableInstant(10));
assert!(PortableInstant(10) == PortableInstant(10));
assert!(PortableInstant(15) > PortableInstant(10));
}
#[test]
fn deadline_pattern_round_trip() {
let now = PortableInstant(1_000);
let debounce_ms = 75;
let deadline = now.saturating_add_ms(debounce_ms);
let fifty_ms_later = PortableInstant(1_050);
assert!(!fifty_ms_later.has_reached(deadline));
let eighty_ms_later = PortableInstant(1_080);
assert!(eighty_ms_later.has_reached(deadline));
}
#[test]
fn serde_round_trip_preserves_value() {
let original = PortableInstant(1_234_567_890);
let json = serde_json::to_string(&original).unwrap();
assert_eq!(json, "1234567890");
let decoded: PortableInstant = serde_json::from_str(&json).unwrap();
assert_eq!(decoded, original);
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn wall_clock_now_reads_the_platform_clock() {
let before = web_time::SystemTime::now();
let now = wall_clock_now();
let after = web_time::SystemTime::now();
assert!(before <= now && now <= after);
}
}