javonet-ruby-sdk 2.5.17 → 2.5.18

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

@@ -29,15 +29,29 @@ var import_CommandType = require("../utils/CommandType.cjs");
 var import_ConnectionType = require("../utils/ConnectionType.cjs");
 var import_ExceptionThrower = require("../utils/exception/ExceptionThrower.cjs");
 var import_RuntimeName = require("../utils/RuntimeName.cjs");
+var import_TypesHandler = require("../utils/TypesHandler.cjs");
 class InvocationContext {
+  /** @type {RuntimeNameType} */
   #runtimeName;
+  /** @type {IConnectionData} */
   #connectionData;
-  #currentCommand;
-  #responseCommand;
-  #interpreter;
-  // eslint-disable-next-line no-unused-private-class-members
-  #isExecuted;
-  #resultValue;
+  /** @type {Command | null} */
+  #currentCommand = null;
+  /** @type {Command | null} */
+  #responseCommand = null;
+  /** @type {boolean} */
+  #isExecuted = false;
+  /** @type {any | null} */
+  #resultValue = null;
+  /** @type {Interpreter | null} */
+  #interpreter = null;
+  /**
+   *
+   * @param {RuntimeNameType} runtimeName
+   * @param {IConnectionData} connectionData
+   * @param {Command} command
+   * @param {boolean} isExecuted
+   */
   constructor(runtimeName, connectionData, command, isExecuted = false) {
     this.#runtimeName = runtimeName;
     this.#connectionData = connectionData;
@@ -47,6 +61,10 @@ class InvocationContext {
     this.#interpreter = null;
     this.#resultValue = null;
   }
+  /**
+   * @param {Command} localCommand
+   * @returns {InvocationContext}
+   */
   #createInstanceContext(localCommand) {
     if (this.#connectionData.connectionType === import_ConnectionType.ConnectionType.WEB_SOCKET) {
       return new InvocationWsContext(
@@ -61,6 +79,9 @@ class InvocationContext {
       this.#buildCommand(localCommand)
     );
   }
+  /**
+   * @returns {Command|null}
+   */
   get_current_command() {
     return this.#currentCommand;
   }
@@ -74,12 +95,12 @@ class InvocationContext {
   //        this.execute();
   //    }
   //}
-  [Symbol.iterator] = function() {
-    if (this.#currentCommand.commandType !== import_CommandType.CommandType.Reference) {
+  [Symbol.iterator] = () => {
+    if (this.#currentCommand?.commandType !== import_CommandType.CommandType.Reference) {
       throw new Error("Object is not iterable");
     }
     let position = -1;
-    let arraySize = this.getSize().execute().getValue();
+    const arraySize = Number(this.getSize().execute().getValue());
     return {
       next: () => ({
         value: this.getIndex(++position),
@@ -99,15 +120,18 @@ class InvocationContext {
    * @method
    */
   execute() {
+    if (this.#currentCommand === null) {
+      throw new Error("currentCommand is undefined in Invocation Context execute method");
+    }
     this.#interpreter = new import_Interpreter.Interpreter();
     this.#responseCommand = this.#interpreter.execute(this.#currentCommand, this.#connectionData);
-    if (this.#responseCommand === void 0) {
+    if (!this.#responseCommand) {
       throw new Error("responseCommand is undefined in Invocation Context execute method");
     }
-    if (this.#responseCommand.commandType === import_CommandType.CommandType.Exception) {
+    if (this.#responseCommand?.commandType === import_CommandType.CommandType.Exception) {
       throw import_ExceptionThrower.ExceptionThrower.throwException(this.#responseCommand);
     }
-    if (this.#responseCommand.commandType === import_CommandType.CommandType.CreateClassInstance) {
+    if (this.#responseCommand?.commandType === import_CommandType.CommandType.CreateClassInstance) {
       this.#currentCommand = this.#responseCommand;
       this.#isExecuted = true;
       return this;
@@ -335,7 +359,7 @@ class InvocationContext {
    * Creates a null object of a specific type on the target runtime.
    * @param {string} methodName - The name of the method to invoke.
    * @param {...any} args - Method arguments.
-   * @returns {InvocationContext} An InvocationContext instance with the command to create a null object.
+   * @returns {InvocationContext|InvocationWsContext} An InvocationContext instance with the command to create a null object.
    * TODO: connect documentation page url
    * @see [Javonet Guides](https://www.javonet.com/guides/)
    * @method
@@ -361,6 +385,9 @@ class InvocationContext {
       this.#buildCommand(localCommand)
     );
     localInvCtx.execute();
+    if (localInvCtx.#responseCommand === null) {
+      throw new Error("responseCommand is undefined in Invocation Context execute method");
+    }
     return localInvCtx.#responseCommand.payload;
   }
   /**
@@ -370,17 +397,28 @@ class InvocationContext {
    * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/execute-method)
    * @method
    */
+  /**
+   * @returns {unknown}
+   */
   getValue() {
-    this.#resultValue = this.#currentCommand.payload[0];
+    this.#resultValue = this.#currentCommand?.payload[0];
     return this.#resultValue;
   }
-  #buildCommand = function(command) {
+  /**
+   * @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);
-  };
-  #encapsulatePayloadItem = function(payloadItem) {
+  }
+  /**
+   * @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]);
@@ -390,7 +428,7 @@ class InvocationContext {
       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);
+      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++) {
@@ -400,21 +438,36 @@ class InvocationContext {
         ...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 {
-      return new import_Command.Command(this.runtimeName, import_CommandType.CommandType.Value, [payloadItem]);
+      throw Error(
+        "Unsupported payload item type: " + (payloadItem?.constructor?.name || typeof payloadItem) + " for payload item: " + payloadItem
+      );
     }
-  };
+  }
 }
 class InvocationWsContext extends InvocationContext {
+  /** @type {RuntimeNameType} */
   #runtimeName;
+  /** @type {IConnectionData} */
   #connectionData;
+  /** @type {Command | null} */
   #currentCommand;
+  /** @type {Command | null} */
   #responseCommand;
+  /** @type {Interpreter | null} */
   #interpreter;
-  // eslint-disable-next-line no-unused-private-class-members
+  /** @type {boolean} */
   #isExecuted;
-  // eslint-disable-next-line no-unused-private-class-members
+  /** @type {any | null} */
   #resultValue;
+  /**
+   * @param {RuntimeNameType} runtimeName
+   * @param {IConnectionData} connectionData
+   * @param {Command} command
+   * @param {boolean} isExecuted
+   */
   constructor(runtimeName, connectionData, command, isExecuted = false) {
     super(runtimeName, connectionData, command, isExecuted);
     this.#runtimeName = runtimeName;
@@ -432,11 +485,16 @@ class InvocationWsContext extends 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<InvocationWsContext>} the InvocationContext after executing the command.
    * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/execute-method)
+   * @async
    * @method
    */
+  // @ts-expect-error
   async execute() {
+    if (this.#currentCommand === null) {
+      throw new Error("currentCommand is undefined in Invocation Context execute method");
+    }
     this.#interpreter = new import_Interpreter.Interpreter();
     this.#responseCommand = await this.#interpreter.executeAsync(
       this.#currentCommand,

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

@@ -34,6 +34,8 @@ 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");
 const import_meta = {};
 const requireDynamic = (0, import_Runtime.getRequire)(import_meta.url);
 let _Transmitter = null;
@@ -75,26 +77,26 @@ class Javonet {
   /**
    * Initializes Javonet with a custom configuration file taken from external source.
    * Currentyl supported: Configuration file in JSON format
-   * @param config - Path to a configuration file.
+   * @param {string|ConfigSource} config - Path to a configuration file.
    * @returns {ConfigRuntimeFactory} A ConfigRuntimeFactory instance with configuration data.
    * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/configure-channel)
    */
   static withConfig(config) {
-    return new import_ConfigRuntimeFactory.ConfigRuntimeFactory(config, _Transmitter);
+    return new import_ConfigRuntimeFactory.ConfigRuntimeFactory(config);
   }
   /**
    * Activates Javonet with the provided license key.
    * @param {string} licenseKey - The license key to activate Javonet.
-   * @returns {number} The activation status code.
+   * @returns {void} The activation status code.
    * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/getting-started/activating-javonet)
    */
   static activate(licenseKey) {
-    if ((0, import_Runtime.isNodejsRuntime)()) {
-      return _Transmitter?.activate(licenseKey);
-    } else {
-      throw new Error("Javonet.activate is allowed only to run in nodejs runtime");
-    }
+    import_UtilsConst.UtilsConst.setLicenseKey(licenseKey);
   }
+  /**
+   * Gets the runtime information.
+   * @returns {string} The runtime information.
+   */
   static getRuntimeInfo() {
     if ((0, import_Runtime.isNodejsRuntime)()) {
       return import_RuntimeLogger.RuntimeLogger.getRuntimeInfo();
@@ -104,40 +106,19 @@ class Javonet {
   }
   /**
    * Sets the configuration source for the Javonet SDK.
-   *
    * @param {string} configSource - The configuration source.
+   * @returns {void}
    */
   static setConfigSource(configSource) {
-    if ((0, import_Runtime.isNodejsRuntime)()) {
-      return _Transmitter?.setConfigSource(configSource);
-    } else {
-      throw new Error("Javonet.setConfigSource is allowed only to run in nodejs runtime");
-    }
+    import_UtilsConst.UtilsConst.setConfigSource(configSource);
   }
   /**
    * Sets the working directory for the Javonet SDK.
-   *
    * @param {string} path - The working directory.
+   * @returns {void}
    */
   static setJavonetWorkingDirectory(path) {
-    try {
-      if ((0, import_Runtime.isNodejsRuntime)()) {
-        const { mkdirSync } = requireDynamic("fs");
-        path = path.replace(/\\/g, "/");
-        if (!path.endsWith("/")) {
-          path += "/";
-        }
-        mkdirSync(path, { recursive: true, mode: 448 });
-        _Transmitter?.setJavonetWorkingDirectory(path);
-      } else {
-        throw new Error("Javonet.setJavonetWorkingDirectory is allowed only to run in nodejs runtime");
-      }
-    } catch (error) {
-      if (error.code === "MODULE_NOT_FOUND") {
-        throw new Error("fs module not found. Please install it using npm install fs");
-      }
-      throw error;
-    }
+    import_UtilsConst.UtilsConst.setJavonetWorkingDirectory(path);
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -29,53 +29,92 @@ var import_ExceptionThrower = require("../utils/exception/ExceptionThrower.cjs")
 var import_RuntimeName = require("../utils/RuntimeName.cjs");
 var import_Interpreter = require("../core/interpreter/Interpreter.cjs");
 var import_DelegatesCache = require("../core/delegatesCache/DelegatesCache.cjs");
+var import_TypesHandler = require("../utils/TypesHandler.cjs");
+var import_UtilsConst = require("../utils/UtilsConst.cjs");
+var import_Runtime = require("../utils/Runtime.cjs");
+const import_meta = {};
+let _Transmitter = null;
+const requireDynamic = (0, import_Runtime.getRequire)(import_meta.url);
 class RuntimeContext {
+  /** @type {Map<string, RuntimeContext>} */
   static memoryRuntimeContexts = /* @__PURE__ */ new Map();
+  /** @type {Map<string, RuntimeContext>} */
   static networkRuntimeContexts = /* @__PURE__ */ new Map();
+  /** @type {Map<string, RuntimeContext>} */
   static webSocketRuntimeContexts = /* @__PURE__ */ new Map();
-  #currentCommand;
-  #responseCommand;
-  #interpreter;
+  /** @type {Command | null} */
+  #currentCommand = null;
+  /** @type {Command | null} */
+  #responseCommand = null;
+  /** @type {Interpreter | null} */
+  #interpreter = null;
+  /**
+   * @param {RuntimeNameType} runtimeName
+   * @param {IConnectionData} connectionData
+   */
   constructor(runtimeName, connectionData) {
+    this._isExecuted = false;
     this.runtimeName = runtimeName;
     this.connectionData = connectionData;
-    this.#currentCommand = null;
-    this.#responseCommand = null;
     this.#interpreter = new import_Interpreter.Interpreter();
+    if (this.connectionData.connectionType === import_ConnectionType.ConnectionType.WEB_SOCKET) {
+      return;
+    }
+    if (this.runtimeName === import_RuntimeName.RuntimeName.Nodejs && this.connectionData.connectionType === import_ConnectionType.ConnectionType.IN_MEMORY) {
+      return;
+    }
+    _Transmitter?.setJavonetWorkingDirectory(import_UtilsConst.UtilsConst.getJavonetWorkingDirectory());
+    if (import_UtilsConst.UtilsConst.getConfigSource() !== "") {
+      _Transmitter?.setConfigSource(import_UtilsConst.UtilsConst.getConfigSource());
+    }
+    _Transmitter?.activate(import_UtilsConst.UtilsConst.getLicenseKey());
   }
+  /**
+   * @param {RuntimeNameType} runtimeName
+   * @param {IConnectionData} connectionData
+   * @returns {RuntimeContext}
+   */
   static getInstance(runtimeName, connectionData) {
+    if (!_Transmitter) {
+      const { Transmitter } = require("../core/transmitter/Transmitter.cjs");
+      _Transmitter = Transmitter;
+    }
     switch (connectionData.connectionType) {
       case import_ConnectionType.ConnectionType.IN_MEMORY:
-        if (runtimeName in RuntimeContext.memoryRuntimeContexts) {
-          let runtimeCtx = RuntimeContext.memoryRuntimeContexts[runtimeName];
-          runtimeCtx.currentCommand = null;
+        const key = String(runtimeName);
+        if (RuntimeContext.memoryRuntimeContexts.has(key)) {
+          const runtimeCtx = RuntimeContext.memoryRuntimeContexts.get(key);
+          if (!runtimeCtx) throw new Error("Runtime context not found");
+          runtimeCtx.#currentCommand = null;
           return runtimeCtx;
         } else {
-          let runtimeCtx = new RuntimeContext(runtimeName, connectionData);
-          RuntimeContext.memoryRuntimeContexts[runtimeName] = runtimeCtx;
+          const runtimeCtx = new RuntimeContext(runtimeName, connectionData);
+          RuntimeContext.memoryRuntimeContexts.set(key, runtimeCtx);
           return runtimeCtx;
         }
       case import_ConnectionType.ConnectionType.TCP: {
-        let key1 = runtimeName + JSON.stringify(connectionData);
-        if (key1 in RuntimeContext.networkRuntimeContexts) {
-          let runtimeCtx = RuntimeContext.networkRuntimeContexts[key1];
-          runtimeCtx.currentCommand = null;
+        const key1 = String(runtimeName) + JSON.stringify(connectionData);
+        if (RuntimeContext.networkRuntimeContexts.has(key1)) {
+          const runtimeCtx = RuntimeContext.networkRuntimeContexts.get(key1);
+          if (!runtimeCtx) throw new Error("Runtime context not found");
+          runtimeCtx.#currentCommand = null;
           return runtimeCtx;
         } else {
-          let runtimeCtx = new RuntimeContext(runtimeName, connectionData);
-          RuntimeContext.networkRuntimeContexts[key1] = runtimeCtx;
+          const runtimeCtx = new RuntimeContext(runtimeName, connectionData);
+          RuntimeContext.networkRuntimeContexts.set(key1, runtimeCtx);
           return runtimeCtx;
         }
       }
       case import_ConnectionType.ConnectionType.WEB_SOCKET: {
-        let key2 = runtimeName + JSON.stringify(connectionData);
-        if (key2 in RuntimeContext.webSocketRuntimeContexts) {
-          let runtimeCtx = RuntimeContext.webSocketRuntimeContexts[key2];
-          runtimeCtx.currentCommand = null;
+        const key2 = String(runtimeName) + JSON.stringify(connectionData);
+        if (RuntimeContext.webSocketRuntimeContexts.has(key2)) {
+          const runtimeCtx = RuntimeContext.webSocketRuntimeContexts.get(key2);
+          if (!runtimeCtx) throw new Error("Runtime context not found");
+          runtimeCtx.#currentCommand = null;
           return runtimeCtx;
         } else {
-          let runtimeCtx = new RuntimeContext(runtimeName, connectionData);
-          RuntimeContext.webSocketRuntimeContexts[key2] = runtimeCtx;
+          const runtimeCtx = new RuntimeContext(runtimeName, connectionData);
+          RuntimeContext.webSocketRuntimeContexts.set(key2, runtimeCtx);
           return runtimeCtx;
         }
       }
@@ -93,12 +132,12 @@ class RuntimeContext {
    * @method
    */
   execute() {
-    this.#responseCommand = this.#interpreter.execute(this.#currentCommand, this.connectionData);
+    this.#responseCommand = this.#interpreter?.execute(this.#currentCommand, this.connectionData);
     this.#currentCommand = null;
     if (this.#responseCommand === void 0) {
       throw new Error("responseCommand is undefined in Runtime Context execute method");
     }
-    if (this.#responseCommand.commandType === import_CommandType.CommandType.Exception) {
+    if (this.#responseCommand?.commandType === import_CommandType.CommandType.Exception) {
       throw import_ExceptionThrower.ExceptionThrower.throwException(this.#responseCommand);
     }
   }
@@ -246,20 +285,32 @@ class RuntimeContext {
     }
     return new import_InvocationContext.InvocationContext(this.runtimeName, this.connectionData, this.#buildCommand(localCommand));
   }
-  #buildCommand = function(command) {
+  /**
+   * @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);
-  };
-  #encapsulatePayloadItem = function(payloadItem) {
+  }
+  /**
+   * @param {unknown} payloadItem
+   * @returns {Command}
+   */
+  #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 import_InvocationContext.InvocationContext) {
-      return payloadItem.get_current_command();
+      const command = payloadItem?.get_current_command();
+      if (!command) {
+        throw new Error("Command not found");
+      }
+      return 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);
@@ -272,10 +323,14 @@ class RuntimeContext {
         ...newArray
       );
       return new import_Command.Command(this.runtimeName, import_CommandType.CommandType.PassDelegate, args);
-    } else {
+    } 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
+      );
     }
-  };
+  }
   healthCheck() {
     let localCommand = new import_Command.Command(this.runtimeName, import_CommandType.CommandType.Value, ["health_check"]);
     this.#currentCommand = this.#buildCommand(localCommand);

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

@@ -24,6 +24,9 @@ module.exports = __toCommonJS(RuntimeFactory_exports);
 var import_RuntimeName = require("../utils/RuntimeName.cjs");
 var import_RuntimeContext = require("./RuntimeContext.cjs");
 class RuntimeFactory {
+  /**
+   * @param {IConnectionData} connectionData 
+   */
   constructor(connectionData) {
     this.connectionData = connectionData;
   }

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

@@ -0,0 +1,66 @@
+"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 ActivationHelper_exports = {};
+__export(ActivationHelper_exports, {
+  ActivationHelper: () => ActivationHelper
+});
+module.exports = __toCommonJS(ActivationHelper_exports);
+var import_Runtime = require("../../utils/Runtime.cjs");
+class ActivationHelper {
+  /** @type {string} */
+  static temporaryLicenseKey = "License key not set";
+  /**
+   * @param {string} value
+   */
+  static setTemporaryLicenseKey(value) {
+    if (!value || value === "your-license-key") {
+      return;
+    }
+    ActivationHelper.temporaryLicenseKey = value;
+  }
+  /**
+   * @returns {string}
+   */
+  static getTemporaryLicenseKey() {
+    return ActivationHelper.temporaryLicenseKey;
+  }
+  /**
+   * @returns {Promise<string>}
+   */
+  static async getLicenseKey() {
+    try {
+      return ActivationHelper._getLicenseKeyFromFile();
+    } catch {
+      return ActivationHelper.temporaryLicenseKey;
+    }
+  }
+  /**
+   * @returns {string}
+   */
+  static _getLicenseKeyFromFile() {
+    if (!(0, import_Runtime.isBrowserRuntime)()) {
+      throw new Error("ActivationHelper is not supported in the browser runtime.");
+    }
+    return "";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ActivationHelper
+});