hpx-browser 2.4.24

Headless browser engine for hpx: HTML parsing, rendering, CDP, and canvas support
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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

// Timer bootstrap — wires setTimeout/setInterval/clearTimeout/clearInterval to Rust ops.
(() => {
  const ops = Deno.core.ops;
  const pendingCallbacks = new Map();
  let nextCallbackId = 1;

  const fireCallback = (id) => {
    const cb = pendingCallbacks.get(id);
    if (!cb) return;
    if (cb.isInterval) {
      try {
        cb.fn();
      } catch (e) {
        console.error("Interval callback error:", e);
      }
      // Schedule next interval
      const run = async () => {
        await ops.op_timer_sleep(cb.delay);
        if (pendingCallbacks.has(id)) {
          try {
            cb.fn();
          } catch (e) {
            console.error("Interval callback error:", e);
          }
          run();
        }
      };
      run();
    } else {
      pendingCallbacks.delete(id);
      try {
        cb.fn();
      } catch (e) {
        console.error("Timer callback error:", e);
      }
    }
  };

  globalThis.setTimeout = (fn, delay = 0) => {
    const cbId = nextCallbackId++;
    const effectiveDelay = Math.max(delay, 0);
    const timerId = ops.op_set_timeout(effectiveDelay);
    pendingCallbacks.set(cbId, {
      fn,
      delay: effectiveDelay,
      isInterval: false,
      timerId,
    });

    (async () => {
      await ops.op_timer_sleep(effectiveDelay);
      fireCallback(cbId);
    })();

    return cbId;
  };

  globalThis.setInterval = (fn, delay = 0) => {
    const cbId = nextCallbackId++;
    const effectiveDelay = Math.max(delay, 4);
    const timerId = ops.op_set_interval(effectiveDelay);
    pendingCallbacks.set(cbId, {
      fn,
      delay: effectiveDelay,
      isInterval: true,
      timerId,
    });

    const run = async () => {
      await ops.op_timer_sleep(effectiveDelay);
      if (pendingCallbacks.has(cbId)) {
        try {
          fn();
        } catch (e) {
          console.error("Interval callback error:", e);
        }
        run();
      }
    };
    run();

    return cbId;
  };

  globalThis.clearTimeout = (id) => {
    const cb = pendingCallbacks.get(id);
    if (cb) {
      ops.op_clear_timer(cb.timerId);
      pendingCallbacks.delete(id);
    }
  };

  globalThis.clearInterval = (id) => {
    const cb = pendingCallbacks.get(id);
    if (cb) {
      ops.op_clear_timer(cb.timerId);
      pendingCallbacks.delete(id);
    }
  };
})();