Struct Invoke

pub struct Invoke<C, A = JsValue> { /* private fields */ }

A type used to configure an invoke operation.

Implementations

impl<C, A> Invoke<C, A>

pub fn with_args<T>(self, args: T) -> Invoke<C, T::Js>

where T: ToArgs,

Invokes a command with arguments on the backend.

Passing a serializable type

To send a custom serializable type as arguments, use the helper args function.

use {gloo::console, serde::Serialize};

#[derive(Serialize)]
struct User<'str> {
    name: &'str str,
    pass: &'str str,
}

let user = User {
    name: "anon",
    pass: "p@$$w0rD",
};

let args = tauri_wasm::args(&user)?;
let message = tauri_wasm::invoke("login").with_args(args).await?;
console::log!("logged on backend", message);

Passing a JS object

Thanks to the wasm_bindgen attribute you can convert your type into a JS value. To pass the value as arguments implement the ToArgs trait.

use {
    gloo::console,
    tauri_wasm::invoke::ToArgs,
    wasm_bindgen::prelude::*,
};

#[wasm_bindgen(getter_with_clone)]
struct User {
    name: String,
    pass: String,
}

impl ToArgs for User {
    type Js = JsValue;

    fn to_args(self) -> Self::Js {
        // wasm_bindgen attribute implements
        // convertion into JS value
        JsValue::from(self)
    }
}

let user = User {
    name: "anon".to_owned(),
    pass: "p@$$w0rD".to_owned(),
};

let message = tauri_wasm::invoke("login").with_args(user).await?;
console::log!("logged on backend", message);

pub fn with_options(self, opts: Options) -> Self

Invokes a command with options on the backend.

Example

use {gloo::console, tauri_wasm::invoke::Options};

let opts = Options::from_record([
    ("secret", "2"),
    ("data", "3"),
])?;

let message = tauri_wasm::invoke("send").with_options(opts).await?;
console::log!("received from backend", message);

Trait Implementations

impl<C, A> IntoFuture for Invoke<C, A>

where C: AsRef<JsValue>, A: AsRef<JsValue>,

type Output = Result<JsValue, Error>

The output that the future will produce on completion.

type IntoFuture = InvokeFuture

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.