RoomState

Defined in: src/models/room-state.ts:147

Typed Event Emitter class which can act as a Base Model for all our model and communication events. This makes it much easier for us to distinguish between events, as we now need to properly type this, so that our events are not stringly-based and prone to silly typos.

Type parameters:

Events - List of all events emitted by this TypedEventEmitter. Normally an enum type.
Arguments - A ListenerMap type providing mappings from event names to listener types.
SuperclassArguments - TODO: not really sure. Alternative listener mappings, I think? But only honoured for .emit?

Extends

TypedEventEmitter<EmittedEvents, EventHandlerMap>

Constructors

Constructor

new RoomState(roomId, oobMemberFlags?): RoomState

Defined in: src/models/room-state.ts:208

Construct room state.

Room State represents the state of the room at a given point. It can be mutated by adding state events to it. There are two types of room member associated with a state event: normal member objects (accessed via getMember/getMembers) which mutate with the state to represent the current state of that room/user, e.g. the object returned by getMember('@bob:example.com') will mutate to get a different display name if Bob later changes his display name in the room. There are also ‘sentinel’ members (accessed via getSentinelMember). These also represent the state of room members at the point in time represented by the RoomState object, but unlike objects from getMember, sentinel objects will always represent the room state as at the time getSentinelMember was called, so if Bob subsequently changes his display name, a room member object previously acquired with getSentinelMember will still have his old display name. Calling getSentinelMember again after the display name change will return a new RoomMember object with Bob’s new display name.

Parameters

roomId

string

Optional. The ID of the room which has this state. If none is specified it just tracks paginationTokens, useful for notifTimelineSet

oobMemberFlags?

Optional. The state of loading out of bound members. As the timeline might get reset while they are loading, this state needs to be inherited and shared when the room state is cloned for the new timeline. This should only be passed from clone.

status

OobStatus = OobStatus.NotStarted

Returns

RoomState

Overrides

TypedEventEmitter.constructor

Properties

beacons

readonly beacons: Map<string, Beacon>

Defined in: src/models/room-state.ts:174

events

events: Map<string, Map<string, DigitalWorldEvent>>

Defined in: src/models/room-state.ts:170

members

members: Record<string, RoomMember> = {}

Defined in: src/models/room-state.ts:168

paginationToken

paginationToken: string | null = null

Defined in: src/models/room-state.ts:172

reEmitter

readonly reEmitter: TypedReEmitter<EmittedEvents, EventHandlerMap>

Defined in: src/models/room-state.ts:148

roomId

readonly roomId: string

Defined in: src/models/room-state.ts:209

Optional. The ID of the room which has this state. If none is specified it just tracks paginationTokens, useful for notifTimelineSet

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

TypedEventEmitter.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

TypedEventEmitter.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

TypedEventEmitter.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

TypedEventEmitter.errorMonitor

Accessors

hasLiveBeacons

Get Signature

get hasLiveBeacons(): boolean

Defined in: src/models/room-state.ts:357

Returns

boolean

liveBeaconIds

Get Signature

get liveBeaconIds(): string[]

Defined in: src/models/room-state.ts:361

Returns

string[]

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

TypedEventEmitter.[captureRejectionSymbol]

addListener()

addListener<T>(event, listener): this

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

Alias for on.

Type Parameters

T

T extends EventEmitterEvents | EmittedEvents

Parameters

event

T

listener

Listener<EmittedEvents, EventHandlerMap, T>

Returns

this

Inherited from

TypedEventEmitter.addListener

clearOutOfBandMembers()

clearOutOfBandMembers(): void

Defined in: src/models/room-state.ts:767

Clears the loaded out-of-band members

Returns

void

clone()

clone(): RoomState

Defined in: src/models/room-state.ts:369

Creates a copy of this room state so that mutations to either won’t affect the other.

Returns

RoomState

the copy of the room state

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 EmittedEvents

Parameters

event

T

The name of the event to emit

args

…Parameters<EventHandlerMap[T]>

Arguments to pass to the listener

Returns

boolean

true if the event had listeners, false otherwise.

Inherited from

TypedEventEmitter.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 EmittedEvents

Parameters

event

T

The name of the event to emit

args

…Parameters<EventHandlerMap[T]>

Arguments to pass to the listener

Returns

boolean

true if the event had listeners, false otherwise.

Inherited from

TypedEventEmitter.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 EmittedEvents

Parameters

event

T

The name of the event to emit

args

…Parameters<EventHandlerMap[T]>

Arguments to pass to the listener

