A crate to make working with wasm-bindgen easier.

This crate contains the wasm_bindgen_struct macro which can be used to declare wasm_bindgen types, and implement getters/setter as if they were normal rust structs. It can also be used to implement methods for the type, including inline mapping to overcome wasm-bindgen-futures limitations.

Example

```rust // Or you can use this instead to avoid needing to import // the macro throughout your crate // #[macrouse] // extern crate wasmbindgenstruct; use wasmbindgenstruct::wasmbindgen_struct;

[wasmbindgenstruct]

// module here means this type comes from the JS "my-module" module // with the class name aAnotherType

[opts(module = "my-module", js_name = "AnotherType")]

struct MyJsType { // field names are automatically converted to camelCase fielda: String, // ...but can be manually specified if needed #[opts(jsname = "fieldb")] fieldb: String, }

[wasmbindgenstruct]

[opts(module = "my-module")]

impl MyJsType { // Automatically gets the static_method_of = MyJsType applied, // as well as catch due to the Result fn apple() -> Result;

// async functions in wasm-bindgen can only currently return // (), JsValue, or Result<_, JsValue>, whereis one of // the two previously mentioned types. We useMapValue // to tell the macro that the binding method should returnT, // but we'll map the value toU` async fn oranges(&self) -> MapValue { self .orangesjs() .await .unchecked_into::() .into() } } ```

The above expands to:

```rust

// For getters/setters

[wasm_bindgen(module = "my-module")]

extern "C" { #[wasmbindgen(jsname = "AnotherType")] type MyJsType;

#[wasmbindgen( method, getter, jsclass = "AnotherType", jsname = "fieldA" )] fn fielda(this: &MyJsType) -> String;

#[wasmbindgen( method, setter, jsclass = "AnotherType", jsname = "fieldA" )] fn setfield_a(this: &MyJsType, value: String);

#[wasmbindgen( method, getter, jsclass = "AnotherType", jsname = "fieldb" )] fn fieldb(this: &MyJsType) -> String; #[wasmbindgen( method, setter, jsclass = "AnotherType", jsname = "fieldb" )] fn setfield_b(this: &MyJsType, value: String); }

// And for methods impl MyJsType { fn apple() -> Result { #[wasmbindgen(module = "my-module")] extern "C" { #[wasmbindgen(staticmethodof = MyJsType, jsname = "apple")] #[wasmbindgen(catch)] fn applejs() -> Result; } Self::applejs() } async fn oranges(&self) -> String { #[wasmbindgen(module = "my-module")] extern "C" { #[wasmbindgen(method, jsname = "oranges")] async fn orangesjs(this: &MyJsType) -> JsValue; } self .orangesjs() .await .uncheckedinto::() .into() } } ```

#[opts(...)] on structs

• dbg: bool

  Show the formatted output of the macro as a warning

• on: Type

  Allows using an existing type with the struct syntax.

  Example

  ```rust

  [wasm_bindgen]

  extern "C" { type JsType; }

  [wasmbindgenstruct]

  [opts(on = JsType)]

  // Struct can be named anything, it doesn't matter struct JsType { field_1: bool, } ```

• extends: Type

• getter: bool
• setter: bool
• final_: bool
• js_name: Lit
• js_namespacejsnamespace: Vec: [Lit1, Lit2, Lit3, ...]
• module: Lit
• raw_module: Lit

• <unknown>

  Unknown attributes, such as doc comments, are forwarded to the type MyType declaration, or ignored in the case of using on.

#[opts(...)] on struct fields

• getter: bool
• setter: bool
• structural: bool
• final_: bool
• js_name: Lit

#[opts(...)] on impl

• dbg: bool

  Show the formatted output of the macro as a warning

• final_: bool

• js_name: Lit
• js_namespace: [Lit1, Lit2, Lit3, ...]
• module: Lit
• raw_module: Lit

#[opts(...)] on impl methods

• constructor: bool
• final_: bool
• structural: bool
• getter: bool
• setter: bool
• indexing_getter: bool
• indexing_setter: bool
• indexing_deleter: bool
• js_name: Lit
• variadic: bool

Treatment of Special Types

• Result<T, E>

  Implies catch.

• MapValue<T, U>

  Allows specifing the types of the generated wasm-bindgen binding, as well as the actual method type. This allows arbitrary transformations between the bound method and the output method.

  Example

  ```rust

  [wasmbindgenstruct]

  struct JsType;

  [wasmbindgenstruct]

  impl JsType { async fn getasyncstring(&self) -> MapValue { self .getasyncstringjs() .await .uncheckedinto::() .into() } } ```

  Important note

  MapValue is a pseudo-type which only exists within the macro's scope. i.e., this type does not exist outside of #[wasm_bindgen_struct] impl { /* ... */ } and therefore does not need to be imported.