ducktor
ducktor is a Rust crate that allows you to create types from wasm_bindgen::JsValue
using duck typing.
With ducktor, you can define a struct that specifies the fields and types that you expect from a JsValue, and then use the implement From<JsValue>
for it using the #[derive(FromJsValue)]
macro. This way, you can use Rust's type system and syntax to work with JavaScript objects in WebAssembly.
Why
- Using
#[wasm_bindgen]
on exported types requires the input on an exported function be of the class created bywasm-bindgen
which is not always possible - Using imported types with
#[wasm_bindgen] extern "C" { ... }
makes it so that the type is not creatable from Rust. This becomes a problem in shared code where you want to create instance of the type from Rust as well.
Solution
Meet ducktor! A constructor for your structs using duck typing. It allows you to create a struct, as you normally would. Then, you can use the #[derive(FromJsValue)]
macro to implement From<JsValue>
for your struct. This allows you to use the from
method on your struct to create an instance of it from a JsValue
.
Internally, it defines and imports a non-existent JavaScript type that matches the struct fields and types. The JsValue
is then coerced into this type using JsValue::unchecked_ref
and then the struct is created by getting the value of each field from the JS type.
Example
use ducktor::FromJsValue;
// Define a struct that represents a JavaScript object with an a field and a b field
#[derive(FromJsValue)]
struct Data {
a: u32,
b: String,
}
// Create a JavaScript object that conforms to the Data struct
fn roundtrip() {
let data = js_sys::Object::new();
js_sys::Reflect::set(&data, &"a".into(), &42.into()).unwrap();
js_sys::Reflect::set(&data, &"b".into(), &"string".into()).unwrap();
// Convert the JsValue to a Data using the `from_js_value` method
let data: Data = Data::from(&data.into());
assert_eq!(data.a, 42);
assert_eq!(data.b, "string");
}