javonet-ruby-sdk 2.6.3 → 2.6.5

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/receiver/Receiver.cjs

@@ -38,14 +38,13 @@ class Receiver {
     return import_RuntimeLogger.RuntimeLogger.getRuntimeInfo();
   }
   /**
-   * @param {Int8Array} messageByteArray
+   * @param {Uint8Array} messageByteArray
+   * @returns {Promise<Uint8Array> | Uint8Array}
    */
   static sendCommand(messageByteArray) {
     try {
-      return new import_CommandSerializer.CommandSerializer().serialize(
-        new import_Interpreter.Interpreter().process(messageByteArray),
-        this.connectionData
-      );
+      let command = new import_Interpreter.Interpreter().process(messageByteArray);
+      return new import_CommandSerializer.CommandSerializer().serialize(command, this.connectionData);
     } catch (error) {
       const exceptionCommand = import_ExceptionSerializer.ExceptionSerializer.serializeException(
         error,
@@ -55,11 +54,11 @@ class Receiver {
     }
   }
   /**
-   * @param {Int8Array} messageByteArray
-   * @returns {Int8Array}
+   * @param {Uint8Array} messageByteArray
+   * @returns {Promise<Uint8Array> | Uint8Array}
    */
   static heartBeat(messageByteArray) {
-    let response = new Int8Array(2);
+    let response = new Uint8Array(2);
     response[0] = messageByteArray[11];
     response[1] = messageByteArray[12] - 2;
     return response;

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/receiver/ReceiverNative.cjs

@@ -24,13 +24,15 @@ module.exports = __toCommonJS(ReceiverNative_exports);
 var import_Receiver = require("./Receiver.cjs");
 class ReceiverNative {
   /**
-   * @param {Int8Array} messageByteArray
+   * @param {Uint8Array} messageByteArray
+   * @returns {Promise<Uint8Array> | Uint8Array}
    */
   static sendCommand(messageByteArray) {
     return import_Receiver.Receiver.sendCommand(messageByteArray);
   }
   /**
-   * @param {Int8Array} messageByteArray
+   * @param {Uint8Array} messageByteArray
+   * @returns {Uint8Array | Promise<Uint8Array>}
    */
   static heartBeat(messageByteArray) {
     return import_Receiver.Receiver.heartBeat(messageByteArray);

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/transmitter/Transmitter.cjs

@@ -24,14 +24,14 @@ module.exports = __toCommonJS(Transmitter_exports);
 var import_TransmitterWrapper = require("./TransmitterWrapper.cjs");
 class Transmitter {
   /**
-   * @param {Int8Array} messageArray
-   * @returns {Int8Array}
+   * @param {Uint8Array} messageArray
+   * @returns {Uint8Array}
    */
   static sendCommand(messageArray) {
     return import_TransmitterWrapper.TransmitterWrapper.sendCommand(messageArray);
   }
   /**
-   * @param {string} licenseKey 
+   * @param {string} licenseKey
    * @returns {void}
    */
   static activate(licenseKey) {
@@ -40,13 +40,13 @@ class Transmitter {
   /**
    * @param {string} configSource
    * @returns {void}
-  */
+   */
   static setConfigSource(configSource) {
     return import_TransmitterWrapper.TransmitterWrapper.setConfigSource(configSource);
   }
   /**
-   * @param {string} workingDirectory 
-   * @returns 
+   * @param {string} workingDirectory
+   * @returns
    */
   static setJavonetWorkingDirectory(workingDirectory) {
     return import_TransmitterWrapper.TransmitterWrapper.setJavonetWorkingDirectory(workingDirectory);

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/transmitter/TransmitterWebsocket.cjs

@@ -40,9 +40,9 @@ class TransmitterWebsocket {
   }
   /**
    * @async
-   * @param {Int8Array} messageByteArray
+   * @param {Uint8Array} messageByteArray
    * @param {IConnectionData} connectionData
-   * @returns {Promise<Int8Array>} responseByteArray
+   * @returns {Promise<Uint8Array>} responseByteArray
    */
   static sendCommand(messageByteArray, connectionData) {
     const { hostname } = connectionData;

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/transmitter/TransmitterWebsocketBrowser.cjs

@@ -35,9 +35,9 @@ class TransmitterWebsocketBrowser {
   }
   /**
    * @async
-   * @param {Int8Array} messageByteArray
+   * @param {Uint8Array} messageByteArray
    * @param {IConnectionData} connectionData
-   * @returns {Promise<Int8Array>} responseByteArray
+   * @returns {Promise<Uint8Array>} responseByteArray
    */
   static async sendCommand(messageByteArray, connectionData) {
     const { hostname } = connectionData;

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/transmitter/TransmitterWrapper.cjs

@@ -65,7 +65,8 @@ class TransmitterWrapper {
     return library.activate(licenseKey);
   }
   /**
-   * @param {Int8Array} messageArray
+   * @param {Uint8Array} messageArray
+   * @returns {Uint8Array}
    */
   static sendCommand(messageArray) {
     this.loadNativeLibrary();

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/webSocketClient/WebSocketClient.cjs

@@ -62,8 +62,8 @@ class WebSocketClient {
   /**
    * Sends messageArray through websocket connection with guaranteed order preservation
    * @async
-   * @param {Int8Array} messageArray
-   * @returns {Promise<Int8Array>}
+   * @param {Uint8Array} messageArray
+   * @returns {Promise<Uint8Array>}
    */
   send(messageArray) {
     return new Promise((resolve, reject) => {
@@ -104,8 +104,8 @@ class WebSocketClient {
    * Sends a single message through websocket connection
    * @private
    * @async
-   * @param {Int8Array} messageArray
-   * @returns {Promise<Int8Array>}
+   * @param {Uint8Array} messageArray
+   * @returns {Promise<Uint8Array>}
    */
   _send(messageArray) {
     return new Promise((resolve, reject) => {

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/webSocketClient/WebSocketClientBrowser.cjs

@@ -60,8 +60,8 @@ class WebSocketClientBrowser {
   /**
    * Sends messageArray through websocket connection with guaranteed order preservation
    * @async
-   * @param {Int8Array} messageArray
-   * @returns {Promise<Int8Array>}
+   * @param {Uint8Array} messageArray
+   * @returns {Promise<Uint8Array>}
    */
   send(messageArray) {
     return new Promise((resolve, reject) => {
@@ -102,8 +102,8 @@ class WebSocketClientBrowser {
    * Sends a single message through websocket connection
    * @private
    * @async
-   * @param {Int8Array} messageArray
-   * @returns {Promise<Int8Array>}
+   * @param {Uint8Array} messageArray
+   * @returns {Promise<Uint8Array>}
    */
   _sendSingle(messageArray) {
     return new Promise((resolve, reject) => {
@@ -162,8 +162,8 @@ class WebSocketClientBrowser {
    * Sends the data to the WebSocket server and listens for a response.
    * @private
    * @param {WebSocket} client
-   * @param {Int8Array} data
-   * @param {(value: Int8Array) => void} resolve
+   * @param {Uint8Array} data
+   * @param {(value: Uint8Array) => void} resolve
    * @param {(reason?: any) => void} reject
    */
   _sendMessage(client, data, resolve, reject) {
@@ -174,7 +174,7 @@ class WebSocketClientBrowser {
         if (!message?.data) {
           return reject(new Error("Invalid message received"));
         }
-        const byteArray = new Int8Array(message?.data);
+        const byteArray = new Uint8Array(message?.data);
         resolve(byteArray);
         if (this.isDisconnectedAfterMessage) {
           this.disconnect();

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/sdk/ConfigRuntimeFactory.cjs

@@ -39,6 +39,9 @@ class ConfigRuntimeFactory {
   constructor(configSource) {
     this.configSource = configSource;
   }
+  static _IN_MEMORY_CONNECTION_TYPES = ["inmemory", "memory"];
+  static _WEB_SOCKET_CONNECTION_TYPES = ["websocket", "ws"];
+  static _TCP_CONNECTION_TYPES = ["tcp"];
   /**
    * Creates RuntimeContext instance to interact with the .NET Framework runtime.
    * @param {string} [configName="default"] - The name of the configuration to use (optional).
@@ -118,53 +121,48 @@ class ConfigRuntimeFactory {
    */
   #getRuntimeContext(runtime, configName = "default") {
     const jsonResolver = new import_JsonResolver.JsonResolver(this.configSource);
-    import_UtilsConst.UtilsConst.setLicenseKey(jsonResolver.getLicenseKey());
-    if (jsonResolver.getWorkingDirectory()) {
+    try {
+      import_UtilsConst.UtilsConst.setLicenseKey(jsonResolver.getLicenseKey());
+    } catch (e) {
+    }
+    try {
       import_UtilsConst.UtilsConst.setJavonetWorkingDirectory(jsonResolver.getWorkingDirectory());
+    } catch (e) {
     }
+    const channelType = jsonResolver.getChannelType(import_RuntimeNameHandler.RuntimeNameHandler.getName(runtime), configName);
+    const channelTypeLower = channelType ? channelType.trim().toLowerCase() : "";
+    let connectionData = null;
     if ((0, import_Runtime.isBrowserRuntime)()) {
-      const channelType = jsonResolver.getChannelType(import_RuntimeNameHandler.RuntimeNameHandler.getName(runtime), configName);
-      let connectionData = null;
-      if (channelType === "webSocket") {
+      if (ConfigRuntimeFactory._WEB_SOCKET_CONNECTION_TYPES.includes(channelTypeLower)) {
         connectionData = new import_WsConnectionData.WsConnectionData(
           jsonResolver.getChannelHost(import_RuntimeNameHandler.RuntimeNameHandler.getName(runtime), configName)
         );
       } else {
-        throw new Error("Unsupported connection type: " + channelType);
+        throw new Error("Invalid connection type. Use inmemory, tcp or websocket");
       }
       const rtmCtx = import_RuntimeContext.RuntimeContext.getInstance(runtime, connectionData);
       this.#loadModules(runtime, configName, jsonResolver, rtmCtx);
       return rtmCtx;
     }
     if ((0, import_Runtime.isNodejsRuntime)()) {
-      try {
-        const channelType = jsonResolver.getChannelType(
-          import_RuntimeNameHandler.RuntimeNameHandler.getName(runtime),
-          configName
+      if (ConfigRuntimeFactory._IN_MEMORY_CONNECTION_TYPES.includes(channelTypeLower)) {
+        connectionData = new import_InMemoryConnectionData.InMemoryConnectionData();
+      } else if (ConfigRuntimeFactory._TCP_CONNECTION_TYPES.includes(channelTypeLower)) {
+        connectionData = new import_TcpConnectionData.TcpConnectionData(
+          jsonResolver.getChannelHost(import_RuntimeNameHandler.RuntimeNameHandler.getName(runtime), configName),
+          /** @type {number} */
+          jsonResolver.getChannelPort(import_RuntimeNameHandler.RuntimeNameHandler.getName(runtime), configName)
         );
-        const licenseKey = jsonResolver.getLicenseKey();
-        let connectionData = null;
-        if (channelType === "inMemory") {
-          connectionData = new import_InMemoryConnectionData.InMemoryConnectionData();
-        } else if (channelType === "tcp") {
-          connectionData = new import_TcpConnectionData.TcpConnectionData(
-            jsonResolver.getChannelHost(import_RuntimeNameHandler.RuntimeNameHandler.getName(runtime), configName),
-            /** @type {number} */
-            jsonResolver.getChannelPort(import_RuntimeNameHandler.RuntimeNameHandler.getName(runtime), configName)
-          );
-        } else if (channelType === "webSocket") {
-          connectionData = new import_WsConnectionData.WsConnectionData(
-            jsonResolver.getChannelHost(import_RuntimeNameHandler.RuntimeNameHandler.getName(runtime), configName)
-          );
-        } else {
-          throw new Error("Unsupported connection type: " + channelType);
-        }
-        const rtmCtx = import_RuntimeContext.RuntimeContext.getInstance(runtime, connectionData);
-        this.#loadModules(runtime, configName, jsonResolver, rtmCtx);
-        return rtmCtx;
-      } catch (error) {
-        throw error;
+      } else if (ConfigRuntimeFactory._WEB_SOCKET_CONNECTION_TYPES.includes(channelTypeLower)) {
+        connectionData = new import_WsConnectionData.WsConnectionData(
+          jsonResolver.getChannelHost(import_RuntimeNameHandler.RuntimeNameHandler.getName(runtime), configName)
+        );
+      } else {
+        throw new Error("Invalid connection type. Use inmemory, tcp or websocket");
       }
+      const rtmCtx = import_RuntimeContext.RuntimeContext.getInstance(runtime, connectionData);
+      this.#loadModules(runtime, configName, jsonResolver, rtmCtx);
+      return rtmCtx;
     }
     throw new Error("Unsupported runtime environment");
   }
@@ -176,22 +174,27 @@ class ConfigRuntimeFactory {
    */
   #loadModules(runtime, configName, jsonResolver, rtmCtx) {
     try {
-      const modules = jsonResolver.getModules(import_RuntimeNameHandler.RuntimeNameHandler.getName(runtime), configName).split(",").filter((module2) => module2.trim() !== "");
-      if ((0, import_Runtime.isNodejsRuntime)()) {
-        const path = (
-          /** @type {import('path').PlatformPath} */
-          /** @type {unknown} */
-          requireDynamic("path")
-        );
-        const configDirectoryAbsolutePath = process.cwd();
-        modules.forEach((module2) => {
-          if (path.isAbsolute(module2)) {
-            rtmCtx.loadLibrary(module2);
-          } else {
-            rtmCtx.loadLibrary(path.join(configDirectoryAbsolutePath, module2));
-          }
-        });
+      const modules = jsonResolver.getModules(import_RuntimeNameHandler.RuntimeNameHandler.getName(runtime), configName).split(",").map((m) => m.trim()).filter((m) => m !== "");
+      if (!(0, import_Runtime.isNodejsRuntime)()) {
+        return;
+      }
+      const path = (
+        /** @type {import('path').PlatformPath} */
+        /** @type {unknown} */
+        requireDynamic("path")
+      );
+      let configDirectoryAbsolutePath = process.cwd();
+      const isCfgSourcePath = jsonResolver.isConfigSourcePath;
+      if (isCfgSourcePath) {
+        configDirectoryAbsolutePath = path.dirname(jsonResolver.configSource);
       }
+      modules.forEach((module2) => {
+        if (path.isAbsolute(module2)) {
+          rtmCtx.loadLibrary(module2);
+        } else {
+          rtmCtx.loadLibrary(path.join(configDirectoryAbsolutePath, module2));
+        }
+      });
     } catch (error) {
       throw error;
     }

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/sdk/InvocationContext.cjs

@@ -37,12 +37,10 @@ class InvocationContext {
   #connectionData;
   /** @type {Command | null} */
   #currentCommand = null;
-  /** @type {Command | null} */
+  /** @type {Command | Promise<Command> | null} */
   #responseCommand = null;
   /** @type {boolean} */
   #isExecuted = false;
-  /** @type {any | null} */
-  #resultValue = null;
   /** @type {Interpreter | null} */
   #interpreter = null;
   /**
@@ -59,7 +57,6 @@ class InvocationContext {
     this.#responseCommand = null;
     this.#isExecuted = isExecuted;
     this.#interpreter = null;
-    this.#resultValue = null;
   }
   /**
    * @param {Command} localCommand
@@ -100,7 +97,18 @@ class InvocationContext {
       throw new Error("Object is not iterable");
     }
     let position = -1;
-    const arraySize = Number(this.getSize().execute().getValue());
+    let arraySize = 0;
+    const sizeCtx = (
+      /** @type {any} */
+      this.getSize().execute()
+    );
+    if (sizeCtx instanceof Promise) {
+      sizeCtx.then((ctx) => {
+        arraySize = Number(ctx.getValue());
+      });
+    } else {
+      arraySize = Number(sizeCtx.getValue());
+    }
     return {
       next: () => ({
         value: this.getIndex(++position),
@@ -115,7 +123,7 @@ class InvocationContext {
    * Commands are becoming nested through each invocation of methods on Invocation Context.
    * Each invocation triggers the creation of new Invocation Context instance wrapping the current command with new parent command valid for invoked method.
    * Developer can decide on any moment of the materialization for the context taking full control of the chunks of the expression being transferred and processed on target runtime.
-   * @returns {InvocationContext} the InvocationContext after executing the command.
+   * @returns {Promise<InvocationContext> | InvocationContext} the InvocationContext after executing the command.
    * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/execute-method)
    * @method
    */
@@ -127,18 +135,25 @@ class InvocationContext {
       this.#interpreter = new import_Interpreter.Interpreter();
     }
     this.#responseCommand = this.#interpreter.execute(this.#currentCommand, this.#connectionData);
-    if (!this.#responseCommand) {
-      throw new Error("responseCommand is undefined in Invocation Context execute method");
-    }
-    if (this.#responseCommand?.commandType === import_CommandType.CommandType.Exception) {
-      throw import_ExceptionThrower.ExceptionThrower.throwException(this.#responseCommand);
-    }
-    if (this.#responseCommand?.commandType === import_CommandType.CommandType.CreateClassInstance) {
-      this.#currentCommand = this.#responseCommand;
-      this.#isExecuted = true;
-      return this;
+    const handleResponse = (resolvedResponse) => {
+      if (!resolvedResponse) {
+        throw new Error("responseCommand is undefined in Invocation Context execute method");
+      }
+      if (resolvedResponse.commandType === import_CommandType.CommandType.Exception) {
+        throw import_ExceptionThrower.ExceptionThrower.throwException(resolvedResponse);
+      }
+      if (resolvedResponse.commandType === import_CommandType.CommandType.CreateClassInstance) {
+        this.#currentCommand = resolvedResponse;
+        this.#isExecuted = true;
+        return this;
+      }
+      return new InvocationContext(this.#runtimeName, this.#connectionData, resolvedResponse, true);
+    };
+    if (this.#responseCommand instanceof Promise) {
+      return this.#responseCommand.then(handleResponse);
+    } else {
+      return handleResponse(this.#responseCommand);
     }
-    return new InvocationContext(this.#runtimeName, this.#connectionData, this.#responseCommand, true);
   }
   /**
    * Invokes a static method on the target runtime.
@@ -375,14 +390,22 @@ class InvocationContext {
   }
   /**
    * Retrieves the type of the object from the target runtime.
-   * @returns {string} The type of the object.
+   * @returns {Promise<string> | 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();
+    const invocationContext = new InvocationContext(
+      this.#runtimeName,
+      this.#connectionData,
+      this.#buildCommand(localCommand)
+    );
+    const execCtx = (
+      /** @type {any} */
+      invocationContext.execute()
+    );
+    const result = execCtx.getValue();
     return (
       /** @type {string} */
       result
@@ -399,36 +422,31 @@ class InvocationContext {
   }
   /**
    * Retrieves an array from the target runtime.
-   * @returns {InvocationContext} A new InvocationContext instance that wraps the command to retrieve the array.
-   * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/arrays-and-collections/retrieve-array)
+   * @returns {Promise<any[]>}
    * @method
    */
   retrieveArray() {
-    let localCommand = new import_Command.Command(this.#runtimeName, import_CommandType.CommandType.RetrieveArray, []);
-    let localInvCtx = new InvocationContext(
+    const localCommand = new import_Command.Command(this.#runtimeName, import_CommandType.CommandType.RetrieveArray, []);
+    const localInvCtx = new InvocationContext(
       this.#runtimeName,
       this.#connectionData,
       this.#buildCommand(localCommand)
     );
     localInvCtx.execute();
-    if (localInvCtx.#responseCommand === null) {
-      throw new Error("responseCommand is undefined in Invocation Context execute method");
-    }
-    return localInvCtx.#responseCommand.payload;
+    const extract = (respCommand) => {
+      return respCommand.payload;
+    };
+    return localInvCtx.#responseCommand instanceof Promise ? localInvCtx.#responseCommand.then(extract) : localInvCtx.#responseCommand?.payload;
   }
   /**
    * Returns the primitive value from the target runtime. This could be any primitive type in JavaScript,
    * such as int, boolean, byte, char, long, double, float, etc.
-   * @returns {Command} The value of the current command.
+   * @returns {unknown} The value of the current command.
    * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/execute-method)
    * @method
    */
-  /**
-   * @returns {unknown}
-   */
   getValue() {
-    this.#resultValue = this.#currentCommand?.payload[0];
-    return this.#resultValue;
+    return this.#currentCommand?.payload[0];
   }
   /**
    * @param {Command} command
@@ -486,8 +504,6 @@ class InvocationWsContext extends InvocationContext {
   #interpreter;
   /** @type {boolean} */
   #isExecuted;
-  /** @type {any | null} */
-  #resultValue;
   /**
    * @param {RuntimeNameType} runtimeName
    * @param {IConnectionData} connectionData
@@ -502,7 +518,6 @@ class InvocationWsContext extends InvocationContext {
     this.#responseCommand = null;
     this.#isExecuted = isExecuted;
     this.#interpreter = null;
-    this.#resultValue = null;
   }
   /**
    * Executes the current command.
@@ -516,7 +531,6 @@ class InvocationWsContext extends InvocationContext {
    * @async
    * @method
    */
-  // @ts-expect-error
   async execute() {
     if (this.#currentCommand === null) {
       throw new Error("currentCommand is undefined in Invocation Context execute method");
@@ -548,10 +562,13 @@ class InvocationWsContext extends InvocationContext {
    * @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 invocationContext = new InvocationWsContext(
+      this.#runtimeName,
+      this.#connectionData,
+      this.#buildCommand(localCommand)
+    );
     const result = await invocationContext.execute();
     return (
       /** @type {string} */

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/sdk/Javonet.cjs

@@ -20,6 +20,7 @@ var Javonet_exports = {};
 __export(Javonet_exports, {
   CommandDeserializer: () => import_CommandDeserializer.CommandDeserializer,
   CommandSerializer: () => import_CommandSerializer.CommandSerializer,
+  ConfigPriority: () => import_ConfigPriority.ConfigPriority,
   Javonet: () => Javonet,
   TcpConnectionData: () => import_TcpConnectionData.TcpConnectionData,
   WsConnectionData: () => import_WsConnectionData.WsConnectionData
@@ -27,6 +28,7 @@ __export(Javonet_exports, {
 module.exports = __toCommonJS(Javonet_exports);
 var import_ConfigRuntimeFactory = require("./ConfigRuntimeFactory.cjs");
 var import_RuntimeFactory = require("./RuntimeFactory.cjs");
+var import_RuntimeContext = require("./RuntimeContext.cjs");
 var import_InMemoryConnectionData = require("../utils/connectionData/InMemoryConnectionData.cjs");
 var import_Runtime = require("../utils/Runtime.cjs");
 var import_CommandSerializer = require("../core/protocol/CommandSerializer.cjs");
@@ -35,6 +37,8 @@ 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_UtilsConst = require("../utils/UtilsConst.cjs");
+var import_ConfigSourceResolver = require("./configuration/ConfigSourceResolver.cjs");
+var import_ConfigPriority = require("./configuration/ConfigPriority.cjs");
 const import_meta = {};
 const requireDynamic = (0, import_Runtime.getRequire)(import_meta.url);
 let _Transmitter = null;
@@ -119,11 +123,29 @@ class Javonet {
   static setJavonetWorkingDirectory(path) {
     import_UtilsConst.UtilsConst.setJavonetWorkingDirectory(path);
   }
+  /**
+   * Adds a configuration to the ConfigSourceResolver with the specified priority and source.
+   * @param {number} priority - The priority of the configuration.
+   * @param {string} configSource - The configuration source.
+   */
+  static addConfig(priority, configSource) {
+    import_ConfigSourceResolver.ConfigSourceResolver.addConfigs(priority, configSource);
+  }
+  /**
+   * Initializes a RuntimeContext instance based on the specified configuration name.
+   * @param {string} configName - The name of the configuration to use.
+   * @returns {RuntimeContext}  A RuntimeContext instance initialized with the specified configuration.
+   */
+  static initializeRc(configName) {
+    const config = import_ConfigSourceResolver.ConfigSourceResolver.getConfig(configName);
+    return import_RuntimeFactory.RuntimeFactory.initializeRuntimeContext(config);
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CommandDeserializer,
   CommandSerializer,
+  ConfigPriority,
   Javonet,
   TcpConnectionData,
   WsConnectionData

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/sdk/RuntimeFactory.cjs

@@ -25,7 +25,7 @@ var import_RuntimeName = require("../utils/RuntimeName.cjs");
 var import_RuntimeContext = require("./RuntimeContext.cjs");
 class RuntimeFactory {
   /**
-   * @param {IConnectionData} connectionData 
+   * @param {IConnectionData} connectionData
    */
   constructor(connectionData) {
     this.connectionData = connectionData;
@@ -86,6 +86,14 @@ class RuntimeFactory {
   nodejs() {
     return import_RuntimeContext.RuntimeContext.getInstance(import_RuntimeName.RuntimeName.Nodejs, this.connectionData);
   }
+  /**
+   * Creates RuntimeContext instance to interact with the PHP runtime.
+   * @return {RuntimeContext} a RuntimeContext instance for the PHP runtime
+   * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
+   */
+  php() {
+    return import_RuntimeContext.RuntimeContext.getInstance(import_RuntimeName.RuntimeName.Php, this.connectionData);
+  }
   /**
    * Creates RuntimeContext instance to interact with the Python runtime.
    * @return {RuntimeContext} a RuntimeContext instance for the Python runtime
@@ -94,6 +102,30 @@ class RuntimeFactory {
   python27() {
     return import_RuntimeContext.RuntimeContext.getInstance(import_RuntimeName.RuntimeName.Python27, this.connectionData);
   }
+  /**
+   * @param {{ runtime: import("../types.js").RuntimeName; connectionData: import("../utils/connectionData/IConnectionData.js").IConnectionData; modules: any; }} config
+   */
+  static initializeRuntimeContext(config) {
+    const rtmCtx = import_RuntimeContext.RuntimeContext.getInstance(config.runtime, config.connectionData);
+    const modules = (config.modules || "").split(",").map((m) => m.trim()).filter((m) => m !== "");
+    let pathModule = null;
+    try {
+      const _require = typeof require !== "undefined" ? require : eval("require");
+      pathModule = _require("path");
+    } catch (e) {
+      pathModule = null;
+    }
+    modules.forEach((module2) => {
+      const isAbsolute = pathModule ? pathModule.isAbsolute(module2) : module2.startsWith("/") || /^[A-Za-z]:\\/.test(module2);
+      if (isAbsolute) {
+        rtmCtx.loadLibrary(module2);
+      } else {
+        const resolved = pathModule ? pathModule.join(process.cwd(), module2) : `${process.cwd()}/${module2}`;
+        rtmCtx.loadLibrary(resolved);
+      }
+    });
+    return rtmCtx;
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {