Convert from/to native streams?

[MattiasBuelens]

Right now, this project is just a polyfill: it implements the streams specification, and that's it. In reality though, you may need to inter-operate with non-polyfilled streams, e.g. when using web APIs that consume or produce native streams. In that case, you need a way to convert between native streams and polyfilled streams.

web-streams-adapter provides a low-level API to do such conversions between any stream implementation. For this polyfill, it might be interesting to provide an easier way to convert from/to a polyfilled stream.

These could be provided as static utility methods:

ReadableStream.from(stream: ReadableStreamLike): ReadableStream;
ReadableStream.toNative(stream: ReadableStream): typeof window.ReadableStream;

or exported separately:

export function fromReadableStream(stream: ReadableStreamLike): ReadableStream;
export function toNativeReadableStream(stream: ReadableStream): typeof window.ReadableStream;

Any thoughts on this API?

[MattiasBuelens]

Some more thoughts on this...

Right now, the polyfill always replaces the global stream implementations. However, if the native implementation were fully spec-compliant, the polyfill should detect this and simply use the native implementation. (At the moment, Chrome 68 is the closest to full compliance, supporting everything except for readable byte streams.)

If the polyfill would re-export the native implementation, then we can't provide ReadableStream.from without mutating the global ReadableStream. Therefore, we should not use static utility methods.

[jimmywarting]

Looks like the spec is planing on adding ReadableStream.from(iterable) now as well.

It could serve as a grate utility to convert the polyfill stream to/from a native one (until you are using native streams - #20)

maybe could have two implementation in the meanwhile?

• window.ReadableStream.from(iterable) // converts iterable to native
• polyfill.ReadableStream.from(iterable) // converts iterable to polyfilled version

all doe the later one would quickly be obsolete when you are using native streams.
the native ReadableStream would also need asyncIterable to work...

[MattiasBuelens]

Good idea! 👍

Indeed, if ReadableStream.from() becomes a thing, the polyfill can provide a version which also handles conversions. Aside from accepting an (async) iterable, it could also accept a native ReadableStream (even if the native stream is not async iterable itself).

I'll keep it in mind when I (eventually) get to this. Right now, I'm keeping an eye on the ongoing work for converting the spec to WebIDL, in particular on the functional changes that will be needed for the polyfill... 👀

[jimmywarting]

Hi, any progress on implementing ReadableStream.from?
I rather prefer using ReadableStream.from(iterable) rather than having to use NodeJS specific stream.Readable.toWeb()

using NodeJS specific things makes my code less cross env compatible with other runtimes.

[MattiasBuelens]

@jimmywarting Sorry for the long delay! I finally implemented ReadableStream.from(), it'll come in a 3.3.0 release very soon. 😁

As for the next branch, I decided to restart from scratch. I got sidetracked trying to make every polyfill method be compatible with any stream implementation (see #122). And because I got stuck on that, I never actually made a new release in over a year...

So I came up with a new plan:

• Make a 3.3.0 release, bringing in all non-breaking changes from the next branch and getting it fully up-to-date with the latest Streams specification (done in Update to spec version of 13 November 2023 #134).
• Make a 4.0.0 release on top of that with only the breaking changes (which basically means porting Rework variants to reduce bundle size #83).

Hopefully I should get that out of the door in a shorter timeframe. 😅