@meshagent/meshagent 0.37.2 → 0.38.1

package/dist/esm/protocol.js

@@ -1,6 +1,6 @@
 import WebSocket from "isomorphic-ws";
-import { mergeUint8Arrays, decoder, encoder, unpackMessage } from "./utils";
 import { Completer } from "./completer";
+import { decoder, encoder, mergeUint8Arrays, unpackMessage } from "./utils";
 class ProtocolMessage {
     constructor({ id, type, data }) {
         this.id = id;
@@ -9,8 +9,42 @@ class ProtocolMessage {
         this.sent = new Completer();
     }
 }
+export var ProtocolCloseKind;
+(function (ProtocolCloseKind) {
+    ProtocolCloseKind["CLIENT"] = "client";
+    ProtocolCloseKind["SERVER"] = "server";
+    ProtocolCloseKind["ERROR"] = "error";
+})(ProtocolCloseKind || (ProtocolCloseKind = {}));
+export class ProtocolReconnectUnsupportedException extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ProtocolReconnectUnsupportedException";
+    }
+}
+export class ProtocolCloseException extends Error {
+    constructor({ closeCode, reason }) {
+        super(reason == null || reason.trim().length === 0 ? `connection closed with status ${closeCode}` : reason);
+        this.name = "ProtocolCloseException";
+        this.closeCode = closeCode;
+        this.reason = reason;
+    }
+}
+export class ProtocolHandshakeException extends Error {
+    constructor({ statusCode, statusText }) {
+        const normalizedStatusText = statusText?.trim();
+        super(normalizedStatusText == null || normalizedStatusText.length === 0
+            ? `websocket connect failed with status ${statusCode}`
+            : `websocket connect failed with status ${statusCode}: ${normalizedStatusText}`);
+        this.name = "ProtocolHandshakeException";
+        this.statusCode = statusCode;
+        this.statusText = normalizedStatusText;
+    }
+}
+function isNodeRuntime() {
+    return typeof process !== "undefined" && process.release?.name === "node";
+}
 export class StreamProtocolChannel {
-    constructor({ input, output }) {
+    constructor({ input, output, }) {
         this.started = false;
         this._iterator = null;
         this.input = input;
@@ -22,29 +56,24 @@ export class StreamProtocolChannel {
         }
         this.started = true;
         (async () => {
-            this._iterator?.return(null);
+            this._iterator?.return(undefined);
             try {
                 this._iterator = this.input.stream();
                 for await (const message of this._iterator) {
-                    if (message) {
-                        onDataReceived(message);
-                    }
+                    onDataReceived(message);
                 }
+                onDone?.();
             }
             catch (error) {
-                if (onError) {
-                    onError(error);
-                }
-            }
-            finally {
-                if (onDone) {
-                    onDone();
-                }
+                onError?.(error);
             }
-        })();
+        })().catch((error) => {
+            onError?.(error);
+        });
     }
     dispose() {
-        this._iterator?.return(null);
+        this.started = false;
+        this._iterator?.return(undefined);
         this._iterator = null;
         this.input.close();
     }
