Http2Stream

// Write 'hello, ' and then end with 'world!'.
import fs from 'node:fs';
const file = fs.createWriteStream('example.txt');
file.write('hello, ');
file.end('world!');
// Writing more now is not allowed!

// Write 'hello, ' and then end with 'world!'.
import fs from 'node:fs';
const file = fs.createWriteStream('example.txt');
file.write('hello, ');
file.end('world!');
// Writing more now is not allowed!

// Write 'hello, ' and then end with 'world!'.
import fs from 'node:fs';
const file = fs.createWriteStream('example.txt');
file.write('hello, ');
file.end('world!');
// Writing more now is not allowed!

addListener(event: "aborted", listener: () => void): this

addListener(event: "close", listener: () => void): this

addListener(event: "data", listener: (chunk: NonSharedBuffer | string) => void): this

addListener(event: "drain", listener: () => void): this

addListener(event: "end", listener: () => void): this

addListener(event: "error", listener: (err: Error) => void): this

addListener(event: "finish", listener: () => void): this

addListener(event: "frameError", listener: (frameType: number, errorCode: number, id: number) => void): this

addListener(event: "pipe", listener: (src: stream.Readable) => void): this

addListener(event: "streamClosed", listener: (code: number) => void): this

addListener(event: "timeout", listener: () => void): this

addListener(event: "trailers", listener: (trailers: IncomingHttpHeaders, flags: number) => void): this

addListener(event: "unpipe", listener: (src: stream.Readable) => void): this

addListener(event: "wantTrailers", listener: () => void): this

emit(event: "aborted"): boolean

emit(event: "data", chunk: NonSharedBuffer | string): boolean

emit(event: "frameError", frameType: number, errorCode: number, id: number): boolean

emit(event: "streamClosed", code: number): boolean

emit(event: "timeout"): boolean

emit(event: "trailers", trailers: IncomingHttpHeaders, flags: number): boolean

emit(event: "wantTrailers"): boolean

server.on('connection', (stream) => {
console.log('someone connected!');
});

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a

on(event: "aborted", listener: () => void): this

on(event: "close", listener: () => void): this

on(event: "data", listener: (chunk: NonSharedBuffer | string) => void): this

on(event: "drain", listener: () => void): this

on(event: "end", listener: () => void): this

on(event: "error", listener: (err: Error) => void): this

on(event: "finish", listener: () => void): this

on(event: "frameError", listener: (frameType: number, errorCode: number, id: number) => void): this

on(event: "pipe", listener: (src: stream.Readable) => void): this

on(event: "streamClosed", listener: (code: number) => void): this

on(event: "timeout", listener: () => void): this

on(event: "trailers", listener: (trailers: IncomingHttpHeaders, flags: number) => void): this

on(event: "unpipe", listener: (src: stream.Readable) => void): this

on(event: "wantTrailers", listener: () => void): this

server.once('connection', (stream) => {
console.log('Ah, we have our first user!');
});

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a

once(event: "aborted", listener: () => void): this

once(event: "close", listener: () => void): this

once(event: "data", listener: (chunk: NonSharedBuffer | string) => void): this

once(event: "drain", listener: () => void): this

once(event: "end", listener: () => void): this

once(event: "error", listener: (err: Error) => void): this

once(event: "finish", listener: () => void): this

once(event: "frameError", listener: (frameType: number, errorCode: number, id: number) => void): this

once(event: "pipe", listener: (src: stream.Readable) => void): this

once(event: "streamClosed", listener: (code: number) => void): this

once(event: "timeout", listener: () => void): this

once(event: "trailers", listener: (trailers: IncomingHttpHeaders, flags: number) => void): this

once(event: "unpipe", listener: (src: stream.Readable) => void): this

once(event: "wantTrailers", listener: () => void): this

const readable = getReadableStreamSomehow();
readable.on('data', (chunk) => {
console.log(`Received ${chunk.length} bytes of data.`);
readable.pause();
console.log('There will be no additional data for 1 second.');
setTimeout(() => {
console.log('Now data will start flowing again.');
readable.resume();
}, 1000);
});

server.prependListener('connection', (stream) => {
console.log('someone connected!');
});

prependListener(event: "aborted", listener: () => void): this

prependListener(event: "close", listener: () => void): this

prependListener(event: "data", listener: (chunk: NonSharedBuffer | string) => void): this

prependListener(event: "drain", listener: () => void): this

prependListener(event: "end", listener: () => void): this

prependListener(event: "error", listener: (err: Error) => void): this

prependListener(event: "finish", listener: () => void): this

prependListener(event: "frameError", listener: (frameType: number, errorCode: number, id: number) => void): this

