ps-blitz-script 0.5.5

JavaScript execution for Blitz using the Boa engine
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

use std::cell::Cell;
use std::rc::Rc;

use web_time::{Duration, Instant};

pub(crate) struct JobBudget {
    duration: Cell<Duration>,
    deadline: Cell<Option<Instant>>,
}

impl Default for JobBudget {
    fn default() -> Self {
        Self {
            duration: Cell::new(Duration::from_millis(16)),
            deadline: Cell::new(None),
        }
    }
}

impl JobBudget {
    pub(crate) fn duration(&self) -> Duration {
        self.duration.get()
    }

    pub(crate) fn set_duration(&self, duration: Duration) {
        assert!(!duration.is_zero(), "the job budget must be positive");
        self.duration.set(duration);
    }

    pub(crate) fn begin(self: &Rc<Self>) -> JobSlice {
        let owns_deadline = self.deadline.get().is_none();
        if owns_deadline {
            self.deadline
                .set(Some(Instant::now() + self.duration.get()));
        }
        JobSlice {
            budget: Rc::clone(self),
            owns_deadline,
        }
    }

    pub(crate) fn remaining(&self) -> Duration {
        self.deadline.get().map_or(self.duration.get(), |deadline| {
            deadline.saturating_duration_since(Instant::now())
        })
    }

    pub(crate) fn exhausted(&self) -> bool {
        self.deadline
            .get()
            .is_some_and(|deadline| Instant::now() >= deadline)
    }
}

/// Nested drains share the owning poll's deadline.
pub(crate) struct JobSlice {
    budget: Rc<JobBudget>,
    owns_deadline: bool,
}

impl Drop for JobSlice {
    fn drop(&mut self) {
        if self.owns_deadline {
            self.budget.deadline.set(None);
        }
    }
}