javonet-ruby-sdk 2.6.6 → 2.6.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc4db9be4d5355239f2f3075f5e4b69df7138dd6ba981a041158c112f7de3108
-  data.tar.gz: 9dd14af19a2cc86ff283ab90354867737d4bd00dc9d026217a2b877a289b5cfd
+  metadata.gz: 64594a08282eb8db907b43ea836c9ebf444e2fe9c9aaaf436294952c0977de40
+  data.tar.gz: d9bbd4889a2363b1a87d132884d10c51838ecf4387e661f4e87751fd3e0bcc96
 SHA512:
-  metadata.gz: 8b94c624e8e3ae5b186ae61b993993ec8c578492ee98a6b63bb59a6ecf4e2682d55e439796f3e9fc2f66094c15faf306cc7d3cbe128db3baf0c095c739ae9548
-  data.tar.gz: b7d342b393b165dc3f31cf13c25a5288dc52c8c28d572e3f6185da8e96b30b20d8c63e0e41526bcae6bedb6baa902a23ce14ee68b61b31fa10766d54c1090a0e
+  metadata.gz: c4ca5e21b95637ee70e302546bb72b9981cf56f2f622640fa714e1706d05c97c7c7552474cdc927beeb5d9709d6b462b36d7ffb601222467be93c988050114a7
+  data.tar.gz: 0b840b8e096f32d1a11c86ad7afd9dc0ce23f0fc3eb3161deb3eb1efb2f431f360756d032d6ae10d435f6d950b503ac8843e6cb3c43eb39cadd438c31945c959

data/VERSION

@@ -1 +1 @@
-2.6.6
+2.6.8

data/lib/javonet-ruby-sdk/Binaries/Native/Linux/ARM64/version.txt

@@ -1 +1 @@
-2.6.6
+2.6.8

data/lib/javonet-ruby-sdk/Binaries/Native/Linux/X64/version.txt

@@ -1 +1 @@
-2.6.6
+2.6.8

data/lib/javonet-ruby-sdk/Binaries/Native/MacOs/ARM64/version.txt

@@ -1 +1 @@
-2.6.6
+2.6.8

data/lib/javonet-ruby-sdk/Binaries/Native/MacOs/X64/version.txt

@@ -1 +1 @@
-2.6.6
+2.6.8

data/lib/javonet-ruby-sdk/Binaries/Native/Windows/X64/version.txt

@@ -1 +1 @@
-'2.6.6' 
+'2.6.8' 

data/lib/javonet-ruby-sdk/Binaries/Native/Windows/X86/version.txt

@@ -1 +1 @@
-'2.6.6' 
+'2.6.8' 

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