Returns

Promise<boolean>

true if the event had listeners, false otherwise.

Inherited from

TypedEventEmitter.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 EmittedEvents

Parameters

event

T

The name of the event to emit

args

…Parameters<EventHandlerMap[T]>

Arguments to pass to the listener

Returns

Promise<boolean>

true if the event had listeners, false otherwise.

Inherited from

TypedEventEmitter.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

TypedEventEmitter.eventNames

findPredecessor()

findPredecessor(msc3946ProcessDynamicPredecessor?): { eventId?: string; roomId: string; viaServers?: string[]; } | null

Defined in: src/models/room-state.ts:1092

Find the predecessor room based on this room state.

Parameters

msc3946ProcessDynamicPredecessor?

boolean = false

if true, look for an m.room.predecessor state event and use it if found (MSC3946).

Returns

{ eventId?: string; roomId: string; viaServers?: string[]; } | null

null if this room has no predecessor. Otherwise, returns the roomId, last eventId and viaServers of the predecessor room.

If msc3946ProcessDynamicPredecessor is true, use m.predecessor events as well as m.room.create events to find predecessors.

Note: if an m.predecessor event is used, eventId may be undefined since last_known_event_id is optional.

Note: viaServers may be undefined, and will definitely be undefined if this predecessor comes from a RoomCreate event (rather than a RoomPredecessor, which has the optional via_servers property).

getGuestAccess()

getGuestAccess(): GuestAccess

Defined in: src/models/room-state.ts:1068

Returns the guest access based on the m.room.guest_access state event, defaulting to shared.

Returns

GuestAccess

the guest_access applied to this room

getHistoryVisibility()

getHistoryVisibility(): HistoryVisibility

Defined in: src/models/room-state.ts:1058

Returns the history visibility based on the m.room.history_visibility state event, defaulting to shared.

Returns

HistoryVisibility

the history_visibility applied to this room

getInvitedMemberCount()

getInvitedMemberCount(): number

Defined in: src/models/room-state.ts:261

Returns the number of invited members in this room

Returns

number

The number of members in this room whose membership is ‘invite’

getInviteForThreePidToken()

getInviteForThreePidToken(token): DigitalWorldEvent | null

Defined in: src/models/room-state.ts:840

Get the m.room.member event which has the given third party invite token.

Parameters

token

string

The token

Returns

DigitalWorldEvent | null

The m.room.member event or null

getJoinedMemberCount()

getJoinedMemberCount(): number

Defined in: src/models/room-state.ts:237

Returns the number of joined members in this room This method caches the result.

Returns

number

The number of members in this room whose membership is ‘join’

getJoinRule()

getJoinRule(): JoinRule

Defined in: src/models/room-state.ts:1048

Returns the join rule based on the m.room.join_rule state event, defaulting to invite.

Returns

JoinRule

the join_rule applied to this room

getLastModifiedTime()

getLastModifiedTime(): number

Defined in: src/models/room-state.ts:856

Get the timestamp when this room state was last updated. This timestamp is updated when this object has received new state events.

Returns

number

The timestamp

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

TypedEventEmitter.getMaxListeners

getMember()

getMember(userId): RoomMember | null

Defined in: src/models/room-state.ts:303

Get a room member by their user ID.

Parameters

userId

string

The room member’s user ID.

Returns

RoomMember | null

The member or null if they do not exist.

getMembers()

getMembers(): RoomMember[]

Defined in: src/models/room-state.ts:285

Get all RoomMembers in this room.

Returns

RoomMember[]

A list of RoomMembers.

getMembersExcept()

getMembersExcept(excludedIds): RoomMember[]

Defined in: src/models/room-state.ts:294

Get all RoomMembers in this room, excluding the user IDs provided.

Parameters

excludedIds

string[]

The user IDs to exclude.

Returns

RoomMember[]

A list of RoomMembers.

getRoomVersion()

getRoomVersion(): string

Defined in: src/models/room-state.ts:220

Gets the version of the room

Returns

string

The version of the room

getSentinelMember()

getSentinelMember(userId): RoomMember | null

Defined in: src/models/room-state.ts:316

Get a room member whose properties will not change with this room state. You typically want this if you want to attach a RoomMember to a DigitalWorldEvent which may no longer be represented correctly by Room.currentState or Room.oldState. The term ‘sentinel’ refers to the fact that this RoomMember is an unchanging guardian for state at this particular point in time.

Parameters

userId

string

The room member’s user ID.

Returns

RoomMember | null

