javonet-nodejs-sdk 2.5.17 → 2.5.18

package/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
+});

package/dist/sdk/tools/JsonResolver.cjs

@@ -0,0 +1,214 @@
+"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 JsonResolver_exports = {};
+__export(JsonResolver_exports, {
+  JsonResolver: () => JsonResolver
+});
+module.exports = __toCommonJS(JsonResolver_exports);
+var import_Runtime = require("../../utils/Runtime.cjs");
+const import_meta = {};
+function isValidObject(param) {
+  return typeof param === "object" && param !== null && !Array.isArray(param);
+}
+function isValidJson(param) {
+  try {
+    if (typeof param === "string") {
+      const parsed = JSON.parse(param);
+      return typeof parsed === "object" && parsed !== null;
+    }
+    return false;
+  } catch (e) {
+    return false;
+  }
+}
+const requireDynamic = (0, import_Runtime.getRequire)(import_meta.url);
+let fs = null;
+class JsonResolver {
+  /** @type {ConfigSource} */
+  jsonObject;
+  /** @type {string | ConfigSource} */
+  configSource;
+  /**
+   * @param {string | ConfigSource} configSource
+   */
+  constructor(configSource) {
+    this.configSource = JSON.stringify(configSource);
+    this.jsonObject = this._getJsonObject(configSource);
+  }
+  /**
+   * @returns {Partial<Runtimes>}
+   */
+  get runtimes() {
+    return this.jsonObject?.runtimes || {};
+  }
+  /**
+   * @returns {string}
+   */
+  get licenseKey() {
+    return this.jsonObject?.licenseKey || "your-license-key";
+  }
+  /**
+   * @returns {string}
+   */
+  get workingDirectory() {
+    return this.jsonObject?.workingDirectory || "";
+  }
+  /**
+   * @returns {string}
+   */
+  getLicenseKey() {
+    if (!this.licenseKey) {
+      throw new Error("License key not found in configuration source. Check your configuration source.");
+    }
+    return this.licenseKey;
+  }
+  /**
+   * @returns {string}
+   */
+  getWorkingDirectory() {
+    return this.workingDirectory;
+  }
+  /**
+   * @param {RuntimeType} runtimeName
+   * @param {string} configName
+   * @returns {RuntimeChannelType}
+   */
+  getChannelType(runtimeName, configName) {
+    const channel = this._getChannel(runtimeName, configName);
+    return channel.type;
+  }
+  /**
+   * @param {RuntimeType} runtimeName
+   * @param {string} configName
+   * @returns {string}
+   */
+  getChannelHost(runtimeName, configName) {
+    const channel = this._getChannel(runtimeName, configName);
+    if (channel.host === void 0) {
+      throw new Error(`Host not found for channel in runtime ${runtimeName}, config ${configName}`);
+    }
+    return channel.host;
+  }
+  /**
+   * @param {RuntimeType} runtimeName
+   * @param {string} configName
+   * @returns {number|string}
+   */
+  getChannelPort(runtimeName, configName) {
+    const channel = this._getChannel(runtimeName, configName);
+    if (channel.port === void 0) {
+      throw new Error(`Port not found for channel in runtime ${runtimeName}, config ${configName}`);
+    }
+    return channel.port;
+  }
+  /**
+   * @param {RuntimeType} runtimeName
+   * @param {string} configName
+   * @returns {string}
+   */
+  getModules(runtimeName, configName) {
+    const runtime = this._getRuntime(runtimeName, configName);
+    return runtime.modules || "";
+  }
+  /**
+   * @private
+   * @param {string | ConfigSource} configSource
+   * @returns {ConfigSource}
+   */
+  _getJsonObject(configSource) {
+    if (isValidObject(configSource)) {
+      return (
+        /** @type {ConfigSource} */
+        configSource
+      );
+    }
+    if (typeof configSource === "string" && isValidJson(configSource)) {
+      const parsedJson = JSON.parse(configSource);
+      if (isValidObject(parsedJson)) {
+        return parsedJson;
+      }
+    }
+    if ((0, import_Runtime.isNodejsRuntime)()) {
+      if (!fs) {
+        fs = requireDynamic("fs");
+      }
+      if (fs?.existsSync(configSource)) {
+        const jsonText = fs.readFileSync(configSource, "utf8");
+        if (isValidJson(jsonText)) {
+          const parsedFromFile = JSON.parse(jsonText);
+          if (isValidObject(parsedFromFile)) {
+            return parsedFromFile;
+          }
+        }
+      }
+    }
+    throw new Error(
+      `Configuration source is not valid. Check your configuration:${String(this.configSource)}`
+    );
+  }
+  /**
+   * @private
+   * @param {RuntimeType} runtimeName
+   * @param {string} configName
+   * @returns {Runtime}
+   */
+  _getRuntime(runtimeName, configName) {
+    const runtimeList = this.runtimes[runtimeName];
+    if (Array.isArray(runtimeList)) {
+      const runtime = runtimeList.find((item) => item.name === configName);
+      if (runtime) {
+        return runtime;
+      }
+    } else if (typeof runtimeList?.name === "string" && runtimeList?.name === configName) {
+      return runtimeList;
+    }
+    throw new Error(
+      `Runtime config '${configName}' not found in configuration source for runtime '${runtimeName}'. Check your configuration source.`
+    );
+  }
+  /**
+   * @private
+   * @param {RuntimeType} runtimeName
+   * @param {string} configName
+   * @returns {string}
+   */
+  _getRuntimeName(runtimeName, configName) {
+    const runtime = this._getRuntime(runtimeName, configName);
+    return runtime.name;
+  }
+  /**
+   * @private
+   * @param {RuntimeType} runtimeName
+   * @param {string} configName
+   * @returns {RuntimeChannel}
+   */
+  _getChannel(runtimeName, configName) {
+    const runtime = this._getRuntime(runtimeName, configName);
+    if (!runtime.channel) {
+      throw new Error(
+        `Channel not found for runtime config '${configName}' and runtime '${runtimeName}'. Check your configuration source.`
+      );
+    }
+    return runtime.channel;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JsonResolver
+});

