Struct svelte_store::Readable

pub struct Readable<T> { /* private fields */ }

Rust-managed Readable Svelte store.

Implementations

impl<T: 'static> Readable<T>

pub fn new(initial_value: T) -> Self where
    T: Clone + Into<JsValue>, 

Creates a Readable Svelte store.

This function is only implemented for types that can be converted into JsValue. This includes all types annotated with #[wasm_bindgen]. If your type does not provide an Into<JsValue> implementation, use Readable::new_mapped instead.

Examples

Using a type that already provides an implementation of Into<JsValue>.

use svelte_store::Readable;

let store = Readable::new(0u8);

Using a type annotated with #[wasm_bindgen].

use svelte_store::Readable;
use wasm_bindgen::prelude::*;

#[derive(Clone)]
#[wasm_bindgen]
pub struct MyStruct;

let store = Readable::new(MyStruct);

pub fn new_mapped<F>(initial_value: T, mapping_fn: F) -> Self where
    F: FnMut(&T) -> JsValue + 'static, 

Creates a new Readable Svelte store which calls its mapping fn each time the store is set, to produce a JsValue.

This method should be used whenever Readable::new cannot be, due to lacking trait compatibility.

Examples

Creating a store of Vec<u8>.

use svelte_store::Readable;
use wasm_bindgen::prelude::*;

let values = vec![7u8; 7];

let store = Readable::new_mapped(values, |values: &Vec<u8>| {
    values
        .iter()
        .cloned()
        .map(JsValue::from)
        .collect::<js_sys::Array>()
        .into()
});

pub fn set(&mut self, new_value: T)

Sets the value of the store, notifying all store listeners the value has changed.

pub fn set_with<F, O>(&mut self, f: F) -> O where
    F: FnOnce(&mut T) -> O, 

Calls the provided f with a &mut T, returning whatever f returns. After this function is called, the store will be updated and all store listeners will be notified.

Trait Implementations

impl<T> Debug for Readable<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Default for Readable<T> where
    T: Default + Clone + Into<JsValue> + 'static, 

fn default() -> Self

Returns the “default value” for a type.

impl<T> Deref for Readable<T>

Readable relies on the fact that only one instance can exist at a time to provide transparent dereferencing to the inner value. As a result, it is unsound to implement Clone. If you need shared mutability, try using Rc and RefCell.

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T> Display for Readable<T> where
    T: Display, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.