How to send message on chunked body responsed?

[chanble]

I can't send message in a stream iter?

 // this code in update function. 
// fn update(&mut self, ctx: &Context<Self>, msg: Self::Message) -> bool {
//     Msg::start => {
ctx.link().send_future(async move {
    let res = HttpImage::pull(image_url.as_str()).await;
    match res {
        HttpResult::Success(body) => match body {
            SuccessBody::Stream(mut stream) => {
                while let Some(chunked_body) = stream.next().await {
                    let chunked = String::from_utf8(
                        Uint8Array::new(&chunked_body.unwrap()).to_vec(),
                    )
                    .expect("vilid utf8 string");
                    log::info!("chunked body : {:?}", chunked);
                    // This is a chunk, but I can't send message, because not return.
                    // Mybe I need `yield Msg::pulling(chunked);` :)
                    // But..
                }
                Msg::Done
            }
        },
        HttpResult::Failed(err) => {
            log::error!("create image reponse err: {}", err);
            Msg::Stop
        }
    }
})

stream from here:

use reqwasm::http::{Request, Response};
use wasm_bindgen::JsCast;
use wasm_streams::{readable::IntoStream, ReadableStream};
pub(crate) async fn get_trunked(resp: Response) -> Result<IntoStream<'static>, String> {
    let raw_body_opt = resp.body();
    if raw_body_opt.is_none() {
        return Err("get trunk body none".to_owned());
    }
    let raw_body = raw_body_opt.unwrap();
    let sys_stream_body = raw_body
        .dyn_into()
        .map_err(|err| format!("get trunk body dyn into err: {:?}", err))?;
    let body = ReadableStream::from_raw(sys_stream_body);

    Ok(body.into_stream())
}

[chanble]

yew agent can do in the while loop like this:

EventBus::dispatcher() .send(SomeMessage);

[laizy]

maybe yew can add a send_stream method, but you can also implement it as a util function.

        pub fn send_stream<S, M>(&self, stream: S)
            where
                M: Into<COMP::Message>,
                S: Stream<Item = M> + 'static,
        {
            let link = self.clone();
            let js_future = async move {
                while let Some(msg) = stream.next().await {
                    let message: COMP::Message = msg.into();
                    link.send_message(message);
                }
            };
            spawn_local(js_future);
        }

[WorldSEnder]

If you mean the nightly Stream for async iterators, that trait has been renamed to AsyncIterator before anyone else is surprised. I like the idea. Would require to introduce a nightly feature toggle before this can be added.