Streamx-webstream NPM

streamx-webstream

A toWeb/fromWeb wrapper for streamx streams.

Object mode not supported.

Support the cause towards decentralization

bitcoin: bc1q9fpu6muvmg5fj76pyzg3ffjrmksnvfj3c0xva6

Installation

npm install streamx-webstream --save

Import

import {fromWeb, toWeb} from "streamx-webstream";

// or treeshake

import {fromWeb} from "streamx-webstream/from";

// or treeshake

import {toWeb} from "streamx-webstream/to";

// or CDN (and can tree shake that too) 

import {fromWeb, toWeb} from "https://esm.run/streamx-webstream";

`fromWeb(webReadableStream, [options])`

writev not supported at the moment

options.write

Pass to the write option a write function to become a streamx.duplex.
Pass to the write option an unlocked WritableStream (WebAPI) and the streamx.duplex will proxy writes to the WritableStream (WebAPI)
Don't pass write option and the stream will be just a streamx.Readable

options.asTransform

If set to true, in all cases where a duplex would be made via options.write will be a transform instead.

For all other options: see options

`fromWeb({readable, writable}, [options])`

An alternative syntax of fromWeb. When writable is supplied, the options.write is ignored.

Writable can also be a write function.

fromWeb readable example:

import { fromWeb } from "streamx-webstream";
import b4a from "b4a";

const readableWebStream = new ReadableStream({
    start(controller) {
        controller.enqueue(b4a.from("hello"));
        controller.enqueue(b4a.from("world"));
        controller.close();
    }
});

const buffered = [];

// Creates a lock on the readable web stream
const readableStreamX = fromWeb(readableWebStream, {
    // Add whatever streamx options you want.
    map(buffer) {
        return b4a.toString(buffer);
    },
    //write(value, cb) {
    // Adding a write function turns the returned stream into a duplex. 
    //}
});

readableStreamX.on("data", string => {
    buffered.push(string);
});

readableStreamX.once("close", () => {
    console.log(buffered); // hello, world 
});

// You have to make sure the underlying web stream is 
// unlocked even if streamx is already destroyed unless you 
// don't plan on using it again.
await readableStreamX.close();

`toWeb(streamxReadableOrObject)`

writev not supported at the moment

streamxReadableOrObject

Pass a streamx.Readable and get a ReadableStream (WebAPI)
Pass an object with the following options:
- readable: streamx.Readable
- writable: streamx.Writable
- duplex: streamx.Duplex - Will be ignored if either readable or writable option is defined. You could also pass a streamx.Transform here.

returns

If a streamx.Duplex OR a pair streamx.Readable and streamx.Writable is supplied will return an object with WebAPI counterparts in this format: { readable, writable }
If a streamx.Readable is supplied by itself, will return ReadableStream (WebAPI).
If a streamx.Writable is suppled by itself, will return WritableStream (WebAPI).

toWeb Simple readable example:

import { toWeb } from "streamx-webstream";
import { Readable } from "streamx";
import b4a from "b4a";

const buffered = [];
const readable = new Readable();
readable.push('hello');
readable.push('world');
readable.push(null);

const webStreamReadable = toWeb(readable);
const reader = webStreamReadable.getReader();

while(true) {
    const {value, done} = await reader.read();
    if (value) buffered.push(b4a.toString(value));
    if (done) break;
}

console.log(buffered); // hello, world

toWeb Duplex example:

const duplex = new Duplex({
    read(cb) {
        // read logic
    },
    write(data, cb) {
        // write logic
    }
});

const {readable, writable} = toWeb({duplex});

// Do webApi stuff with the readable and writable.
const writer = writable.getWriter();
const reader = readable.getReader();

toWeb Just write example:

const duplex = new Duplex({
    write(data, cb) {
        // write logic
    }
});

const writable = toWeb({writable: duplex});

// Do webApi stuff with the writable.
const writer = writable.getWriter();