javonet-ruby-sdk 2.6.7 → 2.6.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 466353207c739c6ba5c4d38e2a53bb28042cffdd78575f29b26e0ad8a81da1b4
-  data.tar.gz: 79b9909c9c744c49079fee11f843675ff775e23f0dd13ca986b74aee7e516986
+  metadata.gz: bd483c1827f1c74cb5fc63d48819267cf05fa9dad0be8776a602be8da4461048
+  data.tar.gz: 2fe10b5e45c087b9642d47d9ec7dd8cb422113a2a7c9b2a6f5ee5fa608849d4d
 SHA512:
-  metadata.gz: c77ba581bee1edcd67a550280b4e949314bf4443ea02c59665ef354ddbebf79945031467c398678449d7285b0565daa9349048b7b09d861592e78f46d82671dd
-  data.tar.gz: 224d457dd4dfaf531ce71c061dd3ac6923ed20f45ac16a759d87af0fd5711bb241f6ec89b79aca6d4489bfe376f9b28b2052da41d30938bd7c251f2587ceb415
+  metadata.gz: 2adb3e843603f22ddb1656865fe6a9038856c40fe128a9db8590f4368afba23d4552b9bed5dcc8b5508f3567f683367c454a195327ba446bfa346ec9b0d43cae
+  data.tar.gz: 1f2166306bc0ba00930878fffe6434dcbe6819995268e12599911f48d5e54b20a9b499d82d84c635f6762c14915c8c6298d1ab209e6b6557006bbfebf01dea3c

data/VERSION

@@ -1 +1 @@
-2.6.7
+2.6.10

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

@@ -1 +1 @@
-2.6.7
+2.6.10

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

@@ -1 +1 @@
-2.6.7
+2.6.10

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

@@ -1 +1 @@
-2.6.7
+2.6.10

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

@@ -1 +1 @@
-2.6.7
+2.6.10

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

@@ -1 +1 @@
-'2.6.7' 
+'2.6.10' 

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

@@ -1 +1 @@
-'2.6.7' 
+'2.6.10' 

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

@@ -22,6 +22,11 @@ __export(Handler_exports, {
   handlers: () => handlers
 });
 module.exports = __toCommonJS(Handler_exports);
+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_AbstractHandler = require("./AbstractHandler.cjs");
 var import_ReferencesCache = require("../referenceCache/ReferencesCache.cjs");
 var import_ValueHandler = require("./ValueHandler.cjs");
 var import_LoadLibraryHandler = require("./LoadLibraryHandler.cjs");
