js-sys 0.3.95

Bindings for all JS global objects and functions in all JS environments like Node.js and browsers, built on `#[wasm_bindgen]` using the `wasm-bindgen` crate.
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

//! Polyfill for `Atomics.waitAsync` using a dedicated `Worker` per wait.
//! Workers are pooled and reused. The worker communicates the result back via
//! `postMessage`, which resolves a `Promise` on the calling thread.

#![allow(clippy::incompatible_msrv)]

use crate::{Array, Function, Promise};
use alloc::vec;
use alloc::vec::Vec;
use core::cell::RefCell;
use core::sync::atomic::AtomicI32;
use wasm_bindgen::prelude::*;

// Inline bindings for the web Worker and MessageEvent APIs.
// These replace the web-sys dependency, which would create a circular
// dependency since web-sys depends on js-sys.
#[wasm_bindgen]
extern "C" {
    #[derive(Clone)]
    type Worker;
    type MessageEvent;

    #[wasm_bindgen(constructor)]
    fn new_worker(url: &str) -> Worker;

    #[wasm_bindgen(method, js_name = postMessage, catch)]
    fn post_message(this: &Worker, msg: &JsValue) -> Result<(), JsValue>;

    #[wasm_bindgen(method, setter, js_name = onmessage)]
    fn set_onmessage(this: &Worker, cb: Option<&Function>);

    #[wasm_bindgen(method, getter)]
    fn data(this: &MessageEvent) -> JsValue;
}

#[thread_local]
static HELPERS: RefCell<Vec<Worker>> = RefCell::new(vec![]);

fn alloc_helper() -> Worker {
    if let Some(helper) = HELPERS.borrow_mut().pop() {
        return helper;
    }

    let worker_url = wasm_bindgen::link_to!(module = "/src/futures/task/worker.js");
    Worker::new_worker(&worker_url)
}

fn free_helper(helper: Worker) {
    let mut helpers = HELPERS.borrow_mut();
    helpers.push(helper.clone());
    helpers.truncate(10); // random arbitrary limit chosen here
}

pub fn wait_async(ptr: &AtomicI32, value: i32) -> Promise {
    Promise::new(&mut |resolve, _reject| {
        let helper = alloc_helper();
        let helper_ref = helper.clone();

        let onmessage_callback = Closure::once_into_js(move |e: MessageEvent| {
            // Our helper is done waiting so it's available to wait on a
            // different location, so return it to the free list.
            free_helper(helper_ref);
            drop(resolve.call1(&JsValue::NULL, &e.data()));
        });
        helper.set_onmessage(Some(onmessage_callback.as_ref().unchecked_ref()));

        let data = Array::of3(
            &wasm_bindgen::memory(),
            &JsValue::from(ptr.as_ptr() as u32 / 4),
            &JsValue::from(value),
        );

        helper
            .post_message(&data)
            .unwrap_or_else(|js| wasm_bindgen::throw_val(js));
    })
}