import assert from 'assert';
import {Readable, PassThrough} from 'stream';
import {text, json, buffer, arrayBuffer} from 'stream/consumers';
class TimestampSource {
#interval
#counter = 0
start(controller) {
this.#interval = setInterval(() => {
const string = `${this.#counter}`
controller.enqueue(string);
this.#counter++;
console.log(`Enqueued ${string}`);
}, 1_000);
setTimeout(() => {
clearInterval(this.#interval);
controller.close();
}, 10_000);
}
cancel() {
clearInterval(this.#interval);
}
}
async function concatStringStream(stream) {
let result = '';
const reader = stream.getReader();
while (true) {
const {done, value} = await reader.read();
if (done) return result;
result += value;
console.log(`Read ${result.length} characters so far`);
console.log(`Most recently read chunk: ${value}`);
}
}
async function test1Impl() {
const stream = new ReadableStream(new TimestampSource());
concatStringStream(stream).then((result) => console.log('Stream complete', result));
}
export const test1 = test1Impl;
export async function testNodeStream1() {
async function readableToString2(readable) {
let result = '';
for await (const chunk of readable) {
result += chunk;
}
return result;
}
const readable = Readable.from('Good morning!', {encoding: 'utf8'});
return await readableToString2(readable);
}
export async function testConsumersText() {
const readable = Readable.from('hello world', {encoding: 'utf8'});
return await text(readable);
}
export async function testConsumersJson() {
const readable = Readable.from('{"key":"value"}', {encoding: 'utf8'});
const obj = await json(readable);
return JSON.stringify(obj);
}
export async function testConsumersBuffer() {
const readable = Readable.from('hello', {encoding: 'utf8'});
const buf = await buffer(readable);
return buf.byteLength;
}
export async function testConsumersArraybuffer() {
const readable = Readable.from('hello', {encoding: 'utf8'});
const ab = await arrayBuffer(readable);
return ab.byteLength;
}
import { Writable, Duplex } from 'stream';
export async function testReadableFromWeb() {
const webStream = new ReadableStream({
start(controller) {
controller.enqueue(new TextEncoder().encode('hello '));
controller.enqueue(new TextEncoder().encode('from web'));
controller.close();
}
});
const nodeReadable = Readable.fromWeb(webStream);
let result = '';
for await (const chunk of nodeReadable) {
if (typeof chunk === 'string') {
result += chunk;
} else {
result += new TextDecoder().decode(chunk);
}
}
return result;
}
export async function testReadableToWeb() {
const nodeReadable = Readable.from(['hello ', 'to web'], { encoding: 'utf8' });
const webStream = Readable.toWeb(nodeReadable);
const reader = webStream.getReader();
let result = '';
while (true) {
const { done, value } = await reader.read();
if (done) break;
if (typeof value === 'string') {
result += value;
} else {
result += new TextDecoder().decode(value);
}
}
return result;
}
export async function testWritableFromWeb() {
const chunks = [];
const webStream = new WritableStream({
write(chunk) {
chunks.push(chunk);
}
});
const nodeWritable = Writable.fromWeb(webStream);
await new Promise((resolve, reject) => {
nodeWritable.write('hello ', (err) => {
if (err) reject(err);
nodeWritable.write('from web', (err) => {
if (err) reject(err);
nodeWritable.end(() => resolve());
});
});
});
const decoder = new TextDecoder();
return chunks.map(c => {
if (typeof c === 'string') return c;
if (c instanceof Uint8Array || ArrayBuffer.isView(c)) return decoder.decode(c);
return String(c);
}).join('');
}
export async function testWritableToWeb() {
let result = '';
const nodeWritable = new Writable({
write(chunk, encoding, callback) {
result += chunk.toString();
callback();
}
});
const webStream = Writable.toWeb(nodeWritable);
const writer = webStream.getWriter();
await writer.write(new TextEncoder().encode('hello '));
await writer.write(new TextEncoder().encode('to web'));
await writer.close();
return result;
}
export async function testDuplexFromWeb() {
const spoofedReadable = new Readable({
read() { },
readableObjectMode: true,
}, true);
assert.strictEqual(spoofedReadable.readableObjectMode, false);
const spoofedWritable = new Writable({
write(_chunk, _encoding, callback) { callback(); },
writableObjectMode: true,
}, true);
assert.strictEqual(spoofedWritable.writableObjectMode, false);
const FakeDuplex = class Duplex extends Readable {};
const controller = new AbortController();
const fakeDuplex = new FakeDuplex({
readableObjectMode: true,
signal: controller.signal,
});
assert.strictEqual(fakeDuplex.readableObjectMode, false);
controller.abort();
assert.strictEqual(fakeDuplex.destroyed, true);
assert.strictEqual(fakeDuplex.errored?.name, 'AbortError');
const duplexNameDescriptor = Object.getOwnPropertyDescriptor(Duplex, 'name');
try {
Object.defineProperty(Duplex, 'name', {
...duplexNameDescriptor,
value: 'RenamedDuplex',
});
const renamedDuplex = new Duplex({
readableObjectMode: true,
writableObjectMode: true,
});
assert.strictEqual(renamedDuplex.readableObjectMode, true);
assert.strictEqual(renamedDuplex.writableObjectMode, true);
} finally {
Object.defineProperty(Duplex, 'name', duplexNameDescriptor);
}
const written = [];
const { readable, writable } = new TransformStream({
transform(chunk, controller) {
const text = new TextDecoder().decode(chunk);
controller.enqueue(new TextEncoder().encode('echo:' + text));
}
});
const duplex = Duplex.fromWeb({ readable, writable });
duplex.write(new TextEncoder().encode('hello'));
duplex.end();
let result = '';
for await (const chunk of duplex) {
if (typeof chunk === 'string') {
result += chunk;
} else {
result += new TextDecoder().decode(chunk);
}
}
return result;
}