Trait seed::app::orders::Orders

pub trait Orders<Ms: 'static> {
    type AppMs: 'static;
    type Mdl: 'static;
    type INodes: IntoNodes<Self::AppMs> + 'static;

    // Required methods
    fn proxy<ChildMs: 'static>(
        &mut self,
        f: impl FnOnce(ChildMs) -> Ms + 'static + Clone
    ) -> OrdersProxy<'_, ChildMs, Self::AppMs, Self::Mdl, Self::INodes>;
    fn render(&mut self) -> &mut Self;
    fn force_render_now(&mut self) -> &mut Self;
    fn skip(&mut self) -> &mut Self;
    fn notify(&mut self, message: impl Any + Clone) -> &mut Self;
    fn send_msg(&mut self, msg: Ms) -> &mut Self;
    fn perform_cmd<MsU: 'static>(
        &mut self,
        cmd: impl Future<Output = MsU> + 'static
    ) -> &mut Self;
    fn perform_cmd_with_handle<MsU: 'static>(
        &mut self,
        cmd: impl Future<Output = MsU> + 'static
    ) -> CmdHandle;
    fn clone_app(&self) -> App<Self::AppMs, Self::Mdl, Self::INodes>;
    fn msg_mapper(&self) -> Rc<dyn Fn(Ms) -> Self::AppMs>;
    fn after_next_render<MsU: 'static>(
        &mut self,
        callback: impl FnOnce(RenderInfo) -> MsU + 'static
    ) -> &mut Self;
    fn subscribe<MsU: 'static, SubMs: 'static + Clone>(
        &mut self,
        handler: impl FnOnce(SubMs) -> MsU + Clone + 'static
    ) -> &mut Self;
    fn subscribe_with_handle<MsU: 'static, SubMs: 'static + Clone>(
        &mut self,
        handler: impl FnOnce(SubMs) -> MsU + Clone + 'static
    ) -> SubHandle;
    fn stream<MsU: 'static>(
        &mut self,
        stream: impl Stream<Item = MsU> + 'static
    ) -> &mut Self;
    fn stream_with_handle<MsU: 'static>(
        &mut self,
        stream: impl Stream<Item = MsU> + 'static
    ) -> StreamHandle;

    // Provided methods
    fn msg_sender(&self) -> Rc<dyn Fn(Option<Ms>)> { ... }
    fn clone_base_path(&self) -> Rc<[String]> { ... }
}

Required Associated Types

type AppMs: 'static

type Mdl: 'static

type INodes: IntoNodes<Self::AppMs> + 'static

Required Methods

fn proxy<ChildMs: 'static>( &mut self, f: impl FnOnce(ChildMs) -> Ms + 'static + Clone ) -> OrdersProxy<'_, ChildMs, Self::AppMs, Self::Mdl, Self::INodes>

Automatically map message type. It allows you to pass Orders into child module.

Example

Msg::Child(child_msg) => {
   child::update(child_msg, &mut model.child, &mut orders.proxy(Msg::Child));
}

fn render(&mut self) -> &mut Self

Schedule web page rerender after model update. It’s the default behaviour.

fn force_render_now(&mut self) -> &mut Self

Force web page to rerender immediately after model update.

fn skip(&mut self) -> &mut Self

Don’t rerender web page after model update.

fn notify(&mut self, message: impl Any + Clone) -> &mut Self

Notify all subscription handlers that listen for messages with the message’s type.

Note: Seed’s native subscriptions / messages can be also sent - e.g. orders.notify(subs::UrlRequested::new(url)). The most is ignored by the Seed’s runtime, but some of them are processed and trigger side-effects - e.g. simulate <a> link click by sending subs::UrlRequested.

Example

