Thread

Defined in: src/models/thread.ts:71

Extends

ReadReceipt<ThreadEmittedEvents, ThreadEventHandlerMap>

Constructors

Constructor

new Thread(id, rootEvent, opts): Thread

Defined in: src/models/thread.ts:142

Parameters

id

string

rootEvent

DigitalWorldEvent | undefined

opts

IThreadOpts

Returns

Thread

Overrides

ReadReceipt<ThreadEmittedEvents, ThreadEventHandlerMap>.constructor

Properties

client

readonly client: DigitalWorldClient

Defined in: src/models/thread.ts:124

id

readonly id: string

Defined in: src/models/thread.ts:143

initialEventsFetched

initialEventsFetched: boolean = !Thread.hasServerSideSupport

Defined in: src/models/thread.ts:133

Whether or not we need to fetch the initial set of events for the thread. We can only do this if the server has support for it, so if it doesn’t we just pretend that we’ve already fetched them.

replayEvents

replayEvents: DigitalWorldEvent[] | null = []

Defined in: src/models/thread.ts:140

An array of events to add to the timeline once the thread has been initialised with server suppport.

room

readonly room: Room

Defined in: src/models/thread.ts:123

rootEvent

rootEvent: DigitalWorldEvent | undefined

Defined in: src/models/thread.ts:144

timelineSet

readonly timelineSet: EventTimelineSet

Defined in: src/models/thread.ts:79

A reference to all the events ID at the bottom of the threads

captureRejections

static captureRejections: boolean

Defined in: node_modules/.pnpm/@types+node@22.20.0/node_modules/@types/node/events.d.ts:425

Value: boolean

Change the default captureRejections option on all new EventEmitter objects.

Since

v13.4.0, v12.16.0

Inherited from

ReadReceipt.captureRejections

captureRejectionSymbol

readonly static captureRejectionSymbol: typeof captureRejectionSymbol

Defined in: node_modules/.pnpm/@types+node@22.20.0/node_modules/@types/node/events.d.ts:418

Value: Symbol.for('nodejs.rejection')

See how to write a custom rejection handler.

Since

v13.4.0, v12.16.0

Inherited from

ReadReceipt.captureRejectionSymbol

defaultMaxListeners

static defaultMaxListeners: number

Defined in: node_modules/.pnpm/@types+node@22.20.0/node_modules/@types/node/events.d.ts:464

By default, a maximum of 10 listeners can be registered for any single event. This limit can be changed for individual EventEmitter instances using the emitter.setMaxListeners(n) method. To change the default for allEventEmitter instances, the events.defaultMaxListeners property can be used. If this value is not a positive number, a RangeError is thrown.

Take caution when setting the events.defaultMaxListeners because the change affects all EventEmitter instances, including those created before the change is made. However, calling emitter.setMaxListeners(n) still has precedence over events.defaultMaxListeners.

This is not a hard limit. The EventEmitter instance will allow more listeners to be added but will output a trace warning to stderr indicating that a “possible EventEmitter memory leak” has been detected. For any single EventEmitter, the emitter.getMaxListeners() and emitter.setMaxListeners() methods can be used to temporarily avoid this warning:

import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.setMaxListeners(emitter.getMaxListeners() + 1);
emitter.once('event', () => {
  // do stuff
  emitter.setMaxListeners(Math.max(emitter.getMaxListeners() - 1, 0));
});

The --trace-warnings command-line flag can be used to display the stack trace for such warnings.

The emitted warning can be inspected with process.on('warning') and will have the additional emitter, type, and count properties, referring to the event emitter instance, the event’s name and the number of attached listeners, respectively. Its name property is set to 'MaxListenersExceededWarning'.

Since

v0.11.2

Inherited from

ReadReceipt.defaultMaxListeners

errorMonitor

readonly static errorMonitor: typeof errorMonitor

Defined in: node_modules/.pnpm/@types+node@22.20.0/node_modules/@types/node/events.d.ts:411

This symbol shall be used to install a listener for only monitoring 'error' events. Listeners installed using this symbol are called before the regular 'error' listeners are called.

Installing a listener using this symbol does not change the behavior once an 'error' event is emitted. Therefore, the process will still crash if no regular 'error' listener is installed.

Since

v13.6.0, v12.17.0

Inherited from

ReadReceipt.errorMonitor

hasServerSideFwdPaginationSupport

static hasServerSideFwdPaginationSupport: FeatureSupport = FeatureSupport.None

Defined in: src/models/thread.ts:74

hasServerSideListSupport

static hasServerSideListSupport: FeatureSupport = FeatureSupport.None

Defined in: src/models/thread.ts:73

