Bad/redundant methods for Blob

[Pauan]

Right now there's a whole bunch of methods for creating a new Blob:

new_with_buffer_source_sequence
new_with_u8_array_sequence
new_with_blob_sequence
new_with_str_sequence
new_with_buffer_source_sequence_and_options
new_with_u8_array_sequence_and_options
new_with_blob_sequence_and_options
new_with_str_sequence_and_options

These multiple methods exist because new Blob accepts multiple different types, and so web-sys generates one method per type.

However, these multiple methods are completely useless, because they all compile down to new Blob on the JS side, and they have the same type on the Rust side. This has caused confusion for users.

I see two options:

1. Remove them and just have two methods: Blob::new_with_array and Blob::new_with_array_and_options which accept &Array

2. Keep them but change their type to be more useful. For example, new_with_u8_array_sequence could accept a &[u8], new_with_blob_sequence could accept a &Blob, etc.

   Because new Blob accepts 14 different Rust types, that would mean we would need 28 different methods with this approach.

I personally lean toward option 1.

[alexcrichton]

It'd be great if we could automatically fixup methods in the WebIDL generator, it's true that we don't really need quite so many methods all doing the same thing!

[RReverser]

Keep them but change their type to be more useful. For example, new_with_u8_array_sequence could accept a &[u8], new_with_blob_sequence could accept a &Blob, etc.

Note that this is not really an option, because all of these still need to be wrapped into an Array - new Blob doesn't accept byte slice / other blob / etc. directly.

[Pauan]

@RReverser They could automatically create the Array internally, but yeah I prefer option 1.

[NickHu]

I ran into this too. Perhaps at the very least it could be mentioned in the documentation that all the methods are identical.

[foopub]

How does instantiating a blob from u8 array (bytes) work?

I tried doing something similar to this
https://github.com/rustwasm/wasm-bindgen/blob/master/crates/web-sys/tests/wasm/blob.rs
but the new_with_u8... method seems do something weird where bytes over 15 increase the size by 2, so this will fail:

    let bytes = Array::new();
    bytes.push(&1.into());
    bytes.push(&2.into());
    bytes.push(&16.into()); //99 also gives 4 but 100 gives 5. 


    let blob = Blob::new_with_u8_array_sequence(&bytes.into()).unwrap();
    assert_eq!(blob.size(), 3.0); //size is actually 4

giving a size of 4 instead...
I also tried using _with_options variant and passing some MIME types but same problem occurs. Using File::new_from_u8... has similar result, tho converting between the two (blob: Blob = some_file.into()) works fine.

As a concrete example, what I'm attempting is to do is convert an image file to bytes vec (no problems here) then back to an image but the blobs come out with ~2.5 times the size and obviously broken.

[Pauan]

@foopub You have to convert the bytes into a Uint8Array:

let bytes = Array::new();
bytes.push(&Uint8Array::from(&[...]));

let blob = Blob::new_with_u8_array_sequence(&bytes).unwrap();

This is because new Blob only accepts ArrayBuffer, ArrayBufferView, Blob, or String.

You're trying to push numbers into the Array, which won't work. But Uint8Array is an ArrayBufferView, so it will work.

However, an even better option is to use the gloo_file crate, which has a Blob::new method, so you can just do Blob::new(&[...])

[foopub]

@Pauan thank you for the explanation!

[Maximkaaa]

Thank you, @Pauan , for this. I wish it was mentioned somewhere in the Blob documentation. It would have saved a few hours of my life...