javonet-nodejs-sdk 2.5.18 → 2.5.20

package/dist/core/transmitter/TransmitterWebsocket.cjs

@@ -47,7 +47,7 @@ class TransmitterWebsocket {
   static sendCommand(messageByteArray, connectionData) {
     const { hostname } = connectionData;
     const options = {
-      isDisconnectedAfterMessage: true
+      isDisconnectedAfterMessage: false
     };
     return new import_WebSocketClient.WebSocketClient(hostname, options).send(messageByteArray);
   }

package/dist/core/transmitter/TransmitterWebsocketBrowser.cjs

@@ -41,8 +41,7 @@ class TransmitterWebsocketBrowser {
    */
   static async sendCommand(messageByteArray, connectionData) {
     const { hostname } = connectionData;
-    const response = new import_WebSocketClientBrowser.WebSocketClientBrowser(hostname).send(messageByteArray);
-    return response;
+    return new import_WebSocketClientBrowser.WebSocketClientBrowser(hostname).send(messageByteArray);
   }
   /**
    * @async

package/dist/core/webSocketClient/WebSocketClient.cjs

@@ -18,18 +18,27 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var WebSocketClient_exports = {};
 __export(WebSocketClient_exports, {
-  WebSocketClient: () => WebSocketClient
+  WebSocketClient: () => WebSocketClient,
+  clients: () => clients
 });
 module.exports = __toCommonJS(WebSocketClient_exports);
 var import_Runtime = require("../../utils/Runtime.cjs");
 const import_meta = {};
 const requireDynamic = (0, import_Runtime.getRequire)(import_meta.url);
 const WebSocketStateEnum = {
+  CONNECTING: 0,
+  OPEN: 1,
+  CLOSING: 2,
+  CLOSED: 3
+};
+const WebSocketStateEvent = {
   OPEN: "open",
   CLOSE: "close",
-  ERROR: "error"
+  ERROR: "error",
+  MESSAGE: "message"
 };
 let WebSocket = null;
+const clients = {};
 class WebSocketClient {
   /**
    * @param {string} url
@@ -37,45 +46,14 @@ class WebSocketClient {
    */
   constructor(url, options) {
     this.url = url;
-    this.instance = null;
-    this.isConnected = false;
-    this.isDisconnectedAfterMessage = options?.isDisconnectedAfterMessage ?? true;
+    this.isDisconnectedAfterMessage = options?.isDisconnectedAfterMessage ?? false;
   }
-  /**
-   * Connects to the WebSocket server.
-   * @async
-   * @returns {Promise<wsClient>} - A promise that resolves when the connection is established.
-   */
-  async connect() {
-    if (!WebSocket) {
-      if ((0, import_Runtime.isNodejsRuntime)()) {
-        try {
-          WebSocket = requireDynamic("ws");
-        } catch (error) {
-          if (typeof error === "object" && error && "code" in error && error.code === "MODULE_NOT_FOUND") {
-            throw new Error("ws module not found. Please install it using npm install ws");
-          }
-          throw error;
-        }
-      }
-    }
-    return new Promise((resolve, reject) => {
-      if (!WebSocket) {
-        reject(new Error("ws client is null"));
-        return;
-      }
-      const client = new WebSocket(this.url);
-      client.on(WebSocketStateEnum.OPEN, () => {
-        this.instance = client;
-        resolve(client);
-      });
-      client.on(WebSocketStateEnum.ERROR, (error) => {
-        reject(error);
-      });
-      client.on(WebSocketStateEnum.CLOSE, () => {
-        reject(new Error("Connection closed before receiving message"));
-      });
-    });
+  /** @type {wsClient | null} */
+  get instance() {
+    return clients[this.url] || null;
+  }
+  get isConnected() {
+    return this.instance ? this.instance?.readyState === WebSocketStateEnum.OPEN : false;
   }
   /**
    * Sends messageArray through websocket connection
@@ -85,21 +63,36 @@ class WebSocketClient {
    */
   send(messageArray) {
     return new Promise((resolve, reject) => {
-      ;
-      (this.instance ? Promise.resolve(this.instance) : this._connect()).then((client) => {
+      const client = this.instance;
+      if (client) {
         client.send(
           /** @type {any} */
           messageArray
         );
-        client.on("message", (message) => {
+        const messageHandler = (message) => {
           resolve(message);
           if (this.isDisconnectedAfterMessage) {
             this.disconnect();
           }
-        });
-      }).catch((error) => {
-        reject(error);
-      });
+          client.removeListener(WebSocketStateEvent.MESSAGE, messageHandler);
+        };
+        client.on(WebSocketStateEvent.MESSAGE, messageHandler);
+      } else {
+        this._connect().then((ws) => {
+          ws.send(
+            /** @type {any} */
+            messageArray
+          );
+          const messageHandler = (message) => {
+            resolve(message);
+            if (this.isDisconnectedAfterMessage) {
+              this.disconnect();
+            }
+            ws.removeListener(WebSocketStateEvent.MESSAGE, messageHandler);
+          };
+          ws.on(WebSocketStateEvent.MESSAGE, messageHandler);
+        }).catch(reject);
+      }
     });
   }
   /**
@@ -108,9 +101,8 @@ class WebSocketClient {
   disconnect() {
     if (this.instance) {
       this.instance.close();
-      this.instance = null;
+      delete clients[this.url];
     }
-    this.isConnected = false;
   }
   /**
    * Connects to the WebSocket server.
@@ -119,36 +111,31 @@ class WebSocketClient {
    * @returns {Promise<wsClient>} - A promise that resolves when the connection is established.
    */
   _connect() {
-    if (!WebSocket) {
-      if ((0, import_Runtime.isNodejsRuntime)()) {
-        try {
-          WebSocket = requireDynamic("ws");
-        } catch (error) {
-          if (
-            /** @type {{ code?: string }} */
-            error.code === "MODULE_NOT_FOUND"
-          ) {
-            throw new Error("ws module not found. Please install it using npm install ws");
-          }
-          throw error;
+    if (!WebSocket && (0, import_Runtime.isNodejsRuntime)()) {
+      try {
+        WebSocket = requireDynamic("ws");
+      } catch (error) {
+        if (
+          /** @type {{ code?: string }} */
+          error.code === "MODULE_NOT_FOUND"
+        ) {
+          throw new Error("ws module not found. Please install it using npm install ws");
         }
+        throw error;
       }
     }
     return new Promise((resolve, reject) => {
       if (!WebSocket) {
-        reject(new Error("ws client is null"));
-        return;
+        return reject(new Error("ws client is null"));
       }
-      const client = new WebSocket(this.url);
-      client.on(WebSocketStateEnum.OPEN, () => {
-        this.isConnected = true;
-        this.instance = client;
-        resolve(client);
-      });
-      client.on(WebSocketStateEnum.ERROR, (error) => {
-        reject(error);
-      });
-      client.on(WebSocketStateEnum.CLOSE, () => {
+      let client = clients[this.url];
+      if (!client) {
+        client = new WebSocket(this.url);
+        clients[this.url] = client;
+      }
+      client.on(WebSocketStateEvent.OPEN, () => resolve(client));
+      client.on(WebSocketStateEvent.ERROR, (error) => reject(error));
+      client.on(WebSocketStateEvent.CLOSE, () => {
         reject(new Error("Connection closed before receiving message"));
       });
     });
@@ -156,5 +143,6 @@ class WebSocketClient {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  WebSocketClient
+  WebSocketClient,
+  clients
 });

package/dist/core/webSocketClient/WebSocketClientBrowser.cjs

@@ -18,7 +18,8 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var WebSocketClientBrowser_exports = {};
 __export(WebSocketClientBrowser_exports, {
-  WebSocketClientBrowser: () => WebSocketClientBrowser
+  WebSocketClientBrowser: () => WebSocketClientBrowser,
+  clients: () => clients
 });
 module.exports = __toCommonJS(WebSocketClientBrowser_exports);
 var import_Runtime = require("../../utils/Runtime.cjs");
@@ -35,6 +36,7 @@ let WsClient = null;
 if ((0, import_Runtime.isBrowserRuntime)()) {
   WsClient = WebSocket;
 }
+const clients = {};
 class WebSocketClientBrowser {
   /**
    * @param {string} url
@@ -42,10 +44,15 @@ class WebSocketClientBrowser {
    */
   constructor(url, options) {
     this.url = url;
-    this.instance = null;
-    this.isConnected = false;
     this.isDisconnectedAfterMessage = options?.isDisconnectedAfterMessage ?? false;
   }
+  /** @type {WebSocket | null} */
+  get instance() {
+    return clients[this.url] || null;
+  }
+  get isConnected() {
+    return this.instance ? this.instance.readyState === WebSocket.OPEN : false;
+  }
   /**
    * Sends messageArray through websocket connection
    * @async
@@ -54,94 +61,81 @@ class WebSocketClientBrowser {
    */
   send(messageArray) {
     return new Promise((resolve, reject) => {
-      try {
-        if (this.isConnected) {
-          this._sendMessage(messageArray, resolve, reject);
-        } else {
-          this._connect().then(() => {
-            this._sendMessage(messageArray, resolve, reject);
-          });
-        }
-      } catch (error) {
-        reject(error);
+      const client = this.instance;
+      if (client && this.isConnected) {
+        this._sendMessage(client, messageArray, resolve, reject);
+      } else {
+        this._connect().then((ws) => {
+          this._sendMessage(ws, messageArray, resolve, reject);
+        }).catch(reject);
       }
     });
   }
   /**
    * Disconnects the WebSocket by terminating the connection.
-   * @returns {void}
-   *
    */
   disconnect() {
-    if (this.instance) {
-      this.instance.close();
+    const client = this.instance;
+    if (client) {
+      client.close();
+      delete clients[this.url];
     }
-    this.isConnected = false;
   }
   /**
    * Connects to the WebSocket server.
    * @private
    * @async
-   * @returns {Promise<void>} - A promise that resolves when the connection is established.
+   * @returns {Promise<WebSocket>}
    */
   _connect() {
     return new Promise((resolve, reject) => {
-      if (WsClient === null) {
+      if (!WsClient) {
         return reject(new Error("missing WebSocket client"));
       }
-      this.instance = new WsClient(this.url);
-      this.instance.binaryType = "arraybuffer";
-      this.instance.addEventListener(WebSocketState.OPEN, () => {
-        this.isConnected = true;
-        resolve();
-      });
-      this.instance.addEventListener(WebSocketState.ERROR, (error) => {
-        reject(error);
-      });
-      this.instance.addEventListener(WebSocketState.CLOSE, () => {
-        this.isConnected = false;
+      let client = clients[this.url];
+      if (!client) {
+        client = new WsClient(this.url);
+        client.binaryType = "arraybuffer";
+        clients[this.url] = client;
+      }
+      client.addEventListener(WebSocketState.OPEN, () => resolve(client));
+      client.addEventListener(WebSocketState.ERROR, reject);
+      client.addEventListener(WebSocketState.CLOSE, () => {
+        reject(new Error("Connection closed before receiving message"));
       });
     });
   }
   /**
    * Sends the data to the WebSocket server and listens for a response.
    * @private
-   * @async
-   * @param {Int8Array} data - The data to send.
-   * @param {Function} resolve - The resolve function for the Promise.
-   * @param {Function} reject - The reject function for the Promise.
-   * @returns {void}
+   * @param {WebSocket} client
+   * @param {Int8Array} data
+   * @param {(value: Int8Array) => void} resolve
+   * @param {(reason?: any) => void} reject
    */
-  _sendMessage(data, resolve, reject) {
+  _sendMessage(client, data, resolve, reject) {
     try {
-      if (this.instance === null || !this.instance) {
-        throw new Error("error websocket not connected");
-      }
       const arrayBuffer = data.buffer;
-      this.instance.send(arrayBuffer);
-      const handleMessage = (msg) => {
-        if (this.instance === null || !this.instance) {
-          throw new Error("error websocket not connected");
+      client.send(arrayBuffer);
+      const handleMessage = (message) => {
+        if (!message?.data) {
+          return reject(new Error("Invalid message received"));
         }
-        const byteArray = new Int8Array(msg.data);
+        const byteArray = new Int8Array(message?.data);
         resolve(byteArray);
         if (this.isDisconnectedAfterMessage) {
           this.disconnect();
         }
-        this.instance.removeEventListener(WebSocketState.MESSAGE, handleMessage);
-        this.instance.removeEventListener(WebSocketState.ERROR, handleError);
+        client.removeEventListener(WebSocketState.MESSAGE, handleMessage);
+        client.removeEventListener(WebSocketState.ERROR, handleError);
       };
       const handleError = (error) => {
         reject(error);
-        if (this.instance) {
-          this.instance.removeEventListener(WebSocketState.MESSAGE, handleMessage);
-          this.instance.removeEventListener(WebSocketState.ERROR, handleError);
-        }
+        client.removeEventListener(WebSocketState.MESSAGE, handleMessage);
+        client.removeEventListener(WebSocketState.ERROR, handleError);
       };
-      if (this.instance) {
-        this.instance.addEventListener(WebSocketState.MESSAGE, handleMessage);
-        this.instance.addEventListener(WebSocketState.ERROR, handleError);
-      }
+      client.addEventListener(WebSocketState.MESSAGE, handleMessage);
+      client.addEventListener(WebSocketState.ERROR, handleError);
     } catch (err) {
       reject(err);
     }
@@ -149,5 +143,6 @@ class WebSocketClientBrowser {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  WebSocketClientBrowser
+  WebSocketClientBrowser,
+  clients
 });

package/dist/sdk/RuntimeContext.cjs

@@ -75,10 +75,6 @@ class RuntimeContext {
    * @returns {RuntimeContext}
    */
   static getInstance(runtimeName, connectionData) {
-    if (!_Transmitter) {
-      const { Transmitter } = require("../core/transmitter/Transmitter.cjs");
-      _Transmitter = Transmitter;
-    }
     switch (connectionData.connectionType) {
       case import_ConnectionType.ConnectionType.IN_MEMORY:
         const key = String(runtimeName);
@@ -88,6 +84,10 @@ class RuntimeContext {
           runtimeCtx.#currentCommand = null;
           return runtimeCtx;
         } else {
+          if (!_Transmitter) {
+            const { Transmitter } = require("../core/transmitter/Transmitter.cjs");
+            _Transmitter = Transmitter;
+          }
           const runtimeCtx = new RuntimeContext(runtimeName, connectionData);
           RuntimeContext.memoryRuntimeContexts.set(key, runtimeCtx);
           return runtimeCtx;
@@ -100,6 +100,10 @@ class RuntimeContext {
           runtimeCtx.#currentCommand = null;
           return runtimeCtx;
         } else {
+          if (!_Transmitter) {
+            const { Transmitter } = require("../core/transmitter/Transmitter.cjs");
+            _Transmitter = Transmitter;
+          }
           const runtimeCtx = new RuntimeContext(runtimeName, connectionData);
           RuntimeContext.networkRuntimeContexts.set(key1, runtimeCtx);
           return runtimeCtx;

package/dist/types/core/webSocketClient/WebSocketClient.d.ts

@@ -1,3 +1,5 @@
+/** @type {Record<string, wsClient>} */
+export const clients: Record<string, wsClient>;
 export type wsClient = import("ws").WebSocket;
 export type WebSocketClass = typeof import("ws").WebSocket;
 /**
@@ -13,18 +15,11 @@ export class WebSocketClient {
     });
     /** @type {string} */
     url: string;
-    /** @type {wsClient | null} */
-    instance: wsClient | null;
-    /** @type {boolean} */
-    isConnected: boolean;
     /** @type {boolean} */
     isDisconnectedAfterMessage: boolean;
-    /**
-     * Connects to the WebSocket server.
-     * @async
-     * @returns {Promise<wsClient>} - A promise that resolves when the connection is established.
-     */
-    connect(): Promise<wsClient>;
+    /** @type {wsClient | null} */
+    get instance(): wsClient | null;
+    get isConnected(): boolean;
     /**
      * Sends messageArray through websocket connection
      * @async

package/dist/types/core/webSocketClient/WebSocketClientBrowser.d.ts

@@ -1,10 +1,12 @@
-export type Options = {
-    isDisconnectedAfterMessage: boolean;
-};
 /**
  * @typedef {object} Options
- * @property {boolean} isDisconnectedAfterMessage
+ * @property {boolean} [isDisconnectedAfterMessage]
  */
+/** @type {Record<string, WebSocket>} */
+export const clients: Record<string, WebSocket>;
+export type Options = {
+    isDisconnectedAfterMessage?: boolean | undefined;
+};
 /**
  * WebSocketClient class that handles WebSocket connection, message sending, and automatic disconnection.
  */
@@ -14,22 +16,13 @@ export class WebSocketClientBrowser {
      * @param {Options} [options]
      */
     constructor(url: string, options?: Options);
-    /**
-     * @type {string}
-     */
+    /** @type {string} */
     url: string;
-    /**
-     * @type {WebSocket | null}
-     */
-    instance: WebSocket | null;
-    /**
-     * @type {boolean} isConnected indicates whether the WebSocket is connected.
-     */
-    isConnected: boolean;
-    /**
-     * @type {boolean}
-     */
+    /** @type {boolean} */
     isDisconnectedAfterMessage: boolean;
+    /** @type {WebSocket | null} */
+    get instance(): WebSocket | null;
+    get isConnected(): boolean;
     /**
      * Sends messageArray through websocket connection
      * @async
@@ -39,25 +32,22 @@ export class WebSocketClientBrowser {
     send(messageArray: Int8Array): Promise<Int8Array>;
     /**
      * Disconnects the WebSocket by terminating the connection.
-     * @returns {void}
-     *
      */
     disconnect(): void;
     /**
      * Connects to the WebSocket server.
      * @private
      * @async
-     * @returns {Promise<void>} - A promise that resolves when the connection is established.
+     * @returns {Promise<WebSocket>}
      */
     private _connect;
     /**
      * Sends the data to the WebSocket server and listens for a response.
      * @private
-     * @async
-     * @param {Int8Array} data - The data to send.
-     * @param {Function} resolve - The resolve function for the Promise.
-     * @param {Function} reject - The reject function for the Promise.
-     * @returns {void}
+     * @param {WebSocket} client
+     * @param {Int8Array} data
+     * @param {(value: Int8Array) => void} resolve
+     * @param {(reason?: any) => void} reject
      */
     private _sendMessage;
 }

package/lib/core/transmitter/TransmitterWebsocket.js

@@ -29,7 +29,7 @@ export class TransmitterWebsocket {
     static sendCommand(messageByteArray, connectionData) {
         const { hostname } = connectionData
         const options = {
-            isDisconnectedAfterMessage: true,
+            isDisconnectedAfterMessage: false,
         }
         return new WebSocketClient(hostname, options).send(messageByteArray)
     }

package/lib/core/transmitter/TransmitterWebsocketBrowser.js

@@ -23,8 +23,7 @@ export class TransmitterWebsocketBrowser {
      */
     static async sendCommand(messageByteArray, connectionData) {
         const { hostname } = connectionData
-        const response = new WebSocketClientBrowser(hostname).send(messageByteArray)
-        return response
+        return new WebSocketClientBrowser(hostname).send(messageByteArray)
     }
 
     /**

package/lib/core/webSocketClient/WebSocketClient.js

@@ -9,17 +9,33 @@ const requireDynamic = getRequire(import.meta.url)
 /**
  * Enum for WebSocket states.
  * @readonly
- * @enum {string}
+ * @enum {number}
  */
 const WebSocketStateEnum = {
+    CONNECTING: 0,
+    OPEN: 1,
+    CLOSING: 2,
+    CLOSED: 3,
+}
+
+/**
+ * Enum for WebSocket event states.
+ * @readonly
+ * @enum {string}
+ */
+const WebSocketStateEvent = {
     OPEN: 'open',
     CLOSE: 'close',
     ERROR: 'error',
+    MESSAGE: 'message',
 }
 
 /** @type {WebSocketClass | null} */
 let WebSocket = null
 
+/** @type {Record<string, wsClient>} */
+export const clients = {}
+
 /**
  * WebSocketClient class that handles WebSocket connection, message sending, and automatic disconnection.
  */
@@ -31,59 +47,17 @@ class WebSocketClient {
     constructor(url, options) {
         /** @type {string} */
         this.url = url
-        /** @type {wsClient | null} */
-        this.instance = null
         /** @type {boolean} */
-        this.isConnected = false
-        /** @type {boolean} */
-        this.isDisconnectedAfterMessage = options?.isDisconnectedAfterMessage ?? true
+        this.isDisconnectedAfterMessage = options?.isDisconnectedAfterMessage ?? false
     }
 
-    /**
-     * Connects to the WebSocket server.
-     * @async
-     * @returns {Promise<wsClient>} - A promise that resolves when the connection is established.
-     */
-    async connect() {
-        if (!WebSocket) {
-            if (isNodejsRuntime()) {
-                try {
-                    WebSocket = requireDynamic('ws')
-                } catch (error) {
-                    if (
-                        typeof error === 'object' &&
-                        error &&
-                        'code' in error &&
-                        error.code === 'MODULE_NOT_FOUND'
-                    ) {
-                        throw new Error('ws module not found. Please install it using npm install ws')
-                    }
-                    throw error
-                }
-            }
-        }
-
-        return new Promise((resolve, reject) => {
-            if (!WebSocket) {
-                reject(new Error('ws client is null'))
-                return
-            }
-            const client = new WebSocket(this.url)
-
-            client.on(WebSocketStateEnum.OPEN, () => {
-                this.instance = client
-                resolve(client)
-            })
-
-            // eslint-disable-next-line no-unused-vars
-            client.on(WebSocketStateEnum.ERROR, (/** @type {unknown} */ error) => {
-                reject(error)
-            })
+    /** @type {wsClient | null} */
+    get instance() {
+        return clients[this.url] || null
+    }
 
-            client.on(WebSocketStateEnum.CLOSE, () => {
-                reject(new Error('Connection closed before receiving message'))
-            })
-        })
+    get isConnected() {
+        return this.instance ? this.instance?.readyState === WebSocketStateEnum.OPEN : false
     }
 
     /**
@@ -94,21 +68,32 @@ class WebSocketClient {
      */
     send(messageArray) {
         return new Promise((resolve, reject) => {
-            ;(this.instance ? Promise.resolve(this.instance) : this._connect())
-                .then((client) => {
-                    client.send(/** @type {any} */ (messageArray))
-
-                    client.on('message', (/** @type {any} */ message) => {
-                        resolve(message)
-
-                        if (this.isDisconnectedAfterMessage) {
-                            this.disconnect()
+            const client = this.instance
+            if (client) {
+                client.send(/** @type {any} */ (messageArray))
+                const messageHandler = (/** @type {any} */ message) => {
+                    resolve(message)
+                    if (this.isDisconnectedAfterMessage) {
+                        this.disconnect()
+                    }
+                    client.removeListener(WebSocketStateEvent.MESSAGE, messageHandler)
+                }
+                client.on(WebSocketStateEvent.MESSAGE, messageHandler)
+            } else {
+                this._connect()
+                    .then((ws) => {
+                        ws.send(/** @type {any} */ (messageArray))
+                        const messageHandler = (/** @type {any} */ message) => {
+                            resolve(message)
+                            if (this.isDisconnectedAfterMessage) {
+                                this.disconnect()
+                            }
+                            ws.removeListener(WebSocketStateEvent.MESSAGE, messageHandler)
                         }
+                        ws.on(WebSocketStateEvent.MESSAGE, messageHandler)
                     })
-                })
-                .catch((error) => {
-                    reject(error)
-                })
+                    .catch(reject)
+            }
         })
     }
 
@@ -118,9 +103,8 @@ class WebSocketClient {
     disconnect() {
         if (this.instance) {
             this.instance.close()
-            this.instance = null
+            delete clients[this.url]
         }
-        this.isConnected = false
     }
 
     /**
@@ -130,38 +114,31 @@ class WebSocketClient {
      * @returns {Promise<wsClient>} - A promise that resolves when the connection is established.
      */
     _connect() {
-        if (!WebSocket) {
-            if (isNodejsRuntime()) {
-                try {
-                    WebSocket = requireDynamic('ws')
-                } catch (error) {
-                    if (/** @type {{ code?: string }} */ (error).code === 'MODULE_NOT_FOUND') {
-                        throw new Error('ws module not found. Please install it using npm install ws')
-                    }
-                    throw error
+        if (!WebSocket && isNodejsRuntime()) {
+            try {
+                WebSocket = requireDynamic('ws')
+            } catch (error) {
+                if (/** @type {{ code?: string }} */ (error).code === 'MODULE_NOT_FOUND') {
+                    throw new Error('ws module not found. Please install it using npm install ws')
                 }
+                throw error
             }
         }
 
         return new Promise((resolve, reject) => {
             if (!WebSocket) {
-                reject(new Error('ws client is null'))
-                return
+                return reject(new Error('ws client is null'))
             }
-            const client = new WebSocket(this.url)
-
-            client.on(WebSocketStateEnum.OPEN, () => {
-                this.isConnected = true
-                this.instance = client
-                resolve(client)
-            })
 
-            // eslint-disable-next-line no-unused-vars
-            client.on(WebSocketStateEnum.ERROR, (/** @type {unknown} */ error) => {
-                reject(error)
-            })
+            let client = clients[this.url]
+            if (!client) {
+                client = new WebSocket(this.url)
+                clients[this.url] = client
+            }
 
-            client.on(WebSocketStateEnum.CLOSE, () => {
+            client.on(WebSocketStateEvent.OPEN, () => resolve(client))
+            client.on(WebSocketStateEvent.ERROR, (/** @type {unknown} */ error) => reject(error))
+            client.on(WebSocketStateEvent.CLOSE, () => {
                 reject(new Error('Connection closed before receiving message'))
             })
         })

package/lib/core/webSocketClient/WebSocketClientBrowser.js

@@ -1,5 +1,5 @@
 // @ts-check
-import { isBrowserRuntime } from "../../utils/Runtime.js"
+import { isBrowserRuntime } from '../../utils/Runtime.js'
 
 const WebSocketState = /** @type {const} */ ({
     OPEN: 'open',
@@ -14,15 +14,17 @@ const WebSocketState = /** @type {const} */ ({
 let WsClient = null
 
 if (isBrowserRuntime()) {
-    /** @type {typeof WebSocket} */
     WsClient = WebSocket
 }
 
 /**
  * @typedef {object} Options
- * @property {boolean} isDisconnectedAfterMessage
+ * @property {boolean} [isDisconnectedAfterMessage]
  */
 
+/** @type {Record<string, WebSocket>} */
+export const clients = {}
+
 /**
  * WebSocketClient class that handles WebSocket connection, message sending, and automatic disconnection.
  */
@@ -32,25 +34,20 @@ class WebSocketClientBrowser {
      * @param {Options} [options]
      */
     constructor(url, options) {
-        /**
-         * @type {string}
-         */
+        /** @type {string} */
         this.url = url
 
-        /**
-         * @type {WebSocket | null}
-         */
-        this.instance = null
+        /** @type {boolean} */
+        this.isDisconnectedAfterMessage = options?.isDisconnectedAfterMessage ?? false
+    }
 
-        /**
-         * @type {boolean} isConnected indicates whether the WebSocket is connected.
-         */
-        this.isConnected = false
+    /** @type {WebSocket | null} */
+    get instance() {
+        return clients[this.url] || null
+    }
 
-        /**
-         * @type {boolean}
-         */
-        this.isDisconnectedAfterMessage = options?.isDisconnectedAfterMessage ?? false
+    get isConnected() {
+        return this.instance ? this.instance.readyState === WebSocket.OPEN : false
     }
 
     /**
@@ -61,57 +58,53 @@ class WebSocketClientBrowser {
      */
     send(messageArray) {
         return new Promise((resolve, reject) => {
-            try {
-                if (this.isConnected) {
-                    this._sendMessage(messageArray, resolve, reject)
-                } else {
-                    this._connect().then(() => {
-                        this._sendMessage(messageArray, resolve, reject)
+            const client = this.instance
+            if (client && this.isConnected) {
+                this._sendMessage(client, messageArray, resolve, reject)
+            } else {
+                this._connect()
+                    .then((ws) => {
+                        this._sendMessage(ws, messageArray, resolve, reject)
                     })
-                }
-            } catch (error) {
-                reject(error)
+                    .catch(reject)
             }
         })
     }
 
     /**
      * Disconnects the WebSocket by terminating the connection.
-     * @returns {void}
-     *
      */
     disconnect() {
-        if (this.instance) {
-            this.instance.close()
+        const client = this.instance
+        if (client) {
+            client.close()
+            delete clients[this.url]
         }
-        this.isConnected = false
     }
 
     /**
      * Connects to the WebSocket server.
      * @private
      * @async
-     * @returns {Promise<void>} - A promise that resolves when the connection is established.
+     * @returns {Promise<WebSocket>}
      */
     _connect() {
         return new Promise((resolve, reject) => {
-            if (WsClient === null) {
+            if (!WsClient) {
                 return reject(new Error('missing WebSocket client'))
             }
-            this.instance = new WsClient(this.url)
-            this.instance.binaryType = 'arraybuffer'
-
-            this.instance.addEventListener(WebSocketState.OPEN, () => {
-                this.isConnected = true
-                resolve()
-            })
 
-            this.instance.addEventListener(WebSocketState.ERROR, (error) => {
-                reject(error)
-            })
+            let client = clients[this.url]
+            if (!client) {
+                client = new WsClient(this.url)
+                client.binaryType = 'arraybuffer'
+                clients[this.url] = client
+            }
 
-            this.instance.addEventListener(WebSocketState.CLOSE, () => {
-                this.isConnected = false
+            client.addEventListener(WebSocketState.OPEN, () => resolve(client))
+            client.addEventListener(WebSocketState.ERROR, reject)
+            client.addEventListener(WebSocketState.CLOSE, () => {
+                reject(new Error('Connection closed before receiving message'))
             })
         })
     }
@@ -119,51 +112,41 @@ class WebSocketClientBrowser {
     /**
      * Sends the data to the WebSocket server and listens for a response.
      * @private
-     * @async
-     * @param {Int8Array} data - The data to send.
-     * @param {Function} resolve - The resolve function for the Promise.
-     * @param {Function} reject - The reject function for the Promise.
-     * @returns {void}
+     * @param {WebSocket} client
+     * @param {Int8Array} data
+     * @param {(value: Int8Array) => void} resolve
+     * @param {(reason?: any) => void} reject
      */
-    _sendMessage(data, resolve, reject) {
+    _sendMessage(client, data, resolve, reject) {
         try {
-            if (this.instance === null || !this.instance) {
-                throw new Error('error websocket not connected')
-            }
-
             const arrayBuffer = data.buffer
-            this.instance.send(arrayBuffer)
+            client.send(arrayBuffer)
 
-            // @ts-ignore
-            const handleMessage = (msg) => {
-                if (this.instance === null || !this.instance) {
-                    throw new Error('error websocket not connected')
+            const handleMessage = (/** @type {any} */ message) => {
+                if (!message?.data) {
+                    return reject(new Error('Invalid message received'))
                 }
 
-                const byteArray = new Int8Array(msg.data)
+                const byteArray = new Int8Array(message?.data)
                 resolve(byteArray)
 
                 if (this.isDisconnectedAfterMessage) {
                     this.disconnect()
                 }
 
-                this.instance.removeEventListener(WebSocketState.MESSAGE, handleMessage)
-                this.instance.removeEventListener(WebSocketState.ERROR, handleError)
+                client.removeEventListener(WebSocketState.MESSAGE, handleMessage)
+                client.removeEventListener(WebSocketState.ERROR, handleError)
             }
 
-            const handleError = (/** @type {any} */ error) => {
+            const handleError = (/** @type {unknown} */ error) => {
                 reject(error)
 
-                if (this.instance) {
-                    this.instance.removeEventListener(WebSocketState.MESSAGE, handleMessage)
-                    this.instance.removeEventListener(WebSocketState.ERROR, handleError)
-                }
+                client.removeEventListener(WebSocketState.MESSAGE, handleMessage)
+                client.removeEventListener(WebSocketState.ERROR, handleError)
             }
 
-            if (this.instance) {
-                this.instance.addEventListener(WebSocketState.MESSAGE, handleMessage)
-                this.instance.addEventListener(WebSocketState.ERROR, handleError)
-            }
+            client.addEventListener(WebSocketState.MESSAGE, handleMessage)
+            client.addEventListener(WebSocketState.ERROR, handleError)
         } catch (err) {
             reject(err)
         }

package/lib/sdk/RuntimeContext.js

@@ -81,10 +81,6 @@ class RuntimeContext {
      * @returns {RuntimeContext}
      */
     static getInstance(runtimeName, connectionData) {
-        if (!_Transmitter) {
-            const { Transmitter } = requireDynamic('../core/transmitter/Transmitter.js')
-            _Transmitter = Transmitter
-        }
         switch (connectionData.connectionType) {
             case ConnectionType.IN_MEMORY:
                 const key = String(runtimeName)
@@ -94,6 +90,10 @@ class RuntimeContext {
                     runtimeCtx.#currentCommand = null
                     return runtimeCtx
                 } else {
+                    if (!_Transmitter) {
+                        const { Transmitter } = requireDynamic('../core/transmitter/Transmitter.js')
+                        _Transmitter = Transmitter
+                    }
                     const runtimeCtx = new RuntimeContext(runtimeName, connectionData)
                     RuntimeContext.memoryRuntimeContexts.set(key, runtimeCtx)
                     return runtimeCtx
@@ -106,6 +106,10 @@ class RuntimeContext {
                     runtimeCtx.#currentCommand = null
                     return runtimeCtx
                 } else {
+                    if (!_Transmitter) {
+                        const { Transmitter } = requireDynamic('../core/transmitter/Transmitter.js')
+                        _Transmitter = Transmitter
+                    }
                     const runtimeCtx = new RuntimeContext(runtimeName, connectionData)
                     RuntimeContext.networkRuntimeContexts.set(key1, runtimeCtx)
                     return runtimeCtx

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "javonet-nodejs-sdk",
-    "version": "2.5.18",
+    "version": "2.5.20",
     "description": "Javonet allows you to reference and use modules or packages written in (Java/Kotlin/Groovy/Clojure, C#/VB.NET, Ruby, Perl, Python, JavaScript/TypeScript) like they were created in your technology. It works on Linux/Windows and MacOS for applications created in JVM, CLR/Netcore, Perl, Python, Ruby, NodeJS, C++ or GoLang and gives you unparalleled freedom and flexibility with native performance in building your mixed-technologies products. Let it be accessing best AI or cryptography libraries, devices SDKs, legacy client modules, internal custom packages or anything from public repositories available on NPM, Nuget, PyPI, Maven/Gradle, RubyGems or GitHub. Get free from programming languages barriers today! For more information check out our guides at https://www.javonet.com/guides/v2/",
     "keywords": [],
     "author": "SdNCenter Sp. z o. o.",
@@ -30,11 +30,19 @@
             "default": "./lib/utils/CreateRequire.node.js"
         }
     },
+    "jest": {
+        "verbose": true,
+        "testResultsProcessor": "./node_modules/jest-junit-reporter",
+        "coverageReporters": [
+            "json",
+            "lcov",
+            "text",
+            "clover",
+            "cobertura"
+        ]
+    },
     "scripts": {
-        "test": "cross-env NODE_OPTIONS=--experimental-vm-modules jest tests/unitTests tests/functionalTests tests/performanceTests  --maxWorkers=3 --colors",
-        "test:watch": "cross-env NODE_OPTIONS=--experimental-vm-modules jest tests/unitTests tests/functionalTests tests/performanceTests  --maxWorkers=3 --colors --watch",
-        "test:unit": "cross-env NODE_OPTIONS=--experimental-vm-modules jest tests/unitTests  --maxWorkers=3 --colors --outputName=\"test-report.xml\"  -t=\"(Unit)\" --coverage ",
-        "test:functional": "cross-env NODE_OPTIONS=--experimental-vm-modules jest tests/functionalTests  --maxWorkers=1 --colors -t=\"(Functional)\"",
+        "test": "cross-env NODE_OPTIONS=--experimental-vm-modules jest tests/unitTests -t=\"(Unit)\" --maxWorkers=3 --colors --coverage",
         "build:types": "tsc --project tsconfig.declarations.json",
         "build:cjs": "tsup && node scripts/resolve-dist-imports.js",
         "build": "npm run build:cjs && npm run build:types",