hasServerSideSupport

static hasServerSideSupport: FeatureSupport = FeatureSupport.None

Defined in: src/models/thread.ts:72

Accessors

events

Get Signature

get events(): DigitalWorldEvent[]

Defined in: src/models/thread.ts:754

Returns

DigitalWorldEvent[]

hasCurrentUserParticipated

Get Signature

get hasCurrentUserParticipated(): boolean

Defined in: src/models/thread.ts:762

Returns

boolean

length

Get Signature

get length(): number

Defined in: src/models/thread.ts:732

The number of messages in the thread Only count rel_type=m.thread as we want to exclude annotations from that number

Returns

number

liveTimeline

Get Signature

get liveTimeline(): EventTimeline

Defined in: src/models/thread.ts:766

Returns

EventTimeline

replyToEvent

Get Signature

get replyToEvent(): DigitalWorldEvent | null

Defined in: src/models/thread.ts:740

A getter for the last event of the thread. This might be a synthesized event, if so, it will not emit any events to listeners.

Returns

DigitalWorldEvent | null

roomId

Get Signature

get roomId(): string

Defined in: src/models/thread.ts:723

Returns

string

roomState

Get Signature

get roomState(): RoomState

Defined in: src/models/thread.ts:309

Returns

RoomState

timeline

Get Signature

get timeline(): DigitalWorldEvent[]

Defined in: src/models/thread.ts:750

The live event timeline for this thread.

Returns

DigitalWorldEvent[]

The live event timeline for this thread.

Overrides

ReadReceipt.timeline

Methods

[captureRejectionSymbol]()?

optional [captureRejectionSymbol]<K>(error, event, …args): void

Defined in: node_modules/.pnpm/@types+node@22.20.0/node_modules/@types/node/events.d.ts:103

Type Parameters

K

K

Parameters

error

Error

event

string | symbol

args

…AnyRest

Returns

void

Inherited from

ReadReceipt.[captureRejectionSymbol]

addEvent()

addEvent(event, toStartOfTimeline, emit?): void

Defined in: src/models/thread.ts:363

Add an event to the thread and updates the tail/root references if needed Will fire “Thread.update”

Parameters

event

DigitalWorldEvent

The event to add

toStartOfTimeline

boolean

whether the event is being added to the start (and not the end) of the timeline.

emit?

boolean = true

whether to emit the Update event if the thread was updated or not.

Returns

void

addEvents()

addEvents(events, toStartOfTimeline): void

Defined in: src/models/thread.ts:349

Parameters

events

DigitalWorldEvent[]

toStartOfTimeline

boolean

Returns

void

addListener()

addListener<T>(event, listener): this

Defined in: src/models/typed-event-emitter.ts:70

Alias for on.

Type Parameters

T

T extends EventEmitterEvents | ThreadEmittedEvents

Parameters

event

T

listener

Listener<ThreadEmittedEvents, ThreadEventHandlerMap, T>

Returns

this

Inherited from

ReadReceipt.addListener

addLocalEchoReceipt()

addLocalEchoReceipt(userId, e, receiptType, unthreaded?): void

Defined in: src/models/read-receipt.ts:383

Add a temporary local-echo receipt to the room to reflect in the client the fact that we’ve sent one.

Parameters

userId

string

The user ID if the receipt sender

e

DigitalWorldEvent

The event that is to be acknowledged

receiptType

ReceiptType

The type of receipt

unthreaded?

boolean = false

the receipt is unthreaded

Returns

void

Inherited from

ReadReceipt.addLocalEchoReceipt

addReceipt()

addReceipt(event, synthetic): void

Defined in: src/models/thread.ts:774

Parameters

event

DigitalWorldEvent

synthetic

boolean

Returns

void

Overrides

ReadReceipt.addReceipt

addReceiptToStructure()

addReceiptToStructure(eventId, receiptType, userId, receipt, synthetic): void

Defined in: src/models/read-receipt.ts:242

Parameters

eventId

string

receiptType

ReceiptType

userId

string

receipt

Receipt

synthetic

boolean

Returns

void

Inherited from

ReadReceipt.addReceiptToStructure

clearEventMetadata()

clearEventMetadata(event): void

Defined in: src/models/thread.ts:694

Parameters

event

DigitalWorldEvent | null | undefined

Returns

void

emit()

Call Signature

emit<T>(event, …args): boolean

Defined in: src/models/typed-event-emitter.ts:86

Synchronously calls each of the listeners registered for the event named event, in the order they were registered, passing the supplied arguments to each.

Type Parameters

T

T extends ThreadEmittedEvents

Parameters

event

T

The name of the event to emit

args

…Parameters<ThreadEventHandlerMap[T]>

Arguments to pass to the listener

Returns

boolean

true if the event had listeners, false otherwise.

Inherited from

ReadReceipt.emit

Call Signature

emit<T>(event, …args): boolean

Defined in: src/models/typed-event-emitter.ts:87

Synchronously calls each of the listeners registered for the event named event, in the order they were registered, passing the supplied arguments to each.

Type Parameters

T

T extends ThreadEmittedEvents

Parameters

event

T

The name of the event to emit

args

…Parameters<ThreadEventHandlerMap[T]>

Arguments to pass to the listener

Returns

boolean

true if the event had listeners, false otherwise.

Inherited from

ReadReceipt.emit

emitPromised()

Call Signature

emitPromised<T>(event, …args): Promise<boolean>

Defined in: src/models/typed-event-emitter.ts:98

Similar to emit but calls all listeners within a Promise.all and returns the promise chain

Type Parameters

T

T extends ThreadEmittedEvents

Parameters

event

T

The name of the event to emit

args

…Parameters<ThreadEventHandlerMap[T]>

Arguments to pass to the listener

Returns

Promise<boolean>

true if the event had listeners, false otherwise.

Inherited from

ReadReceipt.emitPromised

Call Signature

emitPromised<T>(event, …args): Promise<boolean>

Defined in: src/models/typed-event-emitter.ts:102

Similar to emit but calls all listeners within a Promise.all and returns the promise chain

Type Parameters

T

T extends ThreadEmittedEvents

Parameters

event

T

The name of the event to emit

args

…Parameters<ThreadEventHandlerMap[T]>

Arguments to pass to the listener

Returns

Promise<boolean>

true if the event had listeners, false otherwise.

Inherited from

ReadReceipt.emitPromised

eventNames()

eventNames(): (string | symbol)[]

Defined in: node_modules/.pnpm/@types+node@22.20.0/node_modules/@types/node/events.d.ts:967

Returns an array listing the events for which the emitter has registered listeners. The values in the array are strings or Symbols.

import { EventEmitter } from 'node:events';

const myEE = new EventEmitter();
myEE.on('foo', () => {});
myEE.on('bar', () => {});

const sym = Symbol('symbol');
myEE.on(sym, () => {});

console.log(myEE.eventNames());
// Prints: [ 'foo', 'bar', Symbol(symbol) ]

Returns

(string | symbol)[]

Since

v6.0.0

Inherited from

ReadReceipt.eventNames

findEventById()

findEventById(eventId): DigitalWorldEvent | undefined

Defined in: src/models/thread.ts:704

Finds an event by ID in the current thread

Parameters

eventId

string

Returns

DigitalWorldEvent | undefined

Overrides

ReadReceipt.findEventById

fixupNotifications()

fixupNotifications(userId): void

Defined in: src/models/read-receipt.ts:365

This issue should also be addressed on synapse’s side and is tracked as part of https://github.com/matrix-org/synapse/issues/14837

Retrieves the read receipt for the logged in user and checks if it matches the last event in the room and whether that event originated from the logged in user. Under those conditions we can consider the context as read. This is useful because we never send read receipts against our own events

Parameters

userId

string

the logged in user

Returns

void

Inherited from

ReadReceipt.fixupNotifications

getEventReadUpTo()

getEventReadUpTo(userId, ignoreSynthesized?): string | null

Defined in: src/models/thread.ts:787

Get the ID of the event that a given user has read up to within this thread, or null if we have received no read receipt (at all) from them.

Parameters

userId

string

The user ID to get read receipt event ID for

ignoreSynthesized?

boolean

If true, return only receipts that have been sent by the server, not implicit ones generated by the JS SDK.

Returns

string | null

ID of the latest event that the given user has read, or null.

Overrides

ReadReceipt.getEventReadUpTo

getLastUnthreadedReceiptFor()

getLastUnthreadedReceiptFor(userId): Receipt | undefined

Defined in: src/models/thread.ts:891

Returns the most recent unthreaded receipt for a given user

Parameters

userId

string

the MxID of the User

Returns

Receipt | undefined

an unthreaded Receipt. Can be undefined if receipts have been disabled or a user chooses to use private read receipts (or we have simply not received a receipt from this user yet).

Overrides

ReadReceipt.getLastUnthreadedReceiptFor

getMaxListeners()

getMaxListeners(): number

Defined in: node_modules/.pnpm/@types+node@22.20.0/node_modules/@types/node/events.d.ts:819

Returns the current max listener value for the EventEmitter which is either set by emitter.setMaxListeners(n) or defaults to EventEmitter.defaultMaxListeners.

