from_js_ref 0.2.0

Trait for converting from JS interface reference wrappers
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

# `from_js_ref`

Runtime traits for converting between JS-imported reference types and Rust-exported `wasm-bindgen` types.

This crate is the companion to [`wasm_refgen`](https://crates.io/crates/wasm_refgen), which generates implementations of these traits via a proc-macro.

## Traits

### `FromJsRef`

```rust
pub trait FromJsRef: Sized {
    type JsRef: JsCast;

    /// Convert from a JS reference type to the Rust type.
    fn from_js_ref(castable: &Self::JsRef) -> Self;

    /// Attempt to convert from a raw `JsValue`.
    ///
    /// Provided by default using `dyn_ref` (instanceof).
    /// `wasm_refgen` overrides this with a duck-type check via
    /// `Reflect::has` for reliable validation.
    fn try_from_js_value(js_value: &JsValue) -> Option<Self> { /* ... */ }
}
```

### `JsDeref`

A convenience trait blanket-implemented for all `T::JsRef` types:

```rust
let wasm_foo: WasmFoo = js_foo.js_deref();
```

## Usage

You typically don't implement these traits by hand. Instead, use
`#[wasm_refgen(js_ref = JsFoo)]` on your `impl` block, which generates
the `FromJsRef` implementation automatically.

```rust
use from_js_ref::FromJsRef;

// From a typed reference (infallible)
let foo: WasmFoo = WasmFoo::from_js_ref(&js_foo);

// From a raw JsValue (fallible, duck-type validated)
let foo: Option<WasmFoo> = WasmFoo::try_from_js_value(&js_value);
```

> [!WARNING]
> Do _not_ use `dyn_into::<JsFoo>()` or `dyn_ref::<JsFoo>()` with
> `wasm_refgen`-generated types. These rely on `instanceof`, which
> targets the Rust identifier name rather than the JS class name.
> Use `FromJsRef::try_from_js_value` instead.

## License

Apache-2.0