The member or null if they do not exist.

getStateEvents()

Call Signature

getStateEvents(eventType): DigitalWorldEvent[]

Defined in: src/models/room-state.ts:336

Get state events from the state of the room.

Parameters

eventType

string

The event type of the state event.

Returns

DigitalWorldEvent[]

A list of events

Call Signature

getStateEvents(eventType, stateKey): DigitalWorldEvent | null

Defined in: src/models/room-state.ts:343

Get state events from the state of the room.

Parameters

eventType

string

The event type of the state event.

stateKey

string

The state_key of the state event.

Returns

DigitalWorldEvent | null

A single event (or null if no match found).

getUserIdsWithDisplayName()

getUserIdsWithDisplayName(displayName): string[]

Defined in: src/models/room-state.ts:865

Get user IDs with the specified or similar display names.

Parameters

displayName

string

The display name to get user IDs from.

Returns

string[]

An array of user IDs or an empty array.

hasSufficientPowerLevelFor()

hasSufficientPowerLevelFor(action, powerLevel): boolean

Defined in: src/models/room-state.ts:898

Returns true if the given power level is sufficient for action

Parameters

action

KeysMatching<Required<IPowerLevelsContent>, number>

The type of power level to check

powerLevel

number

The power level of the member

Returns

boolean

true if the given power level is sufficient

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 | EmittedEvents

The name of the event being listened for

Returns

number

Inherited from

TypedEventEmitter.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 | EmittedEvents

Returns

Function[]

Inherited from

TypedEventEmitter.listeners

markOutOfBandMembersFailed()

markOutOfBandMembersFailed(): void

Defined in: src/models/room-state.ts:757

Mark this room state as having failed to fetch out-of-band members

Returns

void

markOutOfBandMembersStarted()

markOutOfBandMembersStarted(): void

Defined in: src/models/room-state.ts:747

Mark this room state as waiting for out-of-band members, ensuring it doesn’t ask for them to be requested again through needsOutOfBandMembers

Returns

void

mayClientSendStateEvent()

mayClientSendStateEvent(stateEventType, cli): boolean

Defined in: src/models/room-state.ts:949

Returns true if the given DigitalWorldClient has permission to send a state event of type stateEventType into this room.

Parameters

stateEventType

string

The type of state events to test

cli

DigitalWorldClient

The client to test permission for

Returns

boolean

true if the given client should be permitted to send the given type of state event into this room, according to the room’s state.

maySendEvent()

maySendEvent(eventType, userId): boolean

Defined in: src/models/room-state.ts:936

Returns true if the given user ID has permission to send a normal event of type eventType into this room.

Parameters

eventType

string

The type of event to test

userId

string

The user ID of the user to test permission for

Returns

boolean

true if the given user ID should be permitted to send the given type of event into this room, according to the room’s state.

maySendMessage()

maySendMessage(userId): boolean

Defined in: src/models/room-state.ts:923

Short-form for maySendEvent(‘m.room.message’, userId)

Parameters

userId

string

The user ID of the user to test permission for

Returns

boolean

true if the given user ID should be permitted to send message events into the given room.

maySendRedactionForEvent()

maySendRedactionForEvent(mxEvent, userId): boolean

Defined in: src/models/room-state.ts:876

Returns true if userId is in room, event is not redacted and either sender of mxEvent or has power level sufficient to redact events other than their own.

Parameters

mxEvent

DigitalWorldEvent

The event to test permission for

userId

string

The user ID of the user to test permission for

Returns

boolean

true if the given used ID can redact given event

maySendStateEvent()

maySendStateEvent(stateEventType, userId): boolean

Defined in: src/models/room-state.ts:965

Returns true if the given user ID has permission to send a state event of type stateEventType into this room.

Parameters

stateEventType

string

The type of state events to test

userId

string

The user ID of the user to test permission for

Returns

boolean

true if the given user ID should be permitted to send the given type of state event into this room, according to the room’s state.

mayTriggerNotifOfType()

mayTriggerNotifOfType(notifLevelKey, userId): boolean

Defined in: src/models/room-state.ts:1023

Returns true if the given user ID has permission to trigger notification of type notifLevelKey

Parameters

notifLevelKey

string

The level of notification to test (eg. ‘room’)

userId

string

The user ID of the user to test permission for

Returns

boolean

true if the given user ID has permission to trigger a notification of this type.

needsOutOfBandMembers()

needsOutOfBandMembers(): boolean

Defined in: src/models/room-state.ts:728