Returns

number

Since

v1.0.0

Inherited from

ReadReceipt.getMaxListeners

getReadReceiptForUserId()

getReadReceiptForUserId(userId, ignoreSynthesized?, receiptType?): WrappedReceipt | null

Defined in: src/models/read-receipt.ts:91

Gets the latest receipt for a given user in the room

Parameters

userId

string

The id of the user for which we want the receipt

ignoreSynthesized?

boolean = false

Whether to ignore synthesized receipts or not

receiptType?

ReceiptType = ReceiptType.Read

Optional. The type of the receipt we want to get

Returns

WrappedReceipt | null

the latest receipts of the chosen type for the chosen user

Inherited from

ReadReceipt.getReadReceiptForUserId

getReceiptsForEvent()

getReceiptsForEvent(event): CachedReceipt[]

Defined in: src/models/read-receipt.ts:339

Get a list of receipts for the given event.

Parameters

event

DigitalWorldEvent

the event to get receipts for

Returns

CachedReceipt[]

A list of receipts with a userId, type and data keys or an empty list.

Inherited from

ReadReceipt.getReceiptsForEvent

getUnfilteredTimelineSet()

getUnfilteredTimelineSet(): EventTimelineSet

Defined in: src/models/thread.ts:770

Returns

EventTimelineSet

Overrides

ReadReceipt.getUnfilteredTimelineSet

getUsersReadUpTo()

getUsersReadUpTo(event): string[]

Defined in: src/models/read-receipt.ts:392

Get a list of user IDs who have read up to the given event.

Parameters

event

DigitalWorldEvent

the event to get read receipts for.

Returns

string[]

A list of user IDs.

Inherited from

ReadReceipt.getUsersReadUpTo

has()

has(eventId): boolean

Defined in: src/models/thread.ts:758

Parameters

eventId

string

Returns

boolean

hasUserReadEvent()

hasUserReadEvent(userId, eventId): boolean

Defined in: src/models/thread.ts:862

Determine if the given user has read a particular event.

It is invalid to call this method with an event that is not part of this thread.

This is not a definitive check as it only checks the events that have been loaded client-side at the time of execution.

Parameters

userId

string

The user ID to check the read state of.

eventId

string

The event ID to check if the user read.

Returns

boolean

True if the user has read the event, false otherwise.

Overrides

ReadReceipt.hasUserReadEvent

lastReply()

lastReply(matches?): DigitalWorldEvent | null

Defined in: src/models/thread.ts:711

Return last reply to the thread, if known.

Parameters

matches?

(ev) => boolean

Returns

DigitalWorldEvent | null

listenerCount()

listenerCount(event): number

Defined in: src/models/typed-event-emitter.ts:115

Returns the number of listeners listening to the event named event.

Parameters

event

EventEmitterEvents | ThreadEmittedEvents

The name of the event being listened for

Returns

number

Inherited from

ReadReceipt.listenerCount

listeners()

listeners(event): Function[]

Defined in: src/models/typed-event-emitter.ts:122

Returns a copy of the array of listeners for the event named event.

Parameters

event

EventEmitterEvents | ThreadEmittedEvents

Returns

Function[]

Inherited from

ReadReceipt.listeners

off()

off<T>(event, listener): this

Defined in: src/models/typed-event-emitter.ts:129

Alias for removeListener

Type Parameters

T

T extends EventEmitterEvents | ThreadEmittedEvents

Parameters

event

T

listener

Listener<ThreadEmittedEvents, ThreadEventHandlerMap, T>

Returns

this

Inherited from

ReadReceipt.off

on()

on<T>(event, listener): this

Defined in: src/models/typed-event-emitter.ts:150

Adds the listener function to the end of the listeners array for the event named event.

No checks are made to see if the listener has already been added. Multiple calls passing the same combination of event and listener will result in the listener being added, and called, multiple times.

By default, event listeners are invoked in the order they are added. The prependListener method can be used as an alternative to add the event listener to the beginning of the listeners array.

Type Parameters

T

T extends EventEmitterEvents | ThreadEmittedEvents

Parameters

event

T

The name of the event.

listener

Listener<ThreadEmittedEvents, ThreadEventHandlerMap, T>

The callback function

Returns

this

a reference to the EventEmitter, so that calls can be chained.

Inherited from

ReadReceipt.on

once()

once<T>(event, listener): this

Defined in: src/models/typed-event-emitter.ts:169

Adds a one-time listener function for the event named event. The next time event is triggered, this listener is removed and then invoked.

Returns a reference to the EventEmitter, so that calls can be chained.

