javonet-nodejs-sdk 2.6.2 → 2.6.4

package/dist/sdk/InvocationContext.cjs

@@ -373,6 +373,34 @@ 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 +545,69 @@ 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

@@ -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");
@@ -34,8 +36,9 @@ 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");
+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;
@@ -120,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

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/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 = {

package/dist/sdk/configuration/Config.cjs

@@ -0,0 +1,55 @@
+"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 Config_exports = {};
+__export(Config_exports, {
+  Config: () => Config
+});
+module.exports = __toCommonJS(Config_exports);
+class Config {
+  /**
+   * @param {*} runtime
+   * @param {*} connectionData
+   * @param {string} [plugins=""]
+   * @param {string} [modules=""]
+   */
+  constructor(runtime, connectionData, plugins = "", modules = "") {
+    this.runtime = runtime;
+    this.connectionData = connectionData;
+    this.plugins = plugins ?? "";
+    this.modules = modules ?? "";
+  }
+  toString() {
+    const parts = [];
+    parts.push(`Runtime: ${this.runtime}`);
+    if (this.connectionData != null) {
+      parts.push(`Host: ${this.connectionData}`);
+    }
+    if (String(this.plugins).trim()) {
+      parts.push(`Plugins: ${this.plugins}`);
+    }
+    if (String(this.modules).trim()) {
+      parts.push(`Modules: ${this.modules}`);
+    }
+    return parts.join(", ");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config
+});

package/dist/sdk/configuration/ConfigPriority.cjs

@@ -0,0 +1,38 @@
+"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 ConfigPriority_exports = {};
+__export(ConfigPriority_exports, {
+  ConfigPriority: () => ConfigPriority
+});
+module.exports = __toCommonJS(ConfigPriority_exports);
+const ConfigPriority = (
+  /** @type {const} */
+  {
+    RuntimeSpecificEnv: 1,
+    GlobalEnv: 2,
+    RuntimeSpecificFile: 3,
+    GlobalFile: 4,
+    User: 5,
+    DefaultLibrary: 6
+  }
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConfigPriority
+});

package/dist/sdk/configuration/ConfigSourceResolver.cjs