@@ -71,11 +76,8 @@ var import_GetAsyncOperationResultHandler = require("./GetAsyncOperationResultHa
 var import_AsKwargsHandler = require("./AsKwargsHandler.cjs");
 var import_GetResultTypeHandler = require("./GetResultTypeHandler.cjs");
 var import_GetGlobalFieldHandler = require("./GetGlobalFieldHandler.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_AbstractHandler = require("./AbstractHandler.cjs");
+var import_RegisterForUpdateHandler = require("./RegisterForUpdateHandler.cjs");
+var import_ValueForUpdateHandler = require("./ValueForUpdateHandler.cjs");
 const handlers = {
   [import_CommandType.CommandType.Value]: new import_ValueHandler.ValueHandler(),
   [import_CommandType.CommandType.LoadLibrary]: new import_LoadLibraryHandler.LoadLibraryHandler(),
@@ -124,7 +126,9 @@ const handlers = {
   [import_CommandType.CommandType.GetAsyncOperationResult]: new import_GetAsyncOperationResultHandler.GetAsyncOperationResultHandler(),
   [import_CommandType.CommandType.AsKwargs]: new import_AsKwargsHandler.AsKwargsHandler(),
   [import_CommandType.CommandType.GetResultType]: new import_GetResultTypeHandler.GetResultTypeHandler(),
-  [import_CommandType.CommandType.GetGlobalField]: new import_GetGlobalFieldHandler.GetGlobalFieldHandler()
+  [import_CommandType.CommandType.GetGlobalField]: new import_GetGlobalFieldHandler.GetGlobalFieldHandler(),
+  [import_CommandType.CommandType.RegisterForUpdate]: new import_RegisterForUpdateHandler.RegisterForUpdateHandler(),
+  [import_CommandType.CommandType.ValueForUpdate]: new import_ValueForUpdateHandler.ValueForUpdateHandler()
 };
 class Handler {
   /**
@@ -142,25 +146,30 @@ 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);
     } catch (e) {
-      return import_ExceptionSerializer.ExceptionSerializer.serializeException(e, command);
+      return Handler.resolveException(e, command);
     }
   }
+  /**
+   * Prefer innerException (or cause) when available.
+   * @param {any} error
+   * @param {Command} command
+   * @returns {Command}
+   */
+  static resolveException(error, command) {
+    const inner = error?.cause;
+    return import_ExceptionSerializer.ExceptionSerializer.serializeException(inner ?? error, command);
+  }
   /**
    * @param {any} response
    * @param {RuntimeName} runtimeName
@@ -172,13 +181,37 @@ class Handler {
         return this.parseCommand(resolvedResponse, runtimeName);
       });
     }
+    let responseCommand;
     if (import_TypesHandler.TypesHandler.isPrimitiveOrNullOrUndefined(response)) {
-      return import_Command.Command.createResponse(response, runtimeName);
+      responseCommand = import_Command.Command.createResponse(response, runtimeName);
     } else {
-      let cache = import_ReferencesCache.ReferencesCache.getInstance();
-      let uuid = cache.cacheReference(response);
-      return import_Command.Command.createReference(uuid, runtimeName);
+      const refCache = import_ReferencesCache.ReferencesCache.getInstance();
+      const uuid = refCache.cacheReference(response);
+      responseCommand = import_Command.Command.createReference(uuid, runtimeName);
+    }
+    const invocationContexts = import_RegisterForUpdateHandler.RegisterForUpdateHandler._invocationContexts.Value;
+    if (invocationContexts && invocationContexts.size > 0) {
+      const refCache = import_ReferencesCache.ReferencesCache.getInstance();
+      for (const [contextKey, instance] of invocationContexts.entries()) {
+        const instanceGuid = refCache.cacheReference(instance);
+        const updateContextCommand = new import_Command.Command(
+          runtimeName,
+          import_CommandType.CommandType.ValueForUpdate,
+          [
+            contextKey.toString(),
+            instanceGuid
+          ]
+        );
+        if (typeof responseCommand.addArgToPayload === "function") {
+          responseCommand = responseCommand.addArgToPayload(updateContextCommand);
+        } else {
+          responseCommand.payload = responseCommand.payload || [];
+          responseCommand.payload.push(updateContextCommand);
+        }
+      }
+      invocationContexts.clear();
     }
+    return responseCommand;
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -44,7 +44,7 @@ class InvokeInstanceMethodHandler extends import_AbstractHandler.AbstractHandler
         let methods = Object.getOwnPropertyNames(instance.__proto__).filter(function(property) {
           return typeof instance.__proto__[property] === "function";
         });
-        let message = `Method ${methodName} not found in object. Available methods:
+        let message = `Method ${methodName} not found in object ${instance.constructor.name}. Available methods:
 `;
         methods.forEach((methodIter) => {
           message += `${methodIter}

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

@@ -44,7 +44,7 @@ class InvokeStaticMethodHandler extends import_AbstractHandler.AbstractHandler {
         let methods = Object.getOwnPropertyNames(type).filter(function(property) {
           return typeof type[property] === "function";
         });
-        let message = `Method ${methodName} not found in class. Available methods:
+        let message = `Method ${methodName} not found in class ${type.name}. Available methods:
 `;
         methods.forEach((methodIter) => {
           message += `${methodIter}

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

@@ -41,8 +41,8 @@ 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");
     }
@@ -54,19 +54,25 @@ class LoadLibraryHandler extends import_AbstractHandler.AbstractHandler {
       const { resolve } = requireDynamic("path");
       _resolve = resolve;
     }
-    const absolutePath = _resolve?.(lib);
-    if (!_existsSync?.(lib ?? "") && !_existsSync?.(absolutePath ?? "")) {
+    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 = requireDynamic(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/handler/RegisterForUpdateHandler.cjs

@@ -0,0 +1,60 @@
+"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 RegisterForUpdateHandler_exports = {};
+__export(RegisterForUpdateHandler_exports, {
+  RegisterForUpdateHandler: () => RegisterForUpdateHandler
+});
+module.exports = __toCommonJS(RegisterForUpdateHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class RegisterForUpdateHandler extends import_AbstractHandler.AbstractHandler {
+  requiredParametersCount = 2;
+  /* type {Map<string, any>} */
+  static _invocationContexts = { Value: /* @__PURE__ */ new Map() };
+  /**
+   * Ensure context map exists and return it.
+   * @returns {Map<string, any>}
+   */
+  static getOrCreateContextMap() {
+    const container = RegisterForUpdateHandler._invocationContexts;
+    if (!container.Value) {
+      container.Value = /* @__PURE__ */ new Map();
+    }
+    return container.Value;
+  }
+  /**
+   * @param {any} command
+   * @returns {any}
+   */
+  process(command) {
+    if (command.payload.length < this.requiredParametersCount) {
+      throw new Error("RegisterForUpdateHandler parameters mismatch");
+    }
+    const objectToRegister = command.payload[0];
+    const guidToRegister = command.payload.length > 1 && typeof command.payload[1] === "string" ? command.payload[1] : "";
+    const contextMap = RegisterForUpdateHandler.getOrCreateContextMap();
+    if (!contextMap.has(guidToRegister)) {
+      contextMap.set(guidToRegister, objectToRegister);
+    }
+    return objectToRegister;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RegisterForUpdateHandler
+});

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

@@ -0,0 +1,36 @@
+"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 ValueForUpdateHandler_exports = {};
+__export(ValueForUpdateHandler_exports, {
+  ValueForUpdateHandler: () => ValueForUpdateHandler
+});
+module.exports = __toCommonJS(ValueForUpdateHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class ValueForUpdateHandler extends import_AbstractHandler.AbstractHandler {
+  /**
+   * @param {any} command
+   */
+  process(command) {
+    throw new Error(`${this.constructor.name} is not implemented in Node.js`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ValueForUpdateHandler
+});

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

@@ -48,17 +48,19 @@ class Interpreter {
    *
    * @param {Command} command
    * @param {IConnectionData} connectionData
-   * @returns {Command | Promise<Command>}
+   * @returns {Promise<Command>}
    */
-  execute(command, connectionData) {
+  async execute(command, connectionData) {
     try {
       let messageByteArray = new import_CommandSerializer.CommandSerializer().serialize(command, connectionData);
-      if (!(messageByteArray instanceof Uint8Array) && !(messageByteArray instanceof Promise)) {
-        throw new Error("Serialized message is neither Uint8Array nor Promise<Uint8Array>");
+      if (!(messageByteArray instanceof Uint8Array)) {
+        throw new Error("Serialized message is not Uint8Array");
       }
       let responseByteArray = void 0;
       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");
+        throw new Error(
+          "Nodejs Core Error: inMemory is only allowed in Nodejs runtime, not in browser"
+        );
       }
       if (command.runtimeName === import_RuntimeName.RuntimeName.Nodejs && connectionData.connectionType === import_ConnectionType.ConnectionType.IN_MEMORY) {
         if (!_Receiver) {
@@ -68,13 +70,7 @@ class Interpreter {
         if (!_Receiver) {
           throw new Error("Nodejs Core Error: Receiver is undefined");
         }
-        if (messageByteArray instanceof Promise) {
-          responseByteArray = messageByteArray.then((resolvedMessage) => {
-            return _Receiver.sendCommand(resolvedMessage);
-          });
-        } else if (messageByteArray instanceof Uint8Array) {
-          responseByteArray = _Receiver.sendCommand(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");
@@ -83,32 +79,14 @@ class Interpreter {
         if (!_Transmitter) {
           throw new Error("Nodejs Core Error: Transmitter is undefined");
         }
-        if (messageByteArray instanceof Uint8Array) {
-          responseByteArray = _Transmitter.sendCommand(messageByteArray);
-        } else {
-          responseByteArray = messageByteArray.then((resolvedMessage) => {
-            return _Transmitter.sendCommand(resolvedMessage);
-          });
-        }
+        responseByteArray = await _Transmitter.sendCommand(messageByteArray);
       } else if (connectionData.connectionType === import_ConnectionType.ConnectionType.WEB_SOCKET) {
-        if (messageByteArray instanceof Uint8Array) {
-          responseByteArray = _TransmitterWebsocket.sendCommand(messageByteArray, connectionData);
-        } else {
-          responseByteArray = messageByteArray.then((resolvedMessage) => {
-            return _TransmitterWebsocket.sendCommand(resolvedMessage, connectionData);
-          });
-        }
+        responseByteArray = await _TransmitterWebsocket.sendCommand(messageByteArray, connectionData);
       }
       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();
-      }
+      return new import_CommandDeserializer.CommandDeserializer(responseByteArray).deserialize();
     } catch (error) {
       throw error;
     }

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));
     }