javonet-nodejs-sdk 2.6.1 → 2.6.3

package/dist/core/handler/Handler.cjs

@@ -25,62 +25,106 @@ module.exports = __toCommonJS(Handler_exports);
 var import_ReferencesCache = require("../referenceCache/ReferencesCache.cjs");
 var import_ValueHandler = require("./ValueHandler.cjs");
 var import_LoadLibraryHandler = require("./LoadLibraryHandler.cjs");
-var import_GetTypeHandler = require("./GetTypeHandler.cjs");
 var import_InvokeStaticMethodHandler = require("./InvokeStaticMethodHandler.cjs");
 var import_GetStaticFieldHandler = require("./GetStaticFieldHandler.cjs");
 var import_SetStaticFieldHandler = require("./SetStaticFieldHandler.cjs");
-var import_ResolveReferenceHandler = require("./ResolveReferenceHandler.cjs");
 var import_CreateClassInstanceHandler = require("./CreateClassInstanceHandler.cjs");
-var import_GetInstanceFieldHandler = require("./GetInstanceFieldHandler.cjs");
-var import_SetInstanceFieldHandler = require("./SetInstanceFieldHandler.cjs");
+var import_GetTypeHandler = require("./GetTypeHandler.cjs");
+var import_ResolveReferenceHandler = require("./ResolveReferenceHandler.cjs");
+var import_GetModuleHandler = require("./GetModuleHandler.cjs");
 var import_InvokeInstanceMethodHandler = require("./InvokeInstanceMethodHandler.cjs");
-var import_DestructReferenceHandler = require("./DestructReferenceHandler.cjs");
+var import_ExceptionHandler = require("./ExceptionHandler.cjs");
+var import_HeartBeatHandler = require("./HeartBeatHandler.cjs");
 var import_CastingHandler = require("./CastingHandler.cjs");
+var import_GetInstanceFieldHandler = require("./GetInstanceFieldHandler.cjs");
+var import_OptimizeHandler = require("./OptimizeHandler.cjs");
+var import_GenerateLibHandler = require("./GenerateLibHandler.cjs");
+var import_InvokeGlobalFunctionHandler = require("./InvokeGlobalFunctionHandler.cjs");
+var import_DestructReferenceHandler = require("./DestructReferenceHandler.cjs");
+var import_ArrayReferenceHandler = require("./ArrayReferenceHandler.cjs");
 var import_ArrayGetItemHandler = require("./ArrayGetItemHandler.cjs");
 var import_ArrayGetSizeHandler = require("./ArrayGetSizeHandler.cjs");
 var import_ArrayGetRankHandler = require("./ArrayGetRankHandler.cjs");
 var import_ArraySetItemHandler = require("./ArraySetItemHandler.cjs");
 var import_ArrayHandler = require("./ArrayHandler.cjs");
+var import_RetrieveArrayHandler = require("./RetrieveArrayHandler.cjs");
+var import_SetInstanceFieldHandler = require("./SetInstanceFieldHandler.cjs");
+var import_InvokeGenericStaticMethodHandler = require("./InvokeGenericStaticMethodHandler.cjs");
+var import_InvokeGenericMethodHandler = require("./InvokeGenericMethodHandler.cjs");
+var import_GetEnumItemHandler = require("./GetEnumItemHandler.cjs");
+var import_GetEnumNameHandler = require("./GetEnumNameHandler.cjs");
+var import_GetEnumValueHandler = require("./GetEnumValueHandler.cjs");
+var import_AsRefHandler = require("./AsRefHandler.cjs");
+var import_AsOutHandler = require("./AsOutHandler.cjs");
+var import_GetRefValueHandler = require("./GetRefValueHandler.cjs");
 var import_EnableNamespaceHandler = require("./EnableNamespaceHandler.cjs");
 var import_EnableTypeHandler = require("./EnableTypeHandler.cjs");
+var import_CreateNullHandler = require("./CreateNullHandler.cjs");
 var import_GetStaticMethodAsDelegateHandler = require("./GetStaticMethodAsDelegateHandler.cjs");
 var import_GetInstanceMethodAsDelegateHandler = require("./GetInstanceMethodAsDelegateHandler.cjs");
 var import_PassDelegateHandler = require("./PassDelegateHandler.cjs");
 var import_InvokeDelegateHandler = require("./InvokeDelegateHandler.cjs");