orders.notify(counter::DoReset);
orders.notify("Hello!");
...
orders.subscribe(Msg::Reset);  // `Msg::Reset(counter::DoReset)`
orders.subscribe(|greeting: &'static str| log!(greeting));

Note:: All notifications are pushed to the queue - i.e. update function is NOT called immediately.

fn send_msg(&mut self, msg: Ms) -> &mut Self

Invoke function update with the given msg.

Example

orders.msg(Msg::Increment);

Note:: All msgs are pushed to the queue - i.e. update function is NOT called immediately.

fn perform_cmd<MsU: 'static>( &mut self, cmd: impl Future<Output = MsU> + 'static ) -> &mut Self

Execute cmd and send its output (if it’s Msg) to update function.

Output has to be Msg, Option<Msg> or ().

Example

orders.perform_cmd(cmds::timeout(2000, || Msg::OnTimeout));
orders.perform_cmd(async { log!("Hello!") });

Note:: Use the alternative perform_cmd_with_handle to control cmd’s lifetime.

Panics

Panics when the output isn’t Msg, Option<Msg> or ().

Stabilisation of issue 391 makes this a compile-time error.

fn perform_cmd_with_handle<MsU: 'static>( &mut self, cmd: impl Future<Output = MsU> + 'static ) -> CmdHandle

Execute given cmd and send its output (if it’s Msg) to update function.

• Returns CmdHandle that you should save to your Model. The cmd is aborted on the handle drop.

Output has to be Msg, Option<Msg> or ().

Example

let timeout_handle = orders.perform_cmd_with_handle(cmds::timeout(2000, || Msg::OnTimeout));
let cmd_handle = orders.perform_cmd_with_handle(async { log!("Hello!") });

Panics

Panics when the output isn’t Msg, Option<Msg> or ().

Stabilisation of issue 391 makes this a compile-time error.

fn clone_app(&self) -> App<Self::AppMs, Self::Mdl, Self::INodes>

Get app instance. Cloning is cheap because App contains only Rc fields.

fn msg_mapper(&self) -> Rc<dyn Fn(Ms) -> Self::AppMs>

Get the function that maps module’s Msg to app’s (root’s) one.

Note: You want to use Orders::msg_sender instead in most cases.

Example

let (app, msg_mapper) = (orders.clone_app(), orders.msg_mapper());
app.update(msg_mapper(Msg::AMessage));

fn after_next_render<MsU: 'static>( &mut self, callback: impl FnOnce(RenderInfo) -> MsU + 'static ) -> &mut Self

Register the callback that will be executed after the next render.

Callback’s only parameter is RenderInfo - it has fields timestamp and timestamp_delta. timestamp_delta is the difference between the old render timestamp and the new one and it has value None if it’s the first rendering.

• It’s useful when you want to use DOM API or make animations.
• You can call this function multiple times - callbacks will be executed in the same order.
• Callback has to return Msg, Option<Msg> or ().

Note: performance.now() is used under the hood to get timestamps.

Panics

Panics when the handler doesn’t return Msg, Option<Msg> or ().

Stabilisation of issue 391 makes this a compile-time error.

