udp-stencil-component-library 25.18.2-beta.1 → 25.18.2-beta.11

package/dist/cjs/index.cjs.js

@@ -85,6 +85,143 @@ function useMatchBreakpoint(breakpointKey) {
     return mediaQueryList.matches;
 }
 
+class UdpWebSocketClient {
+    get isConnected() {
+        var _a;
+        return ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === WebSocket.OPEN;
+    }
+    async connect(url, getAccessToken, keepAliveIntervalMs = 0, keepAliveTimeoutMs = 0) {
+        var _a;
+        if (!this.isWssUrl(url)) {
+            throw new Error("Invalid WebSocket URL. Only ws and wss protocols are supported.");
+        }
+        const accessToken = await getAccessToken();
+        if (accessToken) {
+            // Browsers don't support setting headers manually, they only allow setting the `Sec-WebSocket-Protocol` header (secondary protocol header)
+            this.socket = new WebSocket(url, accessToken);
+        }
+        else {
+            this.socket = new WebSocket(url);
+        }
+        // Wait for the socket to open or error
+        await new Promise((resolve, reject) => {
+            const onOpen = () => {
+                this.socket.removeEventListener('open', onOpen);
+                this.socket.removeEventListener('error', onError);
+                resolve();
+            };
+            const onError = (e) => {
+                this.socket.removeEventListener('open', onOpen);
+                this.socket.removeEventListener('error', onError);
+                reject(e);
+            };
+            this.socket.addEventListener('open', onOpen);
+            this.socket.addEventListener('error', onError);
+        });
+        // Socket is now open, call the openHandler
+        (_a = this.openHandler) === null || _a === void 0 ? void 0 : _a.call(this);
+        // Assign socket events
+        this.socket.onmessage = (e) => this.handleMessage(e);
+        this.socket.onclose = (e) => this.handleClose(e);
+        this.socket.onerror = (e) => this.handleError(e);
+        // Start keepAliveTimer if configured
+        if (keepAliveIntervalMs && keepAliveTimeoutMs) {
+            this.startKeepAliveTimer(keepAliveIntervalMs, keepAliveTimeoutMs);
+        }
+    }
+    onMessageReceived(handler) {
+        this.messageReceivedHandler = handler;
+        return this;
+    }
+    onOpen(handler) {
+        this.openHandler = handler;
+        return this;
+    }
+    onClose(handler) {
+        this.closeHandler = handler;
+        return this;
+    }
+    onError(handler) {
+        this.errorHandler = handler;
+        return this;
+    }
+    send(message) {
+        if (!this.isConnected) {
+            throw new Error("WebSocket is not connected.");
+        }
+        const json = JSON.stringify(message);
+        this.socket.send(json);
+    }
+    close() {
+        if (this.socket) {
+            this.socket.close();
+            this.stopKeepAliveTimer();
+            this.socket = undefined;
+        }
+    }
+    // Event handlers
+    handleMessage(event) {
+        var _a;
+        try {
+            const msg = JSON.parse(event.data);
+            (_a = this.messageReceivedHandler) === null || _a === void 0 ? void 0 : _a.call(this, msg);
+        }
+        catch (err) {
+            console.error("Invalid UdpWebSocketMessage received:", err);
+        }
+    }
+    handleClose(event) {
+        var _a;
+        (_a = this.closeHandler) === null || _a === void 0 ? void 0 : _a.call(this, event);
+        this.close();
+    }
+    handleError(event) {
+        var _a;
+        (_a = this.errorHandler) === null || _a === void 0 ? void 0 : _a.call(this, event);
+        console.error("UdpWebSocket error:", event);
+    }
+    // KeepAlive functions
+    startKeepAliveTimer(intervalMs, timeoutMs) {
+        this.stopKeepAliveTimer();
+        // TODO: Check that this is interval not timeout param
+        this.keepAliveIntervalId = window.setInterval(() => {
+            this.sendKeepAlivePing();
+        }, intervalMs);
+        // Autoclose after timeout reached
+        this.keepAliveTimeoutId = window.setTimeout(() => {
+            this.close();
+        }, timeoutMs);
+    }
+    stopKeepAliveTimer() {
+        if (this.keepAliveIntervalId)
+            clearInterval(this.keepAliveIntervalId);
+        if (this.keepAliveTimeoutId)
+            clearTimeout(this.keepAliveTimeoutId);
+        this.keepAliveIntervalId = undefined;
+        this.keepAliveTimeoutId = undefined;
+    }
+    sendKeepAlivePing() {
+        const pingPacket = {
+            headers: {
+                type: "KeepAlive",
+                timestamp: Date.now()
+            },
+        };
+        try {
+            this.send(pingPacket);
+        }
+        catch (err) {
+            console.error("KeepAlive ping failed to send:", err);
+        }
+    }
+    // Util functions
+    isWssUrl(url) {
+        return /^wss?:\/\//.test(url);
+    }
+}
+UdpWebSocketClient.DEFAULT_KEEPALIVE_INTERVAL_MS = 30000; // 30 sec
+UdpWebSocketClient.DEFAULT_KEEPALIVE_TIMEOUT_MS = 60 * 60 * 1000; // 60 min
+
 exports.convertToAgGridColumns = transformSearchData.convertToAgGridColumns;
 exports.createStructuredQuery = transformSearchData.createStructuredQuery;
 exports.defaultPayload = transformSearchData.defaultPayload;
@@ -108,7 +245,7 @@ Object.defineProperty(exports, "SqlFilterOperators", {
     get: function () { return SearchBuilder.SearchOperators; }
 });
 exports.ConfigService = configService.ConfigService;
+exports.UdpWebSocketClient = UdpWebSocketClient;
 exports.apiMutate = apiMutate;
 exports.getMergedConfig = getMergedConfig;
 exports.useMatchBreakpoint = useMatchBreakpoint;
-//# sourceMappingURL=index.cjs.js.map