By default, event listeners are invoked in the order they are added. The prependOnceListener method can be used as an alternative to add the event listener to the beginning of the listeners array.

Type Parameters

T

T extends EventEmitterEvents | ThreadEmittedEvents

Parameters

event

T

The name of the event.

listener

Listener<ThreadEmittedEvents, ThreadEventHandlerMap, T>

The callback function

Returns

this

a reference to the EventEmitter, so that calls can be chained.

Inherited from

ReadReceipt.once

prependListener()

prependListener<T>(event, listener): this

Defined in: src/models/typed-event-emitter.ts:186

Adds the listener function to the beginning of the listeners array for the event named event.

Type Parameters

T

T extends EventEmitterEvents | ThreadEmittedEvents

Parameters

event

T

The name of the event.

listener

Listener<ThreadEmittedEvents, ThreadEventHandlerMap, T>

The callback function

Returns

this

a reference to the EventEmitter, so that calls can be chained.

Inherited from

ReadReceipt.prependListener

prependOnceListener()

prependOnceListener<T>(event, listener): this

Defined in: src/models/typed-event-emitter.ts:202

Adds a one-timelistener function for the event named event to the beginning of the listeners array. The next time event is triggered, this listener is removed, and then invoked.

Type Parameters

T

T extends EventEmitterEvents | ThreadEmittedEvents

Parameters

event

T

The name of the event.

listener

Listener<ThreadEmittedEvents, ThreadEventHandlerMap, T>

The callback function

Returns

this

a reference to the EventEmitter, so that calls can be chained.

Inherited from

ReadReceipt.prependOnceListener

processEvent()

processEvent(event): Promise<void>

Defined in: src/models/thread.ts:477

Parameters

event

DigitalWorldEvent | null | undefined

Returns

Promise<void>

rawListeners()

rawListeners(event): Function[]

Defined in: src/models/typed-event-emitter.ts:243

Returns a copy of the array of listeners for the event named eventName, including any wrappers (such as those created by .once()).

Parameters

event

EventEmitterEvents | ThreadEmittedEvents

Returns

Function[]

Inherited from

ReadReceipt.rawListeners

removeAllListeners()

removeAllListeners(event?): this

Defined in: src/models/typed-event-emitter.ts:219

Removes all listeners, or those of the specified event.

It is bad practice to remove listeners added elsewhere in the code, particularly when the EventEmitter instance was created by some other component or module (e.g. sockets or file streams).

Parameters

event?

EventEmitterEvents | ThreadEmittedEvents

The name of the event. If undefined, all listeners everywhere are removed.

Returns

this

a reference to the EventEmitter, so that calls can be chained.

Inherited from

ReadReceipt.removeAllListeners

removeListener()

removeListener<T>(event, listener): this

Defined in: src/models/typed-event-emitter.ts:232

Removes the specified listener from the listener array for the event named event.

Type Parameters

T

T extends EventEmitterEvents | ThreadEmittedEvents

Parameters

event

T

listener

Listener<ThreadEmittedEvents, ThreadEventHandlerMap, T>

Returns

this

a reference to the EventEmitter, so that calls can be chained.

Inherited from

ReadReceipt.removeListener

resetLiveTimeline()

resetLiveTimeline(backPaginationToken?, forwardPaginationToken?): Promise<void>

Defined in: src/models/thread.ts:545

Reset the live timeline of all timelineSets, and start new ones.

This is used when /sync returns a 'limited' timeline. 'Limited' means that there's a gap between the messages /sync returned, and the last known message in our timeline. In such a case, our live timeline isn't live anymore and has to be replaced by a new one. To make sure we can continue paginating our timelines correctly, we have to set new pagination tokens on the old and the new timeline.

Parameters

backPaginationToken?

string | null

token for back-paginating the new timeline

forwardPaginationToken?

string | null

token for forward-paginating the old live timeline, if absent or null, all timelines are reset, removing old ones (including the previous live timeline which would otherwise be unable to paginate forwards without this token). Removing just the old live timeline whilst preserving previous ones is not supported.

Returns

Promise<void>

setEventMetadata()

setEventMetadata(event): void

Defined in: src/models/thread.ts:687

Parameters

event

DigitalWorldEvent | null | undefined

Returns

void

setMaxListeners()

setMaxListeners(n): this

Defined in: node_modules/.pnpm/@types+node@22.20.0/node_modules/@types/node/events.d.ts:813

By default EventEmitters will print a warning if more than 10 listeners are added for a particular event. This is a useful default that helps finding memory leaks. The emitter.setMaxListeners() method allows the limit to be modified for this specific EventEmitter instance. The value can be set to Infinity (or 0) to indicate an unlimited number of listeners.