package/dist/types/core/handler/AbstractHandler.d.ts

@@ -1,7 +1,26 @@
 export class AbstractHandler {
-    handlers: any[];
-    process(command: any): void;
-    handleCommand(command: any): void;
-    iterate(cmd: any): void;
+    /**
+     * @type {Record<number, AbstractHandler>}
+     */
+    handlers: Record<number, AbstractHandler>;
+    /**
+     * @param {Command} command
+     */
+    process(command: Command): void;
+    /**
+     * @param {Command} command
+     */
+    handleCommand(command: Command): void;
+    /**
+     * @param {Command} command
+     */
+    iterate(command: Command): void;
+    /**
+     *
+     * @param {*} error
+     * @param {*} class_name
+     * @returns
+     */
     process_stack_trace(error: any, class_name: any): any;
 }
+import { Command } from '../../utils/Command.js';

package/dist/types/core/handler/ArrayGetItemHandler.d.ts

@@ -1,5 +1,12 @@
+export type Command = import("../../utils/Command.js").Command;
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
 export class ArrayGetItemHandler extends AbstractHandler {
     requiredParametersCount: number;
-    process(command: any): any;
+    /**
+     * @param {Command} command
+     */
+    process(command: Command): any;
 }
 import { AbstractHandler } from './AbstractHandler.js';

package/dist/types/core/handler/ArrayGetRankHandler.d.ts

@@ -1,5 +1,12 @@
+export type Command = import("../../utils/Command.js").Command;
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
 export class ArrayGetRankHandler extends AbstractHandler {
     requiredParametersCount: number;
-    process(command: any): number;
+    /**
+     * @param {Command} command
+     */
+    process(command: Command): number;
 }
 import { AbstractHandler } from './AbstractHandler.js';

package/dist/types/core/handler/ArrayGetSizeHandler.d.ts

@@ -1,5 +1,12 @@
+export type Command = import("../../utils/Command.js").Command;
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
 export class ArrayGetSizeHandler extends AbstractHandler {
     requiredParametersCount: number;
-    process(command: any): number;
+    /**
+     * @param {Command} command
+     */
+    process(command: Command): number;
 }
 import { AbstractHandler } from './AbstractHandler.js';

package/dist/types/core/handler/ArrayHandler.d.ts

@@ -1,4 +1,11 @@
+export type Command = import("../../utils/Command.js").Command;
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
 export class ArrayHandler extends AbstractHandler {
-    process(command: any): any;
+    /**
+     * @param {Command} command
+     */
+    process(command: Command): any;
 }
 import { AbstractHandler } from './AbstractHandler.js';

package/dist/types/core/handler/ArraySetItemHandler.d.ts

@@ -1,5 +1,12 @@
+export type Command = import("../../utils/Command.js").Command;
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
 export class ArraySetItemHandler extends AbstractHandler {
     requiredParametersCount: number;
-    process(command: any): number;
+    /**
+     * @param {Command} command
+     */
+    process(command: Command): number;
 }
 import { AbstractHandler } from './AbstractHandler.js';

package/dist/types/core/handler/CastingHandler.d.ts

@@ -1,3 +1,7 @@
+export type Command = import("../../utils/Command.js").Command;
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
 export class CastingHandler extends AbstractHandler {
 }
 import { AbstractHandler } from './AbstractHandler.js';

