javonet-ruby-sdk 2.5.18 → 2.5.20

data/lib/javonet-ruby-sdk/Binaries/Nodejs/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
 });

data/lib/javonet-ruby-sdk/Binaries/Nodejs/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;

data/lib/javonet-ruby-sdk/Binaries/Nodejs/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

data/lib/javonet-ruby-sdk/Binaries/Nodejs/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;
 }