Struct leptos_use::utils::JsonCodec

pub struct JsonCodec;

A codec for storing JSON messages that relies on serde_json to parse.

Example

// Primitive types:
let (get, set, remove) = use_local_storage::<i32, JsonCodec>("my-key");

// Structs:
#[derive(Serialize, Deserialize, Clone, Default, PartialEq)]
pub struct MyState {
    pub hello: String,
}
let (get, set, remove) = use_local_storage::<MyState, JsonCodec>("my-struct-key");

Versioning

If the JSON decoder fails, the storage hook will return T::Default dropping the stored JSON value. See Codec for general information on codec versioning.

Rely on serde

This codec uses serde_json under the hood. A simple way to avoid complex versioning is to rely on serde’s field attributes such as serde(default) and serde(rename = "...").

String replacement

Previous versions of leptos-use offered a merge_defaults fn to rewrite the encoded value. This is possible by wrapping the codec but should be avoided.

#[derive(Serialize, Deserialize, Clone, Default, PartialEq)]
pub struct MyState {
    pub hello: String,
    pub greeting: String,
}

#[derive(Clone, Default)]
pub struct MyStateCodec();
impl StringCodec<MyState> for MyStateCodec {
    type Error = serde_json::Error;

    fn encode(&self, val: &MyState) -> Result<String, Self::Error> {
        serde_json::to_string(val)
    }

    fn decode(&self, stored_value: String) -> Result<MyState, Self::Error> {
        let default_value = MyState::default();
        let rewritten = if stored_value.contains(r#""greeting":"#) {
            stored_value
        } else {
            // add "greeting": "Hello" to the string
            stored_value.replace("}", &format!(r#""greeting": "{}"}}"#, default_value.greeting))
        };
        serde_json::from_str(&rewritten)
    }
}

let (get, set, remove) = use_local_storage::<MyState, MyStateCodec>("my-struct-key");

Transform a JsValue

A better alternative to string replacement might be to parse the JSON then transform the resulting JsValue before decoding it to to your struct again.

#[derive(Serialize, Deserialize, Clone, Default, PartialEq)]
pub struct MyState {
    pub hello: String,
    pub greeting: String,
}

#[derive(Clone, Default)]
pub struct MyStateCodec();
impl StringCodec<MyState> for MyStateCodec {
    type Error = serde_json::Error;

    fn encode(&self, val: &MyState) -> Result<String, Self::Error> {
        serde_json::to_string(val)
    }

    fn decode(&self, stored_value: String) -> Result<MyState, Self::Error> {
        let mut val: serde_json::Value = serde_json::from_str(&stored_value)?;
        // add "greeting": "Hello" to the object if it's missing
        if let Some(obj) = val.as_object_mut() {
            if !obj.contains_key("greeting") {
               obj.insert("greeting".to_string(), json!("Hello"));
            }
            serde_json::from_value(val)
        } else {
            Ok(MyState::default())
        }
    }
}

let (get, set, remove) = use_local_storage::<MyState, MyStateCodec>("my-struct-key");

Trait Implementations

impl Clone for JsonCodec

fn clone(&self) -> JsonCodec

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for JsonCodec

fn default() -> JsonCodec

Returns the “default value” for a type.

impl PartialEq for JsonCodec

fn eq(&self, other: &JsonCodec) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Serialize + DeserializeOwned> StringCodec<T> for JsonCodec

type Error = Error

The error type returned when encoding or decoding fails.

fn encode(&self, val: &T) -> Result<String, Self::Error>

Encodes a value to a string.

fn decode(&self, str: String) -> Result<T, Self::Error>

Decodes a string to a value. Should be able to decode any string encoded by [encode].

impl Copy for JsonCodec

impl StructuralPartialEq for JsonCodec