package/dist/types/core/handler/ConvertTypeHandler.d.ts

@@ -1,3 +1,7 @@
+export type Command = import("../../utils/Command.js").Command;
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
 /**
  * ConvertTypeHandler class handles the conversion of JType to Type.
  */
@@ -9,14 +13,14 @@ export class ConvertTypeHandler extends AbstractHandler {
     requiredParametersCount: number;
     /**
      * Processes the given command to convert JType to Type.
-     * @param {Object} command - The command to process.
+     * @param {Command} command - The command to process.
      * @returns {any} The converted type.
      */
-    process(command: Object): any;
+    process(command: Command): any;
     /**
      * Validates the command to ensure it has enough parameters.
-     * @param {Object} command - The command to validate.
+     * @param {Command} command - The command to validate.
      */
-    validateCommand(command: Object): void;
+    validateCommand(command: Command): void;
 }
 import { AbstractHandler } from './AbstractHandler.js';

package/dist/types/core/handler/CreateClassInstanceHandler.d.ts

@@ -1,5 +1,12 @@
+export type Command = import("../../utils/Command.js").Command;
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
 export class CreateClassInstanceHandler extends AbstractHandler {
     requiredParametersCount: number;
-    process(command: any): any;
+    /**
+     * @param {Command} command
+     */
+    process(command: Command): any;
 }
 import { AbstractHandler } from './AbstractHandler.js';

package/dist/types/core/handler/DestructReferenceHandler.d.ts

@@ -1,4 +1,11 @@
+export type Command = import("../../utils/Command.js").Command;
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
 export class DestructReferenceHandler extends AbstractHandler {
-    process(command: any): number;
+    /**
+     * @param {Command} command
+     */
+    process(command: Command): number;
 }
 import { AbstractHandler } from './AbstractHandler.js';

package/dist/types/core/handler/EnableNamespaceHandler.d.ts

@@ -1,5 +1,12 @@
+export type Command = import("../../utils/Command.js").Command;
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
 export class EnableNamespaceHandler extends AbstractHandler {
     requiredParametersCount: number;
-    process(command: any): number;
+    /**
+     * @param {Command} command
+     */
+    process(command: Command): number;
 }
 import { AbstractHandler } from './AbstractHandler.js';

package/dist/types/core/handler/EnableTypeHandler.d.ts

@@ -1,5 +1,12 @@
+export type Command = import("../../utils/Command.js").Command;
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
 export class EnableTypeHandler extends AbstractHandler {
     requiredParametersCount: number;
-    process(command: any): number;
+    /**
+     * @param {Command} command
+     */
+    process(command: Command): number;
 }
 import { AbstractHandler } from './AbstractHandler.js';

package/dist/types/core/handler/GetGlobalStaticFieldHandler.d.ts

@@ -1,5 +1,12 @@
+export type Command = import("../../utils/Command.js").Command;
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
 export class GetGlobalStaticFieldHandler extends AbstractHandler {
     requiredParametersCount: number;
-    process(command: any): any;
+    /**
+     * @param {Command} command
+     */
+    process(command: Command): any;
 }
 import { AbstractHandler } from './AbstractHandler.js';

package/dist/types/core/handler/GetInstanceFieldHandler.d.ts

@@ -1,5 +1,12 @@
+export type Command = import("../../utils/Command.js").Command;
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
 export class GetInstanceFieldHandler extends AbstractHandler {
     requiredParametersCount: number;
-    process(command: any): any;
+    /**
+     * @param {Command} command
+     */
+    process(command: Command): any;
 }
 import { AbstractHandler } from './AbstractHandler.js';

package/dist/types/core/handler/GetStaticFieldHandler.d.ts

@@ -1,5 +1,13 @@
+export type Command = import("../../utils/Command.js").Command;
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
 export class GetStaticFieldHandler extends AbstractHandler {
     requiredParametersCount: number;
-    process(command: any): any;
+    /**
+     * @param {Command} command
+     * @returns {any}
+     */
+    process(command: Command): any;
 }
 import { AbstractHandler } from './AbstractHandler.js';

package/dist/types/core/handler/GetStaticMethodAsDelegateHandler.d.ts

@@ -1,3 +1,7 @@
+export type Command = import("../../utils/Command.js").Command;
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
 /**
  * Handles retrieving a static method as a delegate.
  */
