javonet-ruby-sdk 2.5.14 → 2.5.16

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

@@ -0,0 +1,164 @@
+"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 PassDelegateHandler_exports = {};
+__export(PassDelegateHandler_exports, {
+  PassDelegateHandler: () => PassDelegateHandler
+});
+module.exports = __toCommonJS(PassDelegateHandler_exports);
+var import_CommandType = require("../../utils/CommandType.cjs");
+var import_InMemoryConnectionData = require("../../utils/connectionData/InMemoryConnectionData.cjs");
+var import_DelegatesCache = require("../delegatesCache/DelegatesCache.cjs");
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class PassDelegateHandler extends import_AbstractHandler.AbstractHandler {
+  constructor(interpreter = null) {
+    super();
+    /** @type {Interpreter | null | undefined} */
+    __publicField(this, "interpreter", null);
+    this.requiredParametersCount = 1;
+    this.interpreter = interpreter;
+  }
+  /**S
+   * Processes the given command to create and compile a delegate.
+   * @param {Command} command - The command to process.
+   * @returns {Function} The compiled delegate function.
+   */
+  process(command) {
+    this.validateCommand(command);
+    const delegateGuid = command.payload[0];
+    const delegate = import_DelegatesCache.delegatesCacheInstance.getDelegate(delegateGuid);
+    return delegate;
+  }
+  /**
+   * Validates the command to ensure it has enough parameters.
+   * @param {Command} command - The command to validate.
+   */
+  validateCommand(command) {
+    if (command.payload.length < this.requiredParametersCount) {
+      throw new Error("PassDelegateHandler parameters mismatch");
+    }
+  }
+  /**
+   * Retrieves the arguments from the command payload.
+   * @param {Command} command - The command containing the payload.
+   * @returns {Array<any>} The extracted arguments.
+   */
+  getArguments(command) {
+    return command.payload.length > 2 ? command.payload.slice(2) : [];
+  }
+  /**
+   * Extracts argument types from the arguments array.
+   * @param {Array<any>} args - The arguments array.
+   * @returns {Array<any>} The argument types.
+   */
+  getArgumentTypes(args) {
+    return args.slice(0, -1).map((arg) => arg.constructor);
+  }
+  /**
+   * Retrieves the return type from the arguments array.
+   * @param {Array<any>} args - The arguments array.
+   * @returns {Function} The return type.
+   */
+  getReturnType(args) {
+    return args[args.length - 1].constructor;
+  }
+  /**
+   * Creates parameter expressions from argument types.
+   * @param {Array<any>} argsTypes - The argument types.
+   * @returns {Array<any>} The parameter expressions.
+   */
+  createParameters(argsTypes) {
+    return argsTypes.map((type, index) => ({ name: `arg${index}`, type }));
+  }
+  /**
+   * Creates an array of arguments for the delegate.
+   * @param {string} delegateGuid - The delegate identifier.
+   * @param {Array<any>} parameters - The parameter expressions.
+   * @returns {Array<any>} The arguments array.
+   */
+  createArgsArray(delegateGuid, parameters) {
+    return [delegateGuid, ...parameters.map((param) => param.name)];
+  }
+  /**
+   * Creates a command expression.
+   * @param {string} callingRuntimeName - The runtime name.
+   * @param {Array<any>} payload - The arguments array.
+   * @returns {Object} The command object.
+   */
+  createCommand(callingRuntimeName, payload) {
+    return {
+      runtimeName: callingRuntimeName,
+      type: import_CommandType.CommandType.InvokeDelegate,
+      payload
+    };
+  }
+  /**
+   * Creates a method call to execute the command.
+   * @param {Command} command - The command object.
+   * @returns {any} The response object.
+   */
+  createExecuteCall(command) {
+    return this.interpreter?.execute(command, new import_InMemoryConnectionData.InMemoryConnectionData());
+  }
+  /**
+   * Retrieves the response payload from the execution call.
+   * @param {Object<string, any>} executeCall - Object containing the execution call.
+   * @returns {Array<any>} The response payload.
+   */
+  getResponse(executeCall) {
+    return executeCall?.payload;
+  }
+  /**
+   * Converts the first element of the response to the return type.
+   * @param {Array<any>} response - The response payload.
+   * @param {Function} returnType - The return type.
+   * @returns {*} The converted first element.
+   */
+  convertFirstElement(response, returnType) {
+    return returnType(response[0]);
+  }
+  /**
+   * Creates a block of expressions for the delegate.
+   * @param {Function} returnType - The return type.
+   * @param {*} convertedFirstElement - The converted first element.
+   * @returns {Object} The block expression.
+   */
+  createBlock(returnType, convertedFirstElement) {
+    return { returnType, body: convertedFirstElement };
+  }
+  /**
+   * Creates a delegate type.
+   * @param {Array<any>} parameters - The parameter expressions.
+   * @param {Function} returnType - The return type.
+   * @returns {Function} The delegate type.
+   */
+  createDelegateType(parameters, returnType) {
+    return (...args) => {
+      if (args.length !== parameters.length) {
+        throw new Error("Invalid argument count.");
+      }
+      return returnType;
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PassDelegateHandler
+});

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

@@ -0,0 +1,41 @@
+"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 ResolveReferenceHandler_exports = {};
+__export(ResolveReferenceHandler_exports, {
+  ResolveReferenceHandler: () => ResolveReferenceHandler
+});
+module.exports = __toCommonJS(ResolveReferenceHandler_exports);
+var import_ReferencesCache = require("../referenceCache/ReferencesCache.cjs");
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class ResolveReferenceHandler extends import_AbstractHandler.AbstractHandler {
+  constructor() {
+    super();
+  }
+  /**
+   * @param {Command} command
+   * @returns {any}
+   */
+  process(command) {
+    return import_ReferencesCache.ReferencesCache.getInstance().resolveReference(command.payload[0]);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ResolveReferenceHandler
+});

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

@@ -0,0 +1,63 @@
+"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 SetGlobalStaticFieldHandler_exports = {};
+__export(SetGlobalStaticFieldHandler_exports, {
+  SetGlobalStaticFieldHandler: () => SetGlobalStaticFieldHandler
+});
+module.exports = __toCommonJS(SetGlobalStaticFieldHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class SetGlobalStaticFieldHandler extends import_AbstractHandler.AbstractHandler {
+  constructor() {
+    super();
+    __publicField(this, "requiredParametersCount", 2);
+  }
+  process(command) {
+    try {
+      if (command.payload.length < this.requiredParametersCount) {
+        throw new Error("Set gloabal static field parameters mismatch");
+      }
+      const { payload } = command;
+      const splitted = payload[0].split(".");
+      const value = payload[1];
+      let fieldToSet;
+      for (let i = 0; i < splitted.length; i++) {
+        if (typeof (fieldToSet ? fieldToSet[splitted[i]] : global[splitted[i]]) === "undefined") {
+          let fields = Object.keys(fieldToSet ? fieldToSet : global);
+          let message = `Field ${splitted[i]} not found in object. Available fields:
+`;
+          fields.forEach((fieldIter) => {
+            message += `${fieldIter}
+`;
+          });
+          throw new Error(message);
+        }
+        fieldToSet = !fieldToSet ? global[splitted[i]] : fieldToSet[splitted[i]];
+      }
+      fieldToSet = value;
+    } catch (error) {
+      throw this.process_stack_trace(error, this.constructor.name);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SetGlobalStaticFieldHandler
+});

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

@@ -0,0 +1,61 @@
+"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 SetInstanceFieldHandler_exports = {};
+__export(SetInstanceFieldHandler_exports, {
+  SetInstanceFieldHandler: () => SetInstanceFieldHandler
+});
+module.exports = __toCommonJS(SetInstanceFieldHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class SetInstanceFieldHandler extends import_AbstractHandler.AbstractHandler {
+  constructor() {
+    super();
+    __publicField(this, "requiredParametersCount", 3);
+  }
+  process(command) {
+    try {
+      if (command.payload.length < this.requiredParametersCount) {
+        throw new Error("Set Instance Field parameters mismatch");
+      }
+      const { payload } = command;
+      let instance = payload[0];
+      let field = payload[1];
+      let value = payload[2];
+      if (typeof instance[field] === "undefined") {
+        let fields = Object.keys(instance);
+        let message = `Field ${field} not found in object. Available fields:
+`;
+        fields.forEach((fieldIter) => {
+          message += `${fieldIter}
+`;
+        });
+        throw new Error(message);
+      }
+      instance[field] = value;
+      return 0;
+    } catch (error) {
+      throw this.process_stack_trace(error, this.constructor.name);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SetInstanceFieldHandler
+});

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

@@ -0,0 +1,59 @@
+"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 SetStaticFieldHandler_exports = {};
+__export(SetStaticFieldHandler_exports, {
+  SetStaticFieldHandler: () => SetStaticFieldHandler
+});
+module.exports = __toCommonJS(SetStaticFieldHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class SetStaticFieldHandler extends import_AbstractHandler.AbstractHandler {
+  constructor() {
+    super();
+    __publicField(this, "requiredParametersCount", 3);
+  }
+  process(command) {
+    try {
+      if (command.payload.length < this.requiredParametersCount) {
+        throw new Error("Set static field parameters mismatch");
+      }
+      const { payload } = command;
+      let [obj, field, value] = payload;
+      if (typeof obj[field] === "undefined") {
+        let fields = Object.keys(obj);
+        let message = `Field ${field} not found in class ${obj.constructor.name}. Available fields:
+`;
+        fields.forEach((fieldIter) => {
+          message += `${fieldIter}
+`;
+        });
+        throw new Error(message);
+      }
+      obj[field] = value;
+      return 0;
+    } catch (error) {
+      throw this.process_stack_trace(error, this.constructor.name);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SetStaticFieldHandler
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/handler/ValueHandler.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 ValueHandler_exports = {};
+__export(ValueHandler_exports, {
+  ValueHandler: () => ValueHandler
+});
+module.exports = __toCommonJS(ValueHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class ValueHandler extends import_AbstractHandler.AbstractHandler {
+  constructor() {
+    super();
+  }
+  process(command) {
+    const { payload } = command;
+    return payload[0];
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ValueHandler
+});

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

@@ -0,0 +1,163 @@
+"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 Interpreter_exports = {};
+__export(Interpreter_exports, {
+  Interpreter: () => Interpreter
+});
+module.exports = __toCommonJS(Interpreter_exports);
+const import_meta = {};
+var import_ConnectionType = require("../../utils/ConnectionType.cjs");
+var import_Runtime = require("../../utils/Runtime.cjs");
+var import_RuntimeName = require("../../utils/RuntimeName.cjs");
+var import_CommandDeserializer = require("../protocol/CommandDeserializer.cjs");
+var import_CommandSerializer = require("../protocol/CommandSerializer.cjs");
+var import_TransmitterWebsocketBrowser = require("../transmitter/TransmitterWebsocketBrowser.cjs");
+var import_TransmitterWebsocket = require("../transmitter/TransmitterWebsocket.cjs");
+var import_Handler = require("../handler/Handler.cjs");
+let _Receiver = null;
+let _Transmitter = null;
+let _TransmitterWebsocket = null;
+if (!_TransmitterWebsocket) {
+  _TransmitterWebsocket = (0, import_Runtime.isNodejsRuntime)() ? import_TransmitterWebsocket.TransmitterWebsocket : import_TransmitterWebsocketBrowser.TransmitterWebsocketBrowser;
+}
+const requireDynamic = (0, import_Runtime.getRequire)(import_meta.url);
+class Interpreter {
+  constructor() {
+    __publicField(this, "handler");
+  }
+  /**
+   *
+   * @param {Command} command
+   * @param {IConnectionData} connectionData
+   * @returns
+   */
+  async executeAsync(command, connectionData) {
+    try {
+      let messageByteArray = new import_CommandSerializer.CommandSerializer().serialize(command, connectionData);
+      let responseByteArray;
+      if (command.runtimeName === import_RuntimeName.RuntimeName.Nodejs && connectionData.connectionType === import_ConnectionType.ConnectionType.IN_MEMORY) {
+        if ((0, import_Runtime.isNodejsRuntime)()) {
+          if (!_Receiver) {
+            const { Receiver } = require("../receiver/Receiver.cjs");
+            _Receiver = Receiver;
+          }
+          responseByteArray = _Receiver.sendCommand(messageByteArray);
+        } else {
+          throw new Error("Node.js runtime not found");
+        }
+      } else if (connectionData.connectionType === import_ConnectionType.ConnectionType.WEB_SOCKET) {
+        try {
+          const _response = await _TransmitterWebsocket.sendCommand(
+            messageByteArray,
+            connectionData
+          );
+          if (_response) {
+            const command2 = new import_CommandDeserializer.CommandDeserializer(_response).deserialize();
+            return command2;
+          } else {
+            throw new Error("Response not received from TransmitterWebsocket");
+          }
+        } catch (error) {
+          throw error;
+        }
+      } else {
+        if ((0, import_Runtime.isNodejsRuntime)()) {
+          if (!_Transmitter) {
+            const { Transmitter } = require("../transmitter/Transmitter.cjs");
+            _Transmitter = Transmitter;
+          }
+          responseByteArray = await _Transmitter.sendCommand(messageByteArray);
+        } else {
+          throw new Error("Allowed only to run in nodejs runtime");
+        }
+      }
+      return new import_CommandDeserializer.CommandDeserializer(responseByteArray).deserialize();
+    } catch (error) {
+      throw error;
+    }
+  }
+  /**
+   *
+   * @param {Command} command
+   * @param {WsConnectionData} connectionData
+   * @returns {Promise<Command>}
+   */
+  execute(command, connectionData) {
+    try {
+      let messageByteArray = new import_CommandSerializer.CommandSerializer().serialize(command, connectionData);
+      let responseByteArray;
+      if (command.runtimeName === import_RuntimeName.RuntimeName.Nodejs && connectionData.connectionType === import_ConnectionType.ConnectionType.IN_MEMORY) {
+        if ((0, import_Runtime.isNodejsRuntime)()) {
+          if (!_Receiver) {
+            const { Receiver } = require("../receiver/Receiver.cjs");
+            _Receiver = Receiver;
+          }
+          responseByteArray = _Receiver.sendCommand(messageByteArray);
+        }
+      } else if (connectionData.connectionType === import_ConnectionType.ConnectionType.WEB_SOCKET) {
+        const promise = _TransmitterWebsocket.sendCommand(messageByteArray, connectionData);
+        return promise.then((_response) => {
+          if (_response) {
+            const command2 = new import_CommandDeserializer.CommandDeserializer(_response).deserialize();
+            return command2;
+          } else {
+            throw new Error("Response not received from TransmitterWebsocket");
+          }
+        }).catch((error) => {
+          throw error;
+        });
+      } else {
+        if ((0, import_Runtime.isNodejsRuntime)()) {
+          if (!_Transmitter) {
+            const { Transmitter } = require("../transmitter/Transmitter.cjs");
+            _Transmitter = Transmitter;
+          }
+          responseByteArray = _Transmitter.sendCommand(messageByteArray);
+        } else {
+          throw new Error("Allowed only to run in nodejs runtime");
+        }
+      }
+      return new import_CommandDeserializer.CommandDeserializer(responseByteArray).deserialize();
+    } catch (error) {
+      throw error;
+    }
+  }
+  /**
+   *
+   * @param {number[]} messageByteArray
+   * @returns {Command}
+   */
+  process(messageByteArray) {
+    try {
+      if (!this.handler) {
+        this.handler = new import_Handler.Handler(this);
+      }
+      const receivedCommand = new import_CommandDeserializer.CommandDeserializer(messageByteArray).deserialize();
+      return this.handler?.handleCommand(receivedCommand);
+    } catch (error) {
+      throw error;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Interpreter
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/namespaceCache/NamespaceCache.cjs

@@ -0,0 +1,61 @@
+"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 NamespaceCache_exports = {};
+__export(NamespaceCache_exports, {
+  NamespaceCache: () => NamespaceCache
+});
+module.exports = __toCommonJS(NamespaceCache_exports);
+const _NamespaceCache = class _NamespaceCache {
+  constructor() {
+    __publicField(this, "namespaceCache", []);
+    if (_NamespaceCache._instance === null) {
+      _NamespaceCache._instance = this;
+    }
+    return _NamespaceCache._instance;
+  }
+  cacheNamespace(namespaceRegex) {
+    this.namespaceCache.push(namespaceRegex);
+  }
+  isNamespaceCacheEmpty() {
+    return this.namespaceCache.length === 0;
+  }
+  isTypeAllowed(typeToCheck) {
+    for (let pattern of this.namespaceCache) {
+      if (new RegExp(pattern).test(typeToCheck.constructor.name)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  getCachedNamespaces() {
+    return this.namespaceCache;
+  }
+  clearCache() {
+    this.namespaceCache = [];
+    return 0;
+  }
+};
+__publicField(_NamespaceCache, "_instance", null);
+let NamespaceCache = _NamespaceCache;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NamespaceCache
+});