javonet-ruby-sdk 2.5.17 → 2.5.19

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/handler/GetStaticMethodAsDelegateHandler.cjs

@@ -33,7 +33,6 @@ class GetStaticMethodAsDelegateHandler extends import_AbstractHandler.AbstractHa
   /**
    * Processes a command to retrieve a static method as a delegate.
    * @param {Command} command - The command containing payload data.
-   * @param {Array<*>} command.payload - The payload containing type, method name, and arguments.
    * @returns {Function} The delegate for the static method.
    * @throws {Error} If the parameters mismatch or the method cannot be found.
    */
@@ -55,12 +54,13 @@ class GetStaticMethodAsDelegateHandler extends import_AbstractHandler.AbstractHa
    * Retrieves the method from the type.
    * @param {Object} type - The class or constructor to search for the method.
    * @param {string} methodName - The name of the method.
-   * @param {Array<Function>} argsType - The argument types.
-   * @param {Object} modifier - Parameter modifier (not used in JS implementation).
    * @returns {Function|null} The found method or null if not found.
    */
   getMethod(type, methodName) {
-    const method = type[methodName];
+    const method = (
+      /** @type {any} */
+      type[methodName]
+    );
     return typeof method === "function" ? method : null;
   }
   /**
@@ -70,9 +70,11 @@ class GetStaticMethodAsDelegateHandler extends import_AbstractHandler.AbstractHa
    * @returns {Error} The error with detailed message.
    */
   createMethodNotFoundError(type, methodName) {
-    const methods = Object.keys(type).filter((key) => typeof type[key] === "function");
+    const methods = Object.keys(type).filter((key) => typeof /** @type {any} */
+    type[key] === "function");
     const availableMethods = methods.map((name) => `${name}()`);
-    const message = `Method ${methodName} not found in class ${type.name}. Available public static methods:
+    const message = `Method ${methodName} not found in class ${/** @type {{name: string}} */
+    type.name}. Available public static methods:
 ${availableMethods.join("\n")}`;
     return new Error(message);
   }

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/handler/GetTypeHandler.cjs

@@ -35,6 +35,11 @@ class GetTypeHandler extends import_AbstractHandler.AbstractHandler {
     this.typeCache = new import_TypeCache.TypeCache();
     this.loadLibaryHandler = new import_LoadLibraryHandler.LoadLibraryHandler();
   }
+  /**
+   * 
+   * @param {Command} command 
+   * @returns 
+   */
   process(command) {
     try {
       if (command.payload.length < this.requiredParametersCount) {
@@ -43,7 +48,10 @@ class GetTypeHandler extends import_AbstractHandler.AbstractHandler {
       const { payload } = command;
       let typeName = payload[0];
       typeName = typeName.replace(".js", "");
-      let typeToReturn = global[typeName];
+      const typeToReturn = (
+        /** @type {any} */
+        global[typeName]
+      );
       if (typeToReturn === void 0) {
         let message = `Type ${typeName} not found
 `;
@@ -69,7 +77,7 @@ Allowed types: ${allowed_types}`
     }
   }
   getAvailableTypes() {
-    let availableTypes = [];
+    const availableTypes = [];
     this.loadLibaryHandler.getLoadedLibraries().forEach((lib) => {
       const dynamicRequire = (0, import_Runtime.getRequire)(import_meta.url);
       const moduleExports = dynamicRequire(`${lib}`);

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/handler/Handler.cjs

@@ -50,16 +50,10 @@ var import_InvokeDelegateHandler = require("./InvokeDelegateHandler.cjs");
 var import_InvokeGlobalFunctionHandler = require("./InvokeGlobalFunctionHandler.cjs");
 var import_CommandType = require("../../utils/CommandType.cjs");
 var import_Command = require("../../utils/Command.cjs");
+var import_TypesHandler = require("../../utils/TypesHandler.cjs");
 var import_ExceptionSerializer = require("../../utils/exception/ExceptionSerializer.cjs");
 var import_ConvertTypeHandler = require("./ConvertTypeHandler.cjs");
 var import_AbstractHandler = require("./AbstractHandler.cjs");
-function isResponseSimpleType(response) {
-  let type = typeof response;
-  return ["string", "boolean", "number"].includes(type);
-}
-function isResponseNull(response) {
-  return response === null;
-}
 const handlers = {
   [import_CommandType.CommandType.Value]: new import_ValueHandler.ValueHandler(),
   [import_CommandType.CommandType.LoadLibrary]: new import_LoadLibraryHandler.LoadLibraryHandler(),
@@ -94,13 +88,16 @@ class Handler {
    */
   constructor(interpreter) {
     this.interpreter = interpreter;
-    handlers[import_CommandType.CommandType.PassDelegate] = new import_PassDelegateHandler.PassDelegateHandler(interpreter);
+    if (!this.interpreter) {
+      throw new Error("interpreter is undefined in Handler constructor");
+    }
+    handlers[import_CommandType.CommandType.PassDelegate] = new import_PassDelegateHandler.PassDelegateHandler(this.interpreter);
     Object.keys(handlers).forEach((commandTypeHandler) => {
       handlers[commandTypeHandler].handlers = handlers;
     });
   }
   /**
-   * @param {{ commandType: number; payload: any[]; runtimeName: number; }} command
+   * @param {Command} command
    */
   handleCommand(command) {
     try {
@@ -116,11 +113,11 @@ class Handler {
   }
   /**
    * @param {any} response
-   * @param {number} runtimeName
+   * @param {RuntimeName} runtimeName
    * @returns {Command}
    */
   parseCommand(response, runtimeName) {
-    if (isResponseNull(response) || isResponseSimpleType(response)) {
+    if (import_TypesHandler.TypesHandler.isPrimitiveOrNullOrUndefined(response)) {
       return import_Command.Command.createResponse(response, runtimeName);
     } else {
       let cache = import_ReferencesCache.ReferencesCache.getInstance();

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/handler/InvokeGlobalFunctionHandler.cjs

@@ -27,6 +27,9 @@ class InvokeGlobalFunctionHandler extends import_AbstractHandler.AbstractHandler
   constructor() {
     super();
   }
+  /**
+   * @param {Command} command
+   */
   process(command) {
     try {
       if (command.payload.length < this.requiredParametersCount) {

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/handler/InvokeInstanceMethodHandler.cjs

@@ -27,6 +27,9 @@ class InvokeInstanceMethodHandler extends import_AbstractHandler.AbstractHandler
   constructor() {
     super();
   }
+  /**
+   * @param {Command} command
+   */
   process(command) {
     try {
       if (command.payload.length < this.requiredParametersCount) {

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/handler/InvokeStaticMethodHandler.cjs

@@ -27,6 +27,9 @@ class InvokeStaticMethodHandler extends import_AbstractHandler.AbstractHandler {
   constructor() {
     super();
   }
+  /**
+   * @param {Command} command
+   */
   process(command) {
     try {
       if (command.payload.length < this.requiredParametersCount) {

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/handler/LoadLibraryHandler.cjs

@@ -27,10 +27,14 @@ const import_meta = {};
 const dynamicImport = (0, import_Runtime.getRequire)(import_meta.url);
 class LoadLibraryHandler extends import_AbstractHandler.AbstractHandler {
   requiredParametersCount = 1;
+  /** @type {string[]} */
   static loadedLibraries = [];
   constructor() {
     super();
   }
+  /**
+   * @param {Command} command
+   */
   process(command) {
     if (command.payload.length < this.requiredParametersCount) {
       throw new Error("Load Library parameters mismatch");

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/handler/SetGlobalStaticFieldHandler.cjs

@@ -27,6 +27,9 @@ class SetGlobalStaticFieldHandler extends import_AbstractHandler.AbstractHandler
   constructor() {
     super();
   }
+  /**
+   * @param {Command} command
+   */
   process(command) {
     try {
       if (command.payload.length < this.requiredParametersCount) {

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/handler/SetInstanceFieldHandler.cjs

@@ -27,6 +27,9 @@ class SetInstanceFieldHandler extends import_AbstractHandler.AbstractHandler {
   constructor() {
     super();
   }
+  /**
+   * @param {Command} command
+   */
   process(command) {
     try {
       if (command.payload.length < this.requiredParametersCount) {

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/handler/SetStaticFieldHandler.cjs

@@ -27,6 +27,9 @@ class SetStaticFieldHandler extends import_AbstractHandler.AbstractHandler {
   constructor() {
     super();
   }
+  /**
+   * @param {Command} command
+   */
   process(command) {
     try {
       if (command.payload.length < this.requiredParametersCount) {

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/handler/ValueHandler.cjs

@@ -26,6 +26,10 @@ class ValueHandler extends import_AbstractHandler.AbstractHandler {
   constructor() {
     super();
   }
+  /**
+   * @param {Command} command
+   * @returns {unknown}
+   */
   process(command) {
     const { payload } = command;
     return payload[0];

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/interpreter/Interpreter.cjs

@@ -38,7 +38,8 @@ if (!_TransmitterWebsocket) {
 }
 const requireDynamic = (0, import_Runtime.getRequire)(import_meta.url);
 class Interpreter {
-  handler;
+  /** @type {Handler | null} */
+  handler = null;
   /**
    *
    * @param {Command} command
@@ -47,21 +48,24 @@ class Interpreter {
    */
   async executeAsync(command, connectionData) {
     try {
+      if (!this.handler) {
+        this.handler = new import_Handler.Handler(this);
+      }
       let messageByteArray = new import_CommandSerializer.CommandSerializer().serialize(command, connectionData);
-      let responseByteArray;
+      let responseByteArray = void 0;
       if (command.runtimeName === import_RuntimeName.RuntimeName.Nodejs && connectionData.connectionType === import_ConnectionType.ConnectionType.IN_MEMORY) {
         if ((0, import_Runtime.isNodejsRuntime)()) {
           if (!_Receiver) {
             const { Receiver } = require("../receiver/Receiver.cjs");
             _Receiver = Receiver;
           }
-          responseByteArray = _Receiver.sendCommand(messageByteArray);
+          responseByteArray = _Receiver?.sendCommand(messageByteArray);
         } else {
           throw new Error("Node.js runtime not found");
         }
       } else if (connectionData.connectionType === import_ConnectionType.ConnectionType.WEB_SOCKET) {
         try {
-          const _response = await _TransmitterWebsocket.sendCommand(
+          const _response = await _TransmitterWebsocket?.sendCommand(
             messageByteArray,
             connectionData
           );
@@ -80,11 +84,14 @@ class Interpreter {
             const { Transmitter } = require("../transmitter/Transmitter.cjs");
             _Transmitter = Transmitter;
           }
-          responseByteArray = await _Transmitter.sendCommand(messageByteArray);
+          responseByteArray = await _Transmitter?.sendCommand(messageByteArray);
         } else {
           throw new Error("Allowed only to run in nodejs runtime");
         }
       }
+      if (!responseByteArray) {
+        throw new Error("No response received from Transmitter");
+      }
       return new import_CommandDeserializer.CommandDeserializer(responseByteArray).deserialize();
     } catch (error) {
       throw error;
@@ -93,23 +100,29 @@ class Interpreter {
   /**
    *
    * @param {Command} command
-   * @param {WsConnectionData} connectionData
-   * @returns {Promise<Command>}
+   * @param {IConnectionData} connectionData
+   * @returns {Command | Promise<Command>}
    */
   execute(command, connectionData) {
     try {
+      if (!this.handler) {
+        this.handler = new import_Handler.Handler(this);
+      }
       let messageByteArray = new import_CommandSerializer.CommandSerializer().serialize(command, connectionData);
-      let responseByteArray;
+      let responseByteArray = void 0;
       if (command.runtimeName === import_RuntimeName.RuntimeName.Nodejs && connectionData.connectionType === import_ConnectionType.ConnectionType.IN_MEMORY) {
         if ((0, import_Runtime.isNodejsRuntime)()) {
           if (!_Receiver) {
             const { Receiver } = require("../receiver/Receiver.cjs");
             _Receiver = Receiver;
           }
-          responseByteArray = _Receiver.sendCommand(messageByteArray);
+          responseByteArray = _Receiver?.sendCommand(messageByteArray);
         }
       } else if (connectionData.connectionType === import_ConnectionType.ConnectionType.WEB_SOCKET) {
-        const promise = _TransmitterWebsocket.sendCommand(messageByteArray, connectionData);
+        const promise = _TransmitterWebsocket?.sendCommand(messageByteArray, connectionData);
+        if (!promise) {
+          throw new Error("TransmitterWebsocket not found");
+        }
         return promise.then((_response) => {
           if (_response) {
             const command2 = new import_CommandDeserializer.CommandDeserializer(_response).deserialize();
@@ -126,11 +139,14 @@ class Interpreter {
             const { Transmitter } = require("../transmitter/Transmitter.cjs");
             _Transmitter = Transmitter;
           }
-          responseByteArray = _Transmitter.sendCommand(messageByteArray);
+          responseByteArray = _Transmitter?.sendCommand(messageByteArray);
         } else {
           throw new Error("Allowed only to run in nodejs runtime");
         }
       }
+      if (!responseByteArray) {
+        throw new Error("No response received from Transmitter");
+      }
       return new import_CommandDeserializer.CommandDeserializer(responseByteArray).deserialize();
     } catch (error) {
       throw error;
@@ -138,7 +154,7 @@ class Interpreter {
   }
   /**
    *
-   * @param {number[]} messageByteArray
+   * @param {Int8Array} messageByteArray
    * @returns {Command}
    */
   process(messageByteArray) {

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/namespaceCache/NamespaceCache.cjs

@@ -22,7 +22,9 @@ __export(NamespaceCache_exports, {
 });
 module.exports = __toCommonJS(NamespaceCache_exports);
 class NamespaceCache {
+  /** @type {NamespaceCache | null} */
   static _instance = null;
+  /** @type {string[]} */
   namespaceCache = [];
   constructor() {
     if (NamespaceCache._instance === null) {
@@ -30,12 +32,22 @@ class NamespaceCache {
     }
     return NamespaceCache._instance;
   }
+  /**
+   * @param {string} namespaceRegex
+   */
   cacheNamespace(namespaceRegex) {
     this.namespaceCache.push(namespaceRegex);
   }
+  /**
+   * @returns {boolean}
+   */
   isNamespaceCacheEmpty() {
     return this.namespaceCache.length === 0;
   }
+  /**
+   * @param {string} typeToCheck
+   * @returns {boolean}
+   */
   isTypeAllowed(typeToCheck) {
     for (let pattern of this.namespaceCache) {
       if (new RegExp(pattern).test(typeToCheck.constructor.name)) {

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

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

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