@@ -11,7 +15,6 @@ export class GetStaticMethodAsDelegateHandler extends AbstractHandler {
     /**
      * Processes a command to retrieve a static method as a delegate.
      * @param {Command} command - The command containing payload data.
-     * @param {Array<*>} command.payload - The payload containing type, method name, and arguments.
      * @returns {Function} The delegate for the static method.
      * @throws {Error} If the parameters mismatch or the method cannot be found.
      */
@@ -20,8 +23,6 @@ export class GetStaticMethodAsDelegateHandler extends AbstractHandler {
      * Retrieves the method from the type.
      * @param {Object} type - The class or constructor to search for the method.
      * @param {string} methodName - The name of the method.
-     * @param {Array<Function>} argsType - The argument types.
-     * @param {Object} modifier - Parameter modifier (not used in JS implementation).
      * @returns {Function|null} The found method or null if not found.
      */
     getMethod(type: Object, methodName: string): Function | null;

package/dist/types/core/handler/GetTypeHandler.d.ts

@@ -1,14 +1,23 @@
+export type Command = import("../../utils/Command.js").Command;
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
 export class GetTypeHandler extends AbstractHandler {
     /** @type {number} */
     requiredParametersCount: number;
-    /** @type {NamespaceCache | null} */
-    namespaceCache: NamespaceCache | null;
-    /** @type {TypeCache | null} */
-    typeCache: TypeCache | null;
-    /** @type {LoadLibraryHandler | null} */
-    loadLibaryHandler: LoadLibraryHandler | null;
-    process(command: any): any;
-    getAvailableTypes(): any[];
+    /** @type {NamespaceCache} */
+    namespaceCache: NamespaceCache;
+    /** @type {TypeCache} */
+    typeCache: TypeCache;
+    /** @type {LoadLibraryHandler} */
+    loadLibaryHandler: LoadLibraryHandler;
+    /**
+     *
+     * @param {Command} command
+     * @returns
+     */
+    process(command: Command): any;
+    getAvailableTypes(): string[];
 }
 import { AbstractHandler } from './AbstractHandler.js';
 import { NamespaceCache } from '../namespaceCache/NamespaceCache.js';

package/dist/types/core/handler/Handler.d.ts

@@ -1,3 +1,4 @@
+export type RuntimeName = import("../../types.d.ts").RuntimeName;
 export class Handler {
     /**
      * @param {import('../interpreter/Interpreter.js').Interpreter} interpreter
@@ -5,20 +6,19 @@ export class Handler {
     constructor(interpreter: import("../interpreter/Interpreter.js").Interpreter);
     interpreter: import("../interpreter/Interpreter.js").Interpreter;
     /**
-     * @param {{ commandType: number; payload: any[]; runtimeName: number; }} command
+     * @param {Command} command
      */
-    handleCommand(command: {
-        commandType: number;
-        payload: any[];
-        runtimeName: number;
-    }): Command;
+    handleCommand(command: Command): Command;
     /**
      * @param {any} response
-     * @param {number} runtimeName
+     * @param {RuntimeName} runtimeName
      * @returns {Command}
      */
-    parseCommand(response: any, runtimeName: number): Command;
+    parseCommand(response: any, runtimeName: RuntimeName): Command;
 }
+/**
+ * @typedef {import('../../types.d.ts').RuntimeName} RuntimeName
+ */
 /**
  * @type {Record<number, AbstractHandler>}
  */

package/dist/types/core/handler/InvokeDelegateHandler.d.ts

@@ -1,3 +1,7 @@
+export type Command = import("../../utils/Command.js").Command;
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
 /**
  * Handles invoking a delegate by GUID.
  */

package/dist/types/core/handler/InvokeGlobalFunctionHandler.d.ts

@@ -1,5 +1,12 @@
+export type Command = import("../../utils/Command.js").Command;
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
 export class InvokeGlobalFunctionHandler extends AbstractHandler {
     requiredParametersCount: number;
-    process(command: any): any;
+    /**
+     * @param {Command} command
+     */
+    process(command: Command): any;
 }
 import { AbstractHandler } from './AbstractHandler.js';

package/dist/types/core/handler/InvokeInstanceMethodHandler.d.ts

@@ -1,5 +1,12 @@
+export type Command = import("../../utils/Command.js").Command;
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
 export class InvokeInstanceMethodHandler extends AbstractHandler {
     requiredParametersCount: number;
-    process(command: any): any;
+    /**
+     * @param {Command} command
+     */
+    process(command: Command): any;
 }
 import { AbstractHandler } from './AbstractHandler.js';

package/dist/types/core/handler/InvokeStaticMethodHandler.d.ts

@@ -1,5 +1,12 @@
+export type Command = import("../../utils/Command.js").Command;
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
 export class InvokeStaticMethodHandler extends AbstractHandler {
     requiredParametersCount: number;
-    process(command: any): any;
+    /**
+     * @param {Command} command
+     */
+    process(command: Command): any;
 }
 import { AbstractHandler } from './AbstractHandler.js';