Returns a reference to the EventEmitter, so that calls can be chained.

Parameters

n

number

Returns

this

Since

v0.3.5

Inherited from

ReadReceipt.setMaxListeners

setUnread()

setUnread(type, count): void

Defined in: src/models/thread.ts:880

Parameters

type

NotificationCountType

count

number

Returns

void

Overrides

ReadReceipt.setUnread

addAbortListener()

static addAbortListener(signal, resource): Disposable

Defined in: node_modules/.pnpm/@types+node@22.20.0/node_modules/@types/node/events.d.ts:403

Listens once to the abort event on the provided signal.

Listening to the abort event on abort signals is unsafe and may lead to resource leaks since another third party with the signal can call e.stopImmediatePropagation(). Unfortunately Node.js cannot change this since it would violate the web standard. Additionally, the original API makes it easy to forget to remove listeners.

This API allows safely using AbortSignals in Node.js APIs by solving these two issues by listening to the event such that stopImmediatePropagation does not prevent the listener from running.

Returns a disposable so that it may be unsubscribed from more easily.

import { addAbortListener } from 'node:events';

function example(signal) {
  let disposable;
  try {
    signal.addEventListener('abort', (e) => e.stopImmediatePropagation());
    disposable = addAbortListener(signal, (e) => {
      // Do something when signal is aborted.
    });
  } finally {
    disposable?.[Symbol.dispose]();
  }
}

Parameters

signal

AbortSignal

resource

(event) => void

Returns

Disposable

Disposable that removes the abort listener.

Since

v20.5.0

Inherited from

ReadReceipt.addAbortListener

getEventListeners()

static getEventListeners(emitter, name): Function[]

Defined in: node_modules/.pnpm/@types+node@22.20.0/node_modules/@types/node/events.d.ts:325

Returns a copy of the array of listeners for the event named eventName.

For EventEmitters this behaves exactly the same as calling .listeners on the emitter.

For EventTargets this is the only way to get the event listeners for the event target. This is useful for debugging and diagnostic purposes.

import { getEventListeners, EventEmitter } from 'node:events';

{
  const ee = new EventEmitter();
  const listener = () => console.log('Events are fun');
  ee.on('foo', listener);
  console.log(getEventListeners(ee, 'foo')); // [ [Function: listener] ]
}
{
  const et = new EventTarget();
  const listener = () => console.log('Events are fun');
  et.addEventListener('foo', listener);
  console.log(getEventListeners(et, 'foo')); // [ [Function: listener] ]
}

Parameters

emitter

EventEmitter<DefaultEventMap> | EventTarget

name

string | symbol

Returns

Function[]

Since

v15.2.0, v14.17.0

Inherited from

ReadReceipt.getEventListeners

getMaxListeners()

static getMaxListeners(emitter): number

Defined in: node_modules/.pnpm/@types+node@22.20.0/node_modules/@types/node/events.d.ts:354

Returns the currently set max amount of listeners.

For EventEmitters this behaves exactly the same as calling .getMaxListeners on the emitter.

For EventTargets this is the only way to get the max event listeners for the event target. If the number of event handlers on a single EventTarget exceeds the max set, the EventTarget will print a warning.

import { getMaxListeners, setMaxListeners, EventEmitter } from 'node:events';

{
  const ee = new EventEmitter();
  console.log(getMaxListeners(ee)); // 10
  setMaxListeners(11, ee);
  console.log(getMaxListeners(ee)); // 11
}
{
  const et = new EventTarget();
  console.log(getMaxListeners(et)); // 10
  setMaxListeners(11, et);
  console.log(getMaxListeners(et)); // 11
}

Parameters

emitter

EventEmitter<DefaultEventMap> | EventTarget

Returns

number

Since

v19.9.0

Inherited from

ReadReceipt.getMaxListeners

listenerCount()

static listenerCount(emitter, eventName): number

Defined in: node_modules/.pnpm/@types+node@22.20.0/node_modules/@types/node/events.d.ts:297

A class method that returns the number of listeners for the given eventName registered on the given emitter.

import { EventEmitter, listenerCount } from 'node:events';

const myEmitter = new EventEmitter();
myEmitter.on('event', () => {});
myEmitter.on('event', () => {});
console.log(listenerCount(myEmitter, 'event'));
// Prints: 2

Parameters

emitter

EventEmitter

The emitter to query

eventName

string | symbol

The event name

Returns

number

Since

v0.9.12

Inherited from

ReadReceipt.listenerCount

on()

Call Signature

static on(emitter, eventName, options?): AsyncIterator<any[]>