@@ -0,0 +1,100 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ConfigSourceResolver_exports = {};
+__export(ConfigSourceResolver_exports, {
+  ConfigSourceResolver: () => ConfigSourceResolver
+});
+module.exports = __toCommonJS(ConfigSourceResolver_exports);
+var import_fs = __toESM(require("fs"), 1);
+var import_process = __toESM(require("process"), 1);
+var import_ConfigsDictionary = require("./ConfigsDictionary.cjs");
+var import_JsonConfigResolver = require("./configResolvers/JsonConfigResolver.cjs");
+var import_YamlConfigResolver = require("./configResolvers/YamlConfigResolver.cjs");
+var import_ConnectionStringConfigResolver = require("./configResolvers/ConnectionStringConfigResolver.cjs");
+class ConfigSourceResolver {
+  static addConfigs(priority, configSource) {
+    console.log(`Adding config from source: ${configSource} with priority '${priority}'`);
+    const configString = ConfigSourceResolver._getConfigSourceAsString(configSource);
+    ConfigSourceResolver._parseConfigsAndAddToCollection(priority, configString);
+  }
+  static getConfig(configName) {
+    console.log(`Retrieving config ${configName}`);
+    return import_ConfigsDictionary.ConfigsDictionary.getConfig(configName);
+  }
+  static clearConfigs() {
+    import_ConfigsDictionary.ConfigsDictionary.clearConfigs();
+  }
+  static _getConfigSourceAsString(configSource) {
+    if (!configSource || configSource.trim() === "") {
+      throw new Error("Config source cannot be null or whitespace.");
+    }
+    const envValue = import_process.default.env[configSource];
+    if (envValue && envValue.trim() !== "") {
+      configSource = envValue;
+    }
+    if (import_fs.default.existsSync(configSource) && import_fs.default.statSync(configSource).isFile()) {
+      configSource = import_fs.default.readFileSync(configSource, { encoding: "utf-8" });
+    }
+    return configSource.trim();
+  }
+  static _parseConfigsAndAddToCollection(priority, configString) {
+    try {
+      const jsonObject = JSON.parse(configString);
+      import_JsonConfigResolver.JsonConfigResolver.addConfigs(priority, jsonObject);
+      return;
+    } catch (ex) {
+      if (ex instanceof SyntaxError) {
+      } else {
+        console.log("Failed to parse config source as JSON: " + ex);
+      }
+    }
+    try {
+      import_YamlConfigResolver.YamlConfigResolver.addConfigs(priority, configString);
+      return;
+    } catch (ex) {
+      if (ex.name === "SyntaxError") {
+      } else {
+        console.log("Failed to parse config source as YAML: " + ex);
+      }
+    }
+    try {
+      import_ConnectionStringConfigResolver.ConnectionStringConfigResolver.addConfigs(priority, configString);
+      return;
+    } catch (ex) {
+      console.log("Failed to parse config source as connection string: " + ex);
+    }
+    throw new Error(
+      "Config source is not valid JSON, YAML, or connection string format:\n" + configString
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConfigSourceResolver
+});

package/dist/sdk/configuration/ConfigsDictionary.cjs

@@ -0,0 +1,121 @@
+"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 ConfigsDictionary_exports = {};
+__export(ConfigsDictionary_exports, {
+  ConfigsDictionary: () => ConfigsDictionary
+});
+module.exports = __toCommonJS(ConfigsDictionary_exports);
+class ConfigsDictionary {
+  /** @type {Map<string, Map<number, any>>} */
+  static _configurations_collection = /* @__PURE__ */ new Map();
+  /**
+   * Normalize priority to a numeric value.
+   * Accepts either a number or an object with a numeric `value` property.
+   * @param {any} priority
+   * @returns {number|undefined}
+   */
+  static _normalizePriority(priority) {
+    if (typeof priority === "number" && Number.isFinite(priority)) {
+      return priority;
+    }
+    if (priority && typeof priority === "object" && "value" in priority && typeof priority.value === "number") {
+      return priority.value;
+    }
+    return void 0;
+  }
+  /**
+   * Add a configuration for a given name and priority.
+   * If the same name+priority already exists, it will not be overwritten.
+   * @param {string} name
+   * @param {number|{value:number}} priority
+   * @param {*} config
+   */
+  static addConfig(name, priority, config) {
+    if (!name || String(name).trim() === "") {
+      console.log("Config name cannot be null or whitespace. Skipping add.");
+      return;
+    }
+    if (config == null) {
+      console.log("Config instance is null. Skipping add.");
+      return;
+    }
+    const key = ConfigsDictionary._normalizePriority(priority);
+    if (typeof key !== "number") {
+      console.log(
+        "Priority must be a numeric value or an object with a numeric `value` property. Skipping add."
+      );
+      return;
+    }
+    let perPriority = ConfigsDictionary._configurations_collection.get(name);
+    if (!perPriority) {
+      perPriority = /* @__PURE__ */ new Map();
+      ConfigsDictionary._configurations_collection.set(name, perPriority);
+    }
+    if (perPriority.has(key)) {
+      console.log(
+        `Config with name \`${name}\` and priority \`${key}\` already exists. It will not be added or updated.`
+      );
+      return;
+    }
+    perPriority.set(key, config);
+    let serialized;
+    try {
+      serialized = JSON.stringify(config);
+    } catch {
+      serialized = String(config);
+    }
+    console.log(`Added configuration \`${name}\` with priority \`${key}\` and parameters ${serialized}`);
+  }
+  /**
+   * Retrieve the configuration with the numerically smallest priority for the given name.
+   * Throws if name is invalid or no configuration is found.
+   * @param {string} name
+   * @returns {*}
+   */
+  static getConfig(name) {
+    if (!name || String(name).trim() === "") {
+      throw new Error("Config name cannot be null or whitespace");
+    }
+    const perPriority = ConfigsDictionary._configurations_collection.get(name);
+    if (!perPriority || perPriority.size === 0) {
+      throw new Error(`Configuration ${name} not found`);
+    }
+    const keysArray = [...perPriority.keys()];
+    const smallest = keysArray.reduce((min, k) => k < min ? k : min, keysArray[0]);
+    const config = perPriority.get(smallest);
+    let serialized;
+    try {
+      serialized = JSON.stringify(config);
+    } catch {
+      serialized = String(config);
+    }
+    console.log(
+      `Retrieved configuration \`${name}\` with priority \`${smallest}\` and parameters ${serialized}`
+    );
+    return config;
+  }
+  /** Clear all stored configurations. */
+  static clearConfigs() {
+    ConfigsDictionary._configurations_collection.clear();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConfigsDictionary
+});

package/dist/sdk/configuration/configResolvers/ConfigResolver.cjs

@@ -0,0 +1,121 @@
+"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 ConfigResolver_exports = {};
+__export(ConfigResolver_exports, {
+  ConfigResolver: () => ConfigResolver
+});
+module.exports = __toCommonJS(ConfigResolver_exports);
+var import_RuntimeNameHandler = require("../../../utils/RuntimeNameHandler.cjs");
+var import_InMemoryConnectionData = require("../../../utils/connectionData/InMemoryConnectionData.cjs");
+var import_WsConnectionData = require("../../../utils/connectionData/WsConnectionData.cjs");
+var import_TcpConnectionData = require("../../../utils/nodejs/connectionData/TcpConnectionData.cjs");
+class ConfigResolver {
+  /**
+   * Parse a runtime string into the runtime enum/name using RuntimeNameHandler.
+   * @param {string} runtime
+   * @returns {*}
+   */
+  static tryParseRuntime(runtime) {
+    if (!runtime || String(runtime).trim() === "") {
+      throw new Error("Runtime string cannot be null or whitespace.");
+    }
+    const normalized = String(runtime).trim().toLowerCase();
+    return import_RuntimeNameHandler.RuntimeNameHandler.getRuntime(normalized);
+  }
+  /**
+   * Build appropriate connection data object from a host string.
+   * - empty / null => InMemoryConnectionData
+   * - "inmemory" or "in-memory" => InMemoryConnectionData
+   * - ws:// or wss:// => WsConnectionData(fullAddress)
+   * - tcp://... => parsed by parseTcp
+   * - host:port or host:port/... => TcpConnectionData(host, port) if valid, otherwise InMemoryConnectionData
+   * @param {string} hostValue
+   * @returns {InMemoryConnectionData|WsConnectionData|TcpConnectionData}
+   */
+  static buildConnectionData(hostValue) {
+    if (!hostValue || String(hostValue).trim() === "") {
+      return new import_InMemoryConnectionData.InMemoryConnectionData();
+    }
+    const hv = String(hostValue).trim();
+    const lower = hv.toLowerCase();
+    if (lower === "inmemory" || lower === "in-memory") {
+      return new import_InMemoryConnectionData.InMemoryConnectionData();
+    }
+    if (lower.startsWith("ws://") || lower.startsWith("wss://")) {
+      return new import_WsConnectionData.WsConnectionData(hv);
+    }
+    if (lower.startsWith("tcp://")) {
+      try {
+        return ConfigResolver.parseTcp(hv.slice(6));
+      } catch (e) {
+        return new import_InMemoryConnectionData.InMemoryConnectionData();
+      }
+    }
+    const colon = hv.indexOf(":");
+    if (colon > 0 && colon < hv.length - 1) {
+      let portPart = hv.substring(colon + 1);
+      const slash = portPart.indexOf("/");
+      if (slash >= 0) {
+        portPart = portPart.substring(0, slash);
+      }
+      try {
+        const port = parseInt(portPart, 10);
+        if (!Number.isFinite(port) || Number.isNaN(port)) {
+          throw new Error("invalid port");
+        }
+        const hostOnly = hv.substring(0, colon);
+        if (String(hostOnly).trim()) {
+          try {
+            return new import_TcpConnectionData.TcpConnectionData(hostOnly, port);
+          } catch (e) {
+            return new import_InMemoryConnectionData.InMemoryConnectionData();
+          }
+        }
+      } catch (e) {
+      }
+    }
+    return new import_InMemoryConnectionData.InMemoryConnectionData();
+  }
+  /**
+   * Parse tcp address portion (after tcp://) into TcpConnectionData.
+   * Expected formats: host:port or host:port/...
+   * Throws Error on invalid format or port.
+   * @param {string} address
+   * @returns {TcpConnectionData}
+   */
+  static parseTcp(address) {
+    const slash = address.indexOf("/");
+    const hostPort = slash >= 0 ? address.substring(0, slash) : address;
+    const colon = hostPort.lastIndexOf(":");
+    if (colon <= 0 || colon >= hostPort.length - 1) {
+      throw new Error("Invalid tcp:// format.");
+    }
+    const host = hostPort.substring(0, colon);
+    const portStr = hostPort.substring(colon + 1);
+    const port = parseInt(portStr, 10);
+    if (!Number.isFinite(port) || Number.isNaN(port)) {
+      throw new Error("Invalid port in tcp:// address.");
+    }
+    return new import_TcpConnectionData.TcpConnectionData(host, port);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConfigResolver
+});