-var import_InvokeGlobalFunctionHandler = require("./InvokeGlobalFunctionHandler.cjs");
+var import_ConvertTypeHandler = require("./ConvertTypeHandler.cjs");
+var import_AddEventListenerHandler = require("./AddEventListenerHandler.cjs");
+var import_PluginWrapperHandler = require("./PluginWrapperHandler.cjs");
+var import_GetAsyncOperationResultHandler = require("./GetAsyncOperationResultHandler.cjs");
+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_ConvertTypeHandler = require("./ConvertTypeHandler.cjs");
 var import_AbstractHandler = require("./AbstractHandler.cjs");
 const handlers = {
   [import_CommandType.CommandType.Value]: new import_ValueHandler.ValueHandler(),
   [import_CommandType.CommandType.LoadLibrary]: new import_LoadLibraryHandler.LoadLibraryHandler(),
   [import_CommandType.CommandType.InvokeStaticMethod]: new import_InvokeStaticMethodHandler.InvokeStaticMethodHandler(),
-  [import_CommandType.CommandType.GetType]: new import_GetTypeHandler.GetTypeHandler(),
   [import_CommandType.CommandType.GetStaticField]: new import_GetStaticFieldHandler.GetStaticFieldHandler(),
   [import_CommandType.CommandType.SetStaticField]: new import_SetStaticFieldHandler.SetStaticFieldHandler(),
   [import_CommandType.CommandType.CreateClassInstance]: new import_CreateClassInstanceHandler.CreateClassInstanceHandler(),
+  [import_CommandType.CommandType.GetType]: new import_GetTypeHandler.GetTypeHandler(),
   [import_CommandType.CommandType.Reference]: new import_ResolveReferenceHandler.ResolveReferenceHandler(),
+  [import_CommandType.CommandType.GetModule]: new import_GetModuleHandler.GetModuleHandler(),
+  [import_CommandType.CommandType.InvokeInstanceMethod]: new import_InvokeInstanceMethodHandler.InvokeInstanceMethodHandler(),
+  [import_CommandType.CommandType.Exception]: new import_ExceptionHandler.ExceptionHandler(),
+  [import_CommandType.CommandType.HeartBeat]: new import_HeartBeatHandler.HeartBeatHandler(),
   [import_CommandType.CommandType.Cast]: new import_CastingHandler.CastingHandler(),
   [import_CommandType.CommandType.GetInstanceField]: new import_GetInstanceFieldHandler.GetInstanceFieldHandler(),
-  [import_CommandType.CommandType.SetInstanceField]: new import_SetInstanceFieldHandler.SetInstanceFieldHandler(),
-  [import_CommandType.CommandType.InvokeInstanceMethod]: new import_InvokeInstanceMethodHandler.InvokeInstanceMethodHandler(),
+  [import_CommandType.CommandType.Optimize]: new import_OptimizeHandler.OptimizeHandler(),
+  [import_CommandType.CommandType.GenerateLib]: new import_GenerateLibHandler.GenerateLibHandler(),
+  [import_CommandType.CommandType.InvokeGlobalFunction]: new import_InvokeGlobalFunctionHandler.InvokeGlobalFunctionHandler(),
   [import_CommandType.CommandType.DestructReference]: new import_DestructReferenceHandler.DestructReferenceHandler(),
+  [import_CommandType.CommandType.ArrayReference]: new import_ArrayReferenceHandler.ArrayReferenceHandler(),
   [import_CommandType.CommandType.ArrayGetItem]: new import_ArrayGetItemHandler.ArrayGetItemHandler(),
   [import_CommandType.CommandType.ArrayGetSize]: new import_ArrayGetSizeHandler.ArrayGetSizeHandler(),
   [import_CommandType.CommandType.ArrayGetRank]: new import_ArrayGetRankHandler.ArrayGetRankHandler(),
   [import_CommandType.CommandType.ArraySetItem]: new import_ArraySetItemHandler.ArraySetItemHandler(),
   [import_CommandType.CommandType.Array]: new import_ArrayHandler.ArrayHandler(),
+  [import_CommandType.CommandType.RetrieveArray]: new import_RetrieveArrayHandler.RetrieveArrayHandler(),
+  [import_CommandType.CommandType.SetInstanceField]: new import_SetInstanceFieldHandler.SetInstanceFieldHandler(),
+  [import_CommandType.CommandType.InvokeGenericStaticMethod]: new import_InvokeGenericStaticMethodHandler.InvokeGenericStaticMethodHandler(),
+  [import_CommandType.CommandType.InvokeGenericMethod]: new import_InvokeGenericMethodHandler.InvokeGenericMethodHandler(),
+  [import_CommandType.CommandType.GetEnumItem]: new import_GetEnumItemHandler.GetEnumItemHandler(),
+  [import_CommandType.CommandType.GetEnumName]: new import_GetEnumNameHandler.GetEnumNameHandler(),
+  [import_CommandType.CommandType.GetEnumValue]: new import_GetEnumValueHandler.GetEnumValueHandler(),
+  [import_CommandType.CommandType.AsRef]: new import_AsRefHandler.AsRefHandler(),
+  [import_CommandType.CommandType.AsOut]: new import_AsOutHandler.AsOutHandler(),
+  [import_CommandType.CommandType.GetRefValue]: new import_GetRefValueHandler.GetRefValueHandler(),
   [import_CommandType.CommandType.EnableNamespace]: new import_EnableNamespaceHandler.EnableNamespaceHandler(),
   [import_CommandType.CommandType.EnableType]: new import_EnableTypeHandler.EnableTypeHandler(),
+  [import_CommandType.CommandType.CreateNull]: new import_CreateNullHandler.CreateNullHandler(),
   [import_CommandType.CommandType.GetStaticMethodAsDelegate]: new import_GetStaticMethodAsDelegateHandler.GetStaticMethodAsDelegateHandler(),
   [import_CommandType.CommandType.GetInstanceMethodAsDelegate]: new import_GetInstanceMethodAsDelegateHandler.GetInstanceMethodAsDelegateHandler(),
   [import_CommandType.CommandType.PassDelegate]: new import_PassDelegateHandler.PassDelegateHandler(),
   [import_CommandType.CommandType.InvokeDelegate]: new import_InvokeDelegateHandler.InvokeDelegateHandler(),
   [import_CommandType.CommandType.ConvertType]: new import_ConvertTypeHandler.ConvertTypeHandler(),
-  [import_CommandType.CommandType.InvokeGlobalFunction]: new import_InvokeGlobalFunctionHandler.InvokeGlobalFunctionHandler()
+  [import_CommandType.CommandType.AddEventListener]: new import_AddEventListenerHandler.AddEventListenerHandler(),
+  [import_CommandType.CommandType.PluginWrapper]: new import_PluginWrapperHandler.PluginWrapperHandler(),
+  [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()
 };
 class Handler {
   /**

package/dist/core/handler/HeartBeatHandler.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 HeartBeatHandler_exports = {};
+__export(HeartBeatHandler_exports, {
+  HeartBeatHandler: () => HeartBeatHandler
+});
+module.exports = __toCommonJS(HeartBeatHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class HeartBeatHandler extends import_AbstractHandler.AbstractHandler {
+  /**
+   * @param {any} command
+   */
+  handleCommand(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 = {
+  HeartBeatHandler
+});

package/dist/core/handler/InvokeGenericMethodHandler.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 InvokeGenericMethodHandler_exports = {};
+__export(InvokeGenericMethodHandler_exports, {
+  InvokeGenericMethodHandler: () => InvokeGenericMethodHandler
+});
+module.exports = __toCommonJS(InvokeGenericMethodHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class InvokeGenericMethodHandler extends import_AbstractHandler.AbstractHandler {
+  /**
+   * @param {any} command
+   */
+  handleCommand(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 = {
+  InvokeGenericMethodHandler
+});

package/dist/core/handler/InvokeGenericStaticMethodHandler.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 InvokeGenericStaticMethodHandler_exports = {};
+__export(InvokeGenericStaticMethodHandler_exports, {
+  InvokeGenericStaticMethodHandler: () => InvokeGenericStaticMethodHandler
+});
+module.exports = __toCommonJS(InvokeGenericStaticMethodHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class InvokeGenericStaticMethodHandler extends import_AbstractHandler.AbstractHandler {
+  /**
+   * @param {any} command
+   */
+  handleCommand(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 = {
+  InvokeGenericStaticMethodHandler
+});

package/dist/core/handler/OptimizeHandler.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 OptimizeHandler_exports = {};
+__export(OptimizeHandler_exports, {
+  OptimizeHandler: () => OptimizeHandler
+});
+module.exports = __toCommonJS(OptimizeHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class OptimizeHandler extends import_AbstractHandler.AbstractHandler {
+  /**
+   * @param {any} command
+   */
+  handleCommand(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 = {
+  OptimizeHandler
+});

package/dist/core/handler/PluginWrapperHandler.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 PluginWrapperHandler_exports = {};
+__export(PluginWrapperHandler_exports, {
+  PluginWrapperHandler: () => PluginWrapperHandler
+});
+module.exports = __toCommonJS(PluginWrapperHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class PluginWrapperHandler extends import_AbstractHandler.AbstractHandler {
+  /**
+   * @param {any} command
+   */
+  handleCommand(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 = {
+  PluginWrapperHandler
+});

package/dist/core/handler/RetrieveArrayHandler.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 RetrieveArrayHandler_exports = {};
+__export(RetrieveArrayHandler_exports, {
+  RetrieveArrayHandler: () => RetrieveArrayHandler
+});
+module.exports = __toCommonJS(RetrieveArrayHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class RetrieveArrayHandler extends import_AbstractHandler.AbstractHandler {
+  /**
+   * @param {any} command
+   */
+  handleCommand(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 = {
+  RetrieveArrayHandler
+});

package/dist/sdk/ActivatorDetails.cjs

@@ -0,0 +1,37 @@
+"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 ActivatorDetails_exports = {};
+__export(ActivatorDetails_exports, {
+  ActivatorDetails: () => ActivatorDetails
+});
+module.exports = __toCommonJS(ActivatorDetails_exports);
+class ActivatorDetails {
+  /**
+   * @param {Function} type - The constructor function/class
+   * @param {any[]} [args] - Arguments to pass to constructor
+   */
+  constructor(type, args = []) {
+    this.type = type;
+    this.arguments = args;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ActivatorDetails
+});

package/dist/sdk/InvocationContext.cjs

@@ -373,6 +373,30 @@ class InvocationContext {
     ]);
     return this.#createInstanceContext(localCommand);
   }
+  /**
+   * Retrieves the type of the object from the target runtime.
+   * @returns {string} The type of the object.
+   * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/type-handling/getting-object-type)
+   * @method
+   */
+  getResultType() {
+    const localCommand = new import_Command.Command(this.#runtimeName, import_CommandType.CommandType.GetResultType, []);
+    const invocationContext = new InvocationContext(this.#runtimeName, this.#connectionData, this.#buildCommand(localCommand));
+    const result = invocationContext.execute().getValue();
+    return (
+      /** @type {string} */
+      result
+    );
+  }
+  /**
+   * Retrieves the name of the runtime where the command is executed.
+   * @returns {number} The name of the runtime.
+   * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/runtime-name)
+   * @method
+   */
+  getRuntimeName() {
+    return this.#runtimeName;
+  }
   /**
    * Retrieves an array from the target runtime.
    * @returns {InvocationContext} A new InvocationContext instance that wraps the command to retrieve the array.
@@ -517,6 +541,65 @@ class InvocationWsContext extends InvocationContext {
     }
     return new InvocationWsContext(this.#runtimeName, this.#connectionData, this.#responseCommand, true);
   }
+  /**
+   * Retrieves the type of the object from the target runtime.
+   * @returns {Promise<string>} The type of the object.
+   * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/type-handling/getting-object-type)
+   * @async
+   * @method
+   */
+  // @ts-expect-error
+  async getResultType() {
+    const localCommand = new import_Command.Command(this.#runtimeName, import_CommandType.CommandType.GetResultType, []);
+    const invocationContext = new InvocationWsContext(this.#runtimeName, this.#connectionData, this.#buildCommand(localCommand));
+    const result = await invocationContext.execute();
+    return (
+      /** @type {string} */
+      result.getValue()
+    );
+  }
+  /**
+   * @param {Command} command
+   * @returns {Command}
+   */
+  #buildCommand(command) {
+    for (let i = 0; i < command.payload.length; i++) {
+      command.payload[i] = this.#encapsulatePayloadItem(command.payload[i]);
+    }
+    return command.prependArgToPayload(this.#currentCommand);
+  }
+  /**
+   * @param {unknown} payloadItem
+   * @returns {Command|null}
+   */
+  #encapsulatePayloadItem(payloadItem) {
+    if (payloadItem instanceof import_Command.Command) {
+      for (let i = 0; i < payloadItem.payload.length; i++) {
+        payloadItem.payload[i] = this.#encapsulatePayloadItem(payloadItem.payload[i]);
+      }
+      return payloadItem;
+    } else if (payloadItem instanceof InvocationContext || payloadItem instanceof InvocationWsContext) {
+      return payloadItem.get_current_command();
+    } else if (payloadItem instanceof Array) {
+      const copiedArray = payloadItem.map((item) => this.#encapsulatePayloadItem(item));
+      return new import_Command.Command(this.#runtimeName, import_CommandType.CommandType.Array, copiedArray);
+    } else if (typeof payloadItem === "function") {
+      let newArray = new Array(payloadItem.length + 1);
+      for (let i = 0; i < newArray.length; i++) {
+        newArray[i] = typeof Object;
+      }
+      const args = [import_DelegatesCache.delegatesCacheInstance.addDelegate(payloadItem), import_RuntimeName.RuntimeName.Nodejs].push(
+        ...newArray
+      );
+      return new import_Command.Command(this.#runtimeName, import_CommandType.CommandType.PassDelegate, args);
+    } else if (import_TypesHandler.TypesHandler.isPrimitiveOrNullOrUndefined(payloadItem)) {
+      return new import_Command.Command(this.#runtimeName, import_CommandType.CommandType.Value, [payloadItem]);
+    } else {
+      throw Error(
+        "Unsupported payload item type: " + (payloadItem?.constructor?.name || typeof payloadItem) + " for payload item: " + payloadItem
+      );
+    }
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/sdk/Javonet.cjs

@@ -34,7 +34,6 @@ var import_CommandDeserializer = require("../core/protocol/CommandDeserializer.c
 var import_RuntimeLogger = require("../utils/RuntimeLogger.cjs");
 var import_TcpConnectionData = require("../utils/nodejs/connectionData/TcpConnectionData.cjs");
 var import_WsConnectionData = require("../utils/connectionData/WsConnectionData.cjs");
-var import_ActivationHelper = require("./tools/ActivationHelper.cjs");
 var import_UtilsConst = require("../utils/UtilsConst.cjs");
 const import_meta = {};
 const requireDynamic = (0, import_Runtime.getRequire)(import_meta.url);

package/dist/sdk/RuntimeContext.cjs

@@ -264,6 +264,25 @@ class RuntimeContext {
     }
     return new import_InvocationContext.InvocationContext(this.runtimeName, this.connectionData, this.#buildCommand(localCommand));
   }
+  /**
+   * Retrieves the value of an global field from the target runtime.
+   * @param {string} fieldName - The name of the field to get.
+   * @returns {InvocationContext} A new InvocationContext instance that wraps the command to get the global field.
+   * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/fields-and-properties/getting-values-for-global-fields)
+   * @method
+   */
+  getGlobalField(fieldName) {
+    let localCommand = new import_Command.Command(this.runtimeName, import_CommandType.CommandType.GetGlobalField, [fieldName]);
+    this.#currentCommand = null;
+    if (this.connectionData.connectionType === import_ConnectionType.ConnectionType.WEB_SOCKET) {
+      return new import_InvocationContext.InvocationWsContext(
+        this.runtimeName,
+        this.connectionData,
+        this.#buildCommand(localCommand)
+      );
+    }
+    return new import_InvocationContext.InvocationContext(this.runtimeName, this.connectionData, this.#buildCommand(localCommand));
+  }
   /**
    * Invokes a function from the called runtime. This method is used when working with functions from the called runtime.
    * The arguments include the function name and the arguments to be passed to the function.

package/dist/sdk/tools/ComplexTypeResolver.cjs

@@ -0,0 +1,114 @@
+"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 ComplexTypeResolver_exports = {};
+__export(ComplexTypeResolver_exports, {
+  ComplexTypeResolver: () => ComplexTypeResolver
+});
+module.exports = __toCommonJS(ComplexTypeResolver_exports);
+var import_Runtime = require("../../utils/Runtime.cjs");
+var import_RuntimeName = require("../../utils/RuntimeName.cjs");
+var import_ActivatorDetails = require("../ActivatorDetails.cjs");
+var import_InvocationContext = require("../InvocationContext.cjs");
+var import_JavaTypeParsingFunctions = require("./typeParsingFunctions/JavaTypeParsingFunctions.cjs");
+var import_NetcoreTypeParsingFunctions = require("./typeParsingFunctions/NetcoreTypeParsingFunctions.cjs");
+var import_NodejsTypeParsingFunctions = require("./typeParsingFunctions/NodejsTypeParsingFunctions.cjs");
+var import_PythonTypeParsingFunctions = require("./typeParsingFunctions/PythonTypeParsingFunctions.cjs");
+const import_meta = {};
+const dynamicImport = (0, import_Runtime.getRequire)(import_meta.url);
+class ComplexTypeResolver {
+  /** @type {Map<string, ActivatorDetails>} */
+  #typeMap = /* @__PURE__ */ new Map();
+  /** @type {Map<number, Map<string, Function>>} */
+  #typeParsingFunctions = /* @__PURE__ */ new Map([
+    [import_RuntimeName.RuntimeName.Netcore, import_NetcoreTypeParsingFunctions.NetcoreTypeParsingFunctions],
+    [import_RuntimeName.RuntimeName.Jvm, import_JavaTypeParsingFunctions.JavaTypeParsingFunctions],
+    [import_RuntimeName.RuntimeName.Nodejs, import_NodejsTypeParsingFunctions.NodejsTypeParsingFunctions],
+    [import_RuntimeName.RuntimeName.Python, import_PythonTypeParsingFunctions.PythonTypeParsingFunctions],
+    [import_RuntimeName.RuntimeName.Python27, import_PythonTypeParsingFunctions.PythonTypeParsingFunctions]
+  ]);
+  /**
+   * Register a custom type mapping
+   * @param {string} resultType - The type name from the target runtime
+   * @param {Function} type - The JavaScript constructor function
+   * @param {any[]} [args] - Default arguments for the constructor
+   */
+  register(resultType, type, args) {
+    if (!this.#typeMap.has(resultType)) {
+      this.#typeMap.set(resultType, new import_ActivatorDetails.ActivatorDetails(type, args));
+    }
+  }
+  /**
+   * Convert InvocationContext result to appropriate JavaScript type
+   * @param {InvocationContext} ic - The invocation context
+   * @returns {any} The converted result
+   */
+  convertResult(ic) {
+    const runtimeName = ic.getRuntimeName();
+    const resultType = ic.getResultType();
+    const runtimeDict = this.#typeParsingFunctions.get(runtimeName);
+    if (runtimeDict) {
+      const parsingFunc = runtimeDict.get(resultType);
+      if (parsingFunc) {
+        return parsingFunc(ic);
+      }
+    }
+    const activatorDetails = this.#typeMap.get(resultType);
+    if (!activatorDetails) {
+      throw new Error(`No type registered for key '${resultType}'.`);
+    }
+    return new /** @type {any} */
+    activatorDetails.type(...activatorDetails.arguments);
+  }
+  /**
+   * Resolve type from string name and optional module
+   * @param {string} typeName - Name of the type to resolve
+   * @param {string} [moduleName] - Optional module name to import from
+   * @returns {Function} The resolved type/constructor function
+   */
+  static resolveType(typeName, moduleName) {
+    if (moduleName) {
+      try {
+        const module2 = dynamicImport(moduleName);
+        const typeObj2 = module2[typeName];
+        if (!typeObj2) {
+          throw new Error(`Type '${typeName}' not found in module '${moduleName}'`);
+        }
+        return typeObj2;
+      } catch (error) {
+        throw new Error(
+          `Failed to resolve type '${typeName}' from module '${moduleName}': ${/** @type {Error} */
+          error.message}`
+        );
+      }
+    }
+    const globalScope = typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {};
+    const typeObj = (
+      /** @type {Record<string, any>} */
+      globalScope[typeName]
+    );
+    if (!typeObj) {
+      throw new Error(`Type '${typeName}' not found in global scope`);
+    }
+    return typeObj;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ComplexTypeResolver
+});