javonet-ruby-sdk 2.5.14 → 2.5.16

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

@@ -0,0 +1,85 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var GetStaticMethodAsDelegateHandler_exports = {};
+__export(GetStaticMethodAsDelegateHandler_exports, {
+  GetStaticMethodAsDelegateHandler: () => GetStaticMethodAsDelegateHandler
+});
+module.exports = __toCommonJS(GetStaticMethodAsDelegateHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class GetStaticMethodAsDelegateHandler extends import_AbstractHandler.AbstractHandler {
+  constructor() {
+    super();
+    /** @type {Array<*>} */
+    __publicField(this, "args", []);
+    this.method = null;
+    this.requiredParametersCount = 2;
+  }
+  /**
+   * Processes a command to retrieve a static method as a delegate.
+   * @param {Command} command - The command containing payload data.
+   * @param {Array<*>} command.payload - The payload containing type, method name, and arguments.
+   * @returns {Function} The delegate for the static method.
+   * @throws {Error} If the parameters mismatch or the method cannot be found.
+   */
+  process(command) {
+    if (command.payload.length < this.requiredParametersCount) {
+      throw new Error(`${this.constructor.name} parameters mismatch`);
+    }
+    const type = command.payload[0];
+    const methodName = command.payload[1];
+    this.args = command.payload.length > 2 ? command.payload.slice(2) : [];
+    this.method = this.getMethod(type, methodName);
+    if (!this.method) {
+      throw this.createMethodNotFoundError(type, methodName);
+    }
+    const methodDelegate = this.method.bind(this);
+    return methodDelegate;
+  }
+  /**
+   * Retrieves the method from the type.
+   * @param {Object} type - The class or constructor to search for the method.
+   * @param {string} methodName - The name of the method.
+   * @param {Array<Function>} argsType - The argument types.
+   * @param {Object} modifier - Parameter modifier (not used in JS implementation).
+   * @returns {Function|null} The found method or null if not found.
+   */
+  getMethod(type, methodName) {
+    const method = type[methodName];
+    return typeof method === "function" ? method : null;
+  }
+  /**
+   * Creates an error message when the method is not found.
+   * @param {Object} type - The class or constructor.
+   * @param {string} methodName - The method name.
+   * @returns {Error} The error with detailed message.
+   */
+  createMethodNotFoundError(type, methodName) {
+    const methods = Object.keys(type).filter((key) => typeof type[key] === "function");
+    const availableMethods = methods.map((name) => `${name}()`);
+    const message = `Method ${methodName} not found in class ${type.name}. Available public static methods:
+${availableMethods.join("\n")}`;
+    return new Error(message);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GetStaticMethodAsDelegateHandler
+});

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

@@ -0,0 +1,87 @@
+"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 GetTypeHandler_exports = {};
+__export(GetTypeHandler_exports, {
+  GetTypeHandler: () => GetTypeHandler
+});
+module.exports = __toCommonJS(GetTypeHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+var import_LoadLibraryHandler = require("./LoadLibraryHandler.cjs");
+var import_NamespaceCache = require("../namespaceCache/NamespaceCache.cjs");
+var import_TypeCache = require("../typeCache/TypeCache.cjs");
+var import_Runtime = require("../../utils/Runtime.cjs");
+const import_meta = {};
+class GetTypeHandler extends import_AbstractHandler.AbstractHandler {
+  constructor() {
+    super();
+    this.requiredParametersCount = 1;
+    this.namespaceCache = new import_NamespaceCache.NamespaceCache();
+    this.typeCache = new import_TypeCache.TypeCache();
+    this.loadLibaryHandler = new import_LoadLibraryHandler.LoadLibraryHandler();
+  }
+  process(command) {
+    try {
+      if (command.payload.length < this.requiredParametersCount) {
+        throw new Error("Get Type parameters mismatch");
+      }
+      const { payload } = command;
+      let typeName = payload[0];
+      typeName = typeName.replace(".js", "");
+      let typeToReturn = global[typeName];
+      if (typeToReturn === void 0) {
+        let message = `Type ${typeName} not found
+`;
+        message += "Available types:\n";
+        message += this.getAvailableTypes().join("\n");
+        throw new Error(message);
+      }
+      if (this.namespaceCache.isNamespaceCacheEmpty() && this.typeCache.isTypeCacheEmpty() || // both caches are empty
+      this.namespaceCache.isTypeAllowed(typeToReturn) || // namespace is allowed
+      this.typeCache.isTypeAllowed(typeToReturn)) {
+      } else {
+        let allowed_namespaces = this.namespaceCache.getCachedNamespaces().join(", ");
+        let allowed_types = this.typeCache.getCachedTypes().join(", ");
+        throw new Error(
+          `Type ${typeToReturn.name} not allowed. 
+Allowed namespaces: ${allowed_namespaces}
+Allowed types: ${allowed_types}`
+        );
+      }
+      return typeToReturn;
+    } catch (error) {
+      throw this.process_stack_trace(error, this.constructor.name);
+    }
+  }
+  getAvailableTypes() {
+    let availableTypes = [];
+    this.loadLibaryHandler.getLoadedLibraries().forEach((lib) => {
+      const dynamicRequire = (0, import_Runtime.getRequire)(import_meta.url);
+      const moduleExports = dynamicRequire(`${lib}`);
+      availableTypes.push(moduleExports.name);
+      Object.keys(moduleExports).forEach((key) => {
+        availableTypes.push(key);
+      });
+    });
+    return availableTypes;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GetTypeHandler
+});

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

@@ -0,0 +1,136 @@
+"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 Handler_exports = {};
+__export(Handler_exports, {
+  Handler: () => Handler,
+  handlers: () => handlers
+});
+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_InvokeInstanceMethodHandler = require("./InvokeInstanceMethodHandler.cjs");
+var import_DestructReferenceHandler = require("./DestructReferenceHandler.cjs");
+var import_CastingHandler = require("./CastingHandler.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_EnableNamespaceHandler = require("./EnableNamespaceHandler.cjs");
+var import_EnableTypeHandler = require("./EnableTypeHandler.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_CommandType = require("../../utils/CommandType.cjs");
+var import_Command = require("../../utils/Command.cjs");
+var import_ExceptionSerializer = require("../../utils/exception/ExceptionSerializer.cjs");
+var import_ConvertTypeHandler = require("./ConvertTypeHandler.cjs");
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+function isResponseSimpleType(response) {
+  let type = typeof response;
+  return ["string", "boolean", "number"].includes(type);
+}
+function isResponseNull(response) {
+  return response === null;
+}
+const handlers = {
+  [import_CommandType.CommandType.Value]: new import_ValueHandler.ValueHandler(),
+  [import_CommandType.CommandType.LoadLibrary]: new import_LoadLibraryHandler.LoadLibraryHandler(),
+  [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.Reference]: new import_ResolveReferenceHandler.ResolveReferenceHandler(),
+  [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.DestructReference]: new import_DestructReferenceHandler.DestructReferenceHandler(),
+  [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.EnableNamespace]: new import_EnableNamespaceHandler.EnableNamespaceHandler(),
+  [import_CommandType.CommandType.EnableType]: new import_EnableTypeHandler.EnableTypeHandler(),
+  [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()
+};
+class Handler {
+  /**
+   * @param {import('../interpreter/Interpreter.js').Interpreter} interpreter
+   */
+  constructor(interpreter) {
+    this.interpreter = interpreter;
+    handlers[import_CommandType.CommandType.PassDelegate] = new import_PassDelegateHandler.PassDelegateHandler(interpreter);
+    Object.keys(handlers).forEach((commandTypeHandler) => {
+      handlers[commandTypeHandler].handlers = handlers;
+    });
+  }
+  /**
+   * @param {{ commandType: number; payload: any[]; runtimeName: number; }} command
+   */
+  handleCommand(command) {
+    try {
+      if (command.commandType === import_CommandType.CommandType.RetrieveArray) {
+        let responseArray = handlers[import_CommandType.CommandType.Reference].handleCommand(command.payload[0]);
+        return import_Command.Command.createArrayResponse(responseArray, command.runtimeName);
+      }
+      let response = handlers[command.commandType].handleCommand(command);
+      return this.parseCommand(response, command.runtimeName);
+    } catch (error) {
+      return import_ExceptionSerializer.ExceptionSerializer.serializeException(error, command);
+    }
+  }
+  /**
+   * @param {any} response
+   * @param {number} runtimeName
+   * @returns {Command}
+   */
+  parseCommand(response, runtimeName) {
+    if (isResponseNull(response) || isResponseSimpleType(response)) {
+      return 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);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Handler,
+  handlers
+});

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

@@ -0,0 +1,53 @@
+"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 InvokeDelegateHandler_exports = {};
+__export(InvokeDelegateHandler_exports, {
+  InvokeDelegateHandler: () => InvokeDelegateHandler
+});
+module.exports = __toCommonJS(InvokeDelegateHandler_exports);
+var import_DelegatesCache = require("../delegatesCache/DelegatesCache.cjs");
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class InvokeDelegateHandler extends import_AbstractHandler.AbstractHandler {
+  constructor() {
+    super();
+    this.requiredParametersCount = 1;
+  }
+  /**
+   * Processes a command to invoke a delegate.
+   * @param {Command} command - The command containing payload data.
+   * @returns {*} The result of the delegate invocation.
+   * @throws {Error} If the parameters mismatch or the delegate cannot be found.
+   */
+  process(command) {
+    const payload = command.payload;
+    if (payload.length < this.requiredParametersCount) {
+      throw new Error(`${this.constructor.name} parameters mismatch`);
+    }
+    const guid = payload[0];
+    const delegate = import_DelegatesCache.delegatesCacheInstance.getDelegate(guid);
+    if (!delegate) {
+      throw new Error("Delegate not found in cache");
+    }
+    return delegate;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InvokeDelegateHandler
+});

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

@@ -0,0 +1,62 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var InvokeGlobalFunctionHandler_exports = {};
+__export(InvokeGlobalFunctionHandler_exports, {
+  InvokeGlobalFunctionHandler: () => InvokeGlobalFunctionHandler
+});
+module.exports = __toCommonJS(InvokeGlobalFunctionHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class InvokeGlobalFunctionHandler extends import_AbstractHandler.AbstractHandler {
+  constructor() {
+    super();
+    __publicField(this, "requiredParametersCount", 1);
+  }
+  process(command) {
+    try {
+      if (command.payload.length < this.requiredParametersCount) {
+        throw new Error("Invoke Global Function parameters mismatch");
+      }
+      const { payload } = command;
+      const functionName = payload[0];
+      const args = payload.slice(1);
+      if (typeof global[functionName] === "function") {
+        return Reflect.apply(global[functionName], void 0, args);
+      } else {
+        let methods = Object.getOwnPropertyNames(global).filter(function(property) {
+          return typeof global[property] === "function";
+        });
+        let message = `Method ${functionName} not found in global. Available methods:
+`;
+        methods.forEach((methodIter) => {
+          message += `${methodIter}
+`;
+        });
+        throw new Error(message);
+      }
+    } catch (error) {
+      throw this.process_stack_trace(error, this.constructor.name);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InvokeGlobalFunctionHandler
+});

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

@@ -0,0 +1,64 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var InvokeInstanceMethodHandler_exports = {};
+__export(InvokeInstanceMethodHandler_exports, {
+  InvokeInstanceMethodHandler: () => InvokeInstanceMethodHandler
+});
+module.exports = __toCommonJS(InvokeInstanceMethodHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class InvokeInstanceMethodHandler extends import_AbstractHandler.AbstractHandler {
+  constructor() {
+    super();
+    __publicField(this, "requiredParametersCount", 2);
+  }
+  process(command) {
+    try {
+      if (command.payload.length < this.requiredParametersCount) {
+        throw new Error("Invoke Instance Method parameters mismatch");
+      }
+      const { payload } = command;
+      let instance = payload[0];
+      let methodName = payload[1];
+      let args = payload.slice(2);
+      let method = instance[methodName];
+      if (typeof method === "undefined") {
+        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:
+`;
+        methods.forEach((methodIter) => {
+          message += `${methodIter}
+`;
+        });
+        throw new Error(message);
+      } else {
+        return Reflect.apply(method, instance, args);
+      }
+    } catch (error) {
+      throw this.process_stack_trace(error, this.constructor.name);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InvokeInstanceMethodHandler
+});

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

@@ -0,0 +1,64 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var InvokeStaticMethodHandler_exports = {};
+__export(InvokeStaticMethodHandler_exports, {
+  InvokeStaticMethodHandler: () => InvokeStaticMethodHandler
+});
+module.exports = __toCommonJS(InvokeStaticMethodHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class InvokeStaticMethodHandler extends import_AbstractHandler.AbstractHandler {
+  constructor() {
+    super();
+    __publicField(this, "requiredParametersCount", 2);
+  }
+  process(command) {
+    try {
+      if (command.payload.length < this.requiredParametersCount) {
+        throw new Error("Invoke Static Method parameters mismatch");
+      }
+      const { payload } = command;
+      let type = payload[0];
+      let methodName = payload[1];
+      let args = payload.slice(2);
+      let method = type[methodName];
+      if (typeof method === "undefined") {
+        let methods = Object.getOwnPropertyNames(type).filter(function(property) {
+          return typeof type[property] === "function";
+        });
+        let message = `Method ${methodName} not found in class. Available methods:
+`;
+        methods.forEach((methodIter) => {
+          message += `${methodIter}
+`;
+        });
+        throw new Error(message);
+      } else {
+        return Reflect.apply(method, void 0, args);
+      }
+    } catch (error) {
+      throw this.process_stack_trace(error, this.constructor.name);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InvokeStaticMethodHandler
+});

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

@@ -0,0 +1,71 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var LoadLibraryHandler_exports = {};
+__export(LoadLibraryHandler_exports, {
+  LoadLibraryHandler: () => LoadLibraryHandler
+});
+module.exports = __toCommonJS(LoadLibraryHandler_exports);
+const import_meta = {};
+var import_Runtime = require("../../utils/Runtime.cjs");
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+const dynamicImport = (0, import_Runtime.getRequire)(import_meta.url);
+const _LoadLibraryHandler = class _LoadLibraryHandler extends import_AbstractHandler.AbstractHandler {
+  constructor() {
+    super();
+    __publicField(this, "requiredParametersCount", 1);
+  }
+  process(command) {
+    if (command.payload.length < this.requiredParametersCount) {
+      throw new Error("Load Library parameters mismatch");
+    }
+    let { payload } = command;
+    let [lib] = payload;
+    let pathArray = lib.split(/[/\\]/);
+    let libraryName = pathArray.length > 1 ? pathArray[pathArray.length - 1] : pathArray[0];
+    libraryName = libraryName.replace(".js", "");
+    let moduleExports;
+    try {
+      moduleExports = dynamicImport(lib);
+      _LoadLibraryHandler.loadedLibraries.push(lib);
+    } catch (error) {
+      try {
+        const modulePath = `${process.cwd()}/${lib}`;
+        moduleExports = dynamicImport(modulePath);
+      } catch (error2) {
+        throw this.process_stack_trace(error2, this.constructor.name);
+      }
+    }
+    global[libraryName] = moduleExports;
+    for (const [key, value] of Object.entries(moduleExports)) {
+      global[key] = value;
+    }
+    return 0;
+  }
+  getLoadedLibraries() {
+    return _LoadLibraryHandler.loadedLibraries;
+  }
+};
+__publicField(_LoadLibraryHandler, "loadedLibraries", []);
+let LoadLibraryHandler = _LoadLibraryHandler;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LoadLibraryHandler
+});