javonet-ruby-sdk 2.6.3 → 2.6.5

data/lib/javonet-ruby-sdk/Binaries/Nodejs/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
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/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
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/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
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/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
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/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
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/sdk/configuration/configResolvers/ConnectionStringConfigResolver.cjs

@@ -0,0 +1,123 @@
+"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 ConnectionStringConfigResolver_exports = {};
+__export(ConnectionStringConfigResolver_exports, {
+  ConnectionStringConfigResolver: () => ConnectionStringConfigResolver
+});
+module.exports = __toCommonJS(ConnectionStringConfigResolver_exports);
+var import_Config = require("../Config.cjs");
+var import_ConfigsDictionary = require("../ConfigsDictionary.cjs");
+var import_ActivationHelper = require("../../tools/ActivationHelper.cjs");
+var import_ConfigResolver = require("./ConfigResolver.cjs");
+class ConnectionStringConfigResolver extends import_ConfigResolver.ConfigResolver {
+  /**
+   * Parse and add multiple configuration lines from a connection string source.
+   * @param {any} priority
+   * @param {string} connectionStringSource
+   */
+  static addConfigs(priority, connectionStringSource) {
+    if (!connectionStringSource || String(connectionStringSource).trim() === "") {
+      throw new Error("Connection string source cannot be null or empty.");
+    }
+    const normalized = String(connectionStringSource).replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    const lines = normalized.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
+    for (const line of lines) {
+      if (line.startsWith("#") || line.startsWith("//")) {
+        continue;
+      }
+      if (line.toLowerCase().startsWith("licensekey")) {
+        ConnectionStringConfigResolver._setLicenseKey(line);
+        continue;
+      }
+      try {
+        const keyValues = ConnectionStringConfigResolver._parseKeyValues(line);
+        const configName = keyValues.name;
+        const runtimeValue = keyValues.runtime;
+        if (!configName || String(configName).trim() === "") {
+          throw new Error("Missing or empty config name.");
+        }
+        if (!runtimeValue || String(runtimeValue).trim() === "") {
+          throw new Error("Missing or empty runtime.");
+        }
+        const runtimeName = import_ConfigResolver.ConfigResolver.tryParseRuntime(runtimeValue);
+        const hostValue = keyValues.host;
+        const connectionData = import_ConfigResolver.ConfigResolver.buildConnectionData(hostValue);
+        const plugins = keyValues.plugins || "";
+        const modules = keyValues.modules || "";
+        const config = new import_Config.Config(runtimeName, connectionData, plugins, modules);
+        import_ConfigsDictionary.ConfigsDictionary.addConfig(configName, priority, config);
+      } catch (ex) {
+        console.log(`Failed to parse config line: '${line}'. Reason: ${ex}`);
+        throw ex;
+      }
+    }
+  }
+  /**
+   * Extract and set temporary license key from a line like "licensekey=VALUE;..."
+   * @param {string} line
+   * @private
+   */
+  static _setLicenseKey(line) {
+    const eq = line.indexOf("=");
+    if (eq > 0 && eq < line.length - 1) {
+      let valuePortion = line.substring(eq + 1).trim();
+      const semicolon = valuePortion.indexOf(";");
+      if (semicolon >= 0) {
+        valuePortion = valuePortion.substring(0, semicolon).trim();
+      }
+      const hashIdx = valuePortion.indexOf("#");
+      if (hashIdx >= 0) {
+        valuePortion = valuePortion.substring(0, hashIdx).trim();
+      }
+      const slashes = valuePortion.indexOf("//");
+      if (slashes >= 0) {
+        valuePortion = valuePortion.substring(0, slashes).trim();
+      }
+      import_ActivationHelper.ActivationHelper.setTemporaryLicenseKey(valuePortion);
+    }
+  }
+  /**
+   * Parse semicolon-separated key=value tokens into an object.
+   * Ignores malformed tokens and logs them.
+   * @param {string} line
+   * @returns {Record<string, string>}
+   * @private
+   */
+  static _parseKeyValues(line) {
+    const result = {};
+    const segments = line.split(";").map((s) => s.trim()).filter((s) => s.length > 0);
+    for (const segment of segments) {
+      const eq = segment.indexOf("=");
+      if (eq <= 0 || eq === segment.length - 1) {
+        console.log(`Ignoring malformed token '${segment}' in line: ${line}`);
+        continue;
+      }
+      const key = segment.substring(0, eq).trim().toLowerCase();
+      const value = segment.substring(eq + 1).trim();
+      if (key) {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConnectionStringConfigResolver
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/sdk/configuration/configResolvers/JsonConfigResolver.cjs

@@ -0,0 +1,125 @@
+"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 JsonConfigResolver_exports = {};
+__export(JsonConfigResolver_exports, {
+  JsonConfigResolver: () => JsonConfigResolver
+});
+module.exports = __toCommonJS(JsonConfigResolver_exports);
+var import_Config = require("../Config.cjs");
+var import_ConfigsDictionary = require("../ConfigsDictionary.cjs");
+var import_ConfigResolver = require("./ConfigResolver.cjs");
+var import_ActivationHelper = require("../../tools/ActivationHelper.cjs");
+class JsonConfigResolver extends import_ConfigResolver.ConfigResolver {
+  /**
+   * Parse and add configurations from a JSON object.
+   * @param {any} priority
+   * @param {Record<string, unknown>} jsonObject
+   */
+  static addConfigs(priority, jsonObject) {
+    if (jsonObject == null) {
+      throw new Error("json_object cannot be None");
+    }
+    if (typeof jsonObject !== "object" || Array.isArray(jsonObject)) {
+      throw new Error("Root JSON element must be a dict/object.");
+    }
+    const licenseKey = (
+      /** @type {Record<string, unknown>} */
+      jsonObject.licenseKey
+    );
+    if (typeof licenseKey === "string") {
+      import_ActivationHelper.ActivationHelper.setTemporaryLicenseKey(licenseKey.trim());
+    }
+    const configs = (
+      /** @type {Record<string, unknown>} */
+      jsonObject.configurations
+    );
+    if (typeof configs !== "object" || configs == null || Array.isArray(configs)) {
+      throw new Error("JSON must contain 'configurations' object.");
+    }
+    for (const [configName, cfg] of Object.entries(
+      /** @type {Record<string, unknown>} */
+      configs
+    )) {
+      try {
+        if (typeof cfg !== "object" || cfg == null || Array.isArray(cfg)) {
+          throw new Error("Configuration value must be an object/dict.");
+        }
+        const runtimeValue = JsonConfigResolver._getRequiredString(
+          /** @type {Record<string, unknown>} */
+          cfg,
+          "runtime"
+        );
+        const runtimeName = import_ConfigResolver.ConfigResolver.tryParseRuntime(runtimeValue);
+        const host = JsonConfigResolver._getOptionalString(
+          /** @type {Record<string, unknown>} */
+          cfg,
+          "host"
+        );
+        const connectionData = import_ConfigResolver.ConfigResolver.buildConnectionData(host);
+        const plugins = JsonConfigResolver._getOptionalString(
+          /** @type {Record<string, unknown>} */
+          cfg,
+          "plugins"
+        );
+        const modules = JsonConfigResolver._getOptionalString(
+          /** @type {Record<string, unknown>} */
+          cfg,
+          "modules"
+        );
+        const config = new import_Config.Config(runtimeName, connectionData, plugins, modules);
+        import_ConfigsDictionary.ConfigsDictionary.addConfig(configName, priority, config);
+      } catch (ex) {
+        console.log(`Failed to add config '${configName}': ${ex}`);
+      }
+    }
+  }
+  /**
+   * Get a required string property from an object, trimmed.
+   * Throws if missing or empty.
+   * @param {Record<string, unknown>} obj
+   * @param {string} property
+   * @returns {string}
+   * @private
+   */
+  static _getRequiredString(obj, property) {
+    const value = obj[property];
+    if (typeof value !== "string" || value.trim() === "") {
+      throw new Error(`Missing or invalid '${property}' property.`);
+    }
+    return value.trim();
+  }
+  /**
+   * Get an optional string property; return empty string when missing or not a string.
+   * @param {Record<string, unknown>} obj
+   * @param {string} property
+   * @returns {string}
+   * @private
+   */
+  static _getOptionalString(obj, property) {
+    const value = obj[property];
+    if (typeof value === "string") {
+      return value;
+    }
+    return "";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JsonConfigResolver
+});