javonet-nodejs-sdk 2.6.9 → 2.6.11

package/dist/core/handler/CreateClassInstanceHandler.cjs

@@ -24,23 +24,9 @@ module.exports = __toCommonJS(CreateClassInstanceHandler_exports);
 var import_AbstractHandler = require("./AbstractHandler.cjs");
 class CreateClassInstanceHandler extends import_AbstractHandler.AbstractHandler {
   requiredParametersCount = 1;
-  // Add a simple invocation contexts store (Map GUID -> object)
-  static _invocationContexts = /* @__PURE__ */ new Map();
-  static getOrCreateContextDictionary() {
-    return CreateClassInstanceHandler._invocationContexts;
-  }
   constructor() {
     super();
   }
-  // Helper to detect GUID in payload (standard format)
-  /**
-   * @param {{ toString: () => any; } | null} value
-   */
-  static isGuid(value) {
-    if (value == null) return false;
-    const s = value.toString();
-    return /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(s);
-  }
   /**
    * @param {Command} command
    */
@@ -50,23 +36,7 @@ class CreateClassInstanceHandler extends import_AbstractHandler.AbstractHandler
         throw new Error("Create Class Instance parameters mismatch");
       }
       let clazz = command.payload[0];
-      let payloadLength = command.payload.length;
-      let contextGuid = null;
-      let constructorArguments = [];
-      if (payloadLength > 1 && CreateClassInstanceHandler.isGuid(command.payload[1])) {
-        contextGuid = command.payload[1].toString();
-        if (payloadLength > 2) {
-          constructorArguments = command.payload.slice(2);
-        } else {
-          constructorArguments = [];
-        }
-      } else {
-        if (payloadLength > 1) {
-          constructorArguments = command.payload.slice(1);
-        } else {
-          constructorArguments = [];
-        }
-      }
+      let constructorArguments = command.payload.slice(1);
       let instance = new clazz(...constructorArguments);
       if (typeof instance === "undefined") {
         let methods = Object.getOwnPropertyNames(clazz).filter(function(property) {
@@ -80,10 +50,6 @@ class CreateClassInstanceHandler extends import_AbstractHandler.AbstractHandler
         });
         throw new Error(message);
       } else {
-        if (contextGuid) {
-          const contextDict = CreateClassInstanceHandler.getOrCreateContextDictionary();
-          contextDict.set(contextGuid, instance);
-        }
         return instance;
       }
     } catch (error) {

package/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,65 +126,79 @@ 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 {
+  static _initialized = false;
   /**
-   * @param {import('../interpreter/Interpreter.js').Interpreter} interpreter
+   * Initializes the handlers map. This is called lazily on first use.
    */
-  constructor(interpreter) {
-    this.interpreter = interpreter;
-    if (!this.interpreter) {
-      throw new Error("interpreter is undefined in Handler constructor");
+  static _initialize() {
+    if (Handler._initialized) {
+      return;
     }
-    handlers[import_CommandType.CommandType.PassDelegate] = new import_PassDelegateHandler.PassDelegateHandler(this.interpreter);
+    handlers[import_CommandType.CommandType.PassDelegate] = new import_PassDelegateHandler.PassDelegateHandler();
     Object.keys(handlers).forEach((commandTypeHandler) => {
       handlers[commandTypeHandler].handlers = handlers;
     });
+    Handler._initialized = true;
   }
   /**
    * @param {Command} command
    * @returns {Promise<Command> | Command}
    */
-  handleCommand(command) {
+  static handleCommand(command) {
+    Handler._initialize();
     try {
       if (command.commandType === import_CommandType.CommandType.RetrieveArray) {
         const responseArray = handlers[import_CommandType.CommandType.Reference].handleCommand(command.payload[0]);
         return import_Command.Command.createArrayResponse(responseArray, command.runtimeName);
       }
       const response = handlers[command.commandType].handleCommand(command);
-      return this.parseCommand(response, command.runtimeName);
+      return Handler.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
    * @returns {Promise<Command> | Command}
    */
-  parseCommand(response, runtimeName) {
+  static parseCommand(response, runtimeName) {
     if (response instanceof Promise) {
       return response.then((resolvedResponse) => {
-        return this.parseCommand(resolvedResponse, runtimeName);
+        return Handler.parseCommand(resolvedResponse, runtimeName);
       });
     }
     let responseCommand;
     if (import_TypesHandler.TypesHandler.isPrimitiveOrNullOrUndefined(response)) {
       responseCommand = import_Command.Command.createResponse(response, runtimeName);
     } else {
-      let cache = import_ReferencesCache.ReferencesCache.getInstance();
-      let uuid = cache.cacheReference(response);
+      const refCache = import_ReferencesCache.ReferencesCache.getInstance();
+      const uuid = refCache.cacheReference(response);
       responseCommand = import_Command.Command.createReference(uuid, runtimeName);
     }
-    const invocationContexts = import_CreateClassInstanceHandler.CreateClassInstanceHandler._invocationContexts;
-    if (invocationContexts && typeof invocationContexts.size === "number" && invocationContexts.size > 0) {
+    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.UpdateInvocationContext,
+          import_CommandType.CommandType.ValueForUpdate,
           [
             contextKey.toString(),
             instanceGuid

package/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}

package/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}

package/dist/core/handler/PassDelegateHandler.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var PassDelegateHandler_exports = {};
 __export(PassDelegateHandler_exports, {
@@ -26,12 +36,9 @@ var import_InMemoryConnectionData = require("../../utils/connectionData/InMemory
 var import_DelegatesCache = require("../delegatesCache/DelegatesCache.cjs");
 var import_AbstractHandler = require("./AbstractHandler.cjs");
 class PassDelegateHandler extends import_AbstractHandler.AbstractHandler {
-  /** @type {Interpreter | null | undefined} */
-  interpreter = null;
-  constructor(interpreter = null) {
+  constructor() {
     super();
     this.requiredParametersCount = 1;
-    this.interpreter = interpreter;
   }
   /**S
    * Processes the given command to create and compile a delegate.
@@ -113,7 +120,8 @@ class PassDelegateHandler extends import_AbstractHandler.AbstractHandler {
    * @returns {Promise<any>} The response object.
    */
   async createExecuteCall(command) {
-    return this.interpreter?.execute(command, new import_InMemoryConnectionData.InMemoryConnectionData());
+    const { Interpreter } = await import("../interpreter/Interpreter.js");
+    return Interpreter.execute(command, new import_InMemoryConnectionData.InMemoryConnectionData());
   }
   /**
    * Retrieves the response payload from the execution call.

package/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
+});

package/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
+});

package/dist/core/interpreter/Interpreter.cjs

@@ -35,24 +35,15 @@ let _Transmitter;
 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} */
-  _handler = null;
-  /** @type {Handler} */
-  get handler() {
-    if (!this._handler) {
-      this._handler = new import_Handler.Handler(this);
-    }
-    return this._handler;
-  }
   /**
    *
    * @param {Command} command
    * @param {IConnectionData} connectionData
    * @returns {Promise<Command>}
    */
-  async execute(command, connectionData) {
+  static async execute(command, connectionData) {
     try {
-      let messageByteArray = new import_CommandSerializer.CommandSerializer().serialize(command, connectionData);
+      let messageByteArray = import_CommandSerializer.CommandSerializer.serialize(command, connectionData);
       if (!(messageByteArray instanceof Uint8Array)) {
         throw new Error("Serialized message is not Uint8Array");
       }
@@ -96,10 +87,10 @@ class Interpreter {
    * @param {Uint8Array} messageByteArray
    * @returns {Promise<Command> | Command}
    */
-  process(messageByteArray) {
+  static process(messageByteArray) {
     try {
       const receivedCommand = new import_CommandDeserializer.CommandDeserializer(messageByteArray).deserialize();
-      return this.handler?.handleCommand(receivedCommand);
+      return import_Handler.Handler.handleCommand(receivedCommand);
     } catch (error) {
       throw error;
     }

package/dist/core/protocol/CommandDeserializer.cjs

@@ -73,7 +73,7 @@ class CommandDeserializer {
       case "JAVONET_DOUBLE":
         return this.readDouble();
       case "JAVONET_UNSIGNED_LONG_LONG":
-        return this.readUllong;
+        return this.readUllong();
       case "JAVONET_UNSIGNED_INTEGER":
         return this.readUInt();
       case "JAVONET_NULL":

package/dist/core/protocol/CommandSerializer.cjs

@@ -35,7 +35,7 @@ class CommandSerializer {
    * @param {number} runtimeVersion
    * @returns {Uint8Array}
    */
-  serialize(rootCommand, connectionData, runtimeVersion = 0) {
+  static serialize(rootCommand, connectionData, runtimeVersion = 0) {
     const buffers = [];
     buffers.push(Uint8Array.of(rootCommand.runtimeName, runtimeVersion));
     if (connectionData) {
@@ -44,7 +44,7 @@ class CommandSerializer {
       buffers.push(Uint8Array.of(0, 0, 0, 0, 0, 0, 0));
     }
     buffers.push(Uint8Array.of(import_RuntimeName.RuntimeName.Python, rootCommand.commandType));
-    this.serializeRecursively(rootCommand, buffers);
+    CommandSerializer.serializeRecursively(rootCommand, buffers);
     return concatenateUint8Arrays(buffers);
   }
   /**
@@ -52,18 +52,18 @@ class CommandSerializer {
    * @param {Command} command
    * @param {Array<Uint8Array>} buffers
    */
-  serializeRecursively(command, buffers) {
+  static 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);
+        CommandSerializer.serializeRecursively(item, buffers);
       } 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);
+        CommandSerializer.serializeRecursively(refCommand, buffers);
       }
     }
   }

package/dist/core/receiver/Receiver.cjs

@@ -21,19 +21,16 @@ __export(Receiver_exports, {
   Receiver: () => Receiver
 });
 module.exports = __toCommonJS(Receiver_exports);
-var import_Interpreter = require("../interpreter/Interpreter.cjs");
 var import_CommandSerializer = require("../protocol/CommandSerializer.cjs");
-var import_Runtime = require("../../utils/Runtime.cjs");
 var import_InMemoryConnectionData = require("../../utils/connectionData/InMemoryConnectionData.cjs");
 var import_ExceptionSerializer = require("../../utils/exception/ExceptionSerializer.cjs");
 var import_Command = require("../../utils/Command.cjs");
 var import_CommandType = require("../../utils/CommandType.cjs");
 var import_RuntimeName = require("../../utils/RuntimeName.cjs");
 var import_RuntimeLogger = require("../../utils/RuntimeLogger.cjs");
+var import_Interpreter = require("./../interpreter/Interpreter.cjs");
 class Receiver {
   static connectionData = new import_InMemoryConnectionData.InMemoryConnectionData();
-  Receiver() {
-  }
   static getRuntimeInfo() {
     return import_RuntimeLogger.RuntimeLogger.getRuntimeInfo();
   }
@@ -43,14 +40,14 @@ class Receiver {
    */
   static async sendCommand(messageByteArray) {
     try {
-      let command = await new import_Interpreter.Interpreter().process(messageByteArray);
-      return new import_CommandSerializer.CommandSerializer().serialize(command, this.connectionData);
+      let command = await import_Interpreter.Interpreter.process(messageByteArray);
+      return import_CommandSerializer.CommandSerializer.serialize(command, this.connectionData);
     } catch (error) {
       const exceptionCommand = import_ExceptionSerializer.ExceptionSerializer.serializeException(
         error,
         new import_Command.Command(import_RuntimeName.RuntimeName.Nodejs, import_CommandType.CommandType.Exception, [])
       );
-      return new import_CommandSerializer.CommandSerializer().serialize(exceptionCommand, this.connectionData);
+      return import_CommandSerializer.CommandSerializer.serialize(exceptionCommand, this.connectionData);
     }
   }
   /**