Get the out-of-band members loading state, whether loading is needed or not. Note that loading might be in progress and hence isn’t needed.

Returns

boolean

whether or not the members of this room need to be loaded

off()

off<T>(event, listener): this

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

Alias for removeListener

Type Parameters

T

T extends EventEmitterEvents | EmittedEvents

Parameters

event

T

listener

Listener<EmittedEvents, EventHandlerMap, T>

Returns

this

Inherited from

TypedEventEmitter.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 | EmittedEvents

Parameters

event

T

The name of the event.

listener

Listener<EmittedEvents, EventHandlerMap, T>

The callback function

Returns

this

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

Inherited from

TypedEventEmitter.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 | EmittedEvents

Parameters

event

T

The name of the event.

listener

Listener<EmittedEvents, EventHandlerMap, T>

The callback function

Returns

this

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

Inherited from

TypedEventEmitter.once

outOfBandMembersReady()

outOfBandMembersReady(): boolean

Defined in: src/models/room-state.ts:738

Check if loading of out-of-band-members has completed

Returns

boolean

true if the full membership list of this room has been loaded. False if it is not started or is in progress.

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 | EmittedEvents

Parameters

event

T

The name of the event.

listener

Listener<EmittedEvents, EventHandlerMap, T>

The callback function

Returns

this

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

Inherited from

TypedEventEmitter.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 | EmittedEvents

Parameters

event

T

The name of the event.

listener

Listener<EmittedEvents, EventHandlerMap, T>

The callback function

Returns

this

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

Inherited from

TypedEventEmitter.prependOnceListener

processBeaconEvents()

processBeaconEvents(events, digitalWorldClient): Promise<void>

Defined in: src/models/room-state.ts:567

Parameters

events

DigitalWorldEvent[]

digitalWorldClient

DigitalWorldClient

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 | EmittedEvents

Returns

Function[]

Inherited from

TypedEventEmitter.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 | EmittedEvents

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

TypedEventEmitter.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 | EmittedEvents

Parameters

event

T

listener

Listener<EmittedEvents, EventHandlerMap, T>

Returns

this

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

Inherited from

TypedEventEmitter.removeListener

setInvitedMemberCount()

setInvitedMemberCount(count): void

Defined in: src/models/room-state.ts:277

Set the amount of invited members in this room

Parameters

count

number

the amount of invited members

Returns

void

setJoinedMemberCount()

setJoinedMemberCount(count): void

Defined in: src/models/room-state.ts:253

Set the joined member count explicitly (like from summary part of the sync response)

Parameters

count

number

the amount of joined members

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

TypedEventEmitter.setMaxListeners

setOutOfBandMembers()

setOutOfBandMembers(stateEvents): void

Defined in: src/models/room-state.ts:784

Sets the loaded out-of-band members.

Parameters

stateEvents

DigitalWorldEvent[]

array of membership state events

Returns

void

setStateEvents()

setStateEvents(stateEvents, markerFoundOptions?): void

Defined in: src/models/room-state.ts:437

Add an array of one or more state DigitalWorldEvents, overwriting any existing state with the same {type, stateKey} tuple. Will fire “RoomState.events” for every event added. May fire “RoomState.members” if there are m.room.member events. May fire “RoomStateEvent.Marker” if there are UNSTABLE_MSC2716_MARKER events.

Parameters

stateEvents

DigitalWorldEvent[]

a list of state events for this room.

markerFoundOptions?

IMarkerFoundOptions

Returns

void

Remarks

Fires RoomStateEvent.Members Fires RoomStateEvent.NewMember Fires RoomStateEvent.Events Fires RoomStateEvent.Marker

setTypingEvent()

setTypingEvent(event): void

Defined in: src/models/room-state.ts:828

Set the current typing event for this room.

Parameters

event

DigitalWorldEvent

The typing event

Returns

void

setUnknownStateEvents()

setUnknownStateEvents(events): void

Defined in: src/models/room-state.ts:415

Add previously unknown state events. When lazy loading members while back-paginating, the relevant room state for the timeline chunk at the end of the chunk can be set with this method.

Parameters

events

DigitalWorldEvent[]

state events to prepend

Returns

void

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

TypedEventEmitter.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

TypedEventEmitter.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

TypedEventEmitter.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

TypedEventEmitter.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

TypedEventEmitter.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

TypedEventEmitter.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

TypedEventEmitter.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

TypedEventEmitter.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.

Returns

void

Since

v15.4.0

Inherited from

TypedEventEmitter.setMaxListeners