TestsStream

addListener(event: "test:complete", listener: (data: EventData.TestComplete) => void): this

addListener(event: "test:coverage", listener: (data: EventData.TestCoverage) => void): this

addListener(event: "test:dequeue", listener: (data: EventData.TestDequeue) => void): this

addListener(event: "test:diagnostic", listener: (data: EventData.TestDiagnostic) => void): this

addListener(event: "test:enqueue", listener: (data: EventData.TestEnqueue) => void): this

addListener(event: "test:fail", listener: (data: EventData.TestFail) => void): this

addListener(event: "test:pass", listener: (data: EventData.TestPass) => void): this

addListener(event: "test:plan", listener: (data: EventData.TestPlan) => void): this

addListener(event: "test:start", listener: (data: EventData.TestStart) => void): this

addListener(event: "test:stderr", listener: (data: EventData.TestStderr) => void): this

addListener(event: "test:stdout", listener: (data: EventData.TestStdout) => void): this

addListener(event: "test:summary", listener: (data: EventData.TestSummary) => void): this

addListener(event: "test:watch:drained", listener: () => void): this

emit(event: "test:complete", data: EventData.TestComplete): boolean

emit(event: "test:coverage", data: EventData.TestCoverage): boolean

emit(event: "test:dequeue", data: EventData.TestDequeue): boolean

emit(event: "test:diagnostic", data: EventData.TestDiagnostic): boolean

emit(event: "test:enqueue", data: EventData.TestEnqueue): boolean

emit(event: "test:fail", data: EventData.TestFail): boolean

emit(event: "test:pass", data: EventData.TestPass): boolean

emit(event: "test:plan", data: EventData.TestPlan): boolean

emit(event: "test:start", data: EventData.TestStart): boolean

emit(event: "test:stderr", data: EventData.TestStderr): boolean

emit(event: "test:stdout", data: EventData.TestStdout): boolean

emit(event: "test:summary", data: EventData.TestSummary): boolean

emit(event: "test:watch:drained"): 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: "test:complete", listener: (data: EventData.TestComplete) => void): this

on(event: "test:coverage", listener: (data: EventData.TestCoverage) => void): this

on(event: "test:dequeue", listener: (data: EventData.TestDequeue) => void): this

on(event: "test:diagnostic", listener: (data: EventData.TestDiagnostic) => void): this

on(event: "test:enqueue", listener: (data: EventData.TestEnqueue) => void): this

on(event: "test:fail", listener: (data: EventData.TestFail) => void): this

on(event: "test:pass", listener: (data: EventData.TestPass) => void): this

on(event: "test:plan", listener: (data: EventData.TestPlan) => void): this

on(event: "test:start", listener: (data: EventData.TestStart) => void): this

on(event: "test:stderr", listener: (data: EventData.TestStderr) => void): this

on(event: "test:stdout", listener: (data: EventData.TestStdout) => void): this

on(event: "test:summary", listener: (data: EventData.TestSummary) => void): this

on(event: "test:watch:drained", 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: "test:complete", listener: (data: EventData.TestComplete) => void): this

once(event: "test:coverage", listener: (data: EventData.TestCoverage) => void): this

once(event: "test:dequeue", listener: (data: EventData.TestDequeue) => void): this

once(event: "test:diagnostic", listener: (data: EventData.TestDiagnostic) => void): this

once(event: "test:enqueue", listener: (data: EventData.TestEnqueue) => void): this

once(event: "test:fail", listener: (data: EventData.TestFail) => void): this

once(event: "test:pass", listener: (data: EventData.TestPass) => void): this

once(event: "test:plan", listener: (data: EventData.TestPlan) => void): this

once(event: "test:start", listener: (data: EventData.TestStart) => void): this

once(event: "test:stderr", listener: (data: EventData.TestStderr) => void): this

once(event: "test:stdout", listener: (data: EventData.TestStdout) => void): this

once(event: "test:summary", listener: (data: EventData.TestSummary) => void): this

once(event: "test:watch:drained", 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: "test:complete", listener: (data: EventData.TestComplete) => void): this

prependListener(event: "test:coverage", listener: (data: EventData.TestCoverage) => void): this

prependListener(event: "test:dequeue", listener: (data: EventData.TestDequeue) => void): this

prependListener(event: "test:diagnostic", listener: (data: EventData.TestDiagnostic) => void): this

prependListener(event: "test:enqueue", listener: (data: EventData.TestEnqueue) => void): this

prependListener(event: "test:fail", listener: (data: EventData.TestFail) => void): this

prependListener(event: "test:pass", listener: (data: EventData.TestPass) => void): this

prependListener(event: "test:plan", listener: (data: EventData.TestPlan) => void): this

prependListener(event: "test:start", listener: (data: EventData.TestStart) => void): this

prependListener(event: "test:stderr", listener: (data: EventData.TestStderr) => void): this

prependListener(event: "test:stdout", listener: (data: EventData.TestStdout) => void): this

prependListener(event: "test:summary", listener: (data: EventData.TestSummary) => void): this

prependListener(event: "test:watch:drained", listener: () => void): this

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

prependOnceListener(event: "test:complete", listener: (data: EventData.TestComplete) => void): this

prependOnceListener(event: "test:coverage", listener: (data: EventData.TestCoverage) => void): this

prependOnceListener(event: "test:dequeue", listener: (data: EventData.TestDequeue) => void): this

prependOnceListener(event: "test:diagnostic", listener: (data: EventData.TestDiagnostic) => void): this

prependOnceListener(event: "test:enqueue", listener: (data: EventData.TestEnqueue) => void): this

prependOnceListener(event: "test:fail", listener: (data: EventData.TestFail) => void): this

prependOnceListener(event: "test:pass", listener: (data: EventData.TestPass) => void): this

prependOnceListener(event: "test:plan", listener: (data: EventData.TestPlan) => void): this

prependOnceListener(event: "test:start", listener: (data: EventData.TestStart) => void): this

prependOnceListener(event: "test:stderr", listener: (data: EventData.TestStderr) => void): this

prependOnceListener(event: "test:stdout", listener: (data: EventData.TestStdout) => void): this

prependOnceListener(event: "test:summary", listener: (data: EventData.TestSummary) => void): this

prependOnceListener(event: "test:watch:drained", 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: "end", listener: () => void): this

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

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

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

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

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

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 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.
});