fn subscribe<MsU: 'static, SubMs: 'static + Clone>( &mut self, handler: impl FnOnce(SubMs) -> MsU + Clone + 'static ) -> &mut Self

Subscribe for messages with the handlers input type.

Handler has to return Msg, Option<Msg> or ().

Example

orders.subscribe(Msg::Reset);  // `Msg::Reset(counter::DoReset)`
orders.subscribe(|greeting: &'static str| log!(greeting));
orders.subscribe(Msg::UrlChanged)  // `update(... Msg::UrlChanged(subs::UrlChanged(url)) =>`
...
orders.notify(counter::DoReset);
orders.notify("Hello!");

Note:: Use the alternative subscribe_with_handle to control sub’s lifetime.

Panics

Panics when the handler doesn’t return Msg, Option<Msg> or ().

Stabilisation of issue 391 makes this a compile-time error.

fn subscribe_with_handle<MsU: 'static, SubMs: 'static + Clone>( &mut self, handler: impl FnOnce(SubMs) -> MsU + Clone + 'static ) -> SubHandle

Subscribe for messages with the handlers input type.

• Returns SubHandle that you should save to your Model. The sub is cancelled on the handle drop.

Handler has to return Msg, Option<Msg> or ().

Example

let sub_handle = orders.subscribe_with_handle(Msg::Reset);  // `Msg::Reset(counter::DoReset)`
orders.subscribe_with_handle(|greeting: &'static str| log!(greeting));
let url_changed_handle = orders.subscribe_with_handle(Msg::UrlChanged)  // `update(... Msg::UrlChanged(subs::UrlChanged(url)) =>`
...
orders.notify(counter::DoReset);
orders.notify("Hello!");

Panics

Panics when the handler doesn’t return Msg, Option<Msg> or ().

Stabilisation of issue 391 makes this a compile-time error.

fn stream<MsU: 'static>( &mut self, stream: impl Stream<Item = MsU> + 'static ) -> &mut Self

Stream Msg, Option<Msg> or ().

Example

orders.stream(streams::interval(1000, || Msg::OnTick));
orders.stream(streams::window_event(Ev::Resize, |_| Msg::OnResize));

Note:: Use the alternative stream_with_handle to control stream’s lifetime.

Panics

Panics when the handler doesn’t return Msg, Option<Msg> or ().

Stabilisation of issue 391 makes this a compile-time error.

fn stream_with_handle<MsU: 'static>( &mut self, stream: impl Stream<Item = MsU> + 'static ) -> StreamHandle

Stream Msg, Option<Msg> or ().

• Returns StreamHandle that you should save to your Model. The stream is cancelled on the handle drop.

Example

let timer_handler = orders.stream_with_handle(streams::interval(1000, || Msg::OnTick));
let stream_handler = orders.stream_with_handle(streams::window_event(Ev::Resize, |_| Msg::OnResize));

Panics

Panics when the handler doesn’t return Msg, Option<Msg> or ().

Stabilisation of issue 391 makes this a compile-time error.

Provided Methods

fn msg_sender(&self) -> Rc<dyn Fn(Option<Ms>)>

Get the function that invokes your update function. The most common use-case is passing the function into callbacks.

Example

fn create_websocket(orders: &impl Orders<Msg>) -> Result<EventClient, WebSocketError> {
    let msg_sender = orders.msg_sender();

    let mut client = EventClient::new(WS_URL)?;
    client.set_on_message(Some(Box::new(move |_: &EventClient, msg: wasm_sockets::Message|
        decode_message(msg, Rc::clone(&send)),
    )));
    // ...
}

fn decode_message(message: WebSocketMessage, msg_sender: Rc<dyn Fn(Option<Msg>)>) {
    ...
        spawn_local(async move {
            let bytes = message
                .bytes()
                .await
                .expect("WebsocketError on binary data");

            let msg: shared::ServerMessage = rmp_serde::from_slice(&bytes).unwrap();
            msg_sender(Some(Msg::BinaryMessageReceived(msg)));
        });
    ...
}

fn clone_base_path(&self) -> Rc<[String]>

Cheap clone base path loaded from element <base href="/base/path/">.

Returns empty slice if there is no base element in your HTML or there were problems with parsing.

Implementors

impl<'a, Ms, AppMs, Mdl, INodes> Orders<Ms> for OrdersProxy<'a, Ms, AppMs, Mdl, INodes>where Ms: 'static, AppMs: 'static, INodes: IntoNodes<AppMs> + 'static,

type AppMs = AppMs

type Mdl = Mdl

type INodes = INodes

impl<Ms, Mdl, INodes> Orders<Ms> for OrdersContainer<Ms, Mdl, INodes>where Ms: 'static, INodes: IntoNodes<Ms> + 'static,

type AppMs = Ms

type Mdl = Mdl

type INodes = INodes