javonet-nodejs-sdk 2.5.17 → 2.5.19

package/dist/core/protocol/CommandDeserializer.cjs

@@ -22,10 +22,12 @@ __export(CommandDeserializer_exports, {
 });
 module.exports = __toCommonJS(CommandDeserializer_exports);
 var import_Command = require("../../utils/Command.cjs");
-var import_CommandType = require("../../utils/CommandType.cjs");
 var import_Type = require("../../utils/Type.cjs");
 var import_TypeDeserializer = require("./TypeDeserializer.cjs");
 class CommandDeserializer {
+  /**
+   * @param {Int8Array} buffer
+   */
   constructor(buffer) {
     this.buffer = buffer;
     this.command = new import_Command.Command(buffer[0], buffer[10], []);
@@ -43,8 +45,14 @@ class CommandDeserializer {
   isAtEnd() {
     return this.position === this.buffer.length;
   }
+  /**
+   * @param {number} typeNum
+   * @returns {any}
+   */
   readObject(typeNum) {
-    const type = Object.entries(import_Type.Type).find((entry) => entry[1] === typeNum)[0];
+    const entry = Object.entries(import_Type.Type).find((entry2) => entry2[1] === typeNum);
+    if (!entry) throw new Error("Unknown type number: " + typeNum);
+    const type = entry[0];
     switch (type) {
       case "JAVONET_COMMAND":
         return this.readCommand();

package/dist/core/protocol/CommandSerializer.cjs

@@ -22,28 +22,48 @@ __export(CommandSerializer_exports, {
 });
 module.exports = __toCommonJS(CommandSerializer_exports);
 var import_TypeSerializer = require("./TypeSerializer.cjs");
+var import_ReferencesCache = require("../referenceCache/ReferencesCache.cjs");
 var import_Command = require("../../utils/Command.cjs");
+var import_CommandType = require("../../utils/CommandType.cjs");
 var import_RuntimeName = require("../../utils/RuntimeName.cjs");
+var import_TypesHandler = require("../../utils/TypesHandler.cjs");
 class CommandSerializer {
-  serialize(rootCommand, connectionData) {
+  /**
+   * Serializes the root command with connection data and optional runtime version.
+   * @param {Command} rootCommand
+   * @param {IConnectionData} connectionData
+   * @param {number} runtimeVersion
+   * @returns {Int8Array}
+   */
+  serialize(rootCommand, connectionData, runtimeVersion = 0) {
     const buffers = [];
-    buffers.push(Uint8Array.of(rootCommand.runtimeName, 0));
+    buffers.push(Uint8Array.of(rootCommand.runtimeName, runtimeVersion));
     if (connectionData) {
       buffers.push(connectionData.serializeConnectionData());
     } else {
       buffers.push(Uint8Array.of(0, 0, 0, 0, 0, 0, 0));
     }
-    buffers.push(Uint8Array.of(import_RuntimeName.RuntimeName.Nodejs, rootCommand.commandType));
+    buffers.push(Uint8Array.of(import_RuntimeName.RuntimeName.Python, rootCommand.commandType));
     this.serializeRecursively(rootCommand, buffers);
     return concatenateUint8Arrays(buffers);
   }
+  /**
+   * Recursively serializes command payload.
+   * @param {Command} command
+   * @param {Array<Uint8Array>} buffers
+   */
   serializeRecursively(command, buffers) {
     for (const item of command.payload) {
       if (item instanceof import_Command.Command) {
         buffers.push(import_TypeSerializer.TypeSerializer.serializeCommand(item));
         this.serializeRecursively(item, buffers);
-      } else {
+      } else if (import_TypesHandler.TypesHandler.isPrimitiveOrNullOrUndefined(item)) {
         buffers.push(import_TypeSerializer.TypeSerializer.serializePrimitive(item));
+      } else {
+        const cachedReference = import_ReferencesCache.ReferencesCache.getInstance().cacheReference(item);
+        const refCommand = new import_Command.Command(import_RuntimeName.RuntimeName.Nodejs, import_CommandType.CommandType.Reference, cachedReference);
+        buffers.push(import_TypeSerializer.TypeSerializer.serializeCommand(refCommand));
+        this.serializeRecursively(refCommand, buffers);
       }
     }
   }

package/dist/core/protocol/TypeDeserializer.cjs

@@ -25,9 +25,17 @@ var import_Command = require("../../utils/Command.cjs");
 var import_buffer = require("buffer");
 var import_StringEncodingMode = require("../../utils/StringEncodingMode.cjs");
 class TypeDeserializer {
+  /**
+   * @param {Int8Array} encodedCommand
+   * @returns {Command}
+   */
   static deserializeCommand(encodedCommand) {
     return new import_Command.Command(encodedCommand[0], encodedCommand[1], []);
   }
+  /**
+   * @param {number} stringEncodingMode
+   * @param {Int8Array} encodedString
+   */
   static deserializeString(stringEncodingMode, encodedString) {
     switch (stringEncodingMode) {
       case import_StringEncodingMode.StringEncodingMode.ASCII:
@@ -53,30 +61,57 @@ class TypeDeserializer {
         throw "Unknown string encoding - not supported in JavaScript";
     }
   }
+  /**
+   * @param {Int8Array} encodedInt
+   */
   static deserializeInt(encodedInt) {
     return encodedInt[0] & 255 | (encodedInt[1] & 255) << 8 | (encodedInt[2] & 255) << 16 | (encodedInt[3] & 255) << 24;
   }
+  /**
+   * @param {Int8Array} encodedBool
+   */
   static deserializeBool(encodedBool) {
     return encodedBool[0] === 1;
   }
+  /**
+   * @param {Int8Array} encodedFloat
+   */
   static deserializeFloat(encodedFloat) {
     return import_buffer.Buffer.from(encodedFloat).readFloatLE();
   }
+  /**
+   * @param {Int8Array} encodedByte
+   */
   static deserializeByte(encodedByte) {
     return import_buffer.Buffer.from(encodedByte).readUint8();
   }
+  /**
+   * @param {Int8Array} encodedChar
+   */
   static deserializeChar(encodedChar) {
     return import_buffer.Buffer.from(encodedChar).readUint8();
   }
+  /**
+   * @param {Int8Array} encodedLongLong
+   */
   static deserializeLongLong(encodedLongLong) {
     return import_buffer.Buffer.from(encodedLongLong).readBigInt64LE();
   }
+  /**
+   * @param {Int8Array} encodedDouble
+   */
   static deserializeDouble(encodedDouble) {
     return import_buffer.Buffer.from(encodedDouble).readDoubleLE();
   }
+  /**
+   * @param {Int8Array} encodedULLong
+   */
   static deserializeULLong(encodedULLong) {
     return import_buffer.Buffer.from(encodedULLong).readBigUInt64LE();
   }
+  /**
+   * @param {Int8Array} encodedUInt
+   */
   static deserializeUInt(encodedUInt) {
     return import_buffer.Buffer.from(encodedUInt).readUIntLE(0, 4);
   }

package/dist/core/protocol/TypeSerializer.cjs

@@ -28,40 +28,54 @@ var import_buffer = require("buffer");
 var import_CustomError = require("../../utils/CustomError.cjs");
 const encoder = new TextEncoder();
 class TypeSerializer {
+  /**
+   * @param {unknown} payload_item
+   */
   static serializePrimitive(payload_item) {
     if (payload_item === null) {
       return TypeSerializer.serializeNull();
     }
     if (payload_item instanceof import_Command.Command) {
       return TypeSerializer.serializeCommand(payload_item);
-    } else if (typeof payload_item === "number" || payload_item instanceof Number) {
+    } else if (typeof payload_item === "number") {
       if (Number.isInteger(payload_item)) {
         return TypeSerializer.serializeInt(payload_item);
       } else {
         return TypeSerializer.serializeDouble(payload_item);
       }
-    } else if (typeof payload_item === "string" || payload_item instanceof String) {
+    } else if (typeof payload_item === "string") {
       return TypeSerializer.serializeString(payload_item);
-    } else if (typeof payload_item === "boolean" || payload_item instanceof Boolean) {
+    } else if (typeof payload_item === "boolean") {
       return TypeSerializer.serializeBool(payload_item);
     } else {
       if (payload_item instanceof Promise) {
-        throw new import_CustomError.CustomError("Type not supported - Promise", JSON.stringify(payload_item));
+        const message = "Unsupported payload item type: " + (payload_item?.constructor?.name || typeof payload_item) + " for payload item: " + payload_item;
+        throw new import_CustomError.CustomError(message, "JAVONET_PROMISE");
       }
       if (payload_item === void 0) {
-        throw "Type not supported - undefined";
+        throw Error(
+          "Unsupported payload item type: " + typeof payload_item + " for payload item: " + payload_item
+        );
       }
-      throw "Unknown type - not supported in JavaScript";
+      throw Error(
+        "Unsupported payload item type: " + (payload_item?.constructor?.name || typeof payload_item) + " for payload item: " + payload_item
+      );
     }
   }
+  /**
+   * @param {Command} command
+   */
   static serializeCommand(command) {
     const buffer = import_buffer.Buffer.alloc(7);
     buffer.writeUInt8(import_Type.Type.JAVONET_COMMAND, 0);
     buffer.fill(import_buffer.Buffer.from(this.serializeIntValue(command.payload.length)), 1, 5);
-    buffer.writeUInt8(command.runtime, 5);
+    buffer.writeUInt8(command.runtimeName, 5);
     buffer.writeUInt8(command.commandType, 6);
     return buffer;
   }
+  /**
+   * @param {string} string_value
+   */
   static serializeString(string_value) {
     let bytes = encoder.encode(string_value);
     const buffer = import_buffer.Buffer.alloc(6 + bytes.length);
@@ -71,6 +85,9 @@ class TypeSerializer {
     buffer.fill(import_buffer.Buffer.from(bytes), 6, 6 + bytes.length);
     return buffer;
   }
+  /**
+   * @param {number} int_value
+   */
   static serializeInt(int_value) {
     const buffer = import_buffer.Buffer.alloc(6);
     buffer.writeUInt8(import_Type.Type.JAVONET_INTEGER, 0);
@@ -78,6 +95,9 @@ class TypeSerializer {
     buffer.writeInt32LE(int_value, 2);
     return buffer;
   }
+  /**
+   * @param {boolean} bool_value
+   */
   static serializeBool(bool_value) {
     const buffer = import_buffer.Buffer.alloc(3);
     buffer.writeUInt8(import_Type.Type.JAVONET_BOOLEAN, 0);
@@ -85,6 +105,9 @@ class TypeSerializer {
     buffer.writeUInt8(bool_value ? 1 : 0, 2);
     return buffer;
   }
+  /**
+   * @param {number} float_value
+   */
   static serializeFloat(float_value) {
     const buffer = import_buffer.Buffer.alloc(6);
     buffer.writeUInt8(import_Type.Type.JAVONET_FLOAT, 0);
@@ -92,6 +115,9 @@ class TypeSerializer {
     buffer.writeFloatLE(float_value, 2);
     return buffer;
   }
+  /**
+   * @param {number} byte_value
+   */
   static serializeByte(byte_value) {
     const buffer = import_buffer.Buffer.alloc(3);
     buffer.writeUInt8(import_Type.Type.JAVONET_BYTE, 0);
@@ -99,6 +125,9 @@ class TypeSerializer {
     buffer.writeUInt8(byte_value, 2);
     return buffer;
   }
+  /**
+   * @param {number} char_value
+   */
   static serializeChar(char_value) {
     const buffer = import_buffer.Buffer.alloc(3);
     buffer.writeUInt8(import_Type.Type.JAVONET_CHAR, 0);
@@ -106,6 +135,9 @@ class TypeSerializer {
     buffer.writeUInt8(char_value, 2);
     return buffer;
   }
+  /**
+   * @param {number} longlong_value
+   */
   static serializeLongLong(longlong_value) {
     const buffer = import_buffer.Buffer.alloc(10);
     buffer.writeUInt8(import_Type.Type.JAVONET_LONG_LONG, 0);
@@ -113,6 +145,9 @@ class TypeSerializer {
     buffer.writeBigInt64LE(BigInt(longlong_value), 2);
     return buffer;
   }
+  /**
+   * @param {number} double_value
+   */
   static serializeDouble(double_value) {
     const buffer = import_buffer.Buffer.alloc(10);
     buffer.writeUInt8(import_Type.Type.JAVONET_DOUBLE, 0);
@@ -120,6 +155,9 @@ class TypeSerializer {
     buffer.writeDoubleLE(double_value, 2);
     return buffer;
   }
+  /**
+   * @param {bigint} ullong_value
+   */
   static serializeULLong(ullong_value) {
     const buffer = import_buffer.Buffer.alloc(10);
     buffer.writeUInt8(import_Type.Type.JAVONET_UNSIGNED_LONG_LONG, 0);
@@ -127,6 +165,9 @@ class TypeSerializer {
     buffer.writeBigUInt64LE(ullong_value, 2);
     return buffer;
   }
+  /**
+   * @param {number} uint_value
+   */
   static serializeUInt(uint_value) {
     const buffer = import_buffer.Buffer.alloc(6);
     buffer.writeUInt8(import_Type.Type.JAVONET_UNSIGNED_INTEGER, 0);
@@ -141,6 +182,9 @@ class TypeSerializer {
     buffer.writeUInt8(0, 2);
     return buffer;
   }
+  /**
+   * @param {number} int_value
+   */
   static serializeIntValue(int_value) {
     const buffer = import_buffer.Buffer.alloc(4);
     buffer.writeInt32LE(int_value, 0);

package/dist/core/receiver/Receiver.cjs

@@ -38,7 +38,7 @@ class Receiver {
     _RuntimeLogger?.printRuntimeInfo();
   }
   /**
-   * @param {number[]} messageByteArray
+   * @param {Int8Array} messageByteArray
    */
   static sendCommand(messageByteArray) {
     return new import_CommandSerializer.CommandSerializer().serialize(

package/dist/core/receiver/ReceiverNative.cjs

@@ -23,9 +23,15 @@ __export(ReceiverNative_exports, {
 module.exports = __toCommonJS(ReceiverNative_exports);
 var import_Receiver = require("./Receiver.cjs");
 class ReceiverNative {
+  /**
+   * @param {Int8Array} messageByteArray
+   */
   static sendCommand(messageByteArray) {
     return import_Receiver.Receiver.sendCommand(messageByteArray);
   }
+  /**
+   * @param {Int8Array} messageByteArray
+   */
   static heartBeat(messageByteArray) {
     return import_Receiver.Receiver.heartBeat(messageByteArray);
   }

package/dist/core/transmitter/Transmitter.cjs

@@ -23,15 +23,31 @@ __export(Transmitter_exports, {
 module.exports = __toCommonJS(Transmitter_exports);
 var import_TransmitterWrapper = require("./TransmitterWrapper.cjs");
 class Transmitter {
+  /**
+   * @param {Int8Array} messageArray
+   * @returns {Int8Array}
+   */
   static sendCommand(messageArray) {
     return import_TransmitterWrapper.TransmitterWrapper.sendCommand(messageArray);
   }
-  static activate = function(licenseKey) {
+  /**
+   * @param {string} licenseKey 
+   * @returns {void}
+   */
+  static activate(licenseKey) {
     return import_TransmitterWrapper.TransmitterWrapper.activate(licenseKey);
-  };
+  }
+  /**
+   * @param {string} configSource
+   * @returns {void}
+  */
   static setConfigSource(configSource) {
     return import_TransmitterWrapper.TransmitterWrapper.setConfigSource(configSource);
   }
+  /**
+   * @param {string} workingDirectory 
+   * @returns 
+   */
   static setJavonetWorkingDirectory(workingDirectory) {
     return import_TransmitterWrapper.TransmitterWrapper.setJavonetWorkingDirectory(workingDirectory);
   }

package/dist/core/transmitter/TransmitterWebsocket.cjs

@@ -40,13 +40,16 @@ class TransmitterWebsocket {
   }
   /**
    * @async
-   * @param {number[]} messageByteArray
-   * @param {WsConnectionData} connectionData
-   * @returns {Promise<number[]>} responseByteArray
+   * @param {Int8Array} messageByteArray
+   * @param {IConnectionData} connectionData
+   * @returns {Promise<Int8Array>} responseByteArray
    */
-  static async sendCommand(messageByteArray, connectionData) {
+  static sendCommand(messageByteArray, connectionData) {
     const { hostname } = connectionData;
-    return new import_WebSocketClient.WebSocketClient(hostname).send(messageByteArray);
+    const options = {
+      isDisconnectedAfterMessage: true
+    };
+    return new import_WebSocketClient.WebSocketClient(hostname, options).send(messageByteArray);
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/core/transmitter/TransmitterWebsocketBrowser.cjs

@@ -36,7 +36,7 @@ class TransmitterWebsocketBrowser {
   /**
    * @async
    * @param {Int8Array} messageByteArray
-   * @param {ConnectionData} connectionData
+   * @param {IConnectionData} connectionData
    * @returns {Promise<Int8Array>} responseByteArray
    */
   static async sendCommand(messageByteArray, connectionData) {

package/dist/core/transmitter/TransmitterWrapper.cjs

@@ -24,11 +24,12 @@ module.exports = __toCommonJS(TransmitterWrapper_exports);
 var import_Runtime = require("../../utils/Runtime.cjs");
 var import_ReceiverNative = require("../receiver/ReceiverNative.cjs");
 const import_meta = {};
-let library;
+let library = null;
+let path = null;
 const requireDynamic = (0, import_Runtime.getRequire)(import_meta.url);
 class TransmitterWrapper {
   static isNativeLibraryLoaded() {
-    return library !== void 0;
+    return Boolean(library);
   }
   static loadNativeLibrary() {
     if (!(0, import_Runtime.isNodejsRuntime)()) {
@@ -38,35 +39,51 @@ class TransmitterWrapper {
       return;
     }
     try {
-      const path = requireDynamic("path");
+      if (!path) {
+        path = requireDynamic("path");
+      }
       const packagePath = (0, import_Runtime.getDependency)("javonet-binaries", import_meta.url);
       const binariesRootPath = path.dirname(packagePath);
-      const nativeAddonPath = path.join(binariesRootPath, "build", "Release", "JavonetNodejsRuntimeAddon.node");
+      const nativeAddonPath = path.join(
+        binariesRootPath,
+        "build",
+        "Release",
+        "JavonetNodejsRuntimeAddon.node"
+      );
       library = requireDynamic(nativeAddonPath);
       library.initializeTransmitter(binariesRootPath);
-      library.setReceiverNative(global.ReceiverNative);
+      library.setReceiverNative(global?.ReceiverNative);
     } catch (error) {
       throw error;
     }
   }
   /**
-   * @param {string} licenseKey 
+   * @param {string} licenseKey
    */
   static activate(licenseKey) {
     this.loadNativeLibrary();
     return library.activate(licenseKey);
   }
+  /**
+   * @param {Int8Array} messageArray
+   */
   static sendCommand(messageArray) {
     this.loadNativeLibrary();
     return library.sendCommand(messageArray);
   }
+  /**
+   * @param {string} configSource
+   */
   static setConfigSource(configSource) {
     this.loadNativeLibrary();
     return library.setConfigSource(configSource);
   }
-  static setJavonetWorkingDirectory(path) {
+  /**
+   * @param {string} path
+   */
+  static setJavonetWorkingDirectory(path2) {
     this.loadNativeLibrary();
-    library.setJavonetWorkingDirectory(path);
+    library.setJavonetWorkingDirectory(path2);
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/core/typeCache/TypeCache.cjs

@@ -22,7 +22,9 @@ __export(TypeCache_exports, {
 });
 module.exports = __toCommonJS(TypeCache_exports);
 class TypeCache {
+  /** @type {TypeCache | null} */
   static _instance = null;
+  /** @type {string[]} */
   typeCache = [];
   constructor() {
     if (TypeCache._instance === null) {
@@ -30,12 +32,18 @@ class TypeCache {
     }
     return TypeCache._instance;
   }
+  /**
+   * @param {string} typRegex
+   */
   cacheType(typRegex) {
     this.typeCache.push(typRegex);
   }
   isTypeCacheEmpty() {
     return this.typeCache.length === 0;
   }
+  /**
+   * @param {{ name: string }} typeToCheck
+   */
   isTypeAllowed(typeToCheck) {
     for (let pattern of this.typeCache) {
       if (new RegExp(pattern).test(typeToCheck.name)) {

package/dist/core/webSocketClient/WebSocketClient.cjs

@@ -33,7 +33,7 @@ let WebSocket = null;
 class WebSocketClient {
   /**
    * @param {string} url
-   * @param {object} options
+   * @param {{ isDisconnectedAfterMessage: boolean }} options
    */
   constructor(url, options) {
     this.url = url;
@@ -44,7 +44,7 @@ class WebSocketClient {
   /**
    * Connects to the WebSocket server.
    * @async
-   * @returns {Promise<WebSocket>} - A promise that resolves when the connection is established.
+   * @returns {Promise<wsClient>} - A promise that resolves when the connection is established.
    */
   async connect() {
     if (!WebSocket) {
@@ -52,7 +52,7 @@ class WebSocketClient {
         try {
           WebSocket = requireDynamic("ws");
         } catch (error) {
-          if (error.code === "MODULE_NOT_FOUND") {
+          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;
@@ -60,6 +60,10 @@ class WebSocketClient {
       }
     }
     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;
@@ -76,18 +80,17 @@ class WebSocketClient {
   /**
    * Sends messageArray through websocket connection
    * @async
-   * @param {Buffer|ArrayBuffer|Buffer[]} messageArray
-   * @returns {Promise<Buffer|ArrayBuffer|Buffer[]>}
+   * @param {Int8Array} messageArray
+   * @returns {Promise<Int8Array>}
    */
   send(messageArray) {
     return new Promise((resolve, reject) => {
       ;
       (this.instance ? Promise.resolve(this.instance) : this._connect()).then((client) => {
-        client.send(messageArray, (err) => {
-          if (err) {
-            reject(err);
-          }
-        });
+        client.send(
+          /** @type {any} */
+          messageArray
+        );
         client.on("message", (message) => {
           resolve(message);
           if (this.isDisconnectedAfterMessage) {
@@ -113,7 +116,7 @@ class WebSocketClient {
    * Connects to the WebSocket server.
    * @private
    * @async
-   * @returns {Promise<WebSocket>} - A promise that resolves when the connection is established.
+   * @returns {Promise<wsClient>} - A promise that resolves when the connection is established.
    */
   _connect() {
     if (!WebSocket) {
@@ -121,7 +124,10 @@ class WebSocketClient {
         try {
           WebSocket = requireDynamic("ws");
         } catch (error) {
-          if (error.code === "MODULE_NOT_FOUND") {
+          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;
@@ -129,6 +135,10 @@ class WebSocketClient {
       }
     }
     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.isConnected = true;

package/dist/core/webSocketClient/WebSocketClientBrowser.cjs

@@ -86,8 +86,8 @@ class WebSocketClientBrowser {
    */
   _connect() {
     return new Promise((resolve, reject) => {
-      if (!WsClient || WsClient === null) {
-        reject(new Error("missing WebSocket client"));
+      if (WsClient === null) {
+        return reject(new Error("missing WebSocket client"));
       }
       this.instance = new WsClient(this.url);
       this.instance.binaryType = "arraybuffer";