toml
[dependencies]
js_ffi = "0.0.11"
A simple FFI library for calling javascript from web assembly with Rust * #![nostd] + alloc for uber small wasm ( unfortunately async-await does't work with nostd yet) * low magic * minimal * no macros * ready for web references * compatible with async-await futures * works with web assembly languages other than Rust * readable library that can be understood quickly and learned from
rust
// get a function handle to console log javascript function
let log = register("console.log");
// call with 1 parameter with no object context and a string
call_1(UNDEFINED, log, TYPE_STRING, to_js_string("Hello World"));
```rust use executor::Executor; use js_ffi::*;
pub fn main() -> () { Executor::spawn(async { let api = API { loghandle: register("console.log"), settimeouthandle: register("window.setTimeout"), }; api.consolelog("hello"); api.windowsettimeout(1000).await; api.console_log("world!"); }); }
struct API { loghandle: JSValue, settimeout_handle: JSValue, }
impl API { pub fn consolelog(&self, msg: &str) { call1(UNDEFINED, self.loghandle, TYPESTRING, tojsstring(msg)); }
pub fn window_set_timeout(&self, millis: i32) -> CallbackFuture {
let (future, id) = CallbackFuture::new();
call_2(
UNDEFINED,
self.set_timeout_handle,
TYPE_FUNCTION,
id,
TYPE_NUM,
millis as JSValue,
);
future
}
} ```
```html
``` ## How it works The basic premise is that you `register` the JavaScript functions you want to have access to from Rust to a constant number function handle. Then you can use `call_*` to send execute the function with arguments depending on the argument count you want to send (e.g. `call_1`, `call_7`). The idea is you can quickly create wrapper functions for exactly what you need. When calling the function you specify the object to call the function of (or undefined if you just want to call the function), the function id to call you registered with, and pairs of argument type and arguments afer. `call_*(