@meshagent/meshagent 0.37.2 → 0.38.1

package/dist/esm/messaging-client.js

@@ -1,15 +1,16 @@
-import { EventEmitter } from "./event-emitter";
 import { Completer } from "./completer";
+import { EventEmitter } from "./event-emitter";
 import { RemoteParticipant } from "./participant";
+import { JsonContent } from "./response";
 import { RoomMessage, RoomMessageEvent } from "./room-event";
 import { RoomServerException } from "./room-server-client";
 import { splitMessageHeader, splitMessagePayload } from "./utils";
 const globalScope = globalThis;
 function bytesToBase64(bytes) {
-    if (globalScope.Buffer) {
+    if (globalScope.Buffer != null) {
         return globalScope.Buffer.from(bytes).toString("base64");
     }
-    if (!globalScope.btoa) {
+    if (globalScope.btoa == null) {
         throw new Error("base64 encoding is not available in this runtime");
     }
     let binary = "";
@@ -27,10 +28,21 @@ export class MessagingClient extends EventEmitter {
         this._messageQueued = null;
         this._sendTask = null;
         this._messageQueueClosed = false;
-        this._enabled = false;
+        this._desiredEnabled = false;
+        this._online = false;
+        this._enableInFlight = false;
         this.client = room;
         this.client.protocol.addHandler("messaging.send", this._messageHandler);
     }
+    get isEnabled() {
+        return this._desiredEnabled;
+    }
+    get online() {
+        return this._online;
+    }
+    get remoteParticipants() {
+        return Object.values(this._participants);
+    }
     _messageInput(params) {
         const input = {
             type: params.type,
@@ -44,16 +56,110 @@ export class MessagingClient extends EventEmitter {
         }
         return input;
     }
-    _syntheticMessageEvent(params) {
-        return new RoomMessageEvent({
-            message: new RoomMessage({
-                fromParticipantId: params.fromParticipantId,
-                type: params.type,
-                message: params.message,
-                local: true,
-            }),
+    async _invoke({ operation, input, }) {
+        await this.client.invoke({
+            toolkit: "messaging",
+            tool: operation,
+            input: new JsonContent({ json: input }),
+        });
+    }
+    _invokeNowait({ operation, input, }) {
+        this.client.invokeNowait({
+            toolkit: "messaging",
+            tool: operation,
+            input: new JsonContent({ json: input }),
         });
     }
+    start() {
+        if (this._sendTask != null) {
+            return;
+        }
+        this._messageQueueClosed = false;
+        this._sendTask = this._sendMessages();
+        if (this._desiredEnabled && this.client.isConnected) {
+            this._enableCurrentConnectionNowait();
+        }
+    }
+    async stop() {
+        const stoppedError = this.client._messageStopError();
+        this._messageQueueClosed = true;
+        this._wakeMessageQueue();
+        this._drainQueuedMessages({ error: stoppedError });
+        const sendTask = this._sendTask;
+        this._sendTask = null;
+        if (sendTask != null) {
+            await sendTask;
+        }
+        this._desiredEnabled = false;
+        this._clearCurrentConnectionState();
+    }
+    async _nextQueuedMessage() {
+        while (true) {
+            if (this._messageQueue.length > 0) {
+                return this._messageQueue.shift() ?? null;
+            }
+            if (this._messageQueueClosed) {
+                return null;
+            }
+            this._messageQueued ?? (this._messageQueued = new Completer());
+            await this._messageQueued.fut;
+        }
+    }
+    _wakeMessageQueue() {
+        const signal = this._messageQueued;
+        this._messageQueued = null;
+        if (signal != null && !signal.completed) {
+            signal.complete();
+        }
+    }
+    _queueMessage(message) {
+        if (this._messageQueueClosed) {
+            throw new RoomServerException("Cannot send messages because messaging has been stopped");
+        }
+        this._messageQueue.push(message);
+        this._wakeMessageQueue();
+    }
+    _setOnline(online) {
+        if (this._online === online) {
+            return;
+        }
+        this._online = online;
+    }
+    async _waitUntilOnline() {
+        while (!this._online) {
+            if (!this.client.isConnected && !this.client._allowDisconnectedRequests) {
+                await this.client._waitUntilConnectedForMessages();
+                continue;
+            }
+            this.client._raiseIfTerminalForMessages();
+            await new Promise((resolve) => setTimeout(resolve, 50));
+        }
+    }
+    _enableCurrentConnectionNowait() {
+        if (this._online || this._enableInFlight) {
+            return;
+        }
+        this._enableInFlight = true;
+        this._invokeNowait({ operation: "enable", input: {} });
+    }
+    _clearCurrentConnectionState() {
+        this._enableInFlight = false;
+        this._setOnline(false);
+        if (Object.keys(this._participants).length === 0) {
+            return;
+        }
+        for (const participantId of Object.keys(this._participants)) {
+            this._removeParticipant(participantId);
+        }
+    }
+    _onRoomDisconnect({ reason: _reason }) {
+        this._clearCurrentConnectionState();
+    }
+    _onRoomReconnect() {
+        if (this._desiredEnabled) {
+            this._enableCurrentConnectionNowait();
+        }
+    }
     _removeParticipant(participantId) {
         const participant = this._participants[participantId];
         if (participant === undefined) {
@@ -68,18 +174,14 @@ export class MessagingClient extends EventEmitter {
             return;
         }
         participant._setOnline(false);
-        const current = this._participants[participant.id];
-        if (current === undefined) {
-            return;
+        if (this._participants[participant.id] !== undefined) {
+            this._removeParticipant(participant.id);
         }
-        this._removeParticipant(participant.id);
-        this.emit("participant_removed", this._syntheticMessageEvent({
-            fromParticipantId: participant.id,
-            type: "participant.disabled",
-            message: { id: participant.id },
-        }));
     }
     _resolveMessageRecipient(to) {
+        if (to == null) {
+            return null;
+        }
         if (!(to instanceof RemoteParticipant)) {
             return to;
         }
@@ -88,116 +190,100 @@ export class MessagingClient extends EventEmitter {
         }
         return this._participants[to.id] ?? null;
     }
-    _queueMessage(message) {
-        if (this._sendTask === null) {
-            throw new RoomServerException("Cannot send messages because messaging has not been started");
-        }
-        this._messageQueue.push(message);
-        const waiter = this._messageQueued;
-        if (waiter !== null) {
-            this._messageQueued = null;
-            waiter.complete();
+    _dropQueuedMessage({ message, error, }) {
+        if (message.completer != null && !message.completer.completed) {
+            message.completer.completeError(error);
         }
     }
-    _rejectQueuedMessages(error) {
+    _drainQueuedMessages({ error }) {
         while (this._messageQueue.length > 0) {
-            const message = this._messageQueue.shift();
-            message?.completer?.completeError(error);
-        }
-    }
-    _isParticipantNotFound(error) {
-        return error instanceof RoomServerException && error.message === "the participant was not found";
-    }
-    async _nextQueuedMessage() {
-        while (this._messageQueue.length === 0) {
-            if (this._messageQueueClosed) {
-                return null;
-            }
-            if (this._messageQueued === null) {
-                this._messageQueued = new Completer();
+            const queued = this._messageQueue.shift();
+            if (queued != null) {
+                this._dropQueuedMessage({ message: queued, error });
             }
-            await this._messageQueued.fut;
         }
-        return this._messageQueue.shift() ?? null;
     }
     async _sendMessages() {
         while (true) {
-            const queued = await this._nextQueuedMessage();
-            if (queued === null) {
+            const message = await this._nextQueuedMessage();
+            if (message == null) {
                 return;
             }
-            const resolvedTo = this._resolveMessageRecipient(queued.to);
-            if (resolvedTo === null) {
-                const error = new RoomServerException("the participant was not found");
-                if (queued.dropIfOffline) {
-                    queued.completer?.complete();
+            try {
+                await this.client._waitUntilConnectedForMessages();
+                if (this._desiredEnabled) {
+                    await this._waitUntilOnline();
+                }
+            }
+            catch (error) {
+                if (error instanceof RoomServerException) {
+                    this._dropQueuedMessage({ message, error });
+                    this._drainQueuedMessages({ error });
                 }
                 else {
-                    queued.completer?.completeError(error);
+                    const wrapped = new RoomServerException(String(error));
+                    this._dropQueuedMessage({ message, error: wrapped });
+                    this._drainQueuedMessages({ error: wrapped });
                 }
+                return;
+            }
+            const resolvedTo = this._resolveMessageRecipient(message.to);
+            if (resolvedTo == null) {
+                this._dropQueuedMessage({
+                    message,
+                    error: new RoomServerException("the participant was not found"),
+                });
                 continue;
             }
             try {
-                await this.client.invoke({
-                    toolkit: "messaging",
-                    tool: "send",
+                await this._invoke({
+                    operation: "send",
                     input: this._messageInput({
                         toParticipantId: resolvedTo.id,
-                        type: queued.type,
-                        message: queued.message,
-                        attachment: queued.attachment,
+                        type: message.type,
+                        message: message.message,
+                        attachment: message.attachment,
                     }),
                 });
-                queued.completer?.complete();
+                if (message.completer != null && !message.completer.completed) {
+                    message.completer.complete();
+                }
             }
             catch (error) {
-                if (this._isParticipantNotFound(error)) {
-                    this._markParticipantOffline(queued.to);
-                    if (queued.dropIfOffline) {
-                        queued.completer?.complete();
+                if (error instanceof RoomServerException) {
+                    const wrapped = this.client._coerceMessageSendError(error);
+                    if (wrapped.message === "the participant was not found") {
+                        this._markParticipantOffline(message.to);
+                        this._dropQueuedMessage({ message, error: wrapped });
                         continue;
                     }
+                    this._dropQueuedMessage({ message, error: wrapped });
+                    continue;
+                }
+                if (message.completer != null && !message.completer.completed) {
+                    message.completer.completeError(error);
                 }
-                queued.completer?.completeError(error);
             }
         }
     }
-    async start() {
-        if (this._sendTask !== null) {
-            return;
-        }
-        this._messageQueueClosed = false;
-        this._sendTask = this._sendMessages();
-    }
-    async stop() {
-        if (this._sendTask === null) {
-            this._enabled = false;
-            return;
-        }
-        this._messageQueueClosed = true;
-        const waiter = this._messageQueued;
-        if (waiter !== null) {
-            this._messageQueued = null;
-            waiter.complete();
+    async sendMessage({ to, type, message, attachment, ignoreOffline = false, }) {
+        if (this._sendTask == null) {
+            throw new RoomServerException("Cannot send messages because messaging has not been started");
         }
-        const sendTask = this._sendTask;
-        this._sendTask = null;
-        await sendTask;
-        this._enabled = false;
-    }
-    async sendMessage({ to, type, message, attachment, ignoreOffline = false }) {
-        const completer = new Completer();
-        this._queueMessage({
+        const queued = {
             to,
             type,
             message,
             attachment,
             dropIfOffline: ignoreOffline,
-            completer,
-        });
-        await completer.fut;
+            completer: ignoreOffline ? undefined : new Completer(),
+        };
+        this._queueMessage(queued);
+        if (queued.completer != null) {
+            await queued.completer.fut;
+        }
     }
-    sendMessageNowait({ to, type, message, attachment }) {
+    sendMessageNowait({ to, type, message, attachment, }) {
         this._queueMessage({
             to,
             type,
@@ -206,34 +292,40 @@ export class MessagingClient extends EventEmitter {
             dropIfOffline: true,
         });
     }
-    async enable() {
-        await this.client.invoke({
-            toolkit: "messaging",
-            tool: "enable",
-            input: {},
-        });
-        this._enabled = true;
-    }
-    async disable() {
-        await this.client.invoke({
-            toolkit: "messaging",
-            tool: "disable",
-            input: {},
-        });
-        this._enabled = false;
-    }
-    async broadcastMessage({ type, message, attachment }) {
-        await this.client.invoke({
-            toolkit: "messaging",
-            tool: "broadcast",
-            input: this._messageInput({ type, message, attachment }),
-        });
+    enable() {
+        this._desiredEnabled = true;
+        if (this.client.isConnected) {
+            this._enableCurrentConnectionNowait();
+        }
     }
-    get remoteParticipants() {
-        return Object.values(this._participants);
+    disable() {
+        const wasOnline = this._online;
+        this._desiredEnabled = false;
+        this._clearCurrentConnectionState();
+        if (this.client.isConnected && wasOnline) {
+            this._invokeNowait({ operation: "disable", input: {} });
+        }
     }
-    get isEnabled() {
-        return this._enabled;
+    async broadcastMessage({ type, message, attachment, }) {
+        if (this._sendTask == null) {
+            throw new RoomServerException("Cannot send messages because messaging has not been started");
+        }
+        await this.client._waitUntilConnectedForMessages();
+        if (this._desiredEnabled) {
+            await this._waitUntilOnline();
+        }
+        try {
+            await this._invoke({
+                operation: "broadcast",
+                input: this._messageInput({ type, message, attachment }),
+            });
+        }
+        catch (error) {
+            if (error instanceof RoomServerException) {
+                throw this.client._coerceMessageSendError(error);
+            }
+            throw error;
+        }
     }
     getParticipants() {
         return this.remoteParticipants;
@@ -249,15 +341,18 @@ export class MessagingClient extends EventEmitter {
         }
         return null;
     }
-    async _handleMessageSend(protocol, messageId, type, bytes) {
-        const headerStr = splitMessageHeader(bytes || new Uint8Array());
-        const payload = splitMessagePayload(bytes || new Uint8Array());
+    async _handleMessageSend(protocol, _messageId, _type, bytes) {
+        if (!this.client.isActiveProtocol(protocol)) {
+            return;
+        }
+        const headerStr = splitMessageHeader(bytes);
+        const payload = splitMessagePayload(bytes);
         const header = JSON.parse(headerStr);
         const message = new RoomMessage({
             fromParticipantId: header["from_participant_id"],
             type: header["type"],
             message: header["message"],
-            attachment: payload,
+            attachment: payload.length > 0 ? payload : undefined,
         });
         switch (message.type) {
             case "messaging.enabled":
@@ -272,54 +367,61 @@ export class MessagingClient extends EventEmitter {
             case "participant.disabled":
                 this._onParticipantDisabled(message);
                 break;
+            default:
+                break;
         }
-        const messageEvent = new RoomMessageEvent({ message });
-        this.client.emit(messageEvent);
-        this.emit("message", messageEvent);
+        const event = new RoomMessageEvent({ message });
+        this.client.emit(event);
+        this.emit("message", event);
     }
     _onParticipantEnabled(message) {
         const data = message.message;
-        const p = new RemoteParticipant(this.client, data["id"], data["role"], true);
-        p._setAttributes(data["attributes"] ?? {});
-        this._participants[data["id"]] = p;
-        this.emit("participant_added", { message });
+        const participant = new RemoteParticipant(this.client, data.id, data.role, true);
+        participant._setAttributes(data.attributes ?? {});
+        this._participants[data.id] = participant;
+        this.emit("participant_added", new RoomMessageEvent({ message }));
     }
     _onParticipantAttributes(message) {
-        const part = this._participants[message.fromParticipantId];
-        if (!part) {
+        const participant = this._participants[message.fromParticipantId];
+        if (participant == null) {
             return;
         }
-        const attrObj = message.message["attributes"];
-        part._setAttributes(attrObj);
-        this.emit("participant_attributes_updated", { message });
+        participant._setAttributes(message.message["attributes"]);
+        this.emit("participant_attributes_updated", new RoomMessageEvent({ message }));
     }
     _onParticipantDisabled(message) {
-        const part = this._removeParticipant(message.message["id"]);
-        if (part) {
-            this.emit("participant_removed", { message });
+        const removed = this._removeParticipant(String(message.message["id"]));
+        if (removed != null) {
+            this.emit("participant_removed", new RoomMessageEvent({ message }));
         }
     }
     _onMessagingEnabled(message) {
+        this._enableInFlight = false;
+        for (const participantId of Object.keys(this._participants)) {
+            delete this._participants[participantId];
+        }
         const participants = message.message["participants"];
         for (const data of participants) {
-            const rp = new RemoteParticipant(this.client, data["id"], data["role"], true);
-            rp._setAttributes(data["attributes"] ?? {});
-            this._participants[data["id"]] = rp;
+            const participant = new RemoteParticipant(this.client, data.id, data.role, true);
+            participant._setAttributes(data.attributes ?? {});
+            this._participants[data.id] = participant;
+        }
+        this._setOnline(true);
+        if (!this._desiredEnabled) {
+            this._invokeNowait({ operation: "disable", input: {} });
+            this._clearCurrentConnectionState();
+            return;
         }
-        this._enabled = true;
-        this.emit("messaging_enabled", { message });
+        this.emit("messaging_enabled", new RoomMessageEvent({ message }));
     }
     dispose() {
         const error = new RoomServerException("messaging client disposed");
         this._messageQueueClosed = true;
-        this._enabled = false;
-        this._rejectQueuedMessages(error);
-        const waiter = this._messageQueued;
-        if (waiter !== null) {
-            this._messageQueued = null;
-            waiter.complete();
-        }
+        this._wakeMessageQueue();
+        this._drainQueuedMessages({ error });
+        this._desiredEnabled = false;
+        this._clearCurrentConnectionState();
+        this.client.protocol.removeHandler("messaging.send", this._messageHandler);
         super.dispose();
-        this.client.protocol.removeHandler("messaging.send");
     }
 }

package/dist/esm/participant.d.ts

@@ -1,14 +1,19 @@
 import { RoomClient } from "./room-client";
 export declare abstract class Participant {
-    readonly id: string;
+    id: string;
     protected readonly client: RoomClient;
     protected _attributes: Record<string, unknown>;
     protected _connections: string[];
     constructor(client: RoomClient, id: string);
     get connections(): ReadonlyArray<string>;
     getAttribute(name: string): unknown;
+    _replaceIdentity({ participantId, attributes, }: {
+        participantId: string;
+        attributes: Record<string, unknown>;
+    }): void;
     _setAttribute(name: string, value: unknown): void;
     _setAttributes(attributes: Record<string, unknown>): void;
+    _attributesSnapshot(): Record<string, unknown>;
 }
 export declare class RemoteParticipant extends Participant {
     readonly role: string;
@@ -18,5 +23,5 @@ export declare class RemoteParticipant extends Participant {
 }
 export declare class LocalParticipant extends Participant {
     constructor(client: RoomClient, id: string);
-    setAttribute(name: string, value: unknown): Promise<void>;
+    setAttribute(name: string, value: unknown): void;
 }

package/dist/esm/participant.js

@@ -1,4 +1,3 @@
-import { packMessage } from "./utils";
 export class Participant {
     constructor(client, id) {
         this._attributes = {};
@@ -12,6 +11,10 @@ export class Participant {
     getAttribute(name) {
         return this._attributes[name];
     }
+    _replaceIdentity({ participantId, attributes, }) {
+        this.id = participantId;
+        this._attributes = { ...attributes };
+    }
     _setAttribute(name, value) {
         this._attributes[name] = value;
     }
@@ -20,6 +23,9 @@ export class Participant {
             this._setAttribute(name, value);
         }
     }
+    _attributesSnapshot() {
+        return { ...this._attributes };
+    }
 }
 export class RemoteParticipant extends Participant {
     constructor(client, id, role, online) {
@@ -35,14 +41,8 @@ export class LocalParticipant extends Participant {
     constructor(client, id) {
         super(client, id);
     }
-    async setAttribute(name, value) {
+    setAttribute(name, value) {
         this._setAttribute(name, value);
-        try {
-            const payload = packMessage({ [name]: value });
-            await this.client.protocol.send("set_attributes", payload);
-        }
-        catch (err) {
-            console.warn("Unable to send attribute changes", err);
-        }
+        this.client._sendLocalAttributesNowait({ [name]: value });
     }
 }