rquickjs-serde 0.3.0

Serde support for rquickjs
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

# rquickjs serde

[![github](https://img.shields.io/badge/github-rquickjs/rquickjs-serde.svg?style=for-the-badge&logo=github)](https://github.com/rquickjs/rquickjs-serde)
[![crates](https://img.shields.io/crates/v/rquickjs-serde.svg?style=for-the-badge&color=fc8d62&logo=rust)](https://crates.io/crates/rquickjs-serde)

This is a serde serializer/deserializer for [rquickjs](https://github.com/DelSkayn/rquickjs) `Value`.

## Usage

```rust
use std::error::Error;

use serde::Serialize;
use rquickjs::{Runtime, Context};

#[derive(Serialize)]
struct User {
    fingerprint: String,
    location: String,
}

fn main() {
    let rt = Runtime::new().unwrap();
    let ctx = Context::full(&rt).unwrap();

    // Serialize to a Value<'_>
    let u = User {
        fingerprint: "0xF9BA143B95FF6D82".to_owned(),
        location: "Menlo Park, CA".to_owned(),
    };
    ctx.with(|ctx| {
        let v = rquickjs_serde::to_value(ctx, u).unwrap();
        let obj = v.into_object().unwrap();

        let fingerprint: String = obj.get("fingerprint").unwrap();
        assert_eq!(fingerprint, "0xF9BA143B95FF6D82");

        let location: String = obj.get("location").unwrap();
        assert_eq!(location, "Menlo Park, CA");
    });

    // Deserialize from a Value<'_>
    let v = ctx.with(|ctx| {
        ctx.eval::<Value<'_>, _>("var a = {fingerprint: '0xF9BA143B95FF6D82', location: 'Menlo Park, CA'};").unwrap();
        let val = ctx.globals().get("a").unwrap();
        let u: User = rquickjs_serde::from_value(val).unwrap();
        u
    });
    assert_eq!(v.fingerprint, "0xF9BA143B95FF6D82");
    assert_eq!(v.location, "Menlo Park, CA");
}
```

## Strict mode

The implementation tries to make smart guesses when it can, for example the deserializer will fallback to converting `BigInt` to `String`. This is likely not what you want if you implement a serialization that is JSON compliant.

This is s why we offer the `strict` mode, that will stick to what the behaviour that the Javascript specification defines for `JSON`. Just switch the method to use it.

```rust
let u: User = rquickjs_serde::from_value_strict(val).unwrap();
```

## Acknowledgements

This project includes code derived from the [Javy](https://github.com/bytecodealliance/javy) project. See [`NOTICE`](./NOTICE) for more details.