@meshagent/meshagent 0.39.3 → 0.39.5

package/dist/esm/protocol.js

@@ -1,27 +1,34 @@
-import WebSocket from "isomorphic-ws";
-import { Completer } from "./completer";
-import { decoder, encoder, mergeUint8Arrays, unpackMessage } from "./utils";
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketClientProtocol = exports.Protocol = exports.ProtocolMessageStream = exports.WebSocketProtocolChannel = exports.StreamProtocolChannel = exports.ProtocolHandshakeException = exports.ProtocolCloseException = exports.ProtocolReconnectUnsupportedException = exports.ProtocolCloseKind = void 0;
+const isomorphic_ws_1 = __importDefault(require("isomorphic-ws"));
+const completer_1 = require("./completer");
+const utils_1 = require("./utils");
 class ProtocolMessage {
     constructor({ id, type, data }) {
         this.id = id;
         this.type = type;
         this.data = data;
-        this.sent = new Completer();
+        this.sent = new completer_1.Completer();
     }
 }
-export var ProtocolCloseKind;
+var ProtocolCloseKind;
 (function (ProtocolCloseKind) {
     ProtocolCloseKind["CLIENT"] = "client";
     ProtocolCloseKind["SERVER"] = "server";
     ProtocolCloseKind["ERROR"] = "error";
-})(ProtocolCloseKind || (ProtocolCloseKind = {}));
-export class ProtocolReconnectUnsupportedException extends Error {
+})(ProtocolCloseKind || (exports.ProtocolCloseKind = ProtocolCloseKind = {}));
+class ProtocolReconnectUnsupportedException extends Error {
     constructor(message) {
         super(message);
         this.name = "ProtocolReconnectUnsupportedException";
     }
 }
-export class ProtocolCloseException extends Error {
+exports.ProtocolReconnectUnsupportedException = ProtocolReconnectUnsupportedException;
+class ProtocolCloseException extends Error {
     constructor({ closeCode, reason }) {
         super(reason == null || reason.trim().length === 0 ? `connection closed with status ${closeCode}` : reason);
         this.name = "ProtocolCloseException";
@@ -29,7 +36,8 @@ export class ProtocolCloseException extends Error {
         this.reason = reason;
     }
 }
-export class ProtocolHandshakeException extends Error {
+exports.ProtocolCloseException = ProtocolCloseException;
+class ProtocolHandshakeException extends Error {
     constructor({ statusCode, statusText }) {
         const normalizedStatusText = statusText?.trim();
         super(normalizedStatusText == null || normalizedStatusText.length === 0
@@ -40,10 +48,11 @@ export class ProtocolHandshakeException extends Error {
         this.statusText = normalizedStatusText;
     }
 }
+exports.ProtocolHandshakeException = ProtocolHandshakeException;
 function isNodeRuntime() {
     return typeof process !== "undefined" && process.release?.name === "node";
 }
-export class StreamProtocolChannel {
+class StreamProtocolChannel {
     constructor({ input, output, }) {
         this.started = false;
         this._iterator = null;
@@ -81,10 +90,11 @@ export class StreamProtocolChannel {
         this.output.add(data);
     }
 }
-export class WebSocketProtocolChannel {
+exports.StreamProtocolChannel = StreamProtocolChannel;
+class WebSocketProtocolChannel {
     constructor({ url, jwt }) {
         this.webSocket = null;
-        this._opened = new Completer();
+        this._opened = new completer_1.Completer();
         this._finished = false;
         this._onUnexpectedResponse = (_request, response) => {
             const statusCode = response.statusCode;
@@ -111,7 +121,7 @@ export class WebSocketProtocolChannel {
                 return;
             }
             if (typeof data === "string") {
-                this._onDataReceived?.(encoder.encode(data));
+                this._onDataReceived?.(utils_1.encoder.encode(data));
                 return;
             }
             if (data instanceof ArrayBuffer) {
@@ -143,12 +153,12 @@ export class WebSocketProtocolChannel {
     start(onDataReceived, { onDone, onError }) {
         const url = new URL(this.url);
         url.searchParams.set("token", this.jwt);
-        this._opened = new Completer();
+        this._opened = new completer_1.Completer();
         this._finished = false;
         this._onDataReceived = onDataReceived;
         this._doneHandler = onDone;
         this._errorHandler = onError;
-        const socket = new WebSocket(url.toString());
+        const socket = new isomorphic_ws_1.default(url.toString());
         this.webSocket = socket;
         if (isNodeRuntime()) {
             socket.on("unexpected-response", this._onUnexpectedResponse);
@@ -183,7 +193,7 @@ export class WebSocketProtocolChannel {
         if (isNodeRuntime()) {
             socket.off("unexpected-response", this._onUnexpectedResponse);
         }
-        if (socket.readyState === WebSocket.CONNECTING || socket.readyState === WebSocket.OPEN) {
+        if (socket.readyState === isomorphic_ws_1.default.CONNECTING || socket.readyState === isomorphic_ws_1.default.OPEN) {
             socket.close(1000);
         }
     }
@@ -196,10 +206,11 @@ export class WebSocketProtocolChannel {
         socket.send(data);
     }
 }
-export class ProtocolMessageStream {
+exports.WebSocketProtocolChannel = WebSocketProtocolChannel;
+class ProtocolMessageStream {
     constructor() {
         this._messages = [];
-        this._messageAdded = new Completer();
+        this._messageAdded = new completer_1.Completer();
         this._closed = false;
     }
     add(message) {
@@ -217,7 +228,7 @@ export class ProtocolMessageStream {
     async *stream() {
         while (!this._closed) {
             await this._messageAdded.fut;
-            this._messageAdded = new Completer();
+            this._messageAdded = new completer_1.Completer();
             while (this._messages.length > 0 && !this._closed) {
                 const message = this._messages.shift();
                 if (message !== undefined) {
@@ -227,12 +238,13 @@ export class ProtocolMessageStream {
         }
     }
 }
-export class Protocol {
+exports.ProtocolMessageStream = ProtocolMessageStream;
+class Protocol {
     constructor({ channel }) {
         this.handlers = {};
         this._id = 0;
         this._send = new ProtocolMessageStream();
-        this._done = new Completer();
+        this._done = new completer_1.Completer();
         this._sendLoop = null;
         this._open = false;
         this._closed = false;
@@ -311,7 +323,7 @@ export class Protocol {
     async handleMessage(messageId, type, data) {
         const handler = this.handlers[type] ?? this.handlers["*"];
         if (handler == null) {
-            const unpacked = unpackMessage(data);
+            const unpacked = (0, utils_1.unpackMessage)(data);
             console.warn(`No handler for message type ${type}; data:`, unpacked);
             return;
         }
@@ -343,7 +355,7 @@ export class Protocol {
         await message.sent.fut;
     }
     async sendJson(object) {
-        await this.send("application/json", encoder.encode(JSON.stringify(object)));
+        await this.send("application/json", utils_1.encoder.encode(JSON.stringify(object)));
     }
     start({ onMessage, onDone, onError, } = {}) {
         if (this._sendLoop != null) {
@@ -405,14 +417,14 @@ export class Protocol {
                 headerView.setUint32(4, message.id & 0xffffffff, false);
                 headerView.setUint32(8, 0, false);
                 headerView.setUint32(12, packets, false);
-                await this.channel.sendData(mergeUint8Arrays(header, encoder.encode(message.type)));
+                await this.channel.sendData((0, utils_1.mergeUint8Arrays)(header, utils_1.encoder.encode(message.type)));
                 for (let i = 0; i < packets; i += 1) {
                     const packetHeader = new Uint8Array(12);
                     const packetHeaderView = new DataView(packetHeader.buffer);
                     packetHeaderView.setUint32(0, Math.floor(message.id / 2 ** 32), false);
                     packetHeaderView.setUint32(4, message.id & 0xffffffff, false);
                     packetHeaderView.setUint32(8, i + 1, false);
-                    await this.channel.sendData(mergeUint8Arrays(packetHeader, message.data.subarray(i * 1024, Math.min((i + 1) * 1024, message.data.length))));
+                    await this.channel.sendData((0, utils_1.mergeUint8Arrays)(packetHeader, message.data.subarray(i * 1024, Math.min((i + 1) * 1024, message.data.length))));
                 }
                 if (!message.sent.completed) {
                     message.sent.complete();
@@ -447,10 +459,10 @@ export class Protocol {
             if (this._recvState === "ready" || this._recvState === "error") {
                 this._recvPacketTotal = dataView.getUint32(12, false);
                 this._recvMessageId = messageId;
-                this._recvType = decoder.decode(dataPacket.subarray(16));
+                this._recvType = utils_1.decoder.decode(dataPacket.subarray(16));
                 if (this._recvPacketTotal === 0) {
                     try {
-                        const merged = mergeUint8Arrays(...this._recvPackets);
+                        const merged = (0, utils_1.mergeUint8Arrays)(...this._recvPackets);
                         this._recvPackets.length = 0;
                         this._dispatchMessage({ messageId, type: this._recvType, data: merged });
                     }
@@ -484,7 +496,7 @@ export class Protocol {
         this._recvPackets.push(dataPacket.subarray(12));
         if (this._recvPacketTotal === this._recvPacketId) {
             try {
-                const merged = mergeUint8Arrays(...this._recvPackets);
+                const merged = (0, utils_1.mergeUint8Arrays)(...this._recvPackets);
                 this._recvPackets.length = 0;
                 this._dispatchMessage({ messageId, type: this._recvType, data: merged });
             }
@@ -504,7 +516,8 @@ export class Protocol {
         });
     }
 }
-export class WebSocketClientProtocol extends Protocol {
+exports.Protocol = Protocol;
+class WebSocketClientProtocol extends Protocol {
     constructor({ url, token }) {
         super({
             channel: new WebSocketProtocolChannel({ url, jwt: token }),
@@ -519,3 +532,4 @@ export class WebSocketClientProtocol extends Protocol {
         return this._token;
     }
 }
+exports.WebSocketClientProtocol = WebSocketClientProtocol;

package/dist/esm/queues-client.js

@@ -1,17 +1,21 @@
-import { EmptyContent, JsonContent } from "./response";
-import { RoomServerException } from "./room-server-client";
-export class Queue {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueuesClient = exports.Queue = void 0;
+const response_1 = require("./response");
+const room_server_client_1 = require("./room-server-client");
+class Queue {
     constructor({ name, size }) {
         this.name = name;
         this.size = size;
     }
 }
-export class QueuesClient {
+exports.Queue = Queue;
+class QueuesClient {
     constructor({ room }) {
         this.client = room;
     }
     _unexpectedResponseError(operation) {
-        return new RoomServerException(`unexpected return type from queues.${operation}`);
+        return new room_server_client_1.RoomServerException(`unexpected return type from queues.${operation}`);
     }
     async _invoke(operation, arguments_) {
         return await this.client.invoke({
@@ -22,7 +26,7 @@ export class QueuesClient {
     }
     async list() {
         const response = await this._invoke("list", {});
-        if (!(response instanceof JsonContent)) {
+        if (!(response instanceof response_1.JsonContent)) {
             throw this._unexpectedResponseError("list");
         }
         const queues = response.json["queues"];
@@ -30,25 +34,25 @@ export class QueuesClient {
     }
     async open(name) {
         const response = await this._invoke("open", { name });
-        if (!(response instanceof EmptyContent)) {
+        if (!(response instanceof response_1.EmptyContent)) {
             throw this._unexpectedResponseError("open");
         }
     }
     async drain(name) {
         const response = await this._invoke("drain", { name });
-        if (!(response instanceof EmptyContent)) {
+        if (!(response instanceof response_1.EmptyContent)) {
             throw this._unexpectedResponseError("drain");
         }
     }
     async close(name) {
         const response = await this._invoke("close", { name });
-        if (!(response instanceof EmptyContent)) {
+        if (!(response instanceof response_1.EmptyContent)) {
             throw this._unexpectedResponseError("close");
         }
     }
     async send(name, message, { create = true }) {
         const response = await this._invoke("send", { name, create, message });
-        if (!(response instanceof EmptyContent)) {
+        if (!(response instanceof response_1.EmptyContent)) {
             throw this._unexpectedResponseError("send");
         }
     }
@@ -58,12 +62,13 @@ export class QueuesClient {
             create,
             wait,
         });
-        if (response instanceof EmptyContent) {
+        if (response instanceof response_1.EmptyContent) {
             return null;
         }
-        if (response instanceof JsonContent) {
+        if (response instanceof response_1.JsonContent) {
             return response.json;
         }
         throw this._unexpectedResponseError("receive");
     }
 }
+exports.QueuesClient = QueuesClient;

package/dist/esm/requirement.js

@@ -1,10 +1,14 @@
-export class RoomException extends Error {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequiredSchema = exports.RequiredToolkit = exports.Requirement = exports.RoomException = void 0;
+class RoomException extends Error {
     constructor(message) {
         super(message);
         this.name = "RoomException";
     }
 }
-export class Requirement {
+exports.RoomException = RoomException;
+class Requirement {
     constructor({ name }) {
         this.name = name;
     }
@@ -22,7 +26,8 @@ export class Requirement {
         throw new RoomException("invalid requirement json");
     }
 }
-export class RequiredToolkit extends Requirement {
+exports.Requirement = Requirement;
+class RequiredToolkit extends Requirement {
     constructor({ name, tools, participantName, }) {
         super({ name });
         this.tools = tools;
@@ -36,7 +41,8 @@ export class RequiredToolkit extends Requirement {
         };
     }
 }
-export class RequiredSchema extends Requirement {
+exports.RequiredToolkit = RequiredToolkit;
+class RequiredSchema extends Requirement {
     constructor({ name }) {
         super({ name });
     }
@@ -46,3 +52,4 @@ export class RequiredSchema extends Requirement {
         };
     }
 }
+exports.RequiredSchema = RequiredSchema;

package/dist/esm/response.js

@@ -1,5 +1,9 @@
-import { packMessage, splitMessageHeader, splitMessagePayload } from "./utils";
-export class BinaryContent {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ControlContent = exports.ControlCloseStatus = exports.EmptyContent = exports.ErrorContent = exports.JsonContent = exports.TextContent = exports.FileContent = exports.LinkContent = exports.BinaryContent = void 0;
+exports.unpackContent = unpackContent;
+const utils_1 = require("./utils");
+class BinaryContent {
     constructor({ data, headers = {} }) {
         this.data = data;
         this.headers = headers;
@@ -11,7 +15,7 @@ export class BinaryContent {
         });
     }
     pack() {
-        return packMessage({
+        return (0, utils_1.packMessage)({
             type: "binary",
             headers: this.headers,
         }, this.data);
@@ -20,7 +24,8 @@ export class BinaryContent {
         return `BinaryContent: headers=${JSON.stringify(this.headers)} length=${this.data.length}`;
     }
 }
-export class LinkContent {
+exports.BinaryContent = BinaryContent;
+class LinkContent {
     constructor({ url, name }) {
         this.url = url;
         this.name = name;
@@ -32,7 +37,7 @@ export class LinkContent {
         });
     }
     pack() {
-        return packMessage({
+        return (0, utils_1.packMessage)({
             type: "link",
             name: this.name,
             url: this.url,
@@ -42,7 +47,8 @@ export class LinkContent {
         return `LinkContent (${this.name}): ${this.url}`;
     }
 }
-export class FileContent {
+exports.LinkContent = LinkContent;
+class FileContent {
     constructor({ data, name, mimeType }) {
         this.data = data;
         this.name = name;
@@ -56,7 +62,7 @@ export class FileContent {
         });
     }
     pack() {
-        return packMessage({
+        return (0, utils_1.packMessage)({
             type: "file",
             name: this.name,
             mime_type: this.mimeType,
@@ -66,7 +72,8 @@ export class FileContent {
         return `FileContent (${this.name}): ${this.mimeType}`;
     }
 }
-export class TextContent {
+exports.FileContent = FileContent;
+class TextContent {
     constructor({ text }) {
         this.text = text;
     }
@@ -76,7 +83,7 @@ export class TextContent {
         });
     }
     pack() {
-        return packMessage({
+        return (0, utils_1.packMessage)({
             type: "text",
             text: this.text,
         });
@@ -85,7 +92,8 @@ export class TextContent {
         return `TextContent: ${this.text}`;
     }
 }
-export class JsonContent {
+exports.TextContent = TextContent;
+class JsonContent {
     constructor({ json }) {
         this.json = json;
     }
@@ -93,7 +101,7 @@ export class JsonContent {
         return new JsonContent({ json: header["json"] });
     }
     pack() {
-        return packMessage({
+        return (0, utils_1.packMessage)({
             type: "json",
             json: this.json,
         });
@@ -102,7 +110,8 @@ export class JsonContent {
         return `JsonContent: ${JSON.stringify(this.json)}`;
     }
 }
-export class ErrorContent {
+exports.JsonContent = JsonContent;
+class ErrorContent {
     constructor({ text, code }) {
         this.text = text;
         this.code = code;
@@ -129,7 +138,7 @@ export class ErrorContent {
         if (this.code !== undefined) {
             header["code"] = this.code;
         }
-        return packMessage(header);
+        return (0, utils_1.packMessage)(header);
     }
     toString() {
         return this.code !== undefined
@@ -137,23 +146,25 @@ export class ErrorContent {
             : `ErrorContent: ${this.text}`;
     }
 }
-export class EmptyContent {
+exports.ErrorContent = ErrorContent;
+class EmptyContent {
     static unpack(_header, _payload) {
         return new EmptyContent();
     }
     pack() {
-        return packMessage({ type: "empty" });
+        return (0, utils_1.packMessage)({ type: "empty" });
     }
     toString() {
         return `EmptyContent`;
     }
 }
-export var ControlCloseStatus;
+exports.EmptyContent = EmptyContent;
+var ControlCloseStatus;
 (function (ControlCloseStatus) {
     ControlCloseStatus[ControlCloseStatus["NORMAL"] = 1000] = "NORMAL";
     ControlCloseStatus[ControlCloseStatus["INVALID_DATA"] = 1007] = "INVALID_DATA";
-})(ControlCloseStatus || (ControlCloseStatus = {}));
-export class ControlContent {
+})(ControlCloseStatus || (exports.ControlCloseStatus = ControlCloseStatus = {}));
+class ControlContent {
     constructor({ method, statusCode, message, }) {
         this.method = method;
         this.statusCode = method === "close" ? statusCode ?? ControlCloseStatus.NORMAL : statusCode;
@@ -192,12 +203,13 @@ export class ControlContent {
                 header["message"] = this.message;
             }
         }
-        return packMessage(header);
+        return (0, utils_1.packMessage)(header);
     }
     toString() {
         return `ControlContent: ${this.method}`;
     }
 }
+exports.ControlContent = ControlContent;
 const _contentTypes = {
     binary: BinaryContent.unpack,
     control: ControlContent.unpack,
@@ -208,9 +220,9 @@ const _contentTypes = {
     link: LinkContent.unpack,
     text: TextContent.unpack,
 };
-export function unpackContent(data) {
-    const header = JSON.parse(splitMessageHeader(data));
-    const payload = splitMessagePayload(data);
+function unpackContent(data) {
+    const header = JSON.parse((0, utils_1.splitMessageHeader)(data));
+    const payload = (0, utils_1.splitMessagePayload)(data);
     const typeKey = header["type"];
     if (!_contentTypes[typeKey]) {
         throw new Error(`Unknown content type: ${typeKey}`);

package/dist/esm/room-client.d.ts

@@ -85,7 +85,8 @@ export declare class RoomClient {
     private _roomName;
     private _roomUrl;
     private _sessionId;
-    private static readonly RECONNECT_RETRY_INTERVAL_MS;
+    private static readonly RECONNECT_RETRY_BASE_DELAY_MS;
+    private static readonly RECONNECT_RETRY_MAX_DELAY_MS;
     private readonly _handleRoomReadyBound;
     private readonly _handleRoomStatusBound;
     private readonly _handleParticipantBound;
@@ -151,6 +152,7 @@ export declare class RoomClient {
     private _completeReconnect;
     private _replaceProtocol;
     private _remainingReconnectTimeout;
+    private _reconnectRetryDelay;
     private _attemptInitialProtocolStartup;
     private _attemptReconnect;
     private _formatDuration;