Defined in: node_modules/.pnpm/@types+node@22.20.0/node_modules/@types/node/events.d.ts:270

import { on, EventEmitter } from 'node:events';
import process from 'node:process';

const ee = new EventEmitter();

// Emit later on
process.nextTick(() => {
  ee.emit('foo', 'bar');
  ee.emit('foo', 42);
});

for await (const event of on(ee, 'foo')) {
  // The execution of this inner block is synchronous and it
  // processes one event at a time (even with await). Do not use
  // if concurrent execution is required.
  console.log(event); // prints ['bar'] [42]
}
// Unreachable here

Returns an AsyncIterator that iterates eventName events. It will throw if the EventEmitter emits 'error'. It removes all listeners when exiting the loop. The value returned by each iteration is an array composed of the emitted event arguments.

An AbortSignal can be used to cancel waiting on events:

import { on, EventEmitter } from 'node:events';
import process from 'node:process';

const ac = new AbortController();

(async () => {
  const ee = new EventEmitter();

  // Emit later on
  process.nextTick(() => {
    ee.emit('foo', 'bar');
    ee.emit('foo', 42);
  });

  for await (const event of on(ee, 'foo', { signal: ac.signal })) {
    // The execution of this inner block is synchronous and it
    // processes one event at a time (even with await). Do not use
    // if concurrent execution is required.
    console.log(event); // prints ['bar'] [42]
  }
  // Unreachable here
})();

process.nextTick(() => ac.abort());

Use the close option to specify an array of event names that will end the iteration:

import { on, EventEmitter } from 'node:events';
import process from 'node:process';

const ee = new EventEmitter();

// Emit later on
process.nextTick(() => {
  ee.emit('foo', 'bar');
  ee.emit('foo', 42);
  ee.emit('close');
});

for await (const event of on(ee, 'foo', { close: ['close'] })) {
  console.log(event); // prints ['bar'] [42]
}
// the loop will exit after 'close' is emitted
console.log('done'); // prints 'done'

Parameters

emitter

EventEmitter

eventName

string | symbol

options?

StaticEventEmitterIteratorOptions

Returns

AsyncIterator<any[]>

An AsyncIterator that iterates eventName events emitted by the emitter

Since

v13.6.0, v12.16.0

Inherited from

ReadReceipt.on

Call Signature

static on(emitter, eventName, options?): AsyncIterator<any[]>

Defined in: node_modules/.pnpm/@types+node@22.20.0/node_modules/@types/node/events.d.ts:275

import { on, EventEmitter } from 'node:events';
import process from 'node:process';

const ee = new EventEmitter();

// Emit later on
process.nextTick(() => {
  ee.emit('foo', 'bar');
  ee.emit('foo', 42);
});

for await (const event of on(ee, 'foo')) {
  // The execution of this inner block is synchronous and it
  // processes one event at a time (even with await). Do not use
  // if concurrent execution is required.
  console.log(event); // prints ['bar'] [42]
}
// Unreachable here

An AbortSignal can be used to cancel waiting on events:

import { on, EventEmitter } from 'node:events';
import process from 'node:process';

const ac = new AbortController();

(async () => {
  const ee = new EventEmitter();

  // Emit later on
  process.nextTick(() => {
    ee.emit('foo', 'bar');
    ee.emit('foo', 42);
  });

  for await (const event of on(ee, 'foo', { signal: ac.signal })) {
    // The execution of this inner block is synchronous and it
    // processes one event at a time (even with await). Do not use
    // if concurrent execution is required.
    console.log(event); // prints ['bar'] [42]
  }
  // Unreachable here
})();

process.nextTick(() => ac.abort());

Use the close option to specify an array of event names that will end the iteration:

import { on, EventEmitter } from 'node:events';
import process from 'node:process';

const ee = new EventEmitter();

// Emit later on
process.nextTick(() => {
  ee.emit('foo', 'bar');
  ee.emit('foo', 42);
  ee.emit('close');
});

for await (const event of on(ee, 'foo', { close: ['close'] })) {
  console.log(event); // prints ['bar'] [42]
}
// the loop will exit after 'close' is emitted
console.log('done'); // prints 'done'

Parameters

emitter

EventTarget

eventName

string

options?

StaticEventEmitterIteratorOptions

Returns

AsyncIterator<any[]>

An AsyncIterator that iterates eventName events emitted by the emitter

Since

v13.6.0, v12.16.0

Inherited from

ReadReceipt.on

once()

Call Signature

static once(emitter, eventName, options?): Promise<any[]>

Defined in: node_modules/.pnpm/@types+node@22.20.0/node_modules/@types/node/events.d.ts:184

