Provide a way to get blobs as a stream of bytes

[rklaehn]

This is currently already possible via export_bao, but it is a bit convoluted since you need to ignore some of the data.

This should be a stream of Result<Bytes, E> where E is Intoio::Error so it can be used with hyper etc. easily.

[vmx]

That would be really appreciated. I've put together some demo locally that can do a streaming download from iroh from a browser. The browser streams expect a channel to get the data from.

I post the code (not cleaned up) below, so that you can an idea in case it influences the API. Though I think a stream of Result<Bytes, E> should be good.

use wasm_streams::{readable::sys::ReadableStream as JsReadableStream, ReadableStream};
…
    pub async fn download(&self, ticket: String) -> Result<JsReadableStream, JsError> {
        let ticket: BlobTicket = ticket.parse().map_err(to_js_err)?;
        let connection = self.0.endpoint().connect(ticket.addr().id, iroh_blobs::ALPN).await?;
        let mut progress = iroh_blobs::get::request::get_blob(connection, ticket.hash());

        let (mut tx, rx) = mpsc::channel::<Result<JsValue, JsValue>>(1);

        wasm_bindgen_futures::spawn_local(async move {
            loop {
                match progress.next().await {
                    Some(GetBlobItem::Item(item)) => match item {
                        BaoContentItem::Leaf(leaf) => {
                            println!("vmx: data received: {:?}", &leaf.data);
                            tracing::info!("vmx: data received: {:?}", &leaf.data);
                            let js_value = Uint8Array::from(&leaf.data[..]).into();
                            tx.send(Ok(js_value)).await.unwrap();
                        }
                        BaoContentItem::Parent(parent) => {
                            tracing::info!("Parent: {parent:?}");
                        }
                    },
                    Some(GetBlobItem::Done(stats)) => {
                        break;
                    }
                    Some(GetBlobItem::Error(err)) => {
                        return Err(anyhow!("Error while streaming blob: {err}"))
                            .map_err(to_js_err)
                            .expect("vmx: error while streaming blob");
                    }
                    None => {
                        return Err(anyhow!("Stream ended unexpectedly."))
                            .map_err(to_js_err)
                            .expect("vmx: error stream ended");
                    }
                }
            }
        });

        let output_stream = ReadableStream::from_stream(rx).into_raw();
        Ok(output_stream)
    }