prependListener(event: "pipe", listener: (src: stream.Readable) => void): this

prependListener(event: "streamClosed", listener: (code: number) => void): this

prependListener(event: "timeout", listener: () => void): this

prependListener(event: "trailers", listener: (trailers: IncomingHttpHeaders, flags: number) => void): this

prependListener(event: "unpipe", listener: (src: stream.Readable) => void): this

prependListener(event: "wantTrailers", listener: () => void): this

server.prependOnceListener('connection', (stream) => {
console.log('Ah, we have our first user!');
});

prependOnceListener(event: "aborted", listener: () => void): this

prependOnceListener(event: "close", listener: () => void): this

prependOnceListener(event: "data", listener: (chunk: NonSharedBuffer | string) => void): this

prependOnceListener(event: "drain", listener: () => void): this

prependOnceListener(event: "end", listener: () => void): this

prependOnceListener(event: "error", listener: (err: Error) => void): this

prependOnceListener(event: "finish", listener: () => void): this

prependOnceListener(event: "frameError", listener: (frameType: number, errorCode: number, id: number) => void): this

prependOnceListener(event: "pipe", listener: (src: stream.Readable) => void): this

prependOnceListener(event: "streamClosed", listener: (code: number) => void): this

prependOnceListener(event: "timeout", listener: () => void): this

prependOnceListener(event: "trailers", listener: (trailers: IncomingHttpHeaders, flags: number) => void): this

prependOnceListener(event: "unpipe", listener: (src: stream.Readable) => void): this

prependOnceListener(event: "wantTrailers", listener: () => void): this

const callback = (stream) => {
console.log('someone connected!');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);

import { EventEmitter } from 'node:events';
class MyEmitter extends EventEmitter {}
const myEmitter = new MyEmitter();

const callbackA = () => {
console.log('A');
myEmitter.removeListener('event', callbackB);
};

const callbackB = () => {
console.log('B');
};

myEmitter.on('event', callbackA);

myEmitter.on('event', callbackB);

// callbackA removes listener callbackB but it will still be called.
// Internal listener array at time of emit [callbackA, callbackB]
myEmitter.emit('event');
// Prints:
//   A
//   B

// callbackB is now removed.
// Internal listener array [callbackA]
myEmitter.emit('event');
// Prints:
//   A

import { EventEmitter } from 'node:events';
const ee = new EventEmitter();

function pong() {
console.log('pong');
}

ee.on('ping', pong);
ee.once('ping', pong);
ee.removeListener('ping', pong);

ee.emit('ping');
ee.emit('ping');

removeListener(event: "close", listener: () => void): this

removeListener(event: "data", listener: (chunk: any) => void): this

removeListener(event: "drain", listener: () => void): this

removeListener(event: "end", listener: () => void): this

removeListener(event: "error", listener: (err: Error) => void): this

removeListener(event: "finish", listener: () => void): this

removeListener(event: "pause", listener: () => void): this

removeListener(event: "pipe", listener: (src: Readable) => void): this

removeListener(event: "readable", listener: () => void): this

removeListener(event: "resume", listener: () => void): this

removeListener(event: "unpipe", listener: (src: Readable) => void): this

getReadableStreamSomehow()
.resume()
.on('end', () => {
console.log('Reached the end, but did not read anything.');
});

import http2 from 'node:http2';
const server = http2.createServer();
server.on('stream', (stream) => {
stream.respond(undefined, { waitForTrailers: true });
stream.on('wantTrailers', () => {
stream.sendTrailers({ xyz: 'abc' });
});
stream.end('Hello World');
});

const readable = getReadableStreamSomehow();
readable.setEncoding('utf8');
readable.on('data', (chunk) => {
assert.equal(typeof chunk, 'string');
console.log('Got %d characters of string data:', chunk.length);
});

import http2 from 'node:http2';
const client = http2.connect('http://example.org:8000');
const { NGHTTP2_CANCEL } = http2.constants;
const req = client.request({ ':path': '/' });

// Cancel the stream if there's no activity after 5 seconds
req.setTimeout(5000, () => req.close(NGHTTP2_CANCEL));

import fs from 'node:fs';
const readable = getReadableStreamSomehow();
const writable = fs.createWriteStream('file.txt');
// All the data from readable goes into 'file.txt',
// but only for the first second.
readable.pipe(writable);
setTimeout(() => {
console.log('Stop writing to file.txt.');
readable.unpipe(writable);
console.log('Manually close the file stream.');
writable.end();
}, 1000);

import { OldReader } from './old-api-module.js';
import { Readable } from 'node:stream';
const oreader = new OldReader();
const myReader = new Readable().wrap(oreader);

myReader.on('readable', () => {
myReader.read(); // etc.
});