Creates a Promise that is fulfilled when the EventEmitter emits the given event or that is rejected if the EventEmitter emits 'error' while waiting. The Promise will resolve with an array of all the arguments emitted to the given event.

This method is intentionally generic and works with the web platform EventTarget interface, which has no special'error' event semantics and does not listen to the 'error' event.

import { once, EventEmitter } from 'node:events';
import process from 'node:process';

const ee = new EventEmitter();

process.nextTick(() => {
  ee.emit('myevent', 42);
});

const [value] = await once(ee, 'myevent');
console.log(value);

const err = new Error('kaboom');
process.nextTick(() => {
  ee.emit('error', err);
});

try {
  await once(ee, 'myevent');
} catch (err) {
  console.error('error happened', err);
}

The special handling of the 'error' event is only used when events.once() is used to wait for another event. If events.once() is used to wait for the ’error' event itself, then it is treated as any other kind of event without special handling:

import { EventEmitter, once } from 'node:events';

const ee = new EventEmitter();

once(ee, 'error')
  .then(([err]) => console.log('ok', err.message))
  .catch((err) => console.error('error', err.message));

ee.emit('error', new Error('boom'));

// Prints: ok boom

An AbortSignal can be used to cancel waiting for the event:

import { EventEmitter, once } from 'node:events';

const ee = new EventEmitter();
const ac = new AbortController();

async function foo(emitter, event, signal) {
  try {
    await once(emitter, event, { signal });
    console.log('event emitted!');
  } catch (error) {
    if (error.name === 'AbortError') {
      console.error('Waiting for the event was canceled!');
    } else {
      console.error('There was an error', error.message);
    }
  }
}

foo(ee, 'foo', ac.signal);
ac.abort(); // Abort waiting for the event
ee.emit('foo'); // Prints: Waiting for the event was canceled!

Parameters

emitter

EventEmitter

eventName

string | symbol

options?

StaticEventEmitterOptions

Returns

Promise<any[]>

Since

v11.13.0, v10.16.0

Inherited from

ReadReceipt.once

Call Signature

static once(emitter, eventName, options?): Promise<any[]>

Defined in: node_modules/.pnpm/@types+node@22.20.0/node_modules/@types/node/events.d.ts:189

This method is intentionally generic and works with the web platform EventTarget interface, which has no special'error' event semantics and does not listen to the 'error' event.

import { once, EventEmitter } from 'node:events';
import process from 'node:process';

const ee = new EventEmitter();

process.nextTick(() => {
  ee.emit('myevent', 42);
});

const [value] = await once(ee, 'myevent');
console.log(value);

const err = new Error('kaboom');
process.nextTick(() => {
  ee.emit('error', err);
});

try {
  await once(ee, 'myevent');
} catch (err) {
  console.error('error happened', err);
}

import { EventEmitter, once } from 'node:events';

const ee = new EventEmitter();

once(ee, 'error')
  .then(([err]) => console.log('ok', err.message))
  .catch((err) => console.error('error', err.message));

ee.emit('error', new Error('boom'));

// Prints: ok boom

An AbortSignal can be used to cancel waiting for the event:

import { EventEmitter, once } from 'node:events';

const ee = new EventEmitter();
const ac = new AbortController();

async function foo(emitter, event, signal) {
  try {
    await once(emitter, event, { signal });
    console.log('event emitted!');
  } catch (error) {
    if (error.name === 'AbortError') {
      console.error('Waiting for the event was canceled!');
    } else {
      console.error('There was an error', error.message);
    }
  }
}

foo(ee, 'foo', ac.signal);
ac.abort(); // Abort waiting for the event
ee.emit('foo'); // Prints: Waiting for the event was canceled!

Parameters

emitter

EventTarget

eventName

string

options?

StaticEventEmitterOptions

Returns

Promise<any[]>

Since

v11.13.0, v10.16.0

Inherited from

ReadReceipt.once

setMaxListeners()

static setMaxListeners(n?, …eventTargets): void

Defined in: node_modules/.pnpm/@types+node@22.20.0/node_modules/@types/node/events.d.ts:369

import { setMaxListeners, EventEmitter } from 'node:events';

const target = new EventTarget();
const emitter = new EventEmitter();

setMaxListeners(5, target, emitter);

Parameters

n?

number

A non-negative number. The maximum number of listeners per EventTarget event.

eventTargets

…(EventEmitter<DefaultEventMap> | EventTarget)[]

Zero or more {EventTarget} or {EventEmitter} instances. If none are specified, n is set as the default max for all newly created {EventTarget} and {EventEmitter} objects.