@@ -56,54 +85,115 @@ export class WebSocketProtocolChannel {
     constructor({ url, jwt }) {
         this.webSocket = null;
         this._opened = new Completer();
-        this._onOpen = () => this._opened.resolve();
-        this._onData = (event) => {
+        this._finished = false;
+        this._onUnexpectedResponse = (_request, response) => {
+            const statusCode = response.statusCode;
+            if (statusCode == null) {
+                this._finish("error", new Error("websocket connect failed"));
+                return;
+            }
+            this._finish("error", new ProtocolHandshakeException({
+                statusCode,
+                statusText: response.statusMessage,
+            }));
+        };
+        this._onOpen = () => {
+            if (!this._opened.completed) {
+                this._opened.complete();
+            }
+        };
+        this._onMessage = (event) => {
             const data = event.data;
             if (data instanceof Blob) {
-                data.arrayBuffer().then((buffer) => {
-                    if (this.onDataReceived) {
-                        this.onDataReceived(new Uint8Array(buffer));
-                    }
+                void data.arrayBuffer().then((buffer) => {
+                    this._onDataReceived?.(new Uint8Array(buffer));
                 });
+                return;
             }
-            else if (typeof (data) == "string") {
-                if (this.onDataReceived) {
-                    this.onDataReceived(new Uint8Array(encoder.encode(data)));
-                }
+            if (typeof data === "string") {
+                this._onDataReceived?.(encoder.encode(data));
+                return;
             }
-            else if (data instanceof ArrayBuffer || data instanceof Buffer) {
-                if (this.onDataReceived) {
-                    this.onDataReceived(new Uint8Array(data));
-                }
+            if (data instanceof ArrayBuffer) {
+                this._onDataReceived?.(new Uint8Array(data));
+                return;
             }
+            if (data instanceof Uint8Array) {
+                this._onDataReceived?.(data);
+                return;
+            }
+            if (ArrayBuffer.isView(data)) {
+                this._onDataReceived?.(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+            }
+        };
+        this._onClose = (event) => {
+            if (event.code === 1000) {
+                this._finish("done");
+                return;
+            }
+            const reason = typeof event.reason === "string" ? event.reason : event.reason.toString();
+            this._finish("error", new ProtocolCloseException({ closeCode: event.code, reason }));
+        };
+        this._onError = (event) => {
+            this._finish("error", event instanceof Error ? event : new Error("websocket error"));
         };
         this.url = url;
         this.jwt = jwt;
     }
     start(onDataReceived, { onDone, onError }) {
-        if (typeof (onDataReceived) != "function") {
-            throw new Error("onDataReceived must be a function");
-        }
         const url = new URL(this.url);
         url.searchParams.set("token", this.jwt);
-        this.onDataReceived = onDataReceived;
-        this.webSocket = new WebSocket(url.toString());
-        this.webSocket.addEventListener("open", this._onOpen);
-        this.webSocket.addEventListener("message", this._onData);
-        if (onDone) {
-            this.webSocket.addEventListener("close", onDone);
+        this._opened = new Completer();
+        this._finished = false;
+        this._onDataReceived = onDataReceived;
+        this._doneHandler = onDone;
+        this._errorHandler = onError;
+        const socket = new WebSocket(url.toString());
+        this.webSocket = socket;
+        if (isNodeRuntime()) {
+            socket.on("unexpected-response", this._onUnexpectedResponse);
         }
-        if (onError) {
-            this.webSocket.addEventListener("error", onError);
+        socket.addEventListener("open", this._onOpen);
+        socket.addEventListener("message", this._onMessage);
+        socket.addEventListener("close", this._onClose);
+        socket.addEventListener("error", this._onError);
+    }
+    _finish(kind, error) {
+        if (this._finished) {
+            return;
         }
+        this._finished = true;
+        if (kind === "done") {
+            this._doneHandler?.();
+            return;
+        }
+        this._errorHandler?.(error);
     }
     dispose() {
-        this.webSocket?.close();
+        const socket = this.webSocket;
         this.webSocket = null;
+        this._onDataReceived = undefined;
+        if (socket == null) {
+            return;
+        }
+        socket.removeEventListener("open", this._onOpen);
+        socket.removeEventListener("message", this._onMessage);
+        socket.removeEventListener("close", this._onClose);
+        socket.removeEventListener("error", this._onError);
+        if (isNodeRuntime()) {
+            socket.off("unexpected-response", this._onUnexpectedResponse);
+        }
+        if (socket.readyState === WebSocket.CONNECTING || socket.readyState === WebSocket.OPEN) {
+            socket.close(1000);
+        }
     }
     async sendData(data) {
         await this._opened.fut;
-        this.webSocket?.send(data);
+        const socket = this.webSocket;
+        if (socket == null) {
+            throw new Error("websocket is closed");
+        }
+        socket.send(data);
     }
 }
 export class ProtocolMessageStream {
@@ -112,15 +202,15 @@ export class ProtocolMessageStream {
         this._messageAdded = new Completer();
         this._closed = false;
     }
-    async add(message) {
+    add(message) {
         this._messages.push(message);
         if (!this._messageAdded.completed) {
             this._messageAdded.complete();
         }
     }
     close() {
+        this._closed = true;
         if (!this._messageAdded.completed) {
-            this._closed = true;
             this._messageAdded.complete();
         }
     }
@@ -129,9 +219,9 @@ export class ProtocolMessageStream {
             await this._messageAdded.fut;
             this._messageAdded = new Completer();
             while (this._messages.length > 0 && !this._closed) {
-                const msg = this._messages.shift();
-                if (msg) {
-                    yield msg;
+                const message = this._messages.shift();
+                if (message !== undefined) {
+                    yield message;
                 }
             }
         }
@@ -142,26 +232,87 @@ export class Protocol {
         this.handlers = {};
         this._id = 0;
         this._send = new ProtocolMessageStream();
+        this._done = new Completer();
+        this._sendLoop = null;
+        this._open = false;
+        this._closed = false;
+        this._closeKind = null;
+        this._closeReason = null;
         this._recvPacketId = 0;
         this._recvState = "ready";
         this._recvPacketTotal = 0;
         this._recvMessageId = -1;
         this._recvType = "";
         this._recvPackets = [];
-        this._iterator = null;
         this.channel = channel;
     }
+    get url() {
+        return null;
+    }
+    get token() {
+        return null;
+    }
+    get isOpen() {
+        return this._open;
+    }
+    get isClosed() {
+        return this._closed;
+    }
+    get closeKind() {
+        return this._closeKind;
+    }
+    get closeReason() {
+        return this._closeReason;
+    }
+    get done() {
+        return this._done.fut;
+    }
+    async waitForClose() {
+        await this.done;
+    }
+    static createFactory(...args) {
+        const ProtocolCtor = this;
+        if (ProtocolCtor === Protocol) {
+            let used = false;
+            return () => {
+                if (used) {
+                    throw new ProtocolReconnectUnsupportedException("protocolFactory was not configured for reconnecting this protocol");
+                }
+                used = true;
+                return new ProtocolCtor(...args);
+            };
+        }
+        return () => new ProtocolCtor(...args);
+    }
+    _setCloseState({ kind, reason, }) {
+        if (this._closeKind == null) {
+            this._closeKind = kind;
+        }
+        if (this._closeReason == null && reason != null && reason.trim().length > 0) {
+            this._closeReason = reason.trim();
+        }
+    }
     addHandler(type, handler) {
+        if (this.handlers[type] !== undefined) {
+            throw new Error(`already registered handler for ${type}`);
+        }
         this.handlers[type] = handler;
     }
-    removeHandler(type) {
+    removeHandler(type, handler) {
+        const current = this.handlers[type];
+        if (current !== handler) {
+            throw new Error(`handler mismatch for ${type}`);
+        }
         delete this.handlers[type];
     }
+    getHandler(type) {
+        return this.handlers[type];
+    }
     async handleMessage(messageId, type, data) {
         const handler = this.handlers[type] ?? this.handlers["*"];
-        if (!handler) {
-            const d = data ? unpackMessage(data) : null;
-            console.warn(`No handler for message type ${type}; data: ${d}`);
+        if (handler == null) {
+            const unpacked = unpackMessage(data);
+            console.warn(`No handler for message type ${type}; data:`, unpacked);
             return;
         }
         await handler(this, messageId, type, data);
@@ -169,69 +320,139 @@ export class Protocol {
     getNextMessageId() {
         return this._id++;
     }
+    sendNowait(type, data, { id } = {}) {
+        if (this._sendError != null) {
+            throw this._sendError;
+        }
+        if (this._closed) {
+            throw new Error("protocol is closed");
+        }
+        const message = new ProtocolMessage({ id: id ?? this.getNextMessageId(), type, data });
+        this._send.add(message);
+        return message.id;
+    }
     async send(type, data, id) {
-        const msg = new ProtocolMessage({ id: id ?? this.getNextMessageId(), type: type, data: data });
-        this._send.add(msg);
-        await msg.sent.fut;
+        const message = new ProtocolMessage({ id: id ?? this.getNextMessageId(), type, data });
+        if (this._sendError != null) {
+            throw this._sendError;
+        }
+        if (this._closed) {
+            throw new Error("protocol is closed");
+        }
+        this._send.add(message);
+        await message.sent.fut;
     }
     async sendJson(object) {
-        return await this.send("application/json", encoder.encode(JSON.stringify(object)));
+        await this.send("application/json", encoder.encode(JSON.stringify(object)));
     }
-    start({ onMessage, onDone, onError } = {}) {
+    start({ onMessage, onDone, onError, } = {}) {
+        if (this._sendLoop != null) {
+            throw new Error("protocol already started");
+        }
         if (onMessage != null) {
             this.addHandler("*", onMessage);
         }
-        this.channel.start(this.onDataReceived.bind(this), { onDone, onError });
-        this._iterator?.return(null);
-        (async () => {
-            this._iterator = this._send.stream();
-            for await (const message of this._iterator) {
-                if (message) {
-                    const packets = Math.ceil((message.data.length / 1024));
-                    const header = new Uint8Array(4 * 4);
-                    const dataView = new DataView(header.buffer);
-                    dataView.setUint32(0, (message.id & 0x000fffff00000000) / Math.pow(2, 32), false);
-                    dataView.setUint32(4, message.id & 0xffffffff, false);
-                    dataView.setUint32(8, 0, false);
-                    dataView.setUint32(12, packets, false);
-                    const headerPacket = mergeUint8Arrays(header, encoder.encode(message.type));
-                    await this.channel.sendData(headerPacket);
-                    for (var i = 0; i < packets; i++) {
-                        const packetHeader = new Uint8Array(3 * 4);
-                        const dataView = new DataView(packetHeader.buffer);
-                        dataView.setUint32(0, (message.id & 0x000fffff00000000) / Math.pow(2, 32), false);
-                        dataView.setUint32(4, message.id & 0xffffffff, false);
-                        dataView.setUint32(8, i + 1, false);
-                        const packet = mergeUint8Arrays(packetHeader, message.data.subarray(i * 1024, Math.min((i + 1) * 1024, message.data.length)));
-                        await this.channel.sendData(packet);
-                    }
-                    message.sent.resolve();
+        this._open = true;
+        this.channel.start(this.onDataReceived.bind(this), {
+            onDone: () => {
+                this._setCloseState({ kind: ProtocolCloseKind.SERVER });
+                this._shutdown();
+                if (!this._done.completed) {
+                    this._done.complete(null);
                 }
-            }
-        })();
+                onDone?.();
+            },
+            onError: (error) => {
+                this._setCloseState({
+                    kind: ProtocolCloseKind.ERROR,
+                    reason: error instanceof Error ? error.message : String(error),
+                });
+                this._shutdown();
+                if (!this._done.completed) {
+                    this._done.complete(error);
+                }
+                onError?.(error);
+            },
+        });
+        this._sendLoop = this._runSendLoop(onError);
     }
-    dispose() {
+    close() {
+        this._setCloseState({ kind: ProtocolCloseKind.CLIENT });
+        this._shutdown();
         this.channel.dispose();
-        this._iterator?.return(null);
-        this._iterator = null;
+        if (!this._done.completed) {
+            this._done.complete(null);
+        }
+    }
+    dispose() {
+        this.close();
+    }
+    _shutdown() {
+        if (this._closed) {
+            return;
+        }
+        this._closed = true;
+        this._open = false;
+        this._send.close();
+    }
+    async _runSendLoop(onError) {
+        for await (const message of this._send.stream()) {
+            try {
+                const packets = Math.ceil(message.data.length / 1024);
+                const header = new Uint8Array(16);
+                const headerView = new DataView(header.buffer);
+                headerView.setUint32(0, Math.floor(message.id / 2 ** 32), false);
+                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)));
+                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))));
+                }
+                if (!message.sent.completed) {
+                    message.sent.complete();
+                }
+            }
+            catch (error) {
+                this._sendError = error;
+                this._setCloseState({
+                    kind: ProtocolCloseKind.ERROR,
+                    reason: error instanceof Error ? error.message : String(error),
+                });
+                if (!message.sent.completed) {
+                    message.sent.completeError(error);
+                }
+                this._shutdown();
+                if (!this._done.completed) {
+                    this._done.complete(error);
+                }
+                onError?.(error);
+                return;
+            }
+        }
     }
     onDataReceived(dataPacket) {
-        const dataView = new DataView(dataPacket.buffer);
-        const messageId = dataView.getUint32(4, false) + dataView.getUint32(0, false) * Math.pow(2, 32);
+        const dataView = new DataView(dataPacket.buffer, dataPacket.byteOffset, dataPacket.byteLength);
+        const messageId = dataView.getUint32(4, false) + dataView.getUint32(0, false) * 2 ** 32;
         const packet = dataView.getUint32(8, false);
-        if (packet != this._recvPacketId) {
+        if (packet !== this._recvPacketId) {
             this._recvState = "error";
         }
-        if (packet == 0) {
-            if (this._recvState == "ready" || this._recvState == "error") {
+        if (packet === 0) {
+            if (this._recvState === "ready" || this._recvState === "error") {
                 this._recvPacketTotal = dataView.getUint32(12, false);
                 this._recvMessageId = messageId;
                 this._recvType = decoder.decode(dataPacket.subarray(16));
-                if (this._recvPacketTotal == 0) {
+                if (this._recvPacketTotal === 0) {
                     try {
                         const merged = mergeUint8Arrays(...this._recvPackets);
                         this._recvPackets.length = 0;
-                        this.handleMessage(messageId, this._recvType, merged);
+                        this._dispatchMessage({ messageId, type: this._recvType, data: merged });
                     }
                     finally {
                         this._recvState = "ready";
@@ -249,39 +470,52 @@ export class Protocol {
                 this._recvState = "error";
                 this._recvPacketId = 0;
             }
+            return;
         }
-        else if (this._recvState != "processing") {
+        if (this._recvState !== "processing") {
             this._recvState = "error";
             this._recvPacketId = 0;
+            return;
         }
-        else {
-            if (messageId != this._recvMessageId) {
-                this._recvState = "error";
-                this._recvPacketId = 0;
-            }
-            this._recvPackets.push(dataPacket.subarray(12));
-            if (this._recvPacketTotal == this._recvPacketId) {
-                try {
-                    const merged = mergeUint8Arrays(...this._recvPackets);
-                    this._recvPackets.length = 0;
-                    this.handleMessage(messageId, this._recvType, merged);
-                }
-                finally {
-                    this._recvState = "ready";
-                    this._recvPacketId = 0;
-                    this._recvType = "";
-                    this._recvMessageId = -1;
-                }
+        if (messageId !== this._recvMessageId) {
+            this._recvState = "error";
+            this._recvPacketId = 0;
+        }
+        this._recvPackets.push(dataPacket.subarray(12));
+        if (this._recvPacketTotal === this._recvPacketId) {
+            try {
+                const merged = mergeUint8Arrays(...this._recvPackets);
+                this._recvPackets.length = 0;
+                this._dispatchMessage({ messageId, type: this._recvType, data: merged });
             }
-            else {
-                this._recvPacketId += 1;
+            finally {
+                this._recvState = "ready";
+                this._recvPacketId = 0;
+                this._recvType = "";
+                this._recvMessageId = -1;
             }
+            return;
         }
+        this._recvPacketId += 1;
+    }
+    _dispatchMessage({ messageId, type, data, }) {
+        void this.handleMessage(messageId, type, data).catch((error) => {
+            console.error("unhandled protocol message handler error", error);
+        });
     }
 }
 export class WebSocketClientProtocol extends Protocol {
     constructor({ url, token }) {
-        const channel = new WebSocketProtocolChannel({ url, jwt: token });
-        super({ channel });
+        super({
+            channel: new WebSocketProtocolChannel({ url, jwt: token }),
+        });
+        this._url = url;
+        this._token = token;
+    }
+    get url() {
+        return this._url;
+    }
+    get token() {
+        return this._token;
     }
 }