@@ -142,18 +142,13 @@ class Handler {
   }
   /**
    * @param {Command} command
+   * @returns {Promise<Command> | Command}
    */
   handleCommand(command) {
     try {
       if (command.commandType === import_CommandType.CommandType.RetrieveArray) {
         const responseArray = handlers[import_CommandType.CommandType.Reference].handleCommand(command.payload[0]);
-        if (responseArray instanceof Promise) {
-          return responseArray.then((resolvedResponseArray) => {
-            return import_Command.Command.createArrayResponse(resolvedResponseArray, command.runtimeName);
-          });
-        } else {
-          return import_Command.Command.createArrayResponse(responseArray, command.runtimeName);
-        }
+        return import_Command.Command.createArrayResponse(responseArray, command.runtimeName);
       }
       const response = handlers[command.commandType].handleCommand(command);
       return this.parseCommand(response, command.runtimeName);

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

@@ -23,10 +23,10 @@ __export(LoadLibraryHandler_exports, {
 module.exports = __toCommonJS(LoadLibraryHandler_exports);
 var import_Runtime = require("../../utils/Runtime.cjs");
 var import_AbstractHandler = require("./AbstractHandler.cjs");
-var import_fs = require("fs");
-var import_path = require("path");
 const import_meta = {};
-const dynamicImport = (0, import_Runtime.getRequire)(import_meta.url);
+let _existsSync = null;
+let _resolve = null;
+const requireDynamic = (0, import_Runtime.getRequire)(import_meta.url);
 class LoadLibraryHandler extends import_AbstractHandler.AbstractHandler {
   requiredParametersCount = 1;
   /** @type {string[]} */
@@ -41,24 +41,38 @@ class LoadLibraryHandler extends import_AbstractHandler.AbstractHandler {
     if (command.payload.length < this.requiredParametersCount) {
       throw new Error("Load Library parameters mismatch");
     }
-    let { payload } = command;
-    let [lib] = payload;
+    const { payload } = command;
+    const [lib] = payload;
     if (!lib) {
       throw new Error("Cannot load module: Library path is required but was not provided");
     }
-    const absolutePath = (0, import_path.resolve)(lib);
-    if (!(0, import_fs.existsSync)(lib) && !(0, import_fs.existsSync)(absolutePath)) {
+    if (!_existsSync) {
+      const { existsSync } = requireDynamic("fs");
+      _existsSync = existsSync;
+    }
+    if (!_resolve) {
+      const { resolve } = requireDynamic("path");
+      _resolve = resolve;
+    }
+    const absolutePath = _resolve ? _resolve(lib) : lib;
+    const candidatePaths = [lib, absolutePath];
+    const existingPath = candidatePaths.find((p) => _existsSync && _existsSync(p));
+    if (!existingPath) {
       throw new Error(`Cannot load module: Library not found: ${lib}`);
     }
-    let pathArray = lib.split(/[/\\]/);
+    const normalizedPath = _resolve ? _resolve(existingPath) : existingPath;
+    if (LoadLibraryHandler.loadedLibraries.includes(normalizedPath)) {
+      return 0;
+    }
+    const pathArray = normalizedPath.split(/[/\\]/);
     let libraryName = pathArray.length > 1 ? pathArray[pathArray.length - 1] : pathArray[0];
-    libraryName = libraryName.replace(".js", "");
+    libraryName = libraryName.replace(/\.js$/i, "");
     let moduleExports;
     try {
-      moduleExports = dynamicImport(lib);
-      LoadLibraryHandler.loadedLibraries.push(lib);
+      moduleExports = requireDynamic(normalizedPath);
+      LoadLibraryHandler.loadedLibraries.push(normalizedPath);
     } catch (error) {
-      throw Error("Cannot load module: " + lib + "\n" + error);
+      throw new Error("Cannot load module: " + normalizedPath + "\n" + error);
     }
     global[libraryName] = moduleExports;
     for (const [key, value] of Object.entries(moduleExports)) {

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

@@ -110,9 +110,9 @@ class PassDelegateHandler extends import_AbstractHandler.AbstractHandler {
   /**
    * Creates a method call to execute the command.
    * @param {Command} command - The command object.
-   * @returns {any} The response object.
+   * @returns {Promise<any>} The response object.
    */
-  createExecuteCall(command) {
+  async createExecuteCall(command) {
     return this.interpreter?.execute(command, new import_InMemoryConnectionData.InMemoryConnectionData());
   }
   /**

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

@@ -32,10 +32,7 @@ var import_Handler = require("../handler/Handler.cjs");
 const import_meta = {};
 let _Receiver;
 let _Transmitter;
-let _TransmitterWebsocket = null;
-if (!_TransmitterWebsocket) {
-  _TransmitterWebsocket = (0, import_Runtime.isNodejsRuntime)() ? import_TransmitterWebsocket.TransmitterWebsocket : import_TransmitterWebsocketBrowser.TransmitterWebsocketBrowser;
-}
+let _TransmitterWebsocket = (0, import_Runtime.isNodejsRuntime)() ? import_TransmitterWebsocket.TransmitterWebsocket : import_TransmitterWebsocketBrowser.TransmitterWebsocketBrowser;
 const requireDynamic = (0, import_Runtime.getRequire)(import_meta.url);
 class Interpreter {
   /** @type {Handler | null} */
@@ -51,40 +48,40 @@ class Interpreter {
    *
    * @param {Command} command
    * @param {IConnectionData} connectionData
-   * @returns
+   * @returns {Promise<Command>}
    */
-  async executeAsync(command, connectionData) {
+  async execute(command, connectionData) {
     try {
       let messageByteArray = new import_CommandSerializer.CommandSerializer().serialize(command, connectionData);
+      if (!(messageByteArray instanceof Uint8Array)) {
+        throw new Error("Serialized message is not Uint8Array");
+      }
       let responseByteArray = void 0;
-      if (connectionData.connectionType === import_ConnectionType.ConnectionType.WEB_SOCKET) {
-        const _response = await _TransmitterWebsocket?.sendCommand(
-          await messageByteArray,
-          connectionData
+      if (!(0, import_Runtime.isNodejsRuntime)() && connectionData.connectionType === import_ConnectionType.ConnectionType.IN_MEMORY) {
+        throw new Error(
+          "Nodejs Core Error: inMemory is only allowed in Nodejs runtime, not in browser"
         );
-        if (_response) {
-          const command2 = new import_CommandDeserializer.CommandDeserializer(_response).deserialize();
-          return command2;
-        } else {
-          throw new Error("Response not received from TransmitterWebsocket");
+      }
+      if (command.runtimeName === import_RuntimeName.RuntimeName.Nodejs && connectionData.connectionType === import_ConnectionType.ConnectionType.IN_MEMORY) {
+        if (!_Receiver) {
+          const { Receiver } = require("../receiver/Receiver.cjs");
+          _Receiver = Receiver;
         }
-      } else {
-        if (!(0, import_Runtime.isNodejsRuntime)()) {
-          throw new Error("InMemory is only allowed in Nodejs runtime");
+        if (!_Receiver) {
+          throw new Error("Nodejs Core Error: Receiver is undefined");
         }
-        if (command.runtimeName === import_RuntimeName.RuntimeName.Nodejs) {
-          if (!_Receiver) {
-            const { Receiver } = require("../receiver/Receiver.cjs");
-            _Receiver = Receiver;
-          }
-          responseByteArray = await _Receiver?.sendCommand(await messageByteArray);
-        } else {
-          if (!_Transmitter) {
-            const { Transmitter } = require("../transmitter/Transmitter.cjs");
-            _Transmitter = Transmitter;
-          }
-          responseByteArray = await _Transmitter?.sendCommand(await messageByteArray);
+        responseByteArray = await _Receiver.sendCommand(messageByteArray);
+      } else if (connectionData.connectionType === import_ConnectionType.ConnectionType.IN_MEMORY || connectionData.connectionType === import_ConnectionType.ConnectionType.TCP) {
+        if (!_Transmitter) {
+          const { Transmitter } = require("../transmitter/Transmitter.cjs");
+          _Transmitter = Transmitter;
         }
+        if (!_Transmitter) {
+          throw new Error("Nodejs Core Error: Transmitter is undefined");
+        }
+        responseByteArray = await _Transmitter.sendCommand(messageByteArray);
+      } else if (connectionData.connectionType === import_ConnectionType.ConnectionType.WEB_SOCKET) {
+        responseByteArray = await _TransmitterWebsocket.sendCommand(messageByteArray, connectionData);
       }
       if (!responseByteArray) {
         throw new Error("No response received from Transmitter");
@@ -94,68 +91,6 @@ class Interpreter {
       throw error;
     }
   }
-  /**
-   *
-   * @param {Command} command
-   * @param {IConnectionData} connectionData
-   * @returns {Command | Promise<Command>}
-   */
-  execute(command, connectionData) {
-    try {
-      let messageByteArray = new import_CommandSerializer.CommandSerializer().serialize(command, connectionData);
-      let responseByteArray = void 0;
-      if (connectionData.connectionType === import_ConnectionType.ConnectionType.WEB_SOCKET) {
-        throw new Error("Not supported");
-      } else {
-        if (!(0, import_Runtime.isNodejsRuntime)()) {
-          throw new Error("InMemory is only allowed in Nodejs runtime");
-        }
-        if (command.runtimeName === import_RuntimeName.RuntimeName.Nodejs && connectionData.connectionType === import_ConnectionType.ConnectionType.IN_MEMORY) {
-          if (!_Receiver) {
-            const { Receiver } = require("../receiver/Receiver.cjs");
-            _Receiver = Receiver;
-          }
-          if (!_Receiver) {
-            throw new Error("Receiver is undefined");
-          }
-          if (messageByteArray instanceof Uint8Array) {
-            responseByteArray = _Receiver.sendCommand(messageByteArray);
-          } else {
-            responseByteArray = messageByteArray.then((resolvedMessage) => {
-              return _Receiver.sendCommand(resolvedMessage);
-            });
-          }
-        } else {
-          if (!_Transmitter) {
-            const { Transmitter } = require("../transmitter/Transmitter.cjs");
-            _Transmitter = Transmitter;
-          }
-          if (!_Transmitter) {
-            throw new Error("Transmitter is undefined");
-          }
-          if (messageByteArray instanceof Uint8Array) {
-            responseByteArray = _Transmitter.sendCommand(messageByteArray);
-          } else {
-            responseByteArray = messageByteArray.then((resolvedMessage) => {
-              return _Transmitter.sendCommand(resolvedMessage);
-            });
-          }
-        }
-        if (!responseByteArray) {
-          throw new Error("No response received from Transmitter");
-        }
-        if (responseByteArray instanceof Promise) {
-          return responseByteArray.then((resolvedResponse) => {
-            return new import_CommandDeserializer.CommandDeserializer(resolvedResponse).deserialize();
-          });
-        } else {
-          return new import_CommandDeserializer.CommandDeserializer(responseByteArray).deserialize();
-        }
-      }
-    } catch (error) {
-      throw error;
-    }
-  }
   /**
    *
    * @param {Uint8Array} messageByteArray

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/protocol/CommandSerializer.cjs

@@ -30,21 +30,16 @@ var import_TypesHandler = require("../../utils/TypesHandler.cjs");
 class CommandSerializer {
   /**
    * Serializes the root command with connection data and optional runtime version.
-   * @param {Promise<Command> | Command} rootCommand
+   * @param {Command} rootCommand
    * @param {IConnectionData} connectionData
    * @param {number} runtimeVersion
-   * @returns {Promise<Uint8Array> | Uint8Array}
+   * @returns {Uint8Array}
    */
   serialize(rootCommand, connectionData, runtimeVersion = 0) {
     const buffers = [];
-    if (rootCommand instanceof Promise) {
-      return rootCommand.then((resolvedCommand) => {
-        return this.serialize(resolvedCommand, connectionData, runtimeVersion);
-      });
-    }
     buffers.push(Uint8Array.of(rootCommand.runtimeName, runtimeVersion));
     if (connectionData) {
-      buffers.push(connectionData.serializeConnectionData());
+      buffers.push(Uint8Array.from(connectionData.serializeConnectionData()));
     } else {
       buffers.push(Uint8Array.of(0, 0, 0, 0, 0, 0, 0));
     }

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/receiver/Receiver.cjs

@@ -39,11 +39,11 @@ class Receiver {
   }
   /**
    * @param {Uint8Array} messageByteArray
-   * @returns {Promise<Uint8Array> | Uint8Array}
+   * @returns {Promise<Uint8Array>}
    */
-  static sendCommand(messageByteArray) {
+  static async sendCommand(messageByteArray) {
     try {
-      let command = new import_Interpreter.Interpreter().process(messageByteArray);
+      let command = await new import_Interpreter.Interpreter().process(messageByteArray);
       return new import_CommandSerializer.CommandSerializer().serialize(command, this.connectionData);
     } catch (error) {
       const exceptionCommand = import_ExceptionSerializer.ExceptionSerializer.serializeException(
@@ -55,13 +55,13 @@ class Receiver {
   }
   /**
    * @param {Uint8Array} messageByteArray
-   * @returns {Promise<Uint8Array> | Uint8Array}
+   * @returns {Promise<Uint8Array>}
    */
-  static heartBeat(messageByteArray) {
+  static async heartBeat(messageByteArray) {
     let response = new Uint8Array(2);
     response[0] = messageByteArray[11];
     response[1] = messageByteArray[12] - 2;
-    return response;
+    return Promise.resolve(response);
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/sdk/Activator.cjs

@@ -0,0 +1,44 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Activator_exports = {};
+__export(Activator_exports, {
+  Activator: () => Activator
+});
+module.exports = __toCommonJS(Activator_exports);
+class Activator {
+  /**
+   * Create a new instance of a type
+   * @param {Function} Type - The constructor function/class
+   * @param {any[] | any} args - The arguments to pass to the constructor
+   * @returns {any} The new instance
+   */
+  static createInstance(Type, args) {
+    if (args == null) {
+      args = [];
+    }
+    if (!Array.isArray(args)) {
+      args = [args];
+    }
+    return